snow-ai 0.3.11 → 0.3.12

package/dist/hooks/useFilePicker.d.ts

@@ -2,13 +2,13 @@ import { TextBuffer } from '../utils/textBuffer.js';
 import { FileListRef } from '../ui/components/FileList.js';
 export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => void): {
     showFilePicker: boolean;
-    setShowFilePicker: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setShowFilePicker: (show: boolean) => void;
     fileSelectedIndex: number;
-    setFileSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setFileSelectedIndex: (index: number | ((prev: number) => number)) => void;
     fileQuery: string;
-    setFileQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setFileQuery: (_query: string) => void;
     atSymbolPosition: number;
-    setAtSymbolPosition: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
     updateFilePickerState: (text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;

package/dist/hooks/useFilePicker.js

@@ -1,19 +1,58 @@
-import { useState, useCallback, useRef } from 'react';
+import { useReducer, useCallback, useRef } from 'react';
+function filePickerReducer(state, action) {
+    switch (action.type) {
+        case 'SHOW':
+            return {
+                ...state,
+                showFilePicker: true,
+                fileSelectedIndex: 0,
+                fileQuery: action.query,
+                atSymbolPosition: action.position,
+            };
+        case 'HIDE':
+            return {
+                ...state,
+                showFilePicker: false,
+                fileSelectedIndex: 0,
+                fileQuery: '',
+                atSymbolPosition: -1,
+            };
+        case 'SELECT_FILE':
+            return {
+                ...state,
+                showFilePicker: false,
+                fileSelectedIndex: 0,
+                fileQuery: '',
+                atSymbolPosition: -1,
+            };
+        case 'SET_SELECTED_INDEX':
+            return {
+                ...state,
+                fileSelectedIndex: action.index,
+            };
+        case 'SET_FILTERED_COUNT':
+            return {
+                ...state,
+                filteredFileCount: action.count,
+            };
+        default:
+            return state;
+    }
+}
 export function useFilePicker(buffer, triggerUpdate) {
-    const [showFilePicker, setShowFilePicker] = useState(false);
-    const [fileSelectedIndex, setFileSelectedIndex] = useState(0);
-    const [fileQuery, setFileQuery] = useState('');
-    const [atSymbolPosition, setAtSymbolPosition] = useState(-1);
-    const [filteredFileCount, setFilteredFileCount] = useState(0);
+    const [state, dispatch] = useReducer(filePickerReducer, {
+        showFilePicker: false,
+        fileSelectedIndex: 0,
+        fileQuery: '',
+        atSymbolPosition: -1,
+        filteredFileCount: 0,
+    });
     const fileListRef = useRef(null);
     // Update file picker state
     const updateFilePickerState = useCallback((text, cursorPos) => {
         if (!text.includes('@')) {
-            if (showFilePicker) {
-                setShowFilePicker(false);
-                setFileSelectedIndex(0);
-                setFileQuery('');
-                setAtSymbolPosition(-1);
+            if (state.showFilePicker) {
+                dispatch({ type: 'HIDE' });
             }
             return;
         }
@@ -24,65 +63,74 @@ export function useFilePicker(buffer, triggerUpdate) {
             // Check if there's no space between '@' and cursor
             const afterAt = beforeCursor.slice(lastAtIndex + 1);
             if (!afterAt.includes(' ') && !afterAt.includes('\n')) {
-                if (!showFilePicker ||
-                    fileQuery !== afterAt ||
-                    atSymbolPosition !== lastAtIndex) {
-                    setShowFilePicker(true);
-                    setFileSelectedIndex(0);
-                    setFileQuery(afterAt);
-                    setAtSymbolPosition(lastAtIndex);
+                if (!state.showFilePicker ||
+                    state.fileQuery !== afterAt ||
+                    state.atSymbolPosition !== lastAtIndex) {
+                    dispatch({ type: 'SHOW', query: afterAt, position: lastAtIndex });
                 }
                 return;
             }
         }
         // Hide file picker if no valid @ context found
-        if (showFilePicker) {
-            setShowFilePicker(false);
-            setFileSelectedIndex(0);
-            setFileQuery('');
-            setAtSymbolPosition(-1);
+        if (state.showFilePicker) {
+            dispatch({ type: 'HIDE' });
         }
-    }, [showFilePicker, fileQuery, atSymbolPosition]);
+    }, [state.showFilePicker, state.fileQuery, state.atSymbolPosition]);
     // Handle file selection
     const handleFileSelect = useCallback(async (filePath) => {
-        if (atSymbolPosition !== -1) {
+        if (state.atSymbolPosition !== -1) {
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             // Replace @query with @filePath + space
-            const beforeAt = text.slice(0, atSymbolPosition);
+            const beforeAt = text.slice(0, state.atSymbolPosition);
             const afterCursor = text.slice(cursorPos);
             const newText = beforeAt + '@' + filePath + ' ' + afterCursor;
             // Set the new text and position cursor after the inserted file path + space
             buffer.setText(newText);
             // Calculate cursor position after the inserted file path + space
             // Reset cursor to beginning, then move to correct position
-            for (let i = 0; i < atSymbolPosition + filePath.length + 2; i++) {
+            for (let i = 0; i < state.atSymbolPosition + filePath.length + 2; i++) {
                 // +2 for @ and space
                 if (i < buffer.getFullText().length) {
                     buffer.moveRight();
                 }
             }
-            setShowFilePicker(false);
-            setFileSelectedIndex(0);
-            setFileQuery('');
-            setAtSymbolPosition(-1);
+            dispatch({ type: 'SELECT_FILE' });
             triggerUpdate();
         }
-    }, [atSymbolPosition, buffer, triggerUpdate]);
+    }, [state.atSymbolPosition, buffer]);
     // Handle filtered file count change
     const handleFilteredCountChange = useCallback((count) => {
-        setFilteredFileCount(count);
+        dispatch({ type: 'SET_FILTERED_COUNT', count });
+    }, []);
+    // Wrapper setters for backwards compatibility
+    const setShowFilePicker = useCallback((show) => {
+        dispatch({ type: show ? 'SHOW' : 'HIDE', query: '', position: -1 });
     }, []);
+    const setFileSelectedIndex = useCallback((index) => {
+        if (typeof index === 'function') {
+            // For functional updates, we need to get current state first
+            // This is a simplified version - in production you might want to use a ref
+            dispatch({ type: 'SET_SELECTED_INDEX', index: index(state.fileSelectedIndex) });
+        }
+        else {
+            dispatch({ type: 'SET_SELECTED_INDEX', index });
+        }
+    }, [state.fileSelectedIndex]);
     return {
-        showFilePicker,
+        showFilePicker: state.showFilePicker,
         setShowFilePicker,
-        fileSelectedIndex,
+        fileSelectedIndex: state.fileSelectedIndex,
         setFileSelectedIndex,
-        fileQuery,
-        setFileQuery,
-        atSymbolPosition,
-        setAtSymbolPosition,
-        filteredFileCount,
+        fileQuery: state.fileQuery,
+        setFileQuery: (_query) => {
+            // Not used, but kept for compatibility
+        },
+        atSymbolPosition: state.atSymbolPosition,
+        setAtSymbolPosition: (_pos) => {
+            // Not used, but kept for compatibility
+        },
+        filteredFileCount: state.filteredFileCount,
         updateFilePickerState,
         handleFileSelect,
         handleFilteredCountChange,

package/dist/hooks/useHistoryNavigation.d.ts

@@ -17,5 +17,10 @@ export declare function useHistoryNavigation(buffer: TextBuffer, triggerUpdate:
         infoText: string;
     }[];
     handleHistorySelect: (value: string) => void;
+    currentHistoryIndex: number;
+    navigateHistoryUp: () => boolean;
+    navigateHistoryDown: () => boolean;
+    resetHistoryNavigation: () => void;
+    saveToHistory: (content: string) => Promise<void>;
 };
 export {};

package/dist/hooks/useHistoryNavigation.js

@@ -1,9 +1,25 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
+import { historyManager } from '../utils/historyManager.js';
 export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHistorySelect) {
     const [showHistoryMenu, setShowHistoryMenu] = useState(false);
     const [historySelectedIndex, setHistorySelectedIndex] = useState(0);
     const [escapeKeyCount, setEscapeKeyCount] = useState(0);
     const escapeKeyTimer = useRef(null);
+    // Terminal-style history navigation state
+    const [currentHistoryIndex, setCurrentHistoryIndex] = useState(-1); // -1 means not in history mode
+    const savedInput = useRef(''); // Save current input when entering history mode
+    const [persistentHistory, setPersistentHistory] = useState([]);
+    const persistentHistoryRef = useRef([]);
+    // Keep ref in sync with state
+    useEffect(() => {
+        persistentHistoryRef.current = persistentHistory;
+    }, [persistentHistory]);
+    // Load persistent history on mount
+    useEffect(() => {
+        historyManager.loadHistory().then(entries => {
+            setPersistentHistory(entries);
+        });
+    }, []);
     // Cleanup timer on unmount
     useEffect(() => {
         return () => {
@@ -35,7 +51,62 @@ export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHisto
             triggerUpdate();
             onHistorySelect(selectedIndex, selectedMessage.content);
         }
-    }, [chatHistory, onHistorySelect, buffer, triggerUpdate]);
+    }, [chatHistory, onHistorySelect, buffer]);
+    // Terminal-style history navigation: navigate up (older)
+    const navigateHistoryUp = useCallback(() => {
+        const history = persistentHistoryRef.current;
+        if (history.length === 0)
+            return false;
+        // Save current input when first entering history mode
+        if (currentHistoryIndex === -1) {
+            savedInput.current = buffer.getFullText();
+        }
+        // Navigate to older message (persistentHistory is already newest first)
+        const newIndex = currentHistoryIndex === -1
+            ? 0
+            : Math.min(history.length - 1, currentHistoryIndex + 1);
+        setCurrentHistoryIndex(newIndex);
+        const entry = history[newIndex];
+        if (entry) {
+            buffer.setText(entry.content);
+            triggerUpdate();
+        }
+        return true;
+    }, [currentHistoryIndex, buffer]);
+    // Terminal-style history navigation: navigate down (newer)
+    const navigateHistoryDown = useCallback(() => {
+        if (currentHistoryIndex === -1)
+            return false;
+        const newIndex = currentHistoryIndex - 1;
+        const history = persistentHistoryRef.current;
+        if (newIndex < 0) {
+            // Restore original input
+            buffer.setText(savedInput.current);
+            setCurrentHistoryIndex(-1);
+            savedInput.current = '';
+        }
+        else {
+            setCurrentHistoryIndex(newIndex);
+            const entry = history[newIndex];
+            if (entry) {
+                buffer.setText(entry.content);
+            }
+        }
+        triggerUpdate();
+        return true;
+    }, [currentHistoryIndex, buffer]);
+    // Reset history navigation state
+    const resetHistoryNavigation = useCallback(() => {
+        setCurrentHistoryIndex(-1);
+        savedInput.current = '';
+    }, []);
+    // Save message to persistent history
+    const saveToHistory = useCallback(async (content) => {
+        await historyManager.addEntry(content);
+        // Reload history to update the list
+        const entries = await historyManager.getEntries();
+        setPersistentHistory(entries);
+    }, []);
     return {
         showHistoryMenu,
         setShowHistoryMenu,
@@ -46,5 +117,11 @@ export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHisto
         escapeKeyTimer,
         getUserMessages,
         handleHistorySelect,
+        // Terminal-style history navigation
+        currentHistoryIndex,
+        navigateHistoryUp,
+        navigateHistoryDown,
+        resetHistoryNavigation,
+        saveToHistory,
     };
 }

package/dist/hooks/useInputBuffer.js

@@ -14,7 +14,7 @@ export function useInputBuffer(viewport) {
     useEffect(() => {
         buffer.updateViewport(viewport);
         triggerUpdate();
-    }, [viewport.width, viewport.height, buffer, triggerUpdate]);
+    }, [viewport.width, viewport.height, buffer]);
     // Cleanup buffer on unmount
     useEffect(() => {
         return () => {

package/dist/hooks/useKeyboardInput.d.ts

@@ -41,6 +41,11 @@ type KeyboardInputOptions = {
         infoText: string;
     }>;
     handleHistorySelect: (value: string) => void;
+    currentHistoryIndex: number;
+    navigateHistoryUp: () => boolean;
+    navigateHistoryDown: () => boolean;
+    resetHistoryNavigation: () => void;
+    saveToHistory: (content: string) => Promise<void>;
     pasteFromClipboard: () => Promise<void>;
     onSubmit: (message: string, images?: Array<{
         data: string;

package/dist/hooks/useKeyboardInput.js

@@ -2,7 +2,7 @@ import { useRef, useEffect } from 'react';
 import { useInput } from 'ink';
 import { executeCommand } from '../utils/commandExecutor.js';
 export function useKeyboardInput(options) {
-    const { buffer, disabled, triggerUpdate, forceUpdate, showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, onCommand, showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, setFileQuery, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, fileListRef, showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, pasteFromClipboard, onSubmit, ensureFocus, } = options;
+    const { buffer, disabled, triggerUpdate, forceUpdate, showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, onCommand, showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, setFileQuery, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, fileListRef, showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, currentHistoryIndex, navigateHistoryUp, navigateHistoryDown, resetHistoryNavigation, saveToHistory, pasteFromClipboard, onSubmit, ensureFocus, } = options;
     // Track paste detection
     const inputBuffer = useRef('');
     const inputTimer = useRef(null);
@@ -129,18 +129,18 @@ export function useKeyboardInput(options) {
         }
         // Ctrl+L - Delete from cursor to beginning
         if (key.ctrl && input === 'l') {
-            const fullText = buffer.getFullText();
+            const displayText = buffer.text;
             const cursorPos = buffer.getCursorPosition();
-            const afterCursor = fullText.slice(cursorPos);
+            const afterCursor = displayText.slice(cursorPos);
             buffer.setText(afterCursor);
             forceStateUpdate();
             return;
         }
         // Ctrl+R - Delete from cursor to end
         if (key.ctrl && input === 'r') {
-            const fullText = buffer.getFullText();
+            const displayText = buffer.text;
             const cursorPos = buffer.getCursorPosition();
-            const beforeCursor = fullText.slice(0, cursorPos);
+            const beforeCursor = displayText.slice(0, cursorPos);
             buffer.setText(beforeCursor);
             forceStateUpdate();
             return;
@@ -221,6 +221,10 @@ export function useKeyboardInput(options) {
         }
         // Enter - submit message
         if (key.return) {
+            // Reset history navigation on submit
+            if (currentHistoryIndex !== -1) {
+                resetHistoryNavigation();
+            }
             const message = buffer.getFullText().trim();
             if (message) {
                 // Check if message is a command with arguments (e.g., /review [note])
@@ -253,6 +257,8 @@ export function useKeyboardInput(options) {
                 }));
                 buffer.setText('');
                 forceUpdate({});
+                // Save to persistent history
+                saveToHistory(message);
                 onSubmit(message, validImages.length > 0 ? validImages : undefined);
             }
             return;
@@ -275,23 +281,59 @@ export function useKeyboardInput(options) {
             return;
         }
         if (key.upArrow && !showCommands && !showFilePicker) {
-            buffer.moveUp();
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
-            updateFilePickerState(text, cursorPos);
+            const isEmpty = text.trim() === '';
+            const isAtStart = cursorPos === 0;
+            const hasNewline = text.includes('\n');
+            // Terminal-style history navigation:
+            // 1. Empty input box -> navigate history
+            // 2. Cursor at start of single line -> navigate history
+            // 3. Otherwise -> normal cursor movement
+            if (isEmpty || (!hasNewline && isAtStart)) {
+                const navigated = navigateHistoryUp();
+                if (navigated) {
+                    updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+                    triggerUpdate();
+                    return;
+                }
+            }
+            // Normal cursor movement
+            buffer.moveUp();
+            updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
             triggerUpdate();
             return;
         }
         if (key.downArrow && !showCommands && !showFilePicker) {
-            buffer.moveDown();
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
-            updateFilePickerState(text, cursorPos);
+            const isEmpty = text.trim() === '';
+            const isAtEnd = cursorPos === text.length;
+            const hasNewline = text.includes('\n');
+            // Terminal-style history navigation:
+            // 1. Empty input box -> navigate history (if in history mode)
+            // 2. Cursor at end of single line -> navigate history (if in history mode)
+            // 3. Otherwise -> normal cursor movement
+            if ((isEmpty || (!hasNewline && isAtEnd)) && currentHistoryIndex !== -1) {
+                const navigated = navigateHistoryDown();
+                if (navigated) {
+                    updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
+                    triggerUpdate();
+                    return;
+                }
+            }
+            // Normal cursor movement
+            buffer.moveDown();
+            updateFilePickerState(buffer.getFullText(), buffer.getCursorPosition());
             triggerUpdate();
             return;
         }
         // Regular character input
         if (input && !key.ctrl && !key.meta && !key.escape) {
+            // Reset history navigation when user starts typing
+            if (currentHistoryIndex !== -1) {
+                resetHistoryNavigation();
+            }
             // Ensure focus is active when user is typing (handles delayed focus events)
             // This is especially important for drag-and-drop operations where focus
             // events may arrive out of order or be filtered by sanitizeInput

package/dist/hooks/useStreamingState.js

@@ -76,7 +76,7 @@ export function useStreamingState() {
             });
         }, 1000);
         return () => clearInterval(interval);
-    }, [retryStatus]);
+    }, [retryStatus?.isRetrying, retryStatus?.remainingSeconds]);
     return {
         isStreaming,
         setIsStreaming,

package/dist/mcp/aceCodeSearch.d.ts

@@ -44,6 +44,10 @@ export declare class ACECodeSearchService {
      * Find symbol definition (go to definition)
      */
     findDefinition(symbolName: string, contextFile?: string): Promise<CodeSymbol | null>;
+    /**
+     * Expand glob patterns with braces like "*.{ts,tsx}" into multiple patterns
+     */
+    private expandGlobBraces;
     /**
      * Strategy 1: Use git grep for fast searching in Git repositories
      */

package/dist/mcp/aceCodeSearch.js

@@ -470,6 +470,20 @@ export class ACECodeSearchService {
         }
         return null;
     }
+    /**
+     * Expand glob patterns with braces like "*.{ts,tsx}" into multiple patterns
+     */
+    expandGlobBraces(glob) {
+        // Match {a,b,c} pattern
+        const braceMatch = glob.match(/^(.+)\{([^}]+)\}(.*)$/);
+        if (!braceMatch || !braceMatch[1] || !braceMatch[2] || braceMatch[3] === undefined) {
+            return [glob];
+        }
+        const prefix = braceMatch[1];
+        const alternatives = braceMatch[2].split(',');
+        const suffix = braceMatch[3];
+        return alternatives.map(alt => `${prefix}${alt}${suffix}`);
+    }
     /**
      * Strategy 1: Use git grep for fast searching in Git repositories
      */
