@kosuke-ai/cli 0.0.43 → 0.0.45

package/dist/kosuke/utils/claude-agent.js

@@ -5,24 +5,232 @@
  * for all commands that use Claude Code Agent SDK.
  */
 import { query, } from '@anthropic-ai/claude-agent-sdk';
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 /**
- * Calculate cost based on Claude Sonnet 4.5 pricing
- * - $3 per million input tokens
- * - $15 per million output tokens
- * - $3.75 per million cache creation tokens (input + 25% overhead)
- * - $0.30 per million cache read tokens (90% discount from input)
+ * Load costs configuration from claude.costs.json
  */
-export function calculateCost(inputTokens, outputTokens, cacheCreationTokens = 0, cacheReadTokens = 0) {
-    const INPUT_COST_PER_MILLION = 3.0;
-    const OUTPUT_COST_PER_MILLION = 15.0;
-    const CACHE_CREATION_COST_PER_MILLION = 3.75;
-    const CACHE_READ_COST_PER_MILLION = 0.3;
-    const inputCost = (inputTokens / 1000000) * INPUT_COST_PER_MILLION;
-    const outputCost = (outputTokens / 1000000) * OUTPUT_COST_PER_MILLION;
-    const cacheCreationCost = (cacheCreationTokens / 1000000) * CACHE_CREATION_COST_PER_MILLION;
-    const cacheReadCost = (cacheReadTokens / 1000000) * CACHE_READ_COST_PER_MILLION;
+let costsCache = null;
+function loadCosts() {
+    if (costsCache)
+        return costsCache;
+    try {
+        // Look for claude.costs.json in the package root (three levels up from dist/kosuke/utils)
+        const costsPath = join(__dirname, '..', '..', '..', 'claude.costs.json');
+        const costsContent = readFileSync(costsPath, 'utf-8');
+        costsCache = JSON.parse(costsContent);
+        return costsCache;
+    }
+    catch {
+        // Fallback to default Haiku costs if file not found
+        return {
+            models: {},
+            default: {
+                name: 'Claude Haiku 4.5',
+                input: 1.0,
+                output: 5.0,
+                cacheCreation: 1.25,
+                cacheRead: 0.1,
+            },
+        };
+    }
+}
+/**
+ * Get cost configuration for a specific model
+ */
+function getModelCosts(model) {
+    const costs = loadCosts();
+    return costs.models[model] || costs.default;
+}
+/**
+ * Parse tool usage into structured action and params for streaming/display
+ *
+ * @param toolName - Name of the tool being used
+ * @param toolInput - Input parameters for the tool
+ * @returns Structured action and params object
+ *
+ * @example
+ * parseToolAction('Read', { file_path: '/path/to/file.ts' })
+ * // Returns: { action: 'Read', params: { path: '/path/to/file.ts' } }
+ */
+export function parseToolAction(toolName, toolInput) {
+    const params = {};
+    switch (toolName) {
+        case 'Read':
+            params.path = toolInput.file_path || toolInput.target_file;
+            break;
+        case 'Grep':
+            params.pattern = toolInput.pattern;
+            if (toolInput.type)
+                params.type = toolInput.type;
+            if (toolInput.glob)
+                params.glob = toolInput.glob;
+            if (toolInput.path)
+                params.path = toolInput.path;
+            break;
+        case 'Glob':
+            params.pattern = toolInput.glob_pattern || toolInput.pattern;
+            if (toolInput.target_directory)
+                params.directory = toolInput.target_directory;
+            break;
+        case 'LS':
+            params.path = toolInput.target_directory;
+            break;
+        case 'Task':
+            {
+                const description = toolInput.description;
+                params.description = description;
+                if (toolInput.subagent_type)
+                    params.type = toolInput.subagent_type;
+            }
+            break;
+        case 'WebSearch':
+            params.query = toolInput.search_term;
+            break;
+        case 'WebFetch':
+            {
+                const url = toolInput.url;
+                params.url = url;
+                if (url) {
+                    try {
+                        params.domain = new URL(url).hostname;
+                    }
+                    catch {
+                        params.domain = undefined;
+                    }
+                }
+            }
+            break;
+        case 'Edit':
+        case 'StrReplace':
+        case 'Write':
+        case 'Delete':
+            params.path = toolInput.file_path || toolInput.path;
+            break;
+        case 'Bash':
+        case 'Shell':
+            {
+                const command = toolInput.command;
+                params.command = command;
+            }
+            break;
+        case 'CodebaseSearch':
+            params.query = toolInput.query;
+            if (toolInput.target_directories) {
+                params.directories = toolInput.target_directories;
+            }
+            break;
+        default:
+            // For unknown tools, include all input params as fallback
+            Object.assign(params, toolInput);
+            break;
+    }
+    return { action: toolName, params };
+}
+/**
+ * Check if a tool is a file modification tool
+ * Based on actual tool names used in the codebase
+ */
+function isFileModificationTool(toolName) {
+    return (toolName === 'Write' ||
+        toolName === 'StrReplace' ||
+        toolName === 'Edit' ||
+        toolName === 'Delete');
+}
+/**
+ * Log tool usage
+ */
+export function logToolUsage(toolName, toolInput, filesReferenced) {
+    // Parse tool action using shared utility (handles normalization and params)
+    const input = toolInput && typeof toolInput === 'object' ? toolInput : {};
+    const parsed = parseToolAction(toolName, input);
+    // Track file references for Read operations
+    if (parsed.action === 'Read' && parsed.params.path) {
+        filesReferenced.add(parsed.params.path);
+    }
+    // Format log output based on tool type
+    let logMsg = '';
+    switch (parsed.action) {
+        case 'Write':
+            logMsg = `   ✍️  Writing ${parsed.params.path || 'file'}`;
+            break;
+        case 'StrReplace':
+        case 'Edit':
+            logMsg = `   ✏️  Editing ${parsed.params.path || 'file'}`;
+            break;
+        case 'Delete':
+            logMsg = `   🗑️  Deleting ${parsed.params.path || 'file'}`;
+            break;
+        case 'Read':
+            logMsg = `   📄 Reading ${parsed.params.path || 'file'}`;
+            break;
+        case 'Grep':
+            {
+                const pathInfo = parsed.params.path ? ` in ${parsed.params.path}` : '';
+                logMsg = `   🔍 Searching: ${parsed.params.pattern}${pathInfo}`;
+            }
+            break;
+        case 'Glob':
+            {
+                const dirInfo = parsed.params.directory ? ` in ${parsed.params.directory}` : '';
+                logMsg = `   📁 Finding: ${parsed.params.pattern}${dirInfo}`;
+            }
+            break;
+        case 'LS':
+            logMsg = `   📂 Listing: ${parsed.params.path || 'directory'}`;
+            break;
+        case 'Task':
+            {
+                const taskType = parsed.params.type || 'Task';
+                logMsg = `   🤖 ${taskType}: ${parsed.params.description || ''}`;
+            }
+            break;
+        case 'WebSearch':
+            logMsg = `   🌐 Search: ${parsed.params.query}`;
+            break;
+        case 'WebFetch':
+            logMsg = `   🌐 Fetching: ${parsed.params.domain || parsed.params.url}`;
+            break;
+        case 'Bash':
+        case 'Shell':
+            {
+                const cmd = parsed.params.command;
+                logMsg = `   💻 Running: ${cmd}`;
+            }
+            break;
+        case 'CodebaseSearch':
+            {
+                const dirInfo = parsed.params.directories && Array.isArray(parsed.params.directories)
+                    ? ` in ${parsed.params.directories.join(', ')}`
+                    : '';
+                logMsg = `   🔎 Codebase search: ${parsed.params.query || 'query'}${dirInfo}`;
+            }
+            break;
+        default:
+            // Fallback: show full tool info for unknown tools
+            const args = formatToolArgs(toolInput);
+            logMsg = `   🔧 ${parsed.action}(${args})`;
+            break;
+    }
+    console.log(logMsg);
+}
+/**
+ * Calculate cost based on Claude pricing from claude.costs.json
+ *
+ * Costs are loaded from:
+ * 1. claude.costs.json model-specific costs (if model provided)
+ * 2. claude.costs.json default costs (fallback)
+ */
+export function calculateCost(inputTokens, outputTokens, cacheCreationTokens = 0, cacheReadTokens = 0, model) {
+    // Get costs from JSON (uses model if provided, otherwise default)
+    const costs = model ? getModelCosts(model) : loadCosts().default;
+    const inputCost = (inputTokens / 1000000) * costs.input;
+    const outputCost = (outputTokens / 1000000) * costs.output;
+    const cacheCreationCost = (cacheCreationTokens / 1000000) * costs.cacheCreation;
+    const cacheReadCost = (cacheReadTokens / 1000000) * costs.cacheRead;
     return inputCost + outputCost + cacheCreationCost + cacheReadCost;
 }
 /**
@@ -72,7 +280,7 @@ function shouldLogText(text, verbosity) {
 /**
  * Log assistant message based on verbosity
  */
-function logAssistantMessage(text, verbosity) {
+export function logAssistantMessage(text, verbosity) {
     const trimmed = text.trim();
     if (!trimmed || !shouldLogText(trimmed, verbosity)) {
         return;
@@ -90,72 +298,17 @@ function formatToolArgs(input) {
     return JSON.stringify(input);
 }
 /**
- * Log tool usage
- */
-function logToolUsage(toolName, toolInput, filesReferenced) {
-    if (toolName === 'read_file' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        if (input.target_file) {
-            console.log(`   🔧 Reading ${input.target_file}`);
-            filesReferenced.add(input.target_file);
-        }
-    }
-    else if (toolName === 'grep' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        const pathInfo = input.path ? ` in ${input.path}` : '';
-        console.log(`   🔍 Searching for: ${input.pattern || 'pattern'}${pathInfo}`);
-    }
-    else if (toolName === 'glob_file_search' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        const dirInfo = input.target_directory ? ` in ${input.target_directory}` : '';
-        console.log(`   📁 Finding files: ${input.glob_pattern || '*'}${dirInfo}`);
-    }
-    else if (toolName === 'codebase_search' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        const dirInfo = input.target_directories && input.target_directories.length > 0
-            ? ` in ${input.target_directories.join(', ')}`
-            : '';
-        console.log(`   🔎 Searching codebase: ${input.query || 'query'}${dirInfo}`);
-    }
-    else if (toolName === 'write' ||
-        toolName === 'search_replace' ||
-        toolName === 'edit' ||
-        toolName === 'edit_notebook' ||
-        toolName === 'delete_file') {
-        // Don't log here - fixCount will handle it
-    }
-    else if (toolName === 'run_terminal_cmd' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        const cmd = input.command || 'command';
-        console.log(`   🔧 Running: ${cmd}`);
-    }
-    else if (toolName === 'list_dir' && toolInput && typeof toolInput === 'object') {
-        const input = toolInput;
-        console.log(`   📂 Listing directory: ${input.target_directory || '.'}`);
-    }
-    else {
-        // Generic tool logging with arguments
-        const args = formatToolArgs(toolInput);
-        console.log(`   🔧 ${toolName}(${args})`);
-    }
-}
-/**
- * Run Claude agent with unified configuration and logging
+ * Run agent in streaming mode with typed events
+ * Yields Claude messages + final AgentResult with metrics
+ * For SSE integration and programmatic consumption
+ *
+ * @param prompt - User prompt/instruction
+ * @param config - Agent configuration
+ * @returns AsyncGenerator yielding AgentStreamEvent (messages + final result)
  */
-export async function runAgent(prompt, config) {
-    const { systemPrompt, maxTurns = 20, model = 'claude-sonnet-4-5', cwd = process.cwd(), verbosity = 'normal', permissionMode = 'bypassPermissions', captureConversation = false, settingSources = ['project'], // Default: Load CLAUDE.md from project
-     } = config;
-    // Log the model being used
-    console.log(`🤖 Using model: ${model}\n`);
-    // Check if CLAUDE.md exists and warn if not (when loading from project)
-    if (settingSources.includes('project')) {
-        const claudePath = join(cwd, 'CLAUDE.md');
-        if (!existsSync(claudePath)) {
-            console.warn('⚠️  CLAUDE.md not found in project directory. Agent will use general coding best practices.\n');
-        }
-    }
-    // Create AbortController for cleanup - the SDK spawns child processes
-    // that need to be terminated after each query to prevent memory accumulation
+export async function* runAgentStream(prompt, config) {
+    const { systemPrompt, maxTurns = 20, model = process.env.ANTHROPIC_MODEL || 'claude-haiku-4-5-20251001', cwd = process.cwd(), permissionMode = 'bypassPermissions', settingSources = ['project'], resume, allowedTools, disallowedTools, } = config;
+    // Create AbortController for SDK cleanup
     const abortController = new AbortController();
     const options = {
         model,
@@ -164,7 +317,10 @@ export async function runAgent(prompt, config) {
         cwd,
         permissionMode,
         settingSources,
-        abortController, // Pass to SDK for process cleanup
+        abortController,
+        ...(resume && { resume }),
+        ...(allowedTools && { allowedTools }),
+        ...(disallowedTools && { disallowedTools }),
     };
     const responseStream = query({ prompt, options });
     let response = '';
@@ -174,6 +330,79 @@ export async function runAgent(prompt, config) {
     let cacheReadTokens = 0;
     let fixCount = 0;
     const filesReferenced = new Set();
+    let sessionId;
+    // Process the response stream
+    for await (const message of responseStream) {
+        const claudeMessage = message;
+        // Yield the message
+        yield { type: 'message', data: claudeMessage };
+        // Capture session ID
+        if (!sessionId && claudeMessage.session_id) {
+            sessionId = claudeMessage.session_id;
+        }
+        // Track metrics from assistant messages
+        if (claudeMessage.type === 'assistant' && claudeMessage.message?.content) {
+            for (const block of claudeMessage.message.content) {
+                if (block.type === 'text' && block.text) {
+                    response += block.text;
+                }
+                else if (block.type === 'tool_use' && block.name) {
+                    // Track fixes - count all file modification tools
+                    if (isFileModificationTool(block.name)) {
+                        fixCount++;
+                    }
+                }
+            }
+        }
+        // Track token usage
+        if (claudeMessage.type === 'result' &&
+            claudeMessage.subtype === 'success' &&
+            claudeMessage.usage) {
+            inputTokens += claudeMessage.usage.input_tokens || 0;
+            outputTokens += claudeMessage.usage.output_tokens || 0;
+            cacheCreationTokens += claudeMessage.usage.cache_creation_input_tokens || 0;
+            cacheReadTokens += claudeMessage.usage.cache_read_input_tokens || 0;
+        }
+    }
+    // Calculate cost
+    const cost = calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+    // Yield final result
+    yield {
+        type: 'agent_result',
+        data: {
+            response: response.trim(),
+            tokensUsed: {
+                input: inputTokens,
+                output: outputTokens,
+                cacheCreation: cacheCreationTokens,
+                cacheRead: cacheReadTokens,
+            },
+            cost,
+            fixCount,
+            filesReferenced,
+            sessionId,
+        },
+    };
+}
+/**
+ * Run Claude agent with unified configuration and logging
+ * Processes stream and returns final result
+ */
+export async function runAgent(prompt, config) {
+    const { verbosity = 'normal', captureConversation = false, settingSources = ['project'], cwd = process.cwd(), model = process.env.ANTHROPIC_MODEL || 'claude-haiku-4-5-20251001', } = config;
+    // Log the model being used
+    console.log(`🤖 Using model: ${model}\n`);
+    // Check if CLAUDE.md exists and warn if not (when loading from project)
+    if (settingSources.includes('project')) {
+        const claudePath = join(cwd, 'CLAUDE.md');
+        if (!existsSync(claudePath)) {
+            console.warn('⚠️  CLAUDE.md not found in project directory. Agent will use general coding best practices.\n');
+        }
+    }
+    // Get the stream
+    const stream = runAgentStream(prompt, config);
+    const filesReferenced = new Set();
+    let fixCount = 0;
     // Conversation capture (if enabled)
     const conversationMessages = [];
     // Track current assistant message and tool calls
@@ -186,117 +415,89 @@ export async function runAgent(prompt, config) {
             timestamp: new Date().toISOString(),
         });
     }
-    // Process the response stream
-    for await (const message of responseStream) {
-        if (message.type === 'assistant') {
-            const content = message.message.content;
-            // Start new assistant message if capturing
-            if (captureConversation && !currentMessage) {
-                currentMessage = {
-                    role: 'assistant',
-                    content: '',
-                    timestamp: new Date().toISOString(),
-                    toolCalls: [],
-                };
-            }
-            for (const block of content) {
-                if (block.type === 'text' && block.text) {
-                    response += block.text;
-                    logAssistantMessage(block.text, verbosity);
-                    // Add to current message content
-                    if (captureConversation && currentMessage) {
-                        currentMessage.content += block.text;
-                    }
+    let result = null;
+    // Process the stream and add logging
+    for await (const event of stream) {
+        if (event.type === 'message') {
+            const message = event.data;
+            if (message.type === 'assistant' && message.message?.content) {
+                // Start new assistant message if capturing
+                if (captureConversation && !currentMessage) {
+                    currentMessage = {
+                        role: 'assistant',
+                        content: '',
+                        timestamp: new Date().toISOString(),
+                        toolCalls: [],
+                    };
                 }
-                else if (block.type === 'tool_use') {
-                    // Track fixes - count all file modification tools (case-insensitive)
-                    const toolNameLower = block.name.toLowerCase();
-                    const isFileModification = toolNameLower === 'write' ||
-                        toolNameLower === 'search_replace' ||
-                        toolNameLower === 'edit' ||
-                        toolNameLower === 'edit_notebook' ||
-                        toolNameLower === 'delete_file';
-                    if (isFileModification) {
-                        fixCount++;
-                        console.log(`   🔧 Applying fix ${fixCount}... (${block.name})`);
-                    }
-                    else {
-                        logToolUsage(block.name, block.input, filesReferenced);
+                for (const block of message.message.content) {
+                    if (block.type === 'text' && block.text) {
+                        logAssistantMessage(block.text, verbosity);
+                        // Add to current message content
+                        if (captureConversation && currentMessage) {
+                            currentMessage.content += block.text;
+                        }
                     }
-                    // Capture tool call
-                    if (captureConversation && currentMessage) {
-                        currentMessage.toolCalls.push({
-                            name: block.name,
-                            input: block.input,
-                            // Output will be added when we receive tool_result
-                        });
+                    else if (block.type === 'tool_use' && block.name) {
+                        // Track fixes - count all file modification tools
+                        if (isFileModificationTool(block.name)) {
+                            fixCount++;
+                            console.log(`   🔧 Applying fix ${fixCount}... (${block.name})`);
+                        }
+                        else {
+                            logToolUsage(block.name, block.input, filesReferenced);
+                        }
+                        // Capture tool call
+                        if (captureConversation && currentMessage) {
+                            currentMessage.toolCalls.push({
+                                name: block.name,
+                                input: block.input,
+                            });
+                        }
                     }
                 }
             }
-        }
-        // Capture tool results
-        // Note: tool_result is not part of the message stream type, so we skip this for now
-        // Tool outputs are captured through the SDK's internal handling
-        // Track token usage
-        if (message.type === 'result' && message.subtype === 'success') {
-            const input = message.usage.input_tokens || 0;
-            const output = message.usage.output_tokens || 0;
-            const cacheCreation = message.usage.cache_creation_input_tokens || 0;
-            const cacheRead = message.usage.cache_read_input_tokens || 0;
-            inputTokens += input;
-            outputTokens += output;
-            cacheCreationTokens += cacheCreation;
-            cacheReadTokens += cacheRead;
-            // Debug logging for token tracking (only if verbose)
-            if (verbosity === 'verbose' && (input > 0 || output > 0)) {
-                console.log(`   📊 Turn tokens: ${input} in, ${output} out, ${cacheCreation} cache write, ${cacheRead} cache read`);
+            // Track token usage for verbose logging
+            if (message.type === 'result' && message.subtype === 'success' && message.usage) {
+                const input = message.usage.input_tokens || 0;
+                const output = message.usage.output_tokens || 0;
+                const cacheCreation = message.usage.cache_creation_input_tokens || 0;
+                const cacheRead = message.usage.cache_read_input_tokens || 0;
+                // Debug logging for token tracking (only if verbose)
+                if (verbosity === 'verbose' && (input > 0 || output > 0)) {
+                    console.log(`   📊 Turn tokens: ${input} in, ${output} out, ${cacheCreation} cache write, ${cacheRead} cache read`);
+                }
+                // Save current message when turn completes
+                if (captureConversation && currentMessage) {
+                    conversationMessages.push({
+                        role: currentMessage.role,
+                        content: currentMessage.content,
+                        timestamp: currentMessage.timestamp,
+                        toolCalls: currentMessage.toolCalls.length > 0 ? currentMessage.toolCalls : undefined,
+                    });
+                    currentMessage = null; // Reset for next turn
+                }
             }
-            // Save current message when turn completes
-            if (captureConversation && currentMessage) {
-                conversationMessages.push({
-                    role: currentMessage.role,
-                    content: currentMessage.content,
-                    timestamp: currentMessage.timestamp,
-                    toolCalls: currentMessage.toolCalls.length > 0 ? currentMessage.toolCalls : undefined,
-                });
-                currentMessage = null; // Reset for next turn
+        }
+        else if (event.type === 'agent_result') {
+            result = event.data;
+            // Debug logging for final totals
+            if (verbosity === 'verbose') {
+                console.log(`\n   📊 Final totals:`);
+                console.log(`      • Fixes applied: ${result.fixCount}`);
+                console.log(`      • Total input tokens: ${result.tokensUsed.input.toLocaleString()}`);
+                console.log(`      • Total output tokens: ${result.tokensUsed.output.toLocaleString()}`);
+                console.log(`      • Total cost: $${result.cost.toFixed(4)}`);
             }
         }
     }
-    // Calculate cost
-    const cost = calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
-    // Debug logging for final totals
-    if (verbosity === 'verbose') {
-        console.log(`\n   📊 Final totals:`);
-        console.log(`      • Fixes applied: ${fixCount}`);
-        console.log(`      • Total input tokens: ${inputTokens.toLocaleString()}`);
-        console.log(`      • Total output tokens: ${outputTokens.toLocaleString()}`);
-        console.log(`      • Total cost: $${cost.toFixed(4)}`);
+    if (!result) {
+        throw new Error('Agent stream ended without result');
     }
-    const result = {
-        response: response.trim(),
-        tokensUsed: {
-            input: inputTokens,
-            output: outputTokens,
-            cacheCreation: cacheCreationTokens,
-            cacheRead: cacheReadTokens,
-        },
-        cost,
-        fixCount,
-        filesReferenced,
-    };
     // Include conversation if captured
     if (captureConversation && conversationMessages.length > 0) {
         result.conversationMessages = conversationMessages;
     }
-    // Cleanup: Abort the controller to terminate any child processes spawned by the SDK
-    // This prevents memory accumulation when running multiple agents sequentially (e.g., kosuke build)
-    try {
-        abortController.abort();
-    }
-    catch {
-        // Ignore abort errors - cleanup is best-effort
-    }
     return result;
 }
 //# sourceMappingURL=claude-agent.js.map