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

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/tool_messaging.py

@@ -4,9 +4,13 @@ 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')
+- 🔧 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
@@ -23,7 +27,16 @@ AGENT_MODELS = {
     "delphi": "gpt-5.2-medium",
 }
 
-# Tool display names
+# 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",
@@ -41,10 +54,98 @@ TOOL_NAMES = {
 }
 
 
+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."""
 
-    # AST-grep
+    # 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", ".")
@@ -136,9 +237,6 @@ def main():
         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")
@@ -148,9 +246,14 @@ def main():
             # Show full agent delegation message
             print(f"🎯 {subagent_type}:{model}('{description}')", file=sys.stderr)
         else:
-            # Regular tool usage
+            # 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)
-            print(f"🔧 {display_name}('{description}')", file=sys.stderr)
+
+            # Format output: emoji tool_type:server('description')
+            print(f"{emoji} {tool_type}:{server}('{description}')", file=sys.stderr)
 
         sys.exit(0)
 

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