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

mcp_bridge/config/rate_limits.py

@@ -0,0 +1,222 @@
+"""
+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 asyncio
+import json
+import threading
+from pathlib import Path
+from typing import Dict, Optional
+from collections import defaultdict
+from datetime import datetime
+import logging
+
+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 (json.JSONDecodeError, IOError) 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: Optional[RateLimiter] = 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)

mcp_bridge/config/skills_manifest.json

@@ -0,0 +1,128 @@
+{
+  "schema_version": "1.0.0",
+  "manifest_version": "0.3.9",
+  "description": "Stravinsky skills for Claude Code command integration",
+  "generated_date": "2026-01-08T23:53:08.837988Z",
+  "skills": {
+    "commit.md": {
+      "file_path": "commit.md",
+      "description": "Git Master - Intelligent atomic commit orchestration",
+      "checksum": "f09aee4cc46e",
+      "lines_of_code": 531,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "delphi.md": {
+      "file_path": "delphi.md",
+      "description": "Strategic advisor for architecture and debugging",
+      "checksum": "46ce352164a5",
+      "lines_of_code": 5,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "dewey.md": {
+      "file_path": "dewey.md",
+      "description": "Research librarian for documentation and examples",
+      "checksum": "de4e41fc0e08",
+      "lines_of_code": 54,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "index.md": {
+      "file_path": "str/index.md",
+      "description": "Index project for semantic search",
+      "checksum": "a37c570b70a5",
+      "lines_of_code": 199,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "publish.md": {
+      "file_path": "publish.md",
+      "description": "Publish to PyPI with version bump",
+      "checksum": "9e6ed392ebc4",
+      "lines_of_code": 66,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "review.md": {
+      "file_path": "review.md",
+      "description": "Code review recent changes",
+      "checksum": "47274e796826",
+      "lines_of_code": 67,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "search.md": {
+      "file_path": "str/search.md",
+      "description": "Stravinsky skill",
+      "checksum": "eb092d567333",
+      "lines_of_code": 205,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "start_filewatch.md": {
+      "file_path": "str/start_filewatch.md",
+      "description": "Stravinsky skill",
+      "checksum": "23ca1f6a1999",
+      "lines_of_code": 136,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "stats.md": {
+      "file_path": "str/stats.md",
+      "description": "Stravinsky skill",
+      "checksum": "017f4fc6d099",
+      "lines_of_code": 71,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "stop_filewatch.md": {
+      "file_path": "str/stop_filewatch.md",
+      "description": "Stravinsky skill",
+      "checksum": "dbe92100d0ba",
+      "lines_of_code": 89,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "cancel-loop.md": {
+      "file_path": "strav/cancel-loop.md",
+      "description": "Cancel active continuation loop",
+      "checksum": "d811ea8bb0e9",
+      "lines_of_code": 128,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "loop.md": {
+      "file_path": "strav/loop.md",
+      "description": "Continuation loop for iterative execution",
+      "checksum": "defc1ae0aae4",
+      "lines_of_code": 193,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "strav.md": {
+      "file_path": "strav.md",
+      "description": "Stravinsky Orchestrator - Parallel agent execution",
+      "checksum": "9c9969cf8c09",
+      "lines_of_code": 216,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "verify.md": {
+      "file_path": "verify.md",
+      "description": "Post-implementation verification",
+      "checksum": "87894579d5ec",
+      "lines_of_code": 60,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "version.md": {
+      "file_path": "version.md",
+      "description": "Stravinsky skill",
+      "checksum": "1cf41d5d28da",
+      "lines_of_code": 5,
+      "updatable": true,
+      "priority": "medium"
+    }
+  }
+}

mcp_bridge/hooks/__init__.py

@@ -99,22 +99,27 @@ __all__ = [
     "parallel_execution",
     "stravinsky_mode",
     "todo_delegation",
-    
     # Context & state
     "context",
     "todo_continuation",
     "pre_compact",
-    
     # Tool enhancement
     "tool_messaging",
     "edit_recovery",
     "truncator",
-    
     # Agent lifecycle
     "notification_hook",
     "subagent_stop",
 ]
 
+
+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
+
+
 __version__ = "0.2.63"
 __author__ = "David Andrews"
 __description__ = "Claude Code hooks for Stravinsky MCP parallel execution"

mcp_bridge/hooks/manager.py

@@ -6,6 +6,14 @@ Provides interception points for tool calls and model invocations.
 import logging
 from typing import Any, Callable, Dict, List, Optional, Awaitable
 
+try:
+    from mcp_bridge.config.hook_config import is_hook_enabled
+except ImportError:
+
+    def is_hook_enabled(hook_name: str) -> bool:
+        return True
+
+
 logger = logging.getLogger(__name__)
 
 

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)