claude-code-workflow 6.3.11 → 6.3.13

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -18,6 +19,8 @@ WORKSPACE_DIR_NAME = ".codexlens"
 # Settings file name
 SETTINGS_FILE_NAME = "settings.json"
 
+log = logging.getLogger(__name__)
+
 
 def _default_global_dir() -> Path:
     """Get global CodexLens data directory."""
@@ -200,7 +203,15 @@ class Config:
             # Load embedding settings
             embedding = settings.get("embedding", {})
             if "backend" in embedding:
-                self.embedding_backend = embedding["backend"]
+                backend = embedding["backend"]
+                if backend in {"fastembed", "litellm"}:
+                    self.embedding_backend = backend
+                else:
+                    log.warning(
+                        "Invalid embedding backend in %s: %r (expected 'fastembed' or 'litellm')",
+                        self.settings_path,
+                        backend,
+                    )
             if "model" in embedding:
                 self.embedding_model = embedding["model"]
             if "use_gpu" in embedding:
@@ -224,8 +235,13 @@ class Config:
                 self.llm_timeout_ms = llm["timeout_ms"]
             if "batch_size" in llm:
                 self.llm_batch_size = llm["batch_size"]
-        except Exception:
-            pass  # Silently ignore errors
+        except Exception as exc:
+            log.warning(
+                "Failed to load settings from %s (%s): %s",
+                self.settings_path,
+                type(exc).__name__,
+                exc,
+            )
 
     @classmethod
     def load(cls) -> "Config":

package/codex-lens/src/codexlens/search/ranking.py

@@ -22,12 +22,23 @@ class QueryIntent(str, Enum):
     MIXED = "mixed"
 
 
-def normalize_weights(weights: Dict[str, float]) -> Dict[str, float]:
+def normalize_weights(weights: Dict[str, float | None]) -> Dict[str, float | None]:
     """Normalize weights to sum to 1.0 (best-effort)."""
     total = sum(float(v) for v in weights.values() if v is not None)
-    if not math.isfinite(total) or total <= 0:
-        return {k: float(v) for k, v in weights.items()}
-    return {k: float(v) / total for k, v in weights.items()}
+
+    # NaN total: do not attempt to normalize (division would propagate NaNs).
+    if math.isnan(total):
+        return dict(weights)
+
+    # Infinite total: do not attempt to normalize (division yields 0 or NaN).
+    if not math.isfinite(total):
+        return dict(weights)
+
+    # Zero/negative total: do not attempt to normalize (invalid denominator).
+    if total <= 0:
+        return dict(weights)
+
+    return {k: (float(v) / total if v is not None else None) for k, v in weights.items()}
 
 
 def detect_query_intent(query: str) -> QueryIntent:

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

@@ -16,43 +16,53 @@ import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-from codexlens.entities import SearchResult, SemanticChunk
-from codexlens.errors import StorageError
-
-from . import SEMANTIC_AVAILABLE
-
-if SEMANTIC_AVAILABLE:
-    import numpy as np
-
-# Try to import ANN index (optional hnswlib dependency)
-try:
-    from codexlens.semantic.ann_index import ANNIndex, HNSWLIB_AVAILABLE
+from codexlens.entities import SearchResult, SemanticChunk
+from codexlens.errors import StorageError
+
+try:
+    import numpy as np
+    NUMPY_AVAILABLE = True
+except ImportError:
+    np = None  # type: ignore[assignment]
+    NUMPY_AVAILABLE = False
+
+# Try to import ANN index (optional hnswlib dependency)
+try:
+    from codexlens.semantic.ann_index import ANNIndex, HNSWLIB_AVAILABLE
 except ImportError:
     HNSWLIB_AVAILABLE = False
     ANNIndex = None
 
