stravinsky 0.2.52__py3-none-any.whl → 0.4.18__py3-none-any.whl

mcp_bridge/tools/agent_manager.py

@@ -36,6 +36,8 @@ AGENT_MODEL_ROUTING = {
     "multimodal": None,
     "frontend": None,
     "delphi": None,
+    "research-lead": None,  # Hierarchical orchestrator using gemini-3-flash
+    "implementation-lead": None,  # Hierarchical orchestrator using haiku
     # Planner uses Opus for superior reasoning about dependencies and parallelization
     "planner": "opus",
     # Default for unknown agent types (coding tasks) - use Sonnet 4.5
@@ -48,12 +50,116 @@ AGENT_COST_TIERS = {
     "dewey": "CHEAP",  # Uses gemini-3-flash
     "document_writer": "CHEAP",  # Uses gemini-3-flash
     "multimodal": "CHEAP",  # Uses gemini-3-flash
+    "research-lead": "CHEAP",  # Uses gemini-3-flash
+    "implementation-lead": "CHEAP",  # Uses haiku
     "frontend": "MEDIUM",  # Uses gemini-3-pro-high
     "delphi": "EXPENSIVE",  # Uses gpt-5.2 (OpenAI GPT)
     "planner": "EXPENSIVE",  # Uses Claude Opus 4.5
     "_default": "EXPENSIVE",  # Claude Sonnet 4.5 via CLI
 }
 
+# Display model names for output formatting (user-visible)
+AGENT_DISPLAY_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "document_writer": "gemini-3-flash",
+    "multimodal": "gemini-3-flash",
+    "research-lead": "gemini-3-flash",
+    "implementation-lead": "haiku",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2",
+    "planner": "opus-4.5",
+    "_default": "sonnet-4.5",
+}
+
+# Cost tier emoji indicators for visual differentiation
+# Colors indicate cost: 🟢 cheap/free, 🔵 medium, 🟣 expensive (GPT), 🟠 Claude
+COST_TIER_EMOJI = {
+    "CHEAP": "🟢",  # Free/cheap models (gemini-3-flash, haiku)
+    "MEDIUM": "🔵",  # Medium cost (gemini-3-pro-high)
+    "EXPENSIVE": "🟣",  # Expensive models (gpt-5.2, opus)
+}
+
+# Model family indicators
+MODEL_FAMILY_EMOJI = {
+    "gemini-3-flash": "🟢",
+    "gemini-3-pro-high": "🔵",
+    "haiku": "🟢",
+    "sonnet-4.5": "🟠",
+    "opus-4.5": "🟣",
+    "gpt-5.2": "🟣",
+}
+
+# ANSI color codes for terminal output
+class Colors:
+    """ANSI color codes for colorized terminal output."""
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+
+    # Foreground colors
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+    # Bright foreground colors
+    BRIGHT_BLACK = "\033[90m"
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+
+
+def get_agent_emoji(agent_type: str) -> str:
+    """Get the colored emoji indicator for an agent based on its cost tier."""
+    cost_tier = AGENT_COST_TIERS.get(agent_type, AGENT_COST_TIERS["_default"])
+    return COST_TIER_EMOJI.get(cost_tier, "⚪")
+
+
+def get_model_emoji(model_name: str) -> str:
+    """Get the colored emoji indicator for a model."""
+    return MODEL_FAMILY_EMOJI.get(model_name, "⚪")
+
+
+def colorize_agent_spawn_message(
+    cost_emoji: str,
+    agent_type: str,
+    display_model: str,
+    description: str,
+    task_id: str,
+) -> str:
+    """
+    Create a colorized agent spawn message with ANSI color codes.
+
+    Format:
+    🟢 explore:gemini-3-flash('Find auth...') ⏳
+    task_id=agent_abc123
+
+    With colors:
+    🟢 {CYAN}explore{RESET}:{YELLOW}gemini-3-flash{RESET}('{BOLD}Find auth...{RESET}') ⏳
+    task_id={BRIGHT_BLACK}agent_abc123{RESET}
+    """
+    short_desc = (description or "")[:50].strip()
+
+    # Build colorized message
+    colored_message = (
+        f"{cost_emoji} "
+        f"{Colors.CYAN}{agent_type}{Colors.RESET}:"
+        f"{Colors.YELLOW}{display_model}{Colors.RESET}"
+        f"('{Colors.BOLD}{short_desc}{Colors.RESET}') "
+        f"{Colors.BRIGHT_GREEN}⏳{Colors.RESET}\n"
+        f"task_id={Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}"
+    )
+    return colored_message
+
 
 @dataclass
 class AgentTask:
