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

mcp_bridge/hooks/parallel_execution.py

@@ -8,9 +8,10 @@ when implementation tasks are detected. Eliminates timing ambiguity.
 CRITICAL: Also activates stravinsky mode marker when /stravinsky is invoked,
 enabling hard blocking of direct tools (Read, Grep, Bash) via stravinsky_mode.py.
 """
+
 import json
-import sys
 import re
+import sys
 from pathlib import Path
 
 # Marker file that enables hard blocking of direct tools
@@ -20,11 +21,10 @@ STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
 def detect_stravinsky_invocation(prompt):
     """Detect if /stravinsky skill is being invoked."""
     patterns = [
-        r'/stravinsky',
-        r'<command-name>/stravinsky</command-name>',
-        r'stravinsky orchestrator',
-        r'ultrawork',
-        r'ultrathink',
+        r"/stravinsky",
+        r"<command-name>/stravinsky</command-name>",
+        r"stravinsky orchestrator",
+        r"\bultrawork\b",
     ]
     prompt_lower = prompt.lower()
     return any(re.search(p, prompt_lower) for p in patterns)
@@ -36,16 +36,28 @@ def activate_stravinsky_mode():
         config = {"active": True, "reason": "invoked via /stravinsky skill"}
         STRAVINSKY_MODE_FILE.write_text(json.dumps(config))
         return True
-    except IOError:
+    except OSError:
         return False
 
 
 def detect_implementation_task(prompt):
     """Detect if prompt is an implementation task requiring parallel execution."""
     keywords = [
-        'implement', 'add', 'create', 'build', 'refactor', 'fix',
-        'update', 'modify', 'change', 'develop', 'write code',
-        'feature', 'bug fix', 'enhancement', 'integrate'
+        "implement",
+        "add",
+        "create",
+        "build",
+        "refactor",
+        "fix",
+        "update",
+        "modify",
+        "change",
+        "develop",
+        "write code",
+        "feature",
+        "bug fix",
+        "enhancement",
+        "integrate",
     ]
 
     prompt_lower = prompt.lower()

mcp_bridge/hooks/post_tool/parallel_validation.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Parallel Validation.
+
+Tracks pending tasks after TodoWrite and sets a state flag if parallel
+delegation is required. This state is consumed by the PreToolUse validator.
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict
+
+# State file base location (will be suffixed with session ID)
+STATE_DIR = Path(".claude")
+
+
+def get_state_file() -> Path:
+    """Get path to state file, respecting CLAUDE_CWD and CLAUDE_SESSION_ID."""
+    # Use environment variable passed by Claude Code
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+    # Sanitize session ID
+    session_id = "".join(c for c in session_id if c.isalnum() or c in "-_")
+    
+    return cwd / ".claude" / f"parallel_state_{session_id}.json"
+
+
+def save_state(state: Dict[str, Any]) -> None:
+    """Save state to file."""
+    path = get_state_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=2))
+
+
+def load_state() -> Dict[str, Any]:
+    """Load state from file."""
+    path = get_state_file()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+def process_hook(hook_input: Dict[str, Any]) -> int:
+    """Process the hook input and update state."""
+    tool_name = hook_input.get("tool_name", "")
+    
+    # We only care about TodoWrite (creating tasks)
+    # or maybe Task/agent_spawn (resetting the requirement)
+    
+    if tool_name == "TodoWrite":
+        tool_input = hook_input.get("tool_input", {})
+        todos = tool_input.get("todos", [])
+        
+        # Count independent pending todos
+        # Conservative: assume all pending are independent for now
+        pending_count = sum(1 for t in todos if t.get("status") == "pending")
+        
+        if pending_count >= 2:
+            state = load_state()
+            state.update({
+                "delegation_required": True,
+                "pending_count": pending_count,
+                "last_todo_write": time.time(),
+                "reason": f"TodoWrite created {pending_count} pending items. Parallel delegation required."
+            })
+            save_state(state)
+            
+    elif tool_name in ["Task", "agent_spawn"]:
+        # If a task is spawned, we might be satisfying the requirement
+        # But we need to spawn ONE for EACH independent task. 
+        # For now, let's just note that a spawn happened.
+        # The PreToolUse validator will decide if it's enough (maybe checking count?)
+        # Or we can just decrement a counter?
+        # Simpler: If ANY delegation happens, we assume the user is complying for now.
+        # Strict implementation: We'd track how many spawned vs required.
+        
+        state = load_state()
+        if state.get("delegation_required"):
+            # Update state to reflect compliance
+            state["delegation_required"] = False
+            state["last_delegation"] = time.time()
+            save_state(state)
+
+    return 0
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+        exit_code = process_hook(hook_input)
+        sys.exit(exit_code)
+    except (json.JSONDecodeError, EOFError):
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

mcp_bridge/hooks/pre_compact.py

@@ -13,10 +13,9 @@ Cannot block compaction (exit 2 only shows error).
 
 import json
 import sys
-from pathlib import Path
 from datetime import datetime
-from typing import List, Dict, Any
-
+from pathlib import Path
+from typing import Any
 
 STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
 STATE_DIR = Path.home() / ".claude" / "state"
@@ -43,18 +42,18 @@ def ensure_state_dir():
     STATE_DIR.mkdir(parents=True, exist_ok=True)
 
 
-def get_stravinsky_mode_state() -> Dict[str, Any]:
+def get_stravinsky_mode_state() -> dict[str, Any]:
     """Read stravinsky mode state."""
     if not STRAVINSKY_MODE_FILE.exists():
         return {"active": False}
     try:
         content = STRAVINSKY_MODE_FILE.read_text().strip()
         return json.loads(content) if content else {"active": True}
-    except (json.JSONDecodeError, IOError):
+    except (OSError, json.JSONDecodeError):
         return {"active": True}
 
 
-def extract_preserved_context(prompt: str) -> List[str]:
+def extract_preserved_context(prompt: str) -> list[str]:
     """Extract context matching preservation patterns."""
     preserved = []
     lines = prompt.split("\n")
@@ -70,12 +69,12 @@ def extract_preserved_context(prompt: str) -> List[str]:
     return preserved[:15]  # Max 15 items
 
 
-def log_compaction(preserved: List[str], stravinsky_active: bool):
+def log_compaction(preserved: list[str], stravinsky_active: bool):
     """Log compaction event for audit."""
     ensure_state_dir()
 
     entry = {
-        "timestamp": datetime.utcnow().isoformat(),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
         "preserved_count": len(preserved),
         "stravinsky_mode": stravinsky_active,
         "preview": [p[:50] for p in preserved[:3]],
@@ -84,7 +83,7 @@ def log_compaction(preserved: List[str], stravinsky_active: bool):
     try:
         with COMPACTION_LOG.open("a") as f:
             f.write(json.dumps(entry) + "\n")
-    except IOError:
+    except OSError:
         pass
 
 

mcp_bridge/hooks/pre_tool/agent_spawn_validator.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Agent Spawn Validator.
+
+Blocks direct tools (Read, Grep, etc.) if parallel delegation is required
+but hasn't happened yet.
+
+Triggers when:
+1. parallel_validation.py (PostToolUse) has set 'delegation_required=True'
+2. User tries to use a non-delegation tool
+3. Hard enforcement is enabled (opt-in)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+# State file location
+STATE_FILE = Path(".claude/parallel_state.json")
+CONFIG_FILE = Path(".stravinsky/config.json") # Faster than yaml
+
+
+def get_project_dir() -> Path:
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+def get_state_file() -> Path:
+    cwd = get_project_dir()
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+    # Sanitize session ID
+    session_id = "".join(c for c in session_id if c.isalnum() or c in "-_")
+    return cwd / ".claude" / f"parallel_state_{session_id}.json"
+
+
+def load_state() -> Dict[str, Any]:
+    path = get_state_file()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+def is_enforcement_enabled() -> bool:
+    """Check if hard enforcement is enabled."""
+    # Check env var override
+    if os.environ.get("STRAVINSKY_ALLOW_SEQUENTIAL", "").lower() == "true":
+        return False
+        
+    # Check config file (default: false for now)
+    config_path = get_project_dir() / ".stravinsky/config.json"
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text())
+            return config.get("enforce_parallel_delegation", False)
+        except Exception:
+            pass
+            
+    return False
+
+
+def process_hook(hook_input: Dict[str, Any]) -> int:
+    """Process hook input."""
+    tool_name = hook_input.get("toolName", "")
+    
+    # Allowed tools during delegation phase
+    ALLOWED_TOOLS = ["Task", "agent_spawn", "TodoWrite", "TodoRead"]
+    
+    if tool_name in ALLOWED_TOOLS:
+        return 0
+        
+    state = load_state()
+    
+    # If delegation is not required, allow
+    if not state.get("delegation_required"):
+        return 0
+        
+    # If hard enforcement is not enabled, allow (maybe warn? but PreToolUse warnings aren't visible usually)
+    if not is_enforcement_enabled():
+        # TODO: Ideally print a warning to stderr?
+        return 0
+        
+    # BLOCK
+    print(f"""
+🛑 BLOCKED: PARALLEL DELEGATION REQUIRED
+
+You have {state.get("pending_todos", "multiple")} pending tasks that require parallel execution.
+You are attempting to use '{tool_name}' sequentially.
+
+REQUIRED ACTION:
+Spawn agents for ALL independent tasks in THIS response using:
+- Task(subagent_type="...", prompt="...") 
+- agent_spawn(agent_type="...", prompt="...")
+
+To override (if tasks are truly dependent):
+- Set STRAVINSKY_ALLOW_SEQUENTIAL=true
+- Or use TodoWrite to update tasks to dependent state
+""")
+    return 2
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+        exit_code = process_hook(hook_input)
+        sys.exit(exit_code)
+    except (json.JSONDecodeError, EOFError):
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

mcp_bridge/hooks/preemptive_compaction.py

@@ -9,8 +9,7 @@ Proactively compresses context BEFORE hitting limits by:
 """
 
 import logging