-
-logger = logging.getLogger(__name__)
-
-
-def _cosine_similarity(a: List[float], b: List[float]) -> float:
-    """Compute cosine similarity between two vectors."""
-    if not SEMANTIC_AVAILABLE:
-        raise ImportError("numpy required for vector operations")
-
-    a_arr = np.array(a)
-    b_arr = np.array(b)
-
-    norm_a = np.linalg.norm(a_arr)
-    norm_b = np.linalg.norm(b_arr)
-
-    if norm_a == 0 or norm_b == 0:
-        return 0.0
-
-    return float(np.dot(a_arr, b_arr) / (norm_a * norm_b))
-
-
-class VectorStore:
+
+logger = logging.getLogger(__name__)
+
+# Epsilon used to guard against floating point precision edge cases (e.g., near-zero norms).
+EPSILON = 1e-10
+
+
+def _cosine_similarity(a: List[float], b: List[float]) -> float:
+    """Compute cosine similarity between two vectors."""
+    if not NUMPY_AVAILABLE:
+        raise ImportError("numpy required for vector operations")
+
+    a_arr = np.array(a)
+    b_arr = np.array(b)
+
+    norm_a = np.linalg.norm(a_arr)
+    norm_b = np.linalg.norm(b_arr)
+
+    # Use epsilon tolerance to avoid division by (near-)zero due to floating point precision.
+    if norm_a < EPSILON or norm_b < EPSILON:
+        return 0.0
+
+    denom = norm_a * norm_b
+    if denom < EPSILON:
+        return 0.0
+
+    return float(np.dot(a_arr, b_arr) / denom)
+
+
+class VectorStore:
     """SQLite-based vector storage with HNSW-accelerated similarity search.
 
     Performance optimizations:
@@ -67,12 +77,12 @@ class VectorStore:
     # Default embedding dimension (used when creating new index)
     DEFAULT_DIM = 768
 
-    def __init__(self, db_path: str | Path) -> None:
-        if not SEMANTIC_AVAILABLE:
-            raise ImportError(
-                "Semantic search dependencies not available. "
-                "Install with: pip install codexlens[semantic]"
-            )
+    def __init__(self, db_path: str | Path) -> None:
+        if not NUMPY_AVAILABLE:
+            raise ImportError(
+                "Semantic search dependencies not available. "
+                "Install with: pip install codexlens[semantic]"
+            )
 
         self.db_path = Path(db_path)
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
@@ -299,14 +309,14 @@ class VectorStore:
             ]
             self._embedding_matrix = np.vstack(embeddings)
 
-            # Pre-compute norms for faster similarity calculation
-            self._embedding_norms = np.linalg.norm(
-                self._embedding_matrix, axis=1, keepdims=True
-            )
-            # Avoid division by zero
-            self._embedding_norms = np.where(
-                self._embedding_norms == 0, 1e-10, self._embedding_norms
-            )
+            # Pre-compute norms for faster similarity calculation
+            self._embedding_norms = np.linalg.norm(
+                self._embedding_matrix, axis=1, keepdims=True
+            )
+            # Avoid division by zero
+            self._embedding_norms = np.where(
+                self._embedding_norms == 0, EPSILON, self._embedding_norms
+            )
 
             return True
 

package/codex-lens/src/codexlens/storage/registry.py

@@ -1,12 +1,13 @@
 """Global project registry for CodexLens - SQLite storage."""
 
-from __future__ import annotations
-
-import sqlite3
-import threading
-import time
-from dataclasses import dataclass
-from pathlib import Path
+from __future__ import annotations
+
+import platform
+import sqlite3
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from codexlens.errors import StorageError
@@ -39,7 +40,7 @@ class DirMapping:
     last_updated: float
 
 
-class RegistryStore:
+class RegistryStore:
     """Global project registry - SQLite storage.
 
     Manages indexed projects and directory-to-index path mappings.
@@ -106,8 +107,8 @@ class RegistryStore:
             conn = self._get_connection()
             self._create_schema(conn)
 
