@qduc/term2 0.7.3 → 0.8.0

package/dist/components/message/CommandMessage.js

@@ -0,0 +1,708 @@
+import React, { useState, useEffect, useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { generateDiff } from '../../utils/output/diff.js';
+import { TOOL_NAME_APPLY_PATCH, TOOL_NAME_CREATE_FILE, TOOL_NAME_SEARCH_REPLACE } from '../../tools/tool-names.js';
+import { countDiffStats, formatToolArgs, getFirstParagraph, getMatchCount, isSearchLikeTool, parseCodeContextSearchOutput, parseCodeOutlineOutput, parseFindFilesOutput, parseGrepOutput, parseReadFileOutput, parseSubagentOutput, parseWebFetchOutput, parseWebSearchOutput, stripRgErrorLines, } from './command-message-helpers.js';
+import { COLOR_TOOL_OUTPUT, COLOR_MUTED as THEME_COLOR_MUTED } from '../theme.js';
+import DiffView from '../layout/DiffView.js';
+// --- Command Message Theme Colors ---
+// Customize these values to change the color scheme per theme.
+const COLOR_ERROR = 'red';
+const COLOR_SUCCESS = '#A0A0A0';
+const COLOR_WARNING = 'yellow';
+const COLOR_INFO = 'cyan';
+const COLOR_MUTED = 'gray';
+const COLOR_CONTENT = 'white';
+const COLOR_LINK = 'blue';
+const COLOR_SPECIAL = 'magenta';
+const getConciseAskUserResponse = (output) => {
+    if (!output)
+        return 'No response';
+    const lines = output.split('\n');
+    const answers = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('Answer: ')) {
+            answers.push(trimmed.slice('Answer: '.length).trim());
+        }
+    }
+    if (answers.length > 0) {
+        return answers.join(', ');
+    }
+    return output;
+};
+const CommandMessage = ({ command, output: rawOutput, status, success, failureReason, toolName, toolArgs, isApprovalRejection, hadApproval, displayMode = 'standard', textColor, isSubagent = false, }) => {
+    const isRunning = status === 'pending' || status === 'running';
+    const [isVisible, setIsVisible] = useState(!isRunning);
+    const { output, runtime } = useMemo(() => {
+        const isShell = !toolName || toolName === 'shell';
+        if (isShell && rawOutput) {
+            const match = rawOutput.match(/(?:^|\r?\n)Runtime:\s*(\d+ms)(?:\r?\n|$)/);
+            if (match) {
+                const cleaned = rawOutput.replace(/(?:^|\r?\n)Runtime:\s*\d+ms(?:\r?\n|$)/, '\n').trim();
+                return {
+                    output: cleaned,
+                    runtime: match[1],
+                };
+            }
+        }
+        return { output: rawOutput || '', runtime: undefined };
+    }, [toolName, rawOutput]);
+    const diff = useMemo(() => {
+        if (toolName !== TOOL_NAME_SEARCH_REPLACE || !toolArgs)
+            return '';
+        if (toolArgs.replacements) {
+            return (toolArgs.replacements || [])
+                .map((rep) => generateDiff(rep.search_content, rep.replace_content))
+                .join('\n');
+        }
+        return generateDiff(toolArgs.search_content, toolArgs.replace_content);
+    }, [toolName, toolArgs?.search_content, toolArgs?.replace_content, toolArgs?.replacements]);
+    const createFileDiffLines = useMemo(() => toolName === TOOL_NAME_CREATE_FILE && toolArgs
+        ? (toolArgs.content ?? '')
+            .split('\n')
+            .map((line) => `+${line}`)
+            .join('\n')
+        : '', [toolName, toolArgs?.content]);
+    // Parse the denial reason from the JSON wrapper that the tool rejection interceptor
+    // produces (e.g. {"output":[{"success":false,"error":"..."}]}).
+    const denialReason = useMemo(() => {
+        if (!output)
+            return 'Tool execution was not approved.';
+        try {
+            const parsed = JSON.parse(output);
+            if (parsed?.output?.[0]?.error)
+                return parsed.output[0].error;
+            if (parsed?.error)
+                return parsed.error;
+        }
+        catch {
+            /* not JSON, use as-is */
+        }
+        return output;
+    }, [output]);
+    const formattedArgs = useMemo(() => {
+        return toolArgs ? formatToolArgs(toolName, toolArgs, displayMode) : '';
+    }, [toolName, toolArgs, displayMode]);
+    const changeStats = useMemo(() => {
+        const diffText = toolName === TOOL_NAME_APPLY_PATCH
+            ? toolArgs?.diff
+            : toolName === TOOL_NAME_SEARCH_REPLACE
+                ? diff
+                : toolName === TOOL_NAME_CREATE_FILE
+                    ? createFileDiffLines
+                    : '';
+        if (!diffText) {
+            return null;
+        }
+        const stats = countDiffStats(diffText);
+        return stats.added === 0 && stats.removed === 0 ? null : stats;
+    }, [createFileDiffLines, diff, toolArgs?.diff, toolName]);
+    const changeStatsElement = changeStats ? (React.createElement(React.Fragment, null,
+        ' ',
+        "(",
+        React.createElement(Text, { color: "green" },
+            "+",
+            changeStats.added),
+        " ",
+        React.createElement(Text, { color: COLOR_ERROR },
+            "-",
+            changeStats.removed),
+        ")")) : null;
+    const matchCount = useMemo(() => {
+        if (displayMode !== 'concise')
+            return 0;
+        if (!isSearchLikeTool(toolName, command))
+            return 0;
+        if (isRunning || isApprovalRejection)
+            return 0;
+        return getMatchCount(toolName, command, output);
+    }, [displayMode, toolName, command, isRunning, isApprovalRejection, output]);
+    const matchCountElement = matchCount > 0 ? (React.createElement(Box, { paddingLeft: 2 },
+        React.createElement(Text, { color: COLOR_MUTED },
+            "(",
+            matchCount,
+            " match",
+            matchCount !== 1 ? 'es' : '',
+            ")"))) : null;
+    useEffect(() => {
+        if (!isRunning) {
+            if (!isVisible) {
+                setIsVisible(true);
+            }
+            return;
+        }
+        const timer = setTimeout(() => {
+            setIsVisible(true);
+        }, 1000);
+        return () => clearTimeout(timer);
+    }, [isRunning]);
+    if (!isVisible && !isSubagent) {
+        return null;
+    }
+    if (displayMode === 'concise') {
+        const displayAction = (() => {
+            const isShell = !toolName || toolName === 'shell';
+            if (isShell) {
+                return (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: COLOR_MUTED }, "$"),
+                    " ",
+                    React.createElement(Text, null, command),
+                    runtime && React.createElement(Text, { color: COLOR_MUTED },
+                        " (",
+                        runtime,
+                        ")")));
+            }
+            const argsText = formattedArgs ? ` ${formattedArgs}` : '';
+            const renderAction = (verb) => (React.createElement(React.Fragment, null,
+                React.createElement(Text, { dimColor: true }, verb),
+                React.createElement(Text, null, argsText)));
+            switch (toolName) {
+                case 'grep':
+                    return renderAction('Searched');
+                case 'find_files':
+                    return renderAction('Searched files');
+                case 'read_file':
+                case 'view_file':
+                    return renderAction('Read');
+                case TOOL_NAME_APPLY_PATCH:
+                    return renderAction('Patched');
+                case TOOL_NAME_SEARCH_REPLACE:
+                    return renderAction('Edited');
+                case TOOL_NAME_CREATE_FILE:
+                    return renderAction('Created');
+                case 'ask_mentor':
+                    return renderAction('Asked mentor');
+                case 'ask_user':
+                    return renderAction('Asked user');
+                case 'web_search':
+                    return renderAction('Web searched');
+                case 'web_fetch':
+                    return renderAction('Web fetched');
+                case 'read_code_outline':
+                    return renderAction('Read outline');
+                case 'code_context_search':
+                    return renderAction('Searched context');
+                case 'run_subagent':
+                    return renderAction('Delegated');
+                default:
+                    return (React.createElement(React.Fragment, null,
+                        React.createElement(Text, { dimColor: true },
+                            "[",
+                            toolName,
+                            "]"),
+                        React.createElement(Text, null, argsText)));
+            }
+        })();
+        if (isSubagent) {
+            const isFailed = status === 'failed' || isApprovalRejection || success === false || Boolean(failureReason);
+            const statusChar = isFailed ? '✖' : isRunning ? '▶' : '✔';
+            const actionText = isFailed ? command : displayAction;
+            return (React.createElement(Box, null,
+                React.createElement(Text, { wrap: "truncate", color: THEME_COLOR_MUTED },
+                    statusChar,
+                    " ",
+                    actionText)));
+        }
+        if (isApprovalRejection) {
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    React.createElement(Text, { color: COLOR_ERROR, bold: true }, "\u2716"),
+                    ' ',
+                    displayAction,
+                    changeStatsElement),
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    " \u2192 DENIED: ",
+                    denialReason)));
+        }
+        if (isRunning) {
+            return (React.createElement(Box, null,
+                React.createElement(Text, { color: COLOR_WARNING },
+                    React.createElement(Text, { bold: true }, "\u25B6"),
+                    " ",
+                    displayAction,
+                    changeStatsElement)));
+        }
+        if (success === false || failureReason) {
+            const errorMsg = failureReason || denialReason || 'failed';
+            const displayErrorMsg = isSearchLikeTool(toolName, command)
+                ? stripRgErrorLines(errorMsg).trim() || 'failed'
+                : errorMsg;
+            // Truncate error message like standard mode truncates output
+            const truncatedError = (() => {
+                const lines = displayErrorMsg.trimEnd().split('\n');
+                const maxLines = 3;
+                if (lines.length > maxLines + 1) {
+                    const firstPart = lines.slice(0, maxLines).join('\n');
+                    const lastLine = lines[lines.length - 1];
+                    return `${firstPart}\n... (${lines.length - maxLines - 1} more lines)\n${lastLine}`;
+                }
+                return displayErrorMsg;
+            })();
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    React.createElement(Text, { color: COLOR_ERROR, bold: true }, "\u2716"),
+                    ' ',
+                    displayAction,
+                    changeStatsElement),
+                matchCountElement,
+                matchCount === 0 && React.createElement(Text, { color: textColor || COLOR_SUCCESS }, truncatedError)));
+        }
+        // Success (one line)
+        if (toolName === 'ask_user') {
+            const responseText = getConciseAskUserResponse(output);
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    React.createElement(Text, { color: 'green', bold: true }, "\u2714"),
+                    ' ',
+                    displayAction),
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    " Response: ",
+                    responseText)));
+        }
+        if (toolName === 'ask_mentor') {
+            const firstParagraph = getFirstParagraph(output, 200);
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    React.createElement(Text, { color: 'green', bold: true }, "\u2714"),
+                    ' ',
+                    displayAction),
+                React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                    " Response: ",
+                    firstParagraph)));
+        }
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: textColor || COLOR_SUCCESS },
+                React.createElement(Text, { color: 'green', bold: true }, "\u2714"),
+                ' ',
+                displayAction,
+                changeStatsElement),
+            matchCountElement));
+    }
+    const outputText = output?.trim() ? output : isRunning ? '(running...)' : '(no output)';
+    const displayed = outputText && outputText !== '(no output)'
+        ? (() => {
+            const trimmedOutput = (output || '').trimEnd();
+            const lines = trimmedOutput.split('\n');
+            const maxLines = 3;
+            if (lines.length > maxLines + 1) {
+                const firstPart = lines.slice(0, maxLines).join('\n');
+                const lastLine = lines[lines.length - 1];
+                return `${firstPart}\n... (${lines.length - maxLines - 1} more lines)\n${lastLine}`;
+            }
+            return output;
+        })()
+        : outputText;
+    // Special handling for apply_patch
+    if (toolName === TOOL_NAME_APPLY_PATCH && toolArgs) {
+        if (hadApproval) {
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+        }
+        const isCreate = toolArgs.type === 'create_file';
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: isCreate ? COLOR_SUCCESS : COLOR_WARNING, bold: true }, isCreate ? '[CREATE FILE]' : '[PATCH]'),
+                React.createElement(Text, null,
+                    " ",
+                    toolArgs.path)),
+            toolArgs.diff && success !== false && React.createElement(DiffView, { diff: toolArgs.diff }),
+            failureReason && React.createElement(Text, { color: COLOR_ERROR },
+                "Error: ",
+                failureReason),
+            React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+    }
+    // Special handling for search_replace
+    if (toolName === TOOL_NAME_SEARCH_REPLACE && toolArgs) {
+        // For search_replace that had an approval prompt (user said 'y'), only show output
+        if (hadApproval) {
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+        }
+        // For auto-approved search_replace (no approval prompt), show diff + output
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: COLOR_WARNING, bold: true }, "[SEARCH & REPLACE]"),
+                React.createElement(Text, null,
+                    " ",
+                    toolArgs.path)),
+            React.createElement(DiffView, { diff: diff }),
+            failureReason && React.createElement(Text, { color: COLOR_ERROR },
+                "Error: ",
+                failureReason),
+            React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+    }
+    // Special handling for create_file
+    if (toolName === TOOL_NAME_CREATE_FILE && toolArgs) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_SUCCESS, bold: true }, "[CREATE]"),
+                React.createElement(Text, null,
+                    " ",
+                    toolArgs.path)),
+            success !== false && React.createElement(DiffView, { diff: createFileDiffLines }),
+            failureReason && React.createElement(Text, { color: COLOR_ERROR },
+                "Error: ",
+                failureReason),
+            React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+    }
+    // Standard mode custom tool renderers
+    if (displayMode === 'standard' && success !== false && !failureReason && !isRunning) {
+        if (toolName === 'read_file' || toolName === 'view_file') {
+            const parsed = parseReadFileOutput(output);
+            if (parsed) {
+                const { filePath, totalLines, startLine, endLine, contentLines } = parsed;
+                const maxContentLines = 10;
+                const displayLines = [];
+                let truncatedCount = 0;
+                if (contentLines.length > maxContentLines + 1) {
+                    const topCount = maxContentLines - 1;
+                    for (let i = 0; i < topCount; i++) {
+                        displayLines.push({ lineNum: startLine + i, content: contentLines[i] ?? '' });
+                    }
+                    truncatedCount = contentLines.length - topCount - 1;
+                    displayLines.push({ lineNum: -1, content: `... (${truncatedCount} lines truncated) ...` });
+                    displayLines.push({
+                        lineNum: startLine + contentLines.length - 1,
+                        content: contentLines[contentLines.length - 1] ?? '',
+                    });
+                }
+                else {
+                    contentLines.forEach((content, i) => {
+                        displayLines.push({ lineNum: startLine + i, content });
+                    });
+                }
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDCD6 [READ FILE]"),
+                        React.createElement(Text, null,
+                            ' ',
+                            filePath,
+                            " (Lines ",
+                            startLine,
+                            "-",
+                            endLine,
+                            " of ",
+                            totalLines,
+                            ")")),
+                    React.createElement(Box, { flexDirection: "column", borderStyle: "single", borderColor: COLOR_MUTED, paddingX: 1, marginTop: 1 }, displayLines.map((line, idx) => {
+                        if (line.lineNum === -1) {
+                            return (React.createElement(Text, { key: idx, color: COLOR_MUTED, dimColor: true }, line.content));
+                        }
+                        const lineNumStr = String(line.lineNum).padStart(5, ' ');
+                        return (React.createElement(Text, { key: idx },
+                            React.createElement(Text, { color: COLOR_MUTED, dimColor: true },
+                                lineNumStr,
+                                " \u2502",
+                                ' '),
+                            React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, line.content)));
+                    }))));
+            }
+        }
+        if (toolName === 'grep') {
+            const parsed = parseGrepOutput(output);
+            if (parsed) {
+                const { matchesByFile, note } = parsed;
+                const filePaths = Object.keys(matchesByFile);
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, { marginBottom: 1 },
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDD0D [GREP RESULTS]"),
+                        React.createElement(Text, null,
+                            " for ",
+                            toolArgs?.pattern || '')),
+                    filePaths.map((filePath, fileIdx) => {
+                        const matches = matchesByFile[filePath] ?? [];
+                        return (React.createElement(Box, { key: fileIdx, flexDirection: "column", marginBottom: 1 },
+                            React.createElement(Box, null,
+                                React.createElement(Text, { color: COLOR_INFO, bold: true },
+                                    "\uD83D\uDCC4 ",
+                                    filePath),
+                                React.createElement(Text, { color: COLOR_MUTED },
+                                    ' ',
+                                    "(",
+                                    matches.length,
+                                    " match",
+                                    matches.length !== 1 ? 'es' : '',
+                                    ")")),
+                            React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, matches.map((match, matchIdx) => {
+                                const lineNumStr = String(match.lineNum).padStart(4, ' ');
+                                return (React.createElement(Text, { key: matchIdx },
+                                    React.createElement(Text, { color: COLOR_MUTED, dimColor: true },
+                                        lineNumStr,
+                                        ":",
+                                        ' '),
+                                    React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, match.content)));
+                            }))));
+                    }),
+                    note && (React.createElement(Box, { marginTop: 1 },
+                        React.createElement(Text, { color: COLOR_WARNING }, note)))));
+            }
+        }
+        if (toolName === 'find_files') {
+            const parsed = parseFindFilesOutput(output);
+            if (parsed) {
+                const { files, note } = parsed;
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, { marginBottom: 1 },
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDCC2 [FILE SEARCH]"),
+                        React.createElement(Text, null,
+                            ' ',
+                            "found ",
+                            files.length,
+                            " file",
+                            files.length !== 1 ? 's' : '')),
+                    React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, files.map((file, idx) => (React.createElement(Text, { key: idx, color: COLOR_TOOL_OUTPUT },
+                        "\uD83D\uDCC4 ",
+                        file)))),
+                    note && (React.createElement(Box, { marginTop: 1 },
+                        React.createElement(Text, { color: COLOR_WARNING }, note)))));
+            }
+        }
+        if (toolName === 'run_subagent') {
+            const parsed = parseSubagentOutput(output, toolArgs);
+            if (parsed) {
+                const { role, status, toolsUsed, filesChanged, mainText } = parsed;
+                const statusColor = status === 'completed' ? COLOR_SUCCESS : status === 'failed' ? COLOR_ERROR : COLOR_WARNING;
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83E\uDD16 [SUBAGENT]"),
+                        React.createElement(Text, null,
+                            " ",
+                            role,
+                            " "),
+                        React.createElement(Text, { color: statusColor, bold: true },
+                            "(",
+                            status.toUpperCase(),
+                            ")")),
+                    (toolsUsed || filesChanged) && (React.createElement(Box, { flexDirection: "column", paddingLeft: 2, marginY: 0.5 },
+                        toolsUsed && (React.createElement(Text, { color: COLOR_MUTED },
+                            "\uD83D\uDEE0\uFE0F Tools: ",
+                            React.createElement(Text, { color: COLOR_CONTENT }, toolsUsed))),
+                        filesChanged && (React.createElement(Text, { color: COLOR_MUTED },
+                            "\uD83D\uDCDD Changed: ",
+                            React.createElement(Text, { color: COLOR_CONTENT }, filesChanged))))),
+                    mainText && (React.createElement(Box, { flexDirection: "column", borderStyle: "single", borderColor: COLOR_INFO, paddingX: 1, marginTop: 1 },
+                        React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, mainText)))));
+            }
+        }
+        if (toolName === 'web_search') {
+            const parsed = parseWebSearchOutput(output);
+            if (parsed) {
+                const { answer, results } = parsed;
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, { marginBottom: 1 },
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83C\uDF10 [WEB SEARCH]"),
+                        React.createElement(Text, null,
+                            " \"",
+                            toolArgs?.query || '',
+                            "\"")),
+                    answer && (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLOR_WARNING, paddingX: 1, marginBottom: 1 },
+                        React.createElement(Text, { color: COLOR_WARNING, bold: true }, "\uD83D\uDCA1 Answer Summary"),
+                        React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, answer))),
+                    results && results.length > 0 && (React.createElement(Box, { flexDirection: "column" },
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDCCB Search Results:"),
+                        results.map((res, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginTop: 1, paddingLeft: 2 },
+                            React.createElement(Text, { bold: true, color: COLOR_CONTENT },
+                                idx + 1,
+                                ". ",
+                                res.title),
+                            React.createElement(Text, { color: COLOR_LINK, underline: true },
+                                "\uD83D\uDD17 ",
+                                res.url),
+                            res.published && (React.createElement(Text, { color: COLOR_MUTED, dimColor: true },
+                                "\uD83D\uDCC5 Published: ",
+                                res.published)),
+                            React.createElement(Box, { marginTop: 1 },
+                                React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, res.content)))))))));
+            }
+        }
+        if (toolName === 'web_fetch') {
+            const parsed = parseWebFetchOutput(output);
+            if (parsed) {
+                const { title, url, toc, tempFile, notes, content } = parsed;
+                const maxLines = 15;
+                const contentLines = content.split('\n');
+                let displayContent = content;
+                let truncatedCount = 0;
+                if (contentLines.length > maxLines + 1) {
+                    const firstPart = contentLines.slice(0, maxLines).join('\n');
+                    const lastLine = contentLines[contentLines.length - 1];
+                    truncatedCount = contentLines.length - maxLines - 1;
+                    displayContent = `${firstPart}\n\n... (${truncatedCount} lines of content truncated for preview) ...\n\n${lastLine}`;
+                }
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDCE5 [WEB FETCH]"),
+                        React.createElement(Text, null,
+                            " ",
+                            title)),
+                    React.createElement(Box, { paddingLeft: 2 },
+                        React.createElement(Text, { color: COLOR_LINK, underline: true },
+                            "\uD83D\uDD17 ",
+                            url)),
+                    toc && (React.createElement(Box, { flexDirection: "column", borderStyle: "classic", borderColor: COLOR_MUTED, paddingX: 1, marginY: 1, width: 50 },
+                        React.createElement(Text, { color: COLOR_WARNING, bold: true }, "\uD83D\uDCCB Table of Contents"),
+                        React.createElement(Text, { color: COLOR_MUTED }, toc))),
+                    content && (React.createElement(Box, { flexDirection: "column", borderStyle: "single", borderColor: COLOR_MUTED, paddingX: 1, marginTop: 1 },
+                        React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, displayContent))),
+                    tempFile && (React.createElement(Box, { marginTop: 1 },
+                        React.createElement(Text, { color: COLOR_WARNING },
+                            "\uD83D\uDCBE Full content saved to:",
+                            ' ',
+                            React.createElement(Text, { bold: true, color: COLOR_CONTENT }, tempFile)))),
+                    notes && (React.createElement(Box, { marginTop: 0.5 },
+                        React.createElement(Text, { color: COLOR_WARNING },
+                            "\u26A0\uFE0F ",
+                            notes)))));
+            }
+        }
+        if (toolName === 'ask_mentor') {
+            return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83E\uDDE0 [MENTOR QUESTION]"),
+                    React.createElement(Text, { color: COLOR_CONTENT, italic: true },
+                        ' ',
+                        "\"",
+                        toolArgs?.question || '',
+                        "\"")),
+                React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLOR_SPECIAL, paddingX: 1, marginTop: 1 },
+                    React.createElement(Text, { color: COLOR_SPECIAL, bold: true }, "\uD83D\uDCAC Mentor Response"),
+                    React.createElement(Text, { color: COLOR_TOOL_OUTPUT }, output))));
+        }
+        if (toolName === 'ask_user') {
+            const options = toolArgs?.options;
+            return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: COLOR_INFO, bold: true }, "\u2753 [ASK USER]"),
+                    React.createElement(Text, { color: COLOR_CONTENT },
+                        " ",
+                        toolArgs?.question || 'Unknown question')),
+                options && Array.isArray(options) && options.length > 0 && (React.createElement(Box, { paddingLeft: 2, marginY: 0.5 },
+                    React.createElement(Text, { color: COLOR_MUTED }, "Options: "),
+                    options.map((opt, idx) => (React.createElement(Text, { key: idx, color: idx === 0 ? COLOR_SUCCESS : COLOR_CONTENT },
+                        idx > 0 ? ', ' : '',
+                        "[",
+                        opt,
+                        "]",
+                        idx === 0 ? ' (Recommended)' : ''))))),
+                React.createElement(Box, { paddingLeft: 2, marginTop: 0.5 },
+                    React.createElement(Text, { color: COLOR_MUTED }, "\uD83D\uDDE3\uFE0F Response: "),
+                    React.createElement(Text, { color: COLOR_SUCCESS, bold: true }, output || 'No response yet'))));
+        }
+        if (toolName === 'read_code_outline') {
+            const parsed = parseCodeOutlineOutput(output);
+            if (parsed) {
+                const { filePath, lang, imports, exports, decls } = parsed;
+                return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                    React.createElement(Box, { marginBottom: 1 },
+                        React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDCD1 [CODE OUTLINE]"),
+                        React.createElement(Text, null,
+                            ' ',
+                            filePath,
+                            " (",
+                            lang,
+                            ")")),
+                    imports && imports.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2 },
+                        React.createElement(Text, { color: COLOR_WARNING, bold: true }, "\uD83D\uDCE6 Imports:"),
+                        imports.map((imp, idx) => (React.createElement(Text, { key: idx, color: COLOR_TOOL_OUTPUT },
+                            ' ',
+                            "\u2022 ",
+                            imp))))),
+                    exports && exports.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2 },
+                        React.createElement(Text, { color: COLOR_SUCCESS, bold: true }, "\uD83D\uDCE4 Exports:"),
+                        exports.map((exp, idx) => (React.createElement(Text, { key: idx, color: COLOR_TOOL_OUTPUT },
+                            ' ',
+                            "\u2022 ",
+                            exp))))),
+                    decls && decls.length > 0 && (React.createElement(Box, { flexDirection: "column", paddingLeft: 2 },
+                        React.createElement(Text, { color: COLOR_LINK, bold: true }, "\uD83D\uDEE0\uFE0F Declarations:"),
+                        decls.map((decl, idx) => (React.createElement(Text, { key: idx, color: COLOR_TOOL_OUTPUT },
+                            ' ',
+                            "\u2022 ",
+                            decl)))))));
+            }
+        }
+        if (toolName === 'code_context_search') {
+            const parsed = parseCodeContextSearchOutput(output);
+            if (parsed) {
+                const { queryType } = parsed;
+                if (queryType === 'related') {
+                    const { target, relatedFiles } = parsed;
+                    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                        React.createElement(Box, { marginBottom: 1 },
+                            React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDD17 [RELATED FILES]"),
+                            React.createElement(Text, null,
+                                " for ",
+                                target)),
+                        !relatedFiles || relatedFiles.length === 0 ? (React.createElement(Box, { paddingLeft: 2 },
+                            React.createElement(Text, { color: COLOR_MUTED }, "No related files found."))) : (React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, relatedFiles.map((f, idx) => (React.createElement(Box, { key: idx, flexDirection: "column", marginBottom: 0.5 },
+                            React.createElement(Text, { color: COLOR_CONTENT },
+                                "\uD83D\uDCC4 ",
+                                f.filePath),
+                            React.createElement(Text, { color: COLOR_MUTED, dimColor: true },
+                                ' ',
+                                "Relations: ",
+                                f.relations))))))));
+                }
+                else {
+                    const { symbol, results } = parsed;
+                    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+                        React.createElement(Box, { marginBottom: 1 },
+                            React.createElement(Text, { color: COLOR_INFO, bold: true }, "\uD83D\uDD0D [SYMBOL SEARCH]"),
+                            React.createElement(Text, null,
+                                " \"",
+                                symbol,
+                                "\"")),
+                        !results || results.length === 0 ? (React.createElement(Box, { paddingLeft: 2 },
+                            React.createElement(Text, { color: COLOR_MUTED }, "No symbol declarations found."))) : (React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, results.map((res, idx) => (React.createElement(Text, { key: idx },
+                            React.createElement(Text, { color: COLOR_CONTENT },
+                                "\uD83D\uDCC4 ",
+                                res.filePath,
+                                ":",
+                                res.lineNum),
+                            React.createElement(Text, { color: COLOR_MUTED, dimColor: true },
+                                ' ',
+                                "\u2502",
+                                ' '),
+                            React.createElement(Text, { color: COLOR_WARNING },
+                                res.kind,
+                                " ",
+                                res.name),
+                            res.exported && (React.createElement(Text, { color: COLOR_SUCCESS, dimColor: true },
+                                ' ',
+                                "(exported)")))))))));
+                }
+            }
+        }
+    }
+    // Special handling for approval-rejected shell commands: show the denial message
+    // with a clear [DENIED] label so the user knows what was attempted and why.
+    if (isApprovalRejection) {
+        // Extract just the command part for display (e.g. "rm -rf /dangerous").
+        const displayCommand = formattedArgs || command;
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: COLOR_ERROR, bold: true },
+                "$ ",
+                React.createElement(Text, { bold: true }, displayCommand)),
+            React.createElement(Text, { color: COLOR_ERROR },
+                "\u2192 DENIED: ",
+                denialReason)));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { color: success === false ? COLOR_ERROR : isRunning ? COLOR_WARNING : COLOR_INFO },
+            "$ ",
+            React.createElement(Text, { bold: true }, command),
+            isRunning && formattedArgs && command === toolName && React.createElement(Text, { color: COLOR_WARNING },
+                " ",
+                formattedArgs),
+            runtime && React.createElement(Text, { color: COLOR_MUTED },
+                " (",
+                runtime,
+                ")")),
+        failureReason && React.createElement(Text, { color: COLOR_ERROR },
+            "Error: ",
+            failureReason),
+        React.createElement(Text, { color: success === false ? COLOR_ERROR : COLOR_TOOL_OUTPUT }, displayed)));
+};
+export default React.memo(CommandMessage);
+//# sourceMappingURL=CommandMessage.js.map