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

mcp_bridge/tools/agent_manager.py

@@ -36,6 +36,7 @@ class AgentTask:
     result: Optional[str] = None
     error: Optional[str] = None
     pid: Optional[int] = None
+    timeout: int = 300  # Default 5 minutes
     progress: Optional[Dict[str, Any]] = None  # tool calls, last update
 
 
@@ -117,6 +118,7 @@ class AgentManager:
     
     def spawn(
         self,
+        token_store: Any,
         prompt: str,
         agent_type: str = "explore",
         description: str = "",
@@ -124,6 +126,7 @@ class AgentManager:
         system_prompt: Optional[str] = None,
         model: str = "gemini-3-flash",
         thinking_budget: int = 0,
+        timeout: int = 300,
     ) -> str:
         """
         Spawn a new background agent.
@@ -135,6 +138,7 @@ class AgentManager:
             parent_session_id: Optional parent session for notifications
             system_prompt: Optional custom system prompt
             model: Model to use (gemini-3-flash, claude, etc.)
+            timeout: Maximum execution time in seconds
             
         Returns:
             Task ID for tracking
@@ -149,6 +153,7 @@ class AgentManager:
             status="pending",
             created_at=datetime.now().isoformat(),
             parent_session_id=parent_session_id,
+            timeout=timeout,
         )
         
         # Persist task
@@ -157,18 +162,20 @@ class AgentManager:
         self._save_tasks(tasks)
         
         # Start background execution
-        self._execute_agent(task_id, prompt, agent_type, system_prompt, model, thinking_budget)
+        self._execute_agent(task_id, token_store, prompt, agent_type, system_prompt, model, thinking_budget, timeout)
         
         return task_id
     
     def _execute_agent(
         self,
         task_id: str,
+        token_store: Any,
         prompt: str,
         agent_type: str,
         system_prompt: Optional[str] = None,
         model: str = "gemini-3-flash",
         thinking_budget: int = 0,
+        timeout: int = 300,
     ):
         """Execute agent in background thread."""
         
@@ -202,12 +209,25 @@ class AgentManager:
                     asyncio.set_event_loop(loop)
                     try:
                         result = loop.run_until_complete(
-                            invoke_gemini(
-                                prompt=full_prompt, 
-                                model=model,
-                                thinking_budget=thinking_budget
+                            asyncio.wait_for(
+                                invoke_gemini(
+                                    token_store=token_store,
+                                    prompt=full_prompt, 
+                                    model=model,
+                                    thinking_budget=thinking_budget
+                                ),
+                                timeout=timeout
                             )
                         )
+                    except asyncio.TimeoutError:
+                        self._update_task(
+                            task_id,
+                            status="failed",
+                            error=f"Task timed out after {timeout} seconds",
+                            completed_at=datetime.now().isoformat()
+                        )
+                        logger.error(f"[AgentManager] Gemini agent {task_id} timed out")
+                        return
                     finally:
                         loop.close()
                     
@@ -251,8 +271,23 @@ class AgentManager:
                     self._processes[task_id] = process
                     self._update_task(task_id, pid=process.pid)
                     
-                    # Wait for completion
-                    return_code = process.wait()
+                    # Wait for completion with timeout
+                    try:
+                        return_code = process.wait(timeout=timeout)
+                    except subprocess.TimeoutExpired:
+                        try:
+                            os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+                        except:
+                            process.kill()
+                        
+                        self._update_task(
+                            task_id,
+                            status="failed",
+                            error=f"Task timed out after {timeout} seconds",
+                            completed_at=datetime.now().isoformat()
+                        )
+                        logger.error(f"[AgentManager] Claude agent {task_id} timed out")
+                        return
                     
                     # Read output
                     result = ""
@@ -435,6 +470,23 @@ Use `agent_output` with block=true to wait for completion."""
         status = task["status"]
         description = task.get("description", "")
         agent_type = task.get("agent_type", "unknown")
