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

mcp_bridge/tools/background_tasks.py

@@ -5,17 +5,13 @@ Provides mechanisms to spawn, monitor, and manage async sub-agents.
 Tasks are persisted to .stravinsky/tasks.json.
 """
 
-import asyncio
 import json
-import os
 import subprocess
 import sys
-import time
-import uuid
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 @dataclass
@@ -25,15 +21,15 @@ class BackgroundTask:
     model: str
     status: str  # pending, running, completed, failed
     created_at: str
-    started_at: Optional[str] = None
-    completed_at: Optional[str] = None
-    result: Optional[str] = None
-    error: Optional[str] = None
-    pid: Optional[int] = None
+    started_at: str | None = None
+    completed_at: str | None = None
+    result: str | None = None
+    error: str | None = None
+    pid: int | None = None
 
 
 class BackgroundManager:
-    def __init__(self, base_dir: Optional[str] = None):
+    def __init__(self, base_dir: str | None = None):
         if base_dir:
             self.base_dir = Path(base_dir)
         else:
@@ -49,14 +45,14 @@ class BackgroundManager:
         if not self.state_file.exists():
             self._save_tasks({})
 
-    def _load_tasks(self) -> Dict[str, Any]:
+    def _load_tasks(self) -> dict[str, Any]:
         try:
-            with open(self.state_file, "r") as f:
+            with open(self.state_file) as f:
                 return json.load(f)
         except (json.JSONDecodeError, FileNotFoundError):
             return {}
 
-    def _save_tasks(self, tasks: Dict[str, Any]):
+    def _save_tasks(self, tasks: dict[str, Any]):
         with open(self.state_file, "w") as f:
             json.dump(tasks, f, indent=2)
 
@@ -82,11 +78,11 @@ class BackgroundManager:
             tasks[task_id].update(kwargs)
             self._save_tasks(tasks)
 
-    def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+    def get_task(self, task_id: str) -> dict[str, Any] | None:
         tasks = self._load_tasks()
         return tasks.get(task_id)
 
-    def list_tasks(self) -> List[Dict[str, Any]]:
+    def list_tasks(self) -> list[dict[str, Any]]:
         tasks = self._load_tasks()
         return list(tasks.values())
 

mcp_bridge/tools/code_search.py

@@ -6,11 +6,10 @@ to language servers. Claude Code has native LSP support, so these serve as
 supplementary utilities for advanced operations.
 """
 
-import asyncio
 import json
-import subprocess
+import asyncio
 from pathlib import Path
-
+from mcp_bridge.utils.process import async_execute
 
 async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
     """
@@ -39,11 +38,9 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
     try:
         if suffix in (".ts", ".tsx", ".js", ".jsx"):
             # Use TypeScript compiler for diagnostics
-            result = subprocess.run(
+            result = await async_execute(
                 ["npx", "tsc", "--noEmit", "--pretty", str(path)],
-                capture_output=True,
-                text=True,
-                timeout=30,
+                timeout=30
             )
             output = result.stdout + result.stderr
             if not output.strip():
@@ -52,11 +49,9 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
             
         elif suffix == ".py":
             # Use ruff for Python diagnostics
-            result = subprocess.run(
+            result = await async_execute(
                 ["ruff", "check", str(path), "--output-format=concise"],
-                capture_output=True,
-                text=True,
-                timeout=30,
+                timeout=30
             )
             output = result.stdout + result.stderr
             if not output.strip():
@@ -68,7 +63,7 @@ async def lsp_diagnostics(file_path: str, severity: str = "all") -> str:
             
     except FileNotFoundError as e:
         return f"Tool not found: {e.filename}. Install required tools."
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Diagnostics timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -162,12 +157,7 @@ async def ast_grep_search(pattern: str, directory: str = ".", language: str = ""
             cmd.extend(["--lang", language])
         cmd.append("--json")
         
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=60,
-        )
+        result = await async_execute(cmd, timeout=60)
         
         if result.returncode != 0 and not result.stdout:
             return result.stderr or "No matches found"
@@ -191,15 +181,18 @@ async def ast_grep_search(pattern: str, directory: str = ".", language: str = ""
             
     except FileNotFoundError:
         return "ast-grep (sg) not found. Install with: npm install -g @ast-grep/cli"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Search timed out"
     except Exception as e:
         return f"Error: {str(e)}"
 
 
+from mcp_bridge.native_search import native_glob_files, native_grep_search
+
+
 async def grep_search(pattern: str, directory: str = ".", file_pattern: str = "") -> str:
     """
