stravinsky 0.2.40__py3-none-any.whl → 0.2.67__py3-none-any.whl

mcp_bridge/tools/agent_manager.py

@@ -11,6 +11,7 @@ import os
 import shutil
 import subprocess
 import signal
+import time
 import uuid
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
@@ -21,6 +22,50 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+# Model routing configuration
+# Specialized agents call external models via MCP tools:
+#   explore/dewey/document_writer/multimodal → invoke_gemini(gemini-3-flash)
+#   frontend → invoke_gemini(gemini-3-pro-high)
+#   delphi → invoke_openai(gpt-5.2)
+# Non-specialized coding tasks use Claude CLI with --model sonnet
+AGENT_MODEL_ROUTING = {
+    # Specialized agents - no CLI model flag, they call invoke_* tools
+    "explore": None,
+    "dewey": None,
+    "document_writer": None,
+    "multimodal": None,
+    "frontend": None,
+    "delphi": None,
+    # Planner uses Opus for superior reasoning about dependencies and parallelization
+    "planner": "opus",
+    # Default for unknown agent types (coding tasks) - use Sonnet 4.5
+    "_default": "sonnet",
+}
+
+# Cost tier classification (from oh-my-opencode pattern)
+AGENT_COST_TIERS = {
+    "explore": "CHEAP",  # Uses gemini-3-flash
+    "dewey": "CHEAP",  # Uses gemini-3-flash
+    "document_writer": "CHEAP",  # Uses gemini-3-flash
+    "multimodal": "CHEAP",  # Uses gemini-3-flash
+    "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",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2",
+    "planner": "opus-4.5",
+    "_default": "sonnet-4.5",
+}
+
 
 @dataclass
 class AgentTask:
@@ -86,7 +131,7 @@ class AgentManager:
 
         # In-memory tracking for running processes
         self._processes: Dict[str, subprocess.Popen] = {}
-        self._notification_queue: Dict[str, List[AgentTask]] = {}
+        self._notification_queue: Dict[str, List[Dict[str, Any]]] = {}
 
     def _load_tasks(self) -> Dict[str, Any]:
         """Load tasks from persistent storage."""
