snow-ai 0.4.16 → 0.4.18

package/dist/ui/components/HelpPanel.js

@@ -1,67 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { useI18n } from '../../i18n/index.js';
-// Get platform-specific paste key
-const getPasteKey = () => {
-    return process.platform === 'darwin' ? 'Ctrl+V' : 'Alt+V';
-};
-export default function HelpPanel() {
-    const pasteKey = getPasteKey();
-    const { t } = useI18n();
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "cyan" }, t.helpPanel.title)),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, t.helpPanel.textEditingTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.deleteToStart),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.deleteToEnd),
-            React.createElement(Text, null,
-                ' ',
-                "\u2022 ",
-                t.helpPanel.pasteImages.replace('{pasteKey}', pasteKey))),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, t.helpPanel.quickAccessTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.insertFiles),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.searchContent),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.selectAgent),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.showCommands)),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "blue" }, t.helpPanel.navigationTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.navigateHistory),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.selectItem),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.cancelClose),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.toggleYolo)),
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { bold: true, color: "magenta" }, t.helpPanel.tipsTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipUseHelp),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipShowCommands),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipInterrupt)),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { dimColor: true, color: "gray" }, t.helpPanel.closeHint))));
-}

package/dist/ui/components/MCPInfoPanel.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export default function MCPInfoPanel(): React.JSX.Element;

package/dist/ui/components/MCPInfoPanel.js

@@ -1,108 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
-import SelectInput from 'ink-select-input';
-import { getMCPServicesInfo, refreshMCPToolsCache, reconnectMCPService } from '../../utils/mcpToolsManager.js';
-export default function MCPInfoPanel() {
-    const [mcpStatus, setMcpStatus] = useState([]);
-    const [isLoading, setIsLoading] = useState(true);
-    const [errorMessage, setErrorMessage] = useState(null);
-    const [isReconnecting, setIsReconnecting] = useState(false);
-    const loadMCPStatus = async () => {
-        try {
-            const servicesInfo = await getMCPServicesInfo();
-            const statusList = servicesInfo.map(service => ({
-                name: service.serviceName,
-                connected: service.connected,
-                tools: service.tools.map(tool => tool.name),
-                connectionMethod: service.isBuiltIn ? 'Built-in' : 'External',
-                isBuiltIn: service.isBuiltIn,
-                error: service.error
-            }));
-            setMcpStatus(statusList);
-            setErrorMessage(null);
-            setIsLoading(false);
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to load MCP services');
-            setIsLoading(false);
-        }
-    };
-    useEffect(() => {
-        let isMounted = true;
-        const load = async () => {
-            await loadMCPStatus();
-        };
-        if (isMounted) {
-            load();
-        }
-        return () => {
-            isMounted = false;
-        };
-    }, []);
-    const handleServiceSelect = async (item) => {
-        setIsReconnecting(true);
-        try {
-            if (item.value === 'refresh-all') {
-                // Refresh all services
-                await refreshMCPToolsCache();
-            }
-            else {
-                // Reconnect specific service
-                await reconnectMCPService(item.value);
-            }
-            await loadMCPStatus();
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to reconnect');
-        }
-        finally {
-            setIsReconnecting(false);
-        }
-    };
-    // Build select items from all services
-    const selectItems = [
-        { label: 'Refresh all services', value: 'refresh-all', isRefreshAll: true },
-        ...mcpStatus.map(s => ({
-            label: s.name,
-            value: s.name,
-            connected: s.connected,
-            isBuiltIn: s.isBuiltIn,
-            error: s.error
-        }))
-    ];
-    // Custom item component to render with colors
-    const ItemComponent = ({ isSelected, label }) => {
-        const item = selectItems.find(i => i.label === label);
-        if (!item)
-            return React.createElement(Text, null, label);
-        if (item.isRefreshAll) {
-            return (React.createElement(Text, { color: isSelected ? 'cyan' : 'blue' },
-                "\u21BB ",
-                label));
-        }
-        const statusColor = item.connected ? 'green' : 'red';
-        const suffix = item.isBuiltIn ? ' (System)' : item.connected ? ' (External)' : ` - ${item.error || 'Failed'}`;
-        return (React.createElement(Box, null,
-            React.createElement(Text, { color: statusColor }, "\u25CF "),
-            React.createElement(Text, { color: isSelected ? 'cyan' : 'white' }, label),
-            React.createElement(Text, { color: "gray", dimColor: true }, suffix)));
-    };
-    if (isLoading) {
-        return (React.createElement(Text, { color: "gray" }, "Loading MCP services..."));
-    }
-    if (errorMessage) {
-        return (React.createElement(Box, { borderColor: "red", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "red", dimColor: true },
-                "Error: ",
-                errorMessage)));
-    }
-    if (mcpStatus.length === 0) {
-        return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "gray", dimColor: true }, "No available MCP services detected")));
-    }
-    return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0 },
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "cyan", bold: true }, isReconnecting ? 'Refreshing services...' : 'MCP Services'),
-            !isReconnecting && (React.createElement(SelectInput, { items: selectItems, onSelect: handleServiceSelect, itemComponent: ItemComponent })),
-            isReconnecting && (React.createElement(Text, { color: "yellow", dimColor: true }, "Please wait...")))));
-}

