snow-ai 0.1.12 → 0.2.2

package/dist/utils/sessionManager.js

@@ -0,0 +1,141 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+class SessionManager {
+    constructor() {
+        Object.defineProperty(this, "sessionsDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentSession", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.sessionsDir = path.join(os.homedir(), '.snow', 'sessions');
+    }
+    async ensureSessionsDir() {
+        try {
+            await fs.mkdir(this.sessionsDir, { recursive: true });
+        }
+        catch (error) {
+            // Directory already exists or other error
+        }
+    }
+    getSessionPath(sessionId) {
+        return path.join(this.sessionsDir, `${sessionId}.json`);
+    }
+    async createNewSession() {
+        await this.ensureSessionsDir();
+        // 使用 UUID v4 生成唯一会话 ID，避免并发冲突
+        const sessionId = randomUUID();
+        const session = {
+            id: sessionId,
+            title: 'New Chat',
+            summary: '',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            messages: [],
+            messageCount: 0
+        };
+        this.currentSession = session;
+        await this.saveSession(session);
+        return session;
+    }
+    async saveSession(session) {
+        await this.ensureSessionsDir();
+        const sessionPath = this.getSessionPath(session.id);
+        await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+    }
+    async loadSession(sessionId) {
+        try {
+            const sessionPath = this.getSessionPath(sessionId);
+            const data = await fs.readFile(sessionPath, 'utf-8');
+            const session = JSON.parse(data);
+            this.currentSession = session;
+            return session;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async listSessions() {
+        await this.ensureSessionsDir();
+        try {
+            const files = await fs.readdir(this.sessionsDir);
+            const sessions = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const sessionPath = path.join(this.sessionsDir, file);
+                        const data = await fs.readFile(sessionPath, 'utf-8');
+                        const session = JSON.parse(data);
+                        sessions.push({
+                            id: session.id,
+                            title: session.title,
+                            summary: session.summary,
+                            createdAt: session.createdAt,
+                            updatedAt: session.updatedAt,
+                            messageCount: session.messageCount
+                        });
+                    }
+                    catch (error) {
+                        // Skip invalid session files
+                        continue;
+                    }
+                }
+            }
+            // Sort by updatedAt (newest first)
+            return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    async addMessage(message) {
+        if (!this.currentSession) {
+            this.currentSession = await this.createNewSession();
+        }
+        // Check if this exact message already exists to prevent duplicates
+        const existingMessage = this.currentSession.messages.find(m => m.role === message.role &&
+            m.content === message.content &&
+            Math.abs(m.timestamp - message.timestamp) < 5000 // Within 5 seconds
+        );
+        if (existingMessage) {
+            return; // Don't add duplicate message
+        }
+        this.currentSession.messages.push(message);
+        this.currentSession.messageCount = this.currentSession.messages.length;
+        this.currentSession.updatedAt = Date.now();
+        // Simple title generation from first user message (no API call)
+        if (this.currentSession.messageCount === 1 && message.role === 'user') {
+            this.currentSession.title = message.content.slice(0, 50);
+            this.currentSession.summary = message.content.slice(0, 100);
+        }
+        await this.saveSession(this.currentSession);
+    }
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    setCurrentSession(session) {
+        this.currentSession = session;
+    }
+    clearCurrentSession() {
+        this.currentSession = null;
+    }
+    async deleteSession(sessionId) {
+        try {
+            const sessionPath = this.getSessionPath(sessionId);
+            await fs.unlink(sessionPath);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+export const sessionManager = new SessionManager();

package/dist/utils/textBuffer.d.ts

@@ -5,19 +5,30 @@ export interface Viewport {
 export interface PastePlaceholder {
     id: string;
     content: string;
-    lineCount: number;
+    charCount: number;
+    index: number;
+    placeholder: string;
+}
+export interface ImageData {
+    id: string;
+    data: string;
+    mimeType: string;
     index: number;
     placeholder: string;
 }
 export declare class TextBuffer {
-    private lines;
-    private cursorRow;
-    private cursorCol;
+    private content;
+    private cursorIndex;
     private viewport;
-    private pendingUpdates;
     private pasteStorage;
     private pasteCounter;
     private lastPasteTime;
+    private imageStorage;
+    private imageCounter;
+    private visualLines;
+    private visualLineStarts;
+    private visualCursorPos;
+    private preferredVisualCol;
     constructor(viewport: Viewport);
     get text(): string;
     /**
@@ -25,13 +36,13 @@ export declare class TextBuffer {
      */
     getFullText(): string;
     get visualCursor(): [number, number];
+    getCursorPosition(): number;
     get viewportVisualLines(): string[];
     get maxWidth(): number;
-    private getCurrentLine;
     private scheduleUpdate;
     setText(text: string): void;
     insert(input: string): void;
-    private findBreakPoint;
+    private insertPlainText;
     backspace(): void;
     delete(): void;
     moveLeft(): void;
@@ -49,4 +60,22 @@ export declare class TextBuffer {
         char: string;
         isWideChar: boolean;
     };
+    private clampCursorIndex;
+    private recalculateVisualState;
+    private wrapLineToWidth;
+    private computeVisualCursorFromIndex;
+    private moveCursorToVisualRow;
+    private recomputeVisualCursorOnly;
+    /**
+     * 插入图片数据
+     */
+    insertImage(base64Data: string, mimeType: string): void;
+    /**
+     * 获取所有图片数据
+     */
+    getImages(): ImageData[];
+    /**
+     * 清除所有图片
+     */
+    clearImages(): void;
 }