-import re
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -170,7 +169,7 @@ async def summarize_with_gemini(token_store: Any, content: str) -> str:
         _in_summarization = False
 
 
-async def preemptive_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def preemptive_compaction_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that proactively compresses context before hitting limits.
 

mcp_bridge/hooks/routing_notifications.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for routing fallback notifications.
+
+Monitors provider state changes and notifies users when routing decisions
+are made due to rate limits or provider unavailability.
+"""
+
+import json
+import logging
+import sys
+from pathlib import Path
+
+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__)
+
+
+def format_cooldown_time(seconds: float) -> str:
+    """Format cooldown duration for user display."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    minutes = int(seconds / 60)
+    remaining_seconds = int(seconds % 60)
+    if remaining_seconds == 0:
+        return f"{minutes}m"
+    return f"{minutes}m {remaining_seconds}s"
+
+
+def check_and_notify_routing_state() -> None:
+    """Check current routing state and notify if providers are unavailable."""
+    if not get_provider_tracker or not callable(get_provider_tracker):
+        return
+
+    tracker = get_provider_tracker()
+    if not tracker:
+        return
+
+    status = tracker.get_status()
+
+    unavailable_providers = []
+    for provider_name, provider_status in status.items():
+        if not provider_status["available"] and provider_status["cooldown_remaining"]:
+            cooldown_str = format_cooldown_time(provider_status["cooldown_remaining"])
+            unavailable_providers.append((provider_name, cooldown_str))
+
+    if unavailable_providers:
+        print("\n📊 Provider Status:", file=sys.stderr)
+        for provider, cooldown in unavailable_providers:
+            print(f"  ⏳ {provider.title()}: Cooldown ({cooldown} remaining)", file=sys.stderr)
+
+
+def main() -> None:
+    """Process PostToolUse hook event."""
+    try:
+        hook_input = json.loads(sys.stdin.read())
+
+        tool_name = hook_input.get("tool_name", "")
+
+        if "invoke" in tool_name.lower() or "agent_spawn" in tool_name.lower():
+            check_and_notify_routing_state()
+
+        sys.exit(0)
+
+    except Exception as e:
+        logger.error(f"[RoutingNotifications] Error: {e}", exc_info=True)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    main()

