claude-code-workflow 6.2.7 → 6.3.0

package/ccw/src/commands/cli.ts

@@ -78,6 +78,14 @@ interface CliExecOptions {
   resume?: string | boolean; // true = last, string = execution ID, comma-separated for merge
   id?: string; // Custom execution ID (e.g., IMPL-001-step1)
   noNative?: boolean; // Force prompt concatenation instead of native resume
+  cache?: string | boolean; // Cache: true = auto from CONTEXT, string = comma-separated patterns/content
+  injectMode?: 'none' | 'full' | 'progressive'; // Inject mode for cached content
+}
+
+/** Cache configuration parsed from --cache */
+interface CacheConfig {
+  patterns?: string[];       // @patterns to pack (items starting with @)
+  content?: string;          // Additional text content (items not starting with @)
 }
 
 interface HistoryOptions {
@@ -91,7 +99,7 @@ interface StorageOptions {
   project?: string;
   cliHistory?: boolean;
   memory?: boolean;
-  cache?: boolean;
+  storageCache?: boolean;
   config?: boolean;
   force?: boolean;
 }
@@ -173,15 +181,15 @@ async function showStorageInfo(): Promise<void> {
  * Clean storage
  */
 async function cleanStorage(options: StorageOptions): Promise<void> {
-  const { all, project, force, cliHistory, memory, cache, config } = options;
+  const { all, project, force, cliHistory, memory, storageCache, config } = options;
 
   // Determine what to clean
   const cleanTypes = {
-    cliHistory: cliHistory || (!cliHistory && !memory && !cache && !config),
-    memory: memory || (!cliHistory && !memory && !cache && !config),
-    cache: cache || (!cliHistory && !memory && !cache && !config),
+    cliHistory: cliHistory || (!cliHistory && !memory && !storageCache && !config),
+    memory: memory || (!cliHistory && !memory && !storageCache && !config),
+    cache: storageCache || (!cliHistory && !memory && !storageCache && !config),
     config: config || false, // Config requires explicit flag
-    all: !cliHistory && !memory && !cache && !config
+    all: !cliHistory && !memory && !storageCache && !config
   };
 
   if (project) {
@@ -383,7 +391,7 @@ async function statusAction(): Promise<void> {
  * @param {Object} options - CLI options
  */
 async function execAction(positionalPrompt: string | undefined, options: CliExecOptions): Promise<void> {
-  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, timeout, noStream, resume, id, noNative } = options;
+  const { prompt: optionPrompt, file, tool = 'gemini', mode = 'analysis', model, cd, includeDirs, timeout, noStream, resume, id, noNative, cache, injectMode } = options;
 
   // Priority: 1. --file, 2. --prompt/-p option, 3. positional argument
   let finalPrompt: string | undefined;
@@ -421,6 +429,128 @@ async function execAction(positionalPrompt: string | undefined, options: CliExec
 
   const prompt_to_use = finalPrompt || '';
 
+  // Handle cache option: pack @patterns and/or content
+  let cacheSessionId: string | undefined;
+  let actualPrompt = prompt_to_use;
+
+  if (cache) {
+    const { handler: contextCacheHandler } = await import('../tools/context-cache.js');
+
+    // Parse cache config from comma-separated string
+    // Items starting with @ are patterns, others are text content
+    let cacheConfig: CacheConfig = {};
+
+    if (cache === true) {
+      // --cache without value: auto-extract from CONTEXT field
+      const contextMatch = prompt_to_use.match(/CONTEXT:\s*([^\n]+)/i);
+      if (contextMatch) {
+        const contextLine = contextMatch[1];
+        const patternMatches = contextLine.matchAll(/@[^\s|]+/g);
+        cacheConfig.patterns = Array.from(patternMatches).map(m => m[0]);
+      }
+    } else if (typeof cache === 'string') {
+      // Parse comma-separated items: @patterns and text content
+      const items = cache.split(',').map(s => s.trim()).filter(Boolean);
+      const patterns: string[] = [];
+      const contentParts: string[] = [];
+
+      for (const item of items) {
+        if (item.startsWith('@')) {
+          patterns.push(item);
+        } else {
+          contentParts.push(item);
+        }
+      }
+
+      if (patterns.length > 0) {
+        cacheConfig.patterns = patterns;
+      }
+      if (contentParts.length > 0) {
+        cacheConfig.content = contentParts.join('\n');
+      }
+    }
+
+    // Also extract patterns from CONTEXT if not provided
+    if ((!cacheConfig.patterns || cacheConfig.patterns.length === 0) && prompt_to_use) {
+      const contextMatch = prompt_to_use.match(/CONTEXT:\s*([^\n]+)/i);
+      if (contextMatch) {
+        const contextLine = contextMatch[1];
+        const patternMatches = contextLine.matchAll(/@[^\s|]+/g);
+        cacheConfig.patterns = Array.from(patternMatches).map(m => m[0]);
+      }
+    }
+
+    // Pack if we have patterns or content
+    if ((cacheConfig.patterns && cacheConfig.patterns.length > 0) || cacheConfig.content) {
+      const patternCount = cacheConfig.patterns?.length || 0;
+      const hasContent = !!cacheConfig.content;
+      console.log(chalk.gray(`  Caching: ${patternCount} pattern(s)${hasContent ? ' + text content' : ''}...`));
+
+      const cacheResult = await contextCacheHandler({
+        operation: 'pack',
+        patterns: cacheConfig.patterns,
+        content: cacheConfig.content,
+        cwd: cd || process.cwd(),
+        include_dirs: includeDirs ? includeDirs.split(',') : undefined,
+      });
+
+      if (cacheResult.success && cacheResult.result) {
+        const packResult = cacheResult.result as { session_id: string; files_packed: number; total_bytes: number };
+        cacheSessionId = packResult.session_id;
+        console.log(chalk.gray(`  Cached: ${packResult.files_packed} files, ${packResult.total_bytes} bytes`));
+        console.log(chalk.gray(`  Session: ${cacheSessionId}`));
+
+        // Determine inject mode:
+        // --inject-mode explicitly set > tool default (codex=full, others=none)
+        const effectiveInjectMode = injectMode ?? (tool === 'codex' ? 'full' : 'none');
+
+        if (effectiveInjectMode !== 'none' && cacheSessionId) {
+          if (effectiveInjectMode === 'full') {
+            // Read full cache content
+            const readResult = await contextCacheHandler({
+              operation: 'read',
+              session_id: cacheSessionId,
+              offset: 0,
+              limit: 1024 * 1024, // 1MB max
+            });
+
+            if (readResult.success && readResult.result) {
+              const { content: cachedContent, total_bytes } = readResult.result as { content: string; total_bytes: number };
+              console.log(chalk.gray(`  Injecting ${total_bytes} bytes (full mode)...`));
+              actualPrompt = `=== CACHED CONTEXT (${packResult.files_packed} files) ===\n${cachedContent}\n\n=== USER PROMPT ===\n${prompt_to_use}`;
+            }
+          } else if (effectiveInjectMode === 'progressive') {
+            // Progressive mode: read first page only (64KB default)
+            const pageLimit = 65536;
+            const readResult = await contextCacheHandler({
+              operation: 'read',
+              session_id: cacheSessionId,
+              offset: 0,
+              limit: pageLimit,
+            });
+
+            if (readResult.success && readResult.result) {
+              const { content: cachedContent, total_bytes, has_more, next_offset } = readResult.result as {
+                content: string; total_bytes: number; has_more: boolean; next_offset: number | null
+              };
+              console.log(chalk.gray(`  Injecting ${cachedContent.length}/${total_bytes} bytes (progressive mode)...`));
+
+              const moreInfo = has_more
+                ? `\n[... ${total_bytes - cachedContent.length} more bytes available via: context_cache(operation="read", session_id="${cacheSessionId}", offset=${next_offset}) ...]`
+                : '';
+
+              actualPrompt = `=== CACHED CONTEXT (${packResult.files_packed} files, progressive) ===\n${cachedContent}${moreInfo}\n\n=== USER PROMPT ===\n${prompt_to_use}`;
+            }
+          }
+        }
+
+        console.log();
+      } else {
+        console.log(chalk.yellow(`  Cache warning: ${cacheResult.error}`));
+      }
+    }
+  }
+
   // Parse resume IDs for merge scenario
   const resumeIds = resume && typeof resume === 'string' ? resume.split(',').map(s => s.trim()).filter(Boolean) : [];
   const isMerge = resumeIds.length > 1;
@@ -462,7 +592,7 @@ async function execAction(positionalPrompt: string | undefined, options: CliExec
   try {
     const result = await cliExecutorTool.execute({
       tool,
-      prompt: prompt_to_use,
+      prompt: actualPrompt,
       mode,
       model,
       cd,
@@ -725,14 +855,28 @@ export async function cliCommand(
         console.log(chalk.gray('    --model <model>     Model override'));
         console.log(chalk.gray('    --cd <path>         Working directory'));
         console.log(chalk.gray('    --includeDirs <dirs>  Additional directories'));
-        console.log(chalk.gray('    --timeout <ms>      Timeout (default: 300000)'));
+        console.log(chalk.gray('    --timeout <ms>      Timeout (default: 0=disabled)'));
         console.log(chalk.gray('    --resume [id]       Resume previous session'));
+        console.log(chalk.gray('    --cache <items>     Cache: comma-separated @patterns and text'));
+        console.log(chalk.gray('    --inject-mode <m>   Inject mode: none, full, progressive'));
+        console.log();
+        console.log('  Cache format:');
+        console.log(chalk.gray('    --cache "@src/**/*.ts,@CLAUDE.md"     # @patterns to pack'));
+        console.log(chalk.gray('    --cache "@src/**/*,extra context"     # patterns + text content'));
+        console.log(chalk.gray('    --cache                               # auto from CONTEXT field'));
+        console.log();
+        console.log('  Inject modes:');
+        console.log(chalk.gray('    none:        cache only, no injection (default for gemini/qwen)'));
+        console.log(chalk.gray('    full:        inject all cached content (default for codex)'));
+        console.log(chalk.gray('    progressive: inject first 64KB with MCP continuation hint'));
         console.log();
         console.log('  Examples:');
         console.log(chalk.gray('    ccw cli -p "Analyze auth module" --tool gemini'));
         console.log(chalk.gray('    ccw cli -f prompt.txt --tool codex --mode write'));
         console.log(chalk.gray('    ccw cli -p "$(cat template.md)" --tool gemini'));
         console.log(chalk.gray('    ccw cli --resume --tool gemini'));
+        console.log(chalk.gray('    ccw cli -p "..." --cache "@src/**/*.ts" --tool codex'));
+        console.log(chalk.gray('    ccw cli -p "..." --cache "@src/**/*" --inject-mode progressive --tool gemini'));
         console.log();
       }
     }

package/ccw/src/commands/hook.ts

@@ -6,7 +6,7 @@
 import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
-import { tmpdir } from 'os';
+import { homedir } from 'os';
 
 interface HookOptions {
   stdin?: boolean;
@@ -53,9 +53,10 @@ async function readStdin(): Promise<string> {
 
 /**
  * Get session state file path
+ * Uses ~/.claude/.ccw-sessions/ for reliable persistence across sessions
  */
 function getSessionStateFile(sessionId: string): string {
-  const stateDir = join(tmpdir(), '.ccw-sessions');
+  const stateDir = join(homedir(), '.claude', '.ccw-sessions');
   if (!existsSync(stateDir)) {
     mkdirSync(stateDir, { recursive: true });
   }

package/ccw/src/config/.litellm-api-config-manager.ts.2025-12-23T11-57-43-727Z.bak

@@ -0,0 +1,441 @@
+/**
+ * LiteLLM API Config Manager
+ * Manages provider credentials, endpoint configurations, and model discovery
+ */
+
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+
+// ===========================
+// Type Definitions
+// ===========================
+
+export type ProviderType =
+  | 'openai'
+  | 'anthropic'
+  | 'google'
+  | 'cohere'
+  | 'azure'
+  | 'bedrock'
+  | 'vertexai'
+  | 'huggingface'
+  | 'ollama'
+  | 'custom';
+
+export interface ProviderCredential {
+  id: string;
+  name: string;
+  type: ProviderType;
+  apiKey?: string;
+  baseUrl?: string;
+  apiVersion?: string;
+  region?: string;
+  projectId?: string;
+  organizationId?: string;
+  enabled: boolean;
+  metadata?: Record<string, any>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface EndpointConfig {
+  id: string;
+  name: string;
+  providerId: string;
+  model: string;
+  alias?: string;
+  temperature?: number;
+  maxTokens?: number;
+  topP?: number;
+  enabled: boolean;
+  metadata?: Record<string, any>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  provider: ProviderType;
+  contextWindow: number;
+  supportsFunctions: boolean;
+  supportsStreaming: boolean;
+  inputCostPer1k?: number;
+  outputCostPer1k?: number;
+}
+
+export interface LiteLLMApiConfig {
+  version: string;
+  providers: ProviderCredential[];
+  endpoints: EndpointConfig[];
+}
+
+// ===========================
+// Model Definitions
+// ===========================
+
+export const PROVIDER_MODELS: Record<ProviderType, ModelInfo[]> = {
+  openai: [
+    {
+      id: 'gpt-4-turbo',
+      name: 'GPT-4 Turbo',
+      provider: 'openai',
+      contextWindow: 128000,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.01,
+      outputCostPer1k: 0.03,
+    },
+    {
+      id: 'gpt-4',
+      name: 'GPT-4',
+      provider: 'openai',
+      contextWindow: 8192,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.03,
+      outputCostPer1k: 0.06,
+    },
+    {
+      id: 'gpt-3.5-turbo',
+      name: 'GPT-3.5 Turbo',
+      provider: 'openai',
+      contextWindow: 16385,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.0005,
+      outputCostPer1k: 0.0015,
+    },
+  ],
+  anthropic: [
+    {
+      id: 'claude-3-opus-20240229',
+      name: 'Claude 3 Opus',
+      provider: 'anthropic',
+      contextWindow: 200000,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.015,
+      outputCostPer1k: 0.075,
+    },
+    {
+      id: 'claude-3-sonnet-20240229',
+      name: 'Claude 3 Sonnet',
+      provider: 'anthropic',
+      contextWindow: 200000,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.003,
+      outputCostPer1k: 0.015,
+    },
+    {
+      id: 'claude-3-haiku-20240307',
+      name: 'Claude 3 Haiku',
+      provider: 'anthropic',
+      contextWindow: 200000,
+      supportsFunctions: true,
+      supportsStreaming: true,
+      inputCostPer1k: 0.00025,
+      outputCostPer1k: 0.00125,
+    },
+  ],
+  google: [
+    {
+      id: 'gemini-pro',
+      name: 'Gemini Pro',
+      provider: 'google',
+      contextWindow: 32768,
+      supportsFunctions: true,
+      supportsStreaming: true,
+    },
+    {
+      id: 'gemini-pro-vision',
+      name: 'Gemini Pro Vision',
+      provider: 'google',
+      contextWindow: 16384,
+      supportsFunctions: false,
+      supportsStreaming: true,
+    },
+  ],
+  cohere: [
+    {
+      id: 'command',
+      name: 'Command',
+      provider: 'cohere',
+      contextWindow: 4096,
+      supportsFunctions: false,
+      supportsStreaming: true,
+    },
+    {
+      id: 'command-light',
+      name: 'Command Light',
+      provider: 'cohere',
+      contextWindow: 4096,
+      supportsFunctions: false,
+      supportsStreaming: true,
+    },
+  ],
+  azure: [],
+  bedrock: [],
+  vertexai: [],
+  huggingface: [],
+  ollama: [],
+  custom: [],
+};
+
+// ===========================
+// Config File Management
+// ===========================
+
+const CONFIG_DIR = join(homedir(), '.claude', 'litellm');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function loadConfig(): LiteLLMApiConfig {
+  ensureConfigDir();
+
+  if (!existsSync(CONFIG_FILE)) {
+    const defaultConfig: LiteLLMApiConfig = {
+      version: '1.0.0',
+      providers: [],
+      endpoints: [],
+    };
+    saveConfig(defaultConfig);
+    return defaultConfig;
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(`Failed to load config: ${(err as Error).message}`);
+  }
+}
+
+function saveConfig(config: LiteLLMApiConfig): void {
+  ensureConfigDir();
+
+  try {
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  } catch (err) {
+    throw new Error(`Failed to save config: ${(err as Error).message}`);
+  }
+}
+
+// ===========================
+// Provider Management
+// ===========================
+
+export function getAllProviders(): ProviderCredential[] {
+  const config = loadConfig();
+  return config.providers;
+}
+
+export function getProvider(id: string): ProviderCredential | null {
+  const config = loadConfig();
+  return config.providers.find((p) => p.id === id) || null;
+}
+
+export function createProvider(
+  data: Omit<ProviderCredential, 'id' | 'createdAt' | 'updatedAt'>
+): ProviderCredential {
+  const config = loadConfig();
+
+  const now = new Date().toISOString();
+  const provider: ProviderCredential = {
+    ...data,
+    id: `provider-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  config.providers.push(provider);
+  saveConfig(config);
+
+  return provider;
+}
+
+export function updateProvider(
+  id: string,
+  updates: Partial<ProviderCredential>
+): ProviderCredential | null {
+  const config = loadConfig();
+
+  const index = config.providers.findIndex((p) => p.id === id);
+  if (index === -1) {
+    return null;
+  }
+
+  const updated: ProviderCredential = {
+    ...config.providers[index],
+    ...updates,
+    id,
+    updatedAt: new Date().toISOString(),
+  };
+
+  config.providers[index] = updated;
+  saveConfig(config);
+
+  return updated;
+}
+
+export function deleteProvider(id: string): { success: boolean } {
+  const config = loadConfig();
+
+  const index = config.providers.findIndex((p) => p.id === id);
+  if (index === -1) {
+    return { success: false };
+  }
+
+  config.providers.splice(index, 1);
+
+  // Also delete endpoints using this provider
+  config.endpoints = config.endpoints.filter((e) => e.providerId !== id);
+
+  saveConfig(config);
+
+  return { success: true };
+}
+
+export async function testProviderConnection(
+  providerId: string
+): Promise<{ success: boolean; error?: string }> {
+  const provider = getProvider(providerId);
+
+  if (!provider) {
+    return { success: false, error: 'Provider not found' };
+  }
+
+  if (!provider.enabled) {
+    return { success: false, error: 'Provider is disabled' };
+  }
+
+  // Basic validation
+  if (!provider.apiKey && provider.type !== 'ollama' && provider.type !== 'custom') {
+    return { success: false, error: 'API key is required for this provider type' };
+  }
+
+  // TODO: Implement actual provider connection testing using litellm-client
+  // For now, just validate the configuration
+  return { success: true };
+}
+
+// ===========================
+// Endpoint Management
+// ===========================
+
+export function getAllEndpoints(): EndpointConfig[] {
+  const config = loadConfig();
+  return config.endpoints;
+}
+
+export function getEndpoint(id: string): EndpointConfig | null {
+  const config = loadConfig();
+  return config.endpoints.find((e) => e.id === id) || null;
+}
+
+export function createEndpoint(
+  data: Omit<EndpointConfig, 'id' | 'createdAt' | 'updatedAt'>
+): EndpointConfig {
+  const config = loadConfig();
+
+  // Validate provider exists
+  const provider = config.providers.find((p) => p.id === data.providerId);
+  if (!provider) {
+    throw new Error('Provider not found');
+  }
+
+  const now = new Date().toISOString();
+  const endpoint: EndpointConfig = {
+    ...data,
+    id: `endpoint-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  config.endpoints.push(endpoint);
+  saveConfig(config);
+
+  return endpoint;
+}
+
+export function updateEndpoint(
+  id: string,
+  updates: Partial<EndpointConfig>
+): EndpointConfig | null {
+  const config = loadConfig();
+
+  const index = config.endpoints.findIndex((e) => e.id === id);
+  if (index === -1) {
+    return null;
+  }
+
+  // Validate provider if being updated
+  if (updates.providerId) {
+    const provider = config.providers.find((p) => p.id === updates.providerId);
+    if (!provider) {
+      throw new Error('Provider not found');
+    }
+  }
+
+  const updated: EndpointConfig = {
+    ...config.endpoints[index],
+    ...updates,
+    id,
+    updatedAt: new Date().toISOString(),
+  };
+
+  config.endpoints[index] = updated;
+  saveConfig(config);
+
+  return updated;
+}
+
+export function deleteEndpoint(id: string): { success: boolean } {
+  const config = loadConfig();
+
+  const index = config.endpoints.findIndex((e) => e.id === id);
+  if (index === -1) {
+    return { success: false };
+  }
+
+  config.endpoints.splice(index, 1);
+  saveConfig(config);
+
+  return { success: true };
+}
+
+// ===========================
+// Model Discovery
+// ===========================
+
+export function getModelsForProviderType(providerType: ProviderType): ModelInfo[] | null {
+  return PROVIDER_MODELS[providerType] || null;
+}
+
+export function getAllModels(): Record<ProviderType, ModelInfo[]> {
+  return PROVIDER_MODELS;
+}
+
+// ===========================
+// Config Access
+// ===========================
+
+export function getFullConfig(): LiteLLMApiConfig {
+  return loadConfig();
+}
+
+export function resetConfig(): void {
+  const defaultConfig: LiteLLMApiConfig = {
+    version: '1.0.0',
+    providers: [],
+    endpoints: [],
+  };
+  saveConfig(defaultConfig);
+}