erosolar-cli 1.7.81 → 1.7.82

package/dist/ui/toolDisplay.js

@@ -445,8 +445,15 @@ export function formatToolResultSummary(input) {
         // === 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':
@@ -454,12 +461,16 @@ export function formatToolResultSummary(input) {
         // === 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':
@@ -467,6 +478,8 @@ export function formatToolResultSummary(input) {
         case 'WebSearch':
         case 'web_search':
             return formatWebSearchResult(args, output, success);
+        case 'WebExtract':
+            return formatWebExtractResult(args, output, success);
         // === TASK/AGENT OPERATIONS ===
         case 'Task':
         case 'task':
@@ -479,6 +492,85 @@ export function formatToolResultSummary(input) {
         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
@@ -685,4 +777,564 @@ function formatGenericToolResult(toolName, output, success, durationMs) {
     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