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

mcp_bridge/server.py

@@ -95,56 +95,9 @@ async def list_tools() -> list[Tool]:
     return get_tool_definitions()
 
 
-def _format_tool_log(name: str, arguments: dict[str, Any]) -> str:
-    """Format a concise log message for tool calls."""
-    # LSP tools - show file:line
-    if name.startswith("lsp_"):
-        file_path = arguments.get("file_path", "")
-        if file_path:
-            # Shorten path to last 2 components
-            parts = file_path.split("/")
-            short_path = "/".join(parts[-2:]) if len(parts) > 2 else file_path
-            line = arguments.get("line", "")
-            if line:
-                return f"→ {name}: {short_path}:{line}"
-            return f"→ {name}: {short_path}"
-        query = arguments.get("query", "")
-        if query:
-            return f"→ {name}: query='{query[:40]}'"
-        return f"→ {name}"
-
-    # Model invocation - show agent context if present
-    if name in ("invoke_gemini", "invoke_openai"):
-        agent_ctx = arguments.get("agent_context", {})
-        agent_type = agent_ctx.get("agent_type", "direct") if agent_ctx else "direct"
-        model = arguments.get("model", "default")
-        prompt = arguments.get("prompt", "")
-        # Summarize prompt
-        summary = " ".join(prompt.split())[:80] + "..." if len(prompt) > 80 else prompt
-        return f"[{agent_type}] → {model}: {summary}"
-
-    # Search tools - show pattern
-    if name in ("grep_search", "ast_grep_search", "ast_grep_replace"):
-        pattern = arguments.get("pattern", "")[:50]
-        return f"→ {name}: pattern='{pattern}'"
-
-    # Agent tools - show agent type/task_id
-    if name == "agent_spawn":
-        agent_type = arguments.get("agent_type", "explore")
-        desc = arguments.get("description", "")[:40]
-        return f"→ {name}: [{agent_type}] {desc}"
-    if name in ("agent_output", "agent_cancel", "agent_progress"):
-        task_id = arguments.get("task_id", "")
-        return f"→ {name}: {task_id}"
-
-    # Default - just tool name
-    return f"→ {name}"
-
-
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls with deep lazy loading of implementations."""
-    logger.info(_format_tool_log(name, arguments))
     hook_manager = get_hook_manager_lazy()
     token_store = get_token_store()
 
@@ -190,6 +143,19 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
             result_content = await get_system_health()
 
+        elif name == "semantic_health":
+            from .tools.semantic_search import semantic_health
+
+            result_content = await semantic_health(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "lsp_health":
+            from .tools.lsp.tools import lsp_health
+
+            result_content = await lsp_health()
+
         # --- SEARCH DISPATCH ---
         elif name == "grep_search":
             from .tools.code_search import grep_search
@@ -423,11 +389,191 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 character=arguments["character"],
             )
 
+        elif name == "lsp_code_action_resolve":
+            from .tools.lsp import lsp_code_action_resolve
+
+            result_content = await lsp_code_action_resolve(
+                file_path=arguments["file_path"],
+                action_code=arguments["action_code"],
+                line=arguments.get("line"),
+            )
+
+        elif name == "lsp_extract_refactor":
+            from .tools.lsp import lsp_extract_refactor
+
+            result_content = await lsp_extract_refactor(
+                file_path=arguments["file_path"],
+                start_line=arguments["start_line"],
+                start_char=arguments["start_char"],
+                end_line=arguments["end_line"],
+                end_char=arguments["end_char"],
+                new_name=arguments["new_name"],
+                kind=arguments.get("kind", "function"),
+            )
+
         elif name == "lsp_servers":
             from .tools.lsp import lsp_servers
 
             result_content = await lsp_servers()
 
+        elif name == "lsp_diagnostics":
+            from .tools.code_search import lsp_diagnostics
+
+            result_content = await lsp_diagnostics(
+                file_path=arguments["file_path"],
+                severity=arguments.get("severity", "all"),
+            )
+
+        elif name == "semantic_search":
+            from .tools.semantic_search import semantic_search
+
+            result_content = await semantic_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 == "hybrid_search":
+            from .tools.semantic_search import hybrid_search
+
+            result_content = await hybrid_search(
+                query=arguments["query"],
+                pattern=arguments.get("pattern"),
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "semantic_index":
+            from .tools.semantic_search import index_codebase
+
+            result_content = await index_codebase(
+                project_path=arguments.get("project_path", "."),
+                force=arguments.get("force", False),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "semantic_stats":
+            from .tools.semantic_search import semantic_stats
+
+            result_content = await semantic_stats(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "start_file_watcher":
+            from .tools.semantic_search import start_file_watcher
+            import json
+
+            try:
+                watcher = 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)
+            except ValueError as e:
+                # No index exists
+                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)
+                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
+
+            stopped = stop_file_watcher(
+                project_path=arguments.get("project_path", "."),
+            )
+
+            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
+
+            result_content = cancel_indexing(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "delete_index":
+            from .tools.semantic_search import delete_index
+
+            result_content = delete_index(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider"),  # None if not specified
+                delete_all=arguments.get("delete_all", False),
+            )
+
+        elif name == "list_file_watchers":
+            from .tools.semantic_search import list_file_watchers
+            import json
+
+            result_content = json.dumps(list_file_watchers(), indent=2)
+
+        elif name == "multi_query_search":
+            from .tools.semantic_search 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.semantic_search 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.semantic_search 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"),
+            )
+
         else:
             result_content = f"Unknown tool: {name}"
 
@@ -441,7 +587,10 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 processed_text = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content[0].text
                 )
-                result_content[0].text = processed_text
+                # Only update if processed_text is non-empty to avoid empty text blocks
+                # (API error: cache_control cannot be set for empty text blocks)
+                if processed_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
@@ -510,6 +659,16 @@ async def async_main():
     except Exception as e:
         logger.error(f"Failed to initialize hooks: {e}")
 
+    # Clean up stale ChromaDB locks on startup
+    try:
+        from .tools.semantic_search import cleanup_stale_chromadb_locks
+
+        removed_count = cleanup_stale_chromadb_locks()
+        if removed_count > 0:
+            logger.info(f"Cleaned up {removed_count} stale ChromaDB lock(s)")
+    except Exception as e:
+        logger.warning(f"Failed to cleanup ChromaDB locks: {e}")
+
     # Start background token refresh scheduler
     try:
         from .auth.token_refresh import background_token_refresh
@@ -529,6 +688,12 @@ async def async_main():
     except Exception as e:
         logger.critical("Server process crashed in async_main", exc_info=True)
         sys.exit(1)
+    finally:
+        logger.info("Initiating shutdown sequence...")
+        from .tools.lsp.manager import get_lsp_manager
+
+        lsp_manager = get_lsp_manager()
+        await lsp_manager.shutdown()
 
 
 def main():
@@ -741,4 +906,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())