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

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/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."""
 

mcp_bridge/server.py

@@ -428,6 +428,14 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
             result_content = await lsp_servers()
 
+        elif name == "lsp_diagnostics":
+            from .tools.code_search import lsp_diagnostics
+
+            result_content = await lsp_diagnostics(
+                file_path=arguments["file_path"],
+                severity=arguments.get("severity", "all"),
+            )
+
         else:
             result_content = f"Unknown tool: {name}"
 
@@ -441,7 +449,10 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 processed_text = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content[0].text
                 )
-                result_content[0].text = processed_text
+                # Only update if processed_text is non-empty to avoid empty text blocks
+                # (API error: cache_control cannot be set for empty text blocks)
+                if processed_text:
+                    result_content[0].text = processed_text
             elif isinstance(result_content, str):
                 result_content = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content

mcp_bridge/server_tools.py

@@ -357,6 +357,11 @@ def get_tool_definitions() -> List[Tool]:
                         "description": "Maximum execution time in seconds",
                         "default": 300,
                     },
+                    "blocking": {
+                        "type": "boolean",
+                        "description": "If true, wait for agent completion and return result directly. Recommended for delphi consultations.",
+                        "default": False,
+                    },
                 },
                 "required": ["prompt"],
             },

mcp_bridge/tools/agent_manager.py

@@ -54,6 +54,18 @@ AGENT_COST_TIERS = {
     "_default": "EXPENSIVE",  # Claude Sonnet 4.5 via CLI
 }
 
+# Display model names for output formatting (user-visible)
+AGENT_DISPLAY_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "document_writer": "gemini-3-flash",
+    "multimodal": "gemini-3-flash",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2",
+    "planner": "opus-4.5",
+    "_default": "sonnet-4.5",
+}
+
 
 @dataclass
 class AgentTask:
@@ -631,6 +643,7 @@ async def agent_spawn(
     model: str = "gemini-3-flash",
     thinking_budget: int = 0,
     timeout: int = 300,
+    blocking: bool = False,
 ) -> str:
     """
     Spawn a background agent.
@@ -642,9 +655,10 @@ async def agent_spawn(
         model: Model to use (gemini-3-flash, gemini-2.0-flash, claude)
         thinking_budget: Reserved reasoning tokens
         timeout: Execution timeout in seconds
+        blocking: If True, wait for completion and return result directly (use for delphi)
 
     Returns:
-        Task ID and instructions
+        Task ID and instructions, or full result if blocking=True
     """
     manager = get_manager()
 
@@ -788,16 +802,18 @@ CONSTRAINTS:
         timeout=timeout,
     )
 
-    return f"""🚀 Background agent spawned successfully.
+    # Get display model for concise output
+    display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    short_desc = (description or prompt[:50]).strip()
 
-**Task ID**: {task_id}
-**Agent Type**: {agent_type}
-**Description**: {description or prompt[:50]}
+    # If blocking mode (recommended for delphi), wait for completion
+    if blocking:
+        result = manager.get_output(task_id, block=True, timeout=timeout)
+        return f"{agent_type}:{display_model}('{short_desc}') [BLOCKING]\n\n{result}"
 
-The agent is now running. Use:
-- `agent_progress(task_id="{task_id}")` to monitor real-time progress
-- `agent_output(task_id="{task_id}")` to get final result
-- `agent_cancel(task_id="{task_id}")` to stop the agent"""
+    # Concise format: AgentType:model('description')
+    return f"""{agent_type}:{display_model}('{short_desc}')
+task_id={task_id}"""
 
 
 async def agent_output(task_id: str, block: bool = False) -> str:
@@ -887,7 +903,7 @@ async def agent_list() -> str:
     if not tasks:
         return "No background agent tasks found."
 
-    lines = ["**Background Agent Tasks**", ""]
+    lines = []
 
     for t in sorted(tasks, key=lambda x: x.get("created_at", ""), reverse=True):
         status_emoji = {
@@ -898,8 +914,11 @@ async def agent_list() -> str:
             "cancelled": "⚠️",
         }.get(t["status"], "❓")
 
+        agent_type = t.get("agent_type", "unknown")
+        display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
         desc = t.get("description", t.get("prompt", "")[:40])
-        lines.append(f"- {status_emoji} [{t['id']}] {t['agent_type']}: {desc}")
+        # Concise format: status agent:model('desc') id=xxx
+        lines.append(f"{status_emoji} {agent_type}:{display_model}('{desc}') id={t['id']}")
 
     return "\n".join(lines)
 

mcp_bridge/tools/code_search.py

@@ -15,17 +15,21 @@ from pathlib import Path
 async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
     """
     Get diagnostics (errors, warnings) for a file using language server.
-    
+
     For TypeScript/JavaScript, uses `tsc` or `biome`.
     For Python, uses `pyright` or `ruff`.
-    
+
     Args:
         file_path: Path to the file to analyze
         severity: Filter by severity (error, warning, information, hint, all)
-        
+
     Returns:
         Formatted diagnostics output.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"🩺 LSP-DIAG: file={file_path} severity={severity}", file=sys.stderr)
