claude-code-workflow 6.2.9 → 6.3.1

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

@@ -33,6 +33,14 @@ const VENV_PYTHON =
 let bootstrapChecked = false;
 let bootstrapReady = false;
 
+// Venv status cache with TTL
+interface VenvStatusCache {
+  status: ReadyStatus;
+  timestamp: number;
+}
+let venvStatusCache: VenvStatusCache | null = null;
+const VENV_STATUS_TTL = 5 * 60 * 1000; // 5 minutes TTL
+
 // Track running indexing process for cancellation
 let currentIndexingProcess: ReturnType<typeof spawn> | null = null;
 let currentIndexingAborted = false;
@@ -77,6 +85,7 @@ interface SemanticStatus {
   backend?: string;
   accelerator?: string;
   providers?: string[];
+  litellmAvailable?: boolean;
   error?: string;
 }
 
@@ -115,6 +124,13 @@ interface ProgressInfo {
   totalFiles?: number;
 }
 
+/**
+ * Clear venv status cache (call after install/uninstall operations)
+ */
+function clearVenvStatusCache(): void {
+  venvStatusCache = null;
+}
+
 /**
  * Detect available Python 3 executable
  * @returns Python executable command
@@ -137,17 +153,27 @@ function getSystemPython(): string {
 
 /**
  * Check if CodexLens venv exists and has required packages
+ * @param force - Force refresh cache (default: false)
  * @returns Ready status
  */
-async function checkVenvStatus(): Promise<ReadyStatus> {
+async function checkVenvStatus(force = false): Promise<ReadyStatus> {
+  // Use cached result if available and not expired
+  if (!force && venvStatusCache && (Date.now() - venvStatusCache.timestamp < VENV_STATUS_TTL)) {
+    return venvStatusCache.status;
+  }
+
   // Check venv exists
   if (!existsSync(CODEXLENS_VENV)) {
-    return { ready: false, error: 'Venv not found' };
+    const result = { ready: false, error: 'Venv not found' };
+    venvStatusCache = { status: result, timestamp: Date.now() };
+    return result;
   }
 
   // Check python executable exists
   if (!existsSync(VENV_PYTHON)) {
-    return { ready: false, error: 'Python executable not found in venv' };
+    const result = { ready: false, error: 'Python executable not found in venv' };
+    venvStatusCache = { status: result, timestamp: Date.now() };
+    return result;
   }
 
   // Check codexlens is importable
@@ -168,15 +194,21 @@ async function checkVenvStatus(): Promise<ReadyStatus> {
     });
 
     child.on('close', (code) => {
+      let result: ReadyStatus;
       if (code === 0) {
-        resolve({ ready: true, version: stdout.trim() });
+        result = { ready: true, version: stdout.trim() };
       } else {
-        resolve({ ready: false, error: `CodexLens not installed: ${stderr}` });
+        result = { ready: false, error: `CodexLens not installed: ${stderr}` };
       }
+      // Cache the result
+      venvStatusCache = { status: result, timestamp: Date.now() };
+      resolve(result);
     });
 
     child.on('error', (err) => {
-      resolve({ ready: false, error: `Failed to check venv: ${err.message}` });
+      const result = { ready: false, error: `Failed to check venv: ${err.message}` };
+      venvStatusCache = { status: result, timestamp: Date.now() };
+      resolve(result);
     });
   });
 }
@@ -198,8 +230,15 @@ async function checkSemanticStatus(): Promise<SemanticStatus> {
 import sys
 import json
 try:
-    from codexlens.semantic import SEMANTIC_AVAILABLE, SEMANTIC_BACKEND
-    result = {"available": SEMANTIC_AVAILABLE, "backend": SEMANTIC_BACKEND if SEMANTIC_AVAILABLE else None}
+    import codexlens.semantic as semantic
+    SEMANTIC_AVAILABLE = bool(getattr(semantic, "SEMANTIC_AVAILABLE", False))
+    SEMANTIC_BACKEND = getattr(semantic, "SEMANTIC_BACKEND", None)
+    LITELLM_AVAILABLE = bool(getattr(semantic, "LITELLM_AVAILABLE", False))
+    result = {
+        "available": SEMANTIC_AVAILABLE,
+        "backend": SEMANTIC_BACKEND if SEMANTIC_AVAILABLE else None,
+        "litellm_available": LITELLM_AVAILABLE,
+    }
 
     # Get ONNX providers for accelerator info
     try:
@@ -250,6 +289,7 @@ except Exception as e:
           backend: result.backend,
           accelerator: result.accelerator || 'CPU',
           providers: result.providers || [],
+          litellmAvailable: result.litellm_available || false,
           error: result.error
         });
       } catch {
@@ -263,6 +303,77 @@ except Exception as e:
   });
 }
 
+/**
+ * Ensure LiteLLM embedder dependencies are available in the CodexLens venv.
+ * Installs ccw-litellm into the venv if needed.
+ */
+async function ensureLiteLLMEmbedderReady(): Promise<BootstrapResult> {
+  // Ensure CodexLens venv exists and CodexLens is installed.
+  const readyStatus = await ensureReady();
+  if (!readyStatus.ready) {
+    return { success: false, error: readyStatus.error || 'CodexLens not ready' };
+  }
+
+  // Check if ccw_litellm can be imported
+  const importStatus = await new Promise<{ ok: boolean; error?: string }>((resolve) => {
+    const child = spawn(VENV_PYTHON, ['-c', 'import ccw_litellm; print("OK")'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 15000,
+    });
+
+    let stderr = '';
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({ ok: code === 0, error: stderr.trim() || undefined });
+    });
+
+    child.on('error', (err) => {
+      resolve({ ok: false, error: err.message });
+    });
+  });
+
+  if (importStatus.ok) {
+    return { success: true };
+  }
+
+  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 (!installed) {
+      console.log('[CodexLens] Installing ccw-litellm from PyPI...');
+      execSync(`"${pipPath}" install ccw-litellm`, { stdio: 'inherit' });
+    }
+
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: `Failed to install ccw-litellm: ${(err as Error).message}` };
+  }
+}
+
 /**
  * GPU acceleration mode for semantic search
  */
@@ -421,6 +532,17 @@ async function installSemantic(gpuMode: GpuMode = 'cpu'): Promise<BootstrapResul
 
       child.on('close', (code) => {
         if (code === 0) {
+          // IMPORTANT: fastembed installs onnxruntime (CPU) as dependency, which conflicts
+          // with onnxruntime-directml/gpu. Reinstall the GPU version to ensure it takes precedence.
+          if (gpuMode !== 'cpu') {
+            try {
+              console.log(`[CodexLens] Reinstalling ${onnxPackage} to ensure GPU provider works...`);
+              execSync(`"${pipPath}" install --force-reinstall ${onnxPackage}`, { stdio: 'pipe', timeout: 300000 });
+              console.log(`[CodexLens] ${onnxPackage} reinstalled successfully`);
+            } catch (e) {
+              console.warn(`[CodexLens] Warning: Failed to reinstall ${onnxPackage}: ${(e as Error).message}`);
+            }
+          }
           console.log(`[CodexLens] Semantic dependencies installed successfully (${gpuMode} mode)`);
           resolve({ success: true, message: `Installed with ${modeDescription}` });
         } else {
@@ -490,6 +612,8 @@ async function bootstrapVenv(): Promise<BootstrapResult> {
       execSync(`"${pipPath}" install codexlens`, { stdio: 'inherit' });
     }
 
+    // Clear cache after successful installation
+    clearVenvStatusCache();
     return { success: true };
   } catch (err) {
     return { success: false, error: `Failed to install codexlens: ${(err as Error).message}` };
@@ -1209,6 +1333,7 @@ async function uninstallCodexLens(): Promise<BootstrapResult> {
     // Reset bootstrap cache
     bootstrapChecked = false;
     bootstrapReady = false;
+    clearVenvStatusCache();
 
     console.log('[CodexLens] CodexLens uninstalled successfully');
     return { success: true, message: 'CodexLens uninstalled successfully' };
@@ -1273,7 +1398,19 @@ function isIndexingInProgress(): boolean {
 export type { ProgressInfo, ExecuteOptions };
 
 // Export for direct usage
-export { ensureReady, executeCodexLens, checkVenvStatus, bootstrapVenv, checkSemanticStatus, installSemantic, detectGpuSupport, uninstallCodexLens, cancelIndexing, isIndexingInProgress };
+export {
+  ensureReady,
+  executeCodexLens,
+  checkVenvStatus,
+  bootstrapVenv,
+  checkSemanticStatus,
+  ensureLiteLLMEmbedderReady,
+  installSemantic,
+  detectGpuSupport,
+  uninstallCodexLens,
+  cancelIndexing,
+  isIndexingInProgress,
+};
 export type { GpuMode };
 
 // Backward-compatible export for tests

package/ccw/src/tools/context-cache-store.ts

@@ -0,0 +1,368 @@
+/**
+ * Context Cache Store - In-memory cache with TTL and LRU eviction
+ * Stores packed file contents with session-based lifecycle management
+ */
+
+/** Cache entry metadata */
+export interface CacheMetadata {
+  files: string[];           // Source file paths
+  patterns: string[];        // Original @patterns
+  total_bytes: number;       // Total content bytes
+  file_count: number;        // Number of files packed
+}
+
+/** Cache entry structure */
+export interface CacheEntry {
+  session_id: string;
+  created_at: number;        // Timestamp ms
+  accessed_at: number;       // Last access timestamp
+  ttl: number;               // TTL in ms
+  content: string;           // Packed file content
+  metadata: CacheMetadata;
+}
+
+/** Paginated read result */
+export interface PagedReadResult {
+  content: string;           // Current page content
+  offset: number;            // Current byte offset
+  limit: number;             // Requested bytes
+  total_bytes: number;       // Total content bytes
+  has_more: boolean;         // Has more content
+  next_offset: number | null; // Next page offset (null if no more)
+}
+
+/** Cache status info */
+export interface CacheStatus {
+  entries: number;           // Total cache entries
+  total_bytes: number;       // Total bytes cached
+  oldest_session: string | null;
+  newest_session: string | null;
+}
+
+/** Session status info */
+export interface SessionStatus {
+  session_id: string;
+  exists: boolean;
+  files?: string[];
+  file_count?: number;
+  total_bytes?: number;
+  created_at?: string;
+  expires_at?: string;
+  accessed_at?: string;
+  ttl_remaining_ms?: number;
+}
+
+/** Default configuration */
+const DEFAULT_MAX_ENTRIES = 100;
+const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_PAGE_SIZE = 65536; // 64KB
+
+/**
+ * Context Cache Store singleton
+ * Manages in-memory cache with TTL expiration and LRU eviction
+ */
+class ContextCacheStore {
+  private cache: Map<string, CacheEntry> = new Map();
+  private maxEntries: number;
+  private defaultTTL: number;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+
+  constructor(options: {
+    maxEntries?: number;
+    defaultTTL?: number;
+    cleanupIntervalMs?: number;
+  } = {}) {
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.defaultTTL = options.defaultTTL ?? DEFAULT_TTL_MS;
+
+    // Start periodic cleanup
+    const cleanupMs = options.cleanupIntervalMs ?? 60000; // 1 minute
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired();
+    }, cleanupMs);
+
+    // Allow cleanup to not keep process alive
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+
+  /**
+   * Store packed content in cache
+   */
+  set(
+    sessionId: string,
+    content: string,
+    metadata: CacheMetadata,
+    ttl?: number
+  ): CacheEntry {
+    const now = Date.now();
+    const entryTTL = ttl ?? this.defaultTTL;
+
+    // Evict if at capacity
+    if (this.cache.size >= this.maxEntries && !this.cache.has(sessionId)) {
+      this.evictOldest();
+    }
+
+    const entry: CacheEntry = {
+      session_id: sessionId,
+      created_at: now,
+      accessed_at: now,
+      ttl: entryTTL,
+      content,
+      metadata,
+    };
+
+    this.cache.set(sessionId, entry);
+    return entry;
+  }
+
+  /**
+   * Get cache entry by session ID
+   */
+  get(sessionId: string): CacheEntry | null {
+    const entry = this.cache.get(sessionId);
+
+    if (!entry) {
+      return null;
+    }
+
+    // Check TTL expiration
+    if (this.isExpired(entry)) {
+      this.cache.delete(sessionId);
+      return null;
+    }
+
+    // Update access time (LRU)
+    entry.accessed_at = Date.now();
+    return entry;
+  }
+
+  /**
+   * Read content with pagination
+   */
+  read(
+    sessionId: string,
+    offset: number = 0,
+    limit: number = DEFAULT_PAGE_SIZE
+  ): PagedReadResult | null {
+    const entry = this.get(sessionId);
+
+    if (!entry) {
+      return null;
+    }
+
+    const content = entry.content;
+    const totalBytes = Buffer.byteLength(content, 'utf-8');
+
+    // Handle byte-based offset for UTF-8
+    // For simplicity, we use character-based slicing
+    // This is approximate but works for most use cases
+    const charOffset = Math.min(offset, content.length);
+    const charLimit = Math.min(limit, content.length - charOffset);
+
+    const pageContent = content.slice(charOffset, charOffset + charLimit);
+    const endOffset = charOffset + pageContent.length;
+    const hasMore = endOffset < content.length;
+
+    return {
+      content: pageContent,
+      offset: charOffset,
+      limit: charLimit,
+      total_bytes: totalBytes,
+      has_more: hasMore,
+      next_offset: hasMore ? endOffset : null,
+    };
+  }
+
+  /**
+   * Release (delete) cache entry
+   */
+  release(sessionId: string): { released: boolean; freed_bytes: number } {
+    const entry = this.cache.get(sessionId);
+
+    if (!entry) {
+      return { released: false, freed_bytes: 0 };
+    }
+
+    const freedBytes = entry.metadata.total_bytes;
+    this.cache.delete(sessionId);
+
+    return { released: true, freed_bytes: freedBytes };
+  }
+
+  /**
+   * Get session status
+   */
+  getSessionStatus(sessionId: string): SessionStatus {
+    const entry = this.cache.get(sessionId);
+
+    if (!entry) {
+      return { session_id: sessionId, exists: false };
+    }
+
+    // Check if expired
+    if (this.isExpired(entry)) {
+      this.cache.delete(sessionId);
+      return { session_id: sessionId, exists: false };
+    }
+
+    const now = Date.now();
+    const expiresAt = entry.created_at + entry.ttl;
+    const ttlRemaining = Math.max(0, expiresAt - now);
+
+    return {
+      session_id: sessionId,
+      exists: true,
+      files: entry.metadata.files,
+      file_count: entry.metadata.file_count,
+      total_bytes: entry.metadata.total_bytes,
+      created_at: new Date(entry.created_at).toISOString(),
+      expires_at: new Date(expiresAt).toISOString(),
+      accessed_at: new Date(entry.accessed_at).toISOString(),
+      ttl_remaining_ms: ttlRemaining,
+    };
+  }
+
+  /**
+   * Get overall cache status
+   */
+  getStatus(): CacheStatus {
+    let totalBytes = 0;
+    let oldest: CacheEntry | null = null;
+    let newest: CacheEntry | null = null;
+
+    for (const entry of this.cache.values()) {
+      // Skip expired entries
+      if (this.isExpired(entry)) {
+        continue;
+      }
+
+      totalBytes += entry.metadata.total_bytes;
+
+      if (!oldest || entry.created_at < oldest.created_at) {
+        oldest = entry;
+      }
+      if (!newest || entry.created_at > newest.created_at) {
+        newest = entry;
+      }
+    }
+
+    return {
+      entries: this.cache.size,
+      total_bytes: totalBytes,
+      oldest_session: oldest?.session_id ?? null,
+      newest_session: newest?.session_id ?? null,
+    };
+  }
+
+  /**
+   * Cleanup expired entries
+   */
+  cleanupExpired(): { removed: number } {
+    let removed = 0;
+    const now = Date.now();
+
+    for (const [sessionId, entry] of this.cache.entries()) {
+      if (this.isExpired(entry, now)) {
+        this.cache.delete(sessionId);
+        removed++;
+      }
+    }
+
+    return { removed };
+  }
+
+  /**
+   * Clear all cache entries
+   */
+  clear(): { removed: number } {
+    const count = this.cache.size;
+    this.cache.clear();
+    return { removed: count };
+  }
+
+  /**
+   * Check if entry is expired
+   */
+  private isExpired(entry: CacheEntry, now?: number): boolean {
+    const currentTime = now ?? Date.now();
+    return currentTime > entry.created_at + entry.ttl;
+  }
+
+  /**
+   * Evict oldest entry (LRU)
+   */
+  private evictOldest(): void {
+    let oldest: [string, CacheEntry] | null = null;
+
+    for (const [sessionId, entry] of this.cache.entries()) {
+      if (!oldest || entry.accessed_at < oldest[1].accessed_at) {
+        oldest = [sessionId, entry];
+      }
+    }
+
+    if (oldest) {
+      this.cache.delete(oldest[0]);
+    }
+  }
+
+  /**
+   * Stop cleanup timer (for graceful shutdown)
+   */
+  destroy(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+
+  /**
+   * List all session IDs
+   */
+  listSessions(): string[] {
+    return Array.from(this.cache.keys());
+  }
+
+  /**
+   * Check if session exists and is valid
+   */
+  has(sessionId: string): boolean {
+    const entry = this.cache.get(sessionId);
+    if (!entry) return false;
+    if (this.isExpired(entry)) {
+      this.cache.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+}
+
+// Singleton instance
+let cacheInstance: ContextCacheStore | null = null;
+
+/**
+ * Get the singleton cache instance
+ */
+export function getContextCacheStore(options?: {
+  maxEntries?: number;
+  defaultTTL?: number;
+  cleanupIntervalMs?: number;
+}): ContextCacheStore {
+  if (!cacheInstance) {
+    cacheInstance = new ContextCacheStore(options);
+  }
+  return cacheInstance;
+}
+
+/**
+ * Reset the cache instance (for testing)
+ */
+export function resetContextCacheStore(): void {
+  if (cacheInstance) {
+    cacheInstance.destroy();
+    cacheInstance = null;
+  }
+}
+
+export { ContextCacheStore };