claude-code-workflow 6.3.18 → 6.3.20

package/ccw/src/tools/codex-lens.ts

@@ -17,6 +17,13 @@ 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 {
+  UvManager,
+  ensureUvInstalled,
+  isUvAvailable,
+  createCodexLensUvManager,
+} from '../utils/uv-manager.js';
 
 // Get directory of this module
 const __filename = fileURLToPath(import.meta.url);
@@ -322,33 +329,71 @@ async function ensureLiteLLMEmbedderReady(): Promise<BootstrapResult> {
     return { success: true };
   }
 
-  const pipPath =
-    process.platform === 'win32'
-      ? join(CODEXLENS_VENV, 'Scripts', 'pip.exe')
-      : join(CODEXLENS_VENV, 'bin', 'pip');
+  console.log('[CodexLens] Installing ccw-litellm for LiteLLM embedding backend...');
 
-  try {
-    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'),
+  ];
 
-    const possiblePaths = [
-      join(process.cwd(), 'ccw-litellm'),
-      join(__dirname, '..', '..', '..', 'ccw-litellm'), // ccw/src/tools -> project root
-      join(homedir(), 'ccw-litellm'),
-    ];
+  let localPath: string | null = null;
+  for (const p of possiblePaths) {
+    if (existsSync(join(p, 'pyproject.toml'))) {
+      localPath = p;
+      break;
+    }
+  }
 
-    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;
+  // 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 as Error).message);
     }
+  }
 
-    if (!installed) {
-      console.log('[CodexLens] Installing ccw-litellm from PyPI...');
-      execSync(`"${pipPath}" install ccw-litellm`, { stdio: 'inherit' });
+  // Fallback: Use pip for installation
+  const pipPath =
+    process.platform === 'win32'
+      ? join(CODEXLENS_VENV, 'Scripts', 'pip.exe')
+      : join(CODEXLENS_VENV, 'bin', 'pip');
+
+  try {
+    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 });
+    } 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 };
@@ -362,6 +407,15 @@ async function ensureLiteLLMEmbedderReady(): Promise<BootstrapResult> {
  */
 type GpuMode = 'cpu' | 'cuda' | 'directml';
 
+/**
+ * Mapping from GPU mode to codexlens extras for UV installation
+ */
+const GPU_MODE_EXTRAS: Record<GpuMode, string[]> = {
+  cpu: ['semantic'],
+  cuda: ['semantic-gpu'],
+  directml: ['semantic-directml'],
+};
+
 /**
  * Python environment info for compatibility checks
  */
@@ -389,7 +443,8 @@ async function checkPythonEnvForDirectML(): Promise<PythonEnvInfo> {
 
   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);
@@ -425,11 +480,11 @@ async function detectGpuSupport(): Promise<{ mode: GpuMode; available: GpuMode[]
   // 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)';
     }
@@ -465,12 +520,165 @@ async function detectGpuSupport(): Promise<{ mode: GpuMode; available: GpuMode[]
   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: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  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: string | null = 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: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  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: string | null = 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: GpuMode = 'cpu'): Promise<BootstrapResult> {
+  // 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) {
@@ -502,7 +710,7 @@ async function installSemantic(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResul
 
   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 {
       // Package not installed, ignore
@@ -586,7 +794,7 @@ async function installSemantic(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResul
           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) {
               console.warn(`[CodexLens] Warning: Failed to reinstall ${onnxPackage}: ${(e as Error).message}`);
@@ -615,6 +823,13 @@ async function installSemantic(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResul
  * @returns Bootstrap result
  */
 async function bootstrapVenv(): Promise<BootstrapResult> {
+  // 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 });
@@ -625,7 +840,7 @@ async function bootstrapVenv(): Promise<BootstrapResult> {
     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 as Error).message}` };
     }
@@ -650,7 +865,7 @@ async function bootstrapVenv(): Promise<BootstrapResult> {
     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;
       }
@@ -658,7 +873,7 @@ async function bootstrapVenv(): Promise<BootstrapResult> {
 
     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
@@ -807,31 +1022,17 @@ async function executeCodexLens(args: string[], options: ExecuteOptions = {}): P
   }
 
   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: string;
-    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)
@@ -953,9 +1154,10 @@ async function executeCodexLens(args: string[], options: ExecuteOptions = {}): P
 async function initIndex(params: Params): Promise<ExecuteResult> {
   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 });
@@ -1373,11 +1575,57 @@ async function uninstallCodexLens(): Promise<BootstrapResult> {
     }
 
     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: string, maxRetries = 3, delay = 1000): Promise<void> => {
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          fs.rmSync(dirPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 500 });
+          return;
+        } catch (err: any) {
+          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;
@@ -1387,7 +1635,15 @@ async function uninstallCodexLens(): Promise<BootstrapResult> {
     console.log('[CodexLens] CodexLens uninstalled successfully');
     return { success: true, message: 'CodexLens uninstalled successfully' };
   } catch (err) {
-    return { success: false, error: `Failed to uninstall CodexLens: ${(err as Error).message}` };
+    const errorMsg = (err as Error).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}` };
   }
 }
 
@@ -1412,7 +1668,7 @@ function cancelIndexing(): { success: boolean; message?: string; error?: string
       // 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
       }
@@ -1459,7 +1715,16 @@ export {
   uninstallCodexLens,
   cancelIndexing,
   isIndexingInProgress,
+  // UV-based installation functions
+  bootstrapWithUv,
+  installSemanticWithUv,
 };
+
+// Export Python path for direct spawn usage (e.g., watcher)
+export function getVenvPythonPath(): string {
+  return VENV_PYTHON;
+}
+
 export type { GpuMode, PythonEnvInfo };
 
 // Backward-compatible export for tests

package/ccw/src/tools/detect-changed-modules.ts

@@ -8,6 +8,15 @@ import type { ToolSchema, ToolResult } from '../types/tool.js';
 import { readdirSync, statSync, existsSync } from 'fs';
 import { join, resolve, dirname, extname, relative } from 'path';
 import { execSync } from 'child_process';
+import { EXEC_TIMEOUTS } from '../utils/exec-constants.js';
+
+function isExecTimeoutError(error: unknown): boolean {
+  const err = error as { code?: unknown; errno?: unknown; message?: unknown } | null;
+  const code = err?.code ?? err?.errno;
+  if (code === 'ETIMEDOUT') return true;
+  const message = typeof err?.message === 'string' ? err.message : '';
+  return message.includes('ETIMEDOUT');
+}
 
 // Source file extensions to track
 const SOURCE_EXTENSIONS = [
@@ -53,9 +62,12 @@ interface ToolOutput {
  */
 function isGitRepo(basePath: string): boolean {
   try {
-    execSync('git rev-parse --git-dir', { cwd: basePath, stdio: 'pipe' });
+    execSync('git rev-parse --git-dir', { cwd: basePath, stdio: 'pipe', timeout: EXEC_TIMEOUTS.GIT_QUICK });
     return true;
-  } catch (e) {
+  } catch (e: unknown) {
+    if (isExecTimeoutError(e)) {
+      console.warn(`[detect_changed_modules] git rev-parse timed out after ${EXEC_TIMEOUTS.GIT_QUICK}ms`);
+    }
     return false;
   }
 }
@@ -69,13 +81,15 @@ function getGitChangedFiles(basePath: string): string[] {
     let output = execSync('git diff --name-only HEAD 2>/dev/null', {
       cwd: basePath,
       encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: EXEC_TIMEOUTS.GIT_DIFF,
     }).trim();
 
     const cachedOutput = execSync('git diff --name-only --cached 2>/dev/null', {
       cwd: basePath,
       encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: EXEC_TIMEOUTS.GIT_DIFF,
     }).trim();
 
     if (cachedOutput) {
@@ -87,12 +101,16 @@ function getGitChangedFiles(basePath: string): string[] {
       output = execSync('git diff --name-only HEAD~1 HEAD 2>/dev/null', {
         cwd: basePath,
         encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe']
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: EXEC_TIMEOUTS.GIT_DIFF,
       }).trim();
     }
 
     return output ? output.split('\n').filter(f => f.trim()) : [];
-  } catch (e) {
+  } catch (e: unknown) {
+    if (isExecTimeoutError(e)) {
+      console.warn(`[detect_changed_modules] git diff timed out after ${EXEC_TIMEOUTS.GIT_DIFF}ms`);
+    }
     return [];
   }
 }

package/ccw/src/tools/index.ts

@@ -23,6 +23,7 @@ import { executeInitWithProgress } from './smart-search.js';
 import * as readFileMod from './read-file.js';
 import * as coreMemoryMod from './core-memory.js';
 import * as contextCacheMod from './context-cache.js';
+import * as skillContextLoaderMod from './skill-context-loader.js';
 import type { ProgressInfo } from './codex-lens.js';
 
 // Import legacy JS tools
@@ -359,6 +360,7 @@ registerTool(toLegacyTool(smartSearchMod));
 registerTool(toLegacyTool(readFileMod));
 registerTool(toLegacyTool(coreMemoryMod));
 registerTool(toLegacyTool(contextCacheMod));
+registerTool(toLegacyTool(skillContextLoaderMod));
 
 // Register legacy JS tools
 registerTool(uiGeneratePreviewTool);

package/ccw/src/tools/litellm-client.ts

@@ -114,7 +114,8 @@ export class LiteLLMClient {
    */
   async isAvailable(): Promise<boolean> {
     try {
-      await this.executePython(['version'], { timeout: 5000 });
+      // Increased timeout to 15s for Python cold start
+      await this.executePython(['version'], { timeout: 15000 });
       return true;
     } catch {
       return false;
@@ -126,10 +127,14 @@ export class LiteLLMClient {
    */
   async getStatus(): Promise<LiteLLMStatus> {
     try {
-      const output = await this.executePython(['version'], { timeout: 5000 });
+      // Increased timeout to 15s for Python cold start
+      const output = await this.executePython(['version'], { timeout: 15000 });
+      // Parse "ccw-litellm 0.1.0" format
+      const versionMatch = output.trim().match(/ccw-litellm\s+([\d.]+)/);
+      const version = versionMatch ? versionMatch[1] : output.trim();
       return {
         available: true,
-        version: output.trim()
+        version
       };
     } catch (error: any) {
       return {
@@ -143,7 +148,8 @@ export class LiteLLMClient {
    * Get current configuration
    */
   async getConfig(): Promise<any> {
-    const output = await this.executePython(['config', '--json']);
+    // config command outputs JSON by default, no --json flag needed
+    const output = await this.executePython(['config']);
     return JSON.parse(output);
   }