@@ -472,45 +578,45 @@ class AgentManager:
         description = task.get("description", "")
         agent_type = task.get("agent_type", "unknown")
 
+        # Get cost-tier emoji for visual differentiation
+        cost_emoji = get_agent_emoji(agent_type)
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+
         if status == "completed":
             result = task.get("result", "(no output)")
-            return f"""✅ Agent Task Completed
+            return f"""{cost_emoji} {Colors.BRIGHT_GREEN}✅ Agent Task Completed{Colors.RESET}
 
-**Task ID**: {task_id}
-**Agent**: {agent_type}
-**Description**: {description}
+**Task ID**: {Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}
+**Agent**: {Colors.CYAN}{agent_type}{Colors.RESET}:{Colors.YELLOW}{display_model}{Colors.RESET}('{Colors.BOLD}{description}{Colors.RESET}')
 
 **Result**:
 {result}"""
 
         elif status == "failed":
             error = task.get("error", "(no error details)")
-            return f"""❌ Agent Task Failed
+            return f"""{cost_emoji} {Colors.BRIGHT_RED}❌ Agent Task Failed{Colors.RESET}
 
-**Task ID**: {task_id}
-**Agent**: {agent_type}
-**Description**: {description}
+**Task ID**: {Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}
+**Agent**: {Colors.CYAN}{agent_type}{Colors.RESET}:{Colors.YELLOW}{display_model}{Colors.RESET}('{Colors.BOLD}{description}{Colors.RESET}')
 
 **Error**:
 {error}"""
 
         elif status == "cancelled":
-            return f"""⚠️ Agent Task Cancelled
+            return f"""{cost_emoji} {Colors.BRIGHT_YELLOW}⚠️ Agent Task Cancelled{Colors.RESET}
 
-**Task ID**: {task_id}
-**Agent**: {agent_type}
-**Description**: {description}"""
+**Task ID**: {Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}
+**Agent**: {Colors.CYAN}{agent_type}{Colors.RESET}:{Colors.YELLOW}{display_model}{Colors.RESET}('{Colors.BOLD}{description}{Colors.RESET}')"""
 
         else:  # pending or running
             pid = task.get("pid", "N/A")
             started = task.get("started_at", "N/A")
-            return f"""⏳ Agent Task Running
+            return f"""{cost_emoji} {Colors.BRIGHT_YELLOW}⏳ Agent Task Running{Colors.RESET}
 
-**Task ID**: {task_id}
-**Agent**: {agent_type}
-**Description**: {description}
-**PID**: {pid}
-**Started**: {started}
+**Task ID**: {Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}
+**Agent**: {Colors.CYAN}{agent_type}{Colors.RESET}:{Colors.YELLOW}{display_model}{Colors.RESET}('{Colors.BOLD}{description}{Colors.RESET}')
+**PID**: {Colors.DIM}{pid}{Colors.RESET}
+**Started**: {Colors.DIM}{started}{Colors.RESET}
 
 Use `agent_output` with block=true to wait for completion."""
 
@@ -583,11 +689,14 @@ Use `agent_output` with block=true to wait for completion."""
             "cancelled": "⚠️",
         }.get(status, "❓")
 
-        result = f"""{status_emoji} **Agent Progress**
+        # Get cost-tier emoji for visual differentiation
+        cost_emoji = get_agent_emoji(agent_type)
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+
+        result = f"""{cost_emoji} {status_emoji} **Agent Progress**
 
 **Task ID**: {task_id}
