stravinsky 0.1.12__tar.gz → 0.2.24__tar.gz

stravinsky-0.2.24/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*" # Trigger on version tags like v0.2.9
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # Required for trusted publishing
+      contents: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          # Uses trusted publishing - no token needed if configured on PyPI
+          # Fallback to token if trusted publishing not set up:
+          password: ${{ secrets.PYPI_API_TOKEN }}

stravinsky-0.2.24/.stravinsky/agents/agent_8e68511c.out

@@ -0,0 +1 @@
+API Error: 404 {"type":"error","error":{"type":"not_found_error","message":"model: gemini-3-flash"},"request_id":"req_011CWjjRp64NyZfRrodN8rfu"}

stravinsky-0.2.24/.stravinsky/agents/agent_e76617db.out

@@ -0,0 +1 @@
+API Error: 404 {"type":"error","error":{"type":"not_found_error","message":"model: gemini-3-flash"},"request_id":"req_011CWjjHp9ZHrrpZ9nNCfXAF"}

stravinsky-0.2.24/.stravinsky/agents.json

@@ -0,0 +1,34 @@
+{
+  "agent_e76617db": {
+    "id": "agent_e76617db",
+    "prompt": "Tell me a joke about robots.",
+    "agent_type": "explore",
+    "description": "Tell me a joke about robots.",
+    "status": "running",
+    "created_at": "2026-01-02T22:24:43.073103",
+    "parent_session_id": null,
+    "started_at": "2026-01-02T22:24:43.073419",
+    "completed_at": null,
+    "result": null,
+    "error": null,
+    "pid": 18206,
+    "timeout": 300,
+    "progress": null
+  },
+  "agent_8e68511c": {
+    "id": "agent_8e68511c",
+    "prompt": "Tell me a joke about robots.",
+    "agent_type": "explore",
+    "description": "Tell me a joke about robots.",
+    "status": "running",
+    "created_at": "2026-01-02T22:26:29.692048",
+    "parent_session_id": null,
+    "started_at": "2026-01-02T22:26:29.692586",
+    "completed_at": null,
+    "result": null,
+    "error": null,
+    "pid": 23792,
+    "timeout": 300,
+    "progress": null
+  }
+}

