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

mcp_bridge/config/hook_config.py

@@ -0,0 +1,247 @@
+"""
+Hook configuration with selective disabling support.
+
+Provides batteries-included defaults with user-configurable overrides.
+Users can disable specific hooks via ~/.stravinsky/disable_hooks.txt
+"""
+
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Default locations for disable hooks config
+DISABLE_HOOKS_PATHS = [
+    Path.home() / ".stravinsky" / "disable_hooks.txt",
+    Path(".stravinsky") / "disable_hooks.txt",
+    Path(".claude") / "disable_hooks.txt",
+]
+
+
+def get_disabled_hooks() -> set[str]:
+    """
+    Load disabled hooks from config files.
+
+    Checks (in order):
+    1. ~/.stravinsky/disable_hooks.txt (user global)
+    2. .stravinsky/disable_hooks.txt (project local)
+    3. .claude/disable_hooks.txt (claude project local)
+
+    Returns:
+        Set of hook names that should be disabled.
+    """
+    disabled = set()
+
+    for path in DISABLE_HOOKS_PATHS:
+        if path.exists():
+            try:
+                content = path.read_text()
+                for line in content.splitlines():
+                    line = line.strip()
+                    # Skip comments and empty lines
+                    if line and not line.startswith("#"):
+                        disabled.add(line)
+                logger.debug(f"Loaded disabled hooks from {path}: {disabled}")
+            except Exception as e:
+                logger.warning(f"Failed to read {path}: {e}")
+
+    return disabled
+
+
+def is_hook_enabled(hook_name: str) -> bool:
+    """
+    Check if a specific hook is enabled.
+
+    Args:
+        hook_name: Name of the hook (e.g., 'comment_checker', 'session_recovery')
+
+    Returns:
+        True if the hook is enabled (not in disable list), False otherwise.
+    """
+    disabled = get_disabled_hooks()
+    return hook_name not in disabled
+
+
+def get_hook_config_path() -> Path:
+    """
+    Get the path to the user's hook config directory.
+    Creates it if it doesn't exist.
+    """
+    config_dir = Path.home() / ".stravinsky"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def create_sample_disable_hooks() -> Path | None:
+    """
+    Create a sample disable_hooks.txt file with documentation.
+
+    Returns:
+        Path to the created file, or None if it already exists.
+    """
+    config_dir = get_hook_config_path()
+    disable_file = config_dir / "disable_hooks.txt"
+
+    if disable_file.exists():
+        return None
+
+    sample_content = """# Stravinsky Hook Disabling Configuration
+# Add hook names (one per line) to disable them.
+# Lines starting with # are comments.
+#
+# Available hooks:
+# ================
+# 
+# PreToolUse Hooks:
+# - comment_checker       (checks git commit comments for quality)
+# - stravinsky_mode       (blocks direct tool calls, forces delegation)
+# - notification_hook     (displays agent spawn notifications)
+#
+# PostToolUse Hooks:
+# - session_recovery      (detects API errors and logs recovery info)
+# - parallel_execution    (injects parallel execution instructions)
+# - todo_delegation       (enforces parallel Task spawning for todos)
+# - tool_messaging        (user-friendly MCP tool messages)
+# - edit_recovery         (suggests recovery for Edit failures)
+# - truncator             (truncates long responses)
+# - subagent_stop         (handles subagent completion)
+#
+# UserPromptSubmit Hooks:
+# - context               (injects CLAUDE.md content)
+# - todo_continuation     (reminds about incomplete todos)
+#
+# PreCompact Hooks:
+# - pre_compact           (preserves critical context before compaction)
+#
+# Example - to disable the comment checker:
+# comment_checker
+#
+# Example - to disable ultrawork mode detection:
+# parallel_execution
+"""
+
+    disable_file.write_text(sample_content)
+    logger.info(f"Created sample disable_hooks.txt at {disable_file}")
+    return disable_file
+
+
+# Hook metadata for batteries-included config
+HOOK_DEFAULTS = {
+    # PreToolUse hooks
+    "comment_checker": {
+        "type": "PreToolUse",
+        "description": "Checks git commit comments for quality issues",
+        "default_enabled": True,
+        "exit_on_block": 0,  # Warn but don't block
+    },
+    "stravinsky_mode": {
+        "type": "PreToolUse",
+        "description": "Blocks direct tool calls, forces Task delegation",
+        "default_enabled": True,
+        "exit_on_block": 2,  # Hard block
+    },
+    "notification_hook": {
+        "type": "PreToolUse",
+        "description": "Displays agent spawn notifications",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    # PostToolUse hooks
+    "session_recovery": {
+        "type": "PostToolUse",
+        "description": "Detects API errors and logs recovery suggestions",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "parallel_execution": {
+        "type": "PostToolUse",
+        "description": "Injects parallel execution and ULTRAWORK mode",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "todo_delegation": {
+        "type": "PostToolUse",
+        "description": "Enforces parallel Task spawning for 2+ todos",
+        "default_enabled": True,
+        "exit_on_block": 2,  # Hard block in stravinsky mode
+    },
+    "tool_messaging": {
+        "type": "PostToolUse",
+        "description": "User-friendly messages for MCP tools",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "edit_recovery": {
+        "type": "PostToolUse",
+        "description": "Suggests recovery for Edit failures",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "truncator": {
+        "type": "PostToolUse",
+        "description": "Truncates responses longer than 30k chars",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "subagent_stop": {
+        "type": "SubagentStop",
+        "description": "Handles subagent completion events",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    # UserPromptSubmit hooks
+    "context": {
+        "type": "UserPromptSubmit",
+        "description": "Injects CLAUDE.md content to prompts",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    "todo_continuation": {
+        "type": "UserPromptSubmit",
+        "description": "Reminds about incomplete todos",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+    # PreCompact hooks
+    "pre_compact": {
+        "type": "PreCompact",
+        "description": "Preserves critical context before compaction",
+        "default_enabled": True,
+        "exit_on_block": 0,
+    },
+}
+
+
+def get_enabled_hooks() -> dict:
+    """
+    Get all enabled hooks with their configuration.
+
+    Returns:
+        Dict of hook_name -> hook_config for enabled hooks only.
+    """
+    disabled = get_disabled_hooks()
+    enabled = {}
+
+    for hook_name, config in HOOK_DEFAULTS.items():
+        if hook_name not in disabled and config.get("default_enabled", True):
+            enabled[hook_name] = config
+
+    return enabled
+
+
+def list_hooks() -> str:
+    """
+    List all hooks with their status.
+
+    Returns:
+        Formatted string showing hook status.
+    """
+    disabled = get_disabled_hooks()
+    lines = ["# Stravinsky Hooks Status", ""]
+
+    for hook_name, config in sorted(HOOK_DEFAULTS.items()):
+        status = "DISABLED" if hook_name in disabled else "enabled"
+        icon = "" if hook_name in disabled else ""
+        lines.append(f"{icon} {hook_name}: {status} - {config['description']}")
+
+    return "\n".join(lines)

mcp_bridge/config/hooks_manifest.json

@@ -0,0 +1,138 @@
+{
+  "schema_version": "1.0.0",
+  "manifest_version": "0.3.9",
+  "description": "Stravinsky hooks for Claude Code integration",
+  "generated_date": "2026-01-08T23:53:08.836595Z",
+  "hooks": {
+    "context.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/context.py",
+      "description": "Project context injection from local files",
+      "checksum": "2411ea9d7ef9",
+      "lines_of_code": 38,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "context_monitor.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/context_monitor.py",
+      "description": "Pre-emptive context optimization at 70% threshold",
+      "checksum": "7a8d0615af4f",
+      "lines_of_code": 153,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "edit_recovery.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/edit_recovery.py",
+      "description": "Edit/MultiEdit error recovery helper",
+      "checksum": "d4e5a96f7bfc",
+      "lines_of_code": 46,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "notification_hook.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/notification_hook.py",
+      "description": "Agent spawn message formatting",
+      "checksum": "184947c5a227",
+      "lines_of_code": 103,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "parallel_execution.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/parallel_execution.py",
+      "description": "Pre-emptive parallel execution enforcement",
+      "checksum": "9c820d3d19be",
+      "lines_of_code": 111,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "pre_compact.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/pre_compact.py",
+      "description": "Context preservation before compaction",
+      "checksum": "4177023bd901",
+      "lines_of_code": 123,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "stop_hook.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/stop_hook.py",
+      "description": "Continuation loop handler",
+      "checksum": "820aef797e2e",
+      "lines_of_code": 234,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "stravinsky_mode.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/stravinsky_mode.py",
+      "description": "Hard blocking of native tools",
+      "checksum": "5968a95ebcbe",
+      "lines_of_code": 146,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "subagent_stop.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/subagent_stop.py",
+      "description": "Subagent completion handler",
+      "checksum": "1943d8dc5355",
+      "lines_of_code": 98,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "todo_continuation.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/todo_continuation.py",
+      "description": "Todo continuation enforcer",
+      "checksum": "b6685355f319",
+      "lines_of_code": 90,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "todo_delegation.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/todo_delegation.py",
+      "description": "Parallel task spawning enforcement",
+      "checksum": "b4e004d51600",
+      "lines_of_code": 88,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "tool_messaging.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/tool_messaging.py",
+      "description": "User-friendly tool messaging",
+      "checksum": "04a10e76f890",
+      "lines_of_code": 263,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    },
+    "truncator.py": {
+      "version": "0.3.9",
+      "source": "mcp_bridge/hooks/truncator.py",
+      "description": "Tool response truncation at 30k chars",
+      "checksum": "87785bf2c657",
+      "lines_of_code": 23,
+      "updatable": true,
+      "priority": "high",
+      "required": true
+    }
+  }
+}

mcp_bridge/config/rate_limits.py

@@ -0,0 +1,317 @@
+"""
+Rate Limiting Configuration for Stravinsky Agent Manager.
+
+Provides per-model concurrency limits to prevent API overload.
+Implements semaphore-based rate limiting with configurable limits
+per model family.
+
+Configuration file: ~/.stravinsky/config.json
+{
+  "rate_limits": {
+    "claude-opus-4": 2,
+    "claude-sonnet-4.5": 5,
+    "gemini-3-flash": 10,
+    "gemini-3-pro-high": 5,
+    "gpt-5.2": 3
+  }
+}
+"""
+
+import json
+import logging
+import sys
+import threading
+import time
+from collections import defaultdict, deque
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Default rate limits per model (conservative defaults)
+DEFAULT_RATE_LIMITS = {
+    # Claude models via CLI
+    "opus": 2,  # Expensive, limit parallel calls
+    "sonnet": 5,  # Moderate cost
+    "haiku": 10,  # Cheap, allow more
+    # Gemini models via MCP
+    "gemini-3-flash": 10,  # Free/cheap, allow many
+    "gemini-3-pro-high": 5,  # Medium cost
+    # OpenAI models via MCP
+    "gpt-5.2": 3,  # Expensive
+    # Default for unknown models
+    "_default": 5,
+}
+
+# Config file location
+CONFIG_FILE = Path.home() / ".stravinsky" / "config.json"
+
+
+class RateLimiter:
+    """
+    Semaphore-based rate limiter for model concurrency.
+
+    Thread-safe implementation that limits concurrent requests
+    per model family to prevent API overload.
+    """
+
+    def __init__(self):
+        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)
+
+    def _load_limits(self) -> dict[str, int]:
+        """Load rate limits from config file or use defaults."""
+        limits = DEFAULT_RATE_LIMITS.copy()
+
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    config = json.load(f)
+                    if "rate_limits" in config:
+                        limits.update(config["rate_limits"])
+                        logger.info(f"[RateLimiter] Loaded custom limits from {CONFIG_FILE}")
+            except (OSError, json.JSONDecodeError) as e:
+                logger.warning(f"[RateLimiter] Failed to load config: {e}")
+
+        return limits
+
+    def _get_semaphore(self, model: str) -> threading.Semaphore:
+        """Get or create a semaphore for a model."""
+        with self._lock:
+            if model not in self._semaphores:
+                limit = self._limits.get(model, self._limits.get("_default", 5))
+                self._semaphores[model] = threading.Semaphore(limit)
+                logger.debug(f"[RateLimiter] Created semaphore for {model} with limit {limit}")
+            return self._semaphores[model]
+
+    def _normalize_model(self, model: str) -> str:
+        """Normalize model name to match config keys."""
+        model_lower = model.lower()
+
+        # Match known patterns
+        if "opus" in model_lower:
+            return "opus"
+        elif "sonnet" in model_lower:
+            return "sonnet"
+        elif "haiku" in model_lower:
+            return "haiku"
+        elif "gemini" in model_lower and "flash" in model_lower:
+            return "gemini-3-flash"
+        elif "gemini" in model_lower and ("pro" in model_lower or "high" in model_lower):
+            return "gemini-3-pro-high"
+        elif "gpt" in model_lower:
+            return "gpt-5.2"
+
+        return model_lower
+
+    def acquire(self, model: str, timeout: float = 60.0) -> bool:
+        """
+        Acquire a slot for the given model.
+
+        Args:
+            model: Model name to acquire slot for
+            timeout: Maximum time to wait in seconds
+
+        Returns:
+            True if slot acquired, False if timed out
+        """
+        normalized = self._normalize_model(model)
+        semaphore = self._get_semaphore(normalized)
+
+        with self._lock:
+            self._queue_counts[normalized] += 1
+
+        logger.debug(f"[RateLimiter] Acquiring slot for {normalized}")
+        acquired = semaphore.acquire(blocking=True, timeout=timeout)
+
+        with self._lock:
+            self._queue_counts[normalized] -= 1
+            if acquired:
+                self._active_counts[normalized] += 1
+
+        if acquired:
+            logger.debug(f"[RateLimiter] Acquired slot for {normalized}")
+        else:
+            logger.warning(f"[RateLimiter] Timeout waiting for slot for {normalized}")
+
+        return acquired
+
+    def release(self, model: str):
+        """Release a slot for the given model."""
+        normalized = self._normalize_model(model)
+        semaphore = self._get_semaphore(normalized)
+
+        with self._lock:
+            self._active_counts[normalized] = max(0, self._active_counts[normalized] - 1)
+
+        semaphore.release()
+        logger.debug(f"[RateLimiter] Released slot for {normalized}")
+
+    def get_status(self) -> dict[str, dict[str, int]]:
+        """Get current rate limiter status."""
+        with self._lock:
+            return {
+                model: {
+                    "limit": self._limits.get(model, self._limits.get("_default", 5)),
+                    "active": self._active_counts[model],
+                    "queued": self._queue_counts[model],
+                }
+                for model in set(list(self._active_counts.keys()) + list(self._queue_counts.keys()))
+            }
+
+    def update_limits(self, new_limits: dict[str, int]):
+        """
+        Update rate limits dynamically.
+
+        Note: This only affects new semaphores. Existing ones
+        will continue with their original limits until recreated.
+        """
+        with self._lock:
+            self._limits.update(new_limits)
+            logger.info(f"[RateLimiter] Updated limits: {new_limits}")
+
+
+class RateLimitContext:
+    """Context manager for rate-limited model access."""
+
+    def __init__(self, limiter: RateLimiter, model: str, timeout: float = 60.0):
+        self.limiter = limiter
+        self.model = model
+        self.timeout = timeout
+        self.acquired = False
+
+    def __enter__(self):
+        self.acquired = self.limiter.acquire(self.model, self.timeout)
+        if not self.acquired:
+            raise TimeoutError(f"Rate limit timeout for model {self.model}")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.acquired:
+            self.limiter.release(self.model)
+        return False
+
+
+# Global rate limiter instance
+_rate_limiter: RateLimiter | None = None
+_rate_limiter_lock = threading.Lock()
+
+
+def get_rate_limiter() -> RateLimiter:
+    """Get or create the global RateLimiter instance."""
+    global _rate_limiter
+    if _rate_limiter is None:
+        with _rate_limiter_lock:
+            if _rate_limiter is None:
+                _rate_limiter = RateLimiter()
+    return _rate_limiter
+
+
+def rate_limited(model: str, timeout: float = 60.0) -> RateLimitContext:
+    """
+    Get a rate-limited context for a model.
+
+    Usage:
+        with rate_limited("gemini-3-flash") as ctx:
+            # Make API call
+            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