claude-code-workflow 6.3.53 → 7.0.0

package/codex-lens/src/codexlens/api/lsp_lifecycle.py

@@ -0,0 +1,124 @@
+"""LSP server lifecycle management API.
+
+Provides synchronous wrappers around StandaloneLspManager's async
+start/stop methods for use via the executeCodexLensPythonAPI bridge.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from typing import Any, Dict
+
+
+def lsp_start(workspace_root: str) -> Dict[str, Any]:
+    """Start the standalone LSP manager and report configured servers.
+
+    Loads configuration and checks which language server commands are
+    available on the system.  Does NOT start individual language servers
+    (they start on demand when a file of that type is opened).
+
+    Args:
+        workspace_root: Absolute path to the workspace root directory.
+
+    Returns:
+        Dict with keys: servers (list of server info dicts),
+        workspace_root (str).
+    """
+    from codexlens.lsp.standalone_manager import StandaloneLspManager
+
+    async def _run() -> Dict[str, Any]:
+        manager = StandaloneLspManager(workspace_root=workspace_root)
+        await manager.start()
+
+        servers = []
+        for language_id, cfg in sorted(manager._configs.items()):
+            cmd0 = cfg.command[0] if cfg.command else None
+            servers.append({
+                "language_id": language_id,
+                "display_name": cfg.display_name,
+                "extensions": list(cfg.extensions),
+                "command": list(cfg.command),
+                "command_available": bool(shutil.which(cmd0)) if cmd0 else False,
+            })
+
+        # Stop the manager - individual servers are started on demand
+        await manager.stop()
+
+        return {
+            "servers": servers,
+            "server_count": len(servers),
+            "workspace_root": workspace_root,
+        }
+
+    return asyncio.run(_run())
+
+
+def lsp_stop(workspace_root: str) -> Dict[str, Any]:
+    """Stop all running language servers for the given workspace.
+
+    Creates a temporary manager instance, starts it (loads config),
+    then immediately stops it -- which terminates any running server
+    processes that match this workspace root.
+
+    Args:
+        workspace_root: Absolute path to the workspace root directory.
+
+    Returns:
+        Dict confirming shutdown.
+    """
+    from codexlens.lsp.standalone_manager import StandaloneLspManager
+
+    async def _run() -> Dict[str, Any]:
+        manager = StandaloneLspManager(workspace_root=workspace_root)
+        await manager.start()
+        await manager.stop()
+        return {"stopped": True}
+
+    return asyncio.run(_run())
+
+
+def lsp_restart(workspace_root: str) -> Dict[str, Any]:
+    """Restart the standalone LSP manager (stop then start).
+
+    Equivalent to calling lsp_stop followed by lsp_start, but avoids
+    the overhead of two separate Python process invocations.
+
+    Args:
+        workspace_root: Absolute path to the workspace root directory.
+
+    Returns:
+        Dict with keys: servers, server_count, workspace_root.
+    """
+    from codexlens.lsp.standalone_manager import StandaloneLspManager
+
+    async def _run() -> Dict[str, Any]:
+        # Stop phase
+        stop_manager = StandaloneLspManager(workspace_root=workspace_root)
+        await stop_manager.start()
+        await stop_manager.stop()
+
+        # Start phase
+        start_manager = StandaloneLspManager(workspace_root=workspace_root)
+        await start_manager.start()
+
+        servers = []
+        for language_id, cfg in sorted(start_manager._configs.items()):
+            cmd0 = cfg.command[0] if cfg.command else None
+            servers.append({
+                "language_id": language_id,
+                "display_name": cfg.display_name,
+                "extensions": list(cfg.extensions),
+                "command": list(cfg.command),
+                "command_available": bool(shutil.which(cmd0)) if cmd0 else False,
+            })
+
+        await start_manager.stop()
+
+        return {
+            "servers": servers,
+            "server_count": len(servers),
+            "workspace_root": workspace_root,
+        }
+
+    return asyncio.run(_run())

package/codex-lens/src/codexlens/api/semantic.py

@@ -24,6 +24,7 @@ def semantic_search(
     structural_weight: float = 0.3,
     keyword_weight: float = 0.2,
     fusion_strategy: str = "rrf",
+    staged_stage2_mode: Optional[str] = None,
     kind_filter: Optional[List[str]] = None,
     limit: int = 20,
     include_match_reason: bool = False,
@@ -48,7 +49,12 @@ def semantic_search(
             - rrf: Reciprocal Rank Fusion (recommended, default)
             - staged: Staged cascade -> staged_cascade_search
             - binary: Binary rerank cascade -> binary_cascade_search
-            - hybrid: Hybrid cascade -> hybrid_cascade_search
+            - hybrid: Binary rerank cascade (backward compat) -> binary_rerank_cascade_search
+            - dense_rerank: Dense rerank cascade -> dense_rerank_cascade_search
+        staged_stage2_mode: Optional override for staged Stage-2 expansion mode
+            - precomputed: GraphExpander over per-dir graph_neighbors (default)
+            - realtime: Live LSP expansion (requires LSP availability)
+            - static_global_graph: GlobalGraphExpander over global_relationships
         kind_filter: Symbol type filter (e.g., ["function", "class"])
         limit: Max return count (default 20)
         include_match_reason: Generate match reason (heuristic, not LLM)
@@ -96,14 +102,18 @@ def semantic_search(
     # Load config
     config = Config.load()
 
-    # Get or create registry and mapper
-    try:
-        registry = RegistryStore.default()
-        mapper = PathMapper(registry)
-    except Exception as exc:
-        logger.error("Failed to initialize search infrastructure: %s", exc)
-        return []
+    # Optional per-call override for staged cascade Stage-2 mode.
+    if staged_stage2_mode:
+        stage2 = str(staged_stage2_mode).strip().lower()
+        if stage2 in {"live"}:
+            stage2 = "realtime"
+        valid_stage2 = {"precomputed", "realtime", "static_global_graph"}
+        if stage2 in valid_stage2:
+            config.staged_stage2_mode = stage2
+        else:
+            logger.debug("Ignoring invalid staged_stage2_mode: %r", staged_stage2_mode)
 
+    # Get or create registry and mapper
     # Build search options based on mode
     search_options = _build_search_options(
         mode=mode,
@@ -115,15 +125,17 @@ def semantic_search(
 
     # Execute search based on fusion_strategy
     try:
-        with ChainSearchEngine(registry, mapper, config=config) as engine:
-            chain_result = _execute_search(
-                engine=engine,
-                query=query,
-                source_path=project_path,
-                fusion_strategy=fusion_strategy,
-                options=search_options,
-                limit=limit,
-            )
+        with RegistryStore() as registry:
+            mapper = PathMapper()
+            with ChainSearchEngine(registry, mapper, config=config) as engine:
+                chain_result = _execute_search(
+                    engine=engine,
+                    query=query,
+                    source_path=project_path,
+                    fusion_strategy=fusion_strategy,
+                    options=search_options,
+                    limit=limit,
+                )
     except Exception as exc:
         logger.error("Search execution failed: %s", exc)
         return []
@@ -215,7 +227,8 @@ def _execute_search(
     - rrf: Standard hybrid search with RRF fusion
     - staged: staged_cascade_search
     - binary: binary_cascade_search
-    - hybrid: hybrid_cascade_search
+    - hybrid: binary_rerank_cascade_search (backward compat)
+    - dense_rerank: dense_rerank_cascade_search
 
     Args:
         engine: ChainSearchEngine instance
@@ -249,8 +262,8 @@ def _execute_search(
             options=options,
         )
     elif fusion_strategy == "hybrid":
-        # Use hybrid cascade search (FTS+SPLADE+Vector + cross-encoder)
-        return engine.hybrid_cascade_search(
+        # Backward compat: hybrid now maps to binary_rerank_cascade_search
+        return engine.binary_rerank_cascade_search(
             query=query,
             source_path=source_path,
             k=limit,
@@ -342,8 +355,6 @@ def _transform_results(
                 fts_scores.append(source_scores["exact"])
             if "fuzzy" in source_scores:
                 fts_scores.append(source_scores["fuzzy"])
-            if "splade" in source_scores:
-                fts_scores.append(source_scores["splade"])
 
             if fts_scores:
                 structural_score = max(fts_scores)