snow-ai 0.4.15 → 0.4.17

package/dist/ui/components/ChatInput.js

@@ -1,379 +0,0 @@
-import React, { useCallback, useEffect, useRef, useMemo } from 'react';
-import { Box, Text } from 'ink';
-import { cpSlice } from '../../utils/textUtils.js';
-import CommandPanel from './CommandPanel.js';
-import FileList from './FileList.js';
-import AgentPickerPanel from './AgentPickerPanel.js';
-import TodoPickerPanel from './TodoPickerPanel.js';
-import { useInputBuffer } from '../../hooks/useInputBuffer.js';
-import { useCommandPanel } from '../../hooks/useCommandPanel.js';
-import { useFilePicker } from '../../hooks/useFilePicker.js';
-import { useHistoryNavigation } from '../../hooks/useHistoryNavigation.js';
-import { useClipboard } from '../../hooks/useClipboard.js';
-import { useKeyboardInput } from '../../hooks/useKeyboardInput.js';
-import { useTerminalSize } from '../../hooks/useTerminalSize.js';
-import { useTerminalFocus } from '../../hooks/useTerminalFocus.js';
-import { useAgentPicker } from '../../hooks/useAgentPicker.js';
-import { useTodoPicker } from '../../hooks/useTodoPicker.js';
-import { useI18n } from '../../i18n/index.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-/**
- * Calculate context usage percentage
- * This is the same logic used in ChatInput to display usage
- */
-export function calculateContextPercentage(contextUsage) {
-    // Determine which caching system is being used
-    const isAnthropic = (contextUsage.cacheCreationTokens || 0) > 0 ||
-        (contextUsage.cacheReadTokens || 0) > 0;
-    // For Anthropic: Total = inputTokens + cacheCreationTokens + cacheReadTokens
-    // For OpenAI: Total = inputTokens (cachedTokens are already included in inputTokens)
-    const totalInputTokens = isAnthropic
-        ? contextUsage.inputTokens +
-            (contextUsage.cacheCreationTokens || 0) +
-            (contextUsage.cacheReadTokens || 0)
-        : contextUsage.inputTokens;
-    return Math.min(100, (totalInputTokens / contextUsage.maxContextTokens) * 100);
-}
-export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, isProcessing = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage, initialContent = null, onContextPercentageChange, }) {
-    // Use i18n hook for translations
-    const { t } = useI18n();
-    const { theme } = useTheme();
-    // Use terminal size hook to listen for resize events
-    const { columns: terminalWidth } = useTerminalSize();
-    const prevTerminalWidthRef = useRef(terminalWidth);
-    // Use terminal focus hook to detect focus state
-    const { hasFocus, ensureFocus } = useTerminalFocus();
-    // Recalculate viewport dimensions to ensure proper resizing
-    const uiOverhead = 8;
-    const viewportWidth = Math.max(40, terminalWidth - uiOverhead);
-    const viewport = useMemo(() => ({
-        width: viewportWidth,
-        height: 1,
-    }), [viewportWidth]); // Memoize viewport to prevent unnecessary re-renders
-    // Use input buffer hook
-    const { buffer, triggerUpdate, forceUpdate } = useInputBuffer(viewport);
-    // Use command panel hook
-    const { showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, isProcessing: commandPanelIsProcessing, } = useCommandPanel(buffer, isProcessing);
-    // Use file picker hook
-    const { showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, fileQuery, setFileQuery, atSymbolPosition, setAtSymbolPosition, filteredFileCount, searchMode, updateFilePickerState, handleFileSelect, handleFilteredCountChange, fileListRef, } = useFilePicker(buffer, triggerUpdate);
-    // Use history navigation hook
-    const { showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, currentHistoryIndex, navigateHistoryUp, navigateHistoryDown, resetHistoryNavigation, saveToHistory, } = useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHistorySelect);
-    // Use agent picker hook
-    const { showAgentPicker, setShowAgentPicker, agentSelectedIndex, setAgentSelectedIndex, updateAgentPickerState, getFilteredAgents, handleAgentSelect, } = useAgentPicker(buffer, triggerUpdate);
-    // Use todo picker hook
-    const { showTodoPicker, setShowTodoPicker, todoSelectedIndex, setTodoSelectedIndex, todos, selectedTodos, toggleTodoSelection, confirmTodoSelection, isLoading: todoIsLoading, searchQuery: todoSearchQuery, setSearchQuery: setTodoSearchQuery, totalTodoCount, } = useTodoPicker(buffer, triggerUpdate, process.cwd());
-    // Use clipboard hook
-    const { pasteFromClipboard } = useClipboard(buffer, updateCommandPanelState, updateFilePickerState, triggerUpdate);
-    // Use keyboard input hook
-    useKeyboardInput({
-        buffer,
-        disabled,
-        triggerUpdate,
-        forceUpdate,
-        showCommands,
-        setShowCommands,
-        commandSelectedIndex,
-        setCommandSelectedIndex,
-        getFilteredCommands,
-        updateCommandPanelState,
-        onCommand,
-        showFilePicker,
-        setShowFilePicker,
-        fileSelectedIndex,
-        setFileSelectedIndex,
-        fileQuery,
-        setFileQuery,
-        atSymbolPosition,
-        setAtSymbolPosition,
-        filteredFileCount,
-        updateFilePickerState,
-        handleFileSelect,
-        fileListRef,
-        showHistoryMenu,
-        setShowHistoryMenu,
-        historySelectedIndex,
-        setHistorySelectedIndex,
-        escapeKeyCount,
-        setEscapeKeyCount,
-        escapeKeyTimer,
-        getUserMessages,
-        handleHistorySelect,
-        currentHistoryIndex,
-        navigateHistoryUp,
-        navigateHistoryDown,
-        resetHistoryNavigation,
-        saveToHistory,
-        pasteFromClipboard,
-        onSubmit,
-        ensureFocus,
-        showAgentPicker,
-        setShowAgentPicker,
-        agentSelectedIndex,
-        setAgentSelectedIndex,
-        updateAgentPickerState,
-        getFilteredAgents,
-        handleAgentSelect,
-        showTodoPicker,
-        setShowTodoPicker,
-        todoSelectedIndex,
-        setTodoSelectedIndex,
-        todos,
-        selectedTodos,
-        toggleTodoSelection,
-        confirmTodoSelection,
-        todoSearchQuery,
-        setTodoSearchQuery,
-    });
-    // Set initial content when provided (e.g., when rolling back to first message)
-    useEffect(() => {
-        if (initialContent) {
-            // Always do full restore to avoid duplicate placeholders
-            buffer.setText('');
-            const text = initialContent.text;
-            const images = initialContent.images || [];
-            if (images.length === 0) {
-                // No images, just set the text
-                if (text) {
-                    buffer.insert(text);
-                }
-            }
-            else {
-                // Split text by image placeholders and reconstruct with actual images
-                // Placeholder format: [image #N]
-                const imagePlaceholderPattern = /\[image #\d+\]/g;
-                const parts = text.split(imagePlaceholderPattern);
-                // Interleave text parts with images
-                for (let i = 0; i < parts.length; i++) {
-                    // Insert text part
-                    const part = parts[i];
-                    if (part) {
-                        buffer.insert(part);
-                    }
-                    // Insert image after this text part (if exists)
-                    if (i < images.length) {
-                        const img = images[i];
-                        if (img) {
-                            // Extract base64 data from data URL if present
-                            let base64Data = img.data;
-                            if (base64Data.startsWith('data:')) {
-                                const base64Index = base64Data.indexOf('base64,');
-                                if (base64Index !== -1) {
-                                    base64Data = base64Data.substring(base64Index + 7);
-                                }
-                            }
-                            buffer.insertImage(base64Data, img.mimeType);
-                        }
-                    }
-                }
-            }
-            triggerUpdate();
-        }
-        // Only run when initialContent changes
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [initialContent]);
-    // Force full re-render when file picker visibility changes to prevent artifacts
-    useEffect(() => {
-        // Use a small delay to ensure the component tree has updated
-        const timer = setTimeout(() => {
-            forceUpdate();
-        }, 10);
-        return () => clearTimeout(timer);
-    }, [showFilePicker, forceUpdate]);
-    // Handle terminal width changes with debounce (like gemini-cli)
-    useEffect(() => {
-        // Skip on initial mount
-        if (prevTerminalWidthRef.current === terminalWidth) {
-            prevTerminalWidthRef.current = terminalWidth;
-            return;
-        }
-        prevTerminalWidthRef.current = terminalWidth;
-        // Debounce the re-render to avoid flickering during resize
-        const timer = setTimeout(() => {
-            forceUpdate();
-        }, 100);
-        return () => clearTimeout(timer);
-    }, [terminalWidth, forceUpdate]);
-    // Notify parent of context percentage changes
-    const lastPercentageRef = useRef(0);
-    useEffect(() => {
-        if (contextUsage && onContextPercentageChange) {
-            const percentage = calculateContextPercentage(contextUsage);
-            // Only call callback if percentage has actually changed
-            if (percentage !== lastPercentageRef.current) {
-                lastPercentageRef.current = percentage;
-                onContextPercentageChange(percentage);
-            }
-        }
-    }, [contextUsage, onContextPercentageChange]);
-    // Render cursor based on focus state
-    const renderCursor = useCallback((char) => {
-        if (hasFocus) {
-            // Focused: solid block cursor (use inverted colors)
-            return (React.createElement(Text, { backgroundColor: theme.colors.menuNormal, color: theme.colors.background }, char));
-        }
-        else {
-            // Unfocused: no cursor, just render the character normally
-            return React.createElement(Text, null, char);
-        }
-    }, [hasFocus, theme]);
-    // Render content with cursor (treat all text including placeholders as plain text)
-    const renderContent = () => {
-        if (buffer.text.length > 0) {
-            // Use visual lines for proper wrapping and multi-line support
-            const visualLines = buffer.viewportVisualLines;
-            const [cursorRow, cursorCol] = buffer.visualCursor;
-            const renderedLines = [];
-            for (let i = 0; i < visualLines.length; i++) {
-                const line = visualLines[i] || '';
-                if (i === cursorRow) {
-                    // This line contains the cursor
-                    const beforeCursor = cpSlice(line, 0, cursorCol);
-                    const atCursor = cpSlice(line, cursorCol, cursorCol + 1) || ' ';
-                    const afterCursor = cpSlice(line, cursorCol + 1);
-                    renderedLines.push(React.createElement(Box, { key: i, flexDirection: "row" },
-                        React.createElement(Text, null, beforeCursor),
-                        renderCursor(atCursor),
-                        React.createElement(Text, null, afterCursor)));
-                }
-                else {
-                    // No cursor in this line
-                    renderedLines.push(React.createElement(Text, { key: i }, line || ' '));
-                }
-            }
-            return React.createElement(Box, { flexDirection: "column" }, renderedLines);
-        }
-        else {
-            return (React.createElement(React.Fragment, null,
-                renderCursor(' '),
-                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, disabled ? t.chatScreen.waitingForResponse : placeholder)));
-        }
-    };
-    return (React.createElement(Box, { flexDirection: "column", paddingX: 1, width: terminalWidth },
-        showHistoryMenu && (React.createElement(Box, { flexDirection: "column", marginBottom: 1, width: terminalWidth - 2 },
-            React.createElement(Box, { flexDirection: "column" }, (() => {
-                const userMessages = getUserMessages();
-                const maxVisibleItems = 5; // Number of message items to show (reduced for small terminals)
-                // Calculate scroll window to keep selected index visible
-                let startIndex = 0;
-                if (userMessages.length > maxVisibleItems) {
-                    // Keep selected item in the middle of the view when possible
-                    startIndex = Math.max(0, historySelectedIndex - Math.floor(maxVisibleItems / 2));
-                    // Adjust if we're near the end
-                    startIndex = Math.min(startIndex, userMessages.length - maxVisibleItems);
-                }
-                const endIndex = Math.min(userMessages.length, startIndex + maxVisibleItems);
-                const visibleMessages = userMessages.slice(startIndex, endIndex);
-                const hasMoreAbove = startIndex > 0;
-                const hasMoreBelow = endIndex < userMessages.length;
-                return (React.createElement(React.Fragment, null,
-                    React.createElement(Box, { height: 1 }, hasMoreAbove ? (React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.chatScreen.moreAbove.replace('{count}', startIndex.toString()))) : (React.createElement(Text, null, " "))),
-                    visibleMessages.map((message, displayIndex) => {
-                        const actualIndex = startIndex + displayIndex;
-                        // Ensure single line by removing all newlines and control characters
-                        const singleLineLabel = message.label
-                            .replace(/[\r\n\t\v\f\u0000-\u001F\u007F-\u009F]+/g, ' ')
-                            .replace(/\s+/g, ' ')
-                            .trim();
-                        // Calculate available width for the message
-                        const prefixWidth = 3; // "❯  " or "  "
-                        const maxLabelWidth = terminalWidth - 4 - prefixWidth;
-                        const truncatedLabel = singleLineLabel.length > maxLabelWidth
-                            ? singleLineLabel.slice(0, maxLabelWidth - 3) + '...'
-                            : singleLineLabel;
-                        return (React.createElement(Box, { key: message.value, height: 1 },
-                            React.createElement(Text, { color: actualIndex === historySelectedIndex
-                                    ? theme.colors.menuSelected
-                                    : theme.colors.menuNormal, bold: true, wrap: "truncate" },
-                                actualIndex === historySelectedIndex ? '❯  ' : '  ',
-                                truncatedLabel)));
-                    }),
-                    React.createElement(Box, { height: 1 }, hasMoreBelow ? (React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.chatScreen.moreBelow.replace('{count}', (userMessages.length - endIndex).toString()))) : (React.createElement(Text, null, " ")))));
-            })()),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: theme.colors.menuInfo, dimColor: true }, t.chatScreen.historyNavigateHint)))),
-        !showHistoryMenu && (React.createElement(React.Fragment, null,
-            React.createElement(Box, { flexDirection: "column", width: terminalWidth - 2 },
-                React.createElement(Text, { color: theme.colors.menuSecondary }, '─'.repeat(terminalWidth - 2)),
-                React.createElement(Box, { flexDirection: "row" },
-                    React.createElement(Text, { color: theme.colors.menuInfo, bold: true },
-                        "\u276F",
-                        ' '),
-                    React.createElement(Box, { flexGrow: 1 }, renderContent())),
-                React.createElement(Text, { color: theme.colors.menuSecondary }, '─'.repeat(terminalWidth - 2))),
-            (showCommands && getFilteredCommands().length > 0) ||
-                showFilePicker ? (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, null, showCommands && getFilteredCommands().length > 0
-                    ? t.chatScreen.typeToFilterCommands
-                    : showFilePicker
-                        ? searchMode === 'content'
-                            ? t.chatScreen.contentSearchHint
-                            : t.chatScreen.fileSearchHint
-                        : ''))) : null,
-            React.createElement(CommandPanel, { commands: getFilteredCommands(), selectedIndex: commandSelectedIndex, query: buffer.getFullText().slice(1), visible: showCommands, isProcessing: commandPanelIsProcessing }),
-            React.createElement(Box, null,
-                React.createElement(FileList, { ref: fileListRef, query: fileQuery, selectedIndex: fileSelectedIndex, visible: showFilePicker, maxItems: 10, rootPath: process.cwd(), onFilteredCountChange: handleFilteredCountChange, searchMode: searchMode })),
-            React.createElement(AgentPickerPanel, { agents: getFilteredAgents(), selectedIndex: agentSelectedIndex, visible: showAgentPicker, maxHeight: 5 }),
-            React.createElement(TodoPickerPanel, { todos: todos, selectedIndex: todoSelectedIndex, selectedTodos: selectedTodos, visible: showTodoPicker, maxHeight: 5, isLoading: todoIsLoading, searchQuery: todoSearchQuery, totalCount: totalTodoCount }),
-            yoloMode && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: theme.colors.warning, dimColor: true }, t.chatScreen.yoloModeActive))),
-            contextUsage && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, (() => {
-                    // Determine which caching system is being used
-                    const isAnthropic = (contextUsage.cacheCreationTokens || 0) > 0 ||
-                        (contextUsage.cacheReadTokens || 0) > 0;
-                    const isOpenAI = (contextUsage.cachedTokens || 0) > 0;
-                    // Use the exported function for consistent calculation
-                    const percentage = calculateContextPercentage(contextUsage);
-                    // Calculate total tokens for display
-                    const totalInputTokens = isAnthropic
-                        ? contextUsage.inputTokens +
-                            (contextUsage.cacheCreationTokens || 0) +
-                            (contextUsage.cacheReadTokens || 0)
-                        : contextUsage.inputTokens;
-                    let color;
-                    if (percentage < 50)
-                        color = theme.colors.success;
-                    else if (percentage < 75)
-                        color = theme.colors.warning;
-                    else if (percentage < 90)
-                        color = theme.colors.warning;
-                    else
-                        color = theme.colors.error;
-                    const formatNumber = (num) => {
-                        if (num >= 1000)
-                            return `${(num / 1000).toFixed(1)}k`;
-                        return num.toString();
-                    };
-                    const hasCacheMetrics = isAnthropic || isOpenAI;
-                    return (React.createElement(React.Fragment, null,
-                        React.createElement(Text, { color: color },
-                            percentage.toFixed(1),
-                            "%"),
-                        React.createElement(Text, null, " \u00B7 "),
-                        React.createElement(Text, { color: color }, formatNumber(totalInputTokens)),
-                        React.createElement(Text, null, t.chatScreen.tokens),
-                        hasCacheMetrics && (React.createElement(React.Fragment, null,
-                            React.createElement(Text, null, " \u00B7 "),
-                            isAnthropic && (React.createElement(React.Fragment, null,
-                                (contextUsage.cacheReadTokens || 0) > 0 && (React.createElement(React.Fragment, null,
-                                    React.createElement(Text, { color: theme.colors.menuInfo },
-                                        "\u21AF",
-                                        ' ',
-                                        formatNumber(contextUsage.cacheReadTokens || 0),
-                                        ' ',
-                                        t.chatScreen.cached))),
-                                (contextUsage.cacheCreationTokens || 0) > 0 && (React.createElement(React.Fragment, null,
-                                    (contextUsage.cacheReadTokens || 0) > 0 && (React.createElement(Text, null, " \u00B7 ")),
-                                    React.createElement(Text, { color: theme.colors.warning },
-                                        "\u25C6",
-                                        ' ',
-                                        formatNumber(contextUsage.cacheCreationTokens || 0),
-                                        ' ',
-                                        t.chatScreen.newCache))))),
-                            isOpenAI && (React.createElement(Text, { color: theme.colors.menuInfo },
-                                "\u21AF ",
-                                formatNumber(contextUsage.cachedTokens || 0),
-                                ' ',
-                                t.chatScreen.cached))))));
-                })())))))));
-}

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

