claude-code-workflow 6.3.18 → 6.3.19

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

@@ -10,20 +10,21 @@ import {
   getProviderWithResolvedEnvVars,
 } from '../config/litellm-api-config-manager.js';
 import type { CustomEndpoint, ProviderCredential } from '../types/litellm-api-config.js';
+import type { CliOutputUnit } from './cli-output-converter.js';
 
-export interface LiteLLMExecutionOptions {
-  prompt: string;
-  endpointId: string; // Custom endpoint ID (e.g., "my-gpt4o")
-  baseDir: string; // Project base directory
-  cwd?: string; // Working directory for file resolution
-  includeDirs?: string[]; // Additional directories for @patterns
-  enableCache?: boolean; // Override endpoint cache setting
-  onOutput?: (data: { type: string; data: string }) => void;
-  /** Number of retries after the initial attempt (default: 0) */
-  maxRetries?: number;
-  /** Base delay for exponential backoff in milliseconds (default: 1000) */
-  retryBaseDelayMs?: number;
-}
+export interface LiteLLMExecutionOptions {
+  prompt: string;
+  endpointId: string; // Custom endpoint ID (e.g., "my-gpt4o")
+  baseDir: string; // Project base directory
+  cwd?: string; // Working directory for file resolution
+  includeDirs?: string[]; // Additional directories for @patterns
+  enableCache?: boolean; // Override endpoint cache setting
+  onOutput?: (unit: CliOutputUnit) => void;
+  /** Number of retries after the initial attempt (default: 0) */
+  maxRetries?: number;
+  /** Base delay for exponential backoff in milliseconds (default: 1000) */
+  retryBaseDelayMs?: number;
+}
 
 export interface LiteLLMExecutionResult {
   success: boolean;
@@ -52,10 +53,10 @@ export function extractPatterns(prompt: string): string[] {
 /**
  * Execute LiteLLM endpoint with optional context caching
  */
-export async function executeLiteLLMEndpoint(
-  options: LiteLLMExecutionOptions
-): Promise<LiteLLMExecutionResult> {
-  const { prompt, endpointId, baseDir, cwd, includeDirs, enableCache, onOutput } = options;
+export async function executeLiteLLMEndpoint(
+  options: LiteLLMExecutionOptions
+): Promise<LiteLLMExecutionResult> {
+  const { prompt, endpointId, baseDir, cwd, includeDirs, enableCache, onOutput } = options;
 
   // 1. Find endpoint configuration
   const endpoint = findEndpointById(baseDir, endpointId);
@@ -105,7 +106,11 @@ export async function executeLiteLLMEndpoint(
     const patterns = extractPatterns(prompt);
     if (patterns.length > 0) {
       if (onOutput) {
-        onOutput({ type: 'stderr', data: `[Context cache: Found ${patterns.length} @patterns]\n` });
+        onOutput({
+          type: 'stderr',
+          content: `[Context cache: Found ${patterns.length} @patterns]\n`,
+          timestamp: new Date().toISOString()
+        });
       }
 
       // Pack files into cache
@@ -124,7 +129,8 @@ export async function executeLiteLLMEndpoint(
         if (onOutput) {
           onOutput({
             type: 'stderr',
-            data: `[Context cache: Packed ${pack.files_packed} files, ${pack.total_bytes} bytes]\n`,
+            content: `[Context cache: Packed ${pack.files_packed} files, ${pack.total_bytes} bytes]\n`,
+            timestamp: new Date().toISOString()
           });
         }
 
@@ -143,12 +149,20 @@ export async function executeLiteLLMEndpoint(
           cachedFiles = pack.files_packed ? Array(pack.files_packed).fill('...') : [];
 
           if (onOutput) {
-            onOutput({ type: 'stderr', data: `[Context cache: Applied to prompt]\n` });
+            onOutput({
+              type: 'stderr',
+              content: `[Context cache: Applied to prompt]\n`,
+              timestamp: new Date().toISOString()
+            });
           }
         }
       } else if (packResult.error) {
         if (onOutput) {
-          onOutput({ type: 'stderr', data: `[Context cache warning: ${packResult.error}]\n` });
+          onOutput({
+            type: 'stderr',
+            content: `[Context cache warning: ${packResult.error}]\n`,
+            timestamp: new Date().toISOString()
+          });
         }
       }
     }
@@ -159,7 +173,8 @@ export async function executeLiteLLMEndpoint(
     if (onOutput) {
       onOutput({
         type: 'stderr',
-        data: `[LiteLLM: Calling ${provider.type}/${endpoint.model}]\n`,
+        content: `[LiteLLM: Calling ${provider.type}/${endpoint.model}]\n`,
+        timestamp: new Date().toISOString()
       });
     }
 
@@ -183,19 +198,31 @@ export async function executeLiteLLMEndpoint(
       }
     }
 
-    // Use litellm-client to call chat
-    const response = await callWithRetries(
-      () => client.chat(finalPrompt, endpoint.model),
-      {
-        maxRetries: options.maxRetries ?? 0,
-        baseDelayMs: options.retryBaseDelayMs ?? 1000,
-        onOutput,
-        rateLimitKey: `${provider.type}:${endpoint.model}`,
-      },
-    );
+    // Set custom headers from provider advanced settings
+    if (provider.advancedSettings?.customHeaders) {
+      process.env['CCW_LITELLM_EXTRA_HEADERS'] = JSON.stringify(provider.advancedSettings.customHeaders);
+    } else {
+      // Clear any previous custom headers
+      delete process.env['CCW_LITELLM_EXTRA_HEADERS'];
+    }
+
+    // Use litellm-client to call chat
+    const response = await callWithRetries(
+      () => client.chat(finalPrompt, endpoint.model),
+      {
+        maxRetries: options.maxRetries ?? 0,
+        baseDelayMs: options.retryBaseDelayMs ?? 1000,
+        onOutput,
+        rateLimitKey: `${provider.type}:${endpoint.model}`,
+      },
+    );
 
     if (onOutput) {
-      onOutput({ type: 'stdout', data: response });
+      onOutput({
+        type: 'stdout',
+        content: response,
+        timestamp: new Date().toISOString()
+      });
     }
 
     return {
@@ -209,7 +236,11 @@ export async function executeLiteLLMEndpoint(
   } catch (error) {
     const errorMsg = (error as Error).message;
     if (onOutput) {
-      onOutput({ type: 'stderr', data: `[LiteLLM error: ${errorMsg}]\n` });
+      onOutput({
+        type: 'stderr',
+        content: `[LiteLLM error: ${errorMsg}]\n`,
+        timestamp: new Date().toISOString()
+      });
     }
 
     return {
@@ -242,83 +273,84 @@ function getProviderEnvVarName(providerType: string): string | null {
 /**
  * Get environment variable name for provider base URL
  */
-function getProviderBaseUrlEnvVarName(providerType: string): string | null {
-  const envVarMap: Record<string, string> = {
-    openai: 'OPENAI_API_BASE',
-    anthropic: 'ANTHROPIC_API_BASE',
-    azure: 'AZURE_API_BASE',
-  };
-
-  return envVarMap[providerType] || null;
-}
-
-const rateLimitRetryQueueNextAt = new Map<string, number>();
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isRateLimitError(errorMessage: string): boolean {
-  return /429|rate limit|too many requests/i.test(errorMessage);
-}
-
-function isRetryableError(errorMessage: string): boolean {
-  // Never retry auth/config errors
-  if (/401|403|unauthorized|forbidden/i.test(errorMessage)) {
-    return false;
-  }
-
-  // Retry rate limits, transient server errors, and network timeouts
-  return /(429|500|502|503|504|timeout|timed out|econnreset|enotfound|econnrefused|socket hang up)/i.test(
-    errorMessage,
-  );
-}
-
-async function callWithRetries(
-  call: () => Promise<string>,
-  options: {
-    maxRetries: number;
-    baseDelayMs: number;
-    onOutput?: (data: { type: string; data: string }) => void;
-    rateLimitKey: string;
-  },
-): Promise<string> {
-  const { maxRetries, baseDelayMs, onOutput, rateLimitKey } = options;
-  let attempt = 0;
-
-  while (true) {
-    try {
-      return await call();
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-
-      if (attempt >= maxRetries || !isRetryableError(errorMessage)) {
-        throw err;
-      }
-
-      const delayMs = baseDelayMs * 2 ** attempt;
-
-      if (onOutput) {
-        onOutput({
-          type: 'stderr',
-          data: `[LiteLLM retry ${attempt + 1}/${maxRetries}: waiting ${delayMs}ms] ${errorMessage}\n`,
-        });
-      }
-
-      attempt += 1;
-
-      if (isRateLimitError(errorMessage)) {
-        const now = Date.now();
-        const earliestAt = now + delayMs;
-        const queuedAt = rateLimitRetryQueueNextAt.get(rateLimitKey) ?? 0;
-        const scheduledAt = Math.max(queuedAt, earliestAt);
-        rateLimitRetryQueueNextAt.set(rateLimitKey, scheduledAt + delayMs);
-
-        await sleep(scheduledAt - now);
-        continue;
-      }
-
-      await sleep(delayMs);
-    }
-  }
-}
+function getProviderBaseUrlEnvVarName(providerType: string): string | null {
+  const envVarMap: Record<string, string> = {
+    openai: 'OPENAI_API_BASE',
+    anthropic: 'ANTHROPIC_API_BASE',
+    azure: 'AZURE_API_BASE',
+  };
+
+  return envVarMap[providerType] || null;
+}
+
+const rateLimitRetryQueueNextAt = new Map<string, number>();
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isRateLimitError(errorMessage: string): boolean {
+  return /429|rate limit|too many requests/i.test(errorMessage);
+}
+
+function isRetryableError(errorMessage: string): boolean {
+  // Never retry auth/config errors
+  if (/401|403|unauthorized|forbidden/i.test(errorMessage)) {
+    return false;
+  }
+
+  // Retry rate limits, transient server errors, and network timeouts
+  return /(429|500|502|503|504|timeout|timed out|econnreset|enotfound|econnrefused|socket hang up)/i.test(
+    errorMessage,
+  );
+}
+
+async function callWithRetries(
+  call: () => Promise<string>,
+  options: {
+    maxRetries: number;
+    baseDelayMs: number;
+    onOutput?: (unit: CliOutputUnit) => void;
+    rateLimitKey: string;
+  },
+): Promise<string> {
+  const { maxRetries, baseDelayMs, onOutput, rateLimitKey } = options;
+  let attempt = 0;
+
+  while (true) {
+    try {
+      return await call();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+
+      if (attempt >= maxRetries || !isRetryableError(errorMessage)) {
+        throw err;
+      }
+
+      const delayMs = baseDelayMs * 2 ** attempt;
+
+      if (onOutput) {
+        onOutput({
+          type: 'stderr',
+          content: `[LiteLLM retry ${attempt + 1}/${maxRetries}: waiting ${delayMs}ms] ${errorMessage}\n`,
+          timestamp: new Date().toISOString()
+        });
+      }
+
+      attempt += 1;
+
+      if (isRateLimitError(errorMessage)) {
+        const now = Date.now();
+        const earliestAt = now + delayMs;
+        const queuedAt = rateLimitRetryQueueNextAt.get(rateLimitKey) ?? 0;
+        const scheduledAt = Math.max(queuedAt, earliestAt);
+        rateLimitRetryQueueNextAt.set(rateLimitKey, scheduledAt + delayMs);
+
+        await sleep(scheduledAt - now);
+        continue;
+      }
+
+      await sleep(delayMs);
+    }
+  }
+}

package/ccw/src/tools/native-session-discovery.ts

@@ -679,12 +679,207 @@ class ClaudeSessionDiscoverer extends SessionDiscoverer {
   }
 }
 
+/**
+ * OpenCode Session Discoverer
+ * Storage path: ~/.local/share/opencode/storage/ (all platforms)
+ * Structure:
+ *   session/<project-hash>/<session-id>.json  - Session metadata
+ *   message/<session-id>/<message-id>.json    - Message content
+ *   part/<message-id>/<part-id>.json          - Message parts
+ *   project/<project-hash>.json               - Project metadata
+ * https://opencode.ai/docs/config/
+ */
+class OpenCodeSessionDiscoverer extends SessionDiscoverer {
+  tool = 'opencode';
+  // Storage base path: ~/.local/share/opencode/storage
+  basePath = join(
+    process.env.USERPROFILE || getHomePath(),
+    '.local',
+    'share',
+    'opencode',
+    'storage'
+  );
+
+  private getProjectHash(workingDir: string): string | null {
+    // OpenCode uses SHA1 hash of the project directory path
+    const sessionDir = join(this.basePath, 'session');
+    if (!existsSync(sessionDir)) return null;
+
+    try {
+      const projectHashes = readdirSync(sessionDir).filter(d => {
+        const fullPath = join(sessionDir, d);
+        return statSync(fullPath).isDirectory();
+      });
+
+      if (projectHashes.length === 0) return null;
+
+      // If workingDir provided, try to find matching project
+      if (workingDir) {
+        const normalizedWorkDir = resolve(workingDir);
+        // Check project files for directory match
+        const projectDir = join(this.basePath, 'project');
+        if (existsSync(projectDir)) {
+          for (const hash of projectHashes) {
+            const projectFile = join(projectDir, `${hash}.json`);
+            if (existsSync(projectFile)) {
+              try {
+                const projectData = JSON.parse(readFileSync(projectFile, 'utf8'));
+                // Normalize path comparison for Windows
+                const projectPath = projectData.directory?.replace(/\\/g, '/').toLowerCase();
+                const targetPath = normalizedWorkDir.replace(/\\/g, '/').toLowerCase();
+                if (projectPath === targetPath) {
+                  return hash;
+                }
+              } catch {
+                // Skip invalid project files
+              }
+            }
+          }
+        }
+      }
+
+      // Return first available project hash if no match
+      return projectHashes[0];
+    } catch {
+      return null;
+    }
+  }
+
+  getSessions(options: SessionDiscoveryOptions = {}): NativeSession[] {
+    const { workingDir, limit, afterTimestamp } = options;
+    const sessions: NativeSession[] = [];
+
+    const sessionDir = join(this.basePath, 'session');
+    if (!existsSync(sessionDir)) return [];
+
+    try {
+      // Get all project directories or specific one
+      let projectHashes: string[];
+      if (workingDir) {
+        const hash = this.getProjectHash(workingDir);
+        projectHashes = hash ? [hash] : [];
+      } else {
+        projectHashes = readdirSync(sessionDir).filter(d => {
+          const fullPath = join(sessionDir, d);
+          return statSync(fullPath).isDirectory();
+        });
+      }
+
+      for (const projectHash of projectHashes) {
+        const projectSessionDir = join(sessionDir, projectHash);
+        if (!existsSync(projectSessionDir)) continue;
+
+        // Get all session files
+        const sessionFiles = readdirSync(projectSessionDir)
+          .filter(f => f.endsWith('.json'))
+          .map(f => ({
+            name: f,
+            path: join(projectSessionDir, f),
+            stat: statSync(join(projectSessionDir, f))
+          }))
+          .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+
+        for (const file of sessionFiles) {
+          if (afterTimestamp && file.stat.mtime <= afterTimestamp) continue;
+
+          try {
+            const sessionData = JSON.parse(readFileSync(file.path, 'utf8'));
+            sessions.push({
+              sessionId: sessionData.id || basename(file.name, '.json'),
+              tool: this.tool,
+              filePath: file.path,
+              projectHash,
+              createdAt: new Date(sessionData.time?.created || file.stat.birthtime),
+              updatedAt: new Date(sessionData.time?.updated || file.stat.mtime)
+            });
+          } catch {
+            // Skip invalid files
+          }
+        }
+      }
+
+      // Sort by updatedAt descending
+      sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+      return limit ? sessions.slice(0, limit) : sessions;
+    } catch {
+      return [];
+    }
+  }
+
+  findSessionById(sessionId: string): NativeSession | null {
+    const sessions = this.getSessions();
+    return sessions.find(s => s.sessionId === sessionId) || null;
+  }
+
+  /**
+   * Extract first user message from OpenCode session
+   * Messages are stored in: message/<session-id>/<message-id>.json
+   * Format: { id, sessionID, role, time }
+   * Content is in parts: part/<message-id>/<part-id>.json
+   */
+  extractFirstUserMessage(filePath: string): string | null {
+    try {
+      // filePath is the session JSON file
+      const sessionData = JSON.parse(readFileSync(filePath, 'utf8'));
+      const sessionId = sessionData.id;
+      if (!sessionId) return null;
+
+      // Find messages for this session
+      const messageDir = join(this.basePath, 'message', sessionId);
+      if (!existsSync(messageDir)) return null;
+
+      // Get message files sorted by time
+      const messageFiles = readdirSync(messageDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => ({
+          name: f,
+          path: join(messageDir, f)
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+
+      for (const msgFile of messageFiles) {
+        try {
+          const msgData = JSON.parse(readFileSync(msgFile.path, 'utf8'));
+          if (msgData.role === 'user') {
+            // Get content from parts
+            const partDir = join(this.basePath, 'part', msgData.id);
+            if (existsSync(partDir)) {
+              const partFiles = readdirSync(partDir)
+                .filter(f => f.endsWith('.json'))
+                .sort();
+
+              for (const partFile of partFiles) {
+                try {
+                  const partData = JSON.parse(readFileSync(join(partDir, partFile), 'utf8'));
+                  if (partData.type === 'text' && partData.text) {
+                    return partData.text;
+                  }
+                } catch {
+                  // Skip invalid parts
+                }
+              }
+            }
+            // Fallback to title if available
+            return msgData.summary?.title || sessionData.title || null;
+          }
+        } catch {
+          // Skip invalid messages
+        }
+      }
+      return sessionData.title || null;
+    } catch {
+      return null;
+    }
+  }
+}
+
 // Singleton discoverers
 const discoverers: Record<string, SessionDiscoverer> = {
   gemini: new GeminiSessionDiscoverer(),
   qwen: new QwenSessionDiscoverer(),
   codex: new CodexSessionDiscoverer(),
-  claude: new ClaudeSessionDiscoverer()
+  claude: new ClaudeSessionDiscoverer(),
+  opencode: new OpenCodeSessionDiscoverer()
 };
 
 /**
@@ -750,8 +945,14 @@ export function getNativeSessions(
 
 /**
  * Check if a tool supports native resume
+ * Note: codex is excluded because `codex resume` requires a TTY (terminal)
+ * which doesn't work in spawn() context. Codex uses prompt-concat mode instead.
  */
 export function supportsNativeResume(tool: string): boolean {
+  // codex resume requires TTY - use prompt-concat mode instead
+  if (tool === 'codex') {
+    return false;
+  }
   return tool in discoverers;
 }
 
@@ -781,6 +982,13 @@ export function getNativeResumeArgs(
       }
       return ['resume', sessionId];
 
+    case 'opencode':
+      // opencode run --continue (latest) or --session <uuid>
+      if (sessionId === 'latest') {
+        return ['--continue'];
+      }
+      return ['--session', sessionId];
+
     default:
       return [];
   }

package/ccw/src/tools/session-manager.ts

@@ -696,6 +696,23 @@ function executeArchive(params: Params): any {
         } catch { /* continue */ }
       }
     }
+
+    // Update all task JSONs to completed status
+    const taskDir = join(session.path, '.task');
+    if (existsSync(taskDir)) {
+      const taskFiles = readdirSync(taskDir).filter(f => f.endsWith('.json'));
+      for (const taskFile of taskFiles) {
+        try {
+          const taskPath = join(taskDir, taskFile);
+          const taskData = readJsonFile(taskPath);
+          if (taskData.status && taskData.status !== 'completed') {
+            taskData.status = 'completed';
+            taskData.completed_at = new Date().toISOString();
+            writeJsonFile(taskPath, taskData);
+          }
+        } catch { /* skip invalid task files */ }
+      }
+    }
   }
 
   // Ensure archive directory exists
@@ -720,6 +737,11 @@ function executeArchive(params: Params): any {
     }
   }
 
+  // Update development index with archived session info
+  if (sessionMetadata) {
+    updateDevelopmentIndex(sessionMetadata);
+  }
+
   return {
     operation: 'archive',
     session_id,
@@ -886,6 +908,72 @@ function executeStats(params: Params): any {
   };
 }
 
+/**
+ * Updates the project's development index when a session is archived.
+ * Simplified: only appends entries, does NOT manage statistics.
+ * Dashboard aggregator handles dynamic calculation.
+ */
+function updateDevelopmentIndex(sessionMetadata: any): void {
+  if (!sessionMetadata || !sessionMetadata.session_id) {
+    console.warn('Skipping development index update due to missing session metadata.');
+    return;
+  }
+
+  const root = findWorkflowRoot();
+  const projectTechFile = join(root, WORKFLOW_BASE, 'project-tech.json');
+
+  if (!existsSync(projectTechFile)) {
+    console.warn(`Skipping development index update: ${projectTechFile} not found.`);
+    return;
+  }
+
+  try {
+    const projectData = readJsonFile(projectTechFile);
+
+    // Ensure development_index exists
+    if (!projectData.development_index) {
+      projectData.development_index = { feature: [], enhancement: [], bugfix: [], refactor: [], docs: [] };
+    }
+
+    // Type inference from description
+    const description = (sessionMetadata.description || '').toLowerCase();
+    let devType: 'feature' | 'enhancement' | 'bugfix' | 'refactor' | 'docs' = 'enhancement';
+
+    if (sessionMetadata.type === 'docs') {
+      devType = 'docs';
+    } else if (/\b(fix|bug|resolve)\b/.test(description)) {
+      devType = 'bugfix';
+    } else if (/\b(feature|implement|add|create)\b/.test(description)) {
+      devType = 'feature';
+    } else if (/\b(refactor|restructure|cleanup)\b/.test(description)) {
+      devType = 'refactor';
+    }
+
+    const entry = {
+      title: sessionMetadata.description || sessionMetadata.project || sessionMetadata.session_id,
+      sessionId: sessionMetadata.session_id,
+      type: devType,
+      tags: sessionMetadata.tags || [],
+      archivedAt: sessionMetadata.archived_at || new Date().toISOString(),
+    };
+
+    // Append to correct category
+    if (!projectData.development_index[devType]) {
+      projectData.development_index[devType] = [];
+    }
+    projectData.development_index[devType].push(entry);
+
+    // CRITICAL: Do NOT touch projectData.statistics
+    // Dashboard aggregator handles dynamic calculation
+
+    writeJsonFile(projectTechFile, projectData);
+    console.log(`Development index updated for session: ${sessionMetadata.session_id}`);
+
+  } catch (error) {
+    console.error(`Failed to update development index: ${(error as Error).message}`);
+  }
+}
+
 // ============================================================
 // Main Execute Function
 // ============================================================