1500 lines
46 KiB
Python
1500 lines
46 KiB
Python
"""
|
||
AI Steward API - 主动式 AI 管家接口
|
||
|
||
核心功能：
|
||
1. 零配置项目创建
|
||
2. 主动信号捕获
|
||
3. 认知冲突检测
|
||
4. 阻塞自动解决
|
||
5. 个性化进度简报
|
||
"""
|
||
from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
|
||
from sqlalchemy import and_, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from pydantic import BaseModel, Field
|
||
from typing import List, Optional, Dict, Any, Literal
|
||
from datetime import datetime, timezone, timedelta
|
||
import json
|
||
|
||
from ..core.response import success_response
|
||
from ..database import get_db
|
||
from ..dependencies.auth import get_current_user
|
||
from ..dependencies.permissions import require_manager_user
|
||
from ..dependencies.tenant import get_tenant_id
|
||
from ..models import ProjectSignalLink, Signal, User
|
||
from ..services.ai_steward import get_ai_steward_service, AIStewardService
|
||
from ..services.signal_capture import ProactiveSignalCaptureService
|
||
from ..services.cognitive_conflict import get_cognitive_conflict_service
|
||
from ..services.blocker_detection import get_blocker_detection_service
|
||
from ..services.daily_briefing import get_daily_briefing_service
|
||
from ..services.event_workflow import get_event_workflow_engine, WorkflowEventType
|
||
from ..services.adaptive_rag_service import AdaptiveRAGService
|
||
from ..services.ai_orchestration_run_service import AIOrchestrationRunService
|
||
from ..services.feishu_outbox_service import FeishuOutboxService
|
||
from ..services.openclaw_commander_service import OpenClawCommanderService
|
||
from ..services.signal_source_orchestration_service import SignalSourceOrchestrationService
|
||
from ..services.signal_source_repair_service import (
|
||
SignalSourceRepairMissingSignalError,
|
||
SignalSourceRepairService,
|
||
SignalSourceRepairTimeoutError,
|
||
)
|
||
from ..schemas.rag import RAGAskRequest
|
||
from ..utils.audited_write import audited_write
|
||
|
||
|
||
from ..utils.timezone import now_cn_aware, now_cn_naive
|
||
router = APIRouter(prefix="/ai-steward", tags=["AI Steward"])
|
||
|
||
|
||
def _utc_now_naive() -> datetime:
|
||
return now_cn_naive()
|
||
|
||
|
||
async def _ensure_project_signal_link(
|
||
db: AsyncSession,
|
||
*,
|
||
tenant_id: int,
|
||
project_id: int,
|
||
signal_id: int,
|
||
link_type: str = "related",
|
||
) -> None:
|
||
existing = (
|
||
await db.execute(
|
||
select(ProjectSignalLink.id).where(
|
||
and_(
|
||
ProjectSignalLink.tenant_id == int(tenant_id),
|
||
ProjectSignalLink.project_id == int(project_id),
|
||
ProjectSignalLink.signal_id == int(signal_id),
|
||
)
|
||
).limit(1)
|
||
)
|
||
).scalar_one_or_none()
|
||
if existing is not None:
|
||
return
|
||
db.add(
|
||
ProjectSignalLink(
|
||
tenant_id=int(tenant_id),
|
||
project_id=int(project_id),
|
||
signal_id=int(signal_id),
|
||
link_type=link_type,
|
||
relevance_score=1.0,
|
||
)
|
||
)
|
||
|
||
|
||
# ==================== Request/Response Models ====================
|
||
|
||
class ProjectFromTextRequest(BaseModel):
|
||
"""零配置项目创建请求"""
|
||
input_text: str = Field(
|
||
...,
|
||
description="自然语言项目描述，例如：我们要做一个 AI 客服工具，基于 GPT-4o mini，对标 XX 竞品，3 周上线",
|
||
min_length=10,
|
||
max_length=500
|
||
)
|
||
|
||
|
||
class ProjectFromTextResponse(BaseModel):
|
||
"""零配置项目创建响应"""
|
||
project: Dict[str, Any]
|
||
signal: Dict[str, Any]
|
||
charter: Dict[str, Any]
|
||
tasks: List[Dict[str, Any]]
|
||
risks: List[Dict[str, Any]]
|
||
analysis: Dict[str, Any]
|
||
|
||
|
||
class CognitiveConflictResponse(BaseModel):
|
||
"""认知冲突响应"""
|
||
id: str
|
||
type: str
|
||
description: str
|
||
severity: str
|
||
resolution_suggestion: Optional[str] = None
|
||
related_users: List[str]
|
||
|
||
|
||
class DailyBriefingResponse(BaseModel):
|
||
"""每日简报响应"""
|
||
date: str
|
||
total_updates: int
|
||
your_updates: int
|
||
relevant_changes: List[Dict[str, Any]]
|
||
risk_alerts: List[Dict[str, Any]]
|
||
alignment_needed: List[Dict[str, Any]]
|
||
|
||
|
||
class FeishuCaptureRequest(BaseModel):
|
||
"""飞书信号捕获请求"""
|
||
group_chat_id: str
|
||
message_content: str
|
||
sender: str
|
||
feishu_message_id: Optional[str] = None
|
||
|
||
|
||
class BrowserCaptureRequest(BaseModel):
|
||
"""浏览器信号捕获请求"""
|
||
user_id: int
|
||
url: str
|
||
title: str
|
||
content_preview: str
|
||
|
||
|
||
class GitHubCaptureRequest(BaseModel):
|
||
"""GitHub信号捕获请求"""
|
||
repo_url: str
|
||
event_type: str
|
||
event_data: Dict[str, Any]
|
||
|
||
|
||
class ConflictDetectRequest(BaseModel):
|
||
"""认知冲突检测请求"""
|
||
project_id: int
|
||
detect_type: str = "all" # all, charter, definition
|
||
|
||
|
||
class OpenClawCommandDispatchRequest(BaseModel):
|
||
"""OpenClaw 指挥层任务分配请求"""
|
||
project_id: int = Field(..., ge=1)
|
||
instruction: str = Field(..., min_length=4, max_length=2000)
|
||
dry_run: bool = False
|
||
max_operations: int = Field(default=8, ge=1, le=20)
|
||
response_mode: Literal["fast", "complete"] = "fast"
|
||
|
||
|
||
class SignalSourceOnboardRequest(BaseModel):
|
||
project_id: int = Field(..., ge=1)
|
||
instruction: str = Field(..., min_length=6, max_length=2000)
|
||
dry_run: bool = False
|
||
response_mode: Literal["fast", "complete"] = "fast"
|
||
|
||
|
||
class SignalSourceListResponse(BaseModel):
|
||
items: List[Dict[str, Any]]
|
||
|
||
|
||
class SignalSourceRepairRequest(BaseModel):
|
||
project_id: int = Field(..., ge=1)
|
||
registry_ids: List[int] = Field(default_factory=list, min_length=1, max_length=50)
|
||
sender: str = Field(default="PMFlow修复器", min_length=1, max_length=64)
|
||
|
||
|
||
def _parse_related_users(raw_value: Any) -> List[str]:
|
||
"""兼容 involved_user_ids 的 list / json-string / 单值字符串。"""
|
||
if raw_value is None:
|
||
return []
|
||
if isinstance(raw_value, list):
|
||
return [str(item) for item in raw_value if item is not None]
|
||
if isinstance(raw_value, (bytes, bytearray)):
|
||
raw_value = raw_value.decode("utf-8", errors="ignore")
|
||
if isinstance(raw_value, str):
|
||
text = raw_value.strip()
|
||
if not text:
|
||
return []
|
||
try:
|
||
parsed = json.loads(text)
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
if "," in text:
|
||
return [v.strip() for v in text.split(",") if v.strip()]
|
||
return [text]
|
||
if isinstance(parsed, list):
|
||
return [str(item) for item in parsed if item is not None]
|
||
if parsed is None:
|
||
return []
|
||
return [str(parsed)]
|
||
return [str(raw_value)]
|
||
|
||
|
||
# ==================== Zero-Config Project Creation ====================
|
||
|
||
@router.post("/rag/ask")
|
||
async def ask_ai_steward_rag(
|
||
request: RAGAskRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
service = AdaptiveRAGService(db, tenant_id=effective_tenant_id)
|
||
result = await service.answer_question(
|
||
question=request.question,
|
||
asked_by=int(current_user.id),
|
||
asked_via="pmflow",
|
||
project_id=request.project_id,
|
||
source_chat_id=request.source_chat_id,
|
||
session_id=request.session_id,
|
||
force_new_session=bool(request.new_session),
|
||
thinking_mode=request.thinking_mode,
|
||
action_mode=request.action_mode,
|
||
sync_requirement=bool(request.sync_requirement),
|
||
)
|
||
return success_response(result)
|
||
|
||
|
||
@router.post("/command/dispatch")
|
||
@audited_write(caller="user")
|
||
async def dispatch_openclaw_command(
|
||
request: OpenClawCommandDispatchRequest,
|
||
current_user: User = Depends(require_manager_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
service = OpenClawCommanderService(db)
|
||
try:
|
||
result = await service.dispatch_command(
|
||
tenant_id=effective_tenant_id,
|
||
operator_user=current_user,
|
||
project_id=request.project_id,
|
||
instruction=request.instruction,
|
||
dry_run=request.dry_run,
|
||
max_operations=request.max_operations,
|
||
response_mode=request.response_mode,
|
||
)
|
||
except ValueError as exc:
|
||
detail = str(exc)
|
||
if detail == "project not found":
|
||
raise HTTPException(status_code=404, detail=detail) from exc
|
||
raise HTTPException(status_code=400, detail=detail) from exc
|
||
return success_response(result)
|
||
|
||
|
||
@router.post("/signal-sources/onboard")
|
||
@audited_write(caller="user")
|
||
async def onboard_signal_source(
|
||
request: SignalSourceOnboardRequest,
|
||
current_user: User = Depends(require_manager_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
signal = Signal(
|
||
tenant_id=effective_tenant_id,
|
||
source="PMFlow",
|
||
content=f"[PMFlow用户#{int(current_user.id)}]: {request.instruction[:1800]}",
|
||
impact_score=0.7,
|
||
priority="medium",
|
||
processed=False,
|
||
strategic_analysis=json.dumps(
|
||
{
|
||
"source": "pmflow_manual_signal_source_onboard",
|
||
"instruction": request.instruction[:2000],
|
||
"created_at": now_cn_aware().isoformat(),
|
||
},
|
||
ensure_ascii=False,
|
||
),
|
||
tasks_generated=json.dumps([], ensure_ascii=False),
|
||
matched_project_id=int(request.project_id),
|
||
title=(request.instruction[:80] or "新增信号源"),
|
||
signal_type="新需求",
|
||
summary=request.instruction[:300],
|
||
reasoning=json.dumps(["来自 AI Steward 手动信号源接入请求。"], ensure_ascii=False),
|
||
confidence=0.82,
|
||
recommended_action="enter_only",
|
||
status="待处理",
|
||
)
|
||
if not request.dry_run:
|
||
db.add(signal)
|
||
await db.flush()
|
||
await _ensure_project_signal_link(
|
||
db,
|
||
tenant_id=effective_tenant_id,
|
||
project_id=int(request.project_id),
|
||
signal_id=int(signal.id),
|
||
)
|
||
await db.commit()
|
||
await db.refresh(signal)
|
||
signal_id_value = int(signal.id) if not request.dry_run and getattr(signal, "id", None) is not None else None
|
||
|
||
service = SignalSourceOrchestrationService(db)
|
||
result = await service.orchestrate_from_signal(
|
||
tenant_id=effective_tenant_id,
|
||
project_id=int(request.project_id),
|
||
signal_id=signal_id_value,
|
||
initiating_text=request.instruction,
|
||
requested_via="pmflow",
|
||
operator_user_id=int(current_user.id),
|
||
dry_run=bool(request.dry_run),
|
||
response_mode=request.response_mode,
|
||
)
|
||
return success_response(
|
||
{
|
||
"signal_id": signal_id_value,
|
||
**result,
|
||
}
|
||
)
|
||
|
||
|
||
@router.get("/orchestration-runs/{trace_id}")
|
||
async def get_orchestration_run(
|
||
trace_id: str,
|
||
current_user: User = Depends(require_manager_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
row = await AIOrchestrationRunService(db).get_run(
|
||
tenant_id=effective_tenant_id,
|
||
trace_id=str(trace_id or "").strip(),
|
||
)
|
||
if row is None:
|
||
raise HTTPException(status_code=404, detail="orchestration run not found")
|
||
return success_response(AIOrchestrationRunService.serialize_run(row))
|
||
|
||
|
||
@router.get("/projects/{project_id}/signal-sources")
|
||
async def list_project_signal_sources(
|
||
project_id: int,
|
||
current_user: User = Depends(require_manager_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
items = await SignalSourceOrchestrationService(db).list_project_sources(
|
||
tenant_id=effective_tenant_id,
|
||
project_id=int(project_id),
|
||
)
|
||
return success_response(SignalSourceListResponse(items=items).model_dump())
|
||
|
||
|
||
@router.post("/signal-sources/repair-dirty")
|
||
@audited_write(caller="system")
|
||
async def repair_dirty_signal_sources(
|
||
request: SignalSourceRepairRequest,
|
||
current_user: User = Depends(require_manager_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
):
|
||
effective_tenant_id = int(getattr(current_user, "tenant_id", tenant_id) or tenant_id)
|
||
try:
|
||
rows = await SignalSourceRepairService(db).repair_registries(
|
||
tenant_id=effective_tenant_id,
|
||
project_id=int(request.project_id),
|
||
registry_ids=[int(item) for item in request.registry_ids],
|
||
sender=str(request.sender or "PMFlow修复器").strip()[:64] or "PMFlow修复器",
|
||
)
|
||
except SignalSourceRepairTimeoutError as exc:
|
||
raise HTTPException(status_code=504, detail=str(exc)) from exc
|
||
except SignalSourceRepairMissingSignalError as exc:
|
||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||
return success_response(
|
||
{
|
||
"project_id": int(request.project_id),
|
||
"items": rows,
|
||
}
|
||
)
|
||
|
||
@router.post("/project-from-text", response_model=ProjectFromTextResponse)
|
||
async def create_project_from_text(
|
||
request: ProjectFromTextRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
零配置项目创建 - 从一句话生成完整项目
|
||
|
||
示例输入：
|
||
```
|
||
我们要做一个 AI 客服工具，基于 GPT-4o mini，对标 XX 竞品，3 周上线
|
||
```
|
||
|
||
AI 将自动生成：
|
||
- 完整的项目配置
|
||
- 竞品分析信号
|
||
- 项目宪章
|
||
- 任务链（含依赖关系）
|
||
- 风险预警规则
|
||
"""
|
||
try:
|
||
service = get_ai_steward_service(db)
|
||
|
||
result = await service.create_project_from_natural_language(
|
||
input_text=request.input_text,
|
||
creator_id=int(current_user.id),
|
||
tenant_id=tenant_id
|
||
)
|
||
|
||
return ProjectFromTextResponse(**result)
|
||
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"项目创建失败: {str(e)}"
|
||
)
|
||
|
||
|
||
# ==================== Signal Capture Endpoints ====================
|
||
|
||
@router.post("/signal/capture-feishu")
|
||
@audited_write(caller="ai")
|
||
async def capture_feishu_signal(
|
||
request: FeishuCaptureRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
从飞书群聊捕获信号
|
||
|
||
AI 会自动判断消息是否包含有价值的项目或技术信息，
|
||
如果是，则创建信号并自动关联到相关项目
|
||
"""
|
||
try:
|
||
service = ProactiveSignalCaptureService(db)
|
||
result = await service.capture_from_feishu(
|
||
group_chat_id=request.group_chat_id,
|
||
message_content=request.message_content,
|
||
sender=request.sender,
|
||
tenant_id=tenant_id,
|
||
feishu_message_id=request.feishu_message_id,
|
||
)
|
||
response_payload = dict(result) if isinstance(result, dict) else {"result": result}
|
||
|
||
should_enqueue_reply = bool(response_payload.get("direct_reply_required"))
|
||
reply_text = str(response_payload.get("direct_reply_text") or "").strip() or "已收到，正在处理。"
|
||
source_message_id = (str(request.feishu_message_id or "").strip()[:128] or None)
|
||
normalized_chat_id = str(request.group_chat_id or "").strip()
|
||
if should_enqueue_reply and normalized_chat_id:
|
||
try:
|
||
outbox_id = await FeishuOutboxService.enqueue(
|
||
db,
|
||
tenant_id=int(tenant_id),
|
||
chat_id=normalized_chat_id,
|
||
text=reply_text,
|
||
source_message_id=source_message_id,
|
||
dedupe_seed=f"capture-feishu:{normalized_chat_id}:{str(request.sender or '').strip()[:64]}",
|
||
trace_id=str(response_payload.get("ai_trace_id") or "").strip()[:64] or None,
|
||
)
|
||
await db.commit()
|
||
response_payload["reply_outbox_enqueued"] = bool(outbox_id)
|
||
response_payload["reply_outbox_id"] = int(outbox_id) if outbox_id else None
|
||
except Exception as outbox_exc:
|
||
await db.rollback()
|
||
response_payload["reply_outbox_enqueued"] = False
|
||
response_payload["reply_outbox_error"] = str(outbox_exc)[:200]
|
||
return response_payload
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"飞书信号捕获失败: {str(e)}")
|
||
|
||
|
||
@router.post("/signal/capture-browser")
|
||
async def capture_browser_signal(
|
||
request: BrowserCaptureRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
从浏览器标签页捕获信号
|
||
|
||
监控用户访问的技术文档、竞品页面、GitHub issues等
|
||
"""
|
||
try:
|
||
service = ProactiveSignalCaptureService(db)
|
||
result = await service.capture_from_browser(
|
||
user_id=request.user_id,
|
||
url=request.url,
|
||
title=request.title,
|
||
content_preview=request.content_preview,
|
||
tenant_id=tenant_id
|
||
)
|
||
return result
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"浏览器信号捕获失败: {str(e)}")
|
||
|
||
|
||
@router.post("/signal/capture-github")
|
||
async def capture_github_signal(
|
||
request: GitHubCaptureRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
从GitHub事件捕获信号
|
||
|
||
监控竞品仓库更新、上游依赖更新等
|
||
"""
|
||
try:
|
||
service = ProactiveSignalCaptureService(db)
|
||
result = await service.capture_from_github(
|
||
repo_url=request.repo_url,
|
||
event_type=request.event_type,
|
||
event_data=request.event_data,
|
||
tenant_id=tenant_id
|
||
)
|
||
return result
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"GitHub信号捕获失败: {str(e)}")
|
||
|
||
|
||
@router.post("/signal/start-hn-monitor")
|
||
async def start_hn_monitor(
|
||
background_tasks: BackgroundTasks,
|
||
interval_minutes: int = 30,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
启动 HackerNews 定时监控（后台任务）
|
||
|
||
定期抓取 HackerNews 首页，分析技术趋势
|
||
"""
|
||
async def run_monitor():
|
||
service = ProactiveSignalCaptureService(db)
|
||
await service.start_hackernews_monitor(interval_minutes=interval_minutes, tenant_id=tenant_id)
|
||
|
||
background_tasks.add_task(run_monitor)
|
||
return {
|
||
"status": "started",
|
||
"message": f"HackerNews 监控已启动，间隔: {interval_minutes} 分钟"
|
||
}
|
||
|
||
|
||
# ==================== Cognitive Conflict Endpoints ====================
|
||
|
||
@router.get("/cognitive-conflicts", response_model=List[CognitiveConflictResponse])
|
||
async def get_cognitive_conflicts(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id),
|
||
project_id: Optional[int] = None
|
||
):
|
||
"""
|
||
获取认知冲突列表
|
||
|
||
AI 会自动识别团队中的隐性认知差异，例如：
|
||
- 产品说"用户留存提升10%"，开发实现的是"DAU提升10%"
|
||
- 双方没有争论，但目标不一致，AI 会主动识别并推送对齐提醒
|
||
"""
|
||
from ..models import CognitiveConflict, TruthNode
|
||
from sqlalchemy.future import select
|
||
|
||
query = select(CognitiveConflict).where(
|
||
CognitiveConflict.tenant_id == tenant_id,
|
||
CognitiveConflict.status == 'active'
|
||
)
|
||
|
||
if project_id:
|
||
# 通过 truth_node 关联到项目
|
||
query = query.join(
|
||
TruthNode, CognitiveConflict.truth_node_id == TruthNode.id
|
||
).where(
|
||
TruthNode.project_id == project_id
|
||
)
|
||
|
||
result = await db.execute(query)
|
||
conflicts = result.scalars().all()
|
||
|
||
return [
|
||
CognitiveConflictResponse(
|
||
id=str(c.id),
|
||
type=c.conflict_type,
|
||
description=c.description,
|
||
severity="high" if "critical" in (c.description or "").lower() else "medium",
|
||
related_users=_parse_related_users(c.involved_user_ids),
|
||
)
|
||
for c in conflicts
|
||
]
|
||
|
||
|
||
@router.post("/conflicts/detect")
|
||
async def detect_conflicts(
|
||
request: ConflictDetectRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
检测项目中的认知冲突
|
||
|
||
支持检测类型：
|
||
- all: 全部检测（宪章冲突 + 定义冲突）
|
||
- charter: 仅检测宪章中的潜在冲突
|
||
- definition: 仅检测用户定义冲突
|
||
"""
|
||
try:
|
||
service = get_cognitive_conflict_service(db)
|
||
|
||
detected_conflicts = []
|
||
|
||
if request.detect_type in ["all", "charter"]:
|
||
charter_conflicts = await service.detect_charter_conflicts(
|
||
project_id=request.project_id,
|
||
tenant_id=tenant_id
|
||
)
|
||
detected_conflicts.extend(charter_conflicts)
|
||
|
||
if request.detect_type in ["all", "definition"]:
|
||
definition_conflicts = await service.detect_user_definition_conflicts(
|
||
project_id=request.project_id,
|
||
tenant_id=tenant_id
|
||
)
|
||
detected_conflicts.extend(definition_conflicts)
|
||
|
||
return {
|
||
"project_id": request.project_id,
|
||
"detected_count": len(detected_conflicts),
|
||
"conflicts": detected_conflicts
|
||
}
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"冲突检测失败: {str(e)}")
|
||
|
||
|
||
@router.post("/conflicts/{conflict_id}/propose-resolution")
|
||
async def propose_conflict_resolution(
|
||
conflict_id: int,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
AI 生成认知冲突解决方案
|
||
|
||
为冲突双方生成对齐方案：
|
||
1. 分析冲突根因
|
||
2. 提出妥协方案
|
||
3. 生成可执行的对齐计划
|
||
"""
|
||
try:
|
||
service = get_cognitive_conflict_service(db)
|
||
resolution = await service.propose_alignment_resolution(
|
||
conflict_id=conflict_id,
|
||
tenant_id=tenant_id
|
||
)
|
||
return resolution
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=404, detail=str(e))
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"方案生成失败: {str(e)}")
|
||
|
||
|
||
@router.post("/conflicts/{conflict_id}/align")
|
||
async def trigger_async_alignment(
|
||
conflict_id: int,
|
||
user1_id: int,
|
||
user2_id: int,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
触发异步 1v1 认知对齐
|
||
|
||
为冲突双方创建独立的对齐任务：
|
||
1. 发送对齐邀请
|
||
2. 提供背景信息
|
||
3. 收集双方观点
|
||
4. AI 生成共识方案
|
||
"""
|
||
try:
|
||
service = get_cognitive_conflict_service(db)
|
||
alignment = await service.trigger_async_alignment(
|
||
conflict_id=conflict_id,
|
||
user1_id=user1_id,
|
||
user2_id=user2_id,
|
||
tenant_id=tenant_id
|
||
)
|
||
return alignment
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=404, detail=str(e))
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"对齐触发失败: {str(e)}")
|
||
|
||
|
||
@router.post("/cognitive-conflicts/{conflict_id}/resolve")
|
||
async def resolve_cognitive_conflict(
|
||
conflict_id: int,
|
||
resolution_note: str,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
解决认知冲突
|
||
|
||
AI 会生成解决方案建议，双方确认后标记为已解决
|
||
"""
|
||
from ..models import CognitiveConflict
|
||
from sqlalchemy.future import select
|
||
|
||
result = await db.execute(
|
||
select(CognitiveConflict).where(
|
||
CognitiveConflict.id == conflict_id,
|
||
CognitiveConflict.tenant_id == tenant_id
|
||
)
|
||
)
|
||
conflict = result.scalar_one_or_none()
|
||
|
||
if not conflict:
|
||
raise HTTPException(status_code=404, detail="冲突记录不存在")
|
||
|
||
conflict.status = 'resolved'
|
||
conflict.resolved_at = _utc_now_naive()
|
||
conflict.description += f"\n\n解决方案（{current_user.username}）: {resolution_note}"
|
||
|
||
await db.commit()
|
||
|
||
return {"message": "冲突已标记为已解决"}
|
||
|
||
|
||
@router.get("/conflicts/task-mismatch/{task_id}")
|
||
async def check_task_charter_mismatch(
|
||
task_id: int,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
检测任务与宪章的一致性
|
||
|
||
检查：
|
||
1. 任务描述是否与宪章目标一致
|
||
2. 技术选型是否符合约束
|
||
3. 是否偏离项目方向
|
||
"""
|
||
from ..models import Task, TruthNode
|
||
from sqlalchemy.future import select
|
||
|
||
try:
|
||
# 获取任务
|
||
result = await db.execute(
|
||
select(Task).where(
|
||
Task.id == task_id,
|
||
Task.tenant_id == tenant_id
|
||
)
|
||
)
|
||
task = result.scalar_one_or_none()
|
||
|
||
if not task:
|
||
raise HTTPException(status_code=404, detail="任务不存在")
|
||
|
||
# 获取宪章
|
||
charter_result = await db.execute(
|
||
select(TruthNode).where(
|
||
TruthNode.id == task.truth_node_id,
|
||
TruthNode.tenant_id == tenant_id
|
||
)
|
||
)
|
||
charter = charter_result.scalar_one_or_none()
|
||
|
||
if not charter:
|
||
raise HTTPException(status_code=404, detail="宪章不存在")
|
||
|
||
# 检测一致性
|
||
service = get_cognitive_conflict_service(db)
|
||
mismatch = await service.detect_task_charter_mismatch(
|
||
task=task,
|
||
charter_content=charter.content,
|
||
tenant_id=tenant_id
|
||
)
|
||
|
||
if mismatch:
|
||
return {
|
||
"is_aligned": False,
|
||
"mismatch": mismatch
|
||
}
|
||
|
||
return {
|
||
"is_aligned": True,
|
||
"message": "任务与宪章一致"
|
||
}
|
||
|
||
except HTTPException:
|
||
raise
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"一致性检测失败: {str(e)}")
|
||
|
||
|
||
# ==================== Other AI Steward Endpoints ====================
|
||
|
||
@router.get("/daily-briefing")
|
||
async def get_daily_briefing(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
获取个性化每日简报
|
||
|
||
AI 为每个角色生成定制化简报，只包含：
|
||
- 与你相关的任务变更
|
||
- 风险提醒
|
||
- 需要对齐的事项
|
||
- 高影响信号
|
||
- 团队更新
|
||
|
||
彻底过滤无关信息，替代传统日报/周报
|
||
"""
|
||
try:
|
||
service = get_daily_briefing_service(db)
|
||
briefing = await service.generate_personalized_briefing(
|
||
user_id=int(current_user.id),
|
||
tenant_id=tenant_id
|
||
)
|
||
return briefing
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"生成简报失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.get("/daily-briefing/team/{project_id}")
|
||
async def get_team_briefing(
|
||
project_id: int,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
获取团队简报（给管理者）
|
||
|
||
包含：
|
||
- 整体进度
|
||
- 每个成员的工作量
|
||
- 风险和阻塞
|
||
- 需要决策的事项
|
||
"""
|
||
try:
|
||
service = get_daily_briefing_service(db)
|
||
briefing = await service.generate_team_briefing(
|
||
project_id=project_id,
|
||
tenant_id=tenant_id
|
||
)
|
||
return briefing
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=404, detail=str(e))
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"生成团队简报失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.post("/analyze-blocker")
|
||
async def analyze_blocker(
|
||
code_context: str,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
分析代码阻塞
|
||
|
||
当开发在代码注释中提到「这个接口达不到效果」时，
|
||
AI 自动触发分析，推荐替代方案或生成代码片段
|
||
"""
|
||
from ..services.llm import LLMService
|
||
|
||
service = get_ai_steward_service(db)
|
||
|
||
prompt = f"""分析以下代码/注释中提到的问题，提供解决方案：
|
||
|
||
代码上下文：
|
||
{code_context}
|
||
|
||
请提供：
|
||
1. 问题分析
|
||
2. 推荐的替代方案
|
||
3. 示例代码（如适用）
|
||
|
||
以 JSON 格式返回。"""
|
||
|
||
try:
|
||
llm = LLMService()
|
||
response = await llm.generate(
|
||
prompt,
|
||
db=db,
|
||
tenant_id=tenant_id,
|
||
)
|
||
|
||
return {
|
||
'analysis': response,
|
||
'suggestions': [],
|
||
'auto_generated': True
|
||
}
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"分析失败: {str(e)}"
|
||
)
|
||
|
||
|
||
# ==================== Blocker Detection Endpoints ====================
|
||
|
||
class CodeCommentScanRequest(BaseModel):
|
||
"""代码注释扫描请求"""
|
||
code_content: str
|
||
file_path: str
|
||
line_number: int
|
||
project_id: int
|
||
|
||
|
||
class BlockerResolveRequest(BaseModel):
|
||
"""阻塞解决请求"""
|
||
blocker_id: int
|
||
resolution_note: str
|
||
|
||
|
||
@router.post("/blockers/scan-comment")
|
||
async def scan_code_comment_for_blockers(
|
||
request: CodeCommentScanRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
扫描代码注释，检测阻塞
|
||
|
||
自动识别阻塞模式：
|
||
- "等待 X 接口完成"
|
||
- "这个 API 达不到效果"
|
||
- "由于 Y 的限制，暂时跳过"
|
||
|
||
如果检测到阻塞，AI 会自动：
|
||
1. 分析严重程度
|
||
2. 生成解决方案建议
|
||
3. 创建追踪任务（如需要）
|
||
"""
|
||
try:
|
||
service = get_blocker_detection_service(db)
|
||
result = await service.scan_code_comment(
|
||
code_content=request.code_content,
|
||
file_path=request.file_path,
|
||
line_number=request.line_number,
|
||
project_id=request.project_id,
|
||
user_id=int(current_user.id),
|
||
tenant_id=tenant_id
|
||
)
|
||
|
||
if result:
|
||
return {
|
||
'status': 'blocker_detected',
|
||
'blocker': result
|
||
}
|
||
|
||
return {
|
||
'status': 'no_blocker',
|
||
'message': '未检测到阻塞'
|
||
}
|
||
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"扫描失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.post("/blockers/detect-tasks")
|
||
async def detect_task_blockers(
|
||
background_tasks: BackgroundTasks,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
检测所有任务中的阻塞
|
||
|
||
扫描所有超过3天未更新的进行中任务，
|
||
使用 AI 判断是否存在阻塞
|
||
"""
|
||
try:
|
||
service = get_blocker_detection_service(db)
|
||
blockers = await service.detect_task_blockers(tenant_id=tenant_id)
|
||
|
||
return {
|
||
'total_detected': len(blockers),
|
||
'blockers': blockers
|
||
}
|
||
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"检测失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.get("/blockers/active")
|
||
async def get_active_blockers(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
获取所有活跃的阻塞
|
||
|
||
返回所有未解决的阻塞，按严重程度排序
|
||
"""
|
||
try:
|
||
service = get_blocker_detection_service(db)
|
||
blockers = await service.get_active_blockers(tenant_id=tenant_id)
|
||
|
||
# 按严重程度排序
|
||
severity_order = {'high': 0, 'medium': 1, 'low': 2}
|
||
blockers.sort(key=lambda b: severity_order.get(b['severity'], 1))
|
||
|
||
return {
|
||
'total': len(blockers),
|
||
'blockers': blockers
|
||
}
|
||
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"获取失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.post("/blockers/resolve")
|
||
async def resolve_blocker(
|
||
request: BlockerResolveRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
标记阻塞为已解决
|
||
|
||
记录解决方案并关闭阻塞记录
|
||
"""
|
||
try:
|
||
service = get_blocker_detection_service(db)
|
||
result = await service.resolve_blocker(
|
||
blocker_id=request.blocker_id,
|
||
resolution_note=request.resolution_note,
|
||
tenant_id=tenant_id
|
||
)
|
||
|
||
return result
|
||
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=404, detail=str(e))
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"解决失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.get("/stats")
|
||
async def get_ai_steward_stats(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
获取 AI Steward 统计数据
|
||
|
||
展示 AI 为团队节省的工作量：
|
||
- 自动捕获的信号数
|
||
- 避免的认知冲突数
|
||
- 自动解决的阻塞数
|
||
- 节省的会议时间（小时）
|
||
"""
|
||
from ..models import Signal, CognitiveConflict
|
||
from sqlalchemy import func, text
|
||
|
||
# 统计信号数量
|
||
week_ago = _utc_now_naive() - timedelta(days=7)
|
||
month_ago = _utc_now_naive() - timedelta(days=30)
|
||
|
||
signal_result = await db.execute(
|
||
select(func.count(Signal.id)).where(
|
||
Signal.tenant_id == tenant_id,
|
||
Signal.created_at >= week_ago
|
||
)
|
||
)
|
||
signals_captured = signal_result.scalar() or 0
|
||
|
||
# 统计高影响信号
|
||
high_impact_result = await db.execute(
|
||
select(func.count(Signal.id)).where(
|
||
Signal.tenant_id == tenant_id,
|
||
Signal.impact_score >= 0.8,
|
||
Signal.created_at >= week_ago
|
||
)
|
||
)
|
||
high_impact_count = high_impact_result.scalar() or 0
|
||
|
||
# 统计认知冲突
|
||
conflict_result = await db.execute(
|
||
select(func.count(CognitiveConflict.id)).where(
|
||
CognitiveConflict.tenant_id == tenant_id,
|
||
CognitiveConflict.status.in_(['detected', 'active'])
|
||
)
|
||
)
|
||
active_conflicts = conflict_result.scalar() or 0
|
||
|
||
# 统计已解决的冲突
|
||
resolved_conflict_result = await db.execute(
|
||
select(func.count(CognitiveConflict.id)).where(
|
||
CognitiveConflict.tenant_id == tenant_id,
|
||
CognitiveConflict.status == 'resolved',
|
||
CognitiveConflict.resolved_at >= month_ago
|
||
)
|
||
)
|
||
conflicts_resolved = resolved_conflict_result.scalar() or 0
|
||
|
||
# 统计阻塞
|
||
blocker_result = await db.execute(
|
||
text("""
|
||
SELECT COUNT(*) FROM cognitive_conflicts
|
||
WHERE tenant_id = :tenant_id
|
||
AND conflict_type IN ('code_blocker', 'task_blocker')
|
||
AND status = 'detected'
|
||
"""),
|
||
{"tenant_id": tenant_id}
|
||
)
|
||
active_blockers = blocker_result.scalar() or 0
|
||
|
||
# 活跃项目数
|
||
from ..models import Project
|
||
project_result = await db.execute(
|
||
select(func.count(Project.id)).where(
|
||
Project.tenant_id == tenant_id,
|
||
Project.status == 'active'
|
||
)
|
||
)
|
||
active_projects = project_result.scalar() or 0
|
||
|
||
# 估算节省时间（每个冲突/阻塞避免约2小时会议）
|
||
hours_saved = conflicts_resolved * 2
|
||
|
||
stats = {
|
||
'signals_captured': signals_captured,
|
||
'high_impact_signals': high_impact_count,
|
||
'active_conflicts': active_conflicts,
|
||
'conflicts_resolved': conflicts_resolved,
|
||
'active_blockers': active_blockers,
|
||
'active_projects': active_projects,
|
||
'hours_saved': hours_saved,
|
||
'last_updated': now_cn_aware().isoformat()
|
||
}
|
||
|
||
return stats
|
||
|
||
|
||
@router.post("/sync-signal")
|
||
async def sync_external_signal(
|
||
source: str,
|
||
content: str,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
手动同步外部信号
|
||
|
||
支持从以下来源同步：
|
||
- 飞书群聊
|
||
- GitHub commits/PRs
|
||
- 浏览器标签页
|
||
"""
|
||
from ..models import Signal
|
||
from ..services.ai_steward import get_ai_steward_service
|
||
|
||
service = get_ai_steward_service(db)
|
||
|
||
# AI 分析信号重要性
|
||
prompt = f"""分析以下信号的重要性：
|
||
|
||
来源：{source}
|
||
内容：{content}
|
||
|
||
请评估：
|
||
1. impact_score (0-1)
|
||
2. priority (low/medium/high/critical)
|
||
3. 是否需要立即行动
|
||
|
||
以 JSON 格式返回。"""
|
||
|
||
try:
|
||
from ..services.llm import LLMService
|
||
llm = LLMService()
|
||
response = await llm.generate(
|
||
prompt,
|
||
db=db,
|
||
tenant_id=tenant_id,
|
||
)
|
||
|
||
# 创建信号
|
||
signal = Signal(
|
||
source=source,
|
||
content=content,
|
||
impact_score=0.7,
|
||
priority='medium',
|
||
processed=False,
|
||
tenant_id=tenant_id
|
||
)
|
||
db.add(signal)
|
||
await db.commit()
|
||
|
||
return {
|
||
'signal_id': str(signal.id),
|
||
'analysis': response,
|
||
'status': 'captured'
|
||
}
|
||
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"信号同步失败: {str(e)}"
|
||
)
|
||
|
||
|
||
# ==================== Event-Driven Workflow Endpoints ====================
|
||
|
||
class WorkflowTriggerRequest(BaseModel):
|
||
"""工作流触发请求"""
|
||
event_type: str
|
||
event_data: Dict[str, Any]
|
||
|
||
|
||
@router.post("/workflow/trigger")
|
||
async def trigger_workflow(
|
||
request: WorkflowTriggerRequest,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
触发事件驱动工作流
|
||
|
||
支持的事件类型：
|
||
- high_impact_signal: 高影响信号到达
|
||
- blocker_detected: 阻塞检测
|
||
- cognitive_conflict: 认知冲突
|
||
- tech_stack_change: 技术栈变更
|
||
- competitor_update: 竞品动态
|
||
- task_completed: 任务完成
|
||
- task_blocked: 任务阻塞
|
||
- project_risk: 项目风险
|
||
|
||
工作流会自动：
|
||
1. 调整项目优先级
|
||
2. 创建响应任务
|
||
3. 通知相关角色
|
||
4. 更新依赖关系
|
||
"""
|
||
try:
|
||
engine = get_event_workflow_engine(db)
|
||
result = await engine.trigger_workflow(
|
||
event_type=request.event_type,
|
||
event_data=request.event_data,
|
||
tenant_id=tenant_id
|
||
)
|
||
return result
|
||
except Exception as e:
|
||
raise HTTPException(
|
||
status_code=500,
|
||
detail=f"工作流触发失败: {str(e)}"
|
||
)
|
||
|
||
|
||
@router.post("/workflow/signal/{signal_id}")
|
||
async def trigger_signal_workflow(
|
||
signal_id: int,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
当接收到高影响信号时自动触发工作流
|
||
|
||
检查信号的 impact_score，如果超过阈值（0.85），
|
||
自动触发工作流来调整相关项目的优先级
|
||
"""
|
||
from ..models import Signal
|
||
from sqlalchemy.future import select
|
||
|
||
signal_result = await db.execute(
|
||
select(Signal).where(
|
||
Signal.id == signal_id,
|
||
Signal.tenant_id == tenant_id
|
||
)
|
||
)
|
||
signal = signal_result.scalar_one_or_none()
|
||
|
||
if not signal:
|
||
raise HTTPException(status_code=404, detail="信号不存在")
|
||
|
||
# 检查是否达到阈值
|
||
if signal.impact_score < 0.85:
|
||
return {
|
||
'status': 'ignored',
|
||
'reason': f'信号影响分数 {signal.impact_score} 低于阈值 0.85'
|
||
}
|
||
|
||
# 触发高影响信号工作流
|
||
engine = get_event_workflow_engine(db)
|
||
result = await engine.trigger_workflow(
|
||
event_type=WorkflowEventType.HIGH_IMPACT_SIGNAL,
|
||
event_data={'signal_id': signal_id},
|
||
tenant_id=tenant_id
|
||
)
|
||
|
||
return result
|
||
|
||
|
||
@router.get("/workflow/status")
|
||
async def get_workflow_status(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
获取工作流状态
|
||
|
||
显示最近触发的工作流及其结果
|
||
"""
|
||
from ..models import AICallLog
|
||
from sqlalchemy.future import select
|
||
|
||
# 获取最近的工作流记录
|
||
# 这里简化处理，实际应该有专门的工作流记录表
|
||
return {
|
||
'active_workflows': [],
|
||
'recent_triggers': [],
|
||
'message': '工作流状态追踪'
|
||
}
|
||
|
||
|
||
@router.post("/workflow/auto-enable")
|
||
async def enable_auto_workflow(
|
||
project_id: int,
|
||
enable: bool = True,
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
启用/禁用项目的自动工作流
|
||
|
||
启用后，当以下情况发生时会自动触发工作流：
|
||
- 高影响信号到达（>0.85）
|
||
- 任务阻塞检测
|
||
- 认知冲突检测
|
||
"""
|
||
from ..models import Project
|
||
from sqlalchemy.future import select
|
||
|
||
project_result = await db.execute(
|
||
select(Project).where(
|
||
Project.id == project_id,
|
||
Project.tenant_id == tenant_id
|
||
)
|
||
)
|
||
project = project_result.scalar_one_or_none()
|
||
|
||
if not project:
|
||
raise HTTPException(status_code=404, detail="项目不存在")
|
||
|
||
# 这里应该设置项目的 auto_workflow 标志
|
||
# 由于 Project 模型可能没有这个字段，暂时返回成功
|
||
return {
|
||
'project_id': project_id,
|
||
'auto_workflow': enable,
|
||
'message': f'自动工作流已{"启用" if enable else "禁用"}'
|
||
}
|
||
|
||
|
||
# ==================== AI Config Suggestion ====================
|
||
|
||
@router.get("/config/suggest")
|
||
async def get_ai_config_suggestion(
|
||
current_user: User = Depends(get_current_user),
|
||
db: AsyncSession = Depends(get_db),
|
||
tenant_id: int = Depends(get_tenant_id)
|
||
):
|
||
"""
|
||
AI 建议配置方案
|
||
|
||
根据团队现状，智能推荐应该优先配置哪些集成源
|
||
"""
|
||
from ..models import Integration, Project, Signal
|
||
from sqlalchemy.future import select
|
||
from sqlalchemy import func
|
||
|
||
# 检查已配置的集成
|
||
configured_sources = []
|
||
|
||
# 检查飞书配置
|
||
feishu_result = await db.execute(
|
||
select(Integration).where(
|
||
Integration.tenant_id == tenant_id,
|
||
Integration.type == 'feishu',
|
||
Integration.is_active == True
|
||
)
|
||
)
|
||
if feishu_result.scalar_one_or_none():
|
||
configured_sources.append('feishu')
|
||
|
||
# 检查活跃项目数
|
||
project_result = await db.execute(
|
||
select(func.count(Project.id)).where(
|
||
Project.tenant_id == tenant_id,
|
||
Project.status == 'active'
|
||
)
|
||
)
|
||
active_projects = project_result.scalar() or 0
|
||
|
||
# 检查近期信号数量
|
||
signal_result = await db.execute(
|
||
select(func.count(Signal.id)).where(
|
||
Signal.tenant_id == tenant_id,
|
||
Signal.created_at >= (_utc_now_naive() - timedelta(days=7))
|
||
)
|
||
)
|
||
recent_signals = signal_result.scalar() or 0
|
||
|
||
# AI 分析并推荐配置
|
||
recommended = []
|
||
reasoning_parts = []
|
||
|
||
# 根据项目数量推荐
|
||
if active_projects > 0:
|
||
if 'feishu' not in configured_sources:
|
||
recommended.append('feishu')
|
||
reasoning_parts.append(f"您有 {active_projects} 个活跃项目，建议配置飞书群聊集成以自动捕获需求讨论")
|
||
|
||
# 根据信号量推荐
|
||
if recent_signals < 10:
|
||
if 'hn' not in [s.split('_')[0] for s in configured_sources]:
|
||
recommended.append('hn')
|
||
reasoning_parts.append("近期信号较少，建议启用 HackerNews 监控获取更多技术趋势")
|
||
|
||
# 默认推荐
|
||
if not recommended:
|
||
if 'feishu' not in configured_sources:
|
||
recommended.append('feishu')
|
||
if 'hn' not in [s.split('_')[0] for s in configured_sources]:
|
||
recommended.append('hn')
|
||
reasoning_parts.append("建议配置基础集成源以启动 AI 主动捕获能力")
|
||
|
||
reasoning = "；".join(reasoning_parts) if reasoning_parts else "所有基础集成已配置，AI 主动捕获能力已全面启用"
|
||
|
||
# 估算影响
|
||
impact_levels = {
|
||
0: "暂无明显影响",
|
||
1: "预计每周节省 2 小时手动录入时间",
|
||
2: "预计每周节省 4 小时手动录入时间，捕获 10+ 个需求信号",
|
||
3: "预计每周节省 6 小时会议时间，自动对齐 5+ 个认知冲突",
|
||
4: "预计每周节省 8 小时会议时间，主动捕获 20+ 个需求信号"
|
||
}
|
||
impact = impact_levels.get(len(recommended), impact_levels[4])
|
||
|
||
return {
|
||
'recommended_sources': recommended,
|
||
'reasoning': reasoning,
|
||
'estimated_impact': impact,
|
||
'current_config': {
|
||
'feishu_configured': 'feishu' in configured_sources,
|
||
'hn_configured': any('hn' in s for s in configured_sources),
|
||
'github_configured': any('github' in s for s in configured_sources),
|
||
'browser_installed': False # 需要前端检测
|
||
}
|
||
}
|