@@ -1,15 +0,0 @@
-import React from 'react';
-interface Command {
-    name: string;
-    description: string;
-}
-interface Props {
-    commands: Command[];
-    selectedIndex: number;
-    query: string;
-    visible: boolean;
-    maxHeight?: number;
-    isProcessing?: boolean;
-}
-declare const CommandPanel: React.MemoExoticComponent<({ commands, selectedIndex, visible, maxHeight, isProcessing, }: Props) => React.JSX.Element | null>;
-export default CommandPanel;

package/dist/ui/components/CommandPanel.js

@@ -1,80 +0,0 @@
-import React, { memo, useMemo } from 'react';
-import { Box, Text } from 'ink';
-import { Alert } from '@inkjs/ui';
-import { useI18n } from '../../i18n/index.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-const CommandPanel = memo(({ commands, selectedIndex, visible, maxHeight, isProcessing = false, }) => {
-    const { t } = useI18n();
-    const { theme } = useTheme();
-    // Fixed maximum display items to prevent rendering issues
-    const MAX_DISPLAY_ITEMS = 5;
-    const effectiveMaxItems = maxHeight
-        ? Math.min(maxHeight, MAX_DISPLAY_ITEMS)
-        : MAX_DISPLAY_ITEMS;
-    // Limit displayed commands
-    const displayedCommands = useMemo(() => {
-        if (commands.length <= effectiveMaxItems) {
-            return commands;
-        }
-        // Show commands around the selected index
-        const halfWindow = Math.floor(effectiveMaxItems / 2);
-        let startIndex = Math.max(0, selectedIndex - halfWindow);
-        let endIndex = Math.min(commands.length, startIndex + effectiveMaxItems);
-        // Adjust if we're near the end
-        if (endIndex - startIndex < effectiveMaxItems) {
-            startIndex = Math.max(0, endIndex - effectiveMaxItems);
-        }
-        return commands.slice(startIndex, endIndex);
-    }, [commands, selectedIndex, effectiveMaxItems]);
-    // Calculate actual selected index in the displayed subset
-    const displayedSelectedIndex = useMemo(() => {
-        return displayedCommands.findIndex(cmd => {
-            const originalIndex = commands.indexOf(cmd);
-            return originalIndex === selectedIndex;
-        });
-    }, [displayedCommands, commands, selectedIndex]);
-    // Don't show panel if not visible
-    if (!visible) {
-        return null;
-    }
-    // Show processing message if conversation is in progress
-    if (isProcessing) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { width: "100%" },
-                React.createElement(Box, { flexDirection: "column", width: "100%" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: theme.colors.warning, bold: true }, t.commandPanel.title)),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Alert, { variant: "info" }, t.commandPanel.processingMessage))))));
-    }
-    // Don't show panel if no commands found
-    if (commands.length === 0) {
-        return null;
-    }
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { width: "100%" },
-            React.createElement(Box, { flexDirection: "column", width: "100%" },
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: theme.colors.warning, bold: true },
-                        t.commandPanel.availableCommands,
-                        ' ',
-                        commands.length > effectiveMaxItems &&
-                            `(${selectedIndex + 1}/${commands.length})`)),
-                displayedCommands.map((command, index) => (React.createElement(Box, { key: command.name, flexDirection: "column", width: "100%" },
-                    React.createElement(Text, { color: index === displayedSelectedIndex ? theme.colors.success : theme.colors.menuSecondary, bold: true },
-                        index === displayedSelectedIndex ? '❯ ' : '  ',
-                        "/",
-                        command.name),
-                    React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: index === displayedSelectedIndex ? theme.colors.success : theme.colors.menuSecondary, dimColor: true },
-                            "\u2514\u2500 ",
-                            command.description))))),
-                commands.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                        t.commandPanel.scrollHint,
-                        " \u00B7",
-                        ' ',
-                        t.commandPanel.moreHidden.replace('{count}', (commands.length - effectiveMaxItems).toString()))))))));
-});
-CommandPanel.displayName = 'CommandPanel';
-export default CommandPanel;

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