package/dist/ui/components/MCPInfoScreen.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-type Props = {
-    onClose: () => void;
-    panelKey: number;
-};
-export default function MCPInfoScreen({ onClose, panelKey }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/MCPInfoScreen.js

@@ -1,115 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import SelectInput from 'ink-select-input';
-import { getMCPServicesInfo, refreshMCPToolsCache, reconnectMCPService } from '../../utils/mcpToolsManager.js';
-export default function MCPInfoScreen({ onClose, panelKey }) {
-    const [mcpStatus, setMcpStatus] = useState([]);
-    const [isLoading, setIsLoading] = useState(true);
-    const [errorMessage, setErrorMessage] = useState(null);
-    const [isReconnecting, setIsReconnecting] = useState(false);
-    const loadMCPStatus = async () => {
-        try {
-            const servicesInfo = await getMCPServicesInfo();
-            const statusList = servicesInfo.map(service => ({
-                name: service.serviceName,
-                connected: service.connected,
-                tools: service.tools.map(tool => tool.name),
-                connectionMethod: service.isBuiltIn ? 'Built-in' : 'External',
-                isBuiltIn: service.isBuiltIn,
-                error: service.error
-            }));
-            setMcpStatus(statusList);
-            setErrorMessage(null);
-            setIsLoading(false);
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to load MCP services');
-            setIsLoading(false);
-        }
-    };
-    useEffect(() => {
-        process.stdout.write('\x1B[?1049h');
-        process.stdout.write('\x1B[2J');
-        process.stdout.write('\x1B[H');
-        return () => {
-            process.stdout.write('\x1B[2J');
-            process.stdout.write('\x1B[?1049l');
-        };
-    }, []);
-    useEffect(() => {
-        loadMCPStatus();
-    }, [panelKey]);
-    useInput((_, key) => {
-        if (key.escape) {
-            onClose();
-        }
-    });
-    const handleServiceSelect = async (item) => {
-        setIsReconnecting(true);
-        try {
-            if (item.value === 'refresh-all') {
-                // Refresh all services
-                await refreshMCPToolsCache();
-            }
-            else {
-                // Reconnect specific service
-                await reconnectMCPService(item.value);
-            }
-            await loadMCPStatus();
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to reconnect');
-        }
-        finally {
-            setIsReconnecting(false);
-        }
-    };
-    // Build select items from all services
-    const selectItems = [
-        { label: 'Refresh all services', value: 'refresh-all', isRefreshAll: true },
-        ...mcpStatus.map(s => ({
-            label: s.name,
-            value: s.name,
-            connected: s.connected,
-            isBuiltIn: s.isBuiltIn,
-            error: s.error
-        }))
-    ];
-    // Custom item component to render with colors
-    const ItemComponent = ({ isSelected, label }) => {
-        const item = selectItems.find(i => i.label === label);
-        if (!item)
-            return React.createElement(Text, null, label);
-        if (item.isRefreshAll) {
-            return (React.createElement(Text, { color: isSelected ? 'cyan' : 'blue' },
-                "\u21BB ",
-                label));
-        }
-        const statusColor = item.connected ? 'green' : 'red';
-        const suffix = item.isBuiltIn ? ' (System)' : item.connected ? ' (External)' : ` - ${item.error || 'Failed'}`;
-        return (React.createElement(Box, null,
-            React.createElement(Text, { color: statusColor }, "\u25CF "),
-            React.createElement(Text, { color: isSelected ? 'cyan' : 'white' }, label),
-            React.createElement(Text, { color: "gray", dimColor: true }, suffix)));
-    };
-    if (isLoading) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Text, { color: "gray" }, "Loading MCP services...")));
-    }
-    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        React.createElement(Box, { borderStyle: "double", paddingX: 2, paddingY: 0, borderColor: "cyan" },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: "white", bold: true },
-                    React.createElement(Text, { color: "cyan" }, "\u2746 "),
-                    "MCP Services Overview"),
-                React.createElement(Text, { color: "gray", dimColor: true }, "Press ESC to return | Use \u2191\u2193 and Enter to refresh"))),
-        errorMessage && (React.createElement(Box, { borderColor: "red", borderStyle: "round", paddingX: 2, paddingY: 0, marginTop: 1 },
-            React.createElement(Text, { color: "red", dimColor: true },
-                "Error: ",
-                errorMessage))),
-        React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0, marginTop: 1 },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: "cyan", bold: true }, isReconnecting ? 'Refreshing services...' : 'MCP Services'),
-                !isReconnecting && (React.createElement(SelectInput, { items: selectItems, onSelect: handleServiceSelect, itemComponent: ItemComponent })),
-                isReconnecting && (React.createElement(Text, { color: "yellow", dimColor: true }, "Please wait..."))))));
-}