+        pid = task.get("pid")
+        
+        # Zombie Detection: If running but process is gone
+        if status == "running" and pid:
+            try:
+                import psutil
+                if not psutil.pid_exists(pid):
+                    status = "failed"
+                    self._update_task(
+                        task_id, 
+                        status="failed", 
+                        error="Agent process died unexpectedly (Zombie detected)",
+                        completed_at=datetime.now().isoformat()
+                    )
+                    logger.warning(f"[AgentManager] Zombie agent detected: {task_id}")
+            except ImportError:
+                pass 
         
         # Read recent output
         output_content = ""
@@ -507,6 +559,7 @@ async def agent_spawn(
     description: str = "",
     model: str = "gemini-3-flash",
     thinking_budget: int = 0,
+    timeout: int = 300,
 ) -> str:
     """
     Spawn a background agent.
@@ -516,6 +569,8 @@ async def agent_spawn(
         agent_type: Type of agent (explore, dewey, frontend, delphi)
         description: Short description shown in status
         model: Model to use (gemini-3-flash, gemini-2.0-flash, claude)
+        thinking_budget: Reserved reasoning tokens
+        timeout: Execution timeout in seconds
         
     Returns:
         Task ID and instructions
@@ -563,6 +618,7 @@ ULTRATHINK MODE (when user says "ULTRATHINK" or "think harder"):
         system_prompt=system_prompt,
         model=model,
         thinking_budget=thinking_budget,
+        timeout=timeout,
     )
     
     return f"""🚀 Background agent spawned successfully.
@@ -594,6 +650,42 @@ async def agent_output(task_id: str, block: bool = False) -> str:
     return manager.get_output(task_id, block=block)
 
 
+async def agent_retry(
+    task_id: str,
+    new_prompt: Optional[str] = None,
+    new_timeout: Optional[int] = None,
+) -> str:
+    """
+    Retry a failed or timed-out background agent.
+    
+    Args:
+        task_id: The ID of the task to retry
+        new_prompt: Optional refined prompt for the retry
+        new_timeout: Optional new timeout in seconds
+        
+    Returns:
+        New Task ID and status
+    """
+    manager = get_manager()
+    task = manager.get_task(task_id)
+    
+    if not task:
+        return f"❌ Task {task_id} not found."
+    
+    if task["status"] in ["running", "pending"]:
+        return f"⚠️ Task {task_id} is still {task['status']}. Cancel it first if you want to retry."
+    
+    prompt = new_prompt or task["prompt"]
+    timeout = new_timeout or task.get("timeout", 300)
+    
+    return await agent_spawn(
+        prompt=prompt,
+        agent_type=task["agent_type"],
+        description=f"Retry of {task_id}: {task['description']}",
+        timeout=timeout
+    )
+
+
 async def agent_cancel(task_id: str) -> str:
     """
     Cancel a running background agent.

mcp_bridge/tools/continuous_loop.py

@@ -0,0 +1,67 @@
+"""
+Continuous Loop (Ralph Loop) for Stravinsky.
+
+Allows Stravinsky to operate in an autonomous loop until criteria are met.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+async def enable_ralph_loop(goal: str, max_iterations: int = 10) -> str:
+    """
+    Enable continuous processing until a goal is met.
+    
+    Args:
+        goal: The goal to achieve and verify.
+        max_iterations: Maximum number of iterations before stopping.
+    """
+    project_root = Path.cwd()
+    settings_file = project_root / ".claude" / "settings.json"
+    
+    settings = {}
+    if settings_file.exists():
+        try:
+            settings = json.loads(settings_file.read_text())
+        except:
+            pass
+            
+    if "hooks" not in settings:
+        settings["hooks"] = {}
+        
+    # Set the Stop hook to re-trigger if goal not met
+    # Note: Stravinsky's prompt will handle the internal logic 
+    # but the presence of this hook signals "Continue" to Claude Code.
+    settings["hooks"]["Stop"] = [
+        {
+            "type": "command",
+            "command": f'echo "Looping for goal: {goal}"',
+        }
+    ]
+    
+    settings_file.parent.mkdir(parents=True, exist_ok=True)
+    settings_file.write_text(json.dumps(settings, indent=2))
+    
+    return f"🔄 Ralph Loop ENABLED. Goal: {goal}. Stravinsky will now process continuously until completion."
+
+async def disable_ralph_loop() -> str:
+    """Disable the autonomous loop."""
+    project_root = Path.cwd()
+    settings_file = project_root / ".claude" / "settings.json"
+    
+    if not settings_file.exists():
+        return "Ralph Loop is already disabled."
+        
+    try:
+        settings = json.loads(settings_file.read_text())
+        if "hooks" in settings and "Stop" in settings["hooks"]:
+            del settings["hooks"]["Stop"]
+            settings_file.write_text(json.dumps(settings, indent=2))
+            return "✅ Ralph Loop DISABLED."
+    except:
+        pass
+        
+    return "Failed to disable Ralph Loop or it was not active."

