"""信号相关 API 路由""" import json from typing import List, Optional from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, Query from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.future import select from ..database import get_db from ..dependencies.tenant import get_tenant_id from ..models import Signal, SignalFeedback, Project, ProjectSignalLink from ..schemas import ( SignalCreate, SignalPriority, classify_signal_priority, SignalFeedbackCreate, SignalFeedbackResponse, ) from ..services.fetcher import fetch_hn_stories from ..services.analyzer import analyze_impact from ..services.llm import llm_service from ..services.plane import plane_service from ..services.lark import LarkService router = APIRouter(prefix="/signals", tags=["signals"]) lark_service = LarkService() @router.get("/") async def list_signals( roles: Optional[str] = Query(None, description="逗号分隔的角色列表，如 'frontend,backend'"), db: AsyncSession = Depends(get_db), ): """获取信号列表，支持按角色过滤""" result = await db.execute(select(Signal).order_by(Signal.impact_score.desc())) signals = result.scalars().all() if roles: role_list = [r.strip() for r in roles.split(",")] filtered_signals = [] for signal in signals: tasks = [] if signal.tasks_generated: try: tasks = json.loads(signal.tasks_generated) except Exception: tasks = [] filtered_tasks = [t for t in tasks if t.get("type") in role_list] if filtered_tasks: signal_dict = { "id": str(signal.id), "source": signal.source, "content": signal.content, "impact_score": signal.impact_score, "priority": signal.priority, "processed": signal.processed, "strategic_analysis": signal.strategic_analysis, "tasks_generated": signal.tasks_generated, "tasks_filtered": filtered_tasks, "created_at": signal.created_at.isoformat() if signal.created_at else None, } filtered_signals.append(signal_dict) return filtered_signals return signals @router.post("/", response_model=dict) async def create_signal(signal: SignalCreate, db: AsyncSession = Depends(get_db)): new_signal = Signal( source=signal.source, content=signal.content, impact_score=signal.impact_score, ) db.add(new_signal) await db.commit() await db.refresh(new_signal) return {"id": str(new_signal.id), "status": "received"} @router.post("/ingest", response_model=dict) async def ingest_signal( signal: SignalCreate, background_tasks: BackgroundTasks, db: AsyncSession = Depends(get_db), tenant_id: int = Depends(get_tenant_id), ): """接入外部信号，按优先级处理""" initial_priority = signal.priority or classify_signal_priority(signal.impact_score) new_signal = Signal( source=signal.source, content=signal.content, impact_score=signal.impact_score, priority=initial_priority.value, ) db.add(new_signal) await db.commit() await db.refresh(new_signal) if initial_priority == SignalPriority.LOW: return { "id": str(new_signal.id), "priority": initial_priority.value, "status": "recorded", "message": "Low priority signal recorded without processing", } async def process_signal_internal(): try: relevant_context = await llm_service.find_relevant_context( signal_content=signal.content, db_session=db, top_k=3, min_similarity=0.3, tenant_id=tenant_id, ) strategy_result = await llm_service.evaluate_with_voting_async( signal_content=signal.content, relevant_context=relevant_context, impact_score=signal.impact_score, db=db, tenant_id=tenant_id, ) except RuntimeError: if initial_priority == SignalPriority.CRITICAL: raise HTTPException(status_code=403, detail="预算超限，AI 调用被阻止（hard limit）") return { "id": str(new_signal.id), "priority": initial_priority.value, "status": "blocked", "processing_mode": "background", "message": "预算超限，AI 调用被阻止（hard limit）", } is_strategic = strategy_result.get("is_strategic", False) decision_proposal = strategy_result.get("decision_proposal", {}) tasks = strategy_result.get("tasks", []) confidence = strategy_result.get("confidence", 0.0) final_priority = classify_signal_priority(signal.impact_score, confidence) new_signal.priority = final_priority.value sync_result = None notification_sent = False if final_priority in [SignalPriority.CRITICAL, SignalPriority.HIGH]: if is_strategic and tasks: sync_result = await plane_service.sync_tasks( tasks, is_urgent=(final_priority == SignalPriority.CRITICAL) ) default_chat_id = "oc_1234567890" await lark_service.send_strategic_alert( default_chat_id, signal.content, decision_proposal, tasks ) notification_sent = True new_signal.impact_score = 1.0 analysis_data = { "decision_proposal": decision_proposal, "competitiveness_radar": strategy_result.get("competitiveness_radar"), "detected_tech_stacks": strategy_result.get("detected_tech_stacks", []), "related_knowledge_nodes": strategy_result.get("related_knowledge_nodes", []), "rag_context_used": len(relevant_context) if relevant_context else 0, "rag_context_sources": [ctx["id"] for ctx in (relevant_context or [])], } if "_voting" in strategy_result: voting_info = strategy_result["_voting"] analysis_data["voting"] = { "enabled": voting_info.get("enabled"), "models_used": voting_info.get("models_used"), "strategic_votes": voting_info.get("strategic_votes"), "total_votes": voting_info.get("total_votes"), "unanimous": voting_info.get("unanimous"), } new_signal.strategic_analysis = json.dumps(analysis_data) new_signal.tasks_generated = json.dumps(tasks) new_signal.processed = True await db.commit() await db.refresh(new_signal) return { "id": str(new_signal.id), "priority": final_priority.value, "is_strategic": is_strategic, "confidence": confidence, "decision_proposal": decision_proposal, "rag_context_used": len(relevant_context) if relevant_context else 0, "voting": strategy_result.get("_voting"), "tasks_generated": len(tasks), "sync_result": sync_result, "notification_sent": notification_sent, } if initial_priority == SignalPriority.CRITICAL: result = await process_signal_internal() result["processing_mode"] = "synchronous" return result else: background_tasks.add_task(process_signal_internal) return { "id": str(new_signal.id), "priority": initial_priority.value, "status": "queued", "processing_mode": "background", "message": f"{initial_priority.value.upper()} priority signal queued for processing", } @router.post("/fetch", response_model=dict) async def trigger_signal_fetch( background_tasks: BackgroundTasks, db: AsyncSession = Depends(get_db), tenant_id: int = Depends(get_tenant_id), ): """手动触发抓取并分析信号""" def _stop_ollama(): import subprocess import signal import os killed = False try: result = subprocess.run( ["pgrep", "-f", "ollama"], capture_output=True, text=True, ) if result.returncode == 0: for pid in result.stdout.strip().split("\n"): if pid: try: os.kill(int(pid), signal.SIGTERM) killed = True except ProcessLookupError: pass except Exception as e: print(f"[AI] pgrep failed: {e}") if not killed: try: result = subprocess.run( ["pkill", "-9", "-f", "ollama"], capture_output=True, timeout=5, ) killed = result.returncode == 0 except Exception as e: print(f"[AI] pkill failed: {e}") if killed: print("[AI] Ollama stopped - analysis complete") raw_stories = await fetch_hn_stories(limit=30) new_signals_count = 0 processed_count = 0 for story in raw_stories: result = await db.execute(select(Signal).where(Signal.content == story["content"])) if result.scalars().first(): continue impact = analyze_impact(story["content"]) if impact > 0.4: initial_priority = classify_signal_priority(impact) new_signal = Signal( source=story["source"], content=story["content"], impact_score=impact, priority=initial_priority.value, ) db.add(new_signal) await db.commit() await db.refresh(new_signal) new_signals_count += 1 if initial_priority == SignalPriority.LOW: continue async def process_fetched(): nonlocal processed_count try: relevant_context = await llm_service.find_relevant_context( signal_content=story["content"], db_session=db, top_k=3, min_similarity=0.3, tenant_id=tenant_id, ) strategy_result = await llm_service.evaluate_with_voting_async( signal_content=story["content"], relevant_context=relevant_context, impact_score=impact, db=db, tenant_id=tenant_id, ) except RuntimeError: return is_strategic = strategy_result.get("is_strategic", False) decision_proposal = strategy_result.get("decision_proposal", {}) confidence = strategy_result.get("confidence", 0.0) final_priority = classify_signal_priority(impact, confidence) new_signal.priority = final_priority.value analysis_data = { "decision_proposal": decision_proposal, "competitiveness_radar": strategy_result.get("competitiveness_radar"), "detected_tech_stacks": strategy_result.get("detected_tech_stacks", []), "related_knowledge_nodes": strategy_result.get( "related_knowledge_nodes", [] ), "rag_context_used": len(relevant_context) if relevant_context else 0, "rag_context_sources": [ctx["id"] for ctx in (relevant_context or [])], "confidence": confidence, "is_strategic": is_strategic, } if "_voting" in strategy_result: vi = strategy_result["_voting"] analysis_data["voting"] = { "enabled": vi.get("enabled"), "models_used": vi.get("models_used"), "strategic_votes": vi.get("strategic_votes"), "total_votes": vi.get("total_votes"), "unanimous": vi.get("unanimous"), } new_signal.strategic_analysis = json.dumps(analysis_data) new_signal.tasks_generated = json.dumps(strategy_result.get("tasks", [])) new_signal.processed = True await db.commit() processed_count += 1 if initial_priority in [SignalPriority.MEDIUM, SignalPriority.HIGH]: background_tasks.add_task(process_fetched) else: await process_fetched() _stop_ollama() return { "status": "success", "new_signals_count": new_signals_count, "processed_count": processed_count, "message": f"Fetched {new_signals_count} signals, {processed_count} analyzed", } @router.get("/{signal_id}/projects") async def get_signal_projects( signal_id: str, db: AsyncSession = Depends(get_db), ): """获取信号关联的项目""" try: sid = int(signal_id) except (ValueError, TypeError): raise HTTPException(status_code=400, detail="Invalid signal_id") signal_result = await db.execute(select(Signal).where(Signal.id == sid)) if not signal_result.scalar_one_or_none(): raise HTTPException(status_code=404, detail="Signal not found") result = await db.execute( select(Project, ProjectSignalLink) .join(ProjectSignalLink, Project.id == ProjectSignalLink.project_id) .where(ProjectSignalLink.signal_id == sid) ) rows = result.all() return [ { "id": str(p.id), "title": p.title, "status": p.status, "assigned_role": p.assigned_role, "link_type": link.link_type, "relevance_score": link.relevance_score, } for p, link in rows ] @router.post("/{signal_id}/feedback", response_model=SignalFeedbackResponse) async def submit_signal_feedback( signal_id: int, feedback: SignalFeedbackCreate, db: AsyncSession = Depends(get_db), ): """提交信号反馈""" result = await db.execute(select(Signal).where(Signal.id == signal_id)) signal = result.scalar_one_or_none() if not signal: raise HTTPException(status_code=404, detail="Signal not found") ai_predicted_strategic = False ai_confidence = 0.0 if signal.strategic_analysis: try: analysis = json.loads(signal.strategic_analysis) ai_predicted_strategic = analysis.get("is_strategic", signal.impact_score >= 0.9) ai_confidence = analysis.get("confidence", 0.0) except Exception: ai_predicted_strategic = signal.impact_score >= 0.9 new_feedback = SignalFeedback( signal_id=signal_id, was_strategic=feedback.was_strategic, reason=feedback.reason, user_id=feedback.user_id, ai_predicted_strategic=ai_predicted_strategic, ai_confidence=ai_confidence, ) db.add(new_feedback) await db.commit() await db.refresh(new_feedback) is_correct = ai_predicted_strategic == feedback.was_strategic return SignalFeedbackResponse( id=new_feedback.id, signal_id=new_feedback.signal_id, was_strategic=new_feedback.was_strategic, ai_predicted_strategic=new_feedback.ai_predicted_strategic, ai_confidence=new_feedback.ai_confidence, is_correct=is_correct, ) @router.get("/{signal_id}/feedbacks", response_model=List[SignalFeedbackResponse]) async def get_signal_feedbacks( signal_id: int, db: AsyncSession = Depends(get_db), ): """获取某信号的全部反馈""" result = await db.execute( select(SignalFeedback) .where(SignalFeedback.signal_id == signal_id) .order_by(SignalFeedback.created_at.desc()) ) feedbacks = result.scalars().all() return [ SignalFeedbackResponse( id=f.id, signal_id=f.signal_id, was_strategic=f.was_strategic, ai_predicted_strategic=f.ai_predicted_strategic, ai_confidence=f.ai_confidence or 0.0, is_correct=f.ai_predicted_strategic == f.was_strategic, ) for f in feedbacks ]