package/dist/ui/components/MarkdownRenderer.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface Props {
-    content: string;
-}
-export default function MarkdownRenderer({ content }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/MarkdownRenderer.js

@@ -1,70 +0,0 @@
-import React from 'react';
-import { Text, Box } from 'ink';
-import { marked } from 'marked';
-import TerminalRenderer from 'marked-terminal';
-import logger from '../../utils/logger.js';
-// Configure marked to use terminal renderer
-marked.setOptions({
-    // @ts-expect-error - marked-terminal types mismatch with marked v15
-    renderer: new TerminalRenderer({
-        reflowText: true,
-        width: 80,
-        emoji: false,
-        tab: 2,
-    }),
-});
-/**
- * Sanitize markdown content to prevent number-to-alphabet errors
- * Fixes invalid ordered list start attributes (0 or negative values)
- */
-function sanitizeMarkdownContent(content) {
-    // Replace <ol start="0">, <ol start="-1">, etc. with <ol start="1">
-    return content.replace(/<ol\s+start=["']?(0|-\d+)["']?>/gi, '<ol start="1">');
-}
-/**
- * Fallback renderer for when cli-markdown fails
- * Renders content as plain text to ensure visibility
- */
-function renderFallback(content) {
-    const lines = content.split('\n');
-    return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => (React.createElement(Text, { key: index }, line)))));
-}
-export default function MarkdownRenderer({ content }) {
-    // Use marked + marked-terminal for elegant markdown rendering with syntax highlighting
-    // marked provides better stability and cross-platform support
-    try {
-        // Stage 1: Sanitize content to prevent invalid list numbering
-        const sanitizedContent = sanitizeMarkdownContent(content);
-        // Stage 2: Render with marked
-        const rendered = marked.parse(sanitizedContent);
-        // Split into lines and render each separately
-        // This prevents Ink's Text component from creating mysterious whitespace
-        // when handling multi-line content with \n characters
-        const lines = rendered.split('\n');
-        // Safety check: prevent rendering issues with excessively long output
-        if (lines.length > 500) {
-            logger.warn('[MarkdownRenderer] Rendered output has too many lines', {
-                totalLines: lines.length,
-                truncatedTo: 500,
-            });
-            return (React.createElement(Box, { flexDirection: "column" }, lines.slice(0, 500).map((line, index) => (React.createElement(Text, { key: index }, line)))));
-        }
-        return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => (React.createElement(Text, { key: index }, line)))));
-    }
-    catch (error) {
-        // Stage 3: Error handling - catch number-to-alphabet errors
-        if (error?.message?.includes('Number must be >')) {
-            logger.warn('[MarkdownRenderer] Invalid list numbering detected, falling back to plain text', {
-                error: error.message,
-            });
-            return renderFallback(content);
-        }
-        // Re-throw other errors for debugging
-        logger.error('[MarkdownRenderer] Unexpected error during markdown rendering', {
-            error: error.message,
-            stack: error.stack,
-        });
-        // Still provide fallback to prevent crash
-        return renderFallback(content);
-    }
-}