mcp_bridge/hooks/rules_injector.py

@@ -35,7 +35,7 @@ import re
 from dataclasses import dataclass
 from fnmatch import fnmatch
 from pathlib import Path
-from typing import Any, Dict, Optional, Set
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -44,8 +44,8 @@ MAX_RULES_TOKENS = 4000  # Reserve max 4k tokens for rules
 TOKEN_ESTIMATE_RATIO = 4  # ~4 chars per token (conservative)
 
 # Session-scoped caches
-_rules_injection_cache: Dict[str, Set[str]] = {}
-_session_rules_cache: Dict[str, list] = {}
+_rules_injection_cache: dict[str, set[str]] = {}
+_session_rules_cache: dict[str, list] = {}
 
 
 @dataclass(frozen=True)
@@ -128,7 +128,7 @@ def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
     return metadata, body
 
 
-def discover_rules(project_path: Optional[str] = None) -> list[RuleFile]:
+def discover_rules(project_path: str | None = None) -> list[RuleFile]:
     """
     Discover all rule files from .claude/rules/ directories.
 
@@ -212,7 +212,7 @@ def discover_rules(project_path: Optional[str] = None) -> list[RuleFile]:
     return rules
 
 
-def extract_file_paths_from_context(params: Dict[str, Any]) -> Set[str]:
+def extract_file_paths_from_context(params: dict[str, Any]) -> set[str]:
     """
     Extract file paths from prompt context.
 
@@ -248,7 +248,7 @@ def extract_file_paths_from_context(params: Dict[str, Any]) -> Set[str]:
     return paths
 
 
-def match_rules_to_files(rules: list[RuleFile], file_paths: Set[str], project_path: str) -> list[RuleFile]:
+def match_rules_to_files(rules: list[RuleFile], file_paths: set[str], project_path: str) -> list[RuleFile]:
     """
     Match discovered rules to active file paths using glob patterns.
 
@@ -282,15 +282,7 @@ def match_rules_to_files(rules: list[RuleFile], file_paths: Set[str], project_pa
                 matched_this_pattern = False
 
                 # Match absolute path
-                if fnmatch(str(path), glob_pattern):
-                    matched_this_pattern = True
-
-                # Match relative path
-                elif relative_path and fnmatch(relative_path, glob_pattern):
-                    matched_this_pattern = True
-
-                # Match filename only (for patterns like "*.py")
-                elif fnmatch(path.name, glob_pattern):
+                if fnmatch(str(path), glob_pattern) or relative_path and fnmatch(relative_path, glob_pattern) or fnmatch(path.name, glob_pattern):
                     matched_this_pattern = True
 
                 if matched_this_pattern:
@@ -383,13 +375,13 @@ def format_rules_injection(rules: list[RuleFile]) -> str:
     return header + "\n".join(rules_blocks)
 
 
-def get_session_cache_key(session_id: str, file_paths: Set[str]) -> str:
+def get_session_cache_key(session_id: str, file_paths: set[str]) -> str:
     """Generate cache key for session + file combination."""
     sorted_paths = "|".join(sorted(file_paths))
     return f"{session_id}:{sorted_paths}"
 
 
-def is_already_injected(session_id: str, file_paths: Set[str], rule_names: list[str]) -> bool:
+def is_already_injected(session_id: str, file_paths: set[str], rule_names: list[str]) -> bool:
     """
     Check if rules have already been injected for this session + file combination.
 
@@ -434,7 +426,7 @@ def get_cached_rules(session_id: str, project_path: str) -> list[RuleFile]:
     return _session_rules_cache[cache_key]
 
 
-def get_project_path_from_prompt(prompt: str) -> Optional[str]:
+def get_project_path_from_prompt(prompt: str) -> str | None:
     """Extract project path from prompt if available."""
     # Look for common working directory indicators
     patterns = [
@@ -452,7 +444,7 @@ def get_project_path_from_prompt(prompt: str) -> Optional[str]:
     return str(Path.cwd())
 
 
-async def rules_injector_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def rules_injector_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model-invoke hook for automatic rules injection.
 

mcp_bridge/hooks/session_idle.py

@@ -8,7 +8,7 @@ Based on oh-my-opencode's todo-continuation-enforcer pattern.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -30,11 +30,11 @@ Use TodoWrite to check your current task status and continue with the next pendi
 """
 
 # Track sessions to prevent duplicate injections
-_idle_sessions: Dict[str, bool] = {}
-_last_activity: Dict[str, float] = {}
+_idle_sessions: dict[str, bool] = {}
+_last_activity: dict[str, float] = {}
 
 
-async def session_idle_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def session_idle_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model-invoke hook that detects idle sessions with incomplete todos.
 

mcp_bridge/hooks/session_notifier.py

@@ -7,15 +7,15 @@ Provides OS-level desktop notifications when sessions are idle.
 import logging
 import platform
 import subprocess
-from typing import Any, Dict, Optional, Set
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
 # Track which sessions have been notified (avoid duplicates)
-_notified_sessions: Set[str] = set()
+_notified_sessions: set[str] = set()
 
 
-def get_notification_command(title: str, message: str, sound: bool = True) -> Optional[list]:
+def get_notification_command(title: str, message: str, sound: bool = True) -> list | None:
     """
     Get platform-specific notification command.
 
@@ -69,7 +69,7 @@ async def session_notifier_hook(
     session_id: str,
     has_pending_todos: bool,
     idle_seconds: float,
-    params: Dict[str, Any]
+    params: dict[str, Any]
 ) -> None:
     """
     Session idle hook that sends desktop notification.

mcp_bridge/hooks/session_recovery.py

@@ -10,8 +10,7 @@ Detects and recovers from corrupted sessions:
 
 import logging
 import re
-import json
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -80,7 +79,7 @@ Recommended Actions:
 """
 
 
-def detect_corruption(output: str) -> Optional[str]:
+def detect_corruption(output: str) -> str | None:
     """
     Detect if the output shows signs of corruption.
 
@@ -135,9 +134,9 @@ def get_recovery_hint(tool_name: str, issue: str) -> str:
 
 async def session_recovery_hook(
     tool_name: str,
-    arguments: Dict[str, Any],
+    arguments: dict[str, Any],
     output: str
-) -> Optional[str]:
+) -> str | None:
     """
     Post-tool call hook that detects corrupted results and injects recovery information.
 

mcp_bridge/hooks/stravinsky_mode.py

@@ -65,7 +65,7 @@ def read_stravinsky_mode_config() -> dict:
         return {}
     try:
         return json.loads(STRAVINSKY_MODE_FILE.read_text())
-    except (json.JSONDecodeError, IOError):
+    except (OSError, json.JSONDecodeError):
         return {"active": True}
 
 

mcp_bridge/hooks/subagent_stop.py

@@ -16,8 +16,6 @@ Exit codes:
 import json
 import sys
 from pathlib import Path
-from typing import Optional, Tuple
-
 
 STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
 
@@ -27,7 +25,7 @@ def is_stravinsky_mode() -> bool:
     return STRAVINSKY_MODE_FILE.exists()
 
 
-def extract_subagent_info(hook_input: dict) -> Tuple[str, str, str]:
+def extract_subagent_info(hook_input: dict) -> tuple[str, str, str]:
     """
     Extract subagent information from hook input.
 

mcp_bridge/hooks/task_validator.py

@@ -6,7 +6,7 @@ Detects and warns about empty or failed Task tool execution results.
 
 import logging
 import re
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +38,7 @@ Recommended actions:
 
 
 async def task_validator_hook(
-    tool_name: str, tool_input: Dict[str, Any], tool_response: str
+    tool_name: str, tool_input: dict[str, Any], tool_response: str
 ) -> str:
     """
     Post-tool-call hook that validates Task tool responses.