+
     path = Path(file_path)
     if not path.exists():
         return f"Error: File not found: {file_path}"
@@ -49,7 +53,7 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         elif suffix == ".py":
             # Use ruff for Python diagnostics
             result = subprocess.run(
-                ["ruff", "check", str(path), "--output-format=text"],
+                ["ruff", "check", str(path), "--output-format=concise"],
                 capture_output=True,
                 text=True,
                 timeout=30,
@@ -70,21 +74,84 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
         return f"Error: {str(e)}"
 
 
+async def check_ai_comment_patterns(file_path: str) -> str:
+    """
+    Detect AI-generated or placeholder comment patterns that indicate incomplete work.
+
+    Patterns detected:
+    - # TODO: implement, # FIXME, # placeholder
+    - // TODO, // FIXME, // placeholder
+    - AI-style verbose comments: "This function handles...", "This method is responsible for..."
+    - Placeholder phrases: "implement this", "add logic here", "your code here"
+
+    Args:
+        file_path: Path to the file to check
+
+    Returns:
+        List of detected AI-style patterns with line numbers, or "No AI patterns detected"
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+
+    # Patterns that indicate AI-generated or placeholder code
+    ai_patterns = [
+        # Placeholder comments
+        r"#\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        r"//\s*(TODO|FIXME|XXX|HACK):\s*(implement|add|placeholder|your code)",
+        # AI-style verbose descriptions
+        r"#\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r"//\s*This (function|method|class) (handles|is responsible for|manages|processes)",
+        r'"""This (function|method|class) (handles|is responsible for|manages|processes)',
+        # Placeholder implementations
+        r"pass\s*#\s*(TODO|implement|placeholder)",
+        r"raise NotImplementedError.*implement",
+        # Common AI filler phrases
+        r"#.*\b(as needed|as required|as appropriate|if necessary)\b",
+        r"//.*\b(as needed|as required|as appropriate|if necessary)\b",
+    ]
+
+    import re
+
+    try:
+        content = path.read_text()
+        lines = content.split("\n")
+        findings = []
+
+        for i, line in enumerate(lines, 1):
+            for pattern in ai_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    findings.append(f"  Line {i}: {line.strip()[:80]}")
+                    break
+
+        if findings:
+            return f"AI/Placeholder patterns detected in {file_path}:\n" + "\n".join(findings)
+        return "No AI patterns detected"
+
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+
 async def ast_grep_search(pattern: str, directory: str = ".", language: str = "") -> str:
     """
     Search codebase using ast-grep for structural patterns.
-    
+
     ast-grep uses AST-aware pattern matching, finding code by structure
     rather than just text. More precise than regex for code search.
-    
+
     Args:
         pattern: ast-grep pattern to search for
         directory: Directory to search in
         language: Filter by language (typescript, python, rust, etc.)
-        
+
     Returns:
         Matched code locations and snippets.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    lang_info = f" lang={language}" if language else ""
+    print(f"🔍 AST-GREP: pattern='{pattern[:50]}...'{lang_info}", file=sys.stderr)
+
     try:
         cmd = ["sg", "run", "-p", pattern, directory]
         if language:
@@ -129,15 +196,20 @@ async def ast_grep_search(pattern: str, directory: str = ".", language: str = ""
 async def grep_search(pattern: str, directory: str = ".", file_pattern: str = "") -> str:
     """
     Fast text search using ripgrep.
-    
+
     Args:
         pattern: Search pattern (supports regex)
         directory: Directory to search in
         file_pattern: Glob pattern to filter files (e.g., "*.py", "*.ts")
-        
+
     Returns:
         Matched lines with file paths and line numbers.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    glob_info = f" glob={file_pattern}" if file_pattern else ""
+    print(f"🔎 GREP: pattern='{pattern[:50]}'{glob_info} dir={directory}", file=sys.stderr)
+
     try:
         cmd = ["rg", "--line-number", "--max-count=50", pattern, directory]
         if file_pattern:

mcp_bridge/tools/lsp/tools.py

@@ -48,15 +48,19 @@ def _position_to_offset(content: str, line: int, character: int) -> int:
 async def lsp_hover(file_path: str, line: int, character: int) -> str:
     """
     Get type info, documentation, and signature at a position.
-    
+
     Args:
         file_path: Absolute path to the file
         line: Line number (1-indexed)
         character: Character position (0-indexed)
-        
+
     Returns:
         Type information and documentation at the position.
     """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"📍 LSP-HOVER: {file_path}:{line}:{character}", file=sys.stderr)
+
     path = Path(file_path)
     if not path.exists():
         return f"Error: File not found: {file_path}"