-    Fast text search using ripgrep.
+    Fast text search using ripgrep (or native Rust implementation if available).
 
     Args:
         pattern: Search pattern (supports regex)
@@ -214,17 +207,29 @@ async def grep_search(pattern: str, directory: str = ".", file_pattern: str = ""
     glob_info = f" glob={file_pattern}" if file_pattern else ""
     print(f"🔎 GREP: pattern='{pattern[:50]}'{glob_info} dir={directory}", file=sys.stderr)
 
+    # Try native implementation first (currently doesn't support file_pattern filter in the same way)
+    # If file_pattern is provided, we still use rg for now as it's more flexible with globs
+    if not file_pattern:
+        native_results = await native_grep_search(pattern, directory)
+        if native_results is not None:
+            if not native_results:
+                return "No matches found"
+            
+            lines = []
+            for r in native_results[:50]:
+                lines.append(f"{r['path']}:{r['line']}: {r['content']}")
+            
+            if len(native_results) > 50:
+                lines.append(f"... and more (showing first 50 matches)")
+            
+            return "\n".join(lines)
+
     try:
         cmd = ["rg", "--line-number", "--max-count=50", pattern, directory]
         if file_pattern:
             cmd.extend(["--glob", file_pattern])
         
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
+        result = await async_execute(cmd, timeout=30)
         
         output = result.stdout
         if not output.strip():
@@ -234,13 +239,13 @@ async def grep_search(pattern: str, directory: str = ".", file_pattern: str = ""
         lines = output.strip().split("\n")
         if len(lines) > 50:
             lines = lines[:50]
-            lines.append(f"... and more (showing first 50 matches)")
+            lines.append("... and more (showing first 50 matches)")
         
         return "\n".join(lines)
         
     except FileNotFoundError:
         return "ripgrep (rg) not found. Install with: brew install ripgrep"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Search timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -248,7 +253,7 @@ async def grep_search(pattern: str, directory: str = ".", file_pattern: str = ""
 
 async def glob_files(pattern: str, directory: str = ".") -> str:
     """
-    Find files matching a glob pattern.
+    Find files matching a glob pattern (uses native Rust implementation if available).
 
     Args:
         pattern: Glob pattern (e.g., "**/*.py", "src/**/*.ts")
@@ -261,15 +266,24 @@ async def glob_files(pattern: str, directory: str = ".") -> str:
     import sys
     print(f"📁 GLOB: pattern='{pattern}' dir={directory}", file=sys.stderr)
 
+    # Try native implementation first
+    native_results = await native_glob_files(pattern, directory)
+    if native_results is not None:
+        if not native_results:
+            return "No files found"
+        
+        # Limit output
+        lines = native_results
+        if len(lines) > 100:
+            lines = lines[:100]
+            lines.append(f"... and {len(native_results) - 100} more files")
+        
+        return "\n".join(lines)
+
     try:
         cmd = ["fd", "--type", "f", "--glob", pattern, directory]
         
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
+        result = await async_execute(cmd, timeout=30)
         
         output = result.stdout
         if not output.strip():
@@ -285,7 +299,7 @@ async def glob_files(pattern: str, directory: str = ".") -> str:
         
     except FileNotFoundError:
         return "fd not found. Install with: brew install fd"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Search timed out"
     except Exception as e:
         return f"Error: {str(e)}"
@@ -329,12 +343,7 @@ async def ast_grep_replace(
         if dry_run:
             # Show what would change
             cmd.append("--json")
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=60,
-            )
+            result = await async_execute(cmd, timeout=60)
             
             if result.returncode != 0 and not result.stdout:
                 return result.stderr or "No matches found"
@@ -366,12 +375,7 @@ async def ast_grep_replace(
             if language:
                 cmd_apply.extend(["--lang", language])
             
-            result = subprocess.run(
-                cmd_apply,
-                capture_output=True,
-                text=True,
-                timeout=60,
-            )
+            result = await async_execute(cmd_apply, timeout=60)
             
             if result.returncode == 0:
                 return f"✅ Successfully applied replacement:\n- Pattern: `{pattern}`\n- Replacement: `{replacement}`\n\n{result.stdout}"
@@ -380,8 +384,7 @@ async def ast_grep_replace(
             
     except FileNotFoundError:
         return "ast-grep (sg) not found. Install with: npm install -g @ast-grep/cli"
-    except subprocess.TimeoutExpired:
+    except asyncio.TimeoutError:
         return "Replacement timed out"
     except Exception as e:
-        return f"Error: {str(e)}"
-
+        return f"Error: {str(e)}"

mcp_bridge/tools/continuous_loop.py

@@ -7,7 +7,6 @@ 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__)
 

mcp_bridge/tools/dashboard.py

@@ -0,0 +1,19 @@
+import os
+from mcp_bridge.metrics.cost_tracker import get_cost_tracker
+
+async def get_cost_report(session_id: str | None = None) -> str:
+    """Get a cost report for the current or specified session."""
+    tracker = get_cost_tracker()
+    summary = tracker.get_session_summary(session_id)
+    
+    lines = ["## Agent Cost Report"]
+    lines.append(f"**Total Cost**: ${summary['total_cost']:.4f}")
+    lines.append(f"**Total Tokens**: {summary['total_tokens']:,}")
+    lines.append("")
+    lines.append("| Agent | Tokens | Cost |")
+    lines.append("|---|---|---|")
+    
+    for agent, data in summary["by_agent"].items():
+        lines.append(f"| {agent} | {data['tokens']:,} | ${data['cost']:.4f} |")
+        
+    return "\n".join(lines)

mcp_bridge/tools/find_code.py

@@ -0,0 +1,296 @@
+"""
+Smart code search routing tool.
+
+Automatically routes queries to the optimal search strategy:
+- AST patterns (e.g., "class $X", "def $FUNC") → ast_grep_search
+- Natural language (e.g., "authentication logic") → semantic_search
+- Complex queries (e.g., "JWT AND middleware") → hybrid_search
+"""
+
+import re
+from typing import Literal
+
+# Import search tools
+from mcp_bridge.tools.code_search import ast_grep_search, grep_search
+from mcp_bridge.tools.semantic_search import semantic_search, hybrid_search
+from mcp_bridge.tools.search_enhancements import git_context_search
+
+
+SearchType = Literal["auto", "exact", "semantic", "hybrid", "ast", "grep", "context"]
+
+
+def has_ast_pattern(query: str) -> bool:
+    """
+    Detect if query contains AST-grep pattern syntax.
+
+    AST-grep patterns use metavariables ($VAR, $$$) and structural markers.
+
+    Examples:
+        - "class $NAME" → True (has metavariable)
+        - "def $FUNC($$$):" → True (has metavariable and wildcard)
+        - "interface{}" → True (structural pattern)
+        - "find auth code" → False (natural language)
+    """
+    # AST-grep metavariable patterns
+    if re.search(r'\$[A-Z_]+', query):  # $VAR, $NAME, etc.
+        return True
+    if re.search(r'\$\$\$', query):  # Wildcard args
+        return True
+
+    # Common structural patterns (without natural language words)
+    structural_keywords = [
+        r'\bclass\s+\w+\s*[:{(]',  # class Foo: or class Foo {
+        r'\bdef\s+\w+\s*\(',        # def func(
+        r'\bfunction\s+\w+\s*\(',   # function func(
+        r'\binterface\s+\w+\s*[{<]', # interface Foo {
+        r'\bstruct\s+\w+\s*[{<]',   # struct Foo {
+    ]
+
+    for pattern in structural_keywords:
+        if re.search(pattern, query):
+            # Only if it looks like code, not prose
+            # "class Foo:" is code, "class that handles auth" is prose
+            if not re.search(r'\b(that|which|handles|manages|for|with|the)\b', query, re.IGNORECASE):
+                return True
+
+    return False
+
+
+def has_boolean_operators(query: str) -> bool:
+    """
+    Detect boolean operators indicating complex query logic.
+
+    Examples:
+        - "JWT AND middleware" → True
+        - "auth OR login" → True
+        - "NOT deprecated" → True
+        - "authentication logic" → False
+    """
+    # Match boolean operators (case-insensitive, word boundaries)
+    return bool(re.search(r'\b(AND|OR|NOT)\b', query, re.IGNORECASE))
+
+
+def is_natural_language(query: str) -> bool:
+    """
+    Detect if query is natural language vs code pattern.
+
+    Natural language queries use prose phrases, not code syntax.
+
+    Examples:
+        - "find authentication logic" → True
+        - "error handling patterns" → True
+        - "class $NAME" → False (AST pattern)
+        - "JWT middleware" → True (conceptual)
+    """
+    # If it's an AST pattern, it's not natural language
+    if has_ast_pattern(query):
+        return False
+
+    # Natural language indicators
+    nl_indicators = [
+        r'\b(find|search|look for|locate|where|show|get)\b',  # Action verbs
+        r'\b(all|any|every|some)\b',  # Quantifiers
+        r'\b(that|which|with|using|for)\b',  # Connectors
+        r'\b(logic|code|pattern|implementation|function|method|class)\b',  # Meta terms
+        r'\b(how|what|when|why)\b',  # Question words
+    ]
+
+    for pattern in nl_indicators:
+        if re.search(pattern, query, re.IGNORECASE):
+            return True
+
+    # If query has spaces and no code symbols, likely natural language
+    if ' ' in query and not re.search(r'[(){}\[\]<>;,]', query):
+        return True
+
+    return False
+
+
+def detect_search_type(query: str) -> SearchType:
+    """
+    Auto-detect optimal search type based on query pattern.
+
+    Detection logic:
+    1. AST pattern → "ast" (ast_grep_search)
+    2. Boolean operators + natural language → "hybrid" (hybrid_search)
+    3. Natural language → "semantic" (semantic_search)
+    4. Simple text → "grep" (grep_search)
+
+    Args:
+        query: Search query string
+
+    Returns:
+        Detected search type (ast/hybrid/semantic/grep)
+    """
+    # Priority 1: AST patterns
+    if has_ast_pattern(query):
+        return "ast"
+
+    # Priority 2: Complex boolean queries
+    if has_boolean_operators(query):
+        return "hybrid"
+
+    # Priority 3: Natural language
+    if is_natural_language(query):
+        return "semantic"
+
+    # Default: Simple text search
+    return "grep"
+
+
+async def find_code(
+    query: str,
+    search_type: SearchType = "auto",
+    project_path: str = ".",
+    language: str | None = None,
+    n_results: int = 10,
+    provider: str = "ollama",
+) -> str:
+    """
+    Smart code search with automatic routing to optimal search strategy.
+
+    Automatically detects whether query is:
+    - AST pattern (e.g., "class $X") → routes to ast_grep_search
+    - Natural language (e.g., "auth logic") → routes to semantic_search
+    - Complex query (e.g., "JWT AND middleware") → routes to hybrid_search
+    - Simple text → routes to grep_search
+
+    Args:
+        query: Search query (pattern or natural language)
+        search_type: Search strategy ("auto" for detection, or "ast"/"semantic"/"hybrid"/"grep")
+        project_path: Path to project root (default: ".")
+        language: Filter by language (e.g., "py", "ts", "js")
+        n_results: Maximum results to return (default: 10)
+        provider: Embedding provider for semantic search (default: "ollama")
+
+    Returns:
+        Formatted search results with file paths and code snippets.
+
+    Examples:
+        # AST pattern search (auto-detected)
+        find_code("class $NAME")
+
+        # Semantic search (auto-detected)
+        find_code("authentication logic")
+
+        # Hybrid search (auto-detected)
+        find_code("JWT AND middleware")
+
+        # Force specific search type
+        find_code("error handling", search_type="semantic")
+    """
+    # Auto-detect search type if requested
+    if search_type == "auto":
+        detected_type = detect_search_type(query)
+        search_type = detected_type
+
+    # Route to appropriate search tool
+    if search_type == "ast":
+        # AST-grep search for structural patterns
+        return await ast_grep_search(
+            pattern=query,
+            directory=project_path,
+            language=language or "",
+        )
+
+    elif search_type == "semantic":
+        # Semantic search for natural language queries
+        return await semantic_search(
+            query=query,
+            project_path=project_path,
+            n_results=n_results,
+            language=language,
+            provider=provider,  # type: ignore
+        )
+
+    elif search_type == "hybrid":
+        # Hybrid search for complex queries
+        # Parse boolean operators into pattern if possible
+        pattern = None
+        if has_boolean_operators(query):
+            # For now, pass full query to semantic, rely on hybrid's logic
+            # Future: parse "JWT AND middleware" into pattern
+            pass
+
+        return await hybrid_search(
+            query=query,
+            pattern=pattern,
+            project_path=project_path,
+            n_results=n_results,
+            language=language,
+            provider=provider,  # type: ignore
+        )
+
+    elif search_type in ("grep", "exact"):
+        # Text-based grep search
+        file_pattern = ""
+        if language:
+            # Map language to file extension
+            lang_map = {
+                "py": "*.py",
+                "python": "*.py",
+                "ts": "*.ts",
+                "typescript": "*.ts",
+                "js": "*.js",
+                "javascript": "*.js",
+                "tsx": "*.tsx",
+                "jsx": "*.jsx",
+                "go": "*.go",
+                "rust": "*.rs",
+                "java": "*.java",
+                "cpp": "*.cpp",
+                "c": "*.c",
+            }
+            file_pattern = lang_map.get(language.lower(), f"*.{language}")
+
+        return await grep_search(
+            pattern=query,
+            directory=project_path,
+            file_pattern=file_pattern,
+        )
+
+    elif search_type == "context":
+        # Git context search
+        return await git_context_search(
+            target_file=query,
+            project_path=project_path,
+        )
+
+    else:
+        return f"Error: Unknown search_type '{search_type}'. Use 'auto', 'ast', 'semantic', 'hybrid', 'grep', or 'context'."
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    import asyncio
+
+    # Test pattern detection
+    test_cases = [
+        ("class $NAME", "ast"),
+        ("def $FUNC($$$):", "ast"),
+        ("find authentication logic", "semantic"),
+        ("error handling patterns", "semantic"),
+        ("JWT AND middleware", "hybrid"),
+        ("auth OR login", "hybrid"),
+        ("import os", "grep"),
+    ]
+
+    print("Pattern Detection Tests:")
+    print("=" * 60)
+    for query, expected in test_cases:
+        detected = detect_search_type(query)
+        status = "✅" if detected == expected else "❌"
+        print(f"{status} '{query}' → {detected} (expected: {expected})")
+
+    # Test actual search (requires running codebase)
+    async def test_search():
+        print("\n\nSearch Tests:")
+        print("=" * 60)
+
+        # Test semantic search
+        result = await find_code("authentication logic", search_type="auto")
+        print(f"\nQuery: 'authentication logic'")
+        print(f"Result: {result[:200]}...")
+
+    # Uncomment to run tests
+    # asyncio.run(test_search())

mcp_bridge/tools/init.py

@@ -4,6 +4,7 @@ Repository bootstrap logic for Stravinsky.
 
 import logging
 from pathlib import Path
+
 from .templates import CLAUDE_MD_TEMPLATE, SLASH_COMMANDS
 
 logger = logging.getLogger(__name__)

mcp_bridge/tools/list_directory.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+from mcp_bridge.utils.cache import IOCache
+
+async def list_directory(path: str) -> str:
+    """
+    List files and directories in a path with caching.
+    """
+    # USER-VISIBLE NOTIFICATION
+    import sys
+    print(f"📂 LIST: {path}", file=sys.stderr)
+
+    cache = IOCache.get_instance()
+    cache_key = f"list_dir:{os.path.realpath(path)}"
+    
+    cached_result = cache.get(cache_key)
+    if cached_result:
+        return cached_result
+
+    dir_path = Path(path)
+    if not dir_path.exists():
+        return f"Error: Directory not found: {path}"
+    
+    if not dir_path.is_dir():
+        return f"Error: Path is not a directory: {path}"
+
+    try:
+        entries = []
+        # Sort for deterministic output
+        for entry in sorted(dir_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
+            entry_type = "DIR" if entry.is_dir() else "FILE"
+            entries.append(f"[{entry_type}] {entry.name}")
+        
+        result = "\n".join(entries) if entries else "(empty directory)"
+        
+        # Cache for 5 seconds
+        cache.set(cache_key, result)
+        
+        return result
+
+    except Exception as e:
+        return f"Error listing directory {path}: {str(e)}"