claude-code-workflow 6.3.2 → 6.3.4

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

@@ -73,6 +73,7 @@ const ParamsSchema = z.object({
   noNative: z.boolean().optional(), // Force prompt concatenation instead of native resume
   category: z.enum(['user', 'internal', 'insight']).default('user'), // Execution category for tracking
   parentExecutionId: z.string().optional(), // Parent execution ID for fork/retry scenarios
+  stream: z.boolean().default(false), // false = cache full output (default), true = stream output via callback
 });
 
 // Execution category types
@@ -863,24 +864,36 @@ async function executeCliTool(
       const endTime = Date.now();
       const duration = endTime - startTime;
 
-      // Determine status
+      // Determine status - prioritize output content over exit code
       let status: 'success' | 'error' | 'timeout' = 'success';
       if (timedOut) {
         status = 'timeout';
       } else if (code !== 0) {
-        // Check if HTTP 429 but results exist (Gemini quirk)
-        if (stderr.includes('429') && stdout.trim()) {
+        // Non-zero exit code doesn't always mean failure
+        // Check if there's valid output (AI response) - treat as success
+        const hasValidOutput = stdout.trim().length > 0;
+        const hasFatalError = stderr.includes('FATAL') ||
+                              stderr.includes('Authentication failed') ||
+                              stderr.includes('API key') ||
+                              stderr.includes('rate limit exceeded');
+
+        if (hasValidOutput && !hasFatalError) {
+          // Has output and no fatal errors - treat as success despite exit code
           status = 'success';
         } else {
           status = 'error';
         }
       }
 
-      // Create new turn
+      // Create new turn - cache full output when not streaming (default)
+      const shouldCache = !parsed.data.stream;
       const newTurnOutput = {
-        stdout: stdout.substring(0, 10240), // Truncate to 10KB
-        stderr: stderr.substring(0, 2048),  // Truncate to 2KB
-        truncated: stdout.length > 10240 || stderr.length > 2048
+        stdout: stdout.substring(0, 10240), // Truncate preview to 10KB
+        stderr: stderr.substring(0, 2048),  // Truncate preview to 2KB
+        truncated: stdout.length > 10240 || stderr.length > 2048,
+        cached: shouldCache,
+        stdout_full: shouldCache ? stdout : undefined,
+        stderr_full: shouldCache ? stderr : undefined
       };
 
       // Determine base turn number for merge scenarios

package/ccw/src/tools/cli-history-store.ts

@@ -23,6 +23,9 @@ export interface ConversationTurn {
     stdout: string;
     stderr: string;
     truncated: boolean;
+    cached?: boolean;
+    stdout_full?: string;
+    stderr_full?: string;
   };
 }
 
@@ -315,6 +318,28 @@ export class CliHistoryStore {
       } catch (indexErr) {
         console.warn('[CLI History] Turns timestamp index creation warning:', (indexErr as Error).message);
       }
+
+      // Add cached output columns to turns table for non-streaming mode
+      const turnsInfo = this.db.prepare('PRAGMA table_info(turns)').all() as Array<{ name: string }>;
+      const hasCached = turnsInfo.some(col => col.name === 'cached');
+      const hasStdoutFull = turnsInfo.some(col => col.name === 'stdout_full');
+      const hasStderrFull = turnsInfo.some(col => col.name === 'stderr_full');
+
+      if (!hasCached) {
+        console.log('[CLI History] Migrating database: adding cached column to turns table...');
+        this.db.exec('ALTER TABLE turns ADD COLUMN cached INTEGER DEFAULT 0;');
+        console.log('[CLI History] Migration complete: cached column added');
+      }
+      if (!hasStdoutFull) {
+        console.log('[CLI History] Migrating database: adding stdout_full column to turns table...');
+        this.db.exec('ALTER TABLE turns ADD COLUMN stdout_full TEXT;');
+        console.log('[CLI History] Migration complete: stdout_full column added');
+      }
+      if (!hasStderrFull) {
+        console.log('[CLI History] Migrating database: adding stderr_full column to turns table...');
+        this.db.exec('ALTER TABLE turns ADD COLUMN stderr_full TEXT;');
+        console.log('[CLI History] Migration complete: stderr_full column added');
+      }
     } catch (err) {
       console.error('[CLI History] Migration error:', (err as Error).message);
       // Don't throw - allow the store to continue working with existing schema
@@ -421,8 +446,8 @@ export class CliHistoryStore {
     `);
 
     const upsertTurn = this.db.prepare(`
-      INSERT INTO turns (conversation_id, turn_number, timestamp, prompt, duration_ms, status, exit_code, stdout, stderr, truncated)
-      VALUES (@conversation_id, @turn_number, @timestamp, @prompt, @duration_ms, @status, @exit_code, @stdout, @stderr, @truncated)
+      INSERT INTO turns (conversation_id, turn_number, timestamp, prompt, duration_ms, status, exit_code, stdout, stderr, truncated, cached, stdout_full, stderr_full)
+      VALUES (@conversation_id, @turn_number, @timestamp, @prompt, @duration_ms, @status, @exit_code, @stdout, @stderr, @truncated, @cached, @stdout_full, @stderr_full)
       ON CONFLICT(conversation_id, turn_number) DO UPDATE SET
         timestamp = @timestamp,
         prompt = @prompt,
@@ -431,7 +456,10 @@ export class CliHistoryStore {
         exit_code = @exit_code,
         stdout = @stdout,
         stderr = @stderr,
-        truncated = @truncated
+        truncated = @truncated,
+        cached = @cached,
+        stdout_full = @stdout_full,
+        stderr_full = @stderr_full
     `);
 
     const transaction = this.db.transaction(() => {
@@ -463,7 +491,10 @@ export class CliHistoryStore {
           exit_code: turn.exit_code,
           stdout: turn.output.stdout,
           stderr: turn.output.stderr,
-          truncated: turn.output.truncated ? 1 : 0
+          truncated: turn.output.truncated ? 1 : 0,
+          cached: turn.output.cached ? 1 : 0,
+          stdout_full: turn.output.stdout_full || null,
+          stderr_full: turn.output.stderr_full || null
         });
       }
     });
@@ -507,7 +538,10 @@ export class CliHistoryStore {
         output: {
           stdout: t.stdout || '',
           stderr: t.stderr || '',
-          truncated: !!t.truncated
+          truncated: !!t.truncated,
+          cached: !!t.cached,
+          stdout_full: t.stdout_full || undefined,
+          stderr_full: t.stderr_full || undefined
         }
       }))
     };
@@ -533,6 +567,92 @@ export class CliHistoryStore {
     };
   }
 
+  /**
+   * Get paginated cached output for a conversation turn
+   * @param conversationId - Conversation ID
+   * @param turnNumber - Turn number (default: latest turn)
+   * @param options - Pagination options
+   */
+  getCachedOutput(
+    conversationId: string,
+    turnNumber?: number,
+    options: {
+      offset?: number;      // Character offset (default: 0)
+      limit?: number;       // Max characters to return (default: 10000)
+      outputType?: 'stdout' | 'stderr' | 'both';  // Which output to fetch
+    } = {}
+  ): {
+    conversationId: string;
+    turnNumber: number;
+    stdout?: { content: string; totalBytes: number; offset: number; hasMore: boolean };
+    stderr?: { content: string; totalBytes: number; offset: number; hasMore: boolean };
+    cached: boolean;
+    prompt: string;
+    status: string;
+    timestamp: string;
+  } | null {
+    const { offset = 0, limit = 10000, outputType = 'both' } = options;
+
+    // Get turn (latest if not specified)
+    let turn;
+    if (turnNumber !== undefined) {
+      turn = this.db.prepare(`
+        SELECT * FROM turns WHERE conversation_id = ? AND turn_number = ?
+      `).get(conversationId, turnNumber) as any;
+    } else {
+      turn = this.db.prepare(`
+        SELECT * FROM turns WHERE conversation_id = ? ORDER BY turn_number DESC LIMIT 1
+      `).get(conversationId) as any;
+    }
+
+    if (!turn) return null;
+
+    const result: {
+      conversationId: string;
+      turnNumber: number;
+      stdout?: { content: string; totalBytes: number; offset: number; hasMore: boolean };
+      stderr?: { content: string; totalBytes: number; offset: number; hasMore: boolean };
+      cached: boolean;
+      prompt: string;
+      status: string;
+      timestamp: string;
+    } = {
+      conversationId,
+      turnNumber: turn.turn_number,
+      cached: !!turn.cached,
+      prompt: turn.prompt,
+      status: turn.status,
+      timestamp: turn.timestamp
+    };
+
+    // Use full output if cached, otherwise use truncated
+    if (outputType === 'stdout' || outputType === 'both') {
+      const fullStdout = turn.cached ? (turn.stdout_full || '') : (turn.stdout || '');
+      const totalBytes = fullStdout.length;
+      const content = fullStdout.substring(offset, offset + limit);
+      result.stdout = {
+        content,
+        totalBytes,
+        offset,
+        hasMore: offset + limit < totalBytes
+      };
+    }
+
+    if (outputType === 'stderr' || outputType === 'both') {
+      const fullStderr = turn.cached ? (turn.stderr_full || '') : (turn.stderr || '');
+      const totalBytes = fullStderr.length;
+      const content = fullStderr.substring(offset, offset + limit);
+      result.stderr = {
+        content,
+        totalBytes,
+        offset,
+        hasMore: offset + limit < totalBytes
+      };
+    }
+
+    return result;
+  }
+
   /**
    * Query execution history
    */

package/codex-lens/src/codexlens/config.py

@@ -100,6 +100,9 @@ class Config:
                                    # For litellm: model name from config (e.g., "qwen3-embedding")
     embedding_use_gpu: bool = True  # For fastembed: whether to use GPU acceleration
 
+    # Indexing/search optimizations
+    global_symbol_index_enabled: bool = True  # Enable project-wide symbol index fast path
+
     # Multi-endpoint configuration for litellm backend
     embedding_endpoints: List[Dict[str, Any]] = field(default_factory=list)
     # List of endpoint configs: [{"model": "...", "api_key": "...", "api_base": "...", "weight": 1.0}]

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

@@ -11,11 +11,14 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional, Dict, Any
 import logging
+import os
 import time
 
 from codexlens.entities import SearchResult, Symbol
+from codexlens.config import Config
 from codexlens.storage.registry import RegistryStore, DirMapping
 from codexlens.storage.dir_index import DirIndexStore, SubdirLink
+from codexlens.storage.global_index import GlobalSymbolIndex
 from codexlens.storage.path_mapper import PathMapper
 from codexlens.storage.sqlite_store import SQLiteStore
 from codexlens.search.hybrid_search import HybridSearchEngine
@@ -107,7 +110,8 @@ class ChainSearchEngine:
     def __init__(self,
                  registry: RegistryStore,
                  mapper: PathMapper,
-                 max_workers: int = 8):
+                 max_workers: int = 8,
+                 config: Config | None = None):
         """Initialize chain search engine.
 
         Args:
@@ -120,6 +124,7 @@ class ChainSearchEngine:
         self.logger = logging.getLogger(__name__)
         self._max_workers = max_workers
         self._executor: Optional[ThreadPoolExecutor] = None
+        self._config = config
 
     def _get_executor(self, max_workers: Optional[int] = None) -> ThreadPoolExecutor:
         """Get or create the shared thread pool executor.
@@ -294,6 +299,71 @@ class ChainSearchEngine:
             self.logger.warning(f"No index found for {source_path}")
             return []
 
+        # Fast path: project-wide global symbol index (avoids chain traversal).
+        if self._config is None or getattr(self._config, "global_symbol_index_enabled", True):
+            try:
+                # Avoid relying on index_to_source() here; use the same logic as _find_start_index
+                # to determine the effective search root directory.
+                search_root = source_path.resolve()
+                exact_index = self.mapper.source_to_index_db(search_root)
+                if not exact_index.exists():
+                    nearest = self.registry.find_nearest_index(search_root)
+                    if nearest:
+                        search_root = nearest.source_path
+
+                project = self.registry.find_by_source_path(str(search_root))
+                if project:
+                    global_db_path = Path(project["index_root"]) / GlobalSymbolIndex.DEFAULT_DB_NAME
+                    if global_db_path.exists():
+                        query_limit = max(int(options.total_limit) * 10, int(options.total_limit))
+                        with GlobalSymbolIndex(global_db_path, project_id=int(project["id"])) as global_index:
+                            candidates = global_index.search(name=name, kind=kind, limit=query_limit)
+
+                        # Apply depth constraint relative to the start index directory.
+                        filtered: List[Symbol] = []
+                        for sym in candidates:
+                            if not sym.file:
+                                continue
+                            try:
+                                root_str = str(search_root)
+                                file_dir_str = str(Path(sym.file).parent)
+
+                                # Normalize Windows long-path prefix (\\?\) if present.
+                                if root_str.startswith("\\\\?\\"):
+                                    root_str = root_str[4:]
+                                if file_dir_str.startswith("\\\\?\\"):
+                                    file_dir_str = file_dir_str[4:]
+
+                                root_cmp = root_str.lower().rstrip("\\/")
+                                dir_cmp = file_dir_str.lower().rstrip("\\/")
+
+                                if os.path.commonpath([root_cmp, dir_cmp]) != root_cmp:
+                                    continue
+
+                                rel = os.path.relpath(dir_cmp, root_cmp)
+                                rel_depth = 0 if rel == "." else len(rel.split(os.sep))
+                            except Exception:
+                                continue
+
+                            if options.depth >= 0 and rel_depth > options.depth:
+                                continue
+                            filtered.append(sym)
+
+                        if filtered:
+                            # Match existing semantics: dedupe by (name, kind, range), sort by name.
+                            seen = set()
+                            unique_symbols: List[Symbol] = []
+                            for sym in filtered:
+                                key = (sym.name, sym.kind, sym.range)
+                                if key in seen:
+                                    continue
+                                seen.add(key)
+                                unique_symbols.append(sym)
+                            unique_symbols.sort(key=lambda s: s.name)
+                            return unique_symbols[: options.total_limit]
+            except Exception as exc:
+                self.logger.debug("Global symbol index fast path failed: %s", exc)
+
         index_paths = self._collect_index_paths(start_index, options.depth)
         if not index_paths:
             return []