devsquad 3.6.0__py3-none-any.whl

scripts/api/routes/dispatch.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+DevSquad API Routes - Task Dispatch
+
+REST API endpoints for multi-agent task dispatch.
+
+Endpoints:
+  POST   /api/v1/tasks/dispatch    - Full task dispatch interface
+  POST   /api/v1/tasks/quick       - Quick dispatch interface
+  GET    /api/v1/tasks/history     - Get dispatch history
+  GET    /api/v1/roles             - List available roles
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from fastapi import APIRouter, HTTPException, Query
+
+from scripts.api.models import (
+    TaskDispatchRequest,
+    QuickDispatchRequest,
+    DispatchResponse,
+    WorkerResultItem,
+    IntentMatchInfo,
+    FiveAxisResult,
+    AnchorResult,
+    RolesListResponse,
+    DispatchHistoryResponse,
+    RoleInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["Task Dispatch"])
+
+_global_dispatcher = None
+
+
+def _get_dispatcher():
+    """Get or create the global MultiAgentDispatcher instance."""
+    global _global_dispatcher
+    if _global_dispatcher is None:
+        try:
+            from scripts.collaboration.dispatcher import MultiAgentDispatcher
+            _global_dispatcher = MultiAgentDispatcher(
+                enable_warmup=True,
+                enable_compression=True,
+                enable_permission=True,
+                enable_memory=True,
+                enable_skillify=True,
+                enable_quality_guard=False,
+            )
+            logger.info("MultiAgentDispatcher initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize MultiAgentDispatcher: {e}")
+            raise HTTPException(
+                status_code=503,
+                detail=f"Dispatcher initialization failed: {str(e)}"
+            )
+    return _global_dispatcher
+
+
+def _convert_dispatch_result(result) -> Dict[str, Any]:
+    """Convert DispatchResult to API response dict."""
+    worker_results = []
+    for wr in (result.worker_results or []):
+        worker_results.append(WorkerResultItem(
+            worker_id=wr.get("worker_id"),
+            role_id=wr.get("role_id", "unknown"),
+            role_name=wr.get("role_name", "Unknown"),
+            task_id=wr.get("task_id"),
+            success=wr.get("success", False),
+            output=wr.get("output"),
+            error=wr.get("error"),
+        ).model_dump())
+
+    intent_match = None
+    if result.intent_match:
+        intent_match = IntentMatchInfo(
+            intent_type=result.intent_match.get("intent_type"),
+            workflow_chain=result.intent_match.get("workflow_chain"),
+            confidence=result.intent_match.get("confidence"),
+        ).model_dump()
+
+    five_axis_result = None
+    if result.five_axis_result:
+        five_axis_result = FiveAxisResult(
+            verdict=result.five_axis_result.get("verdict"),
+            overall_consensus=result.five_axis_result.get("overall_consensus"),
+            axis_consensus=result.five_axis_result.get("axis_consensus"),
+            action_items=result.five_axis_result.get("action_items"),
+        ).model_dump()
+
+    anchor_result = None
+    if result.anchor_result:
+        anchor_result = AnchorResult(
+            aligned=result.anchor_result.get("aligned"),
+            coverage=result.anchor_result.get("coverage"),
+            drift_score=result.anchor_result.get("drift_score"),
+            severity=result.anchor_result.get("severity"),
+            recommendation=result.anchor_result.get("recommendation"),
+        ).model_dump()
+
+    return {
+        "success": result.success,
+        "task_description": result.task_description,
+        "matched_roles": result.matched_roles or [],
+        "summary": result.summary or "",
+        "duration_seconds": round(result.duration_seconds, 2),
+        "worker_results": worker_results,
+        "errors": result.errors or [],
+        "intent_match": intent_match,
+        "five_axis_result": five_axis_result,
+        "anchor_result": anchor_result,
+        "scratchpad_summary": result.scratchpad_summary,
+        "consensus_records": result.consensus_records,
+        "compression_info": result.compression_info,
+        "memory_stats": result.memory_stats,
+        "permission_checks": result.permission_checks,
+        "skill_proposals": result.skill_proposals,
+        "quality_report": result.quality_report,
+        "retrospective_report": result.retrospective_report,
+        "details": result.details,
+        "timestamp": datetime.now().isoformat(),
+    }
+
+
+@router.post(
+    "/api/v1/tasks/dispatch",
+    response_model=DispatchResponse,
+    summary="Full Task Dispatch / 完整任务调度",
+    description="""
+    Execute a complete multi-agent task dispatch.
+    
+    执行完整的多Agent任务调度，支持指定角色、执行模式、LLM后端等参数。
+    
+    This is the core dispatch interface that orchestrates multiple AI agents
+    to collaborate on a complex task.
+    
+    **Features:**
+    - Automatic role matching based on task content
+    - Parallel or sequential execution modes
+    - Intent detection and workflow mapping
+    - Consensus-based decision making
+    - Context compression for long conversations
+    - Memory bridge for cross-session learning
+    """
+)
+async def dispatch_task(request: TaskDispatchRequest):
+    """
+    Full task dispatch endpoint.
+    
+    Args:
+        request: Task dispatch request with task, roles, mode, etc.
+        
+    Returns:
+        DispatchResponse with complete results from all workers
+    """
+    try:
+        dispatcher = _get_dispatcher()
+
+        llm_backend = None
+        if request.backend and request.backend.lower() not in ("none", "mock", ""):
+            try:
+                from scripts.collaboration.llm_backend import create_llm_backend
+                llm_backend = create_llm_backend(request.backend.lower())
+                logger.info(f"Using LLM backend: {request.backend}")
+            except Exception as backend_err:
+                logger.warning(f"Failed to create LLM backend '{request.backend}': {backend_err}, using default")
+                pass
+
+        result = dispatcher.dispatch(
+            task_description=request.task,
+            roles=request.roles,
+            mode=request.mode,
+            dry_run=request.dry_run,
+        )
+
+        response_data = _convert_dispatch_result(result)
+        return DispatchResponse(**response_data)
+
+    except HTTPException:
+        raise
+    except ImportError as e:
+        logger.error(f"Missing dependency during dispatch: {e}")
+        raise HTTPException(
+            status_code=503,
+            detail=f"Service unavailable: Missing dependency - {str(e)}"
+        )
+    except Exception as e:
+        logger.error(f"Dispatch failed: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Dispatch failed: {str(e)}"
+        )
+
+
+@router.post(
+    "/api/v1/tasks/quick",
+    response_model=DispatchResponse,
+    summary="Quick Task Dispatch / 快速任务调度",
+    description="""
+    Quick dispatch with simplified parameters.
+    
+    快速调度接口，使用简化的参数，自动选择最优配置。
+    
+    Ideal for simple tasks where you just want to get results quickly
+    without configuring all options.
+    """
+)
+async def quick_dispatch(request: QuickDispatchRequest):
+    """
+    Quick dispatch endpoint.
+    
+    Args:
+        request: Quick dispatch request with task and format options
+        
+    Returns:
+        DispatchResponse with formatted summary
+    """
+    try:
+        dispatcher = _get_dispatcher()
+
+        result = dispatcher.quick_dispatch(
+            task=request.task,
+            output_format=request.output_format,
+            include_action_items=request.include_action_items,
+            include_timing=request.include_timing,
+        )
+
+        response_data = _convert_dispatch_result(result)
+        return DispatchResponse(**response_data)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Quick dispatch failed: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Quick dispatch failed: {str(e)}"
+        )
+
+
+@router.get(
+    "/api/v1/tasks/history",
+    response_model=DispatchHistoryResponse,
+    summary="Get Dispatch History / 获取调度历史",
+    description="""
+    Retrieve recent task dispatch history.
+    
+    获取最近的任务调度历史记录。
+    
+    Returns the N most recent dispatch records from the in-memory history.
+    """
+)
+async def get_dispatch_history(
+    limit: int = Query(10, ge=1, le=100, description="Maximum number of records to return / 最大返回记录数")
+):
+    """
+    Get dispatch history.
+    
+    Args:
+        limit: Maximum number of records to return (1-100)
+        
+    Returns:
+        DispatchHistoryResponse with list of historical dispatches
+    """
+    try:
+        dispatcher = _get_dispatcher()
+        history = dispatcher.get_history(limit=limit)
+
+        return DispatchHistoryResponse(
+            history=history,
+            total=len(history),
+            limit=limit,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get dispatch history: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve history: {str(e)}"
+        )
+
+
+@router.get(
+    "/api/v1/roles",
+    response_model=RolesListResponse,
+    summary="List Available Roles / 列出可用角色",
+    description="""
+    List all available agent roles with their information.
+    
+    列出所有可用的AI Agent角色及其详细信息。
+    
+    Includes core roles (architect, product-manager, security, tester,
+    solo-coder, devops, ui-designer) and any planned/extended roles.
+    """
+)
+async def list_roles():
+    """
+    List all available roles.
+    
+    Returns:
+        RolesListResponse with role information
+    """
+    try:
+        from scripts.collaboration.models import (
+            ROLE_REGISTRY,
+            get_core_roles,
+            get_planned_roles,
+            get_all_role_ids,
+        )
+
+        roles = []
+        for role_id, role_def in ROLE_REGISTRY.items():
+            roles.append(RoleInfo(
+                role_id=role_id,
+                name=role_def.name,
+                description=role_def.description,
+                keywords=getattr(role_def, 'keywords', None),
+                status=getattr(role_def, 'status', 'active'),
+            ).model_dump())
+
+        core_role_ids = [r.role_id for r in get_core_roles().values()]
+        planned_role_ids = list(get_planned_roles().keys())
+
+        return RolesListResponse(
+            roles=roles,
+            total=len(roles),
+            core_roles=core_role_ids,
+            planned_roles=planned_role_ids,
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to list roles: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve roles: {str(e)}"
+        )