{stravinsky-0.1.12 → stravinsky-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stravinsky
-Version: 0.1.12
+Version: 0.2.24
 Summary: MCP Bridge for Claude Code with Multi-Model Support. Install globally: claude mcp add --scope user stravinsky -- uvx stravinsky. Add to CLAUDE.md: See https://pypi.org/project/stravinsky/
 Project-URL: Repository, https://github.com/GratefulDave/stravinsky
 Project-URL: Issues, https://github.com/GratefulDave/stravinsky/issues
@@ -15,13 +15,14 @@ Requires-Dist: google-auth>=2.20.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: jedi>=0.19.2
 Requires-Dist: keyring>=25.7.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp>=1.2.1
 Requires-Dist: openai>=1.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: ruff>=0.14.10
+Requires-Dist: tenacity>=8.5.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
@@ -76,7 +77,7 @@ claude mcp add stravinsky -- stravinsky
 
 ### Authentication
 
-```bash
+````bash
 # Login to Google (Gemini)
 stravinsky-auth login gemini
 
@@ -88,7 +89,22 @@ stravinsky-auth status
 
 # Logout
 stravinsky-auth logout gemini
-```
+
+### Repo Auto-Initialization
+
+Bootstrap any repository for Stravinsky in one command:
+
+```bash
+# In the root of your project:
+stravinsky-auth init
+````
+
+This will:
+
+1. Create/Update `CLAUDE.md` with Stravinsky parallel execution rules.
+2. Install standard slash commands into `.claude/commands/stra/`.
+
+````
 
 ## Add to Your CLAUDE.md
 
@@ -126,7 +142,7 @@ For ANY task with 2+ independent steps:
 
 - **ULTRATHINK**: Engage exhaustive deep reasoning, multi-dimensional analysis
 - **ULTRAWORK**: Maximum parallel execution - spawn agents aggressively for every subtask
-```
+````
 
 ## Tools (31)
 
@@ -192,7 +208,3 @@ The Codex CLI uses the same port. Stop it with: `killall codex`
 MIT
 
 ---
-
-<div align="center">
-  <small>Built with obsession by the Google Deepmind team.</small>
-</div>

{stravinsky-0.1.12 → stravinsky-0.2.24}/README.md

@@ -45,7 +45,7 @@ claude mcp add stravinsky -- stravinsky
 
 ### Authentication
 
-```bash
+````bash
 # Login to Google (Gemini)
 stravinsky-auth login gemini
 
@@ -57,7 +57,22 @@ stravinsky-auth status
 
 # Logout
 stravinsky-auth logout gemini
-```
+
+### Repo Auto-Initialization
+
+Bootstrap any repository for Stravinsky in one command:
+
+```bash
+# In the root of your project:
+stravinsky-auth init
+````
+
+This will:
+
+1. Create/Update `CLAUDE.md` with Stravinsky parallel execution rules.
+2. Install standard slash commands into `.claude/commands/stra/`.
+
+````
 
 ## Add to Your CLAUDE.md
 
@@ -95,7 +110,7 @@ For ANY task with 2+ independent steps:
 
 - **ULTRATHINK**: Engage exhaustive deep reasoning, multi-dimensional analysis
 - **ULTRAWORK**: Maximum parallel execution - spawn agents aggressively for every subtask
-```
+````
 
 ## Tools (31)
 
@@ -161,7 +176,3 @@ The Codex CLI uses the same port. Stop it with: `killall codex`
 MIT
 
 ---
-
-<div align="center">
-  <small>Built with obsession by the Google Deepmind team.</small>
-</div>

stravinsky-0.2.24/error.log

@@ -0,0 +1,4 @@
+   Building stravinsky @ file:///Users/davidandrews/PycharmProjects/stravinsky
+      Built stravinsky @ file:///Users/davidandrews/PycharmProjects/stravinsky
+Installed 61 packages in 150ms
+INFO:mcp_bridge.server:Starting Stravinsky MCP Bridge Server...

stravinsky-0.2.24/install_native_hooks.py

@@ -0,0 +1,53 @@
+import json
+import os
+from pathlib import Path
+
+def install():
+    project_root = Path.cwd()
+    settings_path = project_root / ".claude" / "settings.json"
+    
+    # Create .claude directory if missing
+    settings_path.parent.mkdir(exist_ok=True)
+
+    # Initial settings
+    if settings_path.exists():
+        try:
+            settings = json.loads(settings_path.read_text())
+        except Exception:
+            settings = {}
+    else:
+        settings = {}
+
+    if "hooks" not in settings:
+        settings["hooks"] = {}
+
+    hooks = settings["hooks"]
+
+    # Hook 1: UserPromptSubmit (Context)
+    hooks["UserPromptSubmit"] = [
+        {
+            "type": "command",
+            "command": f"python3 {project_root}/mcp_bridge/native_hooks/context.py"
+        }
+    ]
+
+    # Hook 2: PostToolUse (Recovery & Truncation)
+    # We chain them or use a dispatcher. Chaining is easier in the JSON.
+    hooks["PostToolUse"] = [
+        {
+            "type": "command",
+            "command": f"python3 {project_root}/mcp_bridge/native_hooks/truncator.py"
+        },
+        {
+            "type": "command",
+            "command": f"python3 {project_root}/mcp_bridge/native_hooks/edit_recovery.py",
+            "matcher": ["Edit", "MultiEdit"]
+        }
+    ]
+
+    # Save
+    settings_path.write_text(json.dumps(settings, indent=2))
+    print(f"✅ Stravinsky native hooks installed to {settings_path}")
+
+if __name__ == "__main__":
+    install()

stravinsky-0.2.24/mcp_bridge/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.24"

{stravinsky-0.1.12 → stravinsky-0.2.24}/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
 

stravinsky-0.2.24/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()

stravinsky-0.2.24/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

stravinsky-0.2.24/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

stravinsky-0.2.24/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

stravinsky-0.2.24/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

stravinsky-0.2.24/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()

stravinsky-0.2.24/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 = 30000 # 30k 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

stravinsky-0.2.24/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()

stravinsky-0.2.24/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()