@@ -155,7 +200,9 @@ class AgentManager:
         Returns:
             Task ID for tracking
         """
-        task_id = f"agent_{uuid.uuid4().hex[:8]}"
+        import uuid as uuid_module  # Local import for MCP context
+
+        task_id = f"agent_{uuid_module.uuid4().hex[:8]}"
 
         task = AgentTask(
             id=task_id,
@@ -220,12 +267,20 @@ class AgentManager:
                     full_prompt,
                     "--output-format",
                     "text",
+                    "--dangerously-skip-permissions",  # Critical: bypass permission prompts
                 ]
 
-                # NOTE: We intentionally do NOT pass --model to Claude CLI
-                # The agent_configs have Stravinsky MCP model names (gemini-3-pro-low, gpt-5.2)
-                # which Claude CLI doesn't recognize. Agents use Claude's default model
-                # and can invoke Stravinsky MCP tools (invoke_gemini, invoke_openai) if needed.
+                # Model routing:
+                # - Specialized agents (explore/dewey/etc): None = use CLI default, they call invoke_*
+                # - Unknown agent types (coding tasks): Use Sonnet 4.5
+                if agent_type in AGENT_MODEL_ROUTING:
+                    cli_model = AGENT_MODEL_ROUTING[agent_type]  # None for specialized
+                else:
+                    cli_model = AGENT_MODEL_ROUTING.get("_default", "sonnet")
+
+                if cli_model:
+                    cmd.extend(["--model", cli_model])
+                    logger.info(f"[AgentManager] Using --model {cli_model} for {agent_type} agent")
 
                 # Add system prompt file if we have one
                 if system_prompt:
@@ -240,6 +295,7 @@ class AgentManager:
                 # (Previously used file handle which was closed before process finished)
                 process = subprocess.Popen(
                     cmd,
+                    stdin=subprocess.DEVNULL,  # Critical: prevent stdin blocking
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     text=True,
@@ -416,9 +472,13 @@ class AgentManager:
             start = datetime.now()
             while (datetime.now() - start).total_seconds() < timeout:
                 task = self.get_task(task_id)
-                if task["status"] != "running":
+                if not task or task["status"] != "running":
                     break
-                asyncio.sleep(0.5)
+                time.sleep(0.5)
+
+        # Refresh task state after potential blocking wait
+        if not task:
+            return f"Task {task_id} not found."
 
         status = task["status"]
         description = task.get("description", "")
@@ -583,6 +643,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.
@@ -594,95 +655,136 @@ 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()
 
     # Map agent types to system prompts
+    # ALL agents use invoke_gemini or invoke_openai - NOT Claude directly
+    # explore/dewey/document_writer/multimodal/frontend → gemini-3-flash
+    # delphi → openai gpt-5.2
     system_prompts = {
-        "explore": "You are a codebase exploration specialist. Find files, patterns, and answer 'where is X?' questions efficiently.",
-        "dewey": "You are a documentation and research specialist. Find implementation examples, official docs, and provide evidence-based answers.",
-        "frontend": """You are a Senior Frontend Architect & Avant-Garde UI Designer with 15+ years experience.
-
-OPERATIONAL DIRECTIVES:
-- Follow instructions. Execute immediately. No fluff.
-- Output First: Prioritize code and visual solutions.
-
-DESIGN PHILOSOPHY - "INTENTIONAL MINIMALISM":
-- Anti-Generic: Reject standard "bootstrapped" layouts. If it looks like a template, it's wrong.
-- Bespoke layouts, asymmetry, distinctive typography.
-- Before placing any element, calculate its purpose. No purpose = delete it.
-
-FRONTEND CODING STANDARDS:
-- Library Discipline: If a UI library (Shadcn, Radix, MUI) is detected, YOU MUST USE IT.
-- Do NOT build custom components if the library provides them.
-- Stack: Modern (React/Vue/Svelte), Tailwind/Custom CSS, semantic HTML5.
-- Focus on micro-interactions, perfect spacing, "invisible" UX.
-
-RESPONSE FORMAT:
-1. Rationale: (1 sentence on why elements were placed there)
-2. The Code.
-
-ULTRATHINK MODE (when user says "ULTRATHINK" or "think harder"):
-1. Deep Reasoning Chain: Detailed breakdown of architectural and design decisions
-2. Edge Case Analysis: What could go wrong and how we prevented it
-3. The Code: Optimized, bespoke, production-ready, utilizing existing libraries""",
-        "delphi": "You are a strategic advisor. Provide architecture guidance, debugging assistance, and code review.",
-        "document_writer": """You are a Technical Documentation Specialist. Your expertise is creating clear, comprehensive documentation.
-
-DOCUMENT TYPES YOU EXCEL AT:
-- README files with proper structure
-- API documentation with examples
-- Architecture decision records (ADRs)
-- User guides and tutorials
-- Inline code documentation
-
-DOCUMENTATION PRINCIPLES:
-- Audience-first: Know who's reading and what they need
-- Progressive disclosure: Overview → Details → Edge cases
-- Examples over explanations: Show, don't just tell
-- Keep it DRY: Reference rather than repeat
-- Version awareness: Note when behavior differs across versions
-
-RESPONSE FORMAT:
-1. Document type and target audience identified
-2. The documentation, properly formatted in markdown""",
-        "multimodal": """You interpret media files that cannot be read as plain text.
-
-Your job: examine the attached file and extract ONLY what was requested.
-
-CAPABILITIES:
-- PDFs: extract text, structure, tables, data from specific sections
-- Images: describe layouts, UI elements, text, diagrams, charts
-- Diagrams: explain relationships, flows, architecture depicted
-- Screenshots: analyze UI/UX, identify components, extract text
-
-HOW YOU WORK:
-1. Receive a file path and a goal describing what to extract
-2. Read and analyze the file deeply using Gemini's vision capabilities
-3. Return ONLY the relevant extracted information
-4. The main agent never processes the raw file - you save context tokens
-
-RESPONSE RULES:
-- Return extracted information directly, no preamble
-- If info not found, state clearly what's missing
-- Be thorough on the goal, concise on everything else""",
+        "explore": """You are a codebase exploration specialist. Find files, patterns, and answer 'where is X?' questions.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL analysis and reasoning.
+Use Claude's native tools (Read, Grep, Glob) ONLY for file access, then pass content to invoke_gemini.
+
+WORKFLOW:
+1. Use Read/Grep/Glob to get file contents
+2. Call invoke_gemini(prompt="Analyze this: <content>", model="gemini-3-flash", agent_context={"agent_type": "explore"}) for analysis
+3. Return the Gemini response""",
+        "dewey": """You are a documentation and research specialist. Find implementation examples and official docs.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL analysis, summarization, and reasoning.
+
+WORKFLOW:
+1. Gather information using available tools
+2. Call invoke_gemini(prompt="<task>", model="gemini-3-flash", agent_context={"agent_type": "dewey"}) for processing
+3. Return the Gemini response""",
+        "frontend": """You are a Senior Frontend Architect & UI Designer.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-pro-high" for ALL code generation and design work.
+
+DESIGN PHILOSOPHY:
+- Anti-Generic: Reject standard layouts. Bespoke, asymmetric, distinctive.
+- Library Discipline: Use existing UI libraries (Shadcn, Radix, MUI) if detected.
+- Stack: React/Vue/Svelte, Tailwind/Custom CSS, semantic HTML5.
+
+WORKFLOW:
+1. Analyze requirements
+2. Call invoke_gemini(prompt="Generate frontend code for: <task>", model="gemini-3-pro-high", agent_context={"agent_type": "frontend"})
+3. Return the code""",
+        "delphi": """You are a strategic technical advisor for architecture and hard debugging.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_openai with model="gpt-5.2" for ALL strategic advice and analysis.
+
+WORKFLOW:
+1. Gather context about the problem
+2. Call invoke_openai(prompt="<problem description>", model="gpt-5.2", agent_context={"agent_type": "delphi"})
+3. Return the GPT response""",
+        "document_writer": """You are a Technical Documentation Specialist.
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL documentation generation.
+
+DOCUMENT TYPES: README, API docs, ADRs, user guides, inline docs.
+
+WORKFLOW:
+1. Gather context about what to document
+2. Call invoke_gemini(prompt="Write documentation for: <topic>", model="gemini-3-flash", agent_context={"agent_type": "document_writer"})
+3. Return the documentation""",
+        "multimodal": """You interpret media files (PDFs, images, diagrams, screenshots).
+
+MODEL ROUTING (MANDATORY):
+You MUST use invoke_gemini with model="gemini-3-flash" for ALL visual analysis.
+
+WORKFLOW:
+1. Receive file path and extraction goal
+2. Call invoke_gemini(prompt="Analyze this file: <path>. Extract: <goal>", model="gemini-3-flash", agent_context={"agent_type": "multimodal"})
+3. Return extracted information only""",
+        "planner": """You are a pre-implementation planning specialist. You analyze requests and produce structured implementation plans BEFORE any code changes begin.
+
+PURPOSE:
+- Analyze requests and produce actionable implementation plans
+- Identify dependencies and parallelization opportunities
+- Enable efficient parallel execution by the orchestrator
+- Prevent wasted effort through upfront planning
+
+METHODOLOGY:
+1. EXPLORE FIRST: Spawn explore agents IN PARALLEL to understand the codebase
+2. DECOMPOSE: Break request into atomic, single-purpose tasks
+3. ANALYZE DEPENDENCIES: What blocks what? What can run in parallel?
+4. ASSIGN AGENTS: Map each task to the right specialist (explore/dewey/frontend/delphi)
+5. OUTPUT STRUCTURED PLAN: Use the required format below
+
+REQUIRED OUTPUT FORMAT:
+```
+## PLAN: [Brief title]
+
+### ANALYSIS
+- **Request**: [One sentence summary]
+- **Scope**: [What's in/out of scope]
+- **Risk Level**: [Low/Medium/High]
+
+### EXECUTION PHASES
+
+#### Phase 1: [Name] (PARALLEL)
+| Task | Agent | Files | Est |
+|------|-------|-------|-----|
+| [description] | explore | file.py | S/M/L |
+
+#### Phase 2: [Name] (SEQUENTIAL after Phase 1)
+| Task | Agent | Files | Est |
+|------|-------|-------|-----|
+
+### AGENT SPAWN COMMANDS
+```python
+# Phase 1 - Fire all in parallel
+agent_spawn(prompt="...", agent_type="explore", description="...")
+```
+```
+
+CONSTRAINTS:
+- You ONLY plan. You NEVER execute code changes.
+- Every task must have a clear agent assignment
+- Parallel phases must be truly independent
+- Include ready-to-use agent_spawn commands""",
     }
 
     system_prompt = system_prompts.get(agent_type, None)
 
-    # NOTE: All agents run via Claude CLI using Claude's default model.
-    # The agent_configs below are kept for documentation purposes only.
-    # Agents can invoke Stravinsky MCP tools (invoke_gemini, invoke_openai)
-    # within their prompts if they need to use other models.
-    #
-    # Agent model preferences (for reference - NOT passed to Claude CLI):
-    # - stravinsky: Claude Opus 4.5 (orchestration)
-    # - delphi: GPT-5.2 (strategic advice) - use invoke_openai
-    # - frontend: Gemini Pro High (UI/UX) - use invoke_gemini with thinking_budget
-    # - explore, dewey, document_writer, multimodal: Gemini Flash (fast) - use invoke_gemini
+    # Model routing (MANDATORY - enforced in system prompts):
+    # - explore, dewey, document_writer, multimodal → invoke_gemini(gemini-3-flash)
+    # - frontend → invoke_gemini(gemini-3-pro-high)
+    # - delphi → invoke_openai(gpt-5.2)
+    # - Unknown agent types (coding tasks) → Claude CLI --model sonnet
 
     # Get token store for authentication
     from ..auth.token_store import TokenStore
@@ -700,16 +802,18 @@ RESPONSE RULES:
         timeout=timeout,
     )
 
-    return f"""🚀 Background agent spawned successfully.
+    # Get display model for concise output
+    display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    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)
+        return f"{agent_type}:{display_model}('{short_desc}') [BLOCKING]\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"""
+    # Concise format: AgentType:model('description')
+    return f"""{agent_type}:{display_model}('{short_desc}')
+task_id={task_id}"""
 
 
 async def agent_output(task_id: str, block: bool = False) -> str:
