stravinsky 0.1.12__py3-none-any.whl

mcp_bridge/tools/background_tasks.py

@@ -0,0 +1,166 @@
+"""
+Background Task Manager for Stravinsky.
+
+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 datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class BackgroundTask:
+    id: str
+    prompt: str
+    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
+
+
+class BackgroundManager:
+    def __init__(self, base_dir: Optional[str] = None):
+        if base_dir:
+            self.base_dir = Path(base_dir)
+        else:
+            # Default to .stravinsky in the current working directory
+            self.base_dir = Path.cwd() / ".stravinsky"
+        
+        self.tasks_dir = self.base_dir / "tasks"
+        self.state_file = self.base_dir / "tasks.json"
+        
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.tasks_dir.mkdir(parents=True, exist_ok=True)
+        
+        if not self.state_file.exists():
+            self._save_tasks({})
+
+    def _load_tasks(self) -> Dict[str, Any]:
+        try:
+            with open(self.state_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return {}
+
+    def _save_tasks(self, tasks: Dict[str, Any]):
+        with open(self.state_file, "w") as f:
+            json.dump(tasks, f, indent=2)
+
+    def create_task(self, prompt: str, model: str) -> str:
+        task_id = str(uuid.uuid4())[:8]
+        task = BackgroundTask(
+            id=task_id,
+            prompt=prompt,
+            model=model,
+            status="pending",
+            created_at=datetime.isoformat(datetime.now()),
+        )
+        
+        tasks = self._load_tasks()
+        tasks[task_id] = asdict(task)
+        self._save_tasks(tasks)
+        return task_id
+
+    def update_task(self, task_id: str, **kwargs):
+        tasks = self._load_tasks()
+        if task_id in tasks:
+            tasks[task_id].update(kwargs)
+            self._save_tasks(tasks)
+
+    def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        tasks = self._load_tasks()
+        return tasks.get(task_id)
+
+    def list_tasks(self) -> List[Dict[str, Any]]:
+        tasks = self._load_tasks()
+        return list(tasks.values())
+
+    def spawn(self, task_id: str):
+        """
+        Spawns a background process to execute the task.
+        In this implementation, it uses another instance of the MCP bridge
+        or a dedicated tool invoker script.
+        """
+        task = self.get_task(task_id)
+        if not task:
+            return
+
+        # We'll use a wrapper script that handles the model invocation and updates the status
+        # mcp_bridge/tools/task_runner.py (we will create this)
+        
+        log_file = self.tasks_dir / f"{task_id}.log"
+        
+        # Start the background process
+        cmd = [
+            sys.executable,
+            "-m", "mcp_bridge.tools.task_runner",
+            "--task-id", task_id,
+            "--base-dir", str(self.base_dir)
+        ]
+        
+        try:
+            # Using Popen to run in background
+            process = subprocess.Popen(
+                cmd,
+                stdout=open(log_file, "w"),
+                stderr=subprocess.STDOUT,
+                start_new_session=True # Run in its own session so it doesn't die with the server
+            )
+            
+            self.update_task(task_id, status="running", pid=process.pid, started_at=datetime.isoformat(datetime.now()))
+        except Exception as e:
+            self.update_task(task_id, status="failed", error=str(e))
+
+
+# Tool interface functions
+
+async def task_spawn(prompt: str, model: str = "gemini-3-flash") -> str:
+    """Spawns a new background task."""
+    manager = BackgroundManager()
+    task_id = manager.create_task(prompt, model)
+    manager.spawn(task_id)
+    return f"Task spawned with ID: {task_id}. Use task_status('{task_id}') to check progress."
+
+
+async def task_status(task_id: str) -> str:
+    """Checks the status of a background task."""
+    manager = BackgroundManager()
+    task = manager.get_task(task_id)
+    if not task:
+        return f"Task {task_id} not found."
+    
+    status = task["status"]
+    if status == "completed":
+        return f"Task {task_id} COMPLETED:\n\n{task.get('result')}"
+    elif status == "failed":
+        return f"Task {task_id} FAILED:\n\n{task.get('error')}"
+    else:
+        return f"Task {task_id} is currently {status} (PID: {task.get('pid')})."
+
+
+async def task_list() -> str:
+    """Lists all background tasks."""
+    manager = BackgroundManager()
+    tasks = manager.list_tasks()
+    if not tasks:
+        return "No background tasks found."
+    
+    lines = ["Background Tasks:"]
+    for t in tasks:
+        lines.append(f"- [{t['id']}] {t['status']}: {t['prompt'][:50]}...")
+    
+    return "\n".join(lines)

mcp_bridge/tools/code_search.py

@@ -0,0 +1,301 @@
+"""
+LSP Tools - Language Server Protocol Operations
+
+These tools provide LSP functionality for Claude Code via subprocess calls
+to language servers. Claude Code has native LSP support, so these serve as
+supplementary utilities for advanced operations.
+"""
+
+import asyncio
+import json
+import subprocess
+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.
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return f"Error: File not found: {file_path}"
+    
+    suffix = path.suffix.lower()
+    
+    try:
+        if suffix in (".ts", ".tsx", ".js", ".jsx"):
+            # Use TypeScript compiler for diagnostics
+            result = subprocess.run(
+                ["npx", "tsc", "--noEmit", "--pretty", str(path)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            output = result.stdout + result.stderr
+            if not output.strip():
+                return "No diagnostics found"
+            return output
+            
+        elif suffix == ".py":
+            # Use ruff for Python diagnostics
+            result = subprocess.run(
+                ["ruff", "check", str(path), "--output-format=text"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            output = result.stdout + result.stderr
+            if not output.strip():
+                return "No diagnostics found"
+            return output
+            
+        else:
+            return f"No diagnostics available for file type: {suffix}"
+            
+    except FileNotFoundError as e:
+        return f"Tool not found: {e.filename}. Install required tools."
+    except subprocess.TimeoutExpired:
+        return "Diagnostics timed out"
+    except Exception as e:
+        return f"Error: {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.
+    """
+    try:
+        cmd = ["sg", "run", "-p", pattern, directory]
+        if language:
+            cmd.extend(["--lang", language])
+        cmd.append("--json")
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        
+        if result.returncode != 0 and not result.stdout:
+            return result.stderr or "No matches found"
+        
+        # Parse and format JSON output
+        try:
+            matches = json.loads(result.stdout)
+            if not matches:
+                return "No matches found"
+            
+            lines = []
+            for match in matches[:20]:  # Limit to 20 results
+                file_path = match.get("file", "unknown")
+                start_line = match.get("range", {}).get("start", {}).get("line", 0)
+                text = match.get("text", "")
+                lines.append(f"{file_path}:{start_line}: {text[:100]}")
+            
+            return "\n".join(lines)
+        except json.JSONDecodeError:
+            return result.stdout or "No matches found"
+            
+    except FileNotFoundError:
+        return "ast-grep (sg) not found. Install with: npm install -g @ast-grep/cli"
+    except subprocess.TimeoutExpired:
+        return "Search timed out"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+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.
+    """
+    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,
+        )
+        
+        output = result.stdout
+        if not output.strip():
+            return "No matches found"
+        
+        # Limit output lines
+        lines = output.strip().split("\n")
+        if len(lines) > 50:
+            lines = lines[:50]
+            lines.append(f"... 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:
+        return "Search timed out"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+async def glob_files(pattern: str, directory: str = ".") -> str:
+    """
+    Find files matching a glob pattern.
+    
+    Args:
+        pattern: Glob pattern (e.g., "**/*.py", "src/**/*.ts")
+        directory: Base directory for search
+        
+    Returns:
+        List of matching file paths.
+    """
+    try:
+        cmd = ["fd", "--type", "f", "--glob", pattern, directory]
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        
+        output = result.stdout
+        if not output.strip():
+            return "No files found"
+        
+        # Limit output
+        lines = output.strip().split("\n")
+        if len(lines) > 100:
+            lines = lines[:100]
+            lines.append(f"... and {len(lines) - 100} more files")
+        
+        return "\n".join(lines)
+        
+    except FileNotFoundError:
+        return "fd not found. Install with: brew install fd"
+    except subprocess.TimeoutExpired:
+        return "Search timed out"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+async def ast_grep_replace(
+    pattern: str,
+    replacement: str,
+    directory: str = ".",
+    language: str = "",
+    dry_run: bool = True
+) -> str:
+    """
+    Replace code patterns using ast-grep's AST-aware replacement.
+    
+    ast-grep uses structural pattern matching for precise code transformations.
+    More reliable than text-based search/replace for refactoring.
+    
+    Args:
+        pattern: ast-grep pattern to search for (e.g., "console.log($A)")
+        replacement: Replacement pattern (e.g., "logger.debug($A)")
+        directory: Directory to search in
+        language: Filter by language (typescript, python, rust, etc.)
+        dry_run: If True (default), only show what would change without applying
+        
+    Returns:
+        Preview of changes or confirmation of applied changes.
+    """
+    try:
+        # Build command
+        cmd = ["sg", "run", "-p", pattern, "-r", replacement, directory]
+        if language:
+            cmd.extend(["--lang", language])
+        
+        if dry_run:
+            # Show what would change
+            cmd.append("--json")
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            
+            if result.returncode != 0 and not result.stdout:
+                return result.stderr or "No matches found"
+            
+            try:
+                matches = json.loads(result.stdout)
+                if not matches:
+                    return "No matches found for pattern"
+                
+                lines = [f"**Dry run** - {len(matches)} matches found:"]
+                for match in matches[:15]:
+                    file_path = match.get("file", "unknown")
+                    start_line = match.get("range", {}).get("start", {}).get("line", 0)
+                    original = match.get("text", "")[:80]
+                    lines.append(f"\n`{file_path}:{start_line}`")
+                    lines.append(f"```\n{original}\n```")
+                
+                if len(matches) > 15:
+                    lines.append(f"\n... and {len(matches) - 15} more matches")
+                
+                lines.append("\n**To apply changes**, call with `dry_run=False`")
+                return "\n".join(lines)
+                
+            except json.JSONDecodeError:
+                return result.stdout or "No matches found"
+        else:
+            # Actually apply the changes
+            cmd_apply = ["sg", "run", "-p", pattern, "-r", replacement, directory, "--update-all"]
+            if language:
+                cmd_apply.extend(["--lang", language])
+            
+            result = subprocess.run(
+                cmd_apply,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            
+            if result.returncode == 0:
+                return f"✅ Successfully applied replacement:\n- Pattern: `{pattern}`\n- Replacement: `{replacement}`\n\n{result.stdout}"
+            else:
+                return f"❌ Failed to apply replacement:\n{result.stderr}"
+            
+    except FileNotFoundError:
+        return "ast-grep (sg) not found. Install with: npm install -g @ast-grep/cli"
+    except subprocess.TimeoutExpired:
+        return "Replacement timed out"
+    except Exception as e:
+        return f"Error: {str(e)}"
+

mcp_bridge/tools/continuous_loop.py

@@ -0,0 +1,67 @@
+"""
+Continuous Loop (Ralph Loop) for Stravinsky.
+
+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__)
+
+async def enable_ralph_loop(goal: str, max_iterations: int = 10) -> str:
+    """
+    Enable continuous processing until a goal is met.
+    
+    Args:
+        goal: The goal to achieve and verify.
+        max_iterations: Maximum number of iterations before stopping.
+    """
+    project_root = Path.cwd()
+    settings_file = project_root / ".claude" / "settings.json"
+    
+    settings = {}
+    if settings_file.exists():
+        try:
+            settings = json.loads(settings_file.read_text())
+        except:
+            pass
+            
+    if "hooks" not in settings:
+        settings["hooks"] = {}
+        
+    # Set the Stop hook to re-trigger if goal not met
+    # Note: Stravinsky's prompt will handle the internal logic 
+    # but the presence of this hook signals "Continue" to Claude Code.
+    settings["hooks"]["Stop"] = [
+        {
+            "type": "command",
+            "command": f'echo "Looping for goal: {goal}"',
+        }
+    ]
+    
+    settings_file.parent.mkdir(parents=True, exist_ok=True)
+    settings_file.write_text(json.dumps(settings, indent=2))
+    
+    return f"🔄 Ralph Loop ENABLED. Goal: {goal}. Stravinsky will now process continuously until completion."
+
+async def disable_ralph_loop() -> str:
+    """Disable the autonomous loop."""
+    project_root = Path.cwd()
+    settings_file = project_root / ".claude" / "settings.json"
+    
+    if not settings_file.exists():
+        return "Ralph Loop is already disabled."
+        
+    try:
+        settings = json.loads(settings_file.read_text())
+        if "hooks" in settings and "Stop" in settings["hooks"]:
+            del settings["hooks"]["Stop"]
+            settings_file.write_text(json.dumps(settings, indent=2))
+            return "✅ Ralph Loop DISABLED."
+    except:
+        pass
+        
+    return "Failed to disable Ralph Loop or it was not active."

mcp_bridge/tools/lsp/__init__.py

@@ -0,0 +1,29 @@
+"""
+LSP Tools Package
+
+Provides Language Server Protocol functionality for code intelligence.
+"""
+
+from .tools import (
+    lsp_hover,
+    lsp_goto_definition,
+    lsp_find_references,
+    lsp_document_symbols,
+    lsp_workspace_symbols,
+    lsp_prepare_rename,
+    lsp_rename,
+    lsp_code_actions,
+    lsp_servers,
+)
+
+__all__ = [
+    "lsp_hover",
+    "lsp_goto_definition",
+    "lsp_find_references",
+    "lsp_document_symbols",
+    "lsp_workspace_symbols",
+    "lsp_prepare_rename",
+    "lsp_rename",
+    "lsp_code_actions",
+    "lsp_servers",
+]