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

mcp_bridge/server.py

@@ -7,22 +7,21 @@ Optimized for extremely fast startup and protocol compliance:
 - Robust crash logging to stderr and /tmp.
 """
 
-import sys
-import os
 import asyncio
 import logging
+import os
+import sys
 import time
 from typing import Any
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import (
-    Tool,
-    TextContent,
-    Resource,
+    GetPromptResult,
     Prompt,
     PromptMessage,
-    GetPromptResult,
+    TextContent,
+    Tool,
 )
 
 from . import __version__
@@ -35,6 +34,26 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# --- LOAD .env FILES (GEMINI_API_KEY, etc.) ---
+# Load from ~/.stravinsky/.env (dedicated config location)
+try:
+    from pathlib import Path
+
+    from dotenv import load_dotenv
+
+    # Load from ~/.env (user-global, lowest priority)
+    home_env = Path.home() / ".env"
+    if home_env.exists():
+        load_dotenv(home_env, override=False)
+
+    # Load from ~/.stravinsky/.env (stravinsky config, takes precedence)
+    stravinsky_env = Path.home() / ".stravinsky" / ".env"
+    if stravinsky_env.exists():
+        load_dotenv(stravinsky_env, override=True)
+        logger.info(f"[Config] Loaded environment from {stravinsky_env}")
+except ImportError:
+    pass  # python-dotenv not installed, skip
+
 
 # Pre-async crash logger
 def install_emergency_logger():
@@ -120,6 +139,17 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 thinking_budget=arguments.get("thinking_budget", 0),
             )
 
+        elif name == "invoke_gemini_agentic":
+            from .tools.model_invoke import invoke_gemini_agentic
+
+            result_content = await invoke_gemini_agentic(
+                token_store=token_store,
+                prompt=arguments["prompt"],
+                model=arguments.get("model", "gemini-3-flash"),
+                max_turns=arguments.get("max_turns", 10),
+                timeout=arguments.get("timeout", 120),
+            )
+
         elif name == "invoke_openai":
             from .tools.model_invoke import invoke_openai
 
@@ -130,6 +160,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 4096),
                 thinking_budget=arguments.get("thinking_budget", 0),
+                reasoning_effort=arguments.get("reasoning_effort", "medium"),
             )
 
         # --- CONTEXT DISPATCH ---
@@ -166,6 +197,13 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 file_pattern=arguments.get("file_pattern", ""),
             )
 
+        elif name == "list_directory":
+            from .tools.list_directory import list_directory
+
+            result_content = await list_directory(
+                path=arguments["path"],
+            )
+
         elif name == "ast_grep_search":
             from .tools.code_search import ast_grep_search
 
@@ -194,6 +232,56 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 directory=arguments.get("directory", "."),
             )
 
+        elif name == "read_file":
+            from .tools.read_file import read_file
+
+            result_content = await read_file(
+                path=arguments["path"],
+                offset=arguments.get("offset", 0),
+                limit=arguments.get("limit"),
+            )
+
+        elif name == "write_file":
+            from .tools.write_file import write_file
+
+            result_content = await write_file(
+                path=arguments["path"],
+                content=arguments["content"],
+            )
+
+        elif name == "replace":
+            from .tools.replace import replace
+
+            result_content = await replace(
+                path=arguments["path"],
+                old_string=arguments["old_string"],
+                new_string=arguments["new_string"],
+                instruction=arguments["instruction"],
+                expected_replacements=arguments.get("expected_replacements", 1),
+            )
+
+        elif name == "run_shell_command":
+            from .tools.run_shell_command import run_shell_command
+
+            result_content = await run_shell_command(
+                command=arguments["command"],
+                description=arguments["description"],
+                dir_path=arguments.get("dir_path", "."),
+            )
+
+        elif name == "tool_search":
+            from .tools.tool_search import search_tools
+            from .server_tools import get_tool_definitions
+
+            # Get all registered tool definitions to search through
+            all_tools = get_tool_definitions()
+
+            result_content = search_tools(
+                query=arguments["query"],
+                tools=all_tools,
+                top_k=arguments.get("top_k", 5),
+            )
+
         # --- SESSION DISPATCH ---
         elif name == "session_list":
             from .tools.session_manager import list_sessions
@@ -284,7 +372,15 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         elif name == "agent_list":
             from .tools.agent_manager import agent_list
 
-            result_content = await agent_list()
+            result_content = await agent_list(show_all=arguments.get("show_all", True))
+
+        elif name == "agent_cleanup":
+            from .tools.agent_manager import agent_cleanup
+
+            result_content = await agent_cleanup(
+                max_age_minutes=arguments.get("max_age_minutes", 30),
+                statuses=arguments.get("statuses"),
+            )
 
         elif name == "agent_progress":
             from .tools.agent_manager import agent_progress
@@ -448,6 +544,63 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 provider=arguments.get("provider", "ollama"),
             )
 
+        elif name == "find_code":
+            from .tools.find_code import find_code
+
+            result_content = await find_code(
+                query=arguments["query"],
+                search_type=arguments.get("search_type", "auto"),
+                project_path=arguments.get("project_path", "."),
+                language=arguments.get("language"),
+                n_results=arguments.get("n_results", 10),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "multi_query_search":
+            from .tools.search_enhancements import multi_query_search
+
+            result_content = await multi_query_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                num_expansions=arguments.get("num_expansions", 3),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "decomposed_search":
+            from .tools.search_enhancements import decomposed_search
+
+            result_content = await decomposed_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "enhanced_search":
+            from .tools.search_enhancements import enhanced_search
+
+            result_content = await enhanced_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                mode=arguments.get("mode", "auto"),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "get_cost_report":
+            from .tools.dashboard import get_cost_report
+
+            result_content = await get_cost_report(
+                session_id=arguments.get("session_id"),
+            )
+
         elif name == "semantic_index":
             from .tools.semantic_search import index_codebase
 
@@ -466,52 +619,60 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             )
 
         elif name == "start_file_watcher":
-            from .tools.semantic_search import start_file_watcher
             import json
 
+            from .tools.semantic_search import start_file_watcher
+
             try:
-                watcher = start_file_watcher(
+                watcher = await start_file_watcher(
                     project_path=arguments.get("project_path", "."),
                     provider=arguments.get("provider", "ollama"),
                     debounce_seconds=arguments.get("debounce_seconds", 2.0),
                 )
 
-                result_content = json.dumps({
-                    "status": "started",
-                    "project_path": str(watcher.project_path),
-                    "debounce_seconds": watcher.debounce_seconds,
-                    "provider": watcher.store.provider_name,
-                    "is_running": watcher.is_running()
-                }, indent=2)
+                result_content = json.dumps(
+                    {
+                        "status": "started",
+                        "project_path": str(watcher.project_path),
+                        "debounce_seconds": watcher.debounce_seconds,
+                        "provider": watcher.store.provider_name,
+                        "is_running": watcher.is_running(),
+                    },
+                    indent=2,
+                )
             except ValueError as e:
                 # No index exists
-                result_content = json.dumps({
-                    "error": str(e),
-                    "hint": "Run semantic_index() before starting file watcher"
-                }, indent=2)
+                result_content = json.dumps(
+                    {"error": str(e), "hint": "Run semantic_index() before starting file watcher"},
+                    indent=2,
+                )
                 print(f"⚠️  start_file_watcher ValueError: {e}", file=sys.stderr)
             except Exception as e:
                 # Unexpected error
                 import traceback
-                result_content = json.dumps({
-                    "error": f"{type(e).__name__}: {str(e)}",
-                    "hint": "Check MCP server logs for details"
-                }, indent=2)
+
+                result_content = json.dumps(
+                    {
+                        "error": f"{type(e).__name__}: {str(e)}",
+                        "hint": "Check MCP server logs for details",
+                    },
+                    indent=2,
+                )
                 print(f"❌ start_file_watcher error: {e}", file=sys.stderr)
                 traceback.print_exc(file=sys.stderr)
 
         elif name == "stop_file_watcher":
-            from .tools.semantic_search import stop_file_watcher
             import json
 
+            from .tools.semantic_search import stop_file_watcher
+
             stopped = stop_file_watcher(
                 project_path=arguments.get("project_path", "."),
             )
 
-            result_content = json.dumps({
-                "stopped": stopped,
-                "project_path": arguments.get("project_path", ".")
-            }, indent=2)
+            result_content = json.dumps(
+                {"stopped": stopped, "project_path": arguments.get("project_path", ".")}, indent=2
+            )
 
         elif name == "cancel_indexing":
             from .tools.semantic_search import cancel_indexing
@@ -531,9 +692,10 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             )
 
         elif name == "list_file_watchers":
-            from .tools.semantic_search import list_file_watchers
             import json
 
+            from .tools.semantic_search import list_file_watchers
+
             result_content = json.dumps(list_file_watchers(), indent=2)
 
         elif name == "multi_query_search":
@@ -620,7 +782,7 @@ async def list_prompts() -> list[Prompt]:
 @server.get_prompt()
 async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptResult:
     """Get a specific prompt content (lazy loaded)."""
-    from .prompts import stravinsky, delphi, dewey, explore, frontend, document_writer, multimodal
+    from .prompts import delphi, dewey, document_writer, explore, frontend, multimodal, stravinsky
 
     prompts_map = {
         "stravinsky": ("Stravinsky orchestrator system prompt", stravinsky.get_stravinsky_prompt),
@@ -649,8 +811,105 @@ async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptRe
     )
 
 
+def sync_user_assets():
+    """
+    Copy package assets to user scope (~/.claude/) on every MCP load.
+
+    This ensures all repos get the latest commands, hooks, rules, and agents
+    from the installed Stravinsky package.
+
+    Handles both:
+    - Development: .claude/ relative to project root
+    - Installed package: stravinsky_claude_assets/ in site-packages
+    """
+    from pathlib import Path
+    import shutil
+
+    # Try multiple locations for package assets
+    package_dir = Path(__file__).parent.parent  # stravinsky/
+
+    # Location 1: Development - .claude/ at project root
+    dev_claude = package_dir / ".claude"
+
+    # Location 2: Installed package - stravinsky_claude_assets in site-packages
+    # When installed via pip/uvx, hatch includes .claude as stravinsky_claude_assets
+    installed_claude = package_dir / "stravinsky_claude_assets"
+
+    # Also check relative to mcp_bridge (alternate install layout)
+    mcp_bridge_dir = Path(__file__).parent
+    installed_claude_alt = mcp_bridge_dir.parent / "stravinsky_claude_assets"
+
+    # Find the first existing assets directory
+    package_claude = None
+    for candidate in [dev_claude, installed_claude, installed_claude_alt]:
+        if candidate.exists():
+            package_claude = candidate
+            break
+
+    # User scope directory
+    user_claude = Path.home() / ".claude"
+
+    if package_claude is None:
+        # Try importlib.resources as last resort (Python 3.9+)
+        try:
+            import importlib.resources as resources
+
+            # Check if stravinsky_claude_assets is a package
+            with resources.files("stravinsky_claude_assets") as assets_path:
+                if assets_path.is_dir():
+                    package_claude = Path(assets_path)
+        except (ImportError, ModuleNotFoundError, TypeError):
+            pass
+
+    if package_claude is None:
+        logger.debug(f"Package assets not found (checked: {dev_claude}, {installed_claude})")
+        return
+
+    # Directories to sync
+    dirs_to_sync = ["commands", "hooks", "rules", "agents"]
+
+    for dir_name in dirs_to_sync:
+        src_dir = package_claude / dir_name
+        dst_dir = user_claude / dir_name
+
+        if not src_dir.exists():
+            continue
+
+        # Create destination if it doesn't exist
+        dst_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy all files recursively (overwrite if source is newer)
+        for src_file in src_dir.rglob("*"):
+            if src_file.is_file():
+                # Compute relative path
+                rel_path = src_file.relative_to(src_dir)
+                dst_file = dst_dir / rel_path
+
+                # Create parent directories
+                dst_file.parent.mkdir(parents=True, exist_ok=True)
+
+                # Copy if source is newer or dest doesn't exist
+                should_copy = not dst_file.exists()
+                if dst_file.exists():
+                    src_mtime = src_file.stat().st_mtime
+                    dst_mtime = dst_file.stat().st_mtime
+                    should_copy = src_mtime > dst_mtime
+
+                if should_copy:
+                    shutil.copy2(src_file, dst_file)
+                    logger.debug(f"Synced {dir_name}/{rel_path} to user scope")
+
+    logger.info("Synced package assets to user scope (~/.claude/)")
+
+
 async def async_main():
     """Server execution entry point."""
+    # Sync package assets to user scope on every MCP load
+    try:
+        sync_user_assets()
+    except Exception as e:
+        logger.warning(f"Failed to sync user assets: {e}")
+
     # Initialize hooks at runtime, not import time
     try:
         from .hooks import initialize_hooks
@@ -685,7 +944,7 @@ async def async_main():
                 write_stream,
                 server.create_initialization_options(),
             )
-    except Exception as e:
+    except Exception:
         logger.critical("Server process crashed in async_main", exc_info=True)
         sys.exit(1)
     finally:
@@ -699,9 +958,9 @@ async def async_main():
 def main():
     """Synchronous entry point with CLI arg handling."""
     import argparse
-    import sys
-    from .tools.agent_manager import get_manager
+
     from .auth.token_store import TokenStore
+    from .tools.agent_manager import get_manager
 
     parser = argparse.ArgumentParser(
         description="Stravinsky MCP Bridge - Multi-model AI orchestration for Claude Code. "
@@ -751,6 +1010,31 @@ def main():
         help="Also clear agent history from .stravinsky/agents.json",
     )
 
+    # proxy command (model server proxy)
+    proxy_parser = subparsers.add_parser(
+        "proxy",
+        help="Manage the model proxy server",
+        description="Starts or manages the FastAPI model proxy for async execution.",
+    )
+    proxy_subparsers = proxy_parser.add_subparsers(
+        dest="proxy_command", help="Proxy subcommands", metavar="SUBCOMMAND"
+    )
+    proxy_subparsers.add_parser(
+        "start",
+        help="Start the model proxy server",
+        description="Launches the FastAPI server on port 8765.",
+    )
+    proxy_subparsers.add_parser(
+        "stop",
+        help="Stop the model proxy server",
+        description="Terminates any running model proxy process.",
+    )
+    proxy_subparsers.add_parser(
+        "status",
+        help="Check proxy server status",
+        description="Verifies if the proxy server is reachable.",
+    )
+
     # auth command (authentication)
     auth_parser = subparsers.add_parser(
         "auth",
@@ -862,6 +1146,51 @@ def main():
             print(f"Stopped {count} running agent(s).")
         return 0
 
+    elif args.command == "proxy":
+        proxy_cmd = getattr(args, "proxy_command", None)
+        import os
+        import sys
+
+        if proxy_cmd == "start":
+            from .proxy.model_server import main as proxy_main
+
+            proxy_main()
+            return 0
+        elif proxy_cmd == "stop":
+            # Simple kill-by-port for now
+            import os
+            import subprocess
+
+            port = int(os.getenv("STRAVINSKY_PROXY_PORT", 8765))
+            try:
+                if sys.platform == "win32":
+                    subprocess.run(
+                        f"taskkill /F /FI \"PID eq $(netstat -ano | findstr :{port} | awk '{{print $5}}')\"",
+                        shell=True,
+                    )
+                else:
+                    subprocess.run(f"lsof -ti:{port} | xargs kill -9", shell=True)
+                print(f"Stopped proxy on port {port}")
+            except Exception as e:
+                print(f"Failed to stop proxy: {e}")
+            return 0
+        elif proxy_cmd == "status":
+            import socket
+
+            port = int(os.getenv("STRAVINSKY_PROXY_PORT", 8765))
+            host = os.getenv("STRAVINSKY_PROXY_HOST", "127.0.0.1")
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                try:
+                    s.connect((host, port))
+                    print(f"✅ Proxy is RUNNING on {host}:{port}")
+                except Exception:
+                    print(f"❌ Proxy is NOT RUNNING on {host}:{port}")
+            return 0
+        else:
+            proxy_parser.print_help()
+            return 0
+
     elif args.command == "auth":
         auth_cmd = getattr(args, "auth_command", None)
         token_store = get_token_store()