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

mcp_bridge/hooks/tmux_manager.py

@@ -5,19 +5,18 @@ Manages persistent tmux sessions and cleanup.
 """
 
 import logging
-import re
 import shlex
 import subprocess
-from typing import Any, Dict, List, Optional, Set
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
 # Track tmux sessions created by Stravinsky
-_tracked_sessions: Set[str] = set()
+_tracked_sessions: set[str] = set()
 SESSION_PREFIX = "stravinsky-"
 
 
-def parse_tmux_command(command: str) -> Optional[str]:
+def parse_tmux_command(command: str) -> str | None:
     """
     Parse tmux command to extract session name.
 
@@ -65,8 +64,8 @@ def normalize_session_name(name: str) -> str:
 
 
 async def tmux_manager_hook(
-    tool_name: str, tool_input: Dict[str, Any], tool_output: Optional[str] = None
-) -> Optional[str]:
+    tool_name: str, tool_input: dict[str, Any], tool_output: str | None = None
+) -> str | None:
     """
     Post-tool-call hook that tracks tmux sessions.
 
@@ -100,7 +99,7 @@ async def tmux_manager_hook(
     return tool_output
 
 
-def cleanup_tmux_sessions() -> List[str]:
+def cleanup_tmux_sessions() -> list[str]:
     """
     Kill all tracked tmux sessions.
 
@@ -134,7 +133,7 @@ def cleanup_tmux_sessions() -> List[str]:
     return killed
 
 
-def get_tracked_sessions() -> Set[str]:
+def get_tracked_sessions() -> set[str]:
     """
     Get set of currently tracked tmux sessions.
     """

mcp_bridge/hooks/todo_delegation.py

@@ -12,6 +12,7 @@ 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
@@ -77,7 +78,9 @@ DO NOT:
 
 Your NEXT action MUST be multiple Task() calls, one for each independent TODO.
 """
-    print(error_message, file=sys.stderr)
+    # CRITICAL: Output to stdout so Claude sees the message
+    # stderr is not reliably injected into the conversation
+    print(error_message)
 
     # Exit code 2 = HARD BLOCK in stravinsky mode
     # Exit code 1 = WARNING otherwise

mcp_bridge/hooks/todo_enforcer.py

@@ -3,49 +3,84 @@ Todo Continuation Enforcer Hook.
 
 Prevents early stopping when pending todos exist.
 Injects a system reminder forcing the agent to complete all todos.
+Includes evidence extraction and verification to prevent vague completion claims.
 """
 
 import logging
-from typing import Any, Dict, Optional
+import re
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
 TODO_CONTINUATION_REMINDER = """
-[SYSTEM REMINDER - TODO CONTINUATION]
+[SYSTEM REMINDER - TODO CONTINUATION & VERIFICATION]
 
 You have pending todos that are NOT yet completed. You MUST continue working.
 
 **Pending Todos:**
 {pending_todos}
 
-**Rules:**
-1. You CANNOT stop or deliver a final answer while todos remain pending
-2. Mark each todo `in_progress` before starting, `completed` immediately after
-3. If a todo is blocked, mark it `cancelled` with explanation and create new actionable todos
-4. Only after ALL todos are `completed` or `cancelled` can you deliver your final answer
+**CRITICAL RULES:**
+1. You CANNOT mark a todo completed without CONCRETE EVIDENCE
+2. Evidence = file paths with line numbers (e.g., src/auth.ts:45-67) or tool output
+3. Vague claims like "I created the file" will be REJECTED
+4. Each completed todo MUST include: `✅ [Todo] - Evidence: path/to/file.py:123`
+5. If you cannot provide evidence, the todo is NOT complete - keep working
+6. Use Read tool to verify file contents before claiming completion
 
-CONTINUE WORKING NOW. Do not acknowledge this message - just proceed with the next pending todo.
+**Example GOOD completion:**
+✅ Create auth validation → Evidence: src/auth.ts:45-67 (validateJWT function implemented)
+
+**Example BAD completion (will be REJECTED):**
+✅ Create auth validation → I created the validation logic
+
+{verification_failures}
+
+CONTINUE WORKING NOW with evidence-backed completions.
 """
 
 
-async def todo_continuation_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def todo_continuation_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that checks for pending todos.
 
     If pending todos exist, injects a reminder into the prompt
     forcing the agent to continue working.