package/dist/ui/components/Menu.d.ts

@@ -1,17 +0,0 @@
-import React from 'react';
-type MenuOption = {
-    label: string;
-    value: string;
-    color?: string;
-    infoText?: string;
-    clearTerminal?: boolean;
-};
-type Props = {
-    options: MenuOption[];
-    onSelect: (value: string) => void;
-    onSelectionChange?: (infoText: string, value: string) => void;
-    maxHeight?: number;
-};
-declare function Menu({ options, onSelect, onSelectionChange, maxHeight }: Props): React.JSX.Element;
-declare const _default: React.MemoExoticComponent<typeof Menu>;
-export default _default;

package/dist/ui/components/Menu.js

@@ -1,88 +0,0 @@
-import React, { useState, useCallback } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
-import { resetTerminal } from '../../utils/terminal.js';
-import { useI18n } from '../../i18n/index.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-function Menu({ options, onSelect, onSelectionChange, maxHeight }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [scrollOffset, setScrollOffset] = useState(0);
-    const { stdout } = useStdout();
-    const { t } = useI18n();
-    const { theme } = useTheme();
-    // Calculate available height
-    const terminalHeight = stdout?.rows || 24;
-    const headerHeight = 8; // Space for header, borders, etc.
-    const defaultMaxHeight = Math.max(5, terminalHeight - headerHeight);
-    const visibleItemCount = maxHeight || defaultMaxHeight;
-    React.useEffect(() => {
-        const currentOption = options[selectedIndex];
-        if (onSelectionChange && currentOption?.infoText) {
-            onSelectionChange(currentOption.infoText, currentOption.value);
-        }
-    }, [selectedIndex, options, onSelectionChange]);
-    // Auto-scroll to keep selected item visible
-    React.useEffect(() => {
-        if (selectedIndex < scrollOffset) {
-            setScrollOffset(selectedIndex);
-        }
-        else if (selectedIndex >= scrollOffset + visibleItemCount) {
-            setScrollOffset(selectedIndex - visibleItemCount + 1);
-        }
-    }, [selectedIndex, scrollOffset, visibleItemCount]);
-    const clearTerminal = useCallback(() => {
-        resetTerminal(stdout);
-    }, [stdout]);
-    const handleInput = useCallback((_input, key) => {
-        if (key.upArrow) {
-            setSelectedIndex(prev => (prev > 0 ? prev - 1 : options.length - 1));
-        }
-        else if (key.downArrow) {
-            setSelectedIndex(prev => (prev < options.length - 1 ? prev + 1 : 0));
-        }
-        else if (key.return) {
-            const selectedOption = options[selectedIndex];
-            if (selectedOption) {
-                if (selectedOption.clearTerminal) {
-                    clearTerminal();
-                }
-                onSelect(selectedOption.value);
-            }
-        }
-    }, [options, selectedIndex, onSelect, clearTerminal]);
-    useInput(handleInput);
-    // Calculate visible options and "more" counts
-    const visibleOptions = options.slice(scrollOffset, scrollOffset + visibleItemCount);
-    const hasMoreAbove = scrollOffset > 0;
-    const hasMoreBelow = scrollOffset + visibleItemCount < options.length;
-    const moreAboveCount = scrollOffset;
-    const moreBelowCount = options.length - (scrollOffset + visibleItemCount);
-    return (React.createElement(Box, { flexDirection: "column", width: '100%', padding: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: theme.colors.menuInfo }, t.menu.navigate)),
-        hasMoreAbove && (React.createElement(Box, null,
-            React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                "\u2191 +",
-                moreAboveCount,
-                " more above"))),
-        visibleOptions.map((option, index) => {
-            const actualIndex = scrollOffset + index;
-            return (React.createElement(Box, { key: option.value },
-                React.createElement(Text, { color: actualIndex === selectedIndex
-                        ? theme.colors.menuSelected
-                        : option.color || theme.colors.menuNormal, bold: true },
-                    actualIndex === selectedIndex ? '❯ ' : '  ',
-                    option.label)));
-        }),
-        hasMoreBelow && (React.createElement(Box, null,
-            React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                "\u2193 +",
-                moreBelowCount,
-                " more below")))));
-}
-// Memoize to prevent unnecessary re-renders
-export default React.memo(Menu, (prevProps, nextProps) => {
-    return (prevProps.options === nextProps.options &&
-        prevProps.onSelect === nextProps.onSelect &&
-        prevProps.onSelectionChange === nextProps.onSelectionChange &&
-        prevProps.maxHeight === nextProps.maxHeight);
-});