@@ -484,7 +498,9 @@ export class ACECodeSearchService {
                 pattern,
             ];
             if (fileGlob) {
-                args.push('--', fileGlob);
+                // Expand glob patterns with braces (e.g., "source/**/*.{ts,tsx}" -> ["source/**/*.ts", "source/**/*.tsx"])
+                const expandedGlobs = this.expandGlobBraces(fileGlob);
+                args.push('--', ...expandedGlobs);
             }
             const child = spawn('git', args, {
                 cwd: this.basePath,

package/dist/mcp/filesystem.js

@@ -411,7 +411,7 @@ export class FilesystemMCPService {
             for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
                 // Yield control periodically to prevent UI freeze
                 if (i % YIELD_INTERVAL === 0) {
-                    await new Promise(resolve => setImmediate(resolve));
+                    await new Promise(resolve => setTimeout(resolve, 0));
                 }
                 // Quick pre-filter: check first line similarity (only for multi-line searches)
                 if (usePreFilter) {
@@ -456,7 +456,7 @@ export class FilesystemMCPService {
                     for (let i = 0; i <= contentLines.length - correctedSearchLines.length; i++) {
                         // Yield control periodically to prevent UI freeze
                         if (i % YIELD_INTERVAL === 0) {
-                            await new Promise(resolve => setImmediate(resolve));
+                            await new Promise(resolve => setTimeout(resolve, 0));
                         }
                         const candidateLines = contentLines.slice(i, i + correctedSearchLines.length);
                         const candidateContent = candidateLines.join('\n');

package/dist/mcp/utils/filesystem/match-finder.utils.js

@@ -22,7 +22,7 @@ export async function findClosestMatches(searchContent, fileLines, topN = 3) {
     for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
         // Yield control periodically to prevent UI freeze
         if (i % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setImmediate(resolve));
+            await new Promise(resolve => setTimeout(resolve, 0));
         }
         // Quick pre-filter: check first line similarity (only for multi-line)
         if (usePreFilter) {

package/dist/ui/components/ChatInput.js

@@ -48,7 +48,7 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
     // Use file picker hook
     const { showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, fileQuery, setFileQuery, atSymbolPosition, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, handleFilteredCountChange, fileListRef, } = useFilePicker(buffer, triggerUpdate);
     // Use history navigation hook
-    const { showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, } = useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHistorySelect);
+    const { showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, currentHistoryIndex, navigateHistoryUp, navigateHistoryDown, resetHistoryNavigation, saveToHistory, } = useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHistorySelect);
     // Use clipboard hook
     const { pasteFromClipboard } = useClipboard(buffer, updateCommandPanelState, updateFilePickerState, triggerUpdate);
     // Use keyboard input hook
@@ -85,6 +85,11 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
         escapeKeyTimer,
         getUserMessages,
         handleHistorySelect,
+        currentHistoryIndex,
+        navigateHistoryUp,
+        navigateHistoryDown,
+        resetHistoryNavigation,
+        saveToHistory,
         pasteFromClipboard,
         onSubmit,
         ensureFocus,
@@ -95,7 +100,9 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
             buffer.setText(initialContent);
             triggerUpdate();
         }
-    }, [initialContent, buffer, 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
@@ -103,7 +110,7 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
             forceUpdate({});
         }, 10);
         return () => clearTimeout(timer);
-    }, [showFilePicker, forceUpdate]);
+    }, [showFilePicker]);
     // Handle terminal width changes with debounce (like gemini-cli)
     useEffect(() => {
         // Skip on initial mount
@@ -117,7 +124,7 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
             forceUpdate({});
         }, 100);
         return () => clearTimeout(timer);
-    }, [terminalWidth, forceUpdate]);
+    }, [terminalWidth]);
     // Notify parent of context percentage changes
     useEffect(() => {
         if (contextUsage && onContextPercentageChange) {

package/dist/utils/historyManager.d.ts

@@ -0,0 +1,45 @@
+export interface HistoryEntry {
+    content: string;
+    timestamp: number;
+}
+export interface HistoryData {
+    entries: HistoryEntry[];
+    lastCleanup: number;
+}
+declare class HistoryManager {
+    private readonly historyFile;
+    private readonly maxAge;
+    private readonly maxEntries;
+    private historyData;
+    constructor();
+    /**
+     * Ensure the .snow directory exists
+     */
+    private ensureSnowDir;
+    /**
+     * Load history from file
+     */
+    loadHistory(): Promise<HistoryEntry[]>;
+    /**
+     * Add a new entry to history
+     */
+    addEntry(content: string): Promise<void>;
+    /**
+     * Get all history entries (newest first)
+     */
+    getEntries(): Promise<HistoryEntry[]>;
+    /**
+     * Clean up entries older than maxAge
+     */
+    private cleanupOldEntries;
+    /**
+     * Save history to file
+     */
+    private saveHistory;
+    /**
+     * Clear all history
+     */
+    clearHistory(): Promise<void>;
+}
+export declare const historyManager: HistoryManager;
+export {};

package/dist/utils/historyManager.js

@@ -0,0 +1,159 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { logger } from './logger.js';
+class HistoryManager {
+    constructor() {
+        Object.defineProperty(this, "historyFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxAge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 24 * 60 * 60 * 1000
+        }); // 1 day in milliseconds
+        Object.defineProperty(this, "maxEntries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        }); // Maximum number of entries to keep
+        Object.defineProperty(this, "historyData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        const snowDir = path.join(os.homedir(), '.snow');
+        this.historyFile = path.join(snowDir, 'history.json');
+    }
+    /**
+     * Ensure the .snow directory exists
+     */
+    async ensureSnowDir() {
+        try {
+            const snowDir = path.dirname(this.historyFile);
+            await fs.mkdir(snowDir, { recursive: true });
+        }
+        catch (error) {
+            // Directory already exists or other error
+        }
+    }
+    /**
+     * Load history from file
+     */
+    async loadHistory() {
+        try {
+            await this.ensureSnowDir();
+            // Try to read existing history file
+            const data = await fs.readFile(this.historyFile, 'utf-8');
+            this.historyData = JSON.parse(data);
+            // Clean up old entries if needed
+            await this.cleanupOldEntries();
+            return this.historyData.entries;
+        }
+        catch (error) {
+            // File doesn't exist or is corrupted, start fresh
+            this.historyData = {
+                entries: [],
+                lastCleanup: Date.now(),
+            };
+            return [];
+        }
+    }
+    /**
+     * Add a new entry to history
+     */
+    async addEntry(content) {
+        // Don't add empty or whitespace-only entries
+        if (!content || !content.trim()) {
+            return;
+        }
+        // Load history if not already loaded
+        if (!this.historyData) {
+            await this.loadHistory();
+        }
+        // Don't add duplicate of the last entry
+        const lastEntry = this.historyData.entries[this.historyData.entries.length - 1];
+        if (lastEntry && lastEntry.content === content) {
+            return;
+        }
+        // Add new entry
+        const newEntry = {
+            content,
+            timestamp: Date.now(),
+        };
+        this.historyData.entries.push(newEntry);
+        // Limit the number of entries
+        if (this.historyData.entries.length > this.maxEntries) {
+            this.historyData.entries = this.historyData.entries.slice(-this.maxEntries);
+        }
+        // Save to file
+        await this.saveHistory();
+    }
+    /**
+     * Get all history entries (newest first)
+     */
+    async getEntries() {
+        if (!this.historyData) {
+            await this.loadHistory();
+        }
+        // Return a copy in reverse order (newest first)
+        return [...this.historyData.entries].reverse();
+    }
+    /**
+     * Clean up entries older than maxAge
+     */
+    async cleanupOldEntries() {
+        if (!this.historyData) {
+            return;
+        }
+        const now = Date.now();
+        const cutoffTime = now - this.maxAge;
+        // Only cleanup once per hour to avoid excessive file writes
+        if (now - this.historyData.lastCleanup < 60 * 60 * 1000) {
+            return;
+        }
+        // Filter out old entries
+        const originalLength = this.historyData.entries.length;
+        this.historyData.entries = this.historyData.entries.filter(entry => entry.timestamp > cutoffTime);
+        // Update last cleanup time
+        this.historyData.lastCleanup = now;
+        // Save if we removed any entries
+        if (this.historyData.entries.length < originalLength) {
+            await this.saveHistory();
+            logger.debug(`Cleaned up ${originalLength - this.historyData.entries.length} old history entries`);
+        }
+    }
+    /**
+     * Save history to file
+     */
+    async saveHistory() {
+        if (!this.historyData) {
+            return;
+        }
+        try {
+            await this.ensureSnowDir();
+            await fs.writeFile(this.historyFile, JSON.stringify(this.historyData, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logger.error('Failed to save history:', error);
+        }
+    }
+    /**
+     * Clear all history
+     */
+    async clearHistory() {
+        this.historyData = {
+            entries: [],
+            lastCleanup: Date.now(),
+        };
+        await this.saveHistory();
+    }
+}
+// Export singleton instance
+export const historyManager = new HistoryManager();

package/dist/utils/textBuffer.js

@@ -196,16 +196,19 @@ export class TextBuffer {
             if (this.pasteTimer) {
                 clearTimeout(this.pasteTimer);
             }
-            // 如果是第一批数据，记录插入位置
+            // 如果是第一批数据，记录插入位置并清空内容
             const isFirstBatch = !this.pasteAccumulator;
             if (isFirstBatch) {
                 this.pastePlaceholderPosition = this.cursorIndex;
+                // 保存粘贴位置前后的内容，避免后续计算错误
+                this.content = cpSlice(this.content, 0, this.pastePlaceholderPosition) +
+                    cpSlice(this.content, this.pastePlaceholderPosition);
             }
             // 累积数据
             this.pasteAccumulator += sanitized;
-            // 移除旧的临时占位符（如果存在）
+            // 移除所有旧的临时占位符（使用全局替换）
             if (!isFirstBatch) {
-                const tempPlaceholderPattern = /\[Pasting\.\.\. \d+ chars\]/;
+                const tempPlaceholderPattern = /\[Pasting\.\.\. \d+ chars\]/g;
                 this.content = this.content.replace(tempPlaceholderPattern, '');
             }
             // 显示更新后的临时占位符
@@ -241,9 +244,9 @@ export class TextBuffer {
             return;
         }
         const totalChars = this.pasteAccumulator.length;
-        // 移除临时占位符（如果存在）
+        // 移除所有临时占位符（使用全局替换）
         // 临时占位符格式: [Pasting... XXX chars]
-        const tempPlaceholderPattern = /\[Pasting\.\.\. \d+ chars\]/;
+        const tempPlaceholderPattern = /\[Pasting\.\.\. \d+ chars\]/g;
         this.content = this.content.replace(tempPlaceholderPattern, '');
         // 只有当累积的字符数超过300时才创建占位符
         if (totalChars > 300) {
@@ -331,6 +334,14 @@ export class TextBuffer {
         if (this.visualLines.length === 0) {
             return;
         }
+        // 检查是否只有单行（没有换行符）
+        const hasNewline = this.content.includes('\n');
+        if (!hasNewline && this.visualLines.length === 1) {
+            // 单行模式：移动到行首
+            this.cursorIndex = 0;
+            this.recomputeVisualCursorOnly();
+            return;
+        }
         const currentRow = this.visualCursorPos[0];
         if (currentRow <= 0) {
             return;
@@ -341,6 +352,14 @@ export class TextBuffer {
         if (this.visualLines.length === 0) {
             return;
         }
+        // 检查是否只有单行（没有换行符）
+        const hasNewline = this.content.includes('\n');
+        if (!hasNewline && this.visualLines.length === 1) {
+            // 单行模式：移动到行尾
+            this.cursorIndex = cpLen(this.content);
+            this.recomputeVisualCursorOnly();
+            return;
+        }
         const currentRow = this.visualCursorPos[0];
         if (currentRow >= this.visualLines.length - 1) {
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.11",
+	"version": "0.3.12",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {