stravinsky 0.2.7__py3-none-any.whl → 0.2.38__py3-none-any.whl

mcp_bridge/server.py

@@ -31,12 +31,11 @@ from . import __version__
 
 # Configure logging to stderr explicitly to avoid protocol corruption
 logging.basicConfig(
-    level=logging.INFO,
-    format='%(levelname)s:%(name)s:%(message)s',
-    stream=sys.stderr
+    level=logging.INFO, format="%(levelname)s:%(name)s:%(message)s", stream=sys.stderr
 )
 logger = logging.getLogger(__name__)
 
+
 # Pre-async crash logger
 def install_emergency_logger():
     def handle_exception(exc_type, exc_value, exc_traceback):
@@ -47,13 +46,15 @@ def install_emergency_logger():
         try:
             with open("/tmp/stravinsky_crash.log", "a") as f:
                 import traceback
+
                 f.write(f"\n--- CRASH AT {time.ctime()} ---\n")
                 traceback.print_exception(exc_type, exc_value, exc_traceback, file=f)
         except:
             pass
-            
+
     sys.excepthook = handle_exception
 
+
 install_emergency_logger()
 
 # --- SERVER INITIALIZATION ---
@@ -64,28 +65,36 @@ server = Server("stravinsky", version=__version__)
 _token_store = None
 _hook_manager = None
 
+
 def get_token_store():
     global _token_store
     if _token_store is None:
         from .auth.token_store import TokenStore
+
         _token_store = TokenStore()
     return _token_store
 
+
 def get_hook_manager_lazy():
     global _hook_manager
     if _hook_manager is None:
         from .hooks.manager import get_hook_manager
+
         _hook_manager = get_hook_manager()
     return _hook_manager
 
+
 # --- MCP INTERFACE ---
 
+
 @server.list_tools()
 async def list_tools() -> list[Tool]:
     """List available tools (metadata only)."""
     from .server_tools import get_tool_definitions
+
     return get_tool_definitions()
 
+
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls with deep lazy loading of implementations."""
@@ -96,12 +105,13 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     try:
         # Pre-tool call hooks orchestration
         arguments = await hook_manager.execute_pre_tool_call(name, arguments)
-        
+
         result_content = None
 
         # --- MODEL DISPATCH ---
         if name == "invoke_gemini":
             from .tools.model_invoke import invoke_gemini
+
             result_content = await invoke_gemini(
                 token_store=token_store,
                 prompt=arguments["prompt"],
@@ -113,6 +123,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "invoke_openai":
             from .tools.model_invoke import invoke_openai
+
             result_content = await invoke_openai(
                 token_store=token_store,
                 prompt=arguments["prompt"],
@@ -125,15 +136,18 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         # --- CONTEXT DISPATCH ---
         elif name == "get_project_context":
             from .tools.project_context import get_project_context
+
             result_content = await get_project_context(project_path=arguments.get("project_path"))
 
         elif name == "get_system_health":
             from .tools.project_context import get_system_health
+
             result_content = await get_system_health()
 
         # --- SEARCH DISPATCH ---
         elif name == "grep_search":
             from .tools.code_search import grep_search
+
             result_content = await grep_search(
                 pattern=arguments["pattern"],
                 directory=arguments.get("directory", "."),
@@ -142,6 +156,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "ast_grep_search":
             from .tools.code_search import ast_grep_search
+
             result_content = await ast_grep_search(
                 pattern=arguments["pattern"],
                 directory=arguments.get("directory", "."),
@@ -150,6 +165,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "ast_grep_replace":
             from .tools.code_search import ast_grep_replace
+
             result_content = await ast_grep_replace(
                 pattern=arguments["pattern"],
                 replacement=arguments["replacement"],
@@ -160,6 +176,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "glob_files":
             from .tools.code_search import glob_files
+
             result_content = await glob_files(
                 pattern=arguments["pattern"],
                 directory=arguments.get("directory", "."),
@@ -168,6 +185,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         # --- SESSION DISPATCH ---
         elif name == "session_list":
             from .tools.session_manager import list_sessions
+
             result_content = list_sessions(
                 project_path=arguments.get("project_path"),
                 limit=arguments.get("limit", 20),
@@ -175,6 +193,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "session_read":
             from .tools.session_manager import read_session
+
             result_content = read_session(
                 session_id=arguments["session_id"],
                 limit=arguments.get("limit"),
@@ -182,6 +201,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "session_search":
             from .tools.session_manager import search_sessions
+
             result_content = search_sessions(
                 query=arguments["query"],
                 session_id=arguments.get("session_id"),
@@ -191,33 +211,57 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         # --- SKILL DISPATCH ---
         elif name == "skill_list":
             from .tools.skill_loader import list_skills
+
             result_content = list_skills(project_path=arguments.get("project_path"))
 
         elif name == "skill_get":
             from .tools.skill_loader import get_skill
+
             result_content = get_skill(
                 name=arguments["name"],
                 project_path=arguments.get("project_path"),
             )
 
+        elif name == "stravinsky_version":
+            from . import __version__
+            import sys
+            import os
+
+            result_content = [
+                TextContent(
+                    type="text",
+                    text=f"Stravinsky Bridge v{__version__}\n"
+                    f"Python: {sys.version.split()[0]}\n"
+                    f"Platform: {sys.platform}\n"
+                    f"CWD: {os.getcwd()}\n"
+                    f"CLI: {os.environ.get('CLAUDE_CLI', '/opt/homebrew/bin/claude')}",
+                )
+            ]
+
+        elif name == "system_restart":
+            # Schedule a restart. We can't exit immediately or MCP will error on the reply.
+            # We'll use a small delay.
+            async def restart_soon():
+                await asyncio.sleep(1)
+                os._exit(0)  # Immediate exit
+
+            asyncio.create_task(restart_soon())
+            result_content = [
+                TextContent(
+                    type="text",
+                    text="🚀 Restarting Stravinsky Bridge... This process will exit and Claude Code will automatically respawn it. Please wait a few seconds before calling tools again.",
+                )
+            ]
+
         # --- AGENT DISPATCH ---
         elif name == "agent_spawn":
-            from .tools.agent_manager import get_agent_manager
-            manager = get_agent_manager()
-            result_content = await manager.spawn(
-                token_store=token_store,
-                prompt=arguments["prompt"],
-                agent_type=arguments.get("agent_type", "explore"),
-                description=arguments.get("description", ""),
-                parent_session_id=arguments.get("parent_session_id"),
-                system_prompt=arguments.get("system_prompt"),
-                model=arguments.get("model", "gemini-3-flash"),
-                thinking_budget=arguments.get("thinking_budget", 0),
-                timeout=arguments.get("timeout", 300),
-            )
+            from .tools.agent_manager import agent_spawn
+
+            result_content = await agent_spawn(**arguments)
 
         elif name == "agent_output":
             from .tools.agent_manager import agent_output
+
             result_content = await agent_output(
                 task_id=arguments["task_id"],
                 block=arguments.get("block", False),
@@ -225,14 +269,17 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "agent_cancel":
             from .tools.agent_manager import agent_cancel
+
             result_content = await agent_cancel(task_id=arguments["task_id"])
 
         elif name == "agent_list":
             from .tools.agent_manager import agent_list
+
             result_content = await agent_list()
 
         elif name == "agent_progress":
             from .tools.agent_manager import agent_progress
+
             result_content = await agent_progress(
                 task_id=arguments["task_id"],
                 lines=arguments.get("lines", 20),
@@ -240,6 +287,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "agent_retry":
             from .tools.agent_manager import agent_retry
+
             result_content = await agent_retry(
                 task_id=arguments["task_id"],
                 new_prompt=arguments.get("new_prompt"),
@@ -249,6 +297,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         # --- BACKGROUND TASK DISPATCH ---
         elif name == "task_spawn":
             from .tools.background_tasks import task_spawn
+
             result_content = await task_spawn(
                 prompt=arguments["prompt"],
                 model=arguments.get("model", "gemini-3-flash"),
@@ -256,15 +305,18 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "task_status":
             from .tools.background_tasks import task_status
+
             result_content = await task_status(task_id=arguments["task_id"])
 
         elif name == "task_list":
             from .tools.background_tasks import task_list
+
             result_content = await task_list()
 
         # --- LSP DISPATCH ---
         elif name == "lsp_hover":
             from .tools.lsp import lsp_hover
+
             result_content = await lsp_hover(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -273,6 +325,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_goto_definition":
             from .tools.lsp import lsp_goto_definition
+
             result_content = await lsp_goto_definition(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -281,6 +334,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_find_references":
             from .tools.lsp import lsp_find_references
+
             result_content = await lsp_find_references(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -290,14 +344,17 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_document_symbols":
             from .tools.lsp import lsp_document_symbols
+
             result_content = await lsp_document_symbols(file_path=arguments["file_path"])
 
         elif name == "lsp_workspace_symbols":
             from .tools.lsp import lsp_workspace_symbols
+
             result_content = await lsp_workspace_symbols(query=arguments["query"])
 
         elif name == "lsp_prepare_rename":
             from .tools.lsp import lsp_prepare_rename
+
             result_content = await lsp_prepare_rename(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -306,6 +363,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_rename":
             from .tools.lsp import lsp_rename
+
             result_content = await lsp_rename(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -315,6 +373,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_code_actions":
             from .tools.lsp import lsp_code_actions
+
             result_content = await lsp_code_actions(
                 file_path=arguments["file_path"],
                 line=arguments["line"],
@@ -323,6 +382,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         elif name == "lsp_servers":
             from .tools.lsp import lsp_servers
+
             result_content = await lsp_servers()
 
         else:
@@ -330,12 +390,20 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
         # Post-tool call hooks orchestration
         if result_content is not None:
-             if isinstance(result_content, list) and len(result_content) > 0 and hasattr(result_content[0], "text"):
-                 processed_text = await hook_manager.execute_post_tool_call(name, arguments, result_content[0].text)
-                 result_content[0].text = processed_text
-             elif isinstance(result_content, str):
-                 result_content = await hook_manager.execute_post_tool_call(name, arguments, result_content)
-        
+            if (
+                isinstance(result_content, list)
+                and len(result_content) > 0
+                and hasattr(result_content[0], "text")
+            ):
+                processed_text = await hook_manager.execute_post_tool_call(
+                    name, arguments, result_content[0].text
+                )
+                result_content[0].text = processed_text
+            elif isinstance(result_content, str):
+                result_content = await hook_manager.execute_post_tool_call(
+                    name, arguments, result_content
+                )
+
         # Format final return as List[TextContent]
         if isinstance(result_content, list):
             return result_content
@@ -345,17 +413,20 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         logger.error(f"Error calling tool {name}: {e}")
         return [TextContent(type="text", text=f"Error: {str(e)}")]
 
+
 @server.list_prompts()
 async def list_prompts() -> list[Prompt]:
     """List available prompts (metadata only)."""
     from .server_tools import get_prompt_definitions
+
     return get_prompt_definitions()
 
+
 @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
-    
+
     prompts_map = {
         "stravinsky": ("Stravinsky orchestrator system prompt", stravinsky.get_stravinsky_prompt),
         "delphi": ("Delphi advisor system prompt", delphi.get_delphi_prompt),
@@ -365,13 +436,13 @@ async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptRe
         "document_writer": ("Document Writer prompt", document_writer.get_document_writer_prompt),
         "multimodal": ("Multimodal Looker prompt", multimodal.get_multimodal_prompt),
     }
-    
+
     if name not in prompts_map:
         raise ValueError(f"Unknown prompt: {name}")
-    
+
     description, get_prompt_fn = prompts_map[name]
     prompt_text = get_prompt_fn()
-    
+
     return GetPromptResult(
         description=description,
         messages=[
@@ -382,11 +453,13 @@ async def get_prompt(name: str, arguments: dict[str, str] | None) -> GetPromptRe
         ],
     )
 
+
 async def async_main():
     """Server execution entry point."""
     # Initialize hooks at runtime, not import time
     try:
         from .hooks import initialize_hooks
+
         initialize_hooks()
     except Exception as e:
         logger.error(f"Failed to initialize hooks: {e}")
@@ -402,22 +475,215 @@ async def async_main():
         logger.critical("Server process crashed in async_main", exc_info=True)
         sys.exit(1)
 
+
 def main():
     """Synchronous entry point with CLI arg handling."""
     import argparse
-    parser = argparse.ArgumentParser(description="Stravinsky MCP Bridge Server")
+    import sys
+    from .tools.agent_manager import get_manager
+    from .auth.token_store import TokenStore
+
+    parser = argparse.ArgumentParser(
+        description="Stravinsky MCP Bridge - Multi-model AI orchestration for Claude Code. "
+        "Spawns background agents with full tool access via Claude CLI.",
+        prog="stravinsky",
+        epilog="Examples:\n"
+        "  stravinsky              # Start MCP server (default)\n"
+        "  stravinsky list         # Show all background agents\n"
+        "  stravinsky status       # Check auth status\n"
+        "  stravinsky stop --clear # Stop agents and clear history\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
     parser.add_argument("--version", action="version", version=f"stravinsky {__version__}")
-    
-    # Check for CLI flags before starting async loop
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands", metavar="COMMAND")
+
+    # list command
+    subparsers.add_parser(
+        "list",
+        help="List all background agent tasks",
+        description="Shows status, ID, type, and description of all spawned agents.",
+    )
+
+    # status command
+    subparsers.add_parser(
+        "status",
+        help="Show authentication status for all providers",
+        description="Displays OAuth authentication status and token expiration for Gemini and OpenAI.",
+    )
+
+    # start command (explicit server start)
+    subparsers.add_parser(
+        "start",
+        help="Explicitly start the MCP server (STDIO transport)",
+        description="Starts the MCP server for communication with Claude Code. Usually started automatically.",
+    )
+
+    # stop command (stop all agents)
+    stop_parser = subparsers.add_parser(
+        "stop",
+        help="Stop all running background agents",
+        description="Terminates all active agent processes. Use --clear to also remove history.",
+    )
+    stop_parser.add_argument(
+        "--clear",
+        action="store_true",
+        help="Also clear agent history from .stravinsky/agents.json",
+    )
+
+    # auth command (authentication)
+    auth_parser = subparsers.add_parser(
+        "auth",
+        help="Authentication commands (login/logout/refresh/status)",
+        description="Manage OAuth authentication for Gemini and OpenAI providers.",
+    )
+    auth_subparsers = auth_parser.add_subparsers(
+        dest="auth_command", help="Auth subcommands", metavar="SUBCOMMAND"
+    )
+
+    # auth login
+    login_parser = auth_subparsers.add_parser(
+        "login",
+        help="Login to a provider via browser OAuth",
+        description="Opens browser for OAuth authentication with the specified provider.",
+    )
+    login_parser.add_argument(
+        "provider",
+        choices=["gemini", "openai"],
+        metavar="PROVIDER",
+        help="Provider to authenticate with: gemini (Google) or openai (ChatGPT Plus/Pro)",
+    )
+
+    # auth logout
+    logout_parser = auth_subparsers.add_parser(
+        "logout",
+        help="Remove stored OAuth credentials",
+        description="Deletes stored access and refresh tokens for the specified provider.",
+    )
+    logout_parser.add_argument(
+        "provider",
+        choices=["gemini", "openai"],
+        metavar="PROVIDER",
+        help="Provider to logout from: gemini or openai",
+    )
+
+    # auth status
+    auth_subparsers.add_parser(
+        "status",
+        help="Show authentication status for all providers",
+        description="Displays authentication status and token expiration for Gemini and OpenAI.",
+    )
+
+    # auth refresh
+    refresh_parser = auth_subparsers.add_parser(
+        "refresh",
+        help="Manually refresh access token",
+        description="Force-refresh the access token using the stored refresh token.",
+    )
+    refresh_parser.add_argument(
+        "provider",
+        choices=["gemini", "openai"],
+        metavar="PROVIDER",
+        help="Provider to refresh token for: gemini or openai",
+    )
+
+    # auth init
+    auth_subparsers.add_parser(
+        "init",
+        help="Bootstrap current repository for Stravinsky",
+        description="Creates .stravinsky/ directory structure and copies default configuration files.",
+    )
+
+    # Check for CLI flags
     args, unknown = parser.parse_known_args()
-    
-    try:
+
+    if args.command == "list":
+        # Run agent_list logic
+        manager = get_manager()
+        tasks = manager.list_tasks()
+        if not tasks:
+            print("No background agent tasks found.")
+            return 0
+
+        print("\nStravinsky Background Agents:")
+        print("-" * 100)
+        print(f"{'STATUS':10} | {'ID':15} | {'TYPE':10} | {'STARTED':20} | DESCRIPTION")
+        print("-" * 100)
+        for t in sorted(tasks, key=lambda x: x.get("created_at", ""), reverse=True):
+            status = t["status"]
+            task_id = t["id"]
+            agent = t["agent_type"]
+            created = t.get("created_at", "")[:19].replace("T", " ")  # Format datetime
+            desc = t.get("description", t.get("prompt", "")[:40])[:40]
+            print(f"{status.upper():10} | {task_id:15} | {agent:10} | {created:20} | {desc}")
+
+            # Show error for failed agents
+            if status == "failed" and t.get("error"):
+                error_msg = t["error"][:100].replace("\n", " ")
+                print(f"           └─ ERROR: {error_msg}")
+        print("-" * 100)
+        return 0
+
+    elif args.command == "status":
+        from .auth.cli import cmd_status
+
+        return cmd_status(TokenStore())
+
+    elif args.command == "start":
         asyncio.run(async_main())
-    except KeyboardInterrupt:
-        pass
-    except Exception as e:
-        logger.critical(f"Unhandled exception in main: {e}")
-        sys.exit(1)
+        return 0
+
+    elif args.command == "stop":
+        manager = get_manager()
+        count = manager.stop_all(clear_history=getattr(args, "clear", False))
+        if getattr(args, "clear", False):
+            print(f"Cleared {count} agent task(s) from history.")
+        else:
+            print(f"Stopped {count} running agent(s).")
+        return 0
+
+    elif args.command == "auth":
+        auth_cmd = getattr(args, "auth_command", None)
+        token_store = get_token_store()
+
+        if auth_cmd == "login":
+            from .auth.cli import cmd_login
+
+            return cmd_login(args.provider, token_store)
+
+        elif auth_cmd == "logout":
+            from .auth.cli import cmd_logout
+
+            return cmd_logout(args.provider, token_store)
+
+        elif auth_cmd == "status":
+            from .auth.cli import cmd_status
+
+            return cmd_status(token_store)
+
+        elif auth_cmd == "refresh":
+            from .auth.cli import cmd_refresh
+
+            return cmd_refresh(args.provider, token_store)
+
+        elif auth_cmd == "init":
+            from .tools.init import bootstrap_repo
+
+            print(bootstrap_repo())
+            return 0
+
+        else:
+            auth_parser.print_help()
+            return 0
+
+    else:
+        # Default behavior: start server (fallback for MCP runners and unknown args)
+        # This ensures that flags like --transport stdio don't cause an exit
+        if unknown:
+            logger.info(f"Starting MCP server with unknown arguments: {unknown}")
+        asyncio.run(async_main())
+        return 0
+
 
 if __name__ == "__main__":
     main()

mcp_bridge/server_tools.py

@@ -4,6 +4,22 @@ from typing import List
 def get_tool_definitions() -> List[Tool]:
     """Return all Tool definitions for the Stravinsky MCP server."""
     return [
+        Tool(
+            name="stravinsky_version",
+            description="Returns the current version of the Stravinsky MCP bridge and diagnostic info.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="system_restart",
+            description="Force-restarts the Stravinsky MCP server by exiting the process. The host (Claude Code) will automatically respawn it, picking up any updated code/packages.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
         Tool(
             name="invoke_gemini",
             description=(
@@ -249,8 +265,10 @@ def get_tool_definitions() -> List[Tool]:
         Tool(
             name="agent_spawn",
             description=(
-                "Spawn a background agent. Uses Gemini by default for fast execution. "
-                "Set model='claude' to use Claude Code CLI with full tool access."
+                "PREFERRED TOOL for parallel work. Spawn multiple agents simultaneously for independent tasks. "
+                "ALWAYS use this when you have 2+ independent research, implementation, or verification tasks. "
+                "Call agent_spawn multiple times in ONE response to run tasks concurrently. "
+                "Each agent runs independently with full Gemini capabilities."
             ),
             inputSchema={
                 "type": "object",
@@ -258,7 +276,7 @@ def get_tool_definitions() -> List[Tool]:
                     "prompt": {"type": "string", "description": "The task for the agent to perform"},
                     "agent_type": {
                         "type": "string",
-                        "description": "Agent type: explore, dewey, frontend, delphi",
+                        "description": "Agent type: explore, dewey, frontend (gemini-3-pro), delphi (gpt-5.2-medium), document_writer, multimodal",
                         "default": "explore",
                     },
                     "description": {"type": "string", "description": "Short description for status display"},