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

mcp_bridge/notifications.py

@@ -0,0 +1,151 @@
+"""
+Desktop Notifications Manager for Stravinsky.
+
+Provides cross-platform desktop notifications (macOS, Linux, Windows)
+for long-running operations like codebase indexing.
+
+Supports:
+- Non-blocking async notifications
+- Platform-specific backends
+- Notification queuing
+"""
+
+import logging
+import platform
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationManager:
+    """
+    Cross-platform desktop notification manager.
+    
+    Provides non-blocking notifications with automatic platform detection.
+    """
+    
+    def __init__(self, app_name: str = "Stravinsky"):
+        self.app_name = app_name
+        self.system = platform.system()
+    
+    def _get_notification_command(
+        self, 
+        title: str, 
+        message: str, 
+        sound: bool = True
+    ) -> Optional[list]:
+        """Get platform-specific notification command."""
+        if self.system == "Darwin":  # macOS
+            script = f'display notification "{message}" with title "{title}"'
+            if sound:
+                script += ' sound name "Glass"'
+            return ["osascript", "-e", script]
+        
+        elif self.system == "Linux":
+            cmd = ["notify-send", "--app-name", self.app_name, title, message]
+            if sound:
+                cmd.extend(["--urgency=normal"])
+            return cmd
+        
+        elif self.system == "Windows":
+            ps_script = f"""
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] | Out-Null
+
+$template = @"
+<toast>
+    <visual>
+        <binding template="ToastGeneric">
+            <text>{title}</text>
+            <text>{message}</text>
+        </binding>
+    </visual>
+</toast>
+"@
+
+$xml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$xml.LoadXml($template)
+$toast = New-Object Windows.UI.Notifications.ToastNotification $xml
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("{self.app_name}").Show($toast)
+"""
+            return ["powershell", "-Command", ps_script]
+        
+        return None
+    
+    def _send_notification_sync(
+        self,
+        title: str,
+        message: str,
+        sound: bool = True
+    ) -> bool:
+        """Send notification synchronously (blocking)."""
+        cmd = self._get_notification_command(title, message, sound)
+        
+        if not cmd:
+            logger.warning(
+                f"[Notifications] Desktop notifications not supported on {self.system}"
+            )
+            return False
+        
+        try:
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            logger.debug(f"[Notifications] Sent: {title}")
+            return True
+        except FileNotFoundError:
+            logger.warning(f"[Notifications] Command not found: {cmd[0]}")
+            return False
+        except Exception as e:
+            logger.error(f"[Notifications] Failed to send notification: {e}")
+            return False
+    
+    async def notify_reindex_start(self, project_path: str) -> bool:
+        """Notify that codebase reindexing has started."""
+        path = Path(project_path).name or Path(project_path).parent.name
+        title = "Codebase Indexing Started"
+        message = f"Indexing {path}..."
+        return self._send_notification_sync(title, message, sound=True)
+    
+    async def notify_reindex_complete(self, stats: Dict) -> bool:
+        """Notify that codebase reindexing is complete."""
+        indexed = stats.get("indexed", 0)
+        pruned = stats.get("pruned", 0)
+        time_taken = stats.get("time_taken", 0)
+        
+        title = "Codebase Indexing Complete"
+        message = f"Indexed {indexed} chunks, pruned {pruned} stale entries in {time_taken}s"
+        
+        return self._send_notification_sync(title, message, sound=True)
+    
+    async def notify_reindex_error(self, error_message: str) -> bool:
+        """Notify that codebase reindexing failed."""
+        title = "Codebase Indexing Failed"
+        # Truncate long error messages
+        message = error_message[:100] + "..." if len(error_message) > 100 else error_message
+        
+        return self._send_notification_sync(title, message, sound=True)
+
+
+# Global singleton instance
+_notification_manager: Optional[NotificationManager] = None
+
+
+def get_notification_manager() -> NotificationManager:
+    """Get or create the global notification manager instance."""
+    global _notification_manager
+    if _notification_manager is None:
+        _notification_manager = NotificationManager()
+    return _notification_manager
+
+
+def reset_notification_manager() -> None:
+    """Reset the global notification manager (for testing)."""
+    global _notification_manager
+    _notification_manager = None

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,6 +389,28 @@ 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
 
@@ -436,6 +424,156 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 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}"
 
@@ -521,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
@@ -540,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():
@@ -752,4 +906,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())