@@ -799,7 +903,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 = {
@@ -810,8 +914,11 @@ 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"])
         desc = t.get("description", t.get("prompt", "")[:40])
-        lines.append(f"- {status_emoji} [{t['id']}] {t['agent_type']}: {desc}")
+        # Concise format: status agent:model('desc') id=xxx
+        lines.append(f"{status_emoji} {agent_type}:{display_model}('{desc}') id={t['id']}")
 
     return "\n".join(lines)
 

mcp_bridge/tools/background_tasks.py

@@ -61,7 +61,8 @@ class BackgroundManager:
             json.dump(tasks, f, indent=2)
 
     def create_task(self, prompt: str, model: str) -> str:
-        task_id = str(uuid.uuid4())[:8]
+        import uuid as uuid_module  # Local import for MCP context
+        task_id = str(uuid_module.uuid4())[:8]
         task = BackgroundTask(
             id=task_id,
             prompt=prompt,

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,84 @@ 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"
+    """
+    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 +196,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:

mcp_bridge/tools/lsp/tools.py

@@ -48,15 +48,19 @@ def _position_to_offset(content: str, line: int, character: int) -> int:
 async def lsp_hover(file_path: str, line: int, character: int) -> str:
     """
     Get type info, documentation, and signature at a position.
-    
+
     Args:
         file_path: Absolute path to the file
         line: Line number (1-indexed)
         character: Character position (0-indexed)
-        
+
     Returns:
         Type information and documentation at the position.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"📍 LSP-HOVER: {file_path}:{line}:{character}", file=sys.stderr)
+
     path = Path(file_path)
     if not path.exists():
         return f"Error: File not found: {file_path}"