claude-code-workflow 6.3.18 → 6.3.20

package/ccw/dist/tools/codex-lens.js

@@ -15,6 +15,8 @@ import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { getSystemPython } from '../utils/python-utils.js';
+import { EXEC_TIMEOUTS } from '../utils/exec-constants.js';
+import { ensureUvInstalled, isUvAvailable, createCodexLensUvManager, } from '../utils/uv-manager.js';
 // Get directory of this module
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -235,28 +237,65 @@ async function ensureLiteLLMEmbedderReady() {
     if (importStatus.ok) {
         return { success: true };
     }
+    console.log('[CodexLens] Installing ccw-litellm for LiteLLM embedding backend...');
+    // Find local ccw-litellm package path
+    const possiblePaths = [
+        join(process.cwd(), 'ccw-litellm'),
+        join(__dirname, '..', '..', '..', 'ccw-litellm'), // ccw/src/tools -> project root
+        join(homedir(), 'ccw-litellm'),
+    ];
+    let localPath = null;
+    for (const p of possiblePaths) {
+        if (existsSync(join(p, 'pyproject.toml'))) {
+            localPath = p;
+            break;
+        }
+    }
+    // Priority: Use UV if available (faster, better dependency resolution)
+    if (await isUvAvailable()) {
+        console.log('[CodexLens] Using UV for ccw-litellm installation...');
+        try {
+            const uv = createCodexLensUvManager();
+            // Ensure venv exists
+            if (!uv.isVenvValid()) {
+                const venvResult = await uv.createVenv();
+                if (!venvResult.success) {
+                    console.log('[CodexLens] UV venv creation failed, falling back to pip:', venvResult.error);
+                    // Fall through to pip fallback
+                }
+            }
+            if (uv.isVenvValid()) {
+                let uvResult;
+                if (localPath) {
+                    console.log(`[CodexLens] Installing ccw-litellm from local path with UV: ${localPath}`);
+                    uvResult = await uv.installFromProject(localPath);
+                }
+                else {
+                    console.log('[CodexLens] Installing ccw-litellm from PyPI with UV...');
+                    uvResult = await uv.install(['ccw-litellm']);
+                }
+                if (uvResult.success) {
+                    return { success: true };
+                }
+                console.log('[CodexLens] UV install failed, falling back to pip:', uvResult.error);
+            }
+        }
+        catch (uvErr) {
+            console.log('[CodexLens] UV error, falling back to pip:', uvErr.message);
+        }
+    }
+    // Fallback: Use pip for installation
     const pipPath = process.platform === 'win32'
         ? join(CODEXLENS_VENV, 'Scripts', 'pip.exe')
         : join(CODEXLENS_VENV, 'bin', 'pip');
     try {
-        console.log('[CodexLens] Installing ccw-litellm for LiteLLM embedding backend...');
-        const possiblePaths = [
-            join(process.cwd(), 'ccw-litellm'),
-            join(__dirname, '..', '..', '..', 'ccw-litellm'), // ccw/src/tools -> project root
-            join(homedir(), 'ccw-litellm'),
-        ];
-        let installed = false;
-        for (const localPath of possiblePaths) {
-            if (existsSync(join(localPath, 'pyproject.toml'))) {
-                console.log(`[CodexLens] Installing ccw-litellm from local path: ${localPath}`);
-                execSync(`"${pipPath}" install -e "${localPath}"`, { stdio: 'inherit' });
-                installed = true;
-                break;
-            }
+        if (localPath) {
+            console.log(`[CodexLens] Installing ccw-litellm from local path with pip: ${localPath}`);
+            execSync(`"${pipPath}" install -e "${localPath}"`, { stdio: 'inherit', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
         }
-        if (!installed) {
-            console.log('[CodexLens] Installing ccw-litellm from PyPI...');
-            execSync(`"${pipPath}" install ccw-litellm`, { stdio: 'inherit' });
+        else {
+            console.log('[CodexLens] Installing ccw-litellm from PyPI with pip...');
+            execSync(`"${pipPath}" install ccw-litellm`, { stdio: 'inherit', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
         }
         return { success: true };
     }
@@ -264,6 +303,14 @@ async function ensureLiteLLMEmbedderReady() {
         return { success: false, error: `Failed to install ccw-litellm: ${err.message}` };
     }
 }
+/**
+ * Mapping from GPU mode to codexlens extras for UV installation
+ */
+const GPU_MODE_EXTRAS = {
+    cpu: ['semantic'],
+    cuda: ['semantic-gpu'],
+    directml: ['semantic-directml'],
+};
 /**
  * Check Python environment in venv for DirectML compatibility
  * DirectML requires: 64-bit Python, version 3.8-3.12
@@ -277,7 +324,8 @@ async function checkPythonEnvForDirectML() {
     }
     try {
         // Get Python version and architecture in one call
-        const checkScript = `import sys, struct; print(f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}|{struct.calcsize('P') * 8}")`;
+        // Use % formatting instead of f-string to avoid Windows shell escaping issues with curly braces
+        const checkScript = `import sys, struct; print('%d.%d.%d|%d' % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro, struct.calcsize('P') * 8))`;
         const result = execSync(`"${pythonPath}" -c "${checkScript}"`, { encoding: 'utf-8', timeout: 10000 }).trim();
         const [version, archStr] = result.split('|');
         const architecture = parseInt(archStr, 10);
@@ -310,12 +358,12 @@ async function detectGpuSupport() {
     // Check for NVIDIA GPU (CUDA)
     try {
         if (process.platform === 'win32') {
-            execSync('nvidia-smi', { stdio: 'pipe' });
+            execSync('nvidia-smi', { stdio: 'pipe', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
             available.push('cuda');
             detectedInfo = 'NVIDIA GPU detected (CUDA available)';
         }
         else {
-            execSync('which nvidia-smi', { stdio: 'pipe' });
+            execSync('which nvidia-smi', { stdio: 'pipe', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
             available.push('cuda');
             detectedInfo = 'NVIDIA GPU detected (CUDA available)';
         }
@@ -351,12 +399,146 @@ async function detectGpuSupport() {
     }
     return { mode: recommendedMode, available, info: detectedInfo, pythonEnv };
 }
+/**
+ * Bootstrap CodexLens venv using UV (fast package manager)
+ * @param gpuMode - GPU acceleration mode for semantic search
+ * @returns Bootstrap result
+ */
+async function bootstrapWithUv(gpuMode = 'cpu') {
+    console.log('[CodexLens] Bootstrapping with UV package manager...');
+    // Ensure UV is installed
+    const uvInstalled = await ensureUvInstalled();
+    if (!uvInstalled) {
+        return { success: false, error: 'Failed to install UV package manager' };
+    }
+    // Create UV manager for CodexLens
+    const uv = createCodexLensUvManager();
+    // Create venv if not exists
+    if (!uv.isVenvValid()) {
+        console.log('[CodexLens] Creating virtual environment with UV...');
+        const createResult = await uv.createVenv();
+        if (!createResult.success) {
+            return { success: false, error: `Failed to create venv: ${createResult.error}` };
+        }
+    }
+    // Find local codex-lens package
+    const possiblePaths = [
+        join(process.cwd(), 'codex-lens'),
+        join(__dirname, '..', '..', '..', 'codex-lens'), // ccw/src/tools -> project root
+        join(homedir(), 'codex-lens'),
+    ];
+    let codexLensPath = null;
+    for (const localPath of possiblePaths) {
+        if (existsSync(join(localPath, 'pyproject.toml'))) {
+            codexLensPath = localPath;
+            break;
+        }
+    }
+    // Determine extras based on GPU mode
+    const extras = GPU_MODE_EXTRAS[gpuMode];
+    if (codexLensPath) {
+        console.log(`[CodexLens] Installing from local path with UV: ${codexLensPath}`);
+        console.log(`[CodexLens] Extras: ${extras.join(', ')}`);
+        const installResult = await uv.installFromProject(codexLensPath, extras);
+        if (!installResult.success) {
+            return { success: false, error: `Failed to install codexlens: ${installResult.error}` };
+        }
+    }
+    else {
+        // Install from PyPI with extras
+        console.log('[CodexLens] Installing from PyPI with UV...');
+        const packageSpec = `codexlens[${extras.join(',')}]`;
+        const installResult = await uv.install([packageSpec]);
+        if (!installResult.success) {
+            return { success: false, error: `Failed to install codexlens: ${installResult.error}` };
+        }
+    }
+    // Clear cache after successful installation
+    clearVenvStatusCache();
+    console.log(`[CodexLens] Bootstrap with UV complete (${gpuMode} mode)`);
+    return { success: true, message: `Installed with UV (${gpuMode} mode)` };
+}
+/**
+ * Install semantic search dependencies using UV (fast package manager)
+ * UV automatically handles ONNX Runtime conflicts
+ * @param gpuMode - GPU acceleration mode: 'cpu', 'cuda', or 'directml'
+ * @returns Bootstrap result
+ */
+async function installSemanticWithUv(gpuMode = 'cpu') {
+    console.log('[CodexLens] Installing semantic dependencies with UV...');
+    // First check if CodexLens is installed
+    const venvStatus = await checkVenvStatus();
+    if (!venvStatus.ready) {
+        return { success: false, error: 'CodexLens not installed. Install CodexLens first.' };
+    }
+    // Check Python environment compatibility for DirectML
+    if (gpuMode === 'directml') {
+        const pythonEnv = await checkPythonEnvForDirectML();
+        if (!pythonEnv.compatible) {
+            const errorDetails = pythonEnv.error || 'Unknown compatibility issue';
+            return {
+                success: false,
+                error: `DirectML installation failed: ${errorDetails}\n\nTo fix this:\n1. Uninstall current Python\n2. Install 64-bit Python 3.10, 3.11, or 3.12 from python.org\n3. Delete ~/.codexlens/venv folder\n4. Reinstall CodexLens`,
+            };
+        }
+        console.log(`[CodexLens] Python ${pythonEnv.version} (${pythonEnv.architecture}-bit) - DirectML compatible`);
+    }
+    // Create UV manager
+    const uv = createCodexLensUvManager();
+    // Find local codex-lens package
+    const possiblePaths = [
+        join(process.cwd(), 'codex-lens'),
+        join(__dirname, '..', '..', '..', 'codex-lens'),
+        join(homedir(), 'codex-lens'),
+    ];
+    let codexLensPath = null;
+    for (const localPath of possiblePaths) {
+        if (existsSync(join(localPath, 'pyproject.toml'))) {
+            codexLensPath = localPath;
+            break;
+        }
+    }
+    // Determine extras based on GPU mode
+    const extras = GPU_MODE_EXTRAS[gpuMode];
+    const modeDescription = gpuMode === 'cuda'
+        ? 'NVIDIA CUDA GPU acceleration'
+        : gpuMode === 'directml'
+            ? 'Windows DirectML GPU acceleration'
+            : 'CPU (ONNX Runtime)';
+    console.log(`[CodexLens] Mode: ${modeDescription}`);
+    console.log(`[CodexLens] Extras: ${extras.join(', ')}`);
+    // Install with extras - UV handles dependency conflicts automatically
+    if (codexLensPath) {
+        console.log(`[CodexLens] Reinstalling from local path with semantic extras...`);
+        const installResult = await uv.installFromProject(codexLensPath, extras);
+        if (!installResult.success) {
+            return { success: false, error: `Installation failed: ${installResult.error}` };
+        }
+    }
+    else {
+        // Install from PyPI
+        const packageSpec = `codexlens[${extras.join(',')}]`;
+        console.log(`[CodexLens] Installing ${packageSpec} from PyPI...`);
+        const installResult = await uv.install([packageSpec]);
+        if (!installResult.success) {
+            return { success: false, error: `Installation failed: ${installResult.error}` };
+        }
+    }
+    console.log(`[CodexLens] Semantic dependencies installed successfully (${gpuMode} mode)`);
+    return { success: true, message: `Installed with ${modeDescription}` };
+}
 /**
  * Install semantic search dependencies with optional GPU acceleration
  * @param gpuMode - GPU acceleration mode: 'cpu', 'cuda', or 'directml'
  * @returns Bootstrap result
  */
 async function installSemantic(gpuMode = 'cpu') {
+    // Prefer UV if available
+    if (await isUvAvailable()) {
+        console.log('[CodexLens] Using UV for semantic installation...');
+        return installSemanticWithUv(gpuMode);
+    }
+    // Fall back to pip logic...
     // First ensure CodexLens is installed
     const venvStatus = await checkVenvStatus();
     if (!venvStatus.ready) {
@@ -383,7 +565,7 @@ async function installSemantic(gpuMode = 'cpu') {
     console.log(`[CodexLens] Cleaning up existing ONNX Runtime packages...`);
     for (const pkg of onnxVariants) {
         try {
-            execSync(`"${pipPath}" uninstall ${pkg} -y`, { stdio: 'pipe' });
+            execSync(`"${pipPath}" uninstall ${pkg} -y`, { stdio: 'pipe', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
             console.log(`[CodexLens] Removed ${pkg}`);
         }
         catch {
@@ -454,7 +636,7 @@ async function installSemantic(gpuMode = 'cpu') {
                     if (gpuMode !== 'cpu') {
                         try {
                             console.log(`[CodexLens] Reinstalling ${onnxPackage} to ensure GPU provider works...`);
-                            execSync(`"${pipPath}" install --force-reinstall ${onnxPackage}`, { stdio: 'pipe', timeout: 300000 });
+                            execSync(`"${pipPath}" install --force-reinstall ${onnxPackage}`, { stdio: 'pipe', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
                             console.log(`[CodexLens] ${onnxPackage} reinstalled successfully`);
                         }
                         catch (e) {
@@ -482,6 +664,12 @@ async function installSemantic(gpuMode = 'cpu') {
  * @returns Bootstrap result
  */
 async function bootstrapVenv() {
+    // Prefer UV if available (faster package resolution and installation)
+    if (await isUvAvailable()) {
+        console.log('[CodexLens] Using UV for bootstrap...');
+        return bootstrapWithUv();
+    }
+    // Fall back to pip logic...
     // Ensure data directory exists
     if (!existsSync(CODEXLENS_DATA_DIR)) {
         mkdirSync(CODEXLENS_DATA_DIR, { recursive: true });
@@ -491,7 +679,7 @@ async function bootstrapVenv() {
         try {
             console.log('[CodexLens] Creating virtual environment...');
             const pythonCmd = getSystemPython();
-            execSync(`${pythonCmd} -m venv "${CODEXLENS_VENV}"`, { stdio: 'inherit' });
+            execSync(`${pythonCmd} -m venv "${CODEXLENS_VENV}"`, { stdio: 'inherit', timeout: EXEC_TIMEOUTS.PROCESS_SPAWN });
         }
         catch (err) {
             return { success: false, error: `Failed to create venv: ${err.message}` };
@@ -513,14 +701,14 @@ async function bootstrapVenv() {
         for (const localPath of possiblePaths) {
             if (existsSync(join(localPath, 'pyproject.toml'))) {
                 console.log(`[CodexLens] Installing from local path: ${localPath}`);
-                execSync(`"${pipPath}" install -e "${localPath}"`, { stdio: 'inherit' });
+                execSync(`"${pipPath}" install -e "${localPath}"`, { stdio: 'inherit', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
                 installed = true;
                 break;
             }
         }
         if (!installed) {
             console.log('[CodexLens] Installing from PyPI...');
-            execSync(`"${pipPath}" install codexlens`, { stdio: 'inherit' });
+            execSync(`"${pipPath}" install codexlens`, { stdio: 'inherit', timeout: EXEC_TIMEOUTS.PACKAGE_INSTALL });
         }
         // Clear cache after successful installation
         clearVenvStatusCache();
@@ -652,30 +840,16 @@ async function executeCodexLens(args, options = {}) {
         return { success: false, error: readyStatus.error };
     }
     return new Promise((resolve) => {
-        // Build command string - quote paths for shell execution
-        const quotedPython = `"${VENV_PYTHON}"`;
-        const cmdArgs = args.map(arg => {
-            // Quote arguments that contain spaces or special characters
-            if (arg.includes(' ') || arg.includes('\\')) {
-                return `"${arg}"`;
-            }
-            return arg;
-        });
-        // Build full command - on Windows, prepend cd to handle different drives
-        let fullCmd;
-        if (process.platform === 'win32' && cwd) {
-            // Use cd /d to change drive and directory, then run command
-            fullCmd = `cd /d "${cwd}" && ${quotedPython} -m codexlens ${cmdArgs.join(' ')}`;
-        }
-        else {
-            fullCmd = `${quotedPython} -m codexlens ${cmdArgs.join(' ')}`;
-        }
-        // Use spawn with shell for real-time progress updates
-        // spawn streams output in real-time, unlike exec which buffers until completion
-        const child = spawn(fullCmd, [], {
-            cwd: process.platform === 'win32' ? undefined : cwd,
-            shell: process.platform === 'win32' ? process.env.ComSpec || true : true,
+        // SECURITY: Use spawn without shell to prevent command injection
+        // Pass arguments directly - no manual quoting needed
+        // spawn's cwd option handles drive changes correctly on Windows
+        const spawnArgs = ['-m', 'codexlens', ...args];
+        const child = spawn(VENV_PYTHON, spawnArgs, {
+            cwd,
+            shell: false, // CRITICAL: Prevent command injection
             timeout,
+            // Ensure proper encoding on Windows
+            env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
         });
         // Track indexing process for cancellation (only for init commands)
         const isIndexingCommand = args.includes('init');
@@ -784,9 +958,10 @@ async function executeCodexLens(args, options = {}) {
  */
 async function initIndex(params) {
     const { path = '.', languages } = params;
-    const args = ['init', path];
+    // Use 'index init' subcommand (new CLI structure)
+    const args = ['index', 'init', path];
     if (languages && languages.length > 0) {
-        args.push('--languages', languages.join(','));
+        args.push('--language', languages.join(','));
     }
     return executeCodexLens(args, { cwd: path });
 }
@@ -1149,10 +1324,55 @@ async function uninstallCodexLens() {
             return { success: false, error: 'CodexLens not installed (venv not found)' };
         }
         console.log('[CodexLens] Uninstalling CodexLens...');
+        // On Windows, kill any Python processes that might be holding locks on .db files
+        if (process.platform === 'win32') {
+            console.log('[CodexLens] Killing any CodexLens Python processes...');
+            const { execSync } = await import('child_process');
+            try {
+                // Kill any python processes from our venv that might be holding file locks
+                execSync(`taskkill /F /IM python.exe /FI "MODULES eq sqlite3" 2>nul`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
+            }
+            catch {
+                // Ignore errors - no processes to kill
+            }
+            // Small delay to allow file handles to be released
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
         console.log(`[CodexLens] Removing directory: ${CODEXLENS_DATA_DIR}`);
-        // Remove the entire .codexlens directory
+        // Remove the entire .codexlens directory with retry logic for locked files
         const fs = await import('fs');
-        fs.rmSync(CODEXLENS_DATA_DIR, { recursive: true, force: true });
+        const path = await import('path');
+        // Helper function to remove directory with retries (Windows EBUSY workaround)
+        const removeWithRetry = async (dirPath, maxRetries = 3, delay = 1000) => {
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 500 });
+                    return;
+                }
+                catch (err) {
+                    if (err.code === 'EBUSY' || err.code === 'EPERM' || err.code === 'ENOTEMPTY') {
+                        console.log(`[CodexLens] Retry ${attempt}/${maxRetries} - file locked, waiting...`);
+                        if (attempt < maxRetries) {
+                            // On Windows, try to forcefully release file handles
+                            if (process.platform === 'win32' && err.path) {
+                                try {
+                                    const { execSync } = await import('child_process');
+                                    // Try to close handles on the specific file
+                                    execSync(`handle -c ${err.path} -y 2>nul`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
+                                }
+                                catch {
+                                    // handle.exe may not be installed, ignore
+                                }
+                            }
+                            await new Promise(resolve => setTimeout(resolve, delay));
+                            continue;
+                        }
+                    }
+                    throw err;
+                }
+            }
+        };
+        await removeWithRetry(CODEXLENS_DATA_DIR);
         // Reset bootstrap cache
         bootstrapChecked = false;
         bootstrapReady = false;
@@ -1161,7 +1381,15 @@ async function uninstallCodexLens() {
         return { success: true, message: 'CodexLens uninstalled successfully' };
     }
     catch (err) {
-        return { success: false, error: `Failed to uninstall CodexLens: ${err.message}` };
+        const errorMsg = err.message;
+        // Provide helpful message for Windows users with locked files
+        if (errorMsg.includes('EBUSY') || errorMsg.includes('resource busy')) {
+            return {
+                success: false,
+                error: `Failed to uninstall CodexLens: Files are locked. Please close any applications using CodexLens indexes (e.g., Claude Code, VS Code) and try again. Details: ${errorMsg}`
+            };
+        }
+        return { success: false, error: `Failed to uninstall CodexLens: ${errorMsg}` };
     }
 }
 /**
@@ -1182,7 +1410,7 @@ function cancelIndexing() {
             // On Windows, use taskkill to kill the process tree
             const { execSync } = require('child_process');
             try {
-                execSync(`taskkill /pid ${currentIndexingProcess.pid} /T /F`, { stdio: 'ignore' });
+                execSync(`taskkill /pid ${currentIndexingProcess.pid} /T /F`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
             }
             catch {
                 // Process may have already exited
@@ -1213,7 +1441,13 @@ function isIndexingInProgress() {
     return currentIndexingProcess !== null && !currentIndexingAborted;
 }
 // Export for direct usage
-export { ensureReady, executeCodexLens, checkVenvStatus, bootstrapVenv, checkSemanticStatus, ensureLiteLLMEmbedderReady, installSemantic, detectGpuSupport, uninstallCodexLens, cancelIndexing, isIndexingInProgress, };
+export { ensureReady, executeCodexLens, checkVenvStatus, bootstrapVenv, checkSemanticStatus, ensureLiteLLMEmbedderReady, installSemantic, detectGpuSupport, uninstallCodexLens, cancelIndexing, isIndexingInProgress, 
+// UV-based installation functions
+bootstrapWithUv, installSemanticWithUv, };
+// Export Python path for direct spawn usage (e.g., watcher)
+export function getVenvPythonPath() {
+    return VENV_PYTHON;
+}
 // Backward-compatible export for tests
 export const codexLensTool = {
     name: schema.name,