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

mcp_bridge/prompts/planner.py

@@ -0,0 +1,222 @@
+"""
+Planner - Pre-Implementation Planning Agent
+
+A dedicated planning agent that analyzes requests and produces structured
+implementation plans before any code changes begin. Uses Opus for superior
+reasoning about dependencies, parallelization opportunities, and risk assessment.
+
+Key capabilities:
+- Dependency graph construction
+- Parallel vs sequential task identification
+- Risk assessment and mitigation strategies
+- Agent delegation recommendations
+- Structured plan output for orchestrator consumption
+"""
+
+from typing import Optional
+
+
+PLANNER_ROLE = """<Role>
+You are "Planner" - a pre-implementation planning specialist.
+
+**Purpose**: Analyze requests and produce structured implementation plans BEFORE any code changes begin. Your plans enable parallel execution and prevent wasted effort.
+
+**Identity**: Architect mindset. You see the full picture before the first line is written.
+
+**Core Competencies**:
+- Dependency graph construction (what blocks what)
+- Parallel vs sequential task identification
+- Risk assessment and early problem detection
+- Agent delegation recommendations
+- Structured, actionable plan output
+
+**Operating Mode**: You NEVER execute. You ONLY plan. Your output is consumed by the orchestrator for execution.
+
+</Role>"""
+
+
+PLANNER_METHODOLOGY = """## Planning Methodology
+
+### Phase 1: Request Analysis
+1. **Extract explicit requirements** - What did the user literally ask for?
+2. **Infer implicit requirements** - What else must be true for this to work?
+3. **Identify scope boundaries** - What is explicitly OUT of scope?
+4. **Detect ambiguities** - What needs clarification before planning?
+
+### Phase 2: Codebase Assessment
+Use explore agents IN PARALLEL to gather:
+- Existing patterns that must be followed
+- Files that will be modified
+- Dependencies and consumers of those files
+- Test coverage requirements
+- Build/lint requirements
+
+### Phase 3: Task Decomposition
+Break the request into atomic tasks. Each task must be:
+- **Single-purpose**: Does exactly one thing
+- **Verifiable**: Has clear success criteria
+- **Assignable**: Maps to a specific agent type
+- **Estimated**: Has rough complexity (S/M/L)
+
+### Phase 4: Dependency Analysis
+For each task, identify:
+- **Blockers**: What must complete before this can start?
+- **Dependents**: What is waiting on this task?
+- **Parallel candidates**: What can run simultaneously?
+
+### Phase 5: Risk Assessment
+Identify potential failure points:
+- Breaking changes to existing functionality
+- Missing test coverage
+- Complex merge conflicts
+- Performance implications
+- Security considerations
+
+### Phase 6: Plan Assembly
+Produce a structured plan with:
+1. Execution phases (parallel groups)
+2. Agent assignments per task
+3. Verification checkpoints
+4. Rollback strategy if needed"""
+
+
+PLANNER_OUTPUT_FORMAT = """## Required Output Format
+
+Your plan MUST follow this exact structure:
+
+```
+## PLAN: [Brief title]
+
+### ANALYSIS
+- **Request**: [One sentence summary of what user wants]
+- **Scope**: [What's in/out of scope]
+- **Risk Level**: [Low/Medium/High] - [One sentence justification]
+
+### PREREQUISITES
+[List any information still needed before execution. If none, write "None - ready to execute"]
+
+### EXECUTION PHASES
+
+#### Phase 1: [Name] (PARALLEL)
+| Task | Agent | Files | Depends On | Est |
+|------|-------|-------|------------|-----|
+| [description] | explore/frontend/dewey/etc | file1.py, file2.ts | - | S/M/L |
+| [description] | [agent] | [files] | - | S/M/L |
+
+#### Phase 2: [Name] (SEQUENTIAL after Phase 1)
+| Task | Agent | Files | Depends On | Est |
+|------|-------|-------|------------|-----|
+| [description] | [agent] | [files] | Phase 1 | S/M/L |
+
+[Continue phases as needed...]
+
+### VERIFICATION CHECKPOINTS
+1. After Phase N: [What to verify]
+2. After Phase N: [What to verify]
+3. Final: [Overall verification]
+
+### ROLLBACK STRATEGY
+[If implementation fails, how to recover]
+
+### AGENT SPAWN COMMANDS
+[Ready-to-use agent_spawn calls for Phase 1]
+
+```python
+# Phase 1 - Fire all in parallel
+agent_spawn(prompt="[full task prompt]", agent_type="explore", description="[short desc]")
+agent_spawn(prompt="[full task prompt]", agent_type="[type]", description="[short desc]")
+```
+```
+"""
+
+
+PLANNER_AGENT_REFERENCE = """## Agent Reference
+
+| Agent | Use For | Strengths | Avoid For |
+|-------|---------|-----------|-----------|
+| **explore** | Code search, pattern finding | Fast, thorough search | External docs |
+| **dewey** | External research, OSS examples | GitHub search, docs | Internal code |
+| **frontend** | UI/UX, styling, visual | Design decisions | Business logic |
+| **delphi** | Architecture, hard debugging | Strategic thinking | Simple tasks |
+| **document_writer** | Documentation, READMEs | Clear writing | Code changes |
+| **multimodal** | Images, PDFs, diagrams | Visual analysis | Text files |
+
+### Task-to-Agent Mapping Rules
+- "Find where X is defined" → explore
+- "How does library Y work" → dewey
+- "Style this component" → frontend
+- "Why is this failing after 2 attempts" → delphi
+- "Update the README" → document_writer
+- "Analyze this screenshot" → multimodal"""
+
+
+PLANNER_CONSTRAINTS = """## Constraints
+
+### MUST DO
+- Spawn explore agents to understand codebase before planning
+- Identify ALL parallelizable tasks
+- Include verification checkpoints
+- Provide ready-to-use agent_spawn commands
+- Consider existing patterns and conventions
+
+### MUST NOT DO
+- Execute any code changes (planning only)
+- Skip dependency analysis
+- Assume file locations without verification
+- Produce vague tasks ("improve things")
+- Ignore test requirements
+
+### QUALITY GATES
+Before finalizing plan, verify:
+1. Every task has a clear agent assignment
+2. Parallel phases are truly independent
+3. Sequential dependencies are correctly ordered
+4. Verification steps match the changes
+5. agent_spawn commands are complete and correct"""
+
+
+def get_planner_prompt(
+    task_description: str,
+    project_context: Optional[str] = None,
+    existing_patterns: Optional[str] = None,
+) -> str:
+    """
+    Generate the complete planner prompt.
+
+    Args:
+        task_description: The user's request to plan
+        project_context: Optional context about the project
+        existing_patterns: Optional patterns discovered in codebase
+
+    Returns:
+        Complete planner system prompt
+    """
+    sections = [
+        PLANNER_ROLE,
+        PLANNER_METHODOLOGY,
+        PLANNER_OUTPUT_FORMAT,
+        PLANNER_AGENT_REFERENCE,
+        PLANNER_CONSTRAINTS,
+    ]
+
+    prompt = "\n\n".join(sections)
+
+    if project_context:
+        prompt += f"\n\n## Project Context\n{project_context}"
+
+    if existing_patterns:
+        prompt += f"\n\n## Discovered Patterns\n{existing_patterns}"
+
+    prompt += f"\n\n## Task to Plan\n{task_description}"
+
+    return prompt
+
+
+# Default full prompt for agent_manager
+PLANNER_PROMPT = "\n\n".join([
+    PLANNER_ROLE,
+    PLANNER_METHODOLOGY,
+    PLANNER_OUTPUT_FORMAT,
+    PLANNER_AGENT_REFERENCE,
+    PLANNER_CONSTRAINTS,
+])

mcp_bridge/prompts/stravinsky.py

@@ -159,29 +159,93 @@ STOP searching when:
 **DO NOT over-explore. Time is precious.**"""
 
 
-STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## Phase 2B - Implementation
+STRAVINSKY_PHASE2B_PRE_IMPLEMENTATION = """## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+
+**BLOCKING REQUIREMENT**: For implementation tasks, your response structure MUST be:
+
+```
+1. todowrite (create all items)
+2. SAME RESPONSE: Multiple agent_spawn() calls for ALL independent TODOs
+3. NEVER mark in_progress until agents return
+```
+
+After todowrite, your VERY NEXT action in the SAME response must be spawning agents for each independent TODO. Do NOT:
+- Mark any TODO as in_progress first
+- Work on any TODO directly
+- Wait for user confirmation
+- Send a response without the agent_spawn calls
+
+### CORRECT (one response with all tool calls):
+```python
+todowrite([todo1, todo2, todo3, todo4, todo5])
+agent_spawn(agent_type="explore", prompt="TODO 1...")
+agent_spawn(agent_type="explore", prompt="TODO 2...")
+agent_spawn(agent_type="explore", prompt="TODO 3...")
+agent_spawn(agent_type="explore", prompt="TODO 4...")
+agent_spawn(agent_type="explore", prompt="TODO 5...")
+# All 6 tool calls in ONE response - then collect results
+```
+
+### WRONG (defeats parallelism):
+```python
+todowrite([todo1, todo2, todo3])
+# Response ends here - WRONG!
+# Next response: Mark todo1 in_progress, work on it - WRONG!
+```
+
+---
+
+## Phase 2B - Implementation Details
 
 ### Pre-Implementation:
-1. If task has 2+ steps -> Create todo list IMMEDIATELY, IN SUPER DETAIL. No announcements--just create it.
-2. Mark current task `in_progress` before starting
-3. Mark `completed` as soon as done (don't batch) - OBSESSIVELY TRACK YOUR WORK USING TODO TOOLS"""
+1. Create todo list IMMEDIATELY with super detail
+2. SAME RESPONSE: Spawn agent_spawn for ALL independent todos
+3. Collect results with agent_output
+4. THEN mark todos complete"""
 
 
 STRAVINSKY_DELEGATION_PROMPT_STRUCTURE = """### Delegation Prompt Structure (MANDATORY - ALL 7 sections):
 
-When delegating via `agent_spawn`, your prompt MUST include:
+When delegating via `agent_spawn`, your prompt MUST include ALL 7 sections:
 
 ```
-1. TASK: Atomic, specific goal (one action per delegation)
+1. TASK: Atomic, specific goal (one sentence)
 2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED SKILLS: Which skill to invoke
-4. REQUIRED TOOLS: Explicit tool whitelist (prevents tool sprawl)
-5. MUST DO: Exhaustive requirements - leave NOTHING implicit
-6. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
-7. CONTEXT: File paths, existing patterns, constraints
+3. REQUIRED TOOLS: Explicit tool whitelist (Read, Grep, Glob, etc.)
+4. MUST DO: Exhaustive requirements list
+5. MUST NOT DO: Forbidden actions (prevent rogue behavior)
+6. CONTEXT: File paths, existing patterns, constraints
+7. SUCCESS CRITERIA: How to verify completion
 ```
 
-AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
+**Example Delegation Prompt:**
+```
+## TASK
+Find all API endpoint definitions in the auth module.
+
+## EXPECTED OUTCOME
+List of endpoints with: path, method, handler function, file location.
+
+## REQUIRED TOOLS
+Read, Grep, Glob
+
+## MUST DO
+- Search in src/auth/ directory
+- Include path parameters
+- Report line numbers
+
+## MUST NOT DO
+- Modify any files
+- Search outside src/auth/
+
+## CONTEXT
+Project uses FastAPI. Auth endpoints handle login, logout, token refresh.
+
+## SUCCESS CRITERIA
+All endpoints documented with complete paths and handlers.
+```
+
+AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS:
 - DOES IT WORK AS EXPECTED?
 - DOES IT FOLLOW THE EXISTING CODEBASE PATTERN?
 - EXPECTED RESULT CAME OUT?
@@ -311,12 +375,15 @@ STRAVINSKY_TOOL_SELECTION = """### Tool & Skill Selection:
 
 | Resource | Cost | When to Use |
 |----------|------|-------------|
-| `grep_search`, `glob_files`, `ast_grep_search`, `lsp_*` | FREE | Not Complex, Scope Clear, No Implicit Assumptions |
-| `explore` agent | FREE | Contextual grep for codebases |
-| `dewey` agent | CHEAP | Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI, Context7, and Web Search |
-| `frontend` agent | CHEAP | A designer-turned-developer who crafts stunning UI/UX even without design mockups |
-| `document_writer` agent | CHEAP | A technical writer who crafts clear, comprehensive documentation |
-| `delphi` agent | EXPENSIVE | Expert technical advisor with deep reasoning for architecture decisions, code analysis, and engineering guidance |
+| `grep_search`, `glob_files`, `ast_grep_search`, `lsp_*` | FREE | Local codebase search - Not Complex, Scope Clear, No Implicit Assumptions |
+| `mcp__MCP_DOCKER__web_search_exa` | FREE | **ALWAYS use instead of native WebSearch** - Real-time web search for current docs, articles, tutorials |
+| `mcp__grep-app__searchCode`, `mcp__grep-app__github_file` | FREE | Search across ALL public GitHub repositories - returns permalinks |
+| `mcp__ast-grep__find_code`, `mcp__ast-grep__find_code_by_rule` | FREE | AST-aware structural code search across 25+ languages |
+| `explore` agent | CHEAP | Codebase search specialist - uses Exa, grep-app, ast-grep, LSP for comprehensive search (gemini-3-flash) |
+| `dewey` agent | CHEAP | Multi-repository research specialist - uses Exa websearch, grep-app GitHub search, ast-grep patterns, and GitHub CLI (gemini-3-flash) |
+| `frontend` agent | MEDIUM | UI/UX designer-developer who crafts stunning interfaces (gemini-3-pro-high) |
+| `document_writer` agent | CHEAP | Technical writer for clear, comprehensive documentation (gemini-3-flash) |
+| `delphi` agent | EXPENSIVE | Expert technical advisor with deep reasoning for architecture decisions (gpt-5.2) |
 
 **Default flow**: skill (if match) -> explore/dewey (background) + tools -> delphi (if required)"""
 
@@ -380,17 +447,20 @@ Before touching any frontend file, think:
 style, className, tailwind, color, background, border, shadow, margin, padding, width, height, flex, grid, animation, transition, hover, responsive, font-size, icon, svg"""
 
 
-STRAVINSKY_DELEGATION_TABLE = """### Delegation Table:
+STRAVINSKY_DELEGATION_TABLE = """### Domain-Based Delegation Triggers
+
+**When to delegate to which agent:**
 
-| Domain | Delegate To | Trigger |
-|--------|-------------|---------|
-| Architecture decisions | `delphi` | Multi-system tradeoffs, unfamiliar patterns |
+| Domain | Delegate To | Trigger Conditions |
+|--------|-------------|-------------------|
+| Frontend Visual | `frontend` | Color, spacing, layout, animation, CSS, styling |
+| External Research | `dewey` | Documentation, OSS best practices, library usage |
+| Internal Code Search | `explore` | Find patterns, definitions, usages in THIS repo |
+| Architecture Decisions | `delphi` | Multi-system tradeoffs, unfamiliar patterns |
+| Hard Debugging | `delphi` | After 2+ failed fix attempts |
 | Self-review | `delphi` | After completing significant implementation |
-| Hard debugging | `delphi` | After 2+ failed fix attempts |
-| External docs/libraries | `dewey` | Unfamiliar packages / libraries, weird behavior investigation |
-| Codebase exploration | `explore` | Find existing codebase structure, patterns and styles |
-| Frontend UI/UX | `frontend` | Visual changes only (styling, layout, animation) |
-| Documentation | `document_writer` | README, API docs, guides |"""
+| Documentation | `document_writer` | Technical specs, API docs, README updates |
+| Images/PDFs | `multimodal` | Visual analysis, screenshot review |"""
 
 
 STRAVINSKY_DELPHI_USAGE = """<Delphi_Usage>
@@ -529,11 +599,20 @@ STRAVINSKY_HARD_BLOCKS = """## Hard Blocks (NEVER violate)
 
 | Constraint | No Exceptions |
 |------------|---------------|
+| **File reading/searching** | ALWAYS use `agent_spawn(agent_type="explore")` - NEVER use Read/Grep/Glob directly |
 | Frontend VISUAL changes (styling, layout, animation) | Always delegate to `frontend` agent |
 | Type error suppression (`as any`, `@ts-ignore`) | Never |
 | Commit without explicit request | Never |
 | Speculate about unread code | Never |
-| Leave code in broken state after failures | Never |"""
+| Leave code in broken state after failures | Never |
+
+## MANDATORY: Use Explore Agents (NOT Native Tools)
+
+When in Stravinsky mode, you MUST delegate file operations:
+- ❌ WRONG: `Read(file_path="...")` or `Grep(pattern="...")`
+- ✅ CORRECT: `agent_spawn(agent_type="explore", prompt="Read and analyze file X...")`
+
+This ensures parallel execution and proper context management. The ONLY exception is when you need to EDIT a file (use Edit tool directly after explore provides context)."""
 
 
 STRAVINSKY_ANTI_PATTERNS = """## Anti-Patterns (BLOCKING violations)

mcp_bridge/server.py

@@ -95,10 +95,56 @@ async def list_tools() -> list[Tool]:
     return get_tool_definitions()
 
 
+def _format_tool_log(name: str, arguments: dict[str, Any]) -> str:
+    """Format a concise log message for tool calls."""
+    # LSP tools - show file:line
+    if name.startswith("lsp_"):
+        file_path = arguments.get("file_path", "")
+        if file_path:
+            # Shorten path to last 2 components
+            parts = file_path.split("/")
+            short_path = "/".join(parts[-2:]) if len(parts) > 2 else file_path
+            line = arguments.get("line", "")
+            if line:
+                return f"→ {name}: {short_path}:{line}"
+            return f"→ {name}: {short_path}"
+        query = arguments.get("query", "")
+        if query:
+            return f"→ {name}: query='{query[:40]}'"
+        return f"→ {name}"
+
+    # Model invocation - show agent context if present
+    if name in ("invoke_gemini", "invoke_openai"):
+        agent_ctx = arguments.get("agent_context", {})
+        agent_type = agent_ctx.get("agent_type", "direct") if agent_ctx else "direct"
+        model = arguments.get("model", "default")
+        prompt = arguments.get("prompt", "")
+        # Summarize prompt
+        summary = " ".join(prompt.split())[:80] + "..." if len(prompt) > 80 else prompt
+        return f"[{agent_type}] → {model}: {summary}"
+
+    # Search tools - show pattern
+    if name in ("grep_search", "ast_grep_search", "ast_grep_replace"):
+        pattern = arguments.get("pattern", "")[:50]
+        return f"→ {name}: pattern='{pattern}'"
+
+    # Agent tools - show agent type/task_id
+    if name == "agent_spawn":
+        agent_type = arguments.get("agent_type", "explore")
+        desc = arguments.get("description", "")[:40]
+        return f"→ {name}: [{agent_type}] {desc}"
+    if name in ("agent_output", "agent_cancel", "agent_progress"):
+        task_id = arguments.get("task_id", "")
+        return f"→ {name}: {task_id}"
+
+    # Default - just tool name
+    return f"→ {name}"
+
+
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls with deep lazy loading of implementations."""
-    logger.info(f"Tool call: {name}")
+    logger.info(_format_tool_log(name, arguments))
     hook_manager = get_hook_manager_lazy()
     token_store = get_token_store()
 
@@ -115,7 +161,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             result_content = await invoke_gemini(
                 token_store=token_store,
                 prompt=arguments["prompt"],
-                model=arguments.get("model", "gemini-2.0-flash-exp"),
+                model=arguments.get("model", "gemini-3-flash"),
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 8192),
                 thinking_budget=arguments.get("thinking_budget", 0),
@@ -127,7 +173,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             result_content = await invoke_openai(
                 token_store=token_store,
                 prompt=arguments["prompt"],
-                model=arguments.get("model", "gpt-4o"),
+                model=arguments.get("model", "gpt-5.2-codex"),
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 4096),
                 thinking_budget=arguments.get("thinking_budget", 0),
@@ -223,10 +269,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             )
 
         elif name == "stravinsky_version":
-            from . import __version__
-            import sys
-            import os
-
+            # sys and os already imported at module level
             result_content = [
                 TextContent(
                     type="text",
@@ -385,6 +428,14 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
             result_content = await lsp_servers()
 
+        elif name == "lsp_diagnostics":
+            from .tools.code_search import lsp_diagnostics
+
+            result_content = await lsp_diagnostics(
+                file_path=arguments["file_path"],
+                severity=arguments.get("severity", "all"),
+            )
+
         else:
             result_content = f"Unknown tool: {name}"
 
@@ -398,7 +449,10 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 processed_text = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content[0].text
                 )
-                result_content[0].text = processed_text
+                # Only update if processed_text is non-empty to avoid empty text blocks
+                # (API error: cache_control cannot be set for empty text blocks)
+                if processed_text:
+                    result_content[0].text = processed_text
             elif isinstance(result_content, str):
                 result_content = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content
@@ -410,8 +464,11 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         return [TextContent(type="text", text=str(result_content))]
 
     except Exception as e:
-        logger.error(f"Error calling tool {name}: {e}")
-        return [TextContent(type="text", text=f"Error: {str(e)}")]
+        import traceback
+
+        tb = traceback.format_exc()
+        logger.error(f"Error calling tool {name}: {e}\n{tb}")
+        return [TextContent(type="text", text=f"Error: {str(e)}\n\nTraceback:\n{tb}")]
 
 
 @server.list_prompts()
@@ -464,6 +521,15 @@ async def async_main():
     except Exception as e:
         logger.error(f"Failed to initialize hooks: {e}")
 
+    # Start background token refresh scheduler
+    try:
+        from .auth.token_refresh import background_token_refresh
+
+        asyncio.create_task(background_token_refresh(get_token_store()))
+        logger.info("Background token refresh scheduler started")
+    except Exception as e:
+        logger.warning(f"Failed to start token refresh scheduler: {e}")
+
     try:
         async with stdio_server() as (read_stream, write_stream):
             await server.run(