-    def _create_schema(self, conn: sqlite3.Connection) -> None:
-        """Create database schema."""
+    def _create_schema(self, conn: sqlite3.Connection) -> None:
+        """Create database schema."""
         try:
             conn.execute(
                 """
@@ -150,12 +151,23 @@ class RegistryStore:
             )
 
             conn.commit()
-        except sqlite3.DatabaseError as exc:
-            raise StorageError(f"Failed to initialize registry schema: {exc}") from exc
-
-    # === Project Operations ===
-
-    def register_project(self, source_root: Path, index_root: Path) -> ProjectInfo:
+        except sqlite3.DatabaseError as exc:
+            raise StorageError(f"Failed to initialize registry schema: {exc}") from exc
+
+    def _normalize_path_for_comparison(self, path: Path) -> str:
+        """Normalize paths for comparisons and storage.
+
+        Windows paths are treated as case-insensitive, so normalize to lowercase.
+        Unix platforms preserve case sensitivity.
+        """
+        path_str = str(path)
+        if platform.system() == "Windows":
+            return path_str.lower()
+        return path_str
+
+    # === Project Operations ===
+
+    def register_project(self, source_root: Path, index_root: Path) -> ProjectInfo:
         """Register a new project or update existing one.
 
         Args:
@@ -164,12 +176,12 @@ class RegistryStore:
 
         Returns:
             ProjectInfo for the registered project
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_root_str = str(source_root.resolve())
-            index_root_str = str(index_root.resolve())
-            now = time.time()
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_root_str = self._normalize_path_for_comparison(source_root.resolve())
+            index_root_str = str(index_root.resolve())
+            now = time.time()
 
             conn.execute(
                 """
@@ -194,7 +206,7 @@ class RegistryStore:
 
             return self._row_to_project_info(row)
 
-    def unregister_project(self, source_root: Path) -> bool:
+    def unregister_project(self, source_root: Path) -> bool:
         """Remove a project registration (cascades to directory mappings).
 
         Args:
@@ -202,10 +214,10 @@ class RegistryStore:
 
         Returns:
             True if project was removed, False if not found
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_root_str = str(source_root.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_root_str = self._normalize_path_for_comparison(source_root.resolve())
 
             row = conn.execute(
                 "SELECT id FROM projects WHERE source_root=?", (source_root_str,)
@@ -218,7 +230,7 @@ class RegistryStore:
             conn.commit()
             return True
 
-    def get_project(self, source_root: Path) -> Optional[ProjectInfo]:
+    def get_project(self, source_root: Path) -> Optional[ProjectInfo]:
         """Get project information by source root.
 
         Args:
@@ -226,10 +238,10 @@ class RegistryStore:
 
         Returns:
             ProjectInfo if found, None otherwise
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_root_str = str(source_root.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_root_str = self._normalize_path_for_comparison(source_root.resolve())
 
             row = conn.execute(
                 "SELECT * FROM projects WHERE source_root=?", (source_root_str,)
@@ -279,19 +291,19 @@ class RegistryStore:
 
             return [self._row_to_project_info(row) for row in rows]
 
-    def update_project_stats(
-        self, source_root: Path, total_files: int, total_dirs: int
-    ) -> None:
+    def update_project_stats(
+        self, source_root: Path, total_files: int, total_dirs: int
+    ) -> None:
         """Update project statistics.
 
         Args:
             source_root: Source code root directory
             total_files: Total number of indexed files
             total_dirs: Total number of indexed directories
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_root_str = str(source_root.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_root_str = self._normalize_path_for_comparison(source_root.resolve())
 
             conn.execute(
                 """
@@ -303,16 +315,16 @@ class RegistryStore:
             )
             conn.commit()
 
-    def set_project_status(self, source_root: Path, status: str) -> None:
+    def set_project_status(self, source_root: Path, status: str) -> None:
         """Set project status.
 
         Args:
             source_root: Source code root directory
             status: Status string ('active', 'stale', 'removed')
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_root_str = str(source_root.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_root_str = self._normalize_path_for_comparison(source_root.resolve())
 
             conn.execute(
                 "UPDATE projects SET status=? WHERE source_root=?",
@@ -322,7 +334,7 @@ class RegistryStore:
 
     # === Directory Mapping Operations ===
 
-    def register_dir(
+    def register_dir(
         self,
         project_id: int,
         source_path: Path,
@@ -341,12 +353,12 @@ class RegistryStore:
 
         Returns:
             DirMapping for the registered directory
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_str = str(source_path.resolve())
-            index_path_str = str(index_path.resolve())
-            now = time.time()
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_path_str = self._normalize_path_for_comparison(source_path.resolve())
+            index_path_str = str(index_path.resolve())
+            now = time.time()
 
             conn.execute(
                 """
@@ -374,7 +386,7 @@ class RegistryStore:
 
             return self._row_to_dir_mapping(row)
 
-    def unregister_dir(self, source_path: Path) -> bool:
+    def unregister_dir(self, source_path: Path) -> bool:
         """Remove a directory mapping.
 
         Args:
@@ -382,10 +394,10 @@ class RegistryStore:
 
         Returns:
             True if directory was removed, False if not found
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_str = str(source_path.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_path_str = self._normalize_path_for_comparison(source_path.resolve())
 
             row = conn.execute(
                 "SELECT id FROM dir_mapping WHERE source_path=?", (source_path_str,)
@@ -398,7 +410,7 @@ class RegistryStore:
             conn.commit()
             return True
 
-    def find_index_path(self, source_path: Path) -> Optional[Path]:
+    def find_index_path(self, source_path: Path) -> Optional[Path]:
         """Find index path for a source directory (exact match).
 
         Args:
@@ -406,10 +418,10 @@ class RegistryStore:
 
         Returns:
             Index path if found, None otherwise
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_str = str(source_path.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_path_str = self._normalize_path_for_comparison(source_path.resolve())
 
             row = conn.execute(
                 "SELECT index_path FROM dir_mapping WHERE source_path=?",
@@ -418,7 +430,7 @@ class RegistryStore:
 
             return Path(row["index_path"]) if row else None
 
-    def find_nearest_index(self, source_path: Path) -> Optional[DirMapping]:
+    def find_nearest_index(self, source_path: Path) -> Optional[DirMapping]:
         """Find nearest indexed ancestor directory.
 
         Searches for the closest parent directory that has an index.
@@ -437,15 +449,15 @@ class RegistryStore:
             conn = self._get_connection()
             source_path_resolved = source_path.resolve()
 
-            # Build list of all parent paths from deepest to shallowest
-            paths_to_check = []
-            current = source_path_resolved
-            while True:
-                paths_to_check.append(str(current))
-                parent = current.parent
-                if parent == current:  # Reached filesystem root
-                    break
-                current = parent
+            # Build list of all parent paths from deepest to shallowest
+            paths_to_check = []
+            current = source_path_resolved
+            while True:
+                paths_to_check.append(self._normalize_path_for_comparison(current))
+                parent = current.parent
+                if parent == current:  # Reached filesystem root
+                    break
+                current = parent
 
             if not paths_to_check:
                 return None
@@ -462,7 +474,7 @@ class RegistryStore:
             row = conn.execute(query, paths_to_check).fetchone()
             return self._row_to_dir_mapping(row) if row else None
 
-    def find_by_source_path(self, source_path: str) -> Optional[Dict[str, str]]:
+    def find_by_source_path(self, source_path: str) -> Optional[Dict[str, str]]:
         """Find project by source path (exact or nearest match).
 
         Searches for a project whose source_root matches or contains
@@ -473,15 +485,16 @@ class RegistryStore:
 
         Returns:
             Dict with project info including 'index_root', or None if not found
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_resolved = str(Path(source_path).resolve())
-
-            # First try exact match on projects table
-            row = conn.execute(
-                "SELECT * FROM projects WHERE source_root=?", (source_path_resolved,)
-            ).fetchone()
+        """
+        with self._lock:
+            conn = self._get_connection()
+            resolved_path = Path(source_path).resolve()
+            source_path_resolved = self._normalize_path_for_comparison(resolved_path)
+
+            # First try exact match on projects table
+            row = conn.execute(
+                "SELECT * FROM projects WHERE source_root=?", (source_path_resolved,)
+            ).fetchone()
 
             if row:
                 return {
@@ -491,16 +504,16 @@ class RegistryStore:
                     "status": row["status"] or "active",
                 }
 
-            # Try finding project that contains this path
-            # Build list of all parent paths
-            paths_to_check = []
-            current = Path(source_path_resolved)
-            while True:
-                paths_to_check.append(str(current))
-                parent = current.parent
-                if parent == current:
-                    break
-                current = parent
+            # Try finding project that contains this path
+            # Build list of all parent paths
+            paths_to_check = []
+            current = resolved_path
+            while True:
+                paths_to_check.append(self._normalize_path_for_comparison(current))
+                parent = current.parent
+                if parent == current:
+                    break
+                current = parent
 
             if paths_to_check:
                 placeholders = ','.join('?' * len(paths_to_check))
@@ -541,7 +554,7 @@ class RegistryStore:
 
             return [self._row_to_dir_mapping(row) for row in rows]
 
-    def get_subdirs(self, source_path: Path) -> List[DirMapping]:
+    def get_subdirs(self, source_path: Path) -> List[DirMapping]:
         """Get direct subdirectory mappings.
 
         Args:
@@ -549,10 +562,10 @@ class RegistryStore:
 
         Returns:
             List of DirMapping objects for direct children
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_str = str(source_path.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_path_str = self._normalize_path_for_comparison(source_path.resolve())
 
             # First get the parent's depth
             parent_row = conn.execute(
@@ -578,16 +591,16 @@ class RegistryStore:
 
             return [self._row_to_dir_mapping(row) for row in rows]
 
-    def update_dir_stats(self, source_path: Path, files_count: int) -> None:
+    def update_dir_stats(self, source_path: Path, files_count: int) -> None:
         """Update directory statistics.
 
         Args:
             source_path: Source directory path
             files_count: Number of files in directory
-        """
-        with self._lock:
-            conn = self._get_connection()
-            source_path_str = str(source_path.resolve())
+        """
+        with self._lock:
+            conn = self._get_connection()
+            source_path_str = self._normalize_path_for_comparison(source_path.resolve())
 
             conn.execute(
                 """