erosolar-cli 1.7.27 → 1.7.29

package/dist/ui/toolDisplay.js

@@ -160,12 +160,12 @@ function truncatePathForDisplay(path, maxLength) {
     const parts = path.split('/').filter(p => p);
     if (parts.length <= 2) {
         // Short path, just truncate
-        return path.slice(0, maxLength - 3) + '...';
+        return `${path.slice(0, maxLength - 3)}...`;
     }
     // Keep filename and truncate middle
     const filename = parts[parts.length - 1];
     if (!filename) {
-        return path.slice(0, maxLength - 3) + '...';
+        return `${path.slice(0, maxLength - 3)}...`;
     }
     const firstPart = parts.slice(0, 2).join('/');
     if (firstPart.length + filename.length + 4 <= maxLength) {
@@ -175,7 +175,7 @@ function truncatePathForDisplay(path, maxLength) {
     if (filename.length <= maxLength - 3) {
         return `.../${filename}`;
     }
-    return filename.slice(0, maxLength - 3) + '...';
+    return `${filename.slice(0, maxLength - 3)}...`;
 }
 /**
  * Format expandable content preview
@@ -363,17 +363,17 @@ export function truncateCommand(command, maxLength = 60) {
     // Try to keep command name and first few args
     const parts = command.split(/\s+/).filter(p => p);
     if (parts.length === 0 || !parts[0]) {
-        return command.slice(0, maxLength - 3) + '...';
+        return `${command.slice(0, maxLength - 3)}...`;
     }
     if (parts.length === 1) {
         // Single long command/path
-        return command.slice(0, maxLength - 3) + '...';
+        return `${command.slice(0, maxLength - 3)}...`;
     }
     // Keep first part (command) and truncate rest
     const cmdName = parts[0];
     const rest = parts.slice(1).join(' ');
     if (cmdName.length + 7 > maxLength) {
-        return cmdName.slice(0, maxLength - 3) + '...';
+        return `${cmdName.slice(0, maxLength - 3)}...`;
     }
     const availableSpace = maxLength - cmdName.length - 4; // -4 for " ..."
     if (rest.length <= availableSpace) {
@@ -421,4 +421,920 @@ export function formatList(items, bullet = '•') {
 export function formatKeyValue(key, value) {
     return `${theme.ui.muted(key)}: ${value}`;
 }
+/**
+ * Format a tool result summary for display in the terminal.
+ * This is the central function for displaying ALL tool results.
+ *
+ * To add support for a new tool:
+ * 1. Add a case in the switch statement below
+ * 2. Create a format function for that tool type
+ *
+ * @returns Formatted string to display, or null if no display needed
+ */
+export function formatToolResultSummary(input) {
+    const { toolName, args, output, success, durationMs } = input;
+    // Determine tool category and format accordingly
+    switch (toolName) {
+        // === FILE OPERATIONS ===
+        case 'Edit':
+        case 'edit_file':
+        case 'Write':
+        case 'write_file':
+            // These already return formatted diff output from fileTools.ts
+            return output;
+        // === BASH/COMMAND EXECUTION ===
+        case 'Bash':
+        case 'bash':
+        case 'execute_bash':
+        case 'execute_bash_stream':
+        case 'execute_command':
+            return formatBashResult(args, output, success, durationMs);
+        // === BACKGROUND BASH ===
+        case 'BashOutput':
+            return formatBashOutputResult(args, output, success);
+        case 'KillShell':
+            return formatKillShellResult(args, output, success);
+        // === FILE READING ===
+        case 'Read':
+        case 'read_file':
+            return formatReadResult(args, output, success);
+        // === SEARCH OPERATIONS ===
+        case 'Grep':
+        case 'grep':
+        case 'grep_search':
+        case 'search_text':
+        case 'search_files':
+            return formatGrepResult(args, output, success);
+        case 'Glob':
+        case 'glob':
+        case 'list_files':
+            return formatGlobResult(args, output, success);
+        case 'find_definition':
+            return formatFindDefinitionResult(args, output, success);
+        // === WEB OPERATIONS ===
+        case 'WebFetch':
+        case 'web_fetch':
+            return formatWebFetchResult(args, output, success);
+        case 'WebSearch':
+        case 'web_search':
+            return formatWebSearchResult(args, output, success);
+        case 'WebExtract':
+            return formatWebExtractResult(args, output, success);
+        // === TASK/AGENT OPERATIONS ===
+        case 'Task':
+        case 'task':
+            return formatTaskResult(args, output, success);
+        // === TODO OPERATIONS ===
+        case 'TodoWrite':
+        case 'todo_write':
+            return formatTodoResult(args, output, success);
+        // === NOTEBOOK OPERATIONS ===
+        case 'NotebookEdit':
+        case 'notebook_edit':
+            return formatNotebookResult(args, output, success);
+        // === USER INTERACTION ===
+        case 'AskUserQuestion':
+            return formatAskUserResult(args, output, success);
+        // === DEV TOOLS ===
+        case 'run_tests':
+            return formatTestResult(args, output, success, durationMs);
+        case 'run_build':
+            return formatBuildResult(args, output, success, durationMs);
+        case 'install_dependencies':
+            return formatInstallResult(args, output, success, durationMs);
+        case 'check_package_info':
+            return formatPackageInfoResult(args, output, success);
+        // === GIT OPERATIONS ===
+        case 'git_release':
+        case 'git_sync':
+        case 'git_cleanup':
+            return formatGitResult(toolName, args, output, success);
+        // === DOCKER ===
+        case 'docker_build':
+        case 'docker_compose':
+            return formatDockerResult(toolName, args, output, success, durationMs);
+        // === CODE ANALYSIS ===
+        case 'analyze_code_structure':
+        case 'find_dependencies':
+        case 'check_code_complexity':
+        case 'advanced_ast_analysis':
+        case 'analyze_code_complexity':
+        case 'suggest_refactoring':
+        case 'generate_code_quality_report':
+            return formatCodeAnalysisResult(toolName, args, output, success);
+        // === TESTING TOOLS ===
+        case 'generate_test_templates':
+        case 'run_coverage_analysis':
+        case 'summarize_coverage_report':
+        case 'analyze_test_coverage':
+        case 'generate_comprehensive_tests':
+            return formatTestingToolResult(toolName, args, output, success);
+        // === LINT/QUALITY ===
+        case 'run_lint_checks':
+        case 'inspect_code_quality':
+        case 'list_lint_rules':
+            return formatLintResult(toolName, args, output, success);
+        // === CLOUD DEPLOY ===
+        case 'cloud_status':
+        case 'cloud_deploy':
+        case 'cloud_init':
+        case 'cloud_login':
+        case 'firebase_deploy':
+        case 'aliyun_deploy':
+            return formatCloudResult(toolName, args, output, success);
+        // === BROWSER AUTOMATION ===
+        case 'browser_create_session':
+        case 'browser_navigate':
+        case 'browser_click':
+        case 'browser_type':
+        case 'browser_screenshot':
+        case 'browser_close_session':
+            return formatBrowserResult(toolName, args, output, success);
+        // === EMAIL ===
+        case 'send_email':
+        case 'send_batch_emails':
+        case 'verify_email_config':
+            return formatEmailResult(toolName, args, output, success);
+        // === SKILLS ===
+        case 'ListSkills':
+        case 'Skill':
+            return formatSkillResult(toolName, args, output, success);
+        // === PLANNING ===
+        case 'ExitPlanMode':
+            return formatPlanModeResult(args, output, success);
+        // === REPO CHECKS ===
+        case 'run_repo_checks':
+            return formatRepoChecksResult(args, output, success);
+        // === LEARNING ===
+        case 'learn_codebase':
+        case 'learn_file':
+        case 'learn_topic':
+        case 'learn_summary':
+            return formatLearnResult(toolName, args, output, success);
+        // === DEFAULT: Unknown tools ===
+        default:
+            // For unknown tools, show a generic summary if output is non-empty
+            return formatGenericToolResult(toolName, output, success, durationMs);
+    }
+}
+/**
+ * Format Bash command result
+ * Shows: command executed, exit status, and output preview
+ */
+function formatBashResult(args, output, success, durationMs) {
+    const command = args['command'] || '';
+    const description = args['description'];
+    const lines = [];
+    // Header with command
+    const statusIcon = success ? theme.success('✓') : theme.error('✗');
+    const cmdDisplay = truncateCommand(command, 50);
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    if (description) {
+        lines.push(`${statusIcon} ${description}${durationStr}`);
+        lines.push(`  ${theme.ui.muted('$')} ${theme.dim(cmdDisplay)}`);
+    }
+    else {
+        lines.push(`${statusIcon} ${theme.ui.muted('$')} ${cmdDisplay}${durationStr}`);
+    }
+    // Output preview (max 5 lines)
+    if (output && output.trim()) {
+        const outputLines = output.trim().split('\n');
+        const maxPreviewLines = 5;
+        const previewLines = outputLines.slice(0, maxPreviewLines);
+        for (const line of previewLines) {
+            // Truncate long lines
+            const truncatedLine = line.length > 80 ? `${line.slice(0, 77)}...` : line;
+            lines.push(`  ${theme.dim(truncatedLine)}`);
+        }
+        if (outputLines.length > maxPreviewLines) {
+            const remaining = outputLines.length - maxPreviewLines;
+            lines.push(`  ${theme.ui.muted(`... +${remaining} more line${remaining === 1 ? '' : 's'}`)}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format Read file result
+ * Shows: file path and line count
+ */
+function formatReadResult(args, output, success) {
+    const filePath = (args['file_path'] || args['path']) || '';
+    const displayPath = truncatePathForDisplay(filePath, 50);
+    if (!success) {
+        return `${theme.error('✗')} Failed to read ${displayPath}`;
+    }
+    const lineCount = output.split('\n').length;
+    return `${theme.success('✓')} Read ${theme.info(displayPath)} ${theme.ui.muted(`(${lineCount} lines)`)}`;
+}
+/**
+ * Format Grep search result
+ * Shows: pattern, matches found, and file list preview
+ */
+function formatGrepResult(args, output, success) {
+    const pattern = args['pattern'] || '';
+    const patternDisplay = pattern.length > 30 ? `${pattern.slice(0, 27)}...` : pattern;
+    const lines = [];
+    if (!success || !output.trim()) {
+        lines.push(`${theme.warning('○')} No matches for "${patternDisplay}"`);
+        return lines.join('\n');
+    }
+    // Count matches/files
+    const outputLines = output.trim().split('\n').filter(l => l.trim());
+    const matchCount = outputLines.length;
+    lines.push(`${theme.success('✓')} Found ${theme.info(String(matchCount))} match${matchCount === 1 ? '' : 'es'} for "${patternDisplay}"`);
+    // Show first few matches
+    const maxPreview = 3;
+    for (let i = 0; i < Math.min(maxPreview, outputLines.length); i++) {
+        const line = outputLines[i] || '';
+        const truncated = line.length > 70 ? `${line.slice(0, 67)}...` : line;
+        lines.push(`  ${theme.dim(truncated)}`);
+    }
+    if (matchCount > maxPreview) {
+        lines.push(`  ${theme.ui.muted(`... +${matchCount - maxPreview} more`)}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format Glob file search result
+ * Shows: pattern and files found
+ */
+function formatGlobResult(args, output, success) {
+    const pattern = args['pattern'] || '*';
+    const lines = [];
+    if (!success || !output.trim()) {
+        lines.push(`${theme.warning('○')} No files matching "${pattern}"`);
+        return lines.join('\n');
+    }
+    const files = output.trim().split('\n').filter(f => f.trim());
+    const fileCount = files.length;
+    lines.push(`${theme.success('✓')} Found ${theme.info(String(fileCount))} file${fileCount === 1 ? '' : 's'} matching "${pattern}"`);
+    // Show first few files
+    const maxPreview = 4;
+    for (let i = 0; i < Math.min(maxPreview, files.length); i++) {
+        const file = files[i] || '';
+        lines.push(`  ${theme.dim(truncatePathForDisplay(file, 60))}`);
+    }
+    if (fileCount > maxPreview) {
+        lines.push(`  ${theme.ui.muted(`... +${fileCount - maxPreview} more`)}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format WebFetch result
+ * Shows: URL and content summary
+ */
+function formatWebFetchResult(args, output, success) {
+    const url = args['url'] || '';
+    let hostname = url;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        // Keep original URL if parsing fails
+    }
+    if (!success) {
+        return `${theme.error('✗')} Failed to fetch ${hostname}`;
+    }
+    const contentLength = output.length;
+    const sizeStr = formatFileSize(contentLength);
+    return `${theme.success('✓')} Fetched ${theme.info(hostname)} ${theme.ui.muted(`(${sizeStr})`)}`;
+}
+/**
+ * Format WebSearch result
+ * Shows: query and result count
+ */
+function formatWebSearchResult(args, output, success) {
+    const query = args['query'] || '';
+    const queryDisplay = query.length > 40 ? `${query.slice(0, 37)}...` : query;
+    if (!success) {
+        return `${theme.error('✗')} Search failed for "${queryDisplay}"`;
+    }
+    // Try to count results from output
+    const resultMatches = output.match(/^\d+\./gm);
+    const resultCount = resultMatches ? resultMatches.length : 'multiple';
+    return `${theme.success('✓')} Found ${theme.info(String(resultCount))} results for "${queryDisplay}"`;
+}
+/**
+ * Format Task/Agent result
+ * Shows: task description and completion status
+ */
+function formatTaskResult(args, _output, success) {
+    const description = args['description'] || 'Task';
+    const truncatedDesc = description.length > 50 ? `${description.slice(0, 47)}...` : description;
+    if (!success) {
+        return `${theme.error('✗')} Task failed: ${truncatedDesc}`;
+    }
+    return `${theme.success('✓')} Completed: ${truncatedDesc}`;
+}
+/**
+ * Format TodoWrite result
+ * Shows: todo list update summary
+ */
+function formatTodoResult(args, _output, success) {
+    const todos = args['todos'];
+    if (!success) {
+        return `${theme.error('✗')} Failed to update todo list`;
+    }
+    if (!todos || !Array.isArray(todos)) {
+        return `${theme.success('✓')} Todo list updated`;
+    }
+    const completed = todos.filter(t => t.status === 'completed').length;
+    const inProgress = todos.filter(t => t.status === 'in_progress').length;
+    const pending = todos.filter(t => t.status === 'pending').length;
+    const parts = [`${theme.success('✓')} Todos:`];
+    if (completed > 0)
+        parts.push(theme.success(`${completed} done`));
+    if (inProgress > 0)
+        parts.push(theme.warning(`${inProgress} active`));
+    if (pending > 0)
+        parts.push(theme.dim(`${pending} pending`));
+    return parts.join(' ');
+}
+/**
+ * Format NotebookEdit result
+ * Shows: notebook and cell info
+ */
+function formatNotebookResult(args, _output, success) {
+    const notebookPath = args['notebook_path'] || '';
+    const editMode = args['edit_mode'] || 'replace';
+    const displayPath = truncatePathForDisplay(notebookPath, 40);
+    if (!success) {
+        return `${theme.error('✗')} Failed to edit notebook ${displayPath}`;
+    }
+    const action = editMode === 'insert' ? 'Inserted cell in' : editMode === 'delete' ? 'Deleted cell from' : 'Updated';
+    return `${theme.success('✓')} ${action} ${theme.info(displayPath)}`;
+}
+/**
+ * Format generic/unknown tool result
+ * Provides a basic summary for tools not explicitly handled
+ */
+function formatGenericToolResult(toolName, output, success, durationMs) {
+    const statusIcon = success ? theme.success('✓') : theme.error('✗');
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    if (!output || !output.trim()) {
+        return `${statusIcon} ${toolName} completed${durationStr}`;
+    }
+    const lineCount = output.split('\n').length;
+    return `${statusIcon} ${toolName} completed ${theme.ui.muted(`(${lineCount} lines)`)}${durationStr}`;
+}
+// ============================================================================
+// ADDITIONAL TOOL FORMATTERS
+// ============================================================================
+/**
+ * Format BashOutput (background shell) result
+ */
+function formatBashOutputResult(args, output, success) {
+    const shellId = (args['bash_id'] || args['shell_id']) || '';
+    const lines = [];
+    if (!success) {
+        return `${theme.error('✗')} Failed to get output from shell ${shellId}`;
+    }
+    const outputLines = output.trim().split('\n').filter(l => l);
+    const lineCount = outputLines.length;
+    lines.push(`${theme.success('✓')} Shell ${theme.info(shellId)} ${theme.ui.muted(`(${lineCount} lines)`)}`);
+    // Show preview
+    const maxPreview = 3;
+    for (let i = 0; i < Math.min(maxPreview, outputLines.length); i++) {
+        const line = outputLines[i] || '';
+        const truncated = line.length > 70 ? `${line.slice(0, 67)}...` : line;
+        lines.push(`  ${theme.dim(truncated)}`);
+    }
+    if (lineCount > maxPreview) {
+        lines.push(`  ${theme.ui.muted(`... +${lineCount - maxPreview} more`)}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format KillShell result
+ */
+function formatKillShellResult(args, _output, success) {
+    const shellId = (args['shell_id']) || '';
+    if (!success) {
+        return `${theme.error('✗')} Failed to kill shell ${shellId}`;
+    }
+    return `${theme.success('✓')} Killed shell ${theme.info(shellId)}`;
+}
+/**
+ * Format find_definition result
+ */
+function formatFindDefinitionResult(args, output, success) {
+    const symbol = (args['symbol'] || args['name']) || '';
+    if (!success || !output.trim()) {
+        return `${theme.warning('○')} Definition not found: ${symbol}`;
+    }
+    const locations = output.trim().split('\n').filter(l => l);
+    return `${theme.success('✓')} Found ${theme.info(String(locations.length))} definition${locations.length === 1 ? '' : 's'} for "${symbol}"`;
+}
+/**
+ * Format WebExtract result
+ */
+function formatWebExtractResult(args, output, success) {
+    const url = args['url'] || '';
+    let hostname = url;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        // Keep original
+    }
+    if (!success) {
+        return `${theme.error('✗')} Failed to extract from ${hostname}`;
+    }
+    const contentLength = output.length;
+    return `${theme.success('✓')} Extracted from ${theme.info(hostname)} ${theme.ui.muted(`(${formatFileSize(contentLength)})`)}`;
+}
+/**
+ * Format AskUserQuestion result
+ */
+function formatAskUserResult(args, output, success) {
+    const questions = args['questions'];
+    const questionCount = questions?.length || 1;
+    if (!success) {
+        return `${theme.error('✗')} Failed to ask user`;
+    }
+    if (output.includes('answer') || output.includes('response')) {
+        return `${theme.success('✓')} User responded`;
+    }
+    return `${theme.info('?')} Asked ${questionCount} question${questionCount === 1 ? '' : 's'}`;
+}
+/**
+ * Format test run result
+ */
+function formatTestResult(args, output, success, durationMs) {
+    const testPattern = (args['pattern'] || args['filter']);
+    const lines = [];
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    // Try to extract test counts from output
+    const passMatch = output.match(/(\d+)\s*(?:passing|passed|✓)/i);
+    const failMatch = output.match(/(\d+)\s*(?:failing|failed|✗)/i);
+    const skipMatch = output.match(/(\d+)\s*(?:skipped|pending)/i);
+    const passed = passMatch ? parseInt(passMatch[1] || '0', 10) : 0;
+    const failed = failMatch ? parseInt(failMatch[1] || '0', 10) : 0;
+    const skipped = skipMatch ? parseInt(skipMatch[1] || '0', 10) : 0;
+    const statusIcon = success && failed === 0 ? theme.success('✓') : theme.error('✗');
+    let summary = `${statusIcon} Tests`;
+    if (testPattern) {
+        summary += ` "${testPattern}"`;
+    }
+    summary += durationStr;
+    lines.push(summary);
+    // Show counts
+    const counts = [];
+    if (passed > 0)
+        counts.push(theme.success(`${passed} passed`));
+    if (failed > 0)
+        counts.push(theme.error(`${failed} failed`));
+    if (skipped > 0)
+        counts.push(theme.warning(`${skipped} skipped`));
+    if (counts.length > 0) {
+        lines.push(`  ${counts.join(', ')}`);
+    }
+    // Show first error if failed
+    if (!success && failed > 0) {
+        const errorMatch = output.match(/(?:Error|FAIL|✗).*?:(.*?)(?:\n|$)/i);
+        if (errorMatch && errorMatch[1]) {
+            const errorMsg = errorMatch[1].trim().slice(0, 60);
+            lines.push(`  ${theme.error(errorMsg)}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format build result
+ */
+function formatBuildResult(args, output, success, durationMs) {
+    const target = (args['target'] || args['script']);
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    if (!success) {
+        // Try to extract error count
+        const errorMatches = output.match(/error/gi);
+        const errorCount = errorMatches ? errorMatches.length : 0;
+        if (errorCount > 0) {
+            return `${theme.error('✗')} Build failed with ${errorCount} error${errorCount === 1 ? '' : 's'}${durationStr}`;
+        }
+        return `${theme.error('✗')} Build failed${durationStr}`;
+    }
+    const label = target ? `Build "${target}"` : 'Build';
+    return `${theme.success('✓')} ${label} succeeded${durationStr}`;
+}
+/**
+ * Format install dependencies result
+ */
+function formatInstallResult(args, output, success, durationMs) {
+    const packages = args['packages'];
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    if (!success) {
+        return `${theme.error('✗')} Install failed${durationStr}`;
+    }
+    // Try to extract package count from output
+    const addedMatch = output.match(/added\s+(\d+)\s+packages?/i);
+    const packageCount = addedMatch ? addedMatch[1] : null;
+    let summary = `${theme.success('✓')} Dependencies installed`;
+    if (packageCount) {
+        summary += ` ${theme.ui.muted(`(${packageCount} packages)`)}`;
+    }
+    else if (packages) {
+        const pkgList = Array.isArray(packages) ? packages : [packages];
+        summary += ` ${theme.ui.muted(`(${pkgList.length} packages)`)}`;
+    }
+    summary += durationStr;
+    return summary;
+}
+/**
+ * Format package info result
+ */
+function formatPackageInfoResult(args, output, success) {
+    const packageName = (args['package'] || args['name']) || '';
+    if (!success) {
+        return `${theme.error('✗')} Package info failed for ${packageName}`;
+    }
+    // Try to extract version
+    const versionMatch = output.match(/version[:\s]+["']?([^"'\s\n]+)/i);
+    const version = versionMatch ? versionMatch[1] : null;
+    if (version) {
+        return `${theme.success('✓')} ${theme.info(packageName)}@${version}`;
+    }
+    return `${theme.success('✓')} Package info: ${theme.info(packageName)}`;
+}
+/**
+ * Format git operation result
+ */
+function formatGitResult(toolName, args, output, success) {
+    const action = toolName.replace('git_', '');
+    if (!success) {
+        return `${theme.error('✗')} Git ${action} failed`;
+    }
+    switch (toolName) {
+        case 'git_release': {
+            const version = (args['version'] || args['tag']);
+            if (version) {
+                return `${theme.success('✓')} Released ${theme.info(version)}`;
+            }
+            return `${theme.success('✓')} Release created`;
+        }
+        case 'git_sync': {
+            // Try to extract ahead/behind from output
+            const aheadMatch = output.match(/(\d+)\s+commit.*ahead/i);
+            const behindMatch = output.match(/(\d+)\s+commit.*behind/i);
+            const parts = [];
+            if (aheadMatch)
+                parts.push(`${aheadMatch[1]} ahead`);
+            if (behindMatch)
+                parts.push(`${behindMatch[1]} behind`);
+            if (parts.length > 0) {
+                return `${theme.success('✓')} Synced ${theme.ui.muted(`(${parts.join(', ')})`)}`;
+            }
+            return `${theme.success('✓')} Git synced`;
+        }
+        case 'git_cleanup': {
+            const branchMatch = output.match(/deleted.*?(\d+)/i);
+            if (branchMatch) {
+                return `${theme.success('✓')} Cleaned up ${branchMatch[1]} branches`;
+            }
+            return `${theme.success('✓')} Git cleanup completed`;
+        }
+        default:
+            return `${theme.success('✓')} Git ${action} completed`;
+    }
+}
+/**
+ * Format docker result
+ */
+function formatDockerResult(toolName, args, output, success, durationMs) {
+    const durationStr = durationMs ? ` ${theme.ui.muted(`(${formatDuration(durationMs)})`)}` : '';
+    if (!success) {
+        return `${theme.error('✗')} Docker ${toolName.replace('docker_', '')} failed${durationStr}`;
+    }
+    switch (toolName) {
+        case 'docker_build': {
+            const tag = (args['tag'] || args['image']);
+            // Try to extract image ID from output
+            const imageMatch = output.match(/(?:Successfully built|sha256:)\s*([a-f0-9]{12})/i);
+            if (tag) {
+                return `${theme.success('✓')} Built image ${theme.info(tag)}${durationStr}`;
+            }
+            if (imageMatch) {
+                return `${theme.success('✓')} Built image ${theme.info(imageMatch[1] || '')}${durationStr}`;
+            }
+            return `${theme.success('✓')} Docker build completed${durationStr}`;
+        }
+        case 'docker_compose': {
+            const action = (args['action'] || args['command']) || 'up';
+            return `${theme.success('✓')} Docker compose ${action}${durationStr}`;
+        }
+        default:
+            return `${theme.success('✓')} Docker operation completed${durationStr}`;
+    }
+}
+/**
+ * Format code analysis result
+ */
+function formatCodeAnalysisResult(toolName, args, output, success) {
+    const filePath = (args['file_path'] || args['path'] || args['file']);
+    const displayPath = filePath ? truncatePathForDisplay(filePath, 40) : '';
+    if (!success) {
+        return `${theme.error('✗')} Analysis failed${displayPath ? ` for ${displayPath}` : ''}`;
+    }
+    const toolLabels = {
+        'analyze_code_structure': 'Structure analyzed',
+        'find_dependencies': 'Dependencies found',
+        'check_code_complexity': 'Complexity checked',
+        'advanced_ast_analysis': 'AST analyzed',
+        'analyze_code_complexity': 'Complexity analyzed',
+        'suggest_refactoring': 'Refactoring suggestions',
+        'generate_code_quality_report': 'Quality report generated',
+    };
+    const label = toolLabels[toolName] || 'Analysis completed';
+    // Try to extract counts from output
+    const issueMatch = output.match(/(\d+)\s*(?:issue|warning|suggestion)/i);
+    if (issueMatch) {
+        return `${theme.success('✓')} ${label}: ${issueMatch[1]} items${displayPath ? ` in ${displayPath}` : ''}`;
+    }
+    return `${theme.success('✓')} ${label}${displayPath ? ` for ${displayPath}` : ''}`;
+}
+/**
+ * Format testing tool result
+ */
+function formatTestingToolResult(toolName, args, output, success) {
+    const filePath = (args['file_path'] || args['path']);
+    const displayPath = filePath ? truncatePathForDisplay(filePath, 40) : '';
+    if (!success) {
+        return `${theme.error('✗')} ${toolName.replace(/_/g, ' ')} failed`;
+    }
+    switch (toolName) {
+        case 'generate_test_templates': {
+            const countMatch = output.match(/(\d+)\s*(?:test|template)/i);
+            if (countMatch) {
+                return `${theme.success('✓')} Generated ${countMatch[1]} test templates`;
+            }
+            return `${theme.success('✓')} Test templates generated`;
+        }
+        case 'run_coverage_analysis':
+        case 'summarize_coverage_report': {
+            const coverageMatch = output.match(/(\d+(?:\.\d+)?)\s*%/);
+            if (coverageMatch) {
+                const pct = parseFloat(coverageMatch[1] || '0');
+                const color = pct >= 80 ? theme.success : pct >= 60 ? theme.warning : theme.error;
+                return `${theme.success('✓')} Coverage: ${color(`${pct}%`)}${displayPath ? ` for ${displayPath}` : ''}`;
+            }
+            return `${theme.success('✓')} Coverage analyzed${displayPath ? ` for ${displayPath}` : ''}`;
+        }
+        case 'analyze_test_coverage': {
+            const coverageMatch = output.match(/(\d+(?:\.\d+)?)\s*%/);
+            if (coverageMatch) {
+                return `${theme.success('✓')} Test coverage: ${coverageMatch[1]}%`;
+            }
+            return `${theme.success('✓')} Test coverage analyzed`;
+        }
+        case 'generate_comprehensive_tests': {
+            return `${theme.success('✓')} Comprehensive tests generated${displayPath ? ` for ${displayPath}` : ''}`;
+        }
+        default:
+            return `${theme.success('✓')} Testing tool completed`;
+    }
+}
+/**
+ * Format lint result
+ */
+function formatLintResult(toolName, args, output, success) {
+    const filePath = (args['file_path'] || args['path']);
+    const displayPath = filePath ? truncatePathForDisplay(filePath, 40) : '';
+    // Try to extract error/warning counts
+    const errorMatch = output.match(/(\d+)\s*error/i);
+    const warnMatch = output.match(/(\d+)\s*warning/i);
+    const errors = errorMatch ? parseInt(errorMatch[1] || '0', 10) : 0;
+    const warnings = warnMatch ? parseInt(warnMatch[1] || '0', 10) : 0;
+    const statusIcon = errors === 0 ? theme.success('✓') : theme.error('✗');
+    switch (toolName) {
+        case 'run_lint_checks': {
+            let summary = `${statusIcon} Lint`;
+            if (displayPath)
+                summary += ` ${displayPath}`;
+            const counts = [];
+            if (errors > 0)
+                counts.push(theme.error(`${errors} errors`));
+            if (warnings > 0)
+                counts.push(theme.warning(`${warnings} warnings`));
+            if (counts.length > 0) {
+                summary += `: ${counts.join(', ')}`;
+            }
+            else if (success) {
+                summary += ': clean';
+            }
+            return summary;
+        }
+        case 'inspect_code_quality': {
+            return `${statusIcon} Code quality inspected${displayPath ? ` for ${displayPath}` : ''}`;
+        }
+        case 'list_lint_rules': {
+            const ruleMatch = output.match(/(\d+)\s*rule/i);
+            if (ruleMatch) {
+                return `${theme.success('✓')} Found ${ruleMatch[1]} lint rules`;
+            }
+            return `${theme.success('✓')} Lint rules listed`;
+        }
+        default:
+            return `${statusIcon} Lint completed`;
+    }
+}
+/**
+ * Format cloud deployment result
+ */
+function formatCloudResult(toolName, args, output, success) {
+    const provider = (args['provider'] || args['platform']);
+    if (!success) {
+        return `${theme.error('✗')} ${toolName.replace(/_/g, ' ')} failed`;
+    }
+    switch (toolName) {
+        case 'cloud_status': {
+            return `${theme.success('✓')} Cloud status checked${provider ? ` (${provider})` : ''}`;
+        }
+        case 'cloud_deploy':
+        case 'firebase_deploy':
+        case 'aliyun_deploy': {
+            // Try to extract URL from output
+            const urlMatch = output.match(/https?:\/\/[^\s]+/);
+            if (urlMatch) {
+                return `${theme.success('✓')} Deployed to ${theme.info(urlMatch[0])}`;
+            }
+            return `${theme.success('✓')} Deployment successful${provider ? ` (${provider})` : ''}`;
+        }
+        case 'cloud_init': {
+            return `${theme.success('✓')} Cloud project initialized${provider ? ` (${provider})` : ''}`;
+        }
+        case 'cloud_login': {
+            return `${theme.success('✓')} Logged in${provider ? ` to ${provider}` : ''}`;
+        }
+        default:
+            return `${theme.success('✓')} Cloud operation completed`;
+    }
+}
+/**
+ * Format browser automation result
+ */
+function formatBrowserResult(toolName, args, output, success) {
+    if (!success) {
+        return `${theme.error('✗')} Browser ${toolName.replace('browser_', '')} failed`;
+    }
+    switch (toolName) {
+        case 'browser_create_session': {
+            const sessionMatch = output.match(/session[:\s]+["']?([^"'\s\n]+)/i);
+            if (sessionMatch) {
+                return `${theme.success('✓')} Browser session created: ${theme.info(sessionMatch[1] || '')}`;
+            }
+            return `${theme.success('✓')} Browser session created`;
+        }
+        case 'browser_navigate': {
+            const url = (args['url']);
+            if (url) {
+                try {
+                    const hostname = new URL(url).hostname;
+                    return `${theme.success('✓')} Navigated to ${theme.info(hostname)}`;
+                }
+                catch {
+                    return `${theme.success('✓')} Navigated to page`;
+                }
+            }
+            return `${theme.success('✓')} Navigated`;
+        }
+        case 'browser_click': {
+            const selector = (args['selector']);
+            return `${theme.success('✓')} Clicked ${selector ? theme.dim(selector) : 'element'}`;
+        }
+        case 'browser_type': {
+            const selector = (args['selector']);
+            return `${theme.success('✓')} Typed text ${selector ? `in ${theme.dim(selector)}` : ''}`;
+        }
+        case 'browser_screenshot': {
+            const path = (args['path'] || args['file_path']);
+            if (path) {
+                return `${theme.success('✓')} Screenshot saved: ${truncatePathForDisplay(path, 40)}`;
+            }
+            return `${theme.success('✓')} Screenshot captured`;
+        }
+        case 'browser_close_session': {
+            return `${theme.success('✓')} Browser session closed`;
+        }
+        default:
+            return `${theme.success('✓')} Browser action completed`;
+    }
+}
+/**
+ * Format email result
+ */
+function formatEmailResult(toolName, args, _output, success) {
+    if (!success) {
+        return `${theme.error('✗')} ${toolName.replace(/_/g, ' ')} failed`;
+    }
+    switch (toolName) {
+        case 'send_email': {
+            const to = (args['to']);
+            const recipients = Array.isArray(to) ? to.length : (to ? 1 : 0);
+            return `${theme.success('✓')} Email sent${recipients ? ` to ${recipients} recipient${recipients === 1 ? '' : 's'}` : ''}`;
+        }
+        case 'send_batch_emails': {
+            const emails = (args['emails']);
+            const count = emails?.length || 0;
+            return `${theme.success('✓')} Sent ${count} email${count === 1 ? '' : 's'}`;
+        }
+        case 'verify_email_config': {
+            return `${theme.success('✓')} Email config verified`;
+        }
+        default:
+            return `${theme.success('✓')} Email operation completed`;
+    }
+}
+/**
+ * Format skill result
+ */
+function formatSkillResult(toolName, args, output, success) {
+    if (!success) {
+        return `${theme.error('✗')} Skill operation failed`;
+    }
+    switch (toolName) {
+        case 'ListSkills': {
+            const skillMatch = output.match(/(\d+)\s*skill/i);
+            if (skillMatch) {
+                return `${theme.success('✓')} Found ${skillMatch[1]} skills`;
+            }
+            return `${theme.success('✓')} Skills listed`;
+        }
+        case 'Skill': {
+            const skillName = (args['skill'] || args['name']);
+            if (skillName) {
+                return `${theme.success('✓')} Skill "${skillName}" executed`;
+            }
+            return `${theme.success('✓')} Skill executed`;
+        }
+        default:
+            return `${theme.success('✓')} Skill completed`;
+    }
+}
+/**
+ * Format plan mode result
+ */
+function formatPlanModeResult(_args, _output, success) {
+    if (!success) {
+        return `${theme.error('✗')} Failed to exit plan mode`;
+    }
+    return `${theme.success('✓')} Exited plan mode`;
+}
+/**
+ * Format repo checks result
+ */
+function formatRepoChecksResult(args, output, success) {
+    const checks = (args['checks']);
+    const checkCount = checks?.length || 0;
+    // Try to extract pass/fail counts
+    const passMatch = output.match(/(\d+)\s*pass/i);
+    const failMatch = output.match(/(\d+)\s*fail/i);
+    const passed = passMatch ? parseInt(passMatch[1] || '0', 10) : 0;
+    const failed = failMatch ? parseInt(failMatch[1] || '0', 10) : 0;
+    const statusIcon = success && failed === 0 ? theme.success('✓') : theme.error('✗');
+    if (passed > 0 || failed > 0) {
+        const counts = [];
+        if (passed > 0)
+            counts.push(theme.success(`${passed} passed`));
+        if (failed > 0)
+            counts.push(theme.error(`${failed} failed`));
+        return `${statusIcon} Repo checks: ${counts.join(', ')}`;
+    }
+    return `${statusIcon} Repo checks${checkCount > 0 ? ` (${checkCount} checks)` : ''} ${success ? 'passed' : 'failed'}`;
+}
+/**
+ * Format learn tool result
+ */
+function formatLearnResult(toolName, args, output, success) {
+    if (!success) {
+        return `${theme.error('✗')} Learning failed`;
+    }
+    switch (toolName) {
+        case 'learn_codebase': {
+            const fileMatch = output.match(/(\d+)\s*file/i);
+            if (fileMatch) {
+                return `${theme.success('✓')} Learned codebase: ${fileMatch[1]} files analyzed`;
+            }
+            return `${theme.success('✓')} Codebase learned`;
+        }
+        case 'learn_file': {
+            const filePath = (args['file_path'] || args['path']);
+            if (filePath) {
+                return `${theme.success('✓')} Learned: ${truncatePathForDisplay(filePath, 40)}`;
+            }
+            return `${theme.success('✓')} File learned`;
+        }
+        case 'learn_topic': {
+            const topic = (args['topic']);
+            if (topic) {
+                return `${theme.success('✓')} Learned topic: ${topic}`;
+            }
+            return `${theme.success('✓')} Topic learned`;
+        }
+        case 'learn_summary': {
+            return `${theme.success('✓')} Summary generated`;
+        }
+        default:
+            return `${theme.success('✓')} Learning completed`;
+    }
+}
 //# sourceMappingURL=toolDisplay.js.map