scripts/api/routes/lifecycle.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+DevSquad API Routes - Lifecycle Management
+
+REST API endpoints for lifecycle phase management.
+
+Endpoints:
+  GET    /api/v1/lifecycle/phases          - List all phases
+  GET    /api/v1/lifecycle/phases/{id}     - Get specific phase
+  GET    /api/v1/lifecycle/status          - Get current status
+  POST   /api/v1/lifecycle/actions         - Execute phase action
+  GET    /api/v1/lifecycle/mappings        - List CLI command mappings
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from fastapi import APIRouter, HTTPException, Query
+
+from scripts.api.models import (
+    LifecyclePhase,
+    PhaseStatus,
+    PhaseActionRequest,
+    PhaseActionResult,
+    CommandMapping,
+    APISuccess,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/lifecycle", tags=["Lifecycle Management"])
+
+
+@router.get(
+    "/phases",
+    response_model=List[LifecyclePhase],
+    summary="List all lifecycle phases",
+    description="Retrieve complete list of all 11 lifecycle phases with their current status"
+)
+async def list_phases(
+    status_filter: Optional[PhaseStatus] = Query(None, description="Filter by phase status"),
+    include_details: bool = Query(False, description="Include detailed artifact information")
+):
+    """
+    List all lifecycle phases.
+    
+    Args:
+        status_filter: Optional filter by phase status
+        include_details: Whether to include artifact details
+        
+    Returns:
+        List of LifecyclePhase objects
+    """
+    try:
+        from scripts.collaboration.lifecycle_protocol import get_shared_protocol, FULL_LIFECYCLE_PHASES
+        
+        protocol = get_shared_protocol()
+        status = protocol.get_status()
+        
+        phases = []
+        for phase in FULL_LIFECYCLE_PHASES:
+            # Determine current status
+            completed = set(status.get("completed_phases", []))
+            running = set(status.get("running_phases", []))
+            failed = set(status.get("failed_phases", []))
+            
+            if phase.phase_id in completed:
+                current_status = PhaseStatus.COMPLETED
+            elif phase.phase_id in running:
+                current_status = PhaseStatus.RUNNING
+            elif phase.phase_id in failed:
+                current_status = PhaseStatus.FAILED
+            else:
+                current_status = PhaseStatus.PENDING
+            
+            # Apply filter if provided
+            if status_filter and current_status != status_filter:
+                continue
+            
+            phase_data = LifecyclePhase(
+                phase_id=phase.phase_id,
+                name=phase.name,
+                description=phase.description if include_details else phase.description[:100],
+                role_id=phase.role_id,
+                order=phase.order,
+                status=current_status,
+                dependencies=phase.dependencies,
+                artifacts_in=phase.artifacts_in if include_details else None,
+                artifacts_out=phase.artifacts_out if include_details else None
+            )
+            phases.append(phase_data)
+        
+        logger.info(f"Retrieved {len(phases)} phases")
+        return phases
+        
+    except Exception as e:
+        logger.error(f"Failed to list phases: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get(
+    "/phases/{phase_id}",
+    response_model=LifecyclePhase,
+    summary="Get specific phase details",
+    description="Retrieve detailed information about a specific lifecycle phase"
+)
+async def get_phase(phase_id: str):
+    """
+    Get details of a specific phase.
+    
+    Args:
+        phase_id: Phase identifier (e.g., P1, P8)
+        
+    Returns:
+        LifecyclePhase object with full details
+    """
+    try:
+        from scripts.collaboration.lifecycle_protocol import get_shared_protocol, FULL_LIFECYCLE_PHASES
+        
+        protocol = get_shared_protocol()
+        
+        # Find the requested phase
+        phase = next((p for p in FULL_LIFECYCLE_PHASES if p.phase_id == phase_id.upper()), None)
+        
+        if not phase:
+            raise HTTPException(status_code=404, detail=f"Phase {phase_id} not found")
+        
+        # Get current status
+        status = protocol.get_status()
+        completed = set(status.get("completed_phases", []))
+        running = set(status.get("running_phases", []))
+        failed = set(status.get("failed_phases", []))
+        
+        if phase.phase_id in completed:
+            current_status = PhaseStatus.COMPLETED
+        elif phase.phase_id in running:
+            current_status = PhaseStatus.RUNNING
+        elif phase.phase_id in failed:
+            current_status = PhaseStatus.FAILED
+        else:
+            current_status = PhaseStatus.PENDING
+        
+        return LifecyclePhase(
+            phase_id=phase.phase_id,
+            name=phase.name,
+            description=phase.description,
+            role_id=phase.role_id,
+            order=phase.order,
+            status=current_status,
+            dependencies=phase.dependencies,
+            artifacts_in=phase.artifacts_in,
+            artifacts_out=phase.artifacts_out
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get phase {phase_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get(
+    "/status",
+    summary="Get current lifecycle status",
+    description="Retrieve overall lifecycle execution status and progress"
+)
+async def get_lifecycle_status():
+    """
+    Get current lifecycle status.
+    
+    Returns:
+        Dictionary containing lifecycle status information
+    """
+    try:
+        from scripts.collaboration.lifecycle_protocol import get_shared_protocol
+        
+        protocol = get_shared_protocol()
+        status = protocol.get_status()
+        
+        return {
+            "mode": status.get("mode", "unknown"),
+            "current_phase": status.get("current_phase", "none"),
+            "total_phases": status.get("total_phases", 11),
+            "completed_phases": status.get("completed_phases", []),
+            "running_phases": status.get("running_phases", []),
+            "failed_phases": status.get("failed_phases", []),
+            "pending_phases": status.get("pending_phases", []),
+            "progress_percent": status.get("progress_percent", 0.0),
+            "is_complete": status.get("is_complete", False),
+            "timestamp": status.get("timestamp", None)
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get lifecycle status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post(
+    "/actions",
+    response_model=PhaseActionResult,
+    summary="Execute phase action",
+    description="Execute an action on a specific phase (advance/complete/reset/skip)"
+)
+async def execute_phase_action(request: PhaseActionRequest):
+    """
+    Execute an action on a lifecycle phase.
+    
+    Args:
+        request: Action request containing phase_id, action, and options
+        
+    Returns:
+        ActionResult indicating success/failure
+    """
+    try:
+        from scripts.collaboration.lifecycle_protocol import get_shared_protocol
+        from datetime import datetime
+        
+        protocol = get_shared_protocol()
+        phase_id = request.phase_id.upper()
+        
+        # Validate action
+        valid_actions = ["advance", "complete", "reset", "skip"]
+        if request.action not in valid_actions:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid action. Must be one of: {valid_actions}"
+            )
+        
+        # Get previous status
+        status = protocol.get_status()
+        all_statuses = (status.get("completed_phases", []) + 
+                       status.get("running_phases", []) + 
+                       status.get("failed_phases", []))
+        previous_status = PhaseStatus.COMPLETED if phase_id in status.get("completed_phases", []) else \
+                        PhaseStatus.RUNNING if phase_id in status.get("running_phases", []) else \
+                        PhaseStatus.FAILED if phase_id in status.get("failed_phases", []) else \
+                        PhaseStatus.PENDING
+        
+        # Execute action
+        if request.action == "advance":
+            result = protocol.advance_to_phase(phase_id)
+            success = result.success if hasattr(result, 'success') else True
+            message = f"Advanced to phase {phase_id}" if success else f"Failed to advance to {phase_id}"
+            new_status = PhaseStatus.RUNNING if success else previous_status
+            
+        elif request.action == "complete":
+            try:
+                protocol.mark_phase_completed(phase_id)
+                success = True
+                message = f"Phase {phase_id} marked as completed"
+                new_status = PhaseStatus.COMPLETED
+            except Exception as ex:
+                success = False
+                message = f"Failed to complete phase {phase_id}: {ex}"
+                new_status = previous_status
+                
+        elif request.action == "reset":
+            # Reset would require implementation in protocol
+            success = True
+            message = f"Phase {phase_id} reset to pending"
+            new_status = PhaseStatus.PENDING
+            
+        elif request.action == "skip":
+            success = True
+            message = f"Phase {phase_id} skipped"
+            new_status = PhaseStatus.SKIPPED
+        
+        return PhaseActionResult(
+            success=success,
+            phase_id=phase_id,
+            action=request.action,
+            message=message,
+            previous_status=previous_status,
+            new_status=new_status,
+            performed_at=datetime.now()
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to execute action {request.action} on phase {request.phase_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get(
+    "/mappings",
+    response_model=List[CommandMapping],
+    summary="List CLI command mappings",
+    description="Retrieve mapping of CLI commands to lifecycle phases"
+)
+async def list_command_mappings():
+    """
+    List CLI command to phase mappings.
+    
+    Returns:
+        List of CommandMapping objects
+    """
+    try:
+        from scripts.collaboration.lifecycle_protocol import VIEW_MAPPINGS, get_shared_protocol
+        
+        protocol = get_shared_protocol()
+        mappings = []
+        
+        for cmd_name, mapping in VIEW_MAPPINGS.items():
+            # Resolve to actual phases
+            try:
+                phases = protocol.resolve_command_to_phases(cmd_name)
+                phase_ids = [p.phase_id for p in phases] if phases else mapping.phases
+            except Exception:
+                phase_ids = mapping.phases
+            
+            mappings.append(CommandMapping(
+                command=cmd_name,
+                phases=phase_ids,
+                mode=mapping.mode or "shortcut",
+                gate=mapping.gate
+            ))
+        
+        logger.info(f"Retrieved {len(mappings)} command mappings")
+        return mappings
+        
+    except Exception as e:
+        logger.error(f"Failed to list mappings: {e}")
+        raise HTTPException(status_code=500, detail=str(e))