claude-code-workflow 6.3.24 → 6.3.26

package/ccw/src/tools/cli-executor-core.ts

@@ -6,6 +6,9 @@
 import { z } from 'zod';
 import type { ToolSchema, ToolResult } from '../types/tool.js';
 import { spawn, ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 import { validatePath } from '../utils/path-resolver.js';
 import { escapeWindowsArg } from '../utils/shell-escape.js';
 import { buildCommand, checkToolAvailability, clearToolCache, debugLog, errorLog, type NativeResumeConfig, type ToolAvailability } from './cli-executor-utils.js';
@@ -82,7 +85,73 @@ import { findEndpointById } from '../config/litellm-api-config-manager.js';
 
 // CLI Settings (CLI封装) integration
 import { loadEndpointSettings, getSettingsFilePath, findEndpoint } from '../config/cli-settings-manager.js';
-import { loadClaudeCliTools } from './claude-cli-tools.js';
+import { loadClaudeCliTools, getToolConfig } from './claude-cli-tools.js';
+
+/**
+ * Parse .env file content into key-value pairs
+ * Supports: KEY=value, KEY="value", KEY='value', comments (#), empty lines
+ */
+function parseEnvFile(content: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  const lines = content.split(/\r?\n/);
+
+  for (const line of lines) {
+    // Skip empty lines and comments
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Find first = sign
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) continue;
+
+    const key = trimmed.substring(0, eqIndex).trim();
+    let value = trimmed.substring(eqIndex + 1).trim();
+
+    // Remove surrounding quotes if present
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    if (key) {
+      env[key] = value;
+    }
+  }
+
+  return env;
+}
+
+/**
+ * Load environment variables from .env file
+ * Supports ~ for home directory expansion
+ */
+function loadEnvFile(envFilePath: string): Record<string, string> {
+  try {
+    // Expand ~ to home directory
+    let resolvedPath = envFilePath;
+    if (resolvedPath.startsWith('~')) {
+      resolvedPath = path.join(os.homedir(), resolvedPath.slice(1));
+    }
+
+    // Resolve relative paths
+    if (!path.isAbsolute(resolvedPath)) {
+      resolvedPath = path.resolve(resolvedPath);
+    }
+
+    if (!fs.existsSync(resolvedPath)) {
+      debugLog('ENV_FILE', `Env file not found: ${resolvedPath}`);
+      return {};
+    }
+
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
+    const envVars = parseEnvFile(content);
+    debugLog('ENV_FILE', `Loaded ${Object.keys(envVars).length} env vars from ${resolvedPath}`);
+    return envVars;
+  } catch (err) {
+    errorLog('ENV_FILE', `Failed to load env file: ${envFilePath}`, err as Error);
+    return {};
+  }
+}
 
 /**
  * Execute Claude CLI with custom settings file (CLI封装)
@@ -746,6 +815,19 @@ async function executeCliTool(
     const commandToSpawn = isWindows ? escapeWindowsArg(command) : command;
     const argsToSpawn = isWindows ? args.map(escapeWindowsArg) : args;
 
+    // Load custom environment variables from envFile if configured (for gemini/qwen)
+    const toolConfig = getToolConfig(workingDir, tool);
+    let customEnv: Record<string, string> = {};
+    if (toolConfig.envFile) {
+      customEnv = loadEnvFile(toolConfig.envFile);
+    }
+
+    // Merge custom env with process.env (custom env takes precedence)
+    const spawnEnv = {
+      ...process.env,
+      ...customEnv
+    };
+
     debugLog('SPAWN', `Spawning process`, {
       command,
       args,
@@ -754,13 +836,16 @@ async function executeCliTool(
       useStdin,
       platform: process.platform,
       fullCommand: `${command} ${args.join(' ')}`,
+      hasCustomEnv: Object.keys(customEnv).length > 0,
+      customEnvKeys: Object.keys(customEnv),
       ...(isWindows ? { escapedCommand: commandToSpawn, escapedArgs: argsToSpawn, escapedFullCommand: `${commandToSpawn} ${argsToSpawn.join(' ')}` } : {})
     });
 
     const child = spawn(commandToSpawn, argsToSpawn, {
       cwd: workingDir,
       shell: isWindows,  // Enable shell on Windows for .cmd files
-      stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe']
+      stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+      env: spawnEnv
     });
 
     // Track current child process for cleanup on interruption
@@ -1190,6 +1275,9 @@ export {
  * - api-endpoint: Check LiteLLM endpoint configuration exists
  */
 export async function getCliToolsStatus(): Promise<Record<string, ToolAvailability>> {
+  const funcStart = Date.now();
+  debugLog('PERF', 'getCliToolsStatus START');
+
   // Default built-in tools
   const builtInTools = ['gemini', 'qwen', 'codex', 'claude', 'opencode'];
 
@@ -1202,6 +1290,7 @@ export async function getCliToolsStatus(): Promise<Record<string, ToolAvailabili
   }
   let toolsInfo: ToolInfo[] = builtInTools.map(name => ({ name, type: 'builtin' }));
 
+  const configLoadStart = Date.now();
   try {
     // Dynamic import to avoid circular dependencies
     const { loadClaudeCliTools } = await import('./claude-cli-tools.js');
@@ -1225,11 +1314,15 @@ export async function getCliToolsStatus(): Promise<Record<string, ToolAvailabili
     // Fallback to built-in tools if config load fails
     debugLog('cli-executor', `Using built-in tools (config load failed: ${(e as Error).message})`);
   }
+  debugLog('PERF', `Config load: ${Date.now() - configLoadStart}ms, tools: ${toolsInfo.length}`);
 
   const results: Record<string, ToolAvailability> = {};
+  const toolTimings: Record<string, number> = {};
 
+  const checksStart = Date.now();
   await Promise.all(toolsInfo.map(async (toolInfo) => {
     const { name, type, enabled, id } = toolInfo;
+    const toolStart = Date.now();
 
     // Check availability based on tool type
     if (type === 'cli-wrapper') {
@@ -1271,8 +1364,13 @@ export async function getCliToolsStatus(): Promise<Record<string, ToolAvailabili
       // For builtin: check system PATH availability
       results[name] = await checkToolAvailability(name);
     }
+
+    toolTimings[name] = Date.now() - toolStart;
   }));
 
+  debugLog('PERF', `Tool checks: ${Date.now() - checksStart}ms | Individual: ${JSON.stringify(toolTimings)}`);
+  debugLog('PERF', `getCliToolsStatus TOTAL: ${Date.now() - funcStart}ms`);
+
   return results;
 }
 
@@ -1520,6 +1618,9 @@ export type { PromptFormat, ConcatOptions } from './cli-prompt-builder.js';
 // Export utility functions and tool definition for backward compatibility
 export { executeCliTool, checkToolAvailability, clearToolCache };
 
+// Export env file utilities for testing
+export { parseEnvFile, loadEnvFile };
+
 // Export prompt concatenation utilities
 export { PromptConcatenator, createPromptConcatenator, buildPrompt, buildMultiTurnPrompt } from './cli-prompt-builder.js';
 

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

@@ -49,6 +49,14 @@ interface VenvStatusCache {
 let venvStatusCache: VenvStatusCache | null = null;
 const VENV_STATUS_TTL = 5 * 60 * 1000; // 5 minutes TTL
 
+// Semantic status cache with TTL (same as venv cache)
+interface SemanticStatusCache {
+  status: SemanticStatus;
+  timestamp: number;
+}
+let semanticStatusCache: SemanticStatusCache | null = null;
+const SEMANTIC_STATUS_TTL = 5 * 60 * 1000; // 5 minutes TTL
+
 // Track running indexing process for cancellation
 let currentIndexingProcess: ReturnType<typeof spawn> | null = null;
 let currentIndexingAborted = false;
@@ -147,8 +155,12 @@ function clearVenvStatusCache(): void {
  * @returns Ready status
  */
 async function checkVenvStatus(force = false): Promise<ReadyStatus> {
+  const funcStart = Date.now();
+  console.log('[PERF][CodexLens] checkVenvStatus START');
+
   // Use cached result if available and not expired
   if (!force && venvStatusCache && (Date.now() - venvStatusCache.timestamp < VENV_STATUS_TTL)) {
+    console.log(`[PERF][CodexLens] checkVenvStatus CACHE HIT: ${Date.now() - funcStart}ms`);
     return venvStatusCache.status;
   }
 
@@ -156,6 +168,7 @@ async function checkVenvStatus(force = false): Promise<ReadyStatus> {
   if (!existsSync(CODEXLENS_VENV)) {
     const result = { ready: false, error: 'Venv not found' };
     venvStatusCache = { status: result, timestamp: Date.now() };
+    console.log(`[PERF][CodexLens] checkVenvStatus (no venv): ${Date.now() - funcStart}ms`);
     return result;
   }
 
@@ -163,12 +176,16 @@ async function checkVenvStatus(force = false): Promise<ReadyStatus> {
   if (!existsSync(VENV_PYTHON)) {
     const result = { ready: false, error: 'Python executable not found in venv' };
     venvStatusCache = { status: result, timestamp: Date.now() };
+    console.log(`[PERF][CodexLens] checkVenvStatus (no python): ${Date.now() - funcStart}ms`);
     return result;
   }
 
-  // Check codexlens is importable
+  // Check codexlens and core dependencies are importable
+  const spawnStart = Date.now();
+  console.log('[PERF][CodexLens] checkVenvStatus spawning Python...');
+
   return new Promise((resolve) => {
-    const child = spawn(VENV_PYTHON, ['-c', 'import codexlens; print(codexlens.__version__)'], {
+    const child = spawn(VENV_PYTHON, ['-c', 'import codexlens; import watchdog; print(codexlens.__version__)'], {
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 10000,
     });
@@ -192,29 +209,54 @@ async function checkVenvStatus(force = false): Promise<ReadyStatus> {
       }
       // Cache the result
       venvStatusCache = { status: result, timestamp: Date.now() };
+      console.log(`[PERF][CodexLens] checkVenvStatus Python spawn: ${Date.now() - spawnStart}ms | TOTAL: ${Date.now() - funcStart}ms | ready: ${result.ready}`);
       resolve(result);
     });
 
     child.on('error', (err) => {
       const result = { ready: false, error: `Failed to check venv: ${err.message}` };
       venvStatusCache = { status: result, timestamp: Date.now() };
+      console.log(`[PERF][CodexLens] checkVenvStatus ERROR: ${Date.now() - funcStart}ms`);
       resolve(result);
     });
   });
 }
 
+/**
+ * Clear semantic status cache (call after install/uninstall operations)
+ */
+function clearSemanticStatusCache(): void {
+  semanticStatusCache = null;
+}
+
 /**
  * Check if semantic search dependencies are installed
+ * @param force - Force refresh cache (default: false)
  * @returns Semantic status
  */
-async function checkSemanticStatus(): Promise<SemanticStatus> {
+async function checkSemanticStatus(force = false): Promise<SemanticStatus> {
+  const funcStart = Date.now();
+  console.log('[PERF][CodexLens] checkSemanticStatus START');
+
+  // Use cached result if available and not expired
+  if (!force && semanticStatusCache && (Date.now() - semanticStatusCache.timestamp < SEMANTIC_STATUS_TTL)) {
+    console.log(`[PERF][CodexLens] checkSemanticStatus CACHE HIT: ${Date.now() - funcStart}ms`);
+    return semanticStatusCache.status;
+  }
+
   // First check if CodexLens is installed
   const venvStatus = await checkVenvStatus();
   if (!venvStatus.ready) {
-    return { available: false, error: 'CodexLens not installed' };
+    const result: SemanticStatus = { available: false, error: 'CodexLens not installed' };
+    semanticStatusCache = { status: result, timestamp: Date.now() };
+    console.log(`[PERF][CodexLens] checkSemanticStatus (no venv): ${Date.now() - funcStart}ms`);
+    return result;
   }
 
   // Check semantic module availability and accelerator info
+  const spawnStart = Date.now();
+  console.log('[PERF][CodexLens] checkSemanticStatus spawning Python...');
+
   return new Promise((resolve) => {
     const checkCode = `
 import sys
@@ -274,21 +316,31 @@ except Exception as e:
       const output = stdout.trim();
       try {
         const result = JSON.parse(output);
-        resolve({
+        console.log(`[PERF][CodexLens] checkSemanticStatus Python spawn: ${Date.now() - spawnStart}ms | TOTAL: ${Date.now() - funcStart}ms | available: ${result.available}`);
+        const status: SemanticStatus = {
           available: result.available || false,
           backend: result.backend,
           accelerator: result.accelerator || 'CPU',
           providers: result.providers || [],
           litellmAvailable: result.litellm_available || false,
           error: result.error
-        });
+        };
+        // Cache the result
+        semanticStatusCache = { status, timestamp: Date.now() };
+        resolve(status);
       } catch {
-        resolve({ available: false, error: output || stderr || 'Unknown error' });
+        console.log(`[PERF][CodexLens] checkSemanticStatus PARSE ERROR: ${Date.now() - funcStart}ms`);
+        const errorStatus: SemanticStatus = { available: false, error: output || stderr || 'Unknown error' };
+        semanticStatusCache = { status: errorStatus, timestamp: Date.now() };
+        resolve(errorStatus);
       }
     });
 
     child.on('error', (err) => {
-      resolve({ available: false, error: `Check failed: ${err.message}` });
+      console.log(`[PERF][CodexLens] checkSemanticStatus ERROR: ${Date.now() - funcStart}ms`);
+      const errorStatus: SemanticStatus = { available: false, error: `Check failed: ${err.message}` };
+      semanticStatusCache = { status: errorStatus, timestamp: Date.now() };
+      resolve(errorStatus);
     });
   });
 }
@@ -583,6 +635,7 @@ async function bootstrapWithUv(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResul
 
   // Clear cache after successful installation
   clearVenvStatusCache();
+  clearSemanticStatusCache();
   console.log(`[CodexLens] Bootstrap with UV complete (${gpuMode} mode)`);
   return { success: true, message: `Installed with UV (${gpuMode} mode)` };
 }
@@ -878,6 +931,7 @@ async function bootstrapVenv(): Promise<BootstrapResult> {
 
     // Clear cache after successful installation
     clearVenvStatusCache();
+    clearSemanticStatusCache();
     return { success: true };
   } catch (err) {
     return { success: false, error: `Failed to install codexlens: ${(err as Error).message}` };
@@ -1631,6 +1685,7 @@ async function uninstallCodexLens(): Promise<BootstrapResult> {
     bootstrapChecked = false;
     bootstrapReady = false;
     clearVenvStatusCache();
+    clearSemanticStatusCache();
 
     console.log('[CodexLens] CodexLens uninstalled successfully');
     return { success: true, message: 'CodexLens uninstalled successfully' };

package/ccw/src/tools/index.ts

@@ -30,6 +30,7 @@ import type { ProgressInfo } from './codex-lens.js';
 import { uiGeneratePreviewTool } from './ui-generate-preview.js';
 import { uiInstantiatePrototypesTool } from './ui-instantiate-prototypes.js';
 import { updateModuleClaudeTool } from './update-module-claude.js';
+import { memoryQueueTool } from './memory-update-queue.js';
 
 interface LegacyTool {
   name: string;
@@ -366,6 +367,7 @@ registerTool(toLegacyTool(skillContextLoaderMod));
 registerTool(uiGeneratePreviewTool);
 registerTool(uiInstantiatePrototypesTool);
 registerTool(updateModuleClaudeTool);
+registerTool(memoryQueueTool);
 
 // Export for external tool registration
 export { registerTool };

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

@@ -10,14 +10,36 @@
  */
 
 import { spawn } from 'child_process';
-import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 
 export interface LiteLLMConfig {
-  pythonPath?: string;  // Default 'python'
+  pythonPath?: string;  // Default: CodexLens venv Python
   configPath?: string;  // Configuration file path
   timeout?: number;     // Default 60000ms
 }
 
+// Platform-specific constants for CodexLens venv
+const IS_WINDOWS = process.platform === 'win32';
+const CODEXLENS_VENV = join(homedir(), '.codexlens', 'venv');
+const VENV_BIN_DIR = IS_WINDOWS ? 'Scripts' : 'bin';
+const PYTHON_EXECUTABLE = IS_WINDOWS ? 'python.exe' : 'python';
+
+/**
+ * Get the Python path from CodexLens venv
+ * Falls back to system 'python' if venv doesn't exist
+ * @returns Path to Python executable
+ */
+export function getCodexLensVenvPython(): string {
+  const venvPython = join(CODEXLENS_VENV, VENV_BIN_DIR, PYTHON_EXECUTABLE);
+  if (existsSync(venvPython)) {
+    return venvPython;
+  }
+  // Fallback to system Python if venv not available
+  return 'python';
+}
+
 export interface ChatMessage {
   role: 'system' | 'user' | 'assistant';
   content: string;
@@ -51,7 +73,7 @@ export class LiteLLMClient {
   private timeout: number;
 
   constructor(config: LiteLLMConfig = {}) {
-    this.pythonPath = config.pythonPath || 'python';
+    this.pythonPath = config.pythonPath || getCodexLensVenvPython();
     this.configPath = config.configPath;
     this.timeout = config.timeout || 60000;
   }

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

@@ -3,7 +3,7 @@
  * Integrates with context-cache for file packing and LiteLLM client for API calls
  */
 
-import { getLiteLLMClient } from './litellm-client.js';
+import { getLiteLLMClient, getCodexLensVenvPython } from './litellm-client.js';
 import { handler as contextCacheHandler } from './context-cache.js';
 import {
   findEndpointById,
@@ -179,7 +179,7 @@ export async function executeLiteLLMEndpoint(
     }
 
     const client = getLiteLLMClient({
-      pythonPath: 'python',
+      pythonPath: getCodexLensVenvPython(),
       timeout: 120000, // 2 minutes
     });