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

mcp_bridge/cli/session_report.py

@@ -8,8 +8,6 @@ Optionally uses Gemini for session summarization.
 
 import argparse
 import json
-import os
-import re
 import sys
 from collections import Counter
 from datetime import datetime
@@ -23,7 +21,6 @@ from rich.table import Table
 from rich.text import Text
 from rich.tree import Tree
 
-
 console = Console()
 
 

mcp_bridge/config/__init__.py

@@ -1,9 +1,9 @@
 # Configuration module
 from .hooks import (
-    get_hooks_config,
-    list_hook_scripts,
     configure_hook,
     get_hook_documentation,
+    get_hooks_config,
+    list_hook_scripts,
 )
 
 __all__ = [

mcp_bridge/config/hook_config.py

@@ -5,10 +5,8 @@ Provides batteries-included defaults with user-configurable overrides.
 Users can disable specific hooks via ~/.stravinsky/disable_hooks.txt
 """
 
-import os
-from pathlib import Path
-from typing import Set, Optional
 import logging
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
@@ -20,7 +18,7 @@ DISABLE_HOOKS_PATHS = [
 ]
 
 
-def get_disabled_hooks() -> Set[str]:
+def get_disabled_hooks() -> set[str]:
     """
     Load disabled hooks from config files.
 
@@ -74,7 +72,7 @@ def get_hook_config_path() -> Path:
     return config_dir
 
 
-def create_sample_disable_hooks() -> Optional[Path]:
+def create_sample_disable_hooks() -> Path | None:
     """
     Create a sample disable_hooks.txt file with documentation.
 

mcp_bridge/config/rate_limits.py

@@ -17,14 +17,13 @@ Configuration file: ~/.stravinsky/config.json
 }
 """
 
-import asyncio
 import json
+import logging
+import sys
 import threading
+import time
+from collections import defaultdict, deque
 from pathlib import Path
-from typing import Dict, Optional
-from collections import defaultdict
-from datetime import datetime
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -56,13 +55,13 @@ class RateLimiter:
     """
 
     def __init__(self):
-        self._semaphores: Dict[str, threading.Semaphore] = {}
+        self._semaphores: dict[str, threading.Semaphore] = {}
         self._lock = threading.Lock()
         self._limits = self._load_limits()
-        self._active_counts: Dict[str, int] = defaultdict(int)
-        self._queue_counts: Dict[str, int] = defaultdict(int)
+        self._active_counts: dict[str, int] = defaultdict(int)
+        self._queue_counts: dict[str, int] = defaultdict(int)
 
-    def _load_limits(self) -> Dict[str, int]:
+    def _load_limits(self) -> dict[str, int]:
         """Load rate limits from config file or use defaults."""
         limits = DEFAULT_RATE_LIMITS.copy()
 
@@ -73,7 +72,7 @@ class RateLimiter:
                     if "rate_limits" in config:
                         limits.update(config["rate_limits"])
                         logger.info(f"[RateLimiter] Loaded custom limits from {CONFIG_FILE}")
-            except (json.JSONDecodeError, IOError) as e:
+            except (OSError, json.JSONDecodeError) as e:
                 logger.warning(f"[RateLimiter] Failed to load config: {e}")
 
         return limits
@@ -150,7 +149,7 @@ class RateLimiter:
         semaphore.release()
         logger.debug(f"[RateLimiter] Released slot for {normalized}")
 
-    def get_status(self) -> Dict[str, Dict[str, int]]:
+    def get_status(self) -> dict[str, dict[str, int]]:
         """Get current rate limiter status."""
         with self._lock:
             return {
@@ -162,7 +161,7 @@ class RateLimiter:
                 for model in set(list(self._active_counts.keys()) + list(self._queue_counts.keys()))
             }
 
-    def update_limits(self, new_limits: Dict[str, int]):
+    def update_limits(self, new_limits: dict[str, int]):
         """
         Update rate limits dynamically.
 
@@ -196,7 +195,7 @@ class RateLimitContext:
 
 
 # Global rate limiter instance
-_rate_limiter: Optional[RateLimiter] = None
+_rate_limiter: RateLimiter | None = None
 _rate_limiter_lock = threading.Lock()
 
 
@@ -220,3 +219,99 @@ def rate_limited(model: str, timeout: float = 60.0) -> RateLimitContext:
             pass
     """
     return RateLimitContext(get_rate_limiter(), model, timeout)
+
+
+class TimeWindowRateLimiter:
+    """
+    Time-window rate limiter (30 requests/minute) with user-visible feedback.
+
+    Implements sliding window algorithm for accurate rate limiting.
+    Complements the existing semaphore-based concurrency limiter.
+    """
+
+    def __init__(self, calls: int = 30, period: int = 60):
+        """
+        Initialize time-window rate limiter.
+
+        Args:
+            calls: Maximum number of calls per period (default: 30)
+            period: Time period in seconds (default: 60)
+        """
+        self.calls = calls
+        self.period = period
+        self._timestamps: deque = deque()
+        self._lock = threading.Lock()
+
+    def acquire_visible(self, provider: str, auth_mode: str) -> float:
+        """
+        Acquire slot with user-visible feedback.
+
+        Args:
+            provider: Provider name for logging (e.g., "GEMINI", "OPENAI")
+            auth_mode: Authentication method (e.g., "OAuth", "API key")
+
+        Returns:
+            wait_time: Time to wait in seconds (0 if no wait needed)
+
+        Note:
+            This method prints status to stderr for user visibility.
+        """
+        with self._lock:
+            now = time.time()
+
+            # Clean old timestamps (sliding window)
+            while self._timestamps and self._timestamps[0] < now - self.period:
+                self._timestamps.popleft()
+
+            current = len(self._timestamps)
+
+            if current < self.calls:
+                self._timestamps.append(now)
+                # Show current count in stderr for visibility
+                print(
+                    f"🔮 {provider} ({auth_mode}): {current + 1}/{self.calls} this minute",
+                    file=sys.stderr,
+                )
+                return 0.0
+
+            # Rate limit hit - calculate wait time
+            wait_time = self._timestamps[0] + self.period - now
+            print(
+                f"⏳ RATE LIMIT ({provider}): {self.calls}/min hit. Waiting {wait_time:.1f}s...",
+                file=sys.stderr,
+            )
+            logger.warning(
+                f"[RateLimit] {provider} hit {self.calls}/min limit. Waiting {wait_time:.1f}s ({auth_mode})"
+            )
+
+            return wait_time
+
+    def get_stats(self) -> dict[str, int]:
+        """Get current rate limiter statistics."""
+        with self._lock:
+            now = time.time()
+            # Clean old timestamps
+            while self._timestamps and self._timestamps[0] < now - self.period:
+                self._timestamps.popleft()
+
+            return {
+                "current_count": len(self._timestamps),
+                "limit": self.calls,
+                "period_seconds": self.period,
+            }
+
+
+# Global time-window rate limiter for Gemini (30 req/min)
+_gemini_time_limiter: TimeWindowRateLimiter | None = None
+_gemini_time_limiter_lock = threading.Lock()
+
+
+def get_gemini_time_limiter() -> TimeWindowRateLimiter:
+    """Get or create the global Gemini time-window rate limiter."""
+    global _gemini_time_limiter
+    if _gemini_time_limiter is None:
+        with _gemini_time_limiter_lock:
+            if _gemini_time_limiter is None:
+                _gemini_time_limiter = TimeWindowRateLimiter(calls=30, period=60)
+                logger.info("[TimeWindowRateLimiter] Created Gemini rate limiter (30 req/min)")
+    return _gemini_time_limiter

mcp_bridge/hooks/HOOKS_SETTINGS.json

@@ -47,6 +47,11 @@
             "type": "command",
             "command": "python3 ~/.claude/hooks/stravinsky_mode.py",
             "description": "Hard blocking of direct tools in stravinsky mode"
+          },
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/pre_tool/agent_spawn_validator.py",
+            "description": "Blocks sequential tool usage when parallel delegation is required"
           }
         ]
       }
@@ -111,6 +116,11 @@
             "type": "command",
             "command": "python3 ~/.claude/hooks/todo_delegation.py",
             "description": "Parallel execution enforcer after TodoWrite"
+          },
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/post_tool/parallel_validation.py",
+            "description": "Tracks pending tasks for hard enforcement"
           }
         ]
       }
@@ -139,7 +149,9 @@
     "execution_control": {
       "parallel_execution.py": "Detects implementation tasks and injects parallel execution instructions before response generation. Activates stravinsky mode on /stravinsky invocation.",
       "stravinsky_mode.py": "Blocks native file tools (Read, Grep, Bash, Edit) when stravinsky mode is active, forcing Task delegation.",
-      "todo_delegation.py": "Hard blocks response completion after TodoWrite if 2+ pending items exist without spawning Task agents."
+      "todo_delegation.py": "Hard blocks response completion after TodoWrite if 2+ pending items exist without spawning Task agents.",
+      "parallel_validation.py": "Tracks pending tasks count after TodoWrite to enable hard enforcement state.",
+      "agent_spawn_validator.py": "Blocks sequential tool usage (Read, Grep, etc.) if parallel delegation is required and enabled."
     },
     "context_management": {
       "context.py": "Auto-injects CLAUDE.md, README.md, or AGENTS.md content into prompts for project-specific context.",
@@ -166,10 +178,11 @@
   "state_files": {
     "~/.stravinsky_mode": "Marker file indicating stravinsky orchestrator mode is active (enables hard blocking)",
     "~/.claude/state/compaction.jsonl": "Audit log of context compaction events with preserved items",
-    ".claude/todo_state.json": "Cached todo state for continuation enforcement"
+    ".claude/todo_state.json": "Cached todo state for continuation enforcement",
+    ".claude/parallel_state.json": "Transient state tracking pending tasks for hard enforcement"
   },
   
-  "version": "0.2.63",
+  "version": "0.2.64",
   "package": "stravinsky",
   "documentation": "https://github.com/GratefulDave/stravinsky"
-}
+}

mcp_bridge/hooks/__init__.py

@@ -115,11 +115,21 @@ __all__ = [
 
 def initialize_hooks():
     """Initialize and register all hooks with the HookManager."""
-    # Currently hooks are primarily external scripts or lazy-loaded.
-    # This entry point allows for future internal hook registration.
-    pass
+    from .delegation_policy import DelegationReminderPolicy
+    from .edit_recovery_policy import EditRecoveryPolicy
+    from .manager import get_hook_manager
+    from .parallel_enforcement_policy import ParallelEnforcementPolicy
+    from .truncation_policy import TruncationPolicy
 
+    manager = get_hook_manager()
 
-__version__ = "0.2.63"
+    # Register unified policies
+    manager.register_policy(TruncationPolicy())
+    manager.register_policy(DelegationReminderPolicy())
+    manager.register_policy(EditRecoveryPolicy())
+    manager.register_policy(ParallelEnforcementPolicy())
+
+
+__version__ = "0.4.60"
 __author__ = "David Andrews"
 __description__ = "Claude Code hooks for Stravinsky MCP parallel execution"

mcp_bridge/hooks/agent_reminder.py

@@ -6,7 +6,7 @@ suggests using background agents for more comprehensive results.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -28,8 +28,8 @@ SEARCH_TOOLS = {"grep", "glob", "rg", "find", "Grep", "Glob", "grep_search", "gl
 
 
 async def agent_reminder_hook(
-    tool_name: str, arguments: Dict[str, Any], output: str
-) -> Optional[str]:
+    tool_name: str, arguments: dict[str, Any], output: str
+) -> str | None:
     """
     Post-tool call hook that suggests background agents after direct search tool usage.
     """
@@ -51,7 +51,7 @@ async def agent_reminder_hook(
     return None
 
 
-def _extract_search_context(arguments: Dict[str, Any]) -> str:
+def _extract_search_context(arguments: dict[str, Any]) -> str:
     """Extract search context from tool arguments."""
     for key in ("pattern", "query", "search", "name", "path"):
         if key in arguments:

mcp_bridge/hooks/auto_slash_command.py

@@ -11,7 +11,7 @@ Detects and auto-processes slash commands in user input:
 import logging
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 SLASH_COMMAND_PATTERN = re.compile(r'(?:^|(?<=\s))\/([a-zA-Z][a-zA-Z0-9_-]*)\b', re.MULTILINE)
 
 
-def extract_slash_commands(text: str) -> List[str]:
+def extract_slash_commands(text: str) -> list[str]:
     """
     Extract all slash command names from text.
 
@@ -40,7 +40,7 @@ def extract_slash_commands(text: str) -> List[str]:
     return unique
 
 
-def load_skill_content(command_name: str, project_path: Optional[str] = None) -> Optional[Tuple[str, str]]:
+def load_skill_content(command_name: str, project_path: str | None = None) -> tuple[str, str] | None:
     """
     Load skill content by command name.
 
@@ -92,7 +92,7 @@ def load_skill_content(command_name: str, project_path: Optional[str] = None) ->
         return None
 
 
-def get_project_path_from_prompt(prompt: str) -> Optional[str]:
+def get_project_path_from_prompt(prompt: str) -> str | None:
     """
     Try to extract project path from prompt context.
     Looks for common patterns that indicate the working directory.
@@ -126,7 +126,7 @@ SKILL_NOT_FOUND_WARNING = """
 """
 
 
-async def auto_slash_command_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def auto_slash_command_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that detects slash commands and injects skill content.
 

mcp_bridge/hooks/budget_optimizer.py

@@ -3,14 +3,14 @@ Thinking budget optimizer hook.
 Analyzes prompt complexity and adjusts thinking_budget for models that support it.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 REASONING_KEYWORDS = [
     "architect", "design", "refactor", "debug", "complex", "optimize", 
     "summarize", "analyze", "explain", "why", "review", "strangler"
 ]
 
-async def budget_optimizer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def budget_optimizer_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Adjusts the thinking_budget based on presence of reasoning-heavy keywords.
     """

mcp_bridge/hooks/claude_limits_hook.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for Claude rate limit detection.
+
+Monitors model invocation responses for Claude-specific rate limit indicators
+and updates the provider state tracker accordingly.
+"""
+
+import json
+import logging
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+try:
+    from routing import get_provider_tracker
+except ImportError:
+    get_provider_tracker = None  # type: ignore
+
+
+logger = logging.getLogger(__name__)
+
+# Claude rate limit indicators
+CLAUDE_RATE_LIMIT_PATTERNS = [
+    "rate limit",
+    "rate_limit_error",
+    "too many requests",
+    "429",
+    "quota exceeded",
+    "rate-limited",
+    "overloaded_error",
+]
+
+
+def detect_claude_rate_limit(tool_result: str | dict) -> bool:
+    """
+    Detect if a tool result indicates Claude rate limiting.
+
+    Args:
+        tool_result: Tool result string or dict
+
+    Returns:
+        True if rate limit detected, False otherwise
+    """
+    # Convert result to searchable string
+    if isinstance(tool_result, dict):
+        search_text = json.dumps(tool_result).lower()
+    else:
+        search_text = str(tool_result).lower()
+
+    # Check for rate limit patterns
+    for pattern in CLAUDE_RATE_LIMIT_PATTERNS:
+        if pattern in search_text:
+            logger.info(f"[ClaudeLimitsHook] Detected rate limit pattern: {pattern}")
+            return True
+
+    return False
+
+
+def main() -> None:
+    """Process PostToolUse hook event."""
+    try:
+        # Read hook input from stdin
+        hook_input = json.loads(sys.stdin.read())
+
+        tool_name = hook_input.get("tool_name", "")
+        tool_result = hook_input.get("tool_result", "")
+
+        # Only monitor invoke tools (Claude uses default Claude models)
+        # We're looking for rate limits from the main Claude context
+        # This is different from invoke_openai/invoke_gemini which are explicit
+        if not any(
+            keyword in tool_name.lower() for keyword in ["invoke", "chat", "generate", "complete"]
+        ):
+            # Not a model invocation tool - skip
+            sys.exit(0)
+
+        # Check for rate limit indicators
+        if detect_claude_rate_limit(tool_result):
+            logger.warning("[ClaudeLimitsHook] Claude rate limit detected")
+
+            if get_provider_tracker and callable(get_provider_tracker):
+                tracker = get_provider_tracker()
+                if tracker:
+                    tracker.mark_rate_limited("claude", duration=300, reason="Claude rate limit")
+                    logger.info("[ClaudeLimitsHook] Marked Claude as rate-limited (300s cooldown)")
+
+                    print(
+                        "\n⚠️ Claude Rate Limit Detected\n"
+                        "→ Routing future requests to OpenAI/Gemini for 5 minutes\n",
+                        file=sys.stderr,
+                    )
+            else:
+                logger.debug(
+                    "[ClaudeLimitsHook] Provider tracker not available, skipping state update"
+                )
+
+        sys.exit(0)
+
+    except Exception as e:
+        # Log error but don't block
+        logger.error(f"[ClaudeLimitsHook] Error: {e}", exc_info=True)
+        print(f"[ClaudeLimitsHook] Warning: {e}", file=sys.stderr)
+        sys.exit(0)  # Exit 0 to not block execution
+
+
+if __name__ == "__main__":
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    main()

mcp_bridge/hooks/comment_checker.py

@@ -6,8 +6,7 @@ Code should be self-documenting; excessive comments indicate AI slop.
 """
 
 import logging
-import re
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -53,8 +52,8 @@ CODE_EXTENSIONS = {
 
 
 async def comment_checker_hook(
-    tool_name: str, arguments: Dict[str, Any], output: str
-) -> Optional[str]:
+    tool_name: str, arguments: dict[str, Any], output: str
+) -> str | None:
     """
     Post-tool call hook that checks for excessive comments in code edits.
     """

mcp_bridge/hooks/compaction.py

@@ -3,7 +3,7 @@ Preemptive context compaction hook.
 Monitors context size and injects optimization reminders.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 THRESHOLD_CHARS = 100000 # Roughly 25k-30k tokens for typical LLM text
 
@@ -17,7 +17,7 @@ COMPACTION_REMINDER = """
 > 4. Keep your next responses concise and focused only on the current sub-task.
 """
 
-async def context_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def context_compaction_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Checks prompt length and injects a compaction reminder if it's too large.
     """

mcp_bridge/hooks/context.py

@@ -1,8 +1,9 @@
+import json
 import os
 import sys
-import json
 from pathlib import Path
 
+
 def main():
     try:
         data = json.load(sys.stdin)

mcp_bridge/hooks/context_monitor.py

@@ -7,7 +7,7 @@ At 85%, suggests compaction before hitting hard limits.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -32,7 +32,7 @@ CONTEXT_THRESHOLD_WARNING = 0.85
 ESTIMATED_MAX_TOKENS = 200000
 
 
-async def context_monitor_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def context_monitor_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that monitors context window usage.
     """

mcp_bridge/hooks/delegation_policy.py

@@ -0,0 +1,85 @@
+import os
+import time
+from pathlib import Path
+
+from ..utils.session_state import get_current_session_id, update_session_state
+from .events import EventType, HookPolicy, PolicyResult, ToolCallEvent
+
+# Check if stravinsky mode is active (hard blocking enabled)
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def is_stravinsky_mode():
+    """Check if hard blocking mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+class DelegationReminderPolicy(HookPolicy):
+    """
+    Policy for TodoWrite: CRITICAL parallel execution enforcer.
+    """
+
+    @property
+    def event_type(self) -> EventType:
+        return EventType.POST_TOOL_CALL
+
+    async def evaluate(self, event: ToolCallEvent) -> PolicyResult:
+        if event.tool_name != "TodoWrite":
+            return PolicyResult(modified_data=event.output)
+
+        todos = event.arguments.get("todos", [])
+        pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+        # Update session state
+        session_id = event.metadata.get("session_id") or get_current_session_id()
+        update_session_state(
+            {
+                "last_todo_write_at": time.time(),
+                "pending_todo_count": pending_count,
+            },
+            session_id=session_id,
+        )
+
+        if pending_count < 2:
+            return PolicyResult(modified_data=event.output)
+
+        stravinsky_active = is_stravinsky_mode()
+
+        mode_warning = ""
+        if stravinsky_active:
+            mode_warning = """
+⚠️ STRAVINSKY MODE ACTIVE - Direct tools (Read, Grep, Bash) are BLOCKED.
+   You MUST use Task(subagent_type="explore", ...) for ALL file operations.
+"""
+
+        error_message = f"""
+╔══════════════════════════════════════════════════════════════════════════╗
+║                🚨 PARALLEL DELEGATION REQUIRED 🚨                        ║
+╠══════════════════════════════════════════════════════════════════════════╣
+║                                                                          ║
+║  TodoWrite created {pending_count} pending items.                                   ║
+║  {mode_warning.strip()}                                                              ║
+║                                                                          ║
+║  You MUST spawn Task agents for ALL independent TODOs in this response.  ║
+║                                                                          ║
+╠══════════════════════════════════════════════════════════════════════════╣
+║  REQUIRED PATTERN:                                                       ║
+║  Task(subagent_type="explore", prompt="TODO 1...", run_in_background=t)  ║
+║  Task(subagent_type="explore", prompt="TODO 2...", run_in_background=t)  ║
+║  ...                                                                     ║
+╚══════════════════════════════════════════════════════════════════════════╝
+"""
+        # In PostToolUse, we often want to APPEND the reminder to the output
+        new_output = (event.output or "") + "\n" + error_message
+
+        return PolicyResult(
+            modified_data=new_output,
+            message=error_message,  # For native hooks, we might just print the message
+            should_block=stravinsky_active,
+            exit_code=2 if stravinsky_active else 1,
+        )
+
+
+if __name__ == "__main__":
+    policy = DelegationReminderPolicy()
+    policy.run_as_native()