@@ -1,11 +0,0 @@
-import React from 'react';
-interface Props {
-    oldContent?: string;
-    newContent: string;
-    filename?: string;
-    completeOldContent?: string;
-    completeNewContent?: string;
-    startLineNumber?: number;
-}
-export default function DiffViewer({ oldContent, newContent, filename, completeOldContent, completeNewContent, startLineNumber, }: Props): React.JSX.Element | null;
-export {};

package/dist/ui/components/DiffViewer.js

@@ -1,178 +0,0 @@
-import React, { useMemo } from 'react';
-import { Box, Text } from 'ink';
-import * as Diff from 'diff';
-import { useTheme } from '../contexts/ThemeContext.js';
-// Helper function to strip line numbers from content (format: "123→content")
-function stripLineNumbers(content) {
-    return content
-        .split('\n')
-        .map(line => {
-        // Match pattern: digits + → + content
-        const match = line.match(/^\s*\d+→(.*)$/);
-        return match ? match[1] : line;
-    })
-        .join('\n');
-}
-export default function DiffViewer({ oldContent = '', newContent, filename, completeOldContent, completeNewContent, startLineNumber = 1, }) {
-    const { theme } = useTheme();
-    // If complete file contents are provided, use them for intelligent diff
-    const useCompleteContent = completeOldContent && completeNewContent;
-    const diffOldContent = useCompleteContent
-        ? completeOldContent
-        : stripLineNumbers(oldContent);
-    const diffNewContent = useCompleteContent
-        ? completeNewContent
-        : stripLineNumbers(newContent);
-    // If no old content, show as new file creation
-    const isNewFile = !diffOldContent || diffOldContent.trim() === '';
-    // Memoize new file rendering to avoid re-splitting lines on every render
-    const newFileContent = useMemo(() => {
-        if (!isNewFile)
-            return null;
-        const allLines = diffNewContent.split('\n');
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { bold: true, color: "green" }, "[New File]"),
-                filename && React.createElement(Text, { color: "cyan" },
-                    " ",
-                    filename)),
-            React.createElement(Box, { flexDirection: "column" }, allLines.map((line, index) => (React.createElement(Text, { key: index, color: "white", backgroundColor: theme.colors.diffAdded },
-                "+ ",
-                line))))));
-    }, [isNewFile, diffNewContent, filename, theme.colors.text, theme.colors.diffAdded]);
-    if (isNewFile) {
-        return newFileContent;
-    }
-    // Memoize expensive diff calculation - only recompute when content changes
-    const hunks = useMemo(() => {
-        // Generate line-by-line diff
-        const diffResult = Diff.diffLines(diffOldContent, diffNewContent);
-        const allChanges = [];
-        let oldLineNum = startLineNumber;
-        let newLineNum = startLineNumber;
-        diffResult.forEach(part => {
-            const lines = part.value.replace(/\n$/, '').split('\n');
-            lines.forEach(line => {
-                if (part.added) {
-                    allChanges.push({
-                        type: 'added',
-                        content: line,
-                        oldLineNum: null,
-                        newLineNum: newLineNum++,
-                    });
-                }
-                else if (part.removed) {
-                    allChanges.push({
-                        type: 'removed',
-                        content: line,
-                        oldLineNum: oldLineNum++,
-                        newLineNum: null,
-                    });
-                }
-                else {
-                    allChanges.push({
-                        type: 'unchanged',
-                        content: line,
-                        oldLineNum: oldLineNum++,
-                        newLineNum: newLineNum++,
-                    });
-                }
-            });
-        });
-        // Find diff hunks (groups of changes with context)
-        const computedHunks = [];
-        const contextLines = 3; // Number of context lines before and after changes
-        for (let i = 0; i < allChanges.length; i++) {
-            const change = allChanges[i];
-            if (change?.type !== 'unchanged') {
-                // Found a change, create a hunk
-                const hunkStart = Math.max(0, i - contextLines);
-                let hunkEnd = i;
-                // Extend the hunk to include all consecutive changes
-                while (hunkEnd < allChanges.length - 1) {
-                    const nextChange = allChanges[hunkEnd + 1];
-                    if (!nextChange)
-                        break;
-                    // If next line is a change, extend the hunk
-                    if (nextChange.type !== 'unchanged') {
-                        hunkEnd++;
-                        continue;
-                    }
-                    // If there are more changes within context distance, extend the hunk
-                    let hasMoreChanges = false;
-                    for (let j = hunkEnd + 1; j < Math.min(allChanges.length, hunkEnd + 1 + contextLines * 2); j++) {
-                        if (allChanges[j]?.type !== 'unchanged') {
-                            hasMoreChanges = true;
-                            break;
-                        }
-                    }
-                    if (hasMoreChanges) {
-                        hunkEnd++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                // Add context lines after the hunk
-                hunkEnd = Math.min(allChanges.length - 1, hunkEnd + contextLines);
-                // Extract the hunk
-                const hunkChanges = allChanges.slice(hunkStart, hunkEnd + 1);
-                const firstChange = hunkChanges[0];
-                const lastChange = hunkChanges[hunkChanges.length - 1];
-                if (firstChange && lastChange) {
-                    computedHunks.push({
-                        startLine: firstChange.oldLineNum || firstChange.newLineNum || 1,
-                        endLine: lastChange.oldLineNum || lastChange.newLineNum || 1,
-                        changes: hunkChanges,
-                    });
-                }
-                // Skip to the end of this hunk
-                i = hunkEnd;
-            }
-        }
-        return computedHunks;
-    }, [diffOldContent, diffNewContent, startLineNumber]);
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, "[File Modified]"),
-            filename && React.createElement(Text, { color: "cyan" },
-                " ",
-                filename)),
-        React.createElement(Box, { flexDirection: "column" },
-            hunks.map((hunk, hunkIndex) => (React.createElement(Box, { key: hunkIndex, flexDirection: "column", marginBottom: 1 },
-                React.createElement(Text, { color: "cyan", dimColor: true },
-                    "@@ Lines ",
-                    hunk.startLine,
-                    "-",
-                    hunk.endLine,
-                    " @@"),
-                hunk.changes.map((change, changeIndex) => {
-                    // Calculate line number to display
-                    const lineNum = change.type === 'added' ? change.newLineNum : change.oldLineNum;
-                    const lineNumStr = lineNum
-                        ? String(lineNum).padStart(4, ' ')
-                        : '    ';
-                    if (change.type === 'added') {
-                        return (React.createElement(Text, { key: changeIndex, color: "white", backgroundColor: theme.colors.diffAdded },
-                            lineNumStr,
-                            " + ",
-                            change.content));
-                    }
-                    if (change.type === 'removed') {
-                        return (React.createElement(Text, { key: changeIndex, color: "white", backgroundColor: theme.colors.diffRemoved },
-                            lineNumStr,
-                            " - ",
-                            change.content));
-                    }
-                    // Unchanged lines (context)
-                    return (React.createElement(Text, { key: changeIndex, dimColor: true },
-                        lineNumStr,
-                        " ",
-                        change.content));
-                })))),
-            hunks.length > 1 && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true },
-                    "Total: ",
-                    hunks.length,
-                    " change region(s)"))))));
-}