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

mcp_bridge/hooks/todo_continuation.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Todo Continuation Enforcer
+
+Checks if there are incomplete todos (in_progress or pending) and injects
+a reminder to continue working on them before starting new work.
+
+Aligned with oh-my-opencode's [SYSTEM REMINDER - TODO CONTINUATION] pattern.
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_todo_state() -> dict:
+    """Try to get current todo state from Claude Code session or local cache."""
+    # Claude Code stores todo state - we can check via session files
+    # For now, we'll use a simple file-based approach
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    todo_cache = cwd / ".claude" / "todo_state.json"
+
+    if todo_cache.exists():
+        try:
+            return json.loads(todo_cache.read_text())
+        except Exception:
+            pass
+
+    return {"todos": []}
+
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        prompt = data.get("prompt", "")
+    except Exception:
+        return 0
+
+    # Get current todo state
+    state = get_todo_state()
+    todos = state.get("todos", [])
+
+    if not todos:
+        # No todos tracked, pass through
+        print(prompt)
+        return 0
+
+    # Count incomplete todos
+    in_progress = [t for t in todos if t.get("status") == "in_progress"]
+    pending = [t for t in todos if t.get("status") == "pending"]
+
+    if not in_progress and not pending:
+        # All todos complete, pass through
+        print(prompt)
+        return 0
+
+    # Build reminder
+    reminder_parts = ["[SYSTEM REMINDER - TODO CONTINUATION]", ""]
+
+    if in_progress:
+        reminder_parts.append(f"IN PROGRESS ({len(in_progress)} items):")
+        for t in in_progress:
+            reminder_parts.append(f"  - {t.get('content', 'Unknown task')}")
+        reminder_parts.append("")
+
+    if pending:
+        reminder_parts.append(f"PENDING ({len(pending)} items):")
+        for t in pending[:5]:  # Show max 5 pending
+            reminder_parts.append(f"  - {t.get('content', 'Unknown task')}")
+        if len(pending) > 5:
+            reminder_parts.append(f"  ... and {len(pending) - 5} more")
+        reminder_parts.append("")
+
+    reminder_parts.extend([
+        "IMPORTANT: You have incomplete work. Before starting anything new:",
+        "1. Continue working on IN_PROGRESS todos first",
+        "2. If blocked, explain why and move to next PENDING item",
+        "3. Only start NEW work if all todos are complete or explicitly abandoned",
+        "",
+        "---",
+        "",
+    ])
+
+    reminder = "\n".join(reminder_parts)
+    print(reminder + prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/todo_delegation.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for TodoWrite: CRITICAL parallel execution enforcer.
+
+This hook fires AFTER TodoWrite completes. If there are 2+ pending items,
+it outputs a STRONG reminder that Task agents must be spawned immediately.
+
+Exit code 2 is used to signal a HARD BLOCK - Claude should see this as
+a failure condition requiring immediate correction.
+
+Works in tandem with:
+- parallel_execution.py (UserPromptSubmit): Pre-emptive instruction injection
+- stravinsky_mode.py (PreToolUse): Hard blocking of Read/Grep/Bash tools
+"""
+import json
+import sys
+from pathlib import Path
+
+# Check if stravinsky mode is active (hard blocking enabled)
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def is_stravinsky_mode():
+    """Check if hard blocking mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+def main():
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    if tool_name != "TodoWrite":
+        return 0
+
+    # Get the todos that were just written
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    # Count pending todos
+    pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+    if pending_count < 2:
+        return 0
+
+    # Check if stravinsky mode is active
+    stravinsky_active = is_stravinsky_mode()
+
+    # CRITICAL: Output urgent reminder for parallel Task spawning
+    mode_warning = ""
+    if stravinsky_active:
+        mode_warning = """
+⚠️ STRAVINSKY MODE ACTIVE - Direct tools (Read, Grep, Bash) are BLOCKED.
+   You MUST use Task(subagent_type="explore", ...) for ALL file operations.
+"""
+
+    error_message = f"""
+🚨 PARALLEL DELEGATION REQUIRED 🚨
+
+TodoWrite created {pending_count} pending items.
+{mode_warning}
+You MUST spawn Task agents for ALL independent TODOs in THIS SAME RESPONSE.
+
+Required pattern (IMMEDIATELY after this message):
+Task(subagent_type="explore", prompt="TODO 1...", description="TODO 1", run_in_background=true)
+Task(subagent_type="explore", prompt="TODO 2...", description="TODO 2", run_in_background=true)
+...
+
+DO NOT:
+- End your response without spawning Tasks
+- Mark TODOs in_progress before spawning Tasks
+- Use Read/Grep/Bash directly (BLOCKED in stravinsky mode)
+
+Your NEXT action MUST be multiple Task() calls, one for each independent TODO.
+"""
+    print(error_message, file=sys.stderr)
+
+    # Exit code 2 = HARD BLOCK in stravinsky mode
+    # Exit code 1 = WARNING otherwise
+    return 2 if stravinsky_active else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/tool_messaging.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for user-friendly tool messaging.
+
+Outputs concise messages about which agent/tool was used and what it did.
+Format examples:
+- ast-grep('Searching for authentication patterns')
+- delphi:openai/gpt-5.2-medium('Analyzing architecture trade-offs')
+- explore:gemini-3-flash('Finding all API endpoints')
+"""
+
+import json
+import os
+import sys
+
+# Agent model mappings
+AGENT_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "code-reviewer": "sonnet",
+    "debugger": "sonnet",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2-medium",
+}
+
+# Tool display names
+TOOL_NAMES = {
+    "mcp__stravinsky__ast_grep_search": "ast-grep",
+    "mcp__stravinsky__grep_search": "grep",
+    "mcp__stravinsky__glob_files": "glob",
+    "mcp__stravinsky__lsp_diagnostics": "lsp-diagnostics",
+    "mcp__stravinsky__lsp_hover": "lsp-hover",
+    "mcp__stravinsky__lsp_goto_definition": "lsp-goto-def",
+    "mcp__stravinsky__lsp_find_references": "lsp-find-refs",
+    "mcp__stravinsky__lsp_document_symbols": "lsp-symbols",
+    "mcp__stravinsky__lsp_workspace_symbols": "lsp-workspace-symbols",
+    "mcp__stravinsky__invoke_gemini": "gemini",
+    "mcp__stravinsky__invoke_openai": "openai",
+    "mcp__grep-app__searchCode": "grep.app",
+    "mcp__grep-app__github_file": "github-file",
+}
+
+
+def extract_description(tool_name: str, params: dict) -> str:
+    """Extract a concise description of what the tool did."""
+
+    # AST-grep
+    if "ast_grep" in tool_name:
+        pattern = params.get("pattern", "")
+        directory = params.get("directory", ".")
+        return f"Searching AST in {directory} for '{pattern[:40]}...'"
+
+    # Grep/search
+    if "grep_search" in tool_name or "searchCode" in tool_name:
+        pattern = params.get("pattern", params.get("query", ""))
+        return f"Searching for '{pattern[:40]}...'"
+
+    # Glob
+    if "glob_files" in tool_name:
+        pattern = params.get("pattern", "")
+        return f"Finding files matching '{pattern}'"
+
+    # LSP diagnostics
+    if "lsp_diagnostics" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Checking {filename} for errors"
+
+    # LSP hover
+    if "lsp_hover" in tool_name:
+        file_path = params.get("file_path", "")
+        line = params.get("line", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Type info for {filename}:{line}"
+
+    # LSP goto definition
+    if "lsp_goto" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "symbol"
+        return f"Finding definition in {filename}"
+
+    # LSP find references
+    if "lsp_find_references" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "symbol"
+        return f"Finding all references to symbol in {filename}"
+
+    # LSP symbols
+    if "lsp_symbols" in tool_name or "lsp_document_symbols" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Getting symbols from {filename}"
+
+    if "lsp_workspace_symbols" in tool_name:
+        query = params.get("query", "")
+        return f"Searching workspace for symbol '{query}'"
+
+    # Gemini invocation
+    if "invoke_gemini" in tool_name:
+        prompt = params.get("prompt", "")
+        # Extract first meaningful line
+        first_line = prompt.split('\n')[0][:50] if prompt else "Processing"
+        return first_line
+
+    # OpenAI invocation
+    if "invoke_openai" in tool_name:
+        prompt = params.get("prompt", "")
+        first_line = prompt.split('\n')[0][:50] if prompt else "Strategic analysis"
+        return first_line
+
+    # GitHub file fetch
+    if "github_file" in tool_name:
+        path = params.get("path", "")
+        repo = params.get("repo", "")
+        return f"Fetching {path} from {repo}"
+
+    # Task delegation
+    if tool_name == "Task":
+        subagent_type = params.get("subagent_type", "unknown")
+        description = params.get("description", "")
+        model = AGENT_MODELS.get(subagent_type, "unknown")
+        return f"{subagent_type}:{model}('{description}')"
+
+    return "Processing"
+
+
+def main():
+    try:
+        # Read hook input from stdin
+        hook_input = json.loads(sys.stdin.read())
+
+        tool_name = hook_input.get("toolName", hook_input.get("tool_name", ""))
+        params = hook_input.get("params", hook_input.get("tool_input", {}))
+
+        # Only output messages for MCP tools and Task delegations
+        if not (tool_name.startswith("mcp__") or tool_name == "Task"):
+            sys.exit(0)
+
+        # Get tool display name
+        display_name = TOOL_NAMES.get(tool_name, tool_name)
+
+        # Special handling for Task delegations
+        if tool_name == "Task":
+            subagent_type = params.get("subagent_type", "unknown")
+            description = params.get("description", "")
+            model = AGENT_MODELS.get(subagent_type, "unknown")
+
+            # Show full agent delegation message
+            print(f"🎯 {subagent_type}:{model}('{description}')", file=sys.stderr)
+        else:
+            # Regular tool usage
+            description = extract_description(tool_name, params)
+            print(f"🔧 {display_name}('{description}')", file=sys.stderr)
+
+        sys.exit(0)
+
+    except Exception as e:
+        # On error, fail silently (don't disrupt workflow)
+        print(f"Tool messaging hook error: {e}", file=sys.stderr)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

mcp_bridge/hooks/truncator.py

@@ -1,19 +1,23 @@
-"""
-Tool output truncator hook.
-Limits the size of tool outputs to prevent context bloat.
-"""
+import os
+import sys
+import json
 
-from typing import Any, Dict, Optional
+MAX_CHARS = 30000
 
-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
+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/notifications.py

@@ -0,0 +1,151 @@
+"""
+Desktop Notifications Manager for Stravinsky.
+
+Provides cross-platform desktop notifications (macOS, Linux, Windows)
+for long-running operations like codebase indexing.
+
+Supports:
+- Non-blocking async notifications
+- Platform-specific backends
+- Notification queuing
+"""
+
+import logging
+import platform
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationManager:
+    """
+    Cross-platform desktop notification manager.
+    
+    Provides non-blocking notifications with automatic platform detection.
+    """
+    
+    def __init__(self, app_name: str = "Stravinsky"):
+        self.app_name = app_name
+        self.system = platform.system()
+    
+    def _get_notification_command(
+        self, 
+        title: str, 
+        message: str, 
+        sound: bool = True
+    ) -> Optional[list]:
+        """Get platform-specific notification command."""
+        if self.system == "Darwin":  # macOS
+            script = f'display notification "{message}" with title "{title}"'
+            if sound:
+                script += ' sound name "Glass"'
+            return ["osascript", "-e", script]
+        
+        elif self.system == "Linux":
+            cmd = ["notify-send", "--app-name", self.app_name, title, message]
+            if sound:
+                cmd.extend(["--urgency=normal"])
+            return cmd
+        
+        elif self.system == "Windows":
+            ps_script = f"""
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+
+$template = @"
+<toast>
+    <visual>
+        <binding template="ToastGeneric">
+            <text>{title}</text>
+            <text>{message}</text>
+        </binding>
+    </visual>
+</toast>
+"@
+
+$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$xml.LoadXml($template)
+$toast = New-Object Windows.UI.Notifications.ToastNotification $xml
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("{self.app_name}").Show($toast)
+"""
+            return ["powershell", "-Command", ps_script]
+        
+        return None
+    
+    def _send_notification_sync(
+        self,
+        title: str,
+        message: str,
+        sound: bool = True
+    ) -> bool:
+        """Send notification synchronously (blocking)."""
+        cmd = self._get_notification_command(title, message, sound)
+        
+        if not cmd:
+            logger.warning(
+                f"[Notifications] Desktop notifications not supported on {self.system}"
+            )
+            return False
+        
+        try:
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            logger.debug(f"[Notifications] Sent: {title}")
+            return True
+        except FileNotFoundError:
+            logger.warning(f"[Notifications] Command not found: {cmd[0]}")
+            return False
+        except Exception as e:
+            logger.error(f"[Notifications] Failed to send notification: {e}")
+            return False
+    
+    async def notify_reindex_start(self, project_path: str) -> bool:
+        """Notify that codebase reindexing has started."""
+        path = Path(project_path).name or Path(project_path).parent.name
+        title = "Codebase Indexing Started"
+        message = f"Indexing {path}..."
+        return self._send_notification_sync(title, message, sound=True)
+    
+    async def notify_reindex_complete(self, stats: Dict) -> bool:
+        """Notify that codebase reindexing is complete."""
+        indexed = stats.get("indexed", 0)
+        pruned = stats.get("pruned", 0)
+        time_taken = stats.get("time_taken", 0)
+        
+        title = "Codebase Indexing Complete"
+        message = f"Indexed {indexed} chunks, pruned {pruned} stale entries in {time_taken}s"
+        
+        return self._send_notification_sync(title, message, sound=True)
+    
+    async def notify_reindex_error(self, error_message: str) -> bool:
+        """Notify that codebase reindexing failed."""
+        title = "Codebase Indexing Failed"
+        # Truncate long error messages
+        message = error_message[:100] + "..." if len(error_message) > 100 else error_message
+        
+        return self._send_notification_sync(title, message, sound=True)
+
+
+# Global singleton instance
+_notification_manager: Optional[NotificationManager] = None
+
+
+def get_notification_manager() -> NotificationManager:
+    """Get or create the global notification manager instance."""
+    global _notification_manager
+    if _notification_manager is None:
+        _notification_manager = NotificationManager()
+    return _notification_manager
+
+
+def reset_notification_manager() -> None:
+    """Reset the global notification manager (for testing)."""
+    global _notification_manager
+    _notification_manager = None

mcp_bridge/prompts/__init__.py

@@ -6,13 +6,15 @@ from . import explore
 from . import frontend
 from . import document_writer
 from . import multimodal
+from . import planner
 
 __all__ = [
     "stravinsky",
-    "delphi", 
+    "delphi",
     "dewey",
     "explore",
     "frontend",
     "document_writer",
     "multimodal",
+    "planner",
 ]

mcp_bridge/prompts/dewey.py

@@ -50,8 +50,8 @@ Classify EVERY request into one of these categories before taking action:
 
 | Type | Trigger Examples | Tools |
 |------|------------------|-------|
-| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | docs + websearch (parallel) |
-| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
+| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | exa websearch + grep-app GitHub search (parallel) |
+| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + ast-grep + read + blame |
 | **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
 | **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
 
@@ -64,12 +64,15 @@ Classify EVERY request into one of these categories before taking action:
 
 **Execute in parallel (3+ calls)**:
 ```
-Tool 1: Search official documentation
-Tool 2: Web search for recent articles/tutorials ("library-name topic 2025")
-Tool 3: GitHub code search for usage patterns (grep_search)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="library-name topic 2026", num_results=5)
+        -> Current articles, blog posts, best practices (ALWAYS use Exa instead of native WebSearch)
+Tool 2: mcp__grep-app__searchCode(query="library-name implementation pattern")
+        -> Real GitHub code examples with permalinks
+Tool 3: gh search repos "library-name" --sort stars --limit 5
+        -> Popular repositories for reference
 ```
 
-**Output**: Summarize findings with links to official docs and real-world examples.
+**Output**: Synthesize with evidence links (Exa URLs + GitHub permalinks).
 
 ---
 
@@ -85,8 +88,8 @@ Step 2: Get commit SHA for permalinks
         cd ${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
 
 Step 3: Find the implementation
-        - grep_search for function/class
-        - ast_grep_search for AST patterns
+        - mcp__ast-grep__find_code(pattern="function $NAME", language="typescript") for structural search
+        - grep_search for function/class names
         - Read the specific file
         - git blame for context if needed
 
@@ -97,9 +100,9 @@ Step 4: Construct permalink
 **Parallel acceleration (4+ calls)**:
 ```
 Tool 1: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
-Tool 2: GitHub code search for function_name
+Tool 2: mcp__grep-app__searchCode(query="repo:owner/repo function_name")
 Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
-Tool 4: Documentation search for relevant API
+Tool 4: mcp__MCP_DOCKER__web_search_exa(query="library-name function_name documentation 2026")
 ```
 
 ---
@@ -131,13 +134,15 @@ gh api repos/owner/repo/pulls/<number>/files
 
 **Execute ALL in parallel (6+ calls)**:
 ```
-// Documentation & Web
-Tool 1: Documentation search
-Tool 2: Web search ("topic recent updates 2025")
+// Web Search (ALWAYS use Exa)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="topic recent updates 2026", num_results=10)
 
-// Code Search
-Tool 3: grep_search(pattern1)
-Tool 4: grep_search(pattern2) or ast_grep_search
+// GitHub Code Search
+Tool 2: mcp__grep-app__searchCode(query="topic implementation pattern")
+Tool 3: mcp__grep-app__searchCode(query="topic usage example")
+
+// AST Pattern Search
+Tool 4: mcp__ast-grep__find_code(pattern="$PATTERN", language="typescript")
 
 // Source Analysis
 Tool 5: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
@@ -182,15 +187,20 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 
 ---
 
-## TOOL REFERENCE (Stravinsky Tools)
+## TOOL REFERENCE (Stravinsky + MCP DOCKER Tools)
 
 ### Primary Tools by Purpose
 
 | Purpose | Tool | Usage |
 |---------|------|-------|
-| **Code Search** | grep_search | Pattern-based search in local/cloned repos |
-| **AST Search** | ast_grep_search | AST-aware code pattern search |
-| **File Glob** | glob_files | Find files by pattern |
+| **Web Search** | `mcp__MCP_DOCKER__web_search_exa` | **ALWAYS use instead of native WebSearch** - Real-time web search for current articles, docs, tutorials |
+| **GitHub Code Search** | `mcp__grep-app__searchCode` | Search across public GitHub repositories - returns permalinks |
+| **GitHub File Fetch** | `mcp__grep-app__github_file` | Fetch specific file from GitHub repo |
+| **AST Pattern Search** | `mcp__ast-grep__find_code` | Structural code search across 25+ languages with AST awareness |
+| **AST Replace** | `mcp__ast-grep__replace` | AST-aware code refactoring and replacement |
+| **Local Code Search** | `grep_search` | Pattern-based search in local/cloned repos (uses ripgrep) |
+| **Local AST Search** | `ast_grep_search` | AST search in cloned repos |
+| **File Glob** | `glob_files` | Find files by pattern |
 | **Clone Repo** | gh CLI | `gh repo clone owner/repo ${TMPDIR:-/tmp}/name -- --depth 1` |
 | **Issues/PRs** | gh CLI | `gh search issues/prs "query" --repo owner/repo` |
 | **View Issue/PR** | gh CLI | `gh issue/pr view <num> --repo owner/repo --comments` |