claude-code-workflow 6.2.6 → 6.2.9

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

@@ -396,7 +396,20 @@ class ChainSearchEngine:
         all_results = []
         stats = SearchStats()
 
-        executor = self._get_executor(options.max_workers)
+        # Force single-threaded execution for vector/hybrid search to avoid GPU crashes
+        # DirectML/ONNX have threading issues when multiple threads access GPU resources
+        effective_workers = options.max_workers
+        if options.enable_vector or options.hybrid_mode:
+            effective_workers = 1
+            self.logger.debug("Using single-threaded mode for vector search (GPU safety)")
+            # Pre-load embedder to avoid initialization overhead per-search
+            try:
+                from codexlens.semantic.embedder import get_embedder
+                get_embedder(profile="code", use_gpu=True)
+            except Exception:
+                pass  # Ignore pre-load failures
+
+        executor = self._get_executor(effective_workers)
         # Submit all search tasks
         future_to_path = {
             executor.submit(

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

@@ -274,19 +274,32 @@ class HybridSearchEngine:
                 )
                 return []
 
-            # Auto-detect embedding dimension and select appropriate profile
-            detected_dim = vector_store.dimension
-            if detected_dim is None:
-                self.logger.info("Vector store dimension unknown, using default profile")
-                profile = "code"  # Default fallback
-            elif detected_dim == 384:
-                profile = "fast"
-            elif detected_dim == 768:
-                profile = "code"
-            elif detected_dim == 1024:
-                profile = "multilingual"  # or balanced, both are 1024
+            # Get stored model configuration (preferred) or auto-detect from dimension
+            model_config = vector_store.get_model_config()
+            if model_config:
+                profile = model_config["model_profile"]
+                self.logger.debug(
+                    "Using stored model config: %s (%s, %dd)",
+                    profile, model_config["model_name"], model_config["embedding_dim"]
+                )
             else:
-                profile = "code"  # Default fallback
+                # Fallback: auto-detect from embedding dimension
+                detected_dim = vector_store.dimension
+                if detected_dim is None:
+                    self.logger.info("Vector store dimension unknown, using default profile")
+                    profile = "code"  # Default fallback
+                elif detected_dim == 384:
+                    profile = "fast"
+                elif detected_dim == 768:
+                    profile = "code"
+                elif detected_dim == 1024:
+                    profile = "multilingual"  # or balanced, both are 1024
+                else:
+                    profile = "code"  # Default fallback
+                self.logger.debug(
+                    "No stored model config, auto-detected profile '%s' from dimension %s",
+                    profile, detected_dim
+                )
 
             # Use cached embedder (singleton) for performance
             embedder = get_embedder(profile=profile)

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

@@ -116,6 +116,17 @@ class VectorStore:
                 CREATE INDEX IF NOT EXISTS idx_chunks_file
                 ON semantic_chunks(file_path)
             """)
+            # Model configuration table - tracks which model generated the embeddings
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS embeddings_config (
+                    id INTEGER PRIMARY KEY CHECK (id = 1),
+                    model_profile TEXT NOT NULL,
+                    model_name TEXT NOT NULL,
+                    embedding_dim INTEGER NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
             conn.commit()
 
     def _init_ann_index(self) -> None:
@@ -932,6 +943,92 @@ class VectorStore:
             return self._ann_index.count()
         return 0
 
+    def get_model_config(self) -> Optional[Dict[str, Any]]:
+        """Get the model configuration used for embeddings in this store.
+
+        Returns:
+            Dictionary with model_profile, model_name, embedding_dim, or None if not set.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT model_profile, model_name, embedding_dim, created_at, updated_at "
+                "FROM embeddings_config WHERE id = 1"
+            ).fetchone()
+            if row:
+                return {
+                    "model_profile": row[0],
+                    "model_name": row[1],
+                    "embedding_dim": row[2],
+                    "created_at": row[3],
+                    "updated_at": row[4],
+                }
+        return None
+
+    def set_model_config(
+        self, model_profile: str, model_name: str, embedding_dim: int
+    ) -> None:
+        """Set the model configuration for embeddings in this store.
+
+        This should be called when generating new embeddings. If a different
+        model was previously used, this will update the configuration.
+
+        Args:
+            model_profile: Model profile name (fast, code, minilm, etc.)
+            model_name: Full model name (e.g., jinaai/jina-embeddings-v2-base-code)
+            embedding_dim: Embedding dimension (e.g., 768)
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT INTO embeddings_config (id, model_profile, model_name, embedding_dim)
+                VALUES (1, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                    model_profile = excluded.model_profile,
+                    model_name = excluded.model_name,
+                    embedding_dim = excluded.embedding_dim,
+                    updated_at = CURRENT_TIMESTAMP
+                """,
+                (model_profile, model_name, embedding_dim)
+            )
+            conn.commit()
+
+    def check_model_compatibility(
+        self, model_profile: str, model_name: str, embedding_dim: int
+    ) -> Tuple[bool, Optional[str]]:
+        """Check if the given model is compatible with existing embeddings.
+
+        Args:
+            model_profile: Model profile to check
+            model_name: Model name to check
+            embedding_dim: Embedding dimension to check
+
+        Returns:
+            Tuple of (is_compatible, warning_message).
+            is_compatible is True if no existing config or configs match.
+            warning_message is a user-friendly message if incompatible.
+        """
+        existing = self.get_model_config()
+        if existing is None:
+            return True, None
+
+        # Check dimension first (most critical)
+        if existing["embedding_dim"] != embedding_dim:
+            return False, (
+                f"Dimension mismatch: existing embeddings use {existing['embedding_dim']}d "
+                f"({existing['model_profile']}), but requested model uses {embedding_dim}d "
+                f"({model_profile}). Use --force to regenerate all embeddings."
+            )
+
+        # Check model (different models with same dimension may have different semantic spaces)
+        if existing["model_profile"] != model_profile:
+            return False, (
+                f"Model mismatch: existing embeddings use '{existing['model_profile']}' "
+                f"({existing['model_name']}), but requested '{model_profile}' "
+                f"({model_name}). Use --force to regenerate all embeddings."
+            )
+
+        return True, None
+
     def close(self) -> None:
         """Close the vector store and release resources.
 

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

@@ -14,11 +14,37 @@ Storage Structure:
                     └── _index.db      # src/ directory index
 """
 
