stravinsky 0.1.2__py3-none-any.whl → 0.2.7__py3-none-any.whl

mcp_bridge/__init__.py

@@ -1,5 +1 @@
-# Stravinsky MCP Bridge
-# Provides MCP tools for OAuth-authenticated access to Gemini and OpenAI models
-
-__version__ = "0.1.0"
-__author__ = "David Andrews"
+__version__ = "0.2.7"

mcp_bridge/auth/cli.py

@@ -9,6 +9,7 @@ import sys
 import time
 
 from .token_store import TokenStore
+from ..tools.init import bootstrap_repo
 from .oauth import perform_oauth_flow as gemini_oauth, refresh_access_token as gemini_refresh
 from .openai_oauth import (
     perform_oauth_flow as openai_oauth,
@@ -184,6 +185,9 @@ def main():
         help="Provider to refresh token for",
     )
     
+    # init command
+    subparsers.add_parser("init", help="Bootstrap current repository for Stravinsky")
+    
     args = parser.parse_args()
     
     if not args.command:
@@ -200,6 +204,9 @@ def main():
         return cmd_status(token_store)
     elif args.command == "refresh":
         return cmd_refresh(args.provider, token_store)
+    elif args.command == "init":
+        print(bootstrap_repo())
+        return 0
     
     return 0
 

mcp_bridge/hooks/__init__.py

@@ -0,0 +1,28 @@
+"""
+Hooks initialization.
+Registers all Tier 1-3 hooks into the HookManager.
+"""
+
+from .manager import get_hook_manager
+from .truncator import output_truncator_hook
+from .edit_recovery import edit_error_recovery_hook
+from .directory_context import directory_context_hook
+from .compaction import context_compaction_hook
+from .budget_optimizer import budget_optimizer_hook
+
+def initialize_hooks():
+    """Register all available hooks."""
+    manager = get_hook_manager()
+    
+    # Tier 1
+    manager.register_post_tool_call(output_truncator_hook)
+    manager.register_post_tool_call(edit_error_recovery_hook)
+    
+    # Tier 2
+    manager.register_pre_model_invoke(directory_context_hook)
+    manager.register_pre_model_invoke(context_compaction_hook)
+    
+    # Tier 3
+    manager.register_pre_model_invoke(budget_optimizer_hook)
+
+# initialize_hooks()

mcp_bridge/hooks/budget_optimizer.py

@@ -0,0 +1,38 @@
+"""
+Thinking budget optimizer hook.
+Analyzes prompt complexity and adjusts thinking_budget for models that support it.
+"""
+
+from typing import Any, Dict, Optional
+
+REASONING_KEYWORDS = [
+    "architect", "design", "refactor", "debug", "complex", "optimize", 
+    "summarize", "analyze", "explain", "why", "review", "strangler"
+]
+
+async def budget_optimizer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Adjusts the thinking_budget based on presence of reasoning-heavy keywords.
+    """
+    model = params.get("model", "")
+    # Only applies to models that typically support reasoning budgets (Gemini 2.0 Thinking, GPT-o1, etc.)
+    if not any(m in model for m in ["thinking", "flash-thinking", "o1", "o3"]):
+        return None
+        
+    prompt = params.get("prompt", "").lower()
+    
+    # Simple heuristic
+    is_complex = any(keyword in prompt for keyword in REASONING_KEYWORDS)
+    
+    current_budget = params.get("thinking_budget", 0)
+    
+    if is_complex and current_budget < 4000:
+        # Increase budget for complex tasks
+        params["thinking_budget"] = 16000
+        return params
+    elif not is_complex and current_budget > 2000:
+        # Lower budget for simple tasks to save time/cost
+        params["thinking_budget"] = 2000
+        return params
+        
+    return None

mcp_bridge/hooks/compaction.py

@@ -0,0 +1,32 @@
+"""
+Preemptive context compaction hook.
+Monitors context size and injects optimization reminders.
+"""
+
+from typing import Any, Dict, Optional
+
+THRESHOLD_CHARS = 100000 # Roughly 25k-30k tokens for typical LLM text
+
+COMPACTION_REMINDER = """
+> **[SYSTEM ALERT - CONTEXT WINDOW NEAR LIMIT]**
+> The current conversation history is reaching its limits. Performance may degrade.
+> Please **STOP** and perform a **Session Compaction**:
+> 1. Summarize all work completed so far in a `TASK_STATE.md` (if not already done).
+> 2. List all pending todos.
+> 3. Clear unnecessary tool outputs from your reasoning.
+> 4. Keep your next responses concise and focused only on the current sub-task.
+"""
+
+async def context_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Checks prompt length and injects a compaction reminder if it's too large.
+    """
+    prompt = params.get("prompt", "")
+    
+    if len(prompt) > THRESHOLD_CHARS:
+        # Check if we haven't already injected the reminder recently
+        if "CONTEXT WINDOW NEAR LIMIT" not in prompt:
+            params["prompt"] = COMPACTION_REMINDER + prompt
+            return params
+            
+    return None

mcp_bridge/hooks/directory_context.py

@@ -0,0 +1,40 @@
+"""
+Directory context injector hook.
+Automatically finds and injects local AGENTS.md or README.md content based on the current context.
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+async def directory_context_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Search for AGENTS.md or README.md in the current working directory and inject them.
+    """
+    cwd = Path.cwd()
+    
+    # Check for AGENTS.md or README.md
+    target_files = ["AGENTS.md", "README.md"]
+    found_file = None
+    for filename in target_files:
+        if (cwd / filename).exists():
+            found_file = cwd / filename
+            break
+            
+    if not found_file:
+        return None
+        
+    try:
+        content = found_file.read_text()
+        # Injects as a special system reminder
+        injection = f"\n\n### Local Directory Context ({found_file.name}):\n{content}\n"
+        
+        # Modify the prompt if it exists in params
+        if "prompt" in params:
+            # Add to the beginning of the prompt as a context block
+            params["prompt"] = injection + params["prompt"]
+            return params
+    except Exception:
+        pass
+        
+    return None

mcp_bridge/hooks/edit_recovery.py

@@ -0,0 +1,41 @@
+"""
+Edit error recovery hook.
+Detects common mistakes in file editing and injects high-priority corrective directives.
+"""
+
+import re
+from typing import Any, Dict, Optional
+
+EDIT_ERROR_PATTERNS = [
+    r"oldString and newString must be different",
+    r"oldString not found",
+    r"oldString found multiple times",
+    r"Target content not found",
+    r"Multiple occurrences of target content found",
+]
+
+EDIT_RECOVERY_PROMPT = """
+> **[EDIT ERROR - IMMEDIATE ACTION REQUIRED]**
+> You made an Edit mistake. STOP and do this NOW:
+> 1. **READ** the file immediately to see its ACTUAL current state.
+> 2. **VERIFY** what the content really looks like (your assumption was wrong).
+> 3. **APOLOGIZE** briefly to the user for the error.
+> 4. **CONTINUE** with corrected action based on the real file content.
+> **DO NOT** attempt another edit until you've read and verified the file state.
+"""
+
+async def edit_error_recovery_hook(tool_name: str, arguments: Dict[str, Any], output: str) -> Optional[str]:
+    """
+    Analyzes tool output for edit errors and appends corrective directives.
+    """
+    # Check if this is an edit-related tool (handling both built-in and common MCP tools)
+    edit_tools = ["replace_file_content", "multi_replace_file_content", "write_to_file", "edit_file", "Edit"]
+    
+    # We also check the output content for common patterns even if the tool name doesn't match perfectly
+    is_edit_error = any(re.search(pattern, output, re.IGNORECASE) for pattern in EDIT_ERROR_PATTERNS)
+    
+    if is_edit_error or any(tool in tool_name for tool in edit_tools):
+        if any(re.search(pattern, output, re.IGNORECASE) for pattern in EDIT_ERROR_PATTERNS):
+            return output + EDIT_RECOVERY_PROMPT
+            
+    return None

mcp_bridge/hooks/manager.py

@@ -0,0 +1,77 @@
+"""
+Modular Hook System for Stravinsky.
+Provides interception points for tool calls and model invocations.
+"""
+
+import logging
+from typing import Any, Callable, Dict, List, Optional, Awaitable
+
+logger = logging.getLogger(__name__)
+
+class HookManager:
+    """
+    Manages the registration and execution of hooks.
+    """
+    _instance = None
+
+    def __init__(self):
+        self.pre_tool_call_hooks: List[Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]] = []
+        self.post_tool_call_hooks: List[Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]] = []
+        self.pre_model_invoke_hooks: List[Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]] = []
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def register_pre_tool_call(self, hook: Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]):
+        """Run before a tool is called. Can modify arguments or return early result."""
+        self.pre_tool_call_hooks.append(hook)
+
+    def register_post_tool_call(self, hook: Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]):
+        """Run after a tool call. Can modify or recover from tool output/error."""
+        self.post_tool_call_hooks.append(hook)
+
+    def register_pre_model_invoke(self, hook: Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]):
+        """Run before model invocation. Can modify prompt or parameters."""
+        self.pre_model_invoke_hooks.append(hook)
+
+    async def execute_pre_tool_call(self, tool_name: str, arguments: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Executes all pre-tool call hooks."""
+        current_args = arguments
+        for hook in self.pre_tool_call_hooks:
+            try:
+                modified_args = await hook(tool_name, current_args)
+                if modified_args is not None:
+                    current_args = modified_args
+            except Exception as e:
+                logger.error(f"[HookManager] Error in pre_tool_call hook {hook.__name__}: {e}")
+        return current_args
+
+    async def execute_post_tool_call(self, tool_name: str, arguments: Dict[str, Any], output: str) -> str:
+        """Executes all post-tool call hooks."""
+        current_output = output
+        for hook in self.post_tool_call_hooks:
+            try:
+                modified_output = await hook(tool_name, arguments, current_output)
+                if modified_output is not None:
+                    current_output = modified_output
+            except Exception as e:
+                logger.error(f"[HookManager] Error in post_tool_call hook {hook.__name__}: {e}")
+        return current_output
+
+    async def execute_pre_model_invoke(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Executes all pre-model invoke hooks."""
+        current_params = params
+        for hook in self.pre_model_invoke_hooks:
+            try:
+                modified_params = await hook(current_params)
+                if modified_params is not None:
+                    current_params = modified_params
+            except Exception as e:
+                logger.error(f"[HookManager] Error in pre_model_invoke hook {hook.__name__}: {e}")
+        return current_params
+
+def get_hook_manager() -> HookManager:
+    return HookManager.get_instance()

mcp_bridge/hooks/truncator.py

@@ -0,0 +1,19 @@
+"""
+Tool output truncator hook.
+Limits the size of tool outputs to prevent context bloat.
+"""
+
+from typing import Any, Dict, Optional
+
+async def output_truncator_hook(tool_name: str, arguments: Dict[str, Any], output: str) -> Optional[str]:
+    """
+    Truncates tool output if it exceeds a certain length.
+    """
+    MAX_LENGTH = 10000 # 10k characters limit
+    
+    if len(output) > MAX_LENGTH:
+        truncated = output[:MAX_LENGTH]
+        summary = f"\n\n... (Result truncated from {len(output)} chars to {MAX_LENGTH} chars) ..."
+        return truncated + summary
+        
+    return None

mcp_bridge/native_hooks/context.py

@@ -0,0 +1,38 @@
+import os
+import sys
+import json
+from pathlib import Path
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        prompt = data.get("prompt", "")
+    except Exception:
+        return
+
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    
+    # Files to look for
+    context_files = ["AGENTS.md", "README.md", "CLAUDE.md"]
+    found_context = ""
+
+    for f in context_files:
+        path = cwd / f
+        if path.exists():
+            try:
+                content = path.read_text()
+                found_context += f"\n\n--- LOCAL CONTEXT: {f} ---\n{content}\n"
+                break # Only use one for brevity
+            except Exception:
+                pass
+
+    if found_context:
+        # Prepend context to prompt
+        # We wrap the user prompt to distinguish it
+        new_prompt = f"{found_context}\n\n[USER PROMPT]\n{prompt}"
+        print(new_prompt)
+    else:
+        print(prompt)
+
+if __name__ == "__main__":
+    main()

mcp_bridge/native_hooks/edit_recovery.py

@@ -0,0 +1,46 @@
+import os
+import sys
+import json
+import re
+
+def main():
+    # Claude Code PostToolUse inputs via Environment Variables
+    tool_name = os.environ.get("CLAUDE_TOOL_NAME")
+    
+    # We only care about Edit/MultiEdit
+    if tool_name not in ["Edit", "MultiEdit"]:
+        return
+
+    # Read from stdin (Claude Code passes the tool response via stdin for some hook types, 
+    # but for PostToolUse it's often better to check the environment variable if available.
+    # Actually, the summary says input is a JSON payload.
+    try:
+        data = json.load(sys.stdin)
+        tool_response = data.get("tool_response", "")
+    except Exception:
+        # Fallback to direct string if not JSON
+        return
+
+    # Error patterns
+    error_patterns = [
+        r"oldString not found",
+        r"oldString matched multiple times",
+        r"line numbers out of range"
+    ]
+
+    recovery_needed = any(re.search(p, tool_response, re.IGNORECASE) for p in error_patterns)
+
+    if recovery_needed:
+        correction = (
+            "\n\n[SYSTEM RECOVERY] It appears the Edit tool failed to find the target string. "
+            "Please call 'Read' on the file again to verify the current content, "
+            "then ensure your 'oldString' is an EXACT match including all whitespace."
+        )
+        # For PostToolUse, stdout is captured and appended/replaces output
+        print(tool_response + correction)
+    else:
+        # No change
+        print(tool_response)
+
+if __name__ == "__main__":
+    main()

mcp_bridge/native_hooks/truncator.py

@@ -0,0 +1,23 @@
+import os
+import sys
+import json
+
+MAX_CHARS = 10000
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        tool_response = data.get("tool_response", "")
+    except Exception:
+        return
+
+    if len(tool_response) > MAX_CHARS:
+        header = f"[TRUNCATED - {len(tool_response)} chars reduced to {MAX_CHARS}]\n"
+        footer = "\n...[TRUNCATED]"
+        truncated = tool_response[:MAX_CHARS]
+        print(header + truncated + footer)
+    else:
+        print(tool_response)
+
+if __name__ == "__main__":
+    main()

mcp_bridge/prompts/stravinsky.py

@@ -18,8 +18,9 @@ You are "Stravinsky" - Powerful AI Agent with orchestration capabilities.
 - Parsing implicit requirements from explicit requests
 - Adapting to codebase maturity (disciplined vs chaotic)
 - Delegating specialized work to the right subagents
-- **AGGRESSIVE PARALLEL EXECUTION** - spawn multiple subagents simultaneously
-- Follows user instructions. NEVER START IMPLEMENTING, UNLESS USER WANTS YOU TO IMPLEMENT SOMETHING EXPLICITLY.
+    **AGGRESSIVE PARALLEL EXECUTION (ULTRAWORK)** - spawn multiple subagents simultaneously for research, implementation, and testing.
+    - **LSP-FIRST RESEARCH**: You MUST use LSP tools (`lsp_hover`, `lsp_goto_definition`, etc.) before falling back to `grep` or `rg` for Python/TypeScript.
+    - Follows user instructions. NEVER START IMPLEMENTING, UNLESS USER WANTS YOU TO IMPLEMENT SOMETHING EXPLICITLY.
 
 **Operating Mode**: You NEVER work alone when specialists are available.
 **DEFAULT: SPAWN PARALLEL AGENTS for any task with 2+ independent components.**
@@ -29,13 +30,14 @@ You are "Stravinsky" - Powerful AI Agent with orchestration capabilities.
 - Deep research → `agent_spawn` parallel background agents with full tool access
 - Complex tasks → Break into components and spawn agents IN PARALLEL
 
-## ULTRATHINK Protocol
+## ULTRAWORK & ULTRATHINK Protocol
 
-When the user says **"ULTRATHINK"**, **"think harder"**, or **"think hard"**:
-1. **Override brevity** - engage in exhaustive, deep-level reasoning
-2. **Multi-dimensional analysis** - examine through psychological, technical, accessibility, scalability lenses
-3. **Maximum depth** - if reasoning feels easy, dig deeper until logic is irrefutable
-4. **Extended thinking budget** - take the time needed for thorough deliberation
+When the user says **"ULTRAWORK"**, **"ULTRATHINK"**, **"think harder"**, or **"think hard"**:
+1. **Engage ULTRAWORK** - Immediately spawn 2-4 sub-agents to handle different aspects of the task (research, plan, implementation, verification) in parallel.
+2. **Override brevity** - engage in exhaustive, deep-level reasoning
+3. **Multi-dimensional analysis** - examine through psychological, technical, accessibility, scalability lenses
+4. **Maximum depth** - if reasoning feels easy, dig deeper until logic is irrefutable
+5. **Extended thinking budget** - take the time needed for thorough deliberation
 
 </Role>"""
 
@@ -99,18 +101,19 @@ Before following existing patterns, assess whether they're worth following.
 
 STRAVINSKY_DELEGATION = """## Phase 2 - Parallel Agents & Delegation (DEFAULT BEHAVIOR)
 
-### DEFAULT: Spawn Parallel Agents
+### DEFAULT: Spawn Parallel Agents (ULTRAWORK)
 
 For ANY task with 2+ independent components:
-1. **Immediately spawn parallel agents** using `agent_spawn`
-2. Continue working on the main task while agents execute
-3. Use `agent_progress` to monitor running agents
-4. Collect results with `agent_output` when ready
+1. **Immediately spawn parallel agents** using `agent_spawn`.
+2. **LSP ALWAYS**: For code tasks, ensure at least one agent is dedicated to LSP-based symbol resolution.
+3. Continue working on the main task while agents execute.
+4. Use `agent_progress` to monitor running agents.
+5. Collect results with `agent_output` when ready.
 
-**Examples of parallel spawning:**
-- "Add feature X" → Spawn: 1) research agent for examples, 2) explore agent for similar patterns, while you plan
-- "Fix bug in Y" → Spawn: 1) debug agent to search logs, 2) explore agent for related code
-- "Build component Z" → Spawn: 1) librarian for docs, 2) frontend agent for UI patterns
+**Examples of ULTRAWORK parallel spawning:**
+- "Add feature X" → Spawn: 1) `explore` agent for LSP/Symbol research, 2) `librarian` for external docs, 3) `delphi` for architecture plan.
+- "Fix bug in Y" → Spawn: 1) `debug` agent for log analysis, 2) `explore` agent with LSP to trace call stack.
+- "Build component Z" → Spawn: 1) `frontend` agent for UI, 2) `explore` for backend integration patterns.
 
 ### Agent Types:
 | Type | Purpose |
@@ -151,9 +154,16 @@ When delegating to external models or agents:
 ```
 
 ### After Delegation:
-- VERIFY the results work as expected
-- VERIFY it follows existing codebase patterns
 - VERIFY expected result came out
+
+### Agent Reliability Protocol (CRITICAL)
+
+If a background agent fails or times out:
+1. **Analyze Failure**: Use `agent_progress` to see the last available output and logs.
+2. **Handle Timout**: If status is `failed` with a timeout error, break the task into smaller sub-tasks and respawn multiple agents. Increasing `timeout` is a secondary option.
+3. **Handle Error**: If the agent errored, refine the prompt to be more specific or provide more context, then use `agent_retry`.
+4. **Zombie Recovery**: If `agent_progress` detects a "Zombie" (process died), immediately `agent_retry`.
+5. **Escalation**: If a task fails 2 consecutive times, stop and ask the user or consult Delphi.
 """