snow-ai 0.1.12 → 0.2.2

package/dist/utils/textBuffer.js

@@ -13,298 +13,384 @@ function sanitizeInput(str) {
 }
 export class TextBuffer {
     constructor(viewport) {
-        Object.defineProperty(this, "lines", {
+        Object.defineProperty(this, "content", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: ['']
+            value: ''
         });
-        Object.defineProperty(this, "cursorRow", {
+        Object.defineProperty(this, "cursorIndex", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 0
         });
-        Object.defineProperty(this, "cursorCol", {
+        Object.defineProperty(this, "viewport", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0
+            value: void 0
         });
-        Object.defineProperty(this, "viewport", {
+        Object.defineProperty(this, "pasteStorage", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        }); // Still needed for width-based text wrapping
-        Object.defineProperty(this, "pendingUpdates", {
+            value: new Map()
+        });
+        Object.defineProperty(this, "pasteCounter", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: 0
         });
-        Object.defineProperty(this, "pasteStorage", {
+        Object.defineProperty(this, "lastPasteTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "imageStorage", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
-        }); // 存储大粘贴内容
-        Object.defineProperty(this, "pasteCounter", {
+        });
+        Object.defineProperty(this, "imageCounter", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 0
-        }); // 粘贴计数器
-        Object.defineProperty(this, "lastPasteTime", {
+        });
+        Object.defineProperty(this, "visualLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['']
+        });
+        Object.defineProperty(this, "visualLineStarts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [0]
+        });
+        Object.defineProperty(this, "visualCursorPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [0, 0]
+        });
+        Object.defineProperty(this, "preferredVisualCol", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: 0
-        }); // 最后粘贴时间
+        });
         this.viewport = viewport;
+        this.recalculateVisualState();
     }
     get text() {
-        return this.lines.join('\n');
+        return this.content;
     }
     /**
      * 获取完整文本，包括替换占位符为原始内容
      */
     getFullText() {
-        let fullText = this.text;
-        // 替换所有占位符为原始内容
-        for (const [, placeholder] of this.pasteStorage) {
-            fullText = fullText.replace(placeholder.placeholder, placeholder.content);
+        let fullText = this.content;
+        for (const placeholder of this.pasteStorage.values()) {
+            if (placeholder.placeholder) {
+                fullText = fullText.split(placeholder.placeholder).join(placeholder.content);
+            }
         }
         return fullText;
     }
     get visualCursor() {
-        return [this.cursorRow, this.cursorCol];
+        return this.visualCursorPos;
+    }
+    getCursorPosition() {
+        return this.cursorIndex;
     }
     get viewportVisualLines() {
-        // Return all lines instead of limiting by viewport height
-        // Viewport height should only be used for initial sizing, not content limiting
-        return this.lines;
+        return this.visualLines;
     }
     get maxWidth() {
-        // Viewport width is still useful for text wrapping/formatting
         return this.viewport.width;
     }
-    getCurrentLine() {
-        return this.lines[this.cursorRow] || '';
-    }
     scheduleUpdate() {
-        if (this.pendingUpdates)
-            return;
-        this.pendingUpdates = true;
-        // Defer updates to next tick to handle rapid input
-        process.nextTick(() => {
-            this.pendingUpdates = false;
-        });
+        // Removed pendingUpdates logic since it's not needed
     }
     setText(text) {
         const sanitized = sanitizeInput(text);
-        this.lines = sanitized.split('\n');
-        if (this.lines.length === 0) {
-            this.lines = [''];
-        }
-        this.cursorRow = Math.min(this.cursorRow, this.lines.length - 1);
-        this.cursorCol = Math.min(this.cursorCol, cpLen(this.getCurrentLine()));
-        // 清空时重置粘贴存储和计数器
-        if (text === '') {
+        this.content = sanitized;
+        this.clampCursorIndex();
+        if (sanitized === '') {
             this.pasteStorage.clear();
             this.pasteCounter = 0;
             this.lastPasteTime = 0;
+            this.imageStorage.clear();
+            this.imageCounter = 0;
         }
+        this.recalculateVisualState();
         this.scheduleUpdate();
     }
     insert(input) {
         const sanitized = sanitizeInput(input);
-        const lines = sanitized.split('\n');
+        if (!sanitized) {
+            return;
+        }
+        const charCount = sanitized.length;
         const now = Date.now();
-        // 检查是否为大量粘贴（超过10行），并防止重复处理
-        if (lines.length > 10) {
-            // 防止在短时间内重复处理同样的粘贴内容
+        if (charCount > 300) {
             if (now - this.lastPasteTime < 100) {
                 return;
             }
             this.lastPasteTime = now;
             this.pasteCounter++;
             const pasteId = `paste_${now}_${this.pasteCounter}`;
-            const placeholder = `[Paste ${lines.length} line #${this.pasteCounter}]`;
-            // 存储原始内容
+            const placeholderText = `[Paste ${charCount} characters #${this.pasteCounter}]`;
             this.pasteStorage.set(pasteId, {
                 id: pasteId,
                 content: sanitized,
-                lineCount: lines.length,
+                charCount: charCount,
                 index: this.pasteCounter,
-                placeholder: placeholder
+                placeholder: placeholderText
             });
-            // 插入占位符
-            const currentLine = this.getCurrentLine();
-            const before = cpSlice(currentLine, 0, this.cursorCol);
-            const after = cpSlice(currentLine, this.cursorCol);
-            this.lines[this.cursorRow] = before + placeholder + after;
-            this.cursorCol += cpLen(placeholder);
+            this.insertPlainText(placeholderText);
             this.scheduleUpdate();
             return;
         }
-        if (lines.length === 1) {
-            // Single line input - check for wrapping
-            const currentLine = this.getCurrentLine();
-            const before = cpSlice(currentLine, 0, this.cursorCol);
-            const after = cpSlice(currentLine, this.cursorCol);
-            const newLine = before + sanitized + after;
-            // 简化换行逻辑，只在超过最大宽度时换行
-            if (visualWidth(newLine) > this.viewport.width && this.viewport.width > 20) {
-                // 尝试在合适位置换行
-                const breakPoint = this.findBreakPoint(newLine, this.viewport.width);
-                if (breakPoint > 0 && breakPoint < newLine.length) {
-                    const firstPart = cpSlice(newLine, 0, breakPoint);
-                    const secondPart = cpSlice(newLine, breakPoint);
-                    this.lines[this.cursorRow] = firstPart;
-                    this.lines.splice(this.cursorRow + 1, 0, secondPart);
-                    // Calculate where cursor should be after insertion
-                    const newCursorPos = this.cursorCol + cpLen(sanitized);
-                    if (newCursorPos <= cpLen(firstPart)) {
-                        // Cursor stays on first line
-                        this.cursorCol = newCursorPos;
-                    }
-                    else {
-                        // Cursor moves to second line
-                        this.cursorRow++;
-                        this.cursorCol = newCursorPos - cpLen(firstPart);
-                    }
-                }
-                else {
-                    // 无法找到合适换行点，直接设置
-                    this.lines[this.cursorRow] = newLine;
-                    this.cursorCol += cpLen(sanitized);
-                }
-            }
-            else {
-                this.lines[this.cursorRow] = newLine;
-                this.cursorCol += cpLen(sanitized);
-            }
-        }
-        else {
-            // Multi-line input (paste) - 正常处理小于等于10行的粘贴
-            const currentLine = this.getCurrentLine();
-            const before = cpSlice(currentLine, 0, this.cursorCol);
-            const after = cpSlice(currentLine, this.cursorCol);
-            // First line: current line prefix + first paste line
-            this.lines[this.cursorRow] = before + lines[0];
-            // Middle lines: insert as new lines
-            const middleLines = lines.slice(1, -1);
-            this.lines.splice(this.cursorRow + 1, 0, ...middleLines);
-            // Last line: last paste line + current line suffix
-            const lastLine = lines[lines.length - 1] + after;
-            this.lines.splice(this.cursorRow + lines.length - 1, 0, lastLine);
-            // Update cursor position
-            this.cursorRow += lines.length - 1;
-            this.cursorCol = cpLen(lines[lines.length - 1] || '');
-        }
+        this.insertPlainText(sanitized);
         this.scheduleUpdate();
     }
-    findBreakPoint(line, maxWidth) {
-        const codePoints = toCodePoints(line);
-        let currentWidth = 0;
-        let lastSpaceIndex = -1;
-        for (let i = 0; i < codePoints.length; i++) {
-            const char = codePoints[i] || '';
-            const charWidth = visualWidth(char);
-            if (char === ' ') {
-                lastSpaceIndex = i;
-            }
-            if (currentWidth + charWidth > maxWidth) {
-                return lastSpaceIndex > 0 ? lastSpaceIndex : Math.max(1, i);
-            }
-            currentWidth += charWidth;
+    insertPlainText(text) {
+        if (!text) {
+            return;
         }
-        return codePoints.length;
+        this.clampCursorIndex();
+        const before = cpSlice(this.content, 0, this.cursorIndex);
+        const after = cpSlice(this.content, this.cursorIndex);
+        this.content = before + text + after;
+        this.cursorIndex += cpLen(text);
+        this.recalculateVisualState();
     }
     backspace() {
-        if (this.cursorCol > 0) {
-            const currentLine = this.getCurrentLine();
-            const before = cpSlice(currentLine, 0, this.cursorCol - 1);
-            const after = cpSlice(currentLine, this.cursorCol);
-            this.lines[this.cursorRow] = before + after;
-            this.cursorCol--;
-        }
-        else if (this.cursorRow > 0) {
-            const currentLine = this.getCurrentLine();
-            const prevLine = this.lines[this.cursorRow - 1] || '';
-            this.cursorCol = cpLen(prevLine);
-            this.lines[this.cursorRow - 1] = prevLine + currentLine;
-            this.lines.splice(this.cursorRow, 1);
-            this.cursorRow--;
+        if (this.cursorIndex === 0) {
+            return;
         }
+        const before = cpSlice(this.content, 0, this.cursorIndex - 1);
+        const after = cpSlice(this.content, this.cursorIndex);
+        this.content = before + after;
+        this.cursorIndex -= 1;
+        this.recalculateVisualState();
         this.scheduleUpdate();
     }
     delete() {
-        const currentLine = this.getCurrentLine();
-        if (this.cursorCol < cpLen(currentLine)) {
-            const before = cpSlice(currentLine, 0, this.cursorCol);
-            const after = cpSlice(currentLine, this.cursorCol + 1);
-            this.lines[this.cursorRow] = before + after;
-        }
-        else if (this.cursorRow < this.lines.length - 1) {
-            const nextLine = this.lines[this.cursorRow + 1] || '';
-            this.lines[this.cursorRow] = currentLine + nextLine;
-            this.lines.splice(this.cursorRow + 1, 1);
+        if (this.cursorIndex >= cpLen(this.content)) {
+            return;
         }
+        const before = cpSlice(this.content, 0, this.cursorIndex);
+        const after = cpSlice(this.content, this.cursorIndex + 1);
+        this.content = before + after;
+        this.recalculateVisualState();
         this.scheduleUpdate();
     }
     moveLeft() {
-        if (this.cursorCol > 0) {
-            this.cursorCol--;
-        }
-        else if (this.cursorRow > 0) {
-            this.cursorRow--;
-            this.cursorCol = cpLen(this.getCurrentLine());
+        if (this.cursorIndex === 0) {
+            return;
         }
+        this.cursorIndex -= 1;
+        this.recomputeVisualCursorOnly();
     }
     moveRight() {
-        const currentLine = this.getCurrentLine();
-        if (this.cursorCol < cpLen(currentLine)) {
-            this.cursorCol++;
-        }
-        else if (this.cursorRow < this.lines.length - 1) {
-            this.cursorRow++;
-            this.cursorCol = 0;
+        if (this.cursorIndex >= cpLen(this.content)) {
+            return;
         }
+        this.cursorIndex += 1;
+        this.recomputeVisualCursorOnly();
     }
     moveUp() {
-        if (this.cursorRow > 0) {
-            this.cursorRow--;
-            const newLineLength = cpLen(this.getCurrentLine());
-            this.cursorCol = Math.min(this.cursorCol, newLineLength);
+        if (this.visualLines.length === 0) {
+            return;
         }
+        const currentRow = this.visualCursorPos[0];
+        if (currentRow <= 0) {
+            return;
+        }
+        this.moveCursorToVisualRow(currentRow - 1);
     }
     moveDown() {
-        if (this.cursorRow < this.lines.length - 1) {
-            this.cursorRow++;
-            const newLineLength = cpLen(this.getCurrentLine());
-            this.cursorCol = Math.min(this.cursorCol, newLineLength);
+        if (this.visualLines.length === 0) {
+            return;
+        }
+        const currentRow = this.visualCursorPos[0];
+        if (currentRow >= this.visualLines.length - 1) {
+            return;
         }
+        this.moveCursorToVisualRow(currentRow + 1);
     }
     /**
      * Update the viewport dimensions, useful for terminal resize handling.
      */
     updateViewport(viewport) {
         this.viewport = viewport;
+        this.recalculateVisualState();
         this.scheduleUpdate();
     }
     /**
      * Get the character and its visual info at cursor position for proper rendering.
      */
     getCharAtCursor() {
-        const currentLine = this.getCurrentLine();
-        const codePoints = toCodePoints(currentLine);
-        if (this.cursorCol >= codePoints.length) {
+        const codePoints = toCodePoints(this.content);
+        if (this.cursorIndex >= codePoints.length) {
             return { char: ' ', isWideChar: false };
         }
-        const char = codePoints[this.cursorCol] || ' ';
-        const isWideChar = visualWidth(char) > 1;
-        return { char, isWideChar };
+        const char = codePoints[this.cursorIndex] || ' ';
+        return { char, isWideChar: visualWidth(char) > 1 };
+    }
+    clampCursorIndex() {
+        const length = cpLen(this.content);
+        if (this.cursorIndex < 0) {
+            this.cursorIndex = 0;
+        }
+        else if (this.cursorIndex > length) {
+            this.cursorIndex = length;
+        }
+    }
+    recalculateVisualState() {
+        this.clampCursorIndex();
+        const width = this.viewport.width;
+        const effectiveWidth = Number.isFinite(width) && width > 0 ? width : Number.POSITIVE_INFINITY;
+        const rawLines = this.content.split('\n');
+        const nextVisualLines = [];
+        const nextStarts = [];
+        let cpOffset = 0;
+        const linesToProcess = rawLines.length > 0 ? rawLines : [''];
+        for (let i = 0; i < linesToProcess.length; i++) {
+            const rawLine = linesToProcess[i] ?? '';
+            const segments = this.wrapLineToWidth(rawLine, effectiveWidth);
+            if (segments.length === 0) {
+                nextVisualLines.push('');
+                nextStarts.push(cpOffset);
+            }
+            else {
+                for (const segment of segments) {
+                    nextVisualLines.push(segment);
+                    nextStarts.push(cpOffset);
+                    cpOffset += cpLen(segment);
+                }
+            }
+            if (i < linesToProcess.length - 1) {
+                // Account for the newline character that separates raw lines
+                cpOffset += 1;
+            }
+        }
+        if (nextVisualLines.length === 0) {
+            nextVisualLines.push('');
+            nextStarts.push(0);
+        }
+        this.visualLines = nextVisualLines;
+        this.visualLineStarts = nextStarts;
+        this.visualCursorPos = this.computeVisualCursorFromIndex(this.cursorIndex);
+        this.preferredVisualCol = this.visualCursorPos[1];
+    }
+    wrapLineToWidth(line, width) {
+        if (line === '') {
+            return [''];
+        }
+        if (!Number.isFinite(width) || width <= 0) {
+            return [line];
+        }
+        const codePoints = toCodePoints(line);
+        const segments = [];
+        let start = 0;
+        while (start < codePoints.length) {
+            let currentWidth = 0;
+            let end = start;
+            let lastBreak = -1;
+            while (end < codePoints.length) {
+                const char = codePoints[end] || '';
+                const charWidth = visualWidth(char);
+                if (char === ' ') {
+                    lastBreak = end + 1;
+                }
+                if (currentWidth + charWidth > width) {
+                    if (lastBreak > start) {
+                        end = lastBreak;
+                    }
+                    break;
+                }
+                currentWidth += charWidth;
+                end++;
+            }
+            if (end === start) {
+                end = Math.min(start + 1, codePoints.length);
+            }
+            segments.push(codePoints.slice(start, end).join(''));
+            start = end;
+        }
+        return segments;
+    }
+    computeVisualCursorFromIndex(position) {
+        if (this.visualLines.length === 0) {
+            return [0, 0];
+        }
+        const totalLength = cpLen(this.content);
+        const clamped = Math.max(0, Math.min(position, totalLength));
+        for (let i = this.visualLines.length - 1; i >= 0; i--) {
+            const start = this.visualLineStarts[i] ?? 0;
+            if (clamped >= start) {
+                const line = this.visualLines[i] ?? '';
+                const col = Math.min(cpLen(line), clamped - start);
+                return [i, col];
+            }
+        }
+        return [0, clamped];
+    }
+    moveCursorToVisualRow(targetRow) {
+        if (this.visualLines.length === 0) {
+            this.cursorIndex = 0;
+            this.visualCursorPos = [0, 0];
+            return;
+        }
+        const row = Math.max(0, Math.min(targetRow, this.visualLines.length - 1));
+        const start = this.visualLineStarts[row] ?? 0;
+        const line = this.visualLines[row] ?? '';
+        const lineLength = cpLen(line);
+        const column = Math.min(this.preferredVisualCol, lineLength);
+        this.cursorIndex = start + column;
+        this.visualCursorPos = [row, column];
+    }
+    recomputeVisualCursorOnly() {
+        this.visualCursorPos = this.computeVisualCursorFromIndex(this.cursorIndex);
+        this.preferredVisualCol = this.visualCursorPos[1];
+    }
+    /**
+     * 插入图片数据
+     */
+    insertImage(base64Data, mimeType) {
+        this.imageCounter++;
+        const imageId = `image_${Date.now()}_${this.imageCounter}`;
+        const placeholderText = `[image #${this.imageCounter}]`;
+        this.imageStorage.set(imageId, {
+            id: imageId,
+            data: base64Data,
+            mimeType: mimeType,
+            index: this.imageCounter,
+            placeholder: placeholderText
+        });
+        this.insertPlainText(placeholderText);
+        this.scheduleUpdate();
+    }
+    /**
+     * 获取所有图片数据
+     */
+    getImages() {
+        return Array.from(this.imageStorage.values()).sort((a, b) => a.index - b.index);
+    }
+    /**
+     * 清除所有图片
+     */
+    clearImages() {
+        this.imageStorage.clear();
+        this.imageCounter = 0;
     }
 }

package/dist/utils/todoPreprocessor.d.ts

@@ -0,0 +1,5 @@
+export declare function formatTodoContext(todos: Array<{
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+}>): string;

package/dist/utils/todoPreprocessor.js

@@ -0,0 +1,19 @@
+export function formatTodoContext(todos) {
+    if (todos.length === 0) {
+        return '';
+    }
+    const statusSymbol = {
+        pending: '[ ]',
+        in_progress: '[~]',
+        completed: '[x]',
+    };
+    const lines = [
+        '## Current TODO List',
+        '',
+        ...todos.map(t => `${statusSymbol[t.status]} ${t.content} (ID: ${t.id})`),
+        '',
+        '**Important**: Update TODO status immediately after completing each task using todo-update tool.',
+        '',
+    ];
+    return lines.join('\n');
+}

package/dist/utils/toolExecutor.d.ts

@@ -0,0 +1,21 @@
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolResult {
+    tool_call_id: string;
+    role: 'tool';
+    content: string;
+}
+/**
+ * Execute a single tool call and return the result
+ */
+export declare function executeToolCall(toolCall: ToolCall): Promise<ToolResult>;
+/**
+ * Execute multiple tool calls in parallel
+ */
+export declare function executeToolCalls(toolCalls: ToolCall[]): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -0,0 +1,28 @@
+import { executeMCPTool } from './mcpToolsManager.js';
+/**
+ * Execute a single tool call and return the result
+ */
+export async function executeToolCall(toolCall) {
+    try {
+        const args = JSON.parse(toolCall.function.arguments);
+        const result = await executeMCPTool(toolCall.function.name, args);
+        return {
+            tool_call_id: toolCall.id,
+            role: 'tool',
+            content: JSON.stringify(result)
+        };
+    }
+    catch (error) {
+        return {
+            tool_call_id: toolCall.id,
+            role: 'tool',
+            content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`
+        };
+    }
+}
+/**
+ * Execute multiple tool calls in parallel
+ */
+export async function executeToolCalls(toolCalls) {
+    return Promise.all(toolCalls.map(tc => executeToolCall(tc)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.1.12",
+	"version": "0.2.2",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -40,18 +40,27 @@
 	],
 	"dependencies": {
 		"@inkjs/ui": "^2.0.0",
+		"@modelcontextprotocol/sdk": "^1.17.3",
+		"chalk-template": "^1.1.2",
+		"cli-highlight": "^2.1.11",
+		"diff": "^8.0.2",
 		"figlet": "^1.8.2",
 		"ink": "^5.2.1",
 		"ink-gradient": "^3.0.0",
+		"ink-markdown": "^1.0.4",
+		"ink-select-input": "^6.2.0",
+		"ink-spinner": "^5.0.0",
 		"ink-text-input": "^6.0.0",
 		"ink-tree-select": "^2.3.1",
 		"meow": "^11.0.0",
-		"openai": "^5.12.2",
+		"openai": "^6.1.0",
 		"react": "^18.2.0",
-		"string-width": "^7.2.0"
+		"string-width": "^7.2.0",
+		"tiktoken": "^1.0.22"
 	},
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/diff": "^7.0.2",
 		"@types/figlet": "^1.7.0",
 		"@types/react": "^18.0.32",
 		"@vdemedes/prettier-config": "^2.0.1",