+
+    Also extracts evidence from agent output and verifies claims.
     """
     prompt = params.get("prompt", "")
 
+    # Extract pending todos
     pending_todos = _extract_pending_todos(prompt)
 
+    # Extract verification failures from previous output (if any)
+    verification_failures = ""
+    skip_verification = params.get("skip_verification", False)
+
+    if not skip_verification:
+        # Check if there's recent output to verify
+        # This would come from previous agent turns
+        previous_output = params.get("previous_output", "")
+        if previous_output:
+            verification_failures = _verify_agent_claims(previous_output)
+
     if pending_todos:
         logger.info(
             f"[TodoEnforcer] Found {len(pending_todos)} pending todos, injecting continuation reminder"
         )
 
         todos_formatted = "\n".join(f"- [ ] {todo}" for todo in pending_todos)
-        reminder = TODO_CONTINUATION_REMINDER.format(pending_todos=todos_formatted)
+
+        # Format verification failures if any
+        failures_text = ""
+        if verification_failures:
+            failures_text = f"\n\n⚠️ VERIFICATION FAILURES FROM PREVIOUS TURN:\n{verification_failures}\n"
+
+        reminder = TODO_CONTINUATION_REMINDER.format(
+            pending_todos=todos_formatted,
+            verification_failures=failures_text
+        )
 
         modified_prompt = prompt + "\n\n" + reminder
         params["prompt"] = modified_prompt
@@ -73,3 +108,138 @@ def _extract_pending_todos(prompt: str) -> list:
             pass
 
     return pending
+
+
+def _extract_evidence(output: str) -> dict[str, list[str]]:
+    """
+    Extract evidence references (file paths, URLs) from agent output.
+
+    Returns:
+        Dict with keys: 'files', 'urls', 'commands'
+    """
+    evidence = {
+        "files": [],
+        "urls": [],
+        "commands": []
+    }
+
+    # File path pattern: src/auth.ts:45 or /path/to/file.py or path/file.js:10-20
+    # Matches common file extensions and optional line numbers
+    file_pattern = r'(?:^|[\s\(\[])([\w/\._-]+\.(?:py|ts|js|tsx|jsx|go|rs|java|c|cpp|h|hpp|md|json|yaml|yml|toml|sh|rb|php|swift|kt))(?::(\d+)(?:-(\d+))?)?'
+
+    for match in re.finditer(file_pattern, output, re.MULTILINE):
+        file_path = match.group(1)
+        line_start = match.group(2)
+        line_end = match.group(3)
+
+        # Build reference string
+        if line_start:
+            if line_end:
+                ref = f"{file_path}:{line_start}-{line_end}"
+            else:
+                ref = f"{file_path}:{line_start}"
+        else:
+            ref = file_path
+
+        evidence["files"].append(ref)
+
+    # URL pattern
+    url_pattern = r'https?://[^\s\)\]>]+'
+    evidence["urls"] = re.findall(url_pattern, output)
+
+    # Command/tool usage pattern (e.g., "Used Read tool", "Ran grep")
+    command_pattern = r'(?:Used|Ran|Called|Executed)\s+(\w+(?:\s+\w+)?)\s+(?:tool|command)'
+    evidence["commands"] = re.findall(command_pattern, output, re.IGNORECASE)
+
+    return evidence
+
+
+def _verify_file_claim(claim: str, file_references: list[str]) -> dict[str, Any]:
+    """
+    Verify a completion claim has file evidence.
+
+    This is a synchronous check - actual file existence verification
+    would require async Read tool access (not available in hooks).
+
+    Returns:
+        Dict with 'verified' (bool) and 'reason' (str)
+    """
+    # Check if claim has any file references
+    if not file_references:
+        return {
+            "verified": False,
+            "reason": "No file paths provided as evidence"
+        }
+
+    # Check for vague language that indicates lack of actual work
+    vague_patterns = [
+        r'\bI\s+(?:created|made|wrote|added|implemented)\b',  # "I created..."
+        r'\b(?:should|will|would)\s+(?:create|add|implement)\b',  # Future tense
+        r'\b(?:basically|essentially|just|simply)\b',  # Minimizing language
+    ]
+
+    claim_lower = claim.lower()
+    vague_count = sum(1 for pattern in vague_patterns if re.search(pattern, claim_lower))
+
+    if vague_count >= 2:
+        return {
+            "verified": False,
+            "reason": f"Claim uses vague language without concrete evidence. Files mentioned: {', '.join(file_references[:3])}"
+        }
+
+    # If we have file references and no vague language, consider it verified
+    # (Actual file content verification would happen in a post-hook with Read access)
+    return {
+        "verified": True,
+        "reason": f"Evidence provided: {', '.join(file_references[:3])}"
+    }
+
+
+def _verify_agent_claims(output: str) -> str:
+    """
+    Verify agent claims against actual evidence.
+
+    Extracts completion claims and checks for concrete evidence.
+
+    Returns:
+        Formatted string of verification failures (empty if all verified)
+    """
+    # Extract evidence from output
+    evidence = _extract_evidence(output)
+
+    # Look for completion claims (✅, "completed", "done", etc.)
+    completion_patterns = [
+        r'✅\s+(.+?)(?:\n|$)',  # Checkmark pattern
+        r'(?:Completed|Finished|Done):\s*(.+?)(?:\n|$)',  # Explicit completion
+        r'"status":\s*"completed".*?"content":\s*"(.+?)"',  # JSON todo format
+    ]
+
+    claims = []
+    for pattern in completion_patterns:
+        matches = re.finditer(pattern, output, re.IGNORECASE | re.DOTALL)
+        for match in matches:
+            claim_text = match.group(1).strip()
+            if claim_text:
+                claims.append(claim_text)
+
+    if not claims:
+        # No completion claims found, nothing to verify
+        return ""
+
+    # Verify each claim
+    failures = []
+    for claim in claims:
+        verification = _verify_file_claim(claim, evidence["files"])
+        if not verification["verified"]:
+            failures.append(f"- {claim[:100]}... → {verification['reason']}")
+
+    if failures:
+        return "\n".join([
+            "The following completion claims lack concrete evidence:",
+            *failures,
+            "",
+            "REQUIRED: Provide file paths with line numbers (e.g., src/auth.ts:45-67)",
+            "Use the Read tool to verify files exist before claiming completion."
+        ])
+
+    return ""

mcp_bridge/hooks/truncation_policy.py

@@ -0,0 +1,37 @@
+from .events import EventType, HookPolicy, PolicyResult, ToolCallEvent
+from ..utils.truncation import truncate_output, TruncationStrategy
+
+
+class TruncationPolicy(HookPolicy):
+    def __init__(self, max_chars: int = 20000):
+        self.max_chars = max_chars
+
+    @property
+    def event_type(self) -> EventType:
+        return EventType.POST_TOOL_CALL
+
+    async def evaluate(self, event: ToolCallEvent) -> PolicyResult:
+        if not event.output or len(event.output) <= self.max_chars:
+            return PolicyResult(modified_data=event.output)
+
+        # Skip truncation for read_file since it handles its own truncation with log-awareness
+        if event.tool_name == "read_file":
+            return PolicyResult(modified_data=event.output)
+
+        # Use middle truncation for general tool outputs
+        modified = truncate_output(
+            event.output, 
+            limit=self.max_chars, 
+            strategy=TruncationStrategy.MIDDLE
+        )
+        
+        return PolicyResult(
+            modified_data=modified,
+            message=modified,  # Message is what gets printed in run_as_native
+        )
+
+
+if __name__ == "__main__":
+    policy = TruncationPolicy()
+    policy.run_as_native()
+

mcp_bridge/hooks/truncator.py

@@ -1,6 +1,5 @@
-import os
-import sys
 import json
+import sys
 
 MAX_CHARS = 30000
 

mcp_bridge/metrics/cost_tracker.py

@@ -0,0 +1,115 @@
+import json
+import time
+import os
+from pathlib import Path
+from dataclasses import dataclass, asdict
+import threading
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Approximate costs per 1M tokens (Input/Output)
+MODEL_COSTS = {
+    "gemini-3-flash": (0.075, 0.30),
+    "gemini-3-pro": (1.25, 5.00),
+    "gpt-5.2-codex": (2.50, 10.00), # Estimated based on GPT-4o
+    "gpt-4o": (2.50, 10.00),
+    "claude-3-5-sonnet": (3.00, 15.00),
+    "claude-3-5-haiku": (0.25, 1.25),
+}
+
+@dataclass
+class CostRecord:
+    timestamp: float
+    model: str
+    input_tokens: int
+    output_tokens: int
+    cost: float
+    agent_type: str
+    task_id: str
+    session_id: str
+
+class CostTracker:
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __init__(self):
+        self.file_path = Path.home() / ".stravinsky" / "usage.jsonl"
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        # Default to Flash pricing if unknown
+        input_price, output_price = MODEL_COSTS.get(model, MODEL_COSTS["gemini-3-flash"])
+        return (input_tokens / 1_000_000 * input_price) + (output_tokens / 1_000_000 * output_price)
+
+    def track_usage(self, model: str, input_tokens: int, output_tokens: int, agent_type: str = "unknown", task_id: str = ""):
+        cost = self.calculate_cost(model, input_tokens, output_tokens)
+        session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+        
+        record = CostRecord(
+            timestamp=time.time(),
+            model=model,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cost=cost,
+            agent_type=agent_type,
+            task_id=task_id,
+            session_id=session_id
+        )
+        
+        try:
+            with open(self.file_path, "a") as f:
+                f.write(json.dumps(asdict(record)) + "\n")
+        except Exception as e:
+            logger.error(f"Failed to write usage record: {e}")
+
+    def get_session_summary(self, session_id: str | None = None) -> dict:
+        if session_id is None:
+            session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+            
+        total_cost = 0.0
+        total_tokens = 0
+        by_agent = {}
+        
+        if not self.file_path.exists():
+            return {"total_cost": 0.0, "total_tokens": 0, "by_agent": {}}
+            
+        try:
+            with open(self.file_path, "r") as f:
+                for line in f:
+                    try:
+                        data = json.loads(line)
+                        if data.get("session_id") == session_id:
+                            cost = data.get("cost", 0.0)
+                            tokens = data.get("input_tokens", 0) + data.get("output_tokens", 0)
+                            agent = data.get("agent_type", "unknown")
+                            
+                            total_cost += cost
+                            total_tokens += tokens
+                            
+                            if agent not in by_agent:
+                                by_agent[agent] = {"cost": 0.0, "tokens": 0}
+                            by_agent[agent]["cost"] += cost
+                            by_agent[agent]["tokens"] += tokens
+                            
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            logger.error(f"Failed to read usage records: {e}")
+            
+        return {
+            "total_cost": total_cost,
+            "total_tokens": total_tokens,
+            "by_agent": by_agent
+        }
+
+def get_cost_tracker():
+    return CostTracker.get_instance()

mcp_bridge/native_search.py

@@ -0,0 +1,93 @@
+"""
+Native Search Wrapper - Optional Rust integration for performance.
+"""
+
+import os
+import logging
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# Attempt to import the native module
+try:
+    import stravinsky_native
+    HAS_NATIVE = True
+except ImportError:
+    HAS_NATIVE = False
+    logger.debug("stravinsky_native module not found. Falling back to CLI tools.")
+
+_executor: Optional[ThreadPoolExecutor] = None
+
+def get_executor() -> ThreadPoolExecutor:
+    """Get the singleton thread pool executor."""
+    global _executor
+    if _executor is None:
+        # Limit worker threads to avoid overwhelming the system
+        _executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="native_ffi")
+    return _executor
+
+async def native_glob_files(pattern: str, directory: str = ".") -> Optional[List[str]]:
+    """
+    Find files matching a glob pattern using Rust implementation.
+    """
+    if not HAS_NATIVE:
+        return None
+    
+    try:
+        # Convert to absolute path for Rust
+        abs_dir = os.path.abspath(directory)
+        loop = asyncio.get_running_loop()
+        
+        # Offload blocking FFI call to thread pool
+        return await loop.run_in_executor(
+            get_executor(), 
+            stravinsky_native.glob_files, 
+            abs_dir, 
+            pattern
+        )
+    except Exception as e:
+        logger.error(f"Native glob_files failed: {e}")
+        return None
+
+async def native_grep_search(pattern: str, directory: str = ".", case_sensitive: bool = False) -> Optional[List[Dict[str, Any]]]:
+    """
+    Fast text search using Rust implementation.
+    """
+    if not HAS_NATIVE:
+        return None
+    
+    try:
+        abs_dir = os.path.abspath(directory)
+        loop = asyncio.get_running_loop()
+        
+        return await loop.run_in_executor(
+            get_executor(),
+            stravinsky_native.grep_search,
+            pattern,
+            abs_dir,
+            case_sensitive
+        )
+    except Exception as e:
+        logger.error(f"Native grep_search failed: {e}")
+        return None
+
+async def native_chunk_code(content: str, language: str) -> Optional[List[Dict[str, Any]]]:
+    """
+    AST-aware code chunking using Rust/tree-sitter.
+    """
+    if not HAS_NATIVE:
+        return None
+    
+    try:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            get_executor(),
+            stravinsky_native.chunk_code,
+            content,
+            language
+        )
+    except Exception as e:
+        logger.error(f"Native chunk_code failed: {e}")
+        return None

mcp_bridge/native_watcher.py

@@ -0,0 +1,118 @@
+"""
+Native Watcher Integration - Rust-based file watching.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import subprocess
+import threading
+from pathlib import Path
+from typing import Optional, Callable
+
+logger = logging.getLogger(__name__)
+
+class NativeFileWatcher:
+    """
+    Python wrapper for the Rust-based stravinsky_watcher binary.
+    """
+    def __init__(self, project_path: str, on_change: Callable[[str, str], None]):
+        self.project_path = os.path.abspath(project_path)
+        self.on_change = on_change
+        self.process: Optional[subprocess.Popen] = None
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def _get_binary_path(self) -> Path:
+        """Find the stravinsky_watcher binary."""
+        # Try relative to this file
+        root_dir = Path(__file__).parent.parent
+        candidates = [
+            root_dir / "rust_native" / "target" / "release" / "stravinsky_watcher",
+            root_dir / "rust_native" / "target" / "debug" / "stravinsky_watcher",
+        ]
+        
+        for c in candidates:
+            if c.exists():
+                return c
+        
+        raise FileNotFoundError("stravinsky_watcher binary not found. Build it with cargo first.")
+
+    def start(self):
+        """Start the native watcher process in a background thread."""
+        if self.process:
+            return
+
+        binary_path = self._get_binary_path()
+        logger.info(f"Starting native watcher: {binary_path} {self.project_path}")
+        
+        self.process = subprocess.Popen(
+            [str(binary_path), self.project_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1
+        )
+
+        self._thread = threading.Thread(target=self._read_stdout, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the native watcher process."""
+        self._stop_event.set()
+        
+        if self.process:
+            logger.info(f"Stopping native watcher process (PID: {self.process.pid})")
+            # Try to terminate gracefully first
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=1.0)
+            except subprocess.TimeoutExpired:
+                logger.warning(f"Native watcher (PID: {self.process.pid}) did not terminate, killing...")
+                self.process.kill()
+                try:
+                    self.process.wait(timeout=1.0)
+                except subprocess.TimeoutExpired:
+                    logger.error(f"Failed to kill native watcher (PID: {self.process.pid})")
+            
+            # Close streams
+            if self.process.stdout:
+                self.process.stdout.close()
+            if self.process.stderr:
+                self.process.stderr.close()
+                
+            self.process = None
+            
+        # Wait for reader thread to exit
+        if self._thread and self._thread.is_alive():
+            # Don't join with timeout in main thread if it might block,
+            # but since we closed stdout, the reader loop should break.
+            self._thread.join(timeout=1.0)
+            if self._thread.is_alive():
+                logger.warning("Native watcher reader thread did not exit cleanly")
+            self._thread = None
+
+    def _read_stdout(self):
+        """Read JSON events from the watcher's stdout."""
+        if not self.process or not self.process.stdout:
+            return
+
+        for line in self.process.stdout:
+            if self._stop_event.is_set():
+                break
+            
+            line = line.strip()
+            if not line or not line.startswith("{"):
+                continue
+
+            try:
+                event = json.loads(line)
+                change_type = event.get("type", "unknown")
+                path = event.get("path", "")
+                self.on_change(change_type, path)
+            except json.JSONDecodeError:
+                logger.error(f"Failed to decode watcher event: {line}")
+
+    def is_running(self) -> bool:
+        return self.process is not None and self.process.poll() is None