package/dist/ui/components/MessageList.d.ts

@@ -1,56 +0,0 @@
-import React from 'react';
-import { SelectedFile } from '../../utils/fileUtils.js';
-export interface Message {
-    role: 'user' | 'assistant' | 'command' | 'subagent';
-    content: string;
-    streaming?: boolean;
-    discontinued?: boolean;
-    commandName?: string;
-    files?: SelectedFile[];
-    images?: Array<{
-        type: 'image';
-        data: string;
-        mimeType: string;
-    }>;
-    toolCall?: {
-        name: string;
-        arguments: any;
-    };
-    toolDisplay?: {
-        toolName: string;
-        args: Array<{
-            key: string;
-            value: string;
-            isLast: boolean;
-        }>;
-    };
-    toolResult?: string;
-    toolCallId?: string;
-    toolPending?: boolean;
-    terminalResult?: {
-        stdout?: string;
-        stderr?: string;
-        exitCode?: number;
-        command?: string;
-    };
-    subAgent?: {
-        agentId: string;
-        agentName: string;
-        isComplete?: boolean;
-    };
-    subAgentInternal?: boolean;
-    subAgentUsage?: {
-        inputTokens: number;
-        outputTokens: number;
-        cacheCreationInputTokens?: number;
-        cacheReadInputTokens?: number;
-    };
-    parallelGroup?: string;
-}
-interface Props {
-    messages: Message[];
-    animationFrame: number;
-    maxMessages?: number;
-}
-declare const MessageList: React.MemoExoticComponent<({ messages, animationFrame, maxMessages }: Props) => React.JSX.Element | null>;
-export default MessageList;

package/dist/ui/components/MessageList.js

