stravinsky 0.2.52__py3-none-any.whl → 0.4.18__py3-none-any.whl

mcp_bridge/hooks/tool_messaging.py

@@ -0,0 +1,267 @@
+#!/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:stravinsky('Searching for authentication patterns')
+- 🟡 get_file_contents:github('Fetching src/main.py from user/repo')
+- 🟣 searchCode:grep-app('Searching GitHub for auth patterns')
+- 🔵 web_search_exa:MCP_DOCKER('Web search for Docker best practices')
+- 🟤 find_code:ast-grep('AST search for class definitions')
+- 🎯 delphi: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",
+}
+
+# MCP Server emoji mappings
+SERVER_EMOJIS = {
+    "github": "🟡",
+    "ast-grep": "🟤",
+    "grep-app": "🟣",
+    "MCP_DOCKER": "🔵",
+    "stravinsky": "🔧",
+}
+
+# Tool display names (legacy mapping for simple tools)
+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 parse_mcp_tool_name(tool_name: str) -> tuple[str, str, str]:
+    """
+    Parse MCP tool name into (server, tool_type, emoji).
+
+    Examples:
+        mcp__github__get_file_contents -> ("github", "get_file_contents", "🟡")
+        mcp__stravinsky__grep_search -> ("stravinsky", "grep", "🔧")
+        mcp__ast-grep__find_code -> ("ast-grep", "find_code", "🟤")
+    """
+    if not tool_name.startswith("mcp__"):
+        return ("unknown", tool_name, "🔧")
+
+    # Remove mcp__ prefix and split by __
+    parts = tool_name[5:].split("__", 1)
+    if len(parts) != 2:
+        return ("unknown", tool_name, "🔧")
+
+    server = parts[0]
+    tool_type = parts[1]
+
+    # Get emoji for server
+    emoji = SERVER_EMOJIS.get(server, "🔧")
+
+    # Get simplified tool name if available
+    simple_name = TOOL_NAMES.get(tool_name, tool_type)
+
+    return (server, simple_name, emoji)
+
+
+def extract_description(tool_name: str, params: dict) -> str:
+    """Extract a concise description of what the tool did."""
+
+    # GitHub tools
+    if "github" in tool_name.lower():
+        if "get_file_contents" in tool_name:
+            path = params.get("path", "")
+            repo = params.get("repo", "")
+            owner = params.get("owner", "")
+            return f"Fetching {path} from {owner}/{repo}"
+        elif "create_or_update_file" in tool_name:
+            path = params.get("path", "")
+            return f"Updating {path}"
+        elif "search_repositories" in tool_name:
+            query = params.get("query", "")
+            return f"Searching repos for '{query[:40]}'"
+        elif "search_code" in tool_name:
+            q = params.get("q", "")
+            return f"Searching code for '{q[:40]}'"
+        elif "create_pull_request" in tool_name:
+            title = params.get("title", "")
+            return f"Creating PR: {title[:40]}"
+        elif "get_pull_request" in tool_name or "list_pull_requests" in tool_name:
+            return "Fetching PR details"
+        return "GitHub operation"
+
+    # MCP_DOCKER tools
+    if "MCP_DOCKER" in tool_name:
+        if "web_search_exa" in tool_name:
+            query = params.get("query", "")
+            return f"Web search: '{query[:40]}'"
+        elif "create_entities" in tool_name:
+            entities = params.get("entities", [])
+            count = len(entities)
+            return f"Creating {count} knowledge graph entities"
+        elif "search_nodes" in tool_name:
+            query = params.get("query", "")
+            return f"Searching knowledge graph for '{query[:40]}'"
+        return "Knowledge graph operation"
+
+    # ast-grep tools
+    if "ast-grep" in tool_name or "ast_grep" in tool_name:
+        if "find_code" in tool_name or "search" in tool_name:
+            pattern = params.get("pattern", "")
+            return f"AST search for '{pattern[:40]}'"
+        elif "test_match" in tool_name:
+            return "Testing AST pattern"
+        elif "dump_syntax" in tool_name:
+            return "Dumping syntax tree"
+        return "AST operation"
+
+    # grep-app tools
+    if "grep-app" in tool_name or "grep_app" in tool_name:
+        if "searchCode" in tool_name:
+            query = params.get("query", "")
+            return f"Searching GitHub for '{query[:40]}'"
+        elif "github_file" in tool_name:
+            path = params.get("path", "")
+            repo = params.get("repo", "")
+            return f"Fetching {path} from {repo}"
+        return "grep.app search"
+
+    # AST-grep (stravinsky)
+    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)
+
+        # 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:
+            # Parse MCP tool name to get server, tool_type, and emoji
+            server, tool_type, emoji = parse_mcp_tool_name(tool_name)
+
+            # Get description of what the tool did
+            description = extract_description(tool_name, params)
+
+            # Format output: emoji tool_type:server('description')
+            print(f"{emoji} {tool_type}:{server}('{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/multimodal.py

@@ -18,32 +18,53 @@ MULTIMODAL_SYSTEM_PROMPT = """You interpret media files that cannot be read as p
 
 Your job: examine the attached file and extract ONLY what was requested.
 
+## TOKEN OPTIMIZATION (CRITICAL)
+
+You exist to REDUCE context token consumption. Instead of passing 50k tokens of raw
+image/PDF data to the main agent, you summarize into 500-2000 tokens of actionable
+information. This is a 95%+ reduction in context usage.
+
 When to use you:
 - Media files the Read tool cannot interpret
 - Extracting specific information or summaries from documents
 - Describing visual content in images or diagrams
 - When analyzed/extracted data is needed, not raw file contents
+- UI screenshots for analysis (NOT for exact CSS recreation)
+- PDF documents requiring data extraction
 
 When NOT to use you:
 - Source code or plain text files needing exact contents (use Read)
 - Files that need editing afterward (need literal content from Read)
 - Simple file reading where no interpretation is needed
 
-How you work:
+## How you work
+
 1. Receive a file path and a goal describing what to extract
-2. Read and analyze the file deeply
-3. Return ONLY the relevant extracted information
+2. Use invoke_gemini with the image/PDF for vision analysis:
+   ```
+   invoke_gemini(
+     prompt="Analyze this image: [goal]",
+     model="gemini-3-flash",
+     image_path="/path/to/file.png",  # Vision API
+     agent_context={"agent_type": "multimodal"}
+   )
+   ```
+3. Return ONLY the relevant extracted information (compressed summary)
 4. The main agent never processes the raw file - you save context tokens
 
+## Output Guidelines
+
 For PDFs: extract text, structure, tables, data from specific sections
 For images: describe layouts, UI elements, text, diagrams, charts
 For diagrams: explain relationships, flows, architecture depicted
+For screenshots: describe visible UI, key elements, layout structure
 
 Response rules:
 - Return extracted information directly, no preamble
 - If info not found, state clearly what's missing
 - Match the language of the request
 - Be thorough on the goal, concise on everything else
+- Keep response under 2000 tokens when possible
 
 Your output goes straight to the main agent for continued work."""