devsquad 3.6.0__py3-none-any.whl

scripts/mcp_server.py

@@ -0,0 +1,289 @@
+"""
+DevSquad MCP (Model Context Protocol) Server — For OpenClaw / Claude Code Tool Integration.
+
+This server exposes MultiAgentDispatcher capabilities as MCP tools, enabling
+any MCP-compatible AI agent (OpenClaw, Claude Code, Cursor, etc.) to invoke
+multi-agent collaboration directly.
+
+Usage:
+    python scripts/mcp_server.py          # Start stdio transport (default)
+    python scripts/mcp_server.py --port 8080  # Start SSE transport
+
+MCP Tools Exposed:
+    1. multiagent_dispatch     — Execute a multi-agent collaboration task
+    2. multiagent_quick        — Quick dispatch with format options
+    3. multiagent_roles        — List available roles
+    4. multiagent_status       — System status and capabilities
+    5. multiagent_analyze      — Analyze task intent (dry-run)
+
+Dependencies (optional, graceful fallback):
+    pip install mcp             # For MCP protocol support
+"""
+import json
+import sys
+import os
+import logging
+from typing import Any, Dict, List, Optional
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+logging.basicConfig(level=logging.WARNING, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("DevSquad-MCP")
+
+try:
+    from scripts.collaboration.input_validator import InputValidator
+    _validator = InputValidator()
+except ImportError:
+    _validator = None
+
+try:
+    from mcp.server.fastmcp import FastMCP
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+    logger.warning("MCP SDK not installed. Run: pip install mcp")
+
+from scripts.collaboration.dispatcher import MultiAgentDispatcher
+from scripts.collaboration.permission_guard import PermissionLevel
+from scripts.collaboration.models import ROLE_REGISTRY
+
+
+class DevSquadMCPServer:
+    """MCP Server wrapper for DevSquad."""
+
+    def __init__(self):
+        self._dispatcher: Optional[MultiAgentDispatcher] = None
+
+    def _get_dispatcher(self, **kwargs) -> MultiAgentDispatcher:
+        """Lazy-init dispatcher with caching."""
+        if self._dispatcher is None:
+            self._dispatcher = MultiAgentDispatcher(**kwargs)
+        return self._dispatcher
+
+    def shutdown(self):
+        """Clean up dispatcher."""
+        if self._dispatcher:
+            self._dispatcher.shutdown()
+            self._dispatcher = None
+
+
+def create_mcp_server() -> "FastMCP":
+    """Create and configure the MCP server with all tools."""
+    if not MCP_AVAILABLE:
+        raise ImportError("MCP SDK not installed. Run: pip install mcp")
+
+    mcp = FastMCP("DevSquad")
+    server = DevSquadMCPServer()
+
+    @mcp.tool()
+    def multiagent_dispatch(
+        task: str,
+        roles: Optional[List[str]] = None,
+        mode: str = "auto",
+        output_format: str = "markdown",
+        dry_run: bool = False,
+    ) -> str:
+        """
+        Execute a full multi-agent collaboration task.
+
+        Args:
+            task: The task description to collaborate on.
+            roles: Optional list of roles (arch/pm/sec/test/coder/infra/ui).
+                   If omitted, auto-matches based on task intent (supports CN+EN keywords).
+            mode: Execution mode — 'auto'(default), 'parallel', 'sequential', or 'consensus'.
+            output_format: Output format — 'markdown'(default), 'json', or 'compact'.
+            dry_run: If True, only analyze without execution.
+
+        Returns:
+            Markdown or JSON formatted collaboration result with findings,
+            conflicts resolution, and action items.
+        """
+        disp = server._get_dispatcher()
+        if _validator:
+            vresult = _validator.validate_task(task)
+            if not vresult.valid:
+                return json.dumps({"error": f"Invalid task: {vresult.reason}", "success": False})
+            task = vresult.sanitized_input or task
+        try:
+            result = disp.dispatch(
+                task=task,
+                roles=roles,
+                mode=mode,
+                dry_run=dry_run,
+            )
+            if output_format == "json":
+                return json.dumps({
+                    "success": result.success,
+                    "matched_roles": getattr(result, 'matched_roles', None),
+                    "summary": result.summary,
+                    "report": result.to_markdown(),
+                }, ensure_ascii=False, indent=2)
+            elif output_format == "compact":
+                return result.summary
+            return result.to_markdown()
+        except Exception as e:
+            logger.error(f"Dispatch error: {e}", exc_info=True)
+            return json.dumps({"error": "Internal error occurred", "success": False})
+
+    @mcp.tool()
+    def multiagent_quick(
+        task: str,
+        output_format: str = "structured",
+        include_action_items: bool = True,
+        include_timing: bool = False,
+    ) -> str:
+        """
+        Quick dispatch with simplified interface and 3 output formats.
+
+        Args:
+            task: Task description.
+            output_format: 'structured'(default table), 'compact'(one-line), or 'detailed'(full).
+            include_action_items: Include H/M/L priority action items.
+            include_timing: Include execution timing data.
+
+        Returns:
+            Formatted collaboration result optimized for quick reading.
+        """
+        disp = server._get_dispatcher()
+        if _validator:
+            vresult = _validator.validate_task(task)
+            if not vresult.valid:
+                return json.dumps({"error": f"Invalid task: {vresult.reason}", "success": False})
+            task = vresult.sanitized_input or task
+        try:
+            result = disp.quick_dispatch(
+                task=task,
+                output_format=output_format,
+                include_action_items=include_action_items,
+                include_timing=include_timing,
+            )
+            return result.to_markdown() if hasattr(result, 'to_markdown') else str(result)
+        except Exception as e:
+            logger.error(f"Quick dispatch error: {e}", exc_info=True)
+            return json.dumps({"error": "Internal error occurred", "success": False})
+
+    @mcp.tool()
+    def multiagent_roles(format: str = "text") -> str:
+        """
+        List all available agent roles with descriptions.
+
+        Args:
+            format: 'text' or 'json'.
+
+        Returns:
+            Role list with descriptions showing expertise areas.
+        """
+        roles = {}
+        for rid, rdef in ROLE_REGISTRY.items():
+            display_id = rdef.aliases[0] if rdef.aliases else rid
+            status_tag = " [planned]" if rdef.status == "planned" else ""
+            roles[display_id] = f"{rdef.description}{status_tag}"
+        if format == "json":
+            return json.dumps(roles, ensure_ascii=False, indent=2)
+        lines = [f"**{role}** — {desc}" for role, desc in roles.items()]
+        return "\n".join(lines)
+
+    @mcp.tool()
+    def multiagent_status() -> str:
+        """
+        Get system status, version info, and capability summary.
+
+        Returns:
+            JSON with version, status, available roles/modes, and module info.
+        """
+        disp = server._get_dispatcher()
+        try:
+            stats = disp.get_status() if hasattr(disp, 'get_status') else {}
+            return json.dumps({
+                "name": "DevSquad",
+                "version": "3.6.0",
+                "status": "ready",
+                "modules": 48,
+                "tests": 1548,
+                "roles": 7,
+                "modes": ["auto", "parallel", "sequential", "consensus"],
+                "backends": ["mock", "openai", "anthropic"],
+                "languages": ["zh", "en", "ja"],
+                "features": {
+                    "memory_bridge": True,
+                    "mce_adapter": True,
+                    "workbuddy_claw": True,
+                    "context_compression": True,
+                    "permission_guard": True,
+                    "skill_learning": True,
+                    "streaming": True,
+                    "checkpoint": True,
+                    "workflow_engine": True,
+                    "prompt_injection_detection": True,
+                    "i18n": True,
+                },
+            }, ensure_ascii=False, indent=2)
+        except Exception as e:
+            return json.dumps({"name": "DevSquad", "version": "3.6.0", "status": "ready", "error": "Internal error occurred"})
+
+    @mcp.tool()
+    def multiagent_analyze(task: str) -> str:
+        """
+        Analyze a task's intent and suggest optimal role configuration (dry-run).
+
+        Args:
+            task: Task description to analyze.
+
+        Returns:
+            Analysis including suggested roles, estimated complexity, and mode recommendation.
+        """
+        disp = server._get_dispatcher(enable_warmup=False)
+        if _validator:
+            vresult = _validator.validate_task(task)
+            if not vresult.valid:
+                return json.dumps({"error": f"Invalid task: {vresult.reason}"})
+            task = vresult.sanitized_input or task
+        try:
+            result = disp.dispatch(task, dry_run=True)
+            return json.dumps({
+                "task": task,
+                "suggested_roles": getattr(result, 'matched_roles', []),
+                "summary": result.summary,
+                "complexity": "estimated from task analysis",
+                "recommended_mode": "auto",
+            }, ensure_ascii=False, indent=2)
+        except Exception as e:
+            return json.dumps({"error": "Internal error occurred"}, ensure_ascii=False, indent=2)
+
+    @mcp.tool()
+    def multiagent_shutdown() -> str:
+        """
+        Shutdown the DevSquad dispatcher and free resources.
+        Call this when done to clean up memory and connections.
+        """
+        server.shutdown()
+        return json.dumps({"status": "shutdown_complete"})
+
+    return mcp
+
+
+def main():
+    """Start the MCP server."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="DevSquad MCP Server")
+    parser.add_argument("--port", "-p", type=int, default=None, help="SSE transport port (default: stdio)")
+    parser.add_argument("--host", default="127.0.0.1", help="SSE host (default: 127.0.0.1)")
+    args = parser.parse_args()
+
+    if not MCP_AVAILABLE:
+        print("ERROR: MCP SDK required. Install with: pip install mcp", file=sys.stderr)
+        sys.exit(1)
+
+    mcp = create_mcp_server()
+
+    if args.port:
+        logger.info(f"Starting SSE server on {args.host}:{args.port}")
+        mcp.run(transport="sse", host=args.host, port=args.port)
+    else:
+        logger.info("Starting stdio server")
+        mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

skills/__init__.py

@@ -0,0 +1,32 @@
+"""
+DevSquad V3.6.0 — Layered Sub-Skill Architecture
+
+This package provides fine-grained, independently usable skills that wrap
+DevSquad's core modules. Each sub-skill is a thin handler (~50 lines) that
+imports from the existing collaboration layer — no duplicated logic.
+
+Architecture:
+    skills/
+    ├── dispatch/      → MultiAgentDispatcher (7-role orchestration)
+    ├── intent/        → IntentWorkflowMapper (6 intents × 3 languages)
+    ├── review/        → FiveAxisConsensusEngine (5-axis code review)
+    ├── security/      → Security audit + PermissionGuard
+    ├── test/          → TestQualityGuard + test strategy
+    └── retrospective/  → RetrospectiveEngine + pattern extraction
+
+Usage (standalone):
+    from skills.dispatch.handler import DispatchSkill
+    result = DispatchSkill().run("Fix login bug")
+
+Usage (via registry):
+    from skills import SkillRegistry
+    skill = SkillRegistry.get("dispatch")
+    result = skill.run("Fix login bug")
+
+All sub-skills work with Mock backend by default (no API key needed).
+"""
+
+from .registry import BaseSkill, get_skill, list_skills, discover_all
+
+__all__ = ["BaseSkill", "get_skill", "list_skills", "discover_all"]
+__version__ = "3.6.0"

skills/dispatch/handler.py

@@ -0,0 +1,52 @@
+"""Dispatch Skill — One-click multi-agent task orchestration."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from skills.registry import BaseSkill
+
+_dispatcher = None
+
+
+def _get_dispatcher():
+    global _dispatcher
+    if _dispatcher is None:
+        from scripts.collaboration.dispatcher import MultiAgentDispatcher
+        _dispatcher = MultiAgentDispatcher()
+    return _dispatcher
+
+
+class DispatchSkill(BaseSkill):
+    name = "dispatch"
+    description = "Multi-agent task dispatch: submit a task → auto-match roles → parallel execution → structured report"
+    version = "3.6.0"
+
+    def run(self, task: str, roles: list = None, mode: str = "auto",
+            dry_run: bool = False) -> dict:
+        d = _get_dispatcher()
+        result = d.dispatch(
+            task_description=task,
+            roles=roles,
+            mode=mode,
+            dry_run=dry_run,
+        )
+        timing = result.timing if hasattr(result, 'timing') and isinstance(result.timing, dict) else {}
+        return {
+            "success": result.success,
+            "matched_roles": result.matched_roles,
+            "worker_results": result.worker_results,
+            "report": getattr(result, 'report', None),
+            "intent_match": result.intent_match,
+            "five_axis_result": result.five_axis_result,
+            "timing": {"total_s": round(timing.get("total", 0), 3)},
+            "status": "success" if result.success else "failed",
+        }
+
+    def quick(self, task: str, **kwargs) -> dict:
+        return self.run(task, **kwargs)
+
+    def roles_info(self) -> list:
+        from scripts.collaboration.role_matcher import RoleMatcher
+        rm = RoleMatcher()
+        return [{"id": r.role_id, "name": r.name, "keywords": r.keywords[:5]} for r in rm.roles]

skills/intent/handler.py

@@ -0,0 +1,59 @@
+"""Intent Detection Skill — 用户意图自动识别与工作流映射。"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from skills.registry import BaseSkill
+
+
+class IntentSkill(BaseSkill):
+    name = "intent"
+    description = "Detect user intent from natural language and map to workflow chain (6 intents × 3 languages)"
+    version = "3.6.0"
+
+    INTENT_MAP = {
+        "bug_fix": "🐛 Bug修复",
+        "new_feature": "✨ 新功能开发",
+        "code_review": "🔍 代码评审",
+        "refactor": "♻️ 重构优化",
+        "investigation": "🔬 问题排查",
+        "documentation": "📝 文档编写",
+    }
+
+    def detect(self, text: str, lang: str = "auto") -> dict:
+        from scripts.collaboration.intent_workflow_mapper import IntentWorkflowMapper
+        mapper = IntentWorkflowMapper()
+        result = mapper.detect_intent(text, lang=lang)
+        icon = self.INTENT_MAP.get(result.intent_type, "❓")
+        return {
+            "intent": result.intent_type,
+            "label": f"{icon} {result.intent_type}",
+            "confidence": round(result.confidence, 4),
+            "lang": lang,
+            "required_roles": result.required_roles or [],
+            "optional_roles": result.optional_roles or [],
+            "workflow_chain": result.workflow_chain or [],
+            "gates": [],
+        }
+
+    def batch_detect(self, texts: list, **kwargs) -> list:
+        return [self.detect(t, **kwargs) for t in texts]
+
+    def list_intents(self) -> list:
+        return [
+            {"type": k, "label": v, "description": self._describe(k)}
+            for k, v in self.INTENT_MAP.items()
+        ]
+
+    @staticmethod
+    def _describe(intent_type: str) -> str:
+        descs = {
+            "bug_fix": "Fix defects, errors, or unexpected behavior",
+            "new_feature": "Build new functionality or features",
+            "code_review": "Review code quality, security, performance",
+            "refactor": "Improve code structure without changing behavior",
+            "investigation": "Diagnose root cause of problems",
+            "documentation": "Create or update documentation",
+        }
+        return descs.get(intent_type, "")

skills/registry.py

@@ -0,0 +1,67 @@
+"""Sub-skill registry: discover and instantiate skills by name."""
+
+import importlib
+from pathlib import Path
+from typing import Dict, Optional, Type
+
+_SKILL_DIR = Path(__file__).parent
+_AVAILABLE_SKILLS: Dict[str, Type] = {}
+
+
+class BaseSkill:
+    """Base class for all DevSquad sub-skills."""
+
+    name: str = ""
+    description: str = ""
+    version: str = "3.6.0"
+
+    def run(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def info(self) -> dict:
+        return {"name": self.name, "description": self.description, "version": self.version}
+
+
+def _load_skill(name: str) -> Optional[Type[BaseSkill]]:
+    skill_dir = _SKILL_DIR / name
+    if not skill_dir.is_dir():
+        return None
+    handler_path = skill_dir / "handler.py"
+    if not handler_path.exists():
+        return None
+    try:
+        mod = importlib.import_module(f"skills.{name}.handler")
+        for attr_name in dir(mod):
+            attr = getattr(mod, attr_name)
+            if isinstance(attr, type) and issubclass(attr, BaseSkill) and attr is not BaseSkill:
+                return attr
+    except Exception:
+        pass
+    return None
+
+
+def get_skill(name: str) -> BaseSkill:
+    """Get a skill instance by name. Lazy-loads on first access."""
+    if name not in _AVAILABLE_SKILLS:
+        cls = _load_skill(name)
+        if cls is None:
+            raise ValueError(f"Skill '{name}' not found. Available: {list_skills()}")
+        _AVAILABLE_SKILLS[name] = cls
+    return _AVAILABLE_SKILLS[name]()
+
+
+def list_skills() -> list:
+    """List all available sub-skill names."""
+    if not _AVAILABLE_SKILLS:
+        for d in sorted(_SKILL_DIR.iterdir()):
+            if d.is_dir() and (d / "handler.py").exists():
+                cls = _load_skill(d.name)
+                if cls:
+                    _AVAILABLE_SKILLS[d.name] = cls
+    return list(_AVAILABLE_SKILLS.keys())
+
+
+def discover_all() -> Dict[str, BaseSkill]:
+    """Instantiate all available skills."""
+    names = list_skills()
+    return {name: get_skill(name) for name in names}

skills/retrospective/handler.py

@@ -0,0 +1,125 @@
+"""Retrospective Skill - V3.6.0"""
+
+from skills.registry import BaseSkill
+from scripts.collaboration.retrospective import RetrospectiveEngine
+from scripts.collaboration.models import (
+    StructuredGoal,
+    GoalItem,
+    GoalItemStatus,
+    AnchorResult,
+    AnchorTrigger,
+)
+
+
+class RetrospectiveSkill(BaseSkill):
+    name = "retrospective"
+    description = "项目复盘 - 提取改进模式/生成可执行建议/复盘摘要"
+    version = "3.6.0"
+
+    CAPABILITIES = [
+        "post_dispatch_analysis",
+        "pattern_extraction",
+        "improvement_suggestion",
+    ]
+
+    OUTPUT_FORMATS = ["findings", "patterns", "improvements", "summary"]
+
+    def run(self, action="info", **kwargs):
+        actions = {
+            "run_retrospective": self.run_retrospective,
+            "extract_patterns": self.extract_patterns,
+            "generate_improvements": self.generate_improvements,
+            "summary": self.summary,
+        }
+        fn = actions.get(action)
+        if not fn:
+            return {"error": f"Unknown action: {action}. Available: {list(actions.keys())}"}
+        return fn(**kwargs)
+
+    def _mock_goal(self, task: str = "") -> StructuredGoal:
+        desc = task or "模拟任务：完成功能开发并修复已知问题"
+        return StructuredGoal(
+            goal_id="retro_mock_001",
+            original_description=desc,
+            items=[
+                GoalItem(item_id="item_001", description=desc, status=GoalItemStatus.FULLY_COVERED, coverage_score=1.0),
+            ],
+        )
+
+    def _mock_anchor_history(self) -> list:
+        return [
+            AnchorResult(aligned=True, trigger=AnchorTrigger.MILESTONE, coverage=0.8, drift_score=0.05),
+            AnchorResult(aligned=True, trigger=AnchorTrigger.PHASE_GATE, coverage=0.9, drift_score=0.02),
+            AnchorResult(aligned=False, trigger=AnchorTrigger.DIRECTION_CHANGE, coverage=0.7, drift_score=0.35),
+            AnchorResult(aligned=True, trigger=AnchorTrigger.STEP_COMPLETE, coverage=0.95, drift_score=0.01),
+        ]
+
+    def run_retrospective(self, dispatch_result: dict = None, task: str = "") -> dict:
+        engine = RetrospectiveEngine()
+        goal = self._mock_goal(task)
+        history = self._mock_anchor_history()
+        report = engine.run(goal=goal, anchor_history=history)
+        result = report.to_dict() if hasattr(report, 'to_dict') else {
+            "task_goal": report.task_goal,
+            "deviations": [d.__dict__ for d in report.deviations],
+            "redundant_steps": report.redundant_steps,
+            "improvements": report.improvements,
+            "summary": report.summary,
+        }
+        if dispatch_result:
+            result["dispatch_context"] = dispatch_result
+        return result
+
+    def extract_patterns(self, history_items: list = None) -> dict:
+        items = history_items or [
+            {"type": "goal_drift", "count": 3},
+            {"type": "redundant_step", "count": 2},
+            {"type": "late_error_detection", "count": 4},
+        ]
+        patterns = {}
+        for item in items:
+            t = item.get("type", "unknown")
+            patterns[t] = patterns.get(t, 0) + item.get("count", 1)
+        top_patterns = sorted(patterns.items(), key=lambda x: x[1], reverse=True)[:5]
+        return {
+            "total_items": len(items),
+            "patterns": [{"type": t, "occurrences": c} for t, c in top_patterns],
+            "insight": f"最频繁模式: {top_patterns[0][0] if top_patterns else 'N/A'} ({top_patterns[0][1] if top_patterns else 0}次)",
+        }
+
+    def generate_improvements(self, findings: list) -> dict:
+        if not findings:
+            findings = ["goal_drift", "missing_anchor_checks"]
+        improvement_map = {
+            "goal_drift": "增加中间锚点检查以尽早发现目标偏移",
+            "missing_anchor_checks": "在关键决策点添加 AnchorCheck 验证",
+            "redundant_steps": "优化工作流消除重复步骤",
+            "late_error_detection": "前置错误检测点，缩短反馈循环",
+            "low_coverage": "补充缺失的测试维度和边界用例",
+        }
+        improvements = [improvement_map.get(f, f"针对 {f} 的改进建议") for f in findings]
+        return {
+            "findings_count": len(findings),
+            "improvements": improvements,
+            "priority": "high" if len(findings) > 3 else "medium",
+        }
+
+    def summary(self, retro_result: dict = None) -> dict:
+        if retro_result:
+            deviations = retro_result.get("deviations", [])
+            improvements = retro_result.get("improvements", [])
+            s = retro_result.get("summary", "")
+        else:
+            full = self.run_retrospective()
+            deviations = full.get("deviations", [])
+            improvements = full.get("improvements", [])
+            s = full.get("summary", "")
+        went_well = [f"目标覆盖率达标" if not deviations else "任务已完成"]
+        to_improve = improvements[:5] if improvements else ["保持当前流程"]
+        return {
+            "what_went_well": went_well,
+            "what_to_improve": to_improve,
+            "deviation_count": len(deviations),
+            "improvement_count": len(improvements),
+            "raw_summary": s,
+        }