snow-ai 0.1.12

package/dist/utils/textBuffer.js

@@ -0,0 +1,310 @@
+import { cpLen, cpSlice, visualWidth, toCodePoints } from './textUtils.js';
+/**
+ * Strip characters that can break terminal rendering.
+ */
+function sanitizeInput(str) {
+    // Replace problematic characters but preserve basic formatting
+    return str
+        .replace(/\r\n/g, '\n') // Normalize line endings
+        .replace(/\r/g, '\n') // Convert remaining \r to \n
+        .replace(/\t/g, '  ') // Convert tabs to spaces
+        // Remove control characters except newlines
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+}
+export class TextBuffer {
+    constructor(viewport) {
+        Object.defineProperty(this, "lines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['']
+        });
+        Object.defineProperty(this, "cursorRow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "cursorCol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "viewport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Still needed for width-based text wrapping
+        Object.defineProperty(this, "pendingUpdates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "pasteStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // 存储大粘贴内容
+        Object.defineProperty(this, "pasteCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // 粘贴计数器
+        Object.defineProperty(this, "lastPasteTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // 最后粘贴时间
+        this.viewport = viewport;
+    }
+    get text() {
+        return this.lines.join('\n');
+    }
+    /**
+     * 获取完整文本，包括替换占位符为原始内容
+     */
+    getFullText() {
+        let fullText = this.text;
+        // 替换所有占位符为原始内容
+        for (const [, placeholder] of this.pasteStorage) {
+            fullText = fullText.replace(placeholder.placeholder, placeholder.content);
+        }
+        return fullText;
+    }
+    get visualCursor() {
+        return [this.cursorRow, this.cursorCol];
+    }
+    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;
+    }
+    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;
+        });
+    }
+    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.pasteStorage.clear();
+            this.pasteCounter = 0;
+            this.lastPasteTime = 0;
+        }
+        this.scheduleUpdate();
+    }
+    insert(input) {
+        const sanitized = sanitizeInput(input);
+        const lines = sanitized.split('\n');
+        const now = Date.now();
+        // 检查是否为大量粘贴（超过10行），并防止重复处理
+        if (lines.length > 10) {
+            // 防止在短时间内重复处理同样的粘贴内容
+            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}]`;
+            // 存储原始内容
+            this.pasteStorage.set(pasteId, {
+                id: pasteId,
+                content: sanitized,
+                lineCount: lines.length,
+                index: this.pasteCounter,
+                placeholder: placeholder
+            });
+            // 插入占位符
+            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.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.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;
+        }
+        return codePoints.length;
+    }
+    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--;
+        }
+        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);
+        }
+        this.scheduleUpdate();
+    }
+    moveLeft() {
+        if (this.cursorCol > 0) {
+            this.cursorCol--;
+        }
+        else if (this.cursorRow > 0) {
+            this.cursorRow--;
+            this.cursorCol = cpLen(this.getCurrentLine());
+        }
+    }
+    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;
+        }
+    }
+    moveUp() {
+        if (this.cursorRow > 0) {
+            this.cursorRow--;
+            const newLineLength = cpLen(this.getCurrentLine());
+            this.cursorCol = Math.min(this.cursorCol, newLineLength);
+        }
+    }
+    moveDown() {
+        if (this.cursorRow < this.lines.length - 1) {
+            this.cursorRow++;
+            const newLineLength = cpLen(this.getCurrentLine());
+            this.cursorCol = Math.min(this.cursorCol, newLineLength);
+        }
+    }
+    /**
+     * Update the viewport dimensions, useful for terminal resize handling.
+     */
+    updateViewport(viewport) {
+        this.viewport = viewport;
+        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) {
+            return { char: ' ', isWideChar: false };
+        }
+        const char = codePoints[this.cursorCol] || ' ';
+        const isWideChar = visualWidth(char) > 1;
+        return { char, isWideChar };
+    }
+}

package/dist/utils/textUtils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Convert a string to an array of code points (Unicode characters).
+ * Handles surrogate pairs correctly.
+ */
+export declare function toCodePoints(str: string): string[];
+/**
+ * Get the length of a string in code points (not bytes).
+ */
+export declare function cpLen(str: string): number;
+/**
+ * Slice a string by code point indices (not byte indices).
+ */
+export declare function cpSlice(str: string, start: number, end?: number): string;
+/**
+ * Get the visual width of a string (how many columns it occupies in terminal).
+ * Handles wide characters like Chinese, emojis, etc.
+ */
+export declare function visualWidth(str: string): number;
+/**
+ * Get character at visual position (accounting for wide characters).
+ */
+export declare function getCharAtVisualPos(str: string, visualPos: number): {
+    char: string;
+    codePointIndex: number;
+} | null;
+/**
+ * Convert code point index to visual position.
+ */
+export declare function codePointToVisualPos(str: string, codePointIndex: number): number;
+/**
+ * Convert visual position to code point index.
+ */
+export declare function visualPosToCodePoint(str: string, visualPos: number): number;

package/dist/utils/textUtils.js

@@ -0,0 +1,83 @@
+import stringWidth from 'string-width';
+/**
+ * Convert a string to an array of code points (Unicode characters).
+ * Handles surrogate pairs correctly.
+ */
+export function toCodePoints(str) {
+    return Array.from(str);
+}
+/**
+ * Get the length of a string in code points (not bytes).
+ */
+export function cpLen(str) {
+    return toCodePoints(str).length;
+}
+/**
+ * Slice a string by code point indices (not byte indices).
+ */
+export function cpSlice(str, start, end) {
+    const codePoints = toCodePoints(str);
+    return codePoints.slice(start, end).join('');
+}
+/**
+ * Get the visual width of a string (how many columns it occupies in terminal).
+ * Handles wide characters like Chinese, emojis, etc.
+ */
+export function visualWidth(str) {
+    return stringWidth(str);
+}
+/**
+ * Get character at visual position (accounting for wide characters).
+ */
+export function getCharAtVisualPos(str, visualPos) {
+    const codePoints = toCodePoints(str);
+    let currentVisualPos = 0;
+    for (let i = 0; i < codePoints.length; i++) {
+        const char = codePoints[i] || '';
+        const charWidth = visualWidth(char);
+        if (currentVisualPos === visualPos) {
+            return { char, codePointIndex: i };
+        }
+        if (currentVisualPos + charWidth > visualPos) {
+            // We're in the middle of a wide character
+            return { char, codePointIndex: i };
+        }
+        currentVisualPos += charWidth;
+    }
+    // Position is at the end of the string
+    if (currentVisualPos === visualPos) {
+        return { char: '', codePointIndex: codePoints.length };
+    }
+    return null;
+}
+/**
+ * Convert code point index to visual position.
+ */
+export function codePointToVisualPos(str, codePointIndex) {
+    const codePoints = toCodePoints(str);
+    let visualPos = 0;
+    for (let i = 0; i < Math.min(codePointIndex, codePoints.length); i++) {
+        const char = codePoints[i] || '';
+        visualPos += visualWidth(char);
+    }
+    return visualPos;
+}
+/**
+ * Convert visual position to code point index.
+ */
+export function visualPosToCodePoint(str, visualPos) {
+    const codePoints = toCodePoints(str);
+    let currentVisualPos = 0;
+    for (let i = 0; i < codePoints.length; i++) {
+        const char = codePoints[i] || '';
+        const charWidth = visualWidth(char);
+        if (currentVisualPos + charWidth > visualPos) {
+            return i;
+        }
+        currentVisualPos += charWidth;
+        if (currentVisualPos >= visualPos) {
+            return i + 1;
+        }
+    }
+    return codePoints.length;
+}

package/package.json

@@ -0,0 +1,86 @@
+{
+	"name": "snow-ai",
+	"version": "0.1.12",
+	"description": "Intelligent Command Line Assistant powered by AI",
+	"license": "MIT",
+	"bin": {
+		"snow": "dist/cli.js"
+	},
+	"type": "module",
+	"keywords": [
+		"cli",
+		"ai",
+		"assistant",
+		"bot",
+		"terminal"
+	],
+	"author": "Mufasa",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/MayDay-wpf/snow-cli.git"
+	},
+	"bugs": {
+		"url": "https://github.com/MayDay-wpf/snow-cli/issues"
+	},
+	"homepage": "https://github.com/MayDay-wpf/snow-cli#readme",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"start": "node dist/cli.js",
+		"prepublishOnly": "npm run build",
+		"test": "prettier --check . && xo && ava",
+		"lint": "xo",
+		"format": "prettier --write ."
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"@inkjs/ui": "^2.0.0",
+		"figlet": "^1.8.2",
+		"ink": "^5.2.1",
+		"ink-gradient": "^3.0.0",
+		"ink-text-input": "^6.0.0",
+		"ink-tree-select": "^2.3.1",
+		"meow": "^11.0.0",
+		"openai": "^5.12.2",
+		"react": "^18.2.0",
+		"string-width": "^7.2.0"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/figlet": "^1.7.0",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.53.1"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}

package/readme.md

@@ -0,0 +1,9 @@
+# aibotpro-cli
+
+> This readme is automatically generated by [create-ink-app](https://github.com/vadimdemedes/create-ink-app)
+
+## Install
+
+```bash
+$ npm install --global aibotpro-cli
+```