+import json
+import os
 import platform
 from pathlib import Path
 from typing import Optional
 
 
+def _get_configured_index_root() -> Path:
+    """Get the index root from environment or config file.
+
+    Priority order:
+    1. CODEXLENS_INDEX_DIR environment variable
+    2. index_dir from ~/.codexlens/config.json
+    3. Default: ~/.codexlens/indexes
+    """
+    env_override = os.getenv("CODEXLENS_INDEX_DIR")
+    if env_override:
+        return Path(env_override).expanduser().resolve()
+
+    config_file = Path.home() / ".codexlens" / "config.json"
+    if config_file.exists():
+        try:
+            cfg = json.loads(config_file.read_text(encoding="utf-8"))
+            if "index_dir" in cfg:
+                return Path(cfg["index_dir"]).expanduser().resolve()
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    return Path.home() / ".codexlens" / "indexes"
+
+
 class PathMapper:
     """Bidirectional mapping tool for source paths ↔ index paths.
 
@@ -31,7 +57,7 @@ class PathMapper:
         index_root: Configured index root directory
     """
 
-    DEFAULT_INDEX_ROOT = Path.home() / ".codexlens" / "indexes"
+    DEFAULT_INDEX_ROOT = _get_configured_index_root()
     INDEX_DB_NAME = "_index.db"
 
     def __init__(self, index_root: Optional[Path] = None):

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "claude-code-workflow",
-  "version": "6.2.6",
+  "version": "6.2.9",
   "description": "JSON-driven multi-agent development framework with intelligent CLI orchestration (Gemini/Qwen/Codex), context-first architecture, and automated workflow execution",
   "type": "module",
   "main": "ccw/src/index.js",
   "bin": {
-    "ccw": "./ccw/bin/ccw.js"
+    "ccw": "./ccw/bin/ccw.js",
+    "ccw-mcp": "./ccw/bin/ccw-mcp.js"
   },
   "scripts": {
+    "build": "tsc -p ccw/tsconfig.json",
     "start": "node ccw/bin/ccw.js",
     "test": "node --test",
-    "prepublishOnly": "echo 'Ready to publish @dyw/claude-code-workflow'"
+    "prepublishOnly": "npm run build && echo 'Ready to publish @dyw/claude-code-workflow'"
   },
   "keywords": [
     "claude",
@@ -45,7 +47,6 @@
     "ccw/bin/",
     "ccw/dist/",
     "ccw/src/",
-    "ccw/package.json",
     ".claude/agents/",
     ".claude/commands/",
     ".claude/output-styles/",
@@ -69,5 +70,12 @@
   "bugs": {
     "url": "https://github.com/catlog22/Claude-Code-Workflow/issues"
   },
-  "homepage": "https://github.com/catlog22/Claude-Code-Workflow#readme"
+  "homepage": "https://github.com/catlog22/Claude-Code-Workflow#readme",
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.0.1",
+    "typescript": "^5.9.3"
+  }
 }

package/ccw/package.json

@@ -1,65 +0,0 @@
-{
-  "name": "claude-code-workflow",
-  "version": "6.2.6",
-  "description": "Claude Code Workflow CLI - Dashboard viewer for workflow sessions and reviews",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "ccw": "./bin/ccw.js",
-    "ccw-mcp": "./bin/ccw-mcp.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx watch src/cli.ts",
-    "test": "node --test tests/*.test.js",
-    "test:codexlens": "node --test tests/codex-lens*.test.js",
-    "test:mcp": "node --test tests/mcp-server.test.js",
-    "lint": "eslint src/"
-  },
-  "keywords": [
-    "claude",
-    "workflow",
-    "cli",
-    "dashboard",
-    "code-review"
-  ],
-  "author": "Claude Code Workflow",
-  "license": "MIT",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
-    "better-sqlite3": "^11.7.0",
-    "boxen": "^7.1.0",
-    "chalk": "^5.3.0",
-    "commander": "^11.0.0",
-    "figlet": "^1.7.0",
-    "glob": "^10.3.0",
-    "gradient-string": "^2.0.2",
-    "inquirer": "^9.2.0",
-    "open": "^9.1.0",
-    "ora": "^7.0.0",
-    "zod": "^4.1.13"
-  },
-  "files": [
-    "bin/",
-    "dist/",
-    "src/",
-    "README.md",
-    "LICENSE"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/claude-code-workflow/ccw"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.12",
-    "@types/gradient-string": "^1.1.6",
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^25.0.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
-  }
-}