-**Agent**: {agent_type}
-**Description**: {description}
+**Agent**: {agent_type}:{display_model}('{description}')
 **Status**: {status}
 """
 
@@ -631,6 +740,7 @@ async def agent_spawn(
     model: str = "gemini-3-flash",
     thinking_budget: int = 0,
     timeout: int = 300,
+    blocking: bool = False,
 ) -> str:
     """
     Spawn a background agent.
@@ -642,9 +752,10 @@ async def agent_spawn(
         model: Model to use (gemini-3-flash, gemini-2.0-flash, claude)
         thinking_budget: Reserved reasoning tokens
         timeout: Execution timeout in seconds
+        blocking: If True, wait for completion and return result directly (use for delphi)
 
     Returns:
-        Task ID and instructions
+        Task ID and instructions, or full result if blocking=True
     """
     manager = get_manager()
 
@@ -762,6 +873,61 @@ CONSTRAINTS:
 - Every task must have a clear agent assignment
 - Parallel phases must be truly independent
 - Include ready-to-use agent_spawn commands""",
+        "research-lead": """You coordinate research tasks by spawning explore and dewey agents in parallel.
+
+## Your Role
+1. Receive research objective from Stravinsky
+2. Decompose into parallel search tasks
+3. Spawn explore/dewey agents for each task
+4. Collect and SYNTHESIZE results
+5. Return structured findings (not raw outputs)
+
+## Output Format
+Always return a Research Brief:
+```json
+{
+  "objective": "Original research goal",
+  "findings": [
+    {"source": "agent_id", "summary": "Key finding", "confidence": "high/medium/low"},
+    ...
+  ],
+  "synthesis": "Combined analysis of all findings",
+  "gaps": ["Information we couldn't find"],
+  "recommendations": ["Suggested next steps"]
+}
+```
+
+MODEL ROUTING:
+Use invoke_gemini with model="gemini-3-flash" for ALL synthesis work.
+""",
+        "implementation-lead": """You coordinate implementation based on research findings.
+
+## Your Role
+1. Receive Research Brief from Stravinsky
+2. Create implementation plan
+3. Delegate to specialists:
+   - frontend: UI/visual work
+   - debugger: Fix failures
+   - code-reviewer: Quality checks
+4. Verify with lsp_diagnostics
+5. Return Implementation Report
+
+## Output Format
+```json
+{
+  "objective": "What was implemented",
+  "files_changed": ["path/to/file.py"],
+  "tests_status": "pass/fail/skipped",
+  "diagnostics": "clean/warnings/errors",
+  "blockers": ["Issues preventing completion"]
+}
+```
+
+## Escalation Rules
+- After 2 failed attempts → spawn debugger
+- After debugger fails → escalate to Stravinsky with context
+- NEVER call delphi directly
+""",
     }
 
     system_prompt = system_prompts.get(agent_type, None)
@@ -788,16 +954,25 @@ CONSTRAINTS:
         timeout=timeout,
     )
 
-    return f"""🚀 Background agent spawned successfully.
+    # Get display model and cost tier emoji for concise output
+    display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    cost_emoji = get_agent_emoji(agent_type)
+    short_desc = (description or prompt[:50]).strip()
 
-**Task ID**: {task_id}
-**Agent Type**: {agent_type}
-**Description**: {description or prompt[:50]}
+    # If blocking mode (recommended for delphi), wait for completion
+    if blocking:
+        result = manager.get_output(task_id, block=True, timeout=timeout)
+        blocking_msg = colorize_agent_spawn_message(
+            cost_emoji, agent_type, display_model, short_desc, task_id
+        )
+        return f"{blocking_msg} {Colors.BOLD}[BLOCKING]{Colors.RESET}\n\n{result}"
 
-The agent is now running. Use:
-- `agent_progress(task_id="{task_id}")` to monitor real-time progress
-- `agent_output(task_id="{task_id}")` to get final result
-- `agent_cancel(task_id="{task_id}")` to stop the agent"""
+    # Enhanced format with ANSI colors: cost_emoji agent:model('description') status_emoji
+    # 🟢 explore:gemini-3-flash('Find auth...') ⏳
+    # With colors: agent type in cyan, model in yellow, description bold
+    return colorize_agent_spawn_message(
+        cost_emoji, agent_type, display_model, short_desc, task_id
+    )
 
 
 async def agent_output(task_id: str, block: bool = False) -> str:
@@ -887,7 +1062,7 @@ async def agent_list() -> str:
     if not tasks:
         return "No background agent tasks found."
 
-    lines = ["**Background Agent Tasks**", ""]
+    lines = []
 
     for t in sorted(tasks, key=lambda x: x.get("created_at", ""), reverse=True):
         status_emoji = {
@@ -898,8 +1073,21 @@ async def agent_list() -> str:
             "cancelled": "⚠️",
         }.get(t["status"], "❓")
 
+        agent_type = t.get("agent_type", "unknown")
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+        cost_emoji = get_agent_emoji(agent_type)
         desc = t.get("description", t.get("prompt", "")[:40])
-        lines.append(f"- {status_emoji} [{t['id']}] {t['agent_type']}: {desc}")
+        task_id = t["id"]
+
+        # Concise format with colors: cost_emoji status agent:model('desc') id=xxx
+        # Agent type in cyan, model in yellow, task_id in dim
+        lines.append(
+            f"{cost_emoji} {status_emoji} "
+            f"{Colors.CYAN}{agent_type}{Colors.RESET}:"
+            f"{Colors.YELLOW}{display_model}{Colors.RESET}"
+            f"('{Colors.BOLD}{desc}{Colors.RESET}') "
+            f"id={Colors.BRIGHT_BLACK}{task_id}{Colors.RESET}"
+        )
 
     return "\n".join(lines)
 

mcp_bridge/tools/code_search.py

@@ -15,17 +15,21 @@ from pathlib import Path
 async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
     """
     Get diagnostics (errors, warnings) for a file using language server.
-    
+
     For TypeScript/JavaScript, uses `tsc` or `biome`.
     For Python, uses `pyright` or `ruff`.
-    
+
     Args:
         file_path: Path to the file to analyze
         severity: Filter by severity (error, warning, information, hint, all)
-        
+
     Returns:
         Formatted diagnostics output.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"🩺 LSP-DIAG: file={file_path} severity={severity}", file=sys.stderr)
+
     path = Path(file_path)
     if not path.exists():
         return f"Error: File not found: {file_path}"
@@ -49,7 +53,7 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         elif suffix == ".py":
             # Use ruff for Python diagnostics
             result = subprocess.run(
-                ["ruff", "check", str(path), "--output-format=text"],
+                ["ruff", "check", str(path), "--output-format=concise"],
                 capture_output=True,
                 text=True,
                 timeout=30,
@@ -70,21 +74,88 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         return f"Error: {str(e)}"
 
 
+async def check_ai_comment_patterns(file_path: str) -> str:
+    """
+    Detect AI-generated or placeholder comment patterns that indicate incomplete work.
+
+    Patterns detected:
+    - # TODO: implement, # FIXME, # placeholder
+    - // TODO, // FIXME, // placeholder
+    - AI-style verbose comments: "This function handles...", "This method is responsible for..."
+    - Placeholder phrases: "implement this", "add logic here", "your code here"
+
+    Args:
+        file_path: Path to the file to check
+
+    Returns:
+        List of detected AI-style patterns with line numbers, or "No AI patterns detected"
+    """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"🤖 AI-CHECK: {file_path}", file=sys.stderr)
+
+    path = Path(file_path)
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+
+    # Patterns that indicate AI-generated or placeholder code
+    ai_patterns = [
+        # Placeholder comments
+        r"#\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        r"//\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        # AI-style verbose descriptions
+        r"#\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r"//\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r'"""This (function|method|class) (handles|is responsible for|manages|processes)',
+        # Placeholder implementations
+        r"pass\s*#\s*(TODO|implement|placeholder)",
+        r"raise NotImplementedError.*implement",
+        # Common AI filler phrases
+        r"#.*\b(as needed|as required|as appropriate|if necessary)\b",
+        r"//.*\b(as needed|as required|as appropriate|if necessary)\b",
+    ]
+
+    import re
+
+    try:
+        content = path.read_text()
+        lines = content.split("\n")
+        findings = []
+
+        for i, line in enumerate(lines, 1):
+            for pattern in ai_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    findings.append(f"  Line {i}: {line.strip()[:80]}")
+                    break
+
+        if findings:
+            return f"AI/Placeholder patterns detected in {file_path}:\n" + "\n".join(findings)
+        return "No AI patterns detected"
+
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+
 async def ast_grep_search(pattern: str, directory: str = ".", language: str = "") -> str:
     """
     Search codebase using ast-grep for structural patterns.
-    
+
     ast-grep uses AST-aware pattern matching, finding code by structure
     rather than just text. More precise than regex for code search.
-    
+
     Args:
         pattern: ast-grep pattern to search for
         directory: Directory to search in
         language: Filter by language (typescript, python, rust, etc.)
-        
+
     Returns:
         Matched code locations and snippets.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    lang_info = f" lang={language}" if language else ""
+    print(f"🔍 AST-GREP: pattern='{pattern[:50]}...'{lang_info}", file=sys.stderr)
+
     try:
         cmd = ["sg", "run", "-p", pattern, directory]
         if language:
@@ -129,15 +200,20 @@ async def ast_grep_search(pattern: str, directory: str = ".", language: str = ""
 async def grep_search(pattern: str, directory: str = ".", file_pattern: str = "") -> str:
     """
     Fast text search using ripgrep.
-    
+
     Args:
         pattern: Search pattern (supports regex)
         directory: Directory to search in
         file_pattern: Glob pattern to filter files (e.g., "*.py", "*.ts")
-        
+
     Returns:
         Matched lines with file paths and line numbers.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    glob_info = f" glob={file_pattern}" if file_pattern else ""
+    print(f"🔎 GREP: pattern='{pattern[:50]}'{glob_info} dir={directory}", file=sys.stderr)
+
     try:
         cmd = ["rg", "--line-number", "--max-count=50", pattern, directory]
         if file_pattern:
@@ -173,14 +249,18 @@ async def grep_search(pattern: str, directory: str = ".", file_pattern: str = ""
 async def glob_files(pattern: str, directory: str = ".") -> str:
     """
     Find files matching a glob pattern.
-    
+
     Args:
         pattern: Glob pattern (e.g., "**/*.py", "src/**/*.ts")
         directory: Base directory for search
-        
+
     Returns:
         List of matching file paths.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"📁 GLOB: pattern='{pattern}' dir={directory}", file=sys.stderr)
+
     try:
         cmd = ["fd", "--type", "f", "--glob", pattern, directory]
         
@@ -234,6 +314,12 @@ async def ast_grep_replace(
     Returns:
         Preview of changes or confirmation of applied changes.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    mode = "dry-run" if dry_run else "APPLY"
+    lang_info = f" lang={language}" if language else ""
+    print(f"🔄 AST-REPLACE: '{pattern[:30]}' → '{replacement[:30]}'{lang_info} [{mode}]", file=sys.stderr)
+
     try:
         # Build command
         cmd = ["sg", "run", "-p", pattern, "-r", replacement, directory]

mcp_bridge/tools/lsp/__init__.py

@@ -13,8 +13,11 @@ from .tools import (
     lsp_prepare_rename,
     lsp_rename,
     lsp_code_actions,
+    lsp_code_action_resolve,
+    lsp_extract_refactor,
     lsp_servers,
 )
+from .manager import LSPManager, get_lsp_manager
 
 __all__ = [
     "lsp_hover",
@@ -25,5 +28,9 @@ __all__ = [
     "lsp_prepare_rename",
     "lsp_rename",
     "lsp_code_actions",
+    "lsp_code_action_resolve",
+    "lsp_extract_refactor",
     "lsp_servers",
+    "LSPManager",
+    "get_lsp_manager",
 ]