@@ -1,97 +0,0 @@
-import React, { memo } from 'react';
-import { Box, Text } from 'ink';
-import MarkdownRenderer from './MarkdownRenderer.js';
-const STREAM_COLORS = ['#FF6EBF', 'green', 'blue', 'cyan', '#B588F8'];
-const MessageList = memo(({ messages, animationFrame, maxMessages = 6 }) => {
-    if (messages.length === 0) {
-        return null;
-    }
-    return (React.createElement(Box, { flexDirection: "column", overflow: "hidden" }, messages.slice(-maxMessages).map((message, index) => {
-        const iconColor = message.role === 'user'
-            ? 'green'
-            : message.role === 'command'
-                ? 'gray'
-                : message.role === 'subagent'
-                    ? 'magenta'
-                    : message.streaming
-                        ? STREAM_COLORS[animationFrame]
-                        : 'cyan';
-        return (React.createElement(Box, { key: index },
-            React.createElement(Text, { color: iconColor, bold: true }, message.role === 'user'
-                ? '⛇'
-                : message.role === 'command'
-                    ? '⌘'
-                    : message.role === 'subagent'
-                        ? '◈'
-                        : '❆'),
-            React.createElement(Box, { marginLeft: 1, flexDirection: "column" }, message.role === 'command' ? (React.createElement(Text, { color: "gray" },
-                "\u2514\u2500 ",
-                message.commandName)) : message.role === 'subagent' ? (React.createElement(React.Fragment, null,
-                React.createElement(Text, { color: "magenta", dimColor: true },
-                    "\u2514\u2500 Sub-Agent: ",
-                    message.subAgent?.agentName,
-                    message.subAgent?.isComplete ? ' ✓' : ' ...'),
-                React.createElement(Box, { marginLeft: 2 },
-                    React.createElement(Text, { color: "gray" }, message.content || ' ')))) : (React.createElement(React.Fragment, null,
-                message.role === 'user' ? (React.createElement(Text, { color: "white", backgroundColor: "#4a4a4a" }, message.content || ' ')) : (React.createElement(MarkdownRenderer, { content: message.content || ' ' })),
-                (message.files || message.images) && (React.createElement(Box, { flexDirection: "column" },
-                    message.files && message.files.length > 0 && (React.createElement(React.Fragment, null, message.files.map((file, fileIndex) => (React.createElement(Text, { key: fileIndex, color: "gray", dimColor: true }, file.isImage
-                        ? `└─ [image #{fileIndex + 1}] ${file.path}`
-                        : `└─ Read \`${file.path}\`${file.exists
-                            ? ` (total line ${file.lineCount})`
-                            : ' (file not found)'}`))))),
-                    message.images && message.images.length > 0 && (React.createElement(React.Fragment, null, message.images.map((_image, imageIndex) => (React.createElement(Text, { key: imageIndex, color: "gray", dimColor: true },
-                        "\u2514\u2500 [image #",
-                        imageIndex + 1,
-                        "]"))))))),
-                message.toolCall &&
-                    message.toolCall.name === 'terminal-execute' &&
-                    message.toolCall.arguments.command && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        "\u2514\u2500 Command:",
-                        ' ',
-                        React.createElement(Text, { color: "white" }, message.toolCall.arguments.command)),
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        "\u2514\u2500 Exit Code:",
-                        ' ',
-                        React.createElement(Text, { color: message.toolCall.arguments.exitCode === 0
-                                ? 'green'
-                                : 'red' }, message.toolCall.arguments.exitCode)),
-                    message.toolCall.arguments.stdout &&
-                        message.toolCall.arguments.stdout.trim().length >
-                            0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-                        React.createElement(Text, { color: "green", dimColor: true }, "\u2514\u2500 stdout:"),
-                        React.createElement(Box, { paddingLeft: 2 },
-                            React.createElement(Text, { color: "white" }, message.toolCall.arguments.stdout
-                                .trim()
-                                .split('\n')
-                                .slice(0, 20)
-                                .join('\n')),
-                            message.toolCall.arguments.stdout
-                                .trim()
-                                .split('\n').length > 20 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))),
-                    message.toolCall.arguments.stderr &&
-                        message.toolCall.arguments.stderr.trim().length >
-                            0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-                        React.createElement(Text, { color: "red", dimColor: true }, "\u2514\u2500 stderr:"),
-                        React.createElement(Box, { paddingLeft: 2 },
-                            React.createElement(Text, { color: "red" }, message.toolCall.arguments.stderr
-                                .trim()
-                                .split('\n')
-                                .slice(0, 10)
-                                .join('\n')),
-                            message.toolCall.arguments.stderr
-                                .trim()
-                                .split('\n').length > 10 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))))),
-                message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue")))))));
-    })));
-}, (prevProps, nextProps) => {
-    const hasStreamingMessage = nextProps.messages.some(m => m.streaming);
-    if (hasStreamingMessage) {
-        return (prevProps.messages === nextProps.messages &&
-            prevProps.animationFrame === nextProps.animationFrame);
-    }
-    return prevProps.messages === nextProps.messages;
-});
-MessageList.displayName = 'MessageList';
-export default MessageList;

package/dist/ui/components/PendingMessages.d.ts

@@ -1,13 +0,0 @@
-import React from 'react';
-interface PendingMessage {
-    text: string;
-    images?: Array<{
-        data: string;
-        mimeType: string;
-    }>;
-}
-interface Props {
-    pendingMessages: PendingMessage[];
-}
-export default function PendingMessages({ pendingMessages }: Props): React.JSX.Element | null;
-export {};