claude-code-workflow 6.3.53 → 7.0.0

package/codex-lens/src/codexlens/env_config.py

@@ -45,6 +45,22 @@ ENV_VARS = {
     # General configuration
     "CODEXLENS_DATA_DIR": "Custom data directory path",
     "CODEXLENS_DEBUG": "Enable debug mode (true/false)",
+    # Cascade / staged pipeline configuration
+    "ENABLE_CASCADE_SEARCH": "Enable cascade search (true/false)",
+    "CASCADE_STRATEGY": "Cascade strategy: binary, binary_rerank (alias: hybrid), dense_rerank, staged",
+    "CASCADE_COARSE_K": "Cascade coarse_k candidate count (int)",
+    "CASCADE_FINE_K": "Cascade fine_k result count (int)",
+    "STAGED_STAGE2_MODE": "Staged Stage 2 mode: precomputed, realtime, static_global_graph",
+    "STAGED_CLUSTERING_STRATEGY": "Staged clustering strategy: auto, score, path, dir_rr, noop, ...",
+    "STAGED_CLUSTERING_MIN_SIZE": "Staged clustering min cluster size (int)",
+    "ENABLE_STAGED_RERANK": "Enable staged reranking in Stage 4 (true/false)",
+    "STAGED_REALTIME_LSP_TIMEOUT_S": "Realtime LSP expansion timeout budget (float seconds)",
+    "STAGED_REALTIME_LSP_DEPTH": "Realtime LSP BFS depth (int)",
+    "STAGED_REALTIME_LSP_MAX_NODES": "Realtime LSP max nodes (int)",
+    "STAGED_REALTIME_LSP_MAX_SEEDS": "Realtime LSP max seeds (int)",
+    "STAGED_REALTIME_LSP_MAX_CONCURRENT": "Realtime LSP max concurrent requests (int)",
+    "STAGED_REALTIME_LSP_WARMUP_S": "Realtime LSP warmup wait after didOpen (float seconds)",
+    "STAGED_REALTIME_LSP_RESOLVE_SYMBOLS": "Resolve symbols via documentSymbol in realtime expansion (true/false)",
     # Chunking configuration
     "CHUNK_STRIP_COMMENTS": "Strip comments from code chunks for embedding: true/false (default: true)",
     "CHUNK_STRIP_DOCSTRINGS": "Strip docstrings from code chunks for embedding: true/false (default: true)",
@@ -104,8 +120,12 @@ def load_env_file(env_path: Path) -> Dict[str, str]:
             if result:
                 key, value = result
                 env_vars[key] = value
-    except Exception as exc:
+    except (OSError, UnicodeDecodeError) as exc:
+        # File access errors or encoding issues are expected and logged
         log.warning("Failed to load .env file %s: %s", env_path, exc)
+    except Exception as exc:
+        # Other unexpected errors are also logged but indicate a code issue
+        log.warning("Unexpected error loading .env file %s: %s", env_path, exc)
     
     return env_vars
 

package/codex-lens/src/codexlens/lsp/keepalive_bridge.py

@@ -0,0 +1,135 @@
+"""Keep-alive wrapper for Standalone LSP servers in synchronous workflows.
+
+The staged realtime pipeline calls into LSP from synchronous code paths.
+Creating a fresh asyncio loop per query (via asyncio.run) forces language
+servers to start/stop every time, which is slow and can trigger shutdown
+timeouts on Windows.
+
+This module runs an asyncio event loop in a background thread and keeps a
+single LspBridge (and its StandaloneLspManager + subprocesses) alive across
+multiple queries. Callers submit coroutines that operate on the shared bridge.
+"""
+
+from __future__ import annotations
+
+import atexit
+import asyncio
+import threading
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Optional, TypeVar
+
+from codexlens.lsp.lsp_bridge import LspBridge
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class KeepAliveKey:
+    workspace_root: str
+    config_file: Optional[str]
+    timeout: float
+
+
+class KeepAliveLspBridge:
+    """Runs a shared LspBridge on a dedicated event loop thread."""
+
+    def __init__(self, *, workspace_root: str, config_file: Optional[str], timeout: float) -> None:
+        self._key = KeepAliveKey(workspace_root=workspace_root, config_file=config_file, timeout=float(timeout))
+        self._lock = threading.RLock()
+        self._call_lock = threading.RLock()
+        self._ready = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._bridge: Optional[LspBridge] = None
+        self._stopped = False
+
+        atexit.register(self.stop)
+
+    @property
+    def key(self) -> KeepAliveKey:
+        return self._key
+
+    def start(self) -> None:
+        with self._lock:
+            if self._stopped:
+                raise RuntimeError("KeepAliveLspBridge is stopped")
+            if self._thread is not None and self._thread.is_alive():
+                return
+
+            self._ready.clear()
+            thread = threading.Thread(target=self._run, name="codexlens-lsp-keepalive", daemon=True)
+            self._thread = thread
+            thread.start()
+
+        if not self._ready.wait(timeout=10.0):
+            raise RuntimeError("Timed out starting LSP keep-alive loop")
+
+    def stop(self) -> None:
+        with self._lock:
+            if self._stopped:
+                return
+            self._stopped = True
+            loop = self._loop
+            bridge = self._bridge
+            thread = self._thread
+
+        if loop is not None and bridge is not None:
+            try:
+                fut = asyncio.run_coroutine_threadsafe(bridge.close(), loop)
+                fut.result(timeout=5.0)
+            except Exception:
+                pass
+            try:
+                loop.call_soon_threadsafe(loop.stop)
+            except Exception:
+                pass
+
+        if thread is not None:
+            try:
+                thread.join(timeout=5.0)
+            except Exception:
+                pass
+
+    def run(self, fn: Callable[[LspBridge], Awaitable[T]], *, timeout: Optional[float] = None) -> T:
+        """Run an async function against the shared LspBridge and return its result."""
+        self.start()
+        loop = self._loop
+        bridge = self._bridge
+        if loop is None or bridge is None:
+            raise RuntimeError("Keep-alive loop not initialized")
+
+        async def _call() -> T:
+            return await fn(bridge)
+
+        # Serialize bridge usage to avoid overlapping LSP request storms.
+        with self._call_lock:
+            fut = asyncio.run_coroutine_threadsafe(_call(), loop)
+            return fut.result(timeout=float(timeout or self._key.timeout) + 1.0)
+
+    def _run(self) -> None:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        bridge = LspBridge(
+            workspace_root=self._key.workspace_root,
+            config_file=self._key.config_file,
+            timeout=self._key.timeout,
+        )
+
+        with self._lock:
+            self._loop = loop
+            self._bridge = bridge
+            self._ready.set()
+
+        try:
+            loop.run_forever()
+        finally:
+            try:
+                if self._bridge is not None:
+                    loop.run_until_complete(self._bridge.close())
+            except Exception:
+                pass
+            try:
+                loop.close()
+            except Exception:
+                pass
+

package/codex-lens/src/codexlens/lsp/lsp_bridge.py

@@ -14,12 +14,16 @@ Features:
 from __future__ import annotations
 
 import asyncio
+import logging
 import os
 import time
 from collections import OrderedDict
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from urllib.parse import unquote
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from codexlens.lsp.standalone_manager import StandaloneLspManager
@@ -62,12 +66,14 @@ class Location:
         """
         # Handle VSCode URI format (file:///path/to/file)
         uri = data.get("uri", data.get("file_path", ""))
-        if uri.startswith("file:///"):
-            # Windows: file:///C:/path -> C:/path
-            # Unix: file:///path -> /path
-            file_path = uri[8:] if uri[8:9].isalpha() and uri[9:10] == ":" else uri[7:]
-        elif uri.startswith("file://"):
-            file_path = uri[7:]
+        if uri.startswith("file://"):
+            # Strip scheme and decode percent-encoding (e.g. file:///d%3A/...).
+            # Keep behavior compatible with both Windows and Unix paths.
+            raw = unquote(uri[7:])  # keep leading slash for Unix paths
+            # Windows: file:///C:/... or file:///c%3A/... -> C:/...
+            if raw.startswith("/") and len(raw) > 2 and raw[2] == ":":
+                raw = raw[1:]
+            file_path = raw
         else:
             file_path = uri
         
@@ -359,6 +365,14 @@ class LspBridge:
                 except (KeyError, TypeError):
                     continue
 
+        logger.debug(
+            "LSP references for %s (%s:%s:%s): %d",
+            symbol.id,
+            symbol.file_path,
+            symbol.range.start_line,
+            symbol.range.start_character,
+            len(locations),
+        )
         self._cache(cache_key, symbol.file_path, locations)
         return locations
     
@@ -503,10 +517,11 @@ class LspBridge:
                         
                         # Parse URI
                         uri = from_item.get("uri", "")
-                        if uri.startswith("file:///"):
-                            fp = uri[8:] if uri[8:9].isalpha() and uri[9:10] == ":" else uri[7:]
-                        elif uri.startswith("file://"):
-                            fp = uri[7:]
+                        if uri.startswith("file://"):
+                            raw = unquote(uri[7:])  # keep leading slash for Unix paths
+                            if raw.startswith("/") and len(raw) > 2 and raw[2] == ":":
+                                raw = raw[1:]
+                            fp = raw
                         else:
                             fp = uri
                         
@@ -539,6 +554,14 @@ class LspBridge:
                         detail="Inferred from reference",
                     ))
         
+        logger.debug(
+            "LSP call hierarchy for %s (%s:%s:%s): %d",
+            symbol.id,
+            symbol.file_path,
+            symbol.range.start_line,
+            symbol.range.start_character,
+            len(items),
+        )
         self._cache(cache_key, symbol.file_path, items)
         return items
     

package/codex-lens/src/codexlens/lsp/lsp_graph_builder.py

@@ -28,6 +28,7 @@ class LspGraphBuilder:
         max_depth: int = 2,
         max_nodes: int = 100,
         max_concurrent: int = 10,
+        resolve_symbols: bool = True,
     ):
         """Initialize GraphBuilder.
 
@@ -35,10 +36,12 @@ class LspGraphBuilder:
             max_depth: Maximum depth for BFS expansion from seeds.
             max_nodes: Maximum number of nodes in the graph.
             max_concurrent: Maximum concurrent LSP requests.
+            resolve_symbols: If False, skip documentSymbol lookups and create lightweight nodes.
         """
         self.max_depth = max_depth
         self.max_nodes = max_nodes
         self.max_concurrent = max_concurrent
+        self.resolve_symbols = resolve_symbols
         # Cache for document symbols per file (avoids per-location hover queries)
         self._document_symbols_cache: Dict[str, List[Dict[str, Any]]] = {}
 
@@ -131,7 +134,10 @@ class LspGraphBuilder:
         # Skip if already visited or at max depth
         if node.id in visited:
             return []
-        if depth > self.max_depth:
+        # Depth is 0 for seeds. To limit expansion to N hops from seeds,
+        # we expand nodes with depth < max_depth.
+        if depth >= self.max_depth:
+            visited.add(node.id)
             return []
         if len(graph.nodes) >= self.max_nodes:
             return []
@@ -276,9 +282,11 @@ class LspGraphBuilder:
             start_line = location.line
 
             # Try to find symbol info from cached document symbols (fast)
-            symbol_info = await self._get_symbol_at_location(
-                file_path, start_line, lsp_bridge
-            )
+            symbol_info = None
+            if self.resolve_symbols:
+                symbol_info = await self._get_symbol_at_location(
+                    file_path, start_line, lsp_bridge
+                )
 
             if symbol_info:
                 name = symbol_info.get("name", f"symbol_L{start_line}")

package/codex-lens/src/codexlens/lsp/standalone_manager.py

@@ -21,6 +21,7 @@ import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import unquote, urlparse
 
 logger = logging.getLogger(__name__)
 
@@ -57,6 +58,10 @@ class ServerState:
     restart_count: int = 0
     # Queue for producer-consumer pattern - continuous reading puts messages here
     message_queue: asyncio.Queue = field(default_factory=asyncio.Queue)
+    # Track opened documents to avoid redundant didOpen spam (and unnecessary delays).
+    # Key: document URI -> (version, file_mtime)
+    opened_documents: Dict[str, Tuple[int, float]] = field(default_factory=dict)
+    opened_documents_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
 
 
 class StandaloneLspManager:
@@ -102,6 +107,7 @@ class StandaloneLspManager:
         self._configs: Dict[str, ServerConfig] = {}  # language_id -> ServerConfig
         self._read_tasks: Dict[str, asyncio.Task] = {}  # language_id -> read task
         self._stderr_tasks: Dict[str, asyncio.Task] = {}  # language_id -> stderr read task
+        self._processor_tasks: Dict[str, asyncio.Task] = {}  # language_id -> message processor task
         self._lock = asyncio.Lock()
         
     def _find_config_file(self) -> Optional[Path]:
@@ -268,7 +274,7 @@ class StandaloneLspManager:
             )
 
             # Start the message processor task to handle queued messages
-            asyncio.create_task(self._process_messages(language_id))
+            self._processor_tasks[language_id] = asyncio.create_task(self._process_messages(language_id))
 
             # Initialize the server - now uses queue for reading responses
             await self._initialize_server(state)
@@ -310,6 +316,15 @@ class StandaloneLspManager:
             except asyncio.CancelledError:
                 pass
 
+        # Cancel message processor task
+        processor_task = self._processor_tasks.pop(language_id, None)
+        if processor_task:
+            processor_task.cancel()
+            try:
+                await processor_task
+            except asyncio.CancelledError:
+                pass
+
         # Send shutdown request
         try:
             await self._send_request(state, "shutdown", None, timeout=5.0)
@@ -341,6 +356,7 @@ class StandaloneLspManager:
         Returns:
             ServerState for the appropriate language server, or None
         """
+        file_path = self._normalize_file_path(file_path)
         language_id = self.get_language_id(file_path)
         if not language_id:
             logger.debug(f"No language server configured for: {file_path}")
@@ -357,6 +373,43 @@ class StandaloneLspManager:
             
             # Start new server
             return await self._start_server(language_id)
+
+    def _normalize_file_path(self, file_path_or_uri: str) -> str:
+        """Normalize a file path that may be an LSP file URI or URI-path.
+
+        LSP responses often contain `file://` URIs with percent-encoding
+        (e.g. `file:///d%3A/...`). Some code paths may forward the parsed
+        URI path (`/d%3A/...`) without the scheme. On Windows, `Path(...)`
+        would interpret that as a root path on the current drive, producing
+        invalid paths like `D:\\d%3A\\...`.
+        """
+        if not file_path_or_uri:
+            return file_path_or_uri
+
+        raw = str(file_path_or_uri).strip()
+
+        if raw.startswith("file:"):
+            try:
+                parsed = urlparse(raw)
+                if parsed.scheme == "file":
+                    raw = unquote(parsed.path)
+                else:
+                    raw = raw.replace("file:///", "").replace("file://", "")
+            except Exception:
+                raw = raw.replace("file:///", "").replace("file://", "")
+
+        # Decode percent-encoded segments (e.g. d%3A -> d:)
+        if "%3a" in raw.lower():
+            try:
+                raw = unquote(raw)
+            except Exception:
+                pass
+
+        # Windows: file URI paths frequently look like "/C:/path"; strip the extra slash.
+        if raw.startswith("/") and len(raw) > 2 and raw[2] == ":":
+            raw = raw[1:]
+
+        return raw
     
     async def _initialize_server(self, state: ServerState) -> None:
         """Send initialize request and wait for response via the message queue.
@@ -771,6 +824,7 @@ class StandaloneLspManager:
     
     def _to_text_document_identifier(self, file_path: str) -> Dict[str, str]:
         """Create TextDocumentIdentifier from file path."""
+        file_path = self._normalize_file_path(file_path)
         uri = Path(file_path).resolve().as_uri()
         return {"uri": uri}
     
@@ -783,30 +837,69 @@ class StandaloneLspManager:
     
     async def _open_document(self, state: ServerState, file_path: str) -> None:
         """Send textDocument/didOpen notification."""
+        file_path = self._normalize_file_path(file_path)
         resolved_path = Path(file_path).resolve()
 
+        # Fast path: already opened and unchanged (per-server cache).
         try:
-            content = resolved_path.read_text(encoding="utf-8")
-        except Exception as e:
-            logger.error(f"Failed to read file {file_path}: {e}")
-            return
+            uri = resolved_path.as_uri()
+        except Exception:
+            uri = ""
 
-        # Detect language ID from extension
-        language_id = self.get_language_id(file_path) or "plaintext"
+        try:
+            file_mtime = float(resolved_path.stat().st_mtime)
+        except Exception:
+            file_mtime = 0.0
 
-        logger.debug(f"Opening document: {resolved_path.name} ({len(content)} chars)")
-        await self._send_notification(state, "textDocument/didOpen", {
-            "textDocument": {
-                "uri": resolved_path.as_uri(),
-                "languageId": language_id,
-                "version": 1,
-                "text": content,
-            }
-        })
+        # Serialize open/change notifications per server to avoid races when
+        # multiple concurrent LSP requests target the same file.
+        async with state.opened_documents_lock:
+            existing = state.opened_documents.get(uri) if uri else None
+            if existing is not None and existing[1] == file_mtime:
+                return
 
-        # Give the language server a brief moment to process the file
-        # The message queue handles any server requests automatically
-        await asyncio.sleep(0.5)
+            try:
+                content = resolved_path.read_text(encoding="utf-8")
+            except Exception as e:
+                logger.error(f"Failed to read file {file_path}: {e}")
+                return
+
+            # Detect language ID from extension
+            language_id = self.get_language_id(file_path) or "plaintext"
+
+            # Send didOpen only once per document; subsequent changes use didChange.
+            if existing is None:
+                version = 1
+                logger.debug(f"Opening document: {resolved_path.name} ({len(content)} chars)")
+                await self._send_notification(
+                    state,
+                    "textDocument/didOpen",
+                    {
+                        "textDocument": {
+                            "uri": uri or resolved_path.as_uri(),
+                            "languageId": language_id,
+                            "version": version,
+                            "text": content,
+                        }
+                    },
+                )
+            else:
+                version = int(existing[0]) + 1
+                logger.debug(f"Updating document: {resolved_path.name} ({len(content)} chars)")
+                await self._send_notification(
+                    state,
+                    "textDocument/didChange",
+                    {
+                        "textDocument": {
+                            "uri": uri or resolved_path.as_uri(),
+                            "version": version,
+                        },
+                        "contentChanges": [{"text": content}],
+                    },
+                )
+
+            if uri:
+                state.opened_documents[uri] = (version, file_mtime)
     
     # ========== Public LSP Methods ==========
     
@@ -1044,7 +1137,7 @@ class StandaloneLspManager:
         """
         # Determine language from item's uri
         uri = item.get("uri", "")
-        file_path = uri.replace("file:///", "").replace("file://", "")
+        file_path = self._normalize_file_path(uri)
         
         state = await self._get_server(file_path)
         if not state:
@@ -1075,7 +1168,7 @@ class StandaloneLspManager:
         """
         # Determine language from item's uri
         uri = item.get("uri", "")
-        file_path = uri.replace("file:///", "").replace("file://", "")
+        file_path = self._normalize_file_path(uri)
 
         state = await self._get_server(file_path)
         if not state:

package/codex-lens/src/codexlens/parsers/__init__.py

@@ -3,6 +3,12 @@
 from __future__ import annotations
 
 from .factory import ParserFactory
-
-__all__ = ["ParserFactory"]
+from .astgrep_binding import AstGrepBinding, is_astgrep_available, get_supported_languages
+
+__all__ = [
+    "ParserFactory",
+    "AstGrepBinding",
+    "is_astgrep_available",
+    "get_supported_languages",
+]