mcp_bridge/tools/init.py

@@ -0,0 +1,50 @@
+"""
+Repository bootstrap logic for Stravinsky.
+"""
+
+import logging
+from pathlib import Path
+from .templates import CLAUDE_MD_TEMPLATE, SLASH_COMMANDS
+
+logger = logging.getLogger(__name__)
+
+def bootstrap_repo(project_path: str | Path | None = None) -> str:
+    """
+    Bootstrap a repository for Stravinsky MCP usage.
+    
+    Creates:
+    - .claude/commands/ (with standard slash commands)
+    - Appends/Creates CLAUDE.md
+    """
+    root = Path(project_path or Path.cwd())
+    
+    # 1. Setup Slash Commands
+    commands_dir = root / ".claude" / "commands" / "stra"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    
+    commands_created = 0
+    for filename, content in SLASH_COMMANDS.items():
+        cmd_file = commands_dir / filename
+        if not cmd_file.exists():
+            cmd_file.write_text(content)
+            commands_created += 1
+            
+    # 2. Setup CLAUDE.md
+    claude_md = root / "CLAUDE.md"
+    if not claude_md.exists():
+        claude_md.write_text("# Project Notes\n\n" + CLAUDE_MD_TEMPLATE)
+        claude_msg = "Created CLAUDE.md"
+    else:
+        content = claude_md.read_text()
+        if "Stravinsky MCP" not in content:
+            with open(claude_md, "a") as f:
+                f.write("\n\n" + CLAUDE_MD_TEMPLATE)
+            claude_msg = "Updated CLAUDE.md with Stravinsky instructions"
+        else:
+            claude_msg = "CLAUDE.md already configured"
+            
+    return (
+        f"✅ Repository Initialized!\n"
+        f"- {claude_msg}\n"
+        f"- Installed {commands_created} new slash commands to .claude/commands/stra/"
+    )

mcp_bridge/tools/lsp/tools.py

@@ -74,10 +74,10 @@ import jedi
 script = jedi.Script(path='{file_path}')
 completions = script.infer({line}, {character})
 for c in completions[:1]:
-    print(f"Type: {{c.type}}")
-    print(f"Name: {{c.full_name}}")
+    logger.info(f"Type: {{c.type}}")
+    logger.info(f"Name: {{c.full_name}}")
     if c.docstring():
-        print(f"\\nDocstring:\\n{{c.docstring()[:500]}}")
+        logger.info(f"\\nDocstring:\\n{{c.docstring()[:500]}}")
 """
                 ],
                 capture_output=True,
@@ -133,7 +133,7 @@ import jedi
 script = jedi.Script(path='{file_path}')
 definitions = script.goto({line}, {character})
 for d in definitions:
-    print(f"{{d.module_path}}:{{d.line}}:{{d.column}} - {{d.full_name}}")
+    logger.info(f"{{d.module_path}}:{{d.line}}:{{d.column}} - {{d.full_name}}")
 """
                 ],
                 capture_output=True,
@@ -193,9 +193,9 @@ import jedi
 script = jedi.Script(path='{file_path}')
 references = script.get_references({line}, {character}, include_builtins=False)
 for r in references[:30]:
-    print(f"{{r.module_path}}:{{r.line}}:{{r.column}}")
+    logger.info(f"{{r.module_path}}:{{r.line}}:{{r.column}}")
 if len(references) > 30:
-    print(f"... and {{len(references) - 30}} more")
+    logger.info(f"... and {{len(references) - 30}} more")
 """
                 ],
                 capture_output=True,
@@ -243,7 +243,7 @@ script = jedi.Script(path='{file_path}')
 names = script.get_names(all_scopes=True, definitions=True)
 for n in names:
     indent = "  " * (n.get_line_code().count("    ") if n.get_line_code() else 0)
-    print(f"{{n.line:4d}} | {{indent}}{{n.type:10}} {{n.name}}")
+    logger.info(f"{{n.line:4d}} | {{indent}}{{n.type:10}} {{n.name}}")
 """
                 ],
                 capture_output=True,
@@ -356,12 +356,12 @@ import jedi
 script = jedi.Script(path='{file_path}')
 refs = script.get_references({line}, {character})
 if refs:
-    print(f"Symbol: {{refs[0].name}}")
-    print(f"Type: {{refs[0].type}}")
-    print(f"References: {{len(refs)}}")
-    print("✅ Rename is valid")
+    logger.info(f"Symbol: {{refs[0].name}}")
+    logger.info(f"Type: {{refs[0].type}}")
+    logger.info(f"References: {{len(refs)}}")
+    logger.info("✅ Rename is valid")
 else:
-    print("❌ No symbol found at position")
+    logger.info("❌ No symbol found at position")
 """
                 ],
                 capture_output=True,
@@ -413,9 +413,9 @@ import jedi
 script = jedi.Script(path='{file_path}')
 refactoring = script.rename({line}, {character}, new_name='{new_name}')
 for path, changed in refactoring.get_changed_files().items():
-    print(f"File: {{path}}")
-    print(changed[:500])
-    print("---")
+    logger.info(f"File: {{path}}")
+    logger.info(changed[:500])
+    logger.info("---")
 """
                 ],
                 capture_output=True,

mcp_bridge/tools/model_invoke.py

@@ -5,13 +5,23 @@ These tools use OAuth tokens from the token store to authenticate
 API requests to external model providers.
 """
 
+import logging
 import time
 
+logger = logging.getLogger(__name__)
+
 import httpx
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception,
+)
 
 from ..auth.token_store import TokenStore
 from ..auth.oauth import refresh_access_token as gemini_refresh, ANTIGRAVITY_HEADERS
 from ..auth.openai_oauth import refresh_access_token as openai_refresh
+from ..hooks.manager import get_hook_manager
 
 
 async def _ensure_valid_token(token_store: TokenStore, provider: str) -> str:
@@ -71,6 +81,18 @@ async def _ensure_valid_token(token_store: TokenStore, provider: str) -> str:
     return access_token
 
 
+def is_retryable_exception(e: Exception) -> bool:
+    """Check if an exception is retryable (429 or 5xx)."""
+    if isinstance(e, httpx.HTTPStatusError):
+        return e.response.status_code == 429 or 500 <= e.response.status_code < 600
+    return False
+
+@retry(
+    stop=stop_after_attempt(5),
+    wait=wait_exponential(multiplier=1, min=4, max=60),
+    retry=retry_if_exception(is_retryable_exception),
+    before_sleep=lambda retry_state: logger.info(f"Rate limited or server error, retrying in {retry_state.next_action.sleep} seconds...")
+)
 async def invoke_gemini(
     token_store: TokenStore,
     prompt: str,
@@ -98,6 +120,24 @@ async def invoke_gemini(
         ValueError: If not authenticated with Gemini
         httpx.HTTPStatusError: If API request fails
     """
+    # Execute pre-model invoke hooks
+    params = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+    }
+    hook_manager = get_hook_manager()
+    params = await hook_manager.execute_pre_model_invoke(params)
+    
+    # Update local variables from possibly modified params
+    prompt = params["prompt"]
+    model = params["model"]
+    temperature = params["temperature"]
+    max_tokens = params["max_tokens"]
+    thinking_budget = params["thinking_budget"]
+
     access_token = await _ensure_valid_token(token_store, "gemini")
 
     # Gemini API endpoint with OAuth
@@ -156,6 +196,12 @@ async def invoke_gemini(
             return f"Error parsing response: {e}"
 
 
+@retry(
+    stop=stop_after_attempt(5),
+    wait=wait_exponential(multiplier=1, min=4, max=60),
+    retry=retry_if_exception(is_retryable_exception),
+    before_sleep=lambda retry_state: logger.info(f"Rate limited or server error, retrying in {retry_state.next_action.sleep} seconds...")
+)
 async def invoke_openai(
     token_store: TokenStore,
     prompt: str,
@@ -181,6 +227,24 @@ async def invoke_openai(
         ValueError: If not authenticated with OpenAI
         httpx.HTTPStatusError: If API request fails
     """
+    # Execute pre-model invoke hooks
+    params = {
+        "prompt": prompt,
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "thinking_budget": thinking_budget,
+    }
+    hook_manager = get_hook_manager()
+    params = await hook_manager.execute_pre_model_invoke(params)
+    
+    # Update local variables from possibly modified params
+    prompt = params["prompt"]
+    model = params["model"]
+    temperature = params["temperature"]
+    max_tokens = params["max_tokens"]
+    thinking_budget = params["thinking_budget"]
+
     access_token = await _ensure_valid_token(token_store, "openai")
 
     # OpenAI Chat Completions API

mcp_bridge/tools/task_runner.py

@@ -0,0 +1,97 @@
+"""
+Task Runner for Stravinsky background sub-agents.
+
+This script is executed as a background process to handle agent tasks,
+capture output, and update status in tasks.json.
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import asyncio
+from datetime import datetime
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
+logger = logging.getLogger("task_runner")
+
+async def run_task(task_id: str, base_dir: str):
+    base_path = Path(base_dir)
+    tasks_file = base_path / "tasks.json"
+    agents_dir = base_path / "agents"
+    
+    # Load task details
+    try:
+        with open(tasks_file, "r") as f:
+            tasks = json.load(f)
+        task = tasks.get(task_id)
+    except Exception as e:
+        logger.error(f"Failed to load tasks: {e}")
+        return
+
+    if not task:
+        logger.error(f"Task {task_id} not found")
+        return
+
+    prompt = task.get("prompt")
+    model = task.get("model", "gemini-2.0-flash")
+    
+    output_file = agents_dir / f"{task_id}.out"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Import model invocation
+        from mcp_bridge.tools.model_invoke import invoke_gemini
+        
+        logger.info(f"Executing task {task_id} with model {model}...")
+        
+        # Execute the model call
+        result = await invoke_gemini(prompt=prompt, model=model)
+        
+        # Save result
+        with open(output_file, "w") as f:
+            f.write(result)
+            
+        # Update status
+        with open(tasks_file, "r") as f:
+            tasks = json.load(f)
+        
+        if task_id in tasks:
+            tasks[task_id].update({
+                "status": "completed",
+                "result": result,
+                "completed_at": datetime.now().isoformat()
+            })
+            with open(tasks_file, "w") as f:
+                json.dump(tasks, f, indent=2)
+                
+        logger.info(f"Task {task_id} completed successfully")
+        
+    except Exception as e:
+        logger.exception(f"Task {task_id} failed: {e}")
+        
+        # Update status with error
+        try:
+            with open(tasks_file, "r") as f:
+                tasks = json.load(f)
+            if task_id in tasks:
+                tasks[task_id].update({
+                    "status": "failed",
+                    "error": str(e),
+                    "completed_at": datetime.now().isoformat()
+                })
+                with open(tasks_file, "w") as f:
+                    json.dump(tasks, f, indent=2)
+        except:
+            pass
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task-id", required=True)
+    parser.add_argument("--base-dir", required=True)
+    args = parser.parse_args()
+    
+    asyncio.run(run_task(args.task_id, args.base_dir))

mcp_bridge/tools/templates.py

@@ -0,0 +1,86 @@
+"""
+Templates for Stravinsky repository initialization.
+"""
+
+CLAUDE_MD_TEMPLATE = """## Stravinsky MCP (Parallel Agents)
+
+Use Stravinsky MCP tools. **DEFAULT: spawn parallel agents for multi-step tasks.**
+
+### Agent Tools
+- `agent_spawn(prompt, agent_type, description)` - Spawn background agent with full tool access
+- `agent_output(task_id, block)` - Get results (block=True to wait)
+- `agent_progress(task_id)` - Check real-time progress
+- `agent_list()` - Overview of all running agents
+- `agent_cancel(task_id)` - Stop a running agent
+
+### Parallel Execution (ULTRAWORK)
+For ANY task with 2+ independent steps:
+1. **Immediately use agent_spawn** for each independent component
+2. Fire all agents simultaneously, don't wait
+3. Monitor with agent_progress, collect with agent_output
+
+### Trigger Commands
+- **ULTRAWORK**: Maximum parallel execution - spawn agents aggressively for every subtask
+- **ULTRATHINK**: Engage exhaustive deep reasoning, multi-dimensional analysis
+"""
+
+# Slash Commands
+COMMAND_STRAVINSKY = """---
+description: Trigger the Stravinsky Orchestrator for complex workflows.
+---
+
+Use the `stravinsky` prompt to initialize our session, assess the environment, and begin orchestration of the requested task. Stravinsky will manage todos and delegate work to specialized sub-agents.
+"""
+
+COMMAND_PARALLEL = """---
+description: Execute a task with multiple parallel agents for speed.
+---
+
+Use the Stravinsky MCP tools to execute this task with PARALLEL AGENTS.
+
+**MANDATORY:** For the following task items, spawn a SEPARATE `agent_spawn` call for EACH independent item. Do not work on them sequentially - fire all agents simultaneously:
+
+$ARGUMENTS
+
+After spawning all agents:
+1. Use `agent_list` to show running agents
+2. Use `agent_progress(task_id)` to monitor each
+3. Collect results with `agent_output(task_id, block=True)` when ready
+"""
+
+COMMAND_CONTEXT = """---
+description: Refresh project situational awareness (Git, Rules, Top Todos).
+---
+
+Call the `get_project_context` tool to retrieve the current Git branch, modified files, local project rules from `.claude/rules/`, and any pending `[ ]` todos in the current scope.
+"""
+
+COMMAND_HEALTH = """---
+description: Perform a comprehensive system health and dependency check.
+---
+
+Call the `get_system_health` tool to verify that all CLI dependencies (rg, fd, sg, tsc, etc.) are installed and that authentication for Gemini and OpenAI is active.
+"""
+
+COMMAND_DELPHI = """---
+description: Consult the Delphi Strategic Advisor for architecture and hard debugging.
+---
+
+Use the `delphi` prompt to analyze the current problem. This triggers a GPT-based consulting phase focused on strategic reasoning, architectural trade-offs, and root-cause analysis for difficult bugs.
+"""
+
+COMMAND_DEWEY = """---
+description: Trigger Dewey for documentation research and implementation examples.
+---
+
+Use the `dewey` prompt to find evidence and documentation for the topic at hand. Dewey specializes in multi-repository search and official documentation retrieval.
+"""
+
+SLASH_COMMANDS = {
+    "stravinsky.md": COMMAND_STRAVINSKY,
+    "parallel.md": COMMAND_PARALLEL,
+    "context.md": COMMAND_CONTEXT,
+    "health.md": COMMAND_HEALTH,
+    "delphi.md": COMMAND_DELPHI,
+    "dewey.md": COMMAND_DEWEY,
+}