snow-ai 0.4.15 → 0.4.17

package/dist/utils/usageLogger.js

@@ -1,114 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
-// 队列来避免并发写入冲突
-let writeQueue = Promise.resolve();
-async function getActiveProfile() {
-    try {
-        const homeDir = os.homedir();
-        const jsonPath = path.join(homeDir, '.snow', 'active-profile.json');
-        const legacyPath = path.join(homeDir, '.snow', 'active-profile.txt');
-        // Try JSON format first
-        try {
-            const fileContent = await fs.readFile(jsonPath, 'utf-8');
-            const data = JSON.parse(fileContent.trim());
-            return data.activeProfile || 'default';
-        }
-        catch {
-            // Fallback to legacy .txt format if JSON doesn't exist
-            try {
-                const profileName = await fs.readFile(legacyPath, 'utf-8');
-                return profileName.trim() || 'default';
-            }
-            catch {
-                return 'default';
-            }
-        }
-    }
-    catch (error) {
-        return 'default';
-    }
-}
-async function getUsageDir() {
-    const homeDir = os.homedir();
-    const snowDir = path.join(homeDir, '.snow', 'usage');
-    const today = new Date().toISOString().split('T')[0] || ''; // YYYY-MM-DD
-    const dateDir = path.join(snowDir, today);
-    // 确保目录存在
-    try {
-        await fs.mkdir(dateDir, { recursive: true });
-    }
-    catch (error) {
-        // 目录可能已存在，忽略错误
-    }
-    return dateDir;
-}
-async function getCurrentLogFile(dateDir) {
-    try {
-        const files = (await fs.readdir(dateDir)).filter(f => f.startsWith('usage-') && f.endsWith('.jsonl'));
-        if (files.length === 0) {
-            return path.join(dateDir, 'usage-001.jsonl');
-        }
-        // 按文件名排序，获取最新的文件
-        files.sort();
-        const latestFileName = files[files.length - 1];
-        if (!latestFileName) {
-            return path.join(dateDir, 'usage-001.jsonl');
-        }
-        const latestFile = path.join(dateDir, latestFileName);
-        // 检查文件大小
-        const stats = await fs.stat(latestFile);
-        if (stats.size >= MAX_FILE_SIZE) {
-            // 创建新文件
-            const match = latestFileName.match(/usage-(\d+)\.jsonl/);
-            const nextNum = match && match[1] ? parseInt(match[1]) + 1 : 1;
-            return path.join(dateDir, `usage-${String(nextNum).padStart(3, '0')}.jsonl`);
-        }
-        return latestFile;
-    }
-    catch (error) {
-        // 如果目录不存在或读取失败，返回默认文件名
-        return path.join(dateDir, 'usage-001.jsonl');
-    }
-}
-/**
- * Save usage data to file system
- * This is called directly from API layers to ensure all usage is tracked
- */
-export function saveUsageToFile(model, usage) {
-    // Add to write queue to avoid concurrent writes
-    writeQueue = writeQueue
-        .then(async () => {
-        try {
-            const profileName = await getActiveProfile();
-            const dateDir = await getUsageDir();
-            const logFile = await getCurrentLogFile(dateDir);
-            // Extract cache tokens (different API formats)
-            const cacheReadTokens = usage.cache_read_input_tokens ?? usage.cached_tokens;
-            // Only save non-sensitive data: model name, profile, and token counts
-            const record = {
-                model,
-                profileName,
-                inputTokens: usage.prompt_tokens || 0,
-                outputTokens: usage.completion_tokens || 0,
-                ...(usage.cache_creation_input_tokens !== undefined && {
-                    cacheCreationInputTokens: usage.cache_creation_input_tokens,
-                }),
-                ...(cacheReadTokens !== undefined && {
-                    cacheReadInputTokens: cacheReadTokens,
-                }),
-                timestamp: new Date().toISOString(),
-            };
-            // Append to file (JSONL format: one JSON object per line)
-            const line = JSON.stringify(record) + '\n';
-            await fs.appendFile(logFile, line, 'utf-8');
-        }
-        catch (error) {
-            console.error('Failed to save usage data:', error);
-        }
-    })
-        .catch(error => {
-        console.error('Usage persistence queue error:', error);
-    });
-}

package/dist/utils/vscodeConnection.d.ts

@@ -1,76 +0,0 @@
-interface EditorContext {
-    activeFile?: string;
-    selectedText?: string;
-    cursorPosition?: {
-        line: number;
-        character: number;
-    };
-    workspaceFolder?: string;
-}
-interface Diagnostic {
-    message: string;
-    severity: 'error' | 'warning' | 'info' | 'hint';
-    line: number;
-    character: number;
-    source?: string;
-    code?: string | number;
-}
-declare class VSCodeConnectionManager {
-    private client;
-    private reconnectTimer;
-    private reconnectAttempts;
-    private readonly MAX_RECONNECT_ATTEMPTS;
-    private readonly BASE_RECONNECT_DELAY;
-    private readonly MAX_RECONNECT_DELAY;
-    private readonly VSCODE_BASE_PORT;
-    private readonly VSCODE_MAX_PORT;
-    private readonly JETBRAINS_BASE_PORT;
-    private readonly JETBRAINS_MAX_PORT;
-    private port;
-    private editorContext;
-    private listeners;
-    private currentWorkingDirectory;
-    private connectingPromise;
-    private connectionTimeout;
-    private readonly CONNECTION_TIMEOUT;
-    start(): Promise<void>;
-    /**
-     * Clean up connection state and resources
-     */
-    private cleanupConnection;
-    /**
-     * Normalize path for cross-platform compatibility
-     * - Converts Windows backslashes to forward slashes
-     * - Converts drive letters to lowercase for consistent comparison
-     */
-    private normalizePath;
-    /**
-     * Find the correct port for the current workspace
-     */
-    private findPortForWorkspace;
-    /**
-     * Check if we should handle this message based on workspace folder
-     */
-    private shouldHandleMessage;
-    private scheduleReconnect;
-    stop(): void;
-    isConnected(): boolean;
-    isClientRunning(): boolean;
-    getContext(): EditorContext;
-    onContextUpdate(listener: (context: EditorContext) => void): () => void;
-    private handleMessage;
-    private notifyListeners;
-    getPort(): number;
-    /**
-     * Request diagnostics for a specific file from IDE
-     * @param filePath - The file path to get diagnostics for
-     * @returns Promise that resolves with diagnostics array
-     */
-    requestDiagnostics(filePath: string): Promise<Diagnostic[]>;
-    /**
-     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
-     */
-    resetReconnectAttempts(): void;
-}
-export declare const vscodeConnection: VSCodeConnectionManager;
-export type { EditorContext, Diagnostic };

package/dist/utils/vscodeConnection.js

@@ -1,430 +0,0 @@
-import { WebSocket } from 'ws';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-class VSCodeConnectionManager {
-    constructor() {
-        Object.defineProperty(this, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "reconnectTimer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "reconnectAttempts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "MAX_RECONNECT_ATTEMPTS", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 10
-        });
-        Object.defineProperty(this, "BASE_RECONNECT_DELAY", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 2000
-        }); // 2 seconds
-        Object.defineProperty(this, "MAX_RECONNECT_DELAY", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 30000
-        }); // 30 seconds
-        // Port ranges: VSCode uses 9527-9537, JetBrains uses 9538-9548
-        Object.defineProperty(this, "VSCODE_BASE_PORT", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 9527
-        });
-        Object.defineProperty(this, "VSCODE_MAX_PORT", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 9537
-        });
-        Object.defineProperty(this, "JETBRAINS_BASE_PORT", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 9538
-        });
-        Object.defineProperty(this, "JETBRAINS_MAX_PORT", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 9548
-        });
-        Object.defineProperty(this, "port", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 9527
-        });
-        Object.defineProperty(this, "editorContext", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "listeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "currentWorkingDirectory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: process.cwd()
-        });
-        // Connection state management
-        Object.defineProperty(this, "connectingPromise", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "connectionTimeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "CONNECTION_TIMEOUT", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 10000
-        }); // 10 seconds timeout for initial connection
-    }
-    async start() {
-        // If already connected, just return success
-        if (this.client?.readyState === WebSocket.OPEN) {
-            return Promise.resolve();
-        }
-        // If already connecting, return the existing promise to avoid duplicate connections
-        if (this.connectingPromise) {
-            return this.connectingPromise;
-        }
-        // Try to find the correct port for this workspace
-        const targetPort = this.findPortForWorkspace();
-        // Create a new connection promise and store it
-        this.connectingPromise = new Promise((resolve, reject) => {
-            let isSettled = false; // Prevent double resolve/reject
-            // Set connection timeout
-            this.connectionTimeout = setTimeout(() => {
-                if (!isSettled) {
-                    isSettled = true;
-                    this.cleanupConnection();
-                    reject(new Error('Connection timeout after 10 seconds'));
-                }
-            }, this.CONNECTION_TIMEOUT);
-            const tryConnect = (port) => {
-                // If already settled (resolved or rejected), stop trying
-                if (isSettled) {
-                    return;
-                }
-                // Check both VSCode and JetBrains port ranges
-                if (port > this.VSCODE_MAX_PORT && port < this.JETBRAINS_BASE_PORT) {
-                    // Jump from VSCode range to JetBrains range
-                    tryConnect(this.JETBRAINS_BASE_PORT);
-                    return;
-                }
-                if (port > this.JETBRAINS_MAX_PORT) {
-                    if (!isSettled) {
-                        isSettled = true;
-                        this.cleanupConnection();
-                        reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
-                    }
-                    return;
-                }
-                try {
-                    this.client = new WebSocket(`ws://localhost:${port}`);
-                    this.client.on('open', () => {
-                        if (!isSettled) {
-                            isSettled = true;
-                            // Reset reconnect attempts on successful connection
-                            this.reconnectAttempts = 0;
-                            this.port = port;
-                            // Clear connection state
-                            if (this.connectionTimeout) {
-                                clearTimeout(this.connectionTimeout);
-                                this.connectionTimeout = null;
-                            }
-                            this.connectingPromise = null;
-                            resolve();
-                        }
-                    });
-                    this.client.on('message', message => {
-                        try {
-                            const data = JSON.parse(message.toString());
-                            // Filter messages by workspace folder
-                            if (this.shouldHandleMessage(data)) {
-                                this.handleMessage(data);
-                            }
-                        }
-                        catch (error) {
-                            // Ignore invalid JSON
-                        }
-                    });
-                    this.client.on('close', () => {
-                        this.client = null;
-                        // Only schedule reconnect if this was an established connection (not initial scan)
-                        if (this.reconnectAttempts > 0 || isSettled) {
-                            this.scheduleReconnect();
-                        }
-                    });
-                    this.client.on('error', _error => {
-                        // On initial connection, try next port
-                        if (this.reconnectAttempts === 0 && !isSettled) {
-                            this.client = null;
-                            // Small delay before trying next port to avoid rapid fire
-                            setTimeout(() => tryConnect(port + 1), 50);
-                        }
-                        // For reconnections, silently handle and let close event trigger reconnect
-                    });
-                }
-                catch (error) {
-                    if (!isSettled) {
-                        setTimeout(() => tryConnect(port + 1), 50);
-                    }
-                }
-            };
-            tryConnect(targetPort);
-        });
-        // Return the promise and clean up state when it completes or fails
-        return this.connectingPromise.finally(() => {
-            this.connectingPromise = null;
-            if (this.connectionTimeout) {
-                clearTimeout(this.connectionTimeout);
-                this.connectionTimeout = null;
-            }
-        });
-    }
-    /**
-     * Clean up connection state and resources
-     */
-    cleanupConnection() {
-        this.connectingPromise = null;
-        if (this.connectionTimeout) {
-            clearTimeout(this.connectionTimeout);
-            this.connectionTimeout = null;
-        }
-        if (this.client) {
-            try {
-                this.client.removeAllListeners();
-                this.client.close();
-            }
-            catch (error) {
-                // Ignore errors during cleanup
-            }
-            this.client = null;
-        }
-    }
-    /**
-     * Normalize path for cross-platform compatibility
-     * - Converts Windows backslashes to forward slashes
-     * - Converts drive letters to lowercase for consistent comparison
-     */
-    normalizePath(filePath) {
-        let normalized = filePath.replace(/\\/g, '/');
-        // Convert Windows drive letter to lowercase (C: -> c:)
-        if (/^[A-Z]:/.test(normalized)) {
-            normalized = normalized.charAt(0).toLowerCase() + normalized.slice(1);
-        }
-        return normalized;
-    }
-    /**
-     * Find the correct port for the current workspace
-     */
-    findPortForWorkspace() {
-        try {
-            const portInfoPath = path.join(os.tmpdir(), 'snow-cli-ports.json');
-            if (fs.existsSync(portInfoPath)) {
-                const portInfo = JSON.parse(fs.readFileSync(portInfoPath, 'utf8'));
-                // Normalize cwd for consistent comparison
-                const cwd = this.normalizePath(this.currentWorkingDirectory);
-                // Direct match
-                if (portInfo[cwd]) {
-                    return portInfo[cwd];
-                }
-                // Check if cwd is within any of the workspace folders
-                for (const [workspace, port] of Object.entries(portInfo)) {
-                    const normalizedWorkspace = this.normalizePath(workspace);
-                    if (cwd.startsWith(normalizedWorkspace)) {
-                        return port;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Ignore errors, will fall back to VSCODE_BASE_PORT
-        }
-        // Start with VSCode port range by default
-        return this.VSCODE_BASE_PORT;
-    }
-    /**
-     * Check if we should handle this message based on workspace folder
-     */
-    shouldHandleMessage(data) {
-        // If no workspace folder in message, accept it (backwards compatibility)
-        if (!data.workspaceFolder) {
-            return true;
-        }
-        // Normalize paths for consistent comparison across platforms
-        const cwd = this.normalizePath(this.currentWorkingDirectory);
-        const workspaceFolder = this.normalizePath(data.workspaceFolder);
-        // Bidirectional check: either cwd is within IDE workspace, or IDE workspace is within cwd
-        const cwdInWorkspace = cwd.startsWith(workspaceFolder);
-        const workspaceInCwd = workspaceFolder.startsWith(cwd);
-        const matches = cwdInWorkspace || workspaceInCwd;
-        return matches;
-    }
-    scheduleReconnect() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-        }
-        this.reconnectAttempts++;
-        if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
-            return;
-        }
-        const delay = Math.min(this.BASE_RECONNECT_DELAY * Math.pow(1.5, this.reconnectAttempts - 1), this.MAX_RECONNECT_DELAY);
-        this.reconnectTimer = setTimeout(() => {
-            this.start().catch(() => {
-                // Silently handle reconnection failures
-            });
-        }, delay);
-    }
-    stop() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        // Clear connection timeout
-        if (this.connectionTimeout) {
-            clearTimeout(this.connectionTimeout);
-            this.connectionTimeout = null;
-        }
-        // Clear connecting promise - this is critical for restart
-        this.connectingPromise = null;
-        if (this.client) {
-            try {
-                this.client.removeAllListeners();
-                this.client.close();
-            }
-            catch (error) {
-                // Ignore errors during cleanup
-            }
-            this.client = null;
-        }
-        this.reconnectAttempts = 0;
-    }
-    isConnected() {
-        return this.client?.readyState === WebSocket.OPEN;
-    }
-    isClientRunning() {
-        return this.client !== null;
-    }
-    getContext() {
-        return { ...this.editorContext };
-    }
-    onContextUpdate(listener) {
-        this.listeners.push(listener);
-        return () => {
-            this.listeners = this.listeners.filter(l => l !== listener);
-        };
-    }
-    handleMessage(data) {
-        if (data.type === 'context') {
-            this.editorContext = {
-                activeFile: data.activeFile,
-                selectedText: data.selectedText,
-                cursorPosition: data.cursorPosition,
-                workspaceFolder: data.workspaceFolder,
-            };
-            this.notifyListeners();
-        }
-    }
-    notifyListeners() {
-        for (const listener of this.listeners) {
-            listener(this.editorContext);
-        }
-    }
-    getPort() {
-        return this.port;
-    }
-    /**
-     * Request diagnostics for a specific file from IDE
-     * @param filePath - The file path to get diagnostics for
-     * @returns Promise that resolves with diagnostics array
-     */
-    async requestDiagnostics(filePath) {
-        return new Promise(resolve => {
-            if (!this.client || this.client.readyState !== WebSocket.OPEN) {
-                resolve([]); // Return empty array if not connected
-                return;
-            }
-            const requestId = Math.random().toString(36).substring(7);
-            let isResolved = false;
-            const timeout = setTimeout(() => {
-                if (!isResolved) {
-                    cleanup();
-                    resolve([]); // Timeout, return empty array
-                }
-            }, 2000); // Reduce timeout from 5s to 2s to avoid long blocking
-            const handler = (message) => {
-                try {
-                    const data = JSON.parse(message.toString());
-                    if (data.type === 'diagnostics' && data.requestId === requestId) {
-                        if (!isResolved) {
-                            cleanup();
-                            resolve(data.diagnostics || []);
-                        }
-                    }
-                }
-                catch (error) {
-                    // Ignore invalid JSON
-                }
-            };
-            const cleanup = () => {
-                isResolved = true;
-                clearTimeout(timeout);
-                if (this.client) {
-                    this.client.off('message', handler);
-                }
-            };
-            this.client.on('message', handler);
-            // Add error handling for send operation
-            try {
-                this.client.send(JSON.stringify({
-                    type: 'getDiagnostics',
-                    requestId,
-                    filePath,
-                }));
-            }
-            catch (error) {
-                cleanup();
-                resolve([]); // If send fails, return empty array
-            }
-        });
-    }
-    /**
-     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
-     */
-    resetReconnectAttempts() {
-        this.reconnectAttempts = 0;
-    }
-}
-export const vscodeConnection = new VSCodeConnectionManager();

package/dist/utils/workspaceSnapshot.d.ts

@@ -1,63 +0,0 @@
-/**
- * Workspace Snapshot Manager
- * Provides git-like version control for workspace files
- */
-declare class WorkspaceSnapshotManager {
-    private readonly snapshotsDir;
-    private activeSnapshot;
-    private readonly ignorePatterns;
-    constructor();
-    /**
-     * Ensure snapshots directory exists
-     */
-    private ensureSnapshotsDir;
-    /**
-     * Calculate SHA256 hash of file content
-     */
-    private calculateFileHash;
-    /**
-     * Recursively scan directory and collect files
-     */
-    private scanDirectory;
-    /**
-     * Scan workspace and build file state map
-     */
-    private scanWorkspace;
-    /**
-     * Create a snapshot of current workspace state
-     */
-    createSnapshot(sessionId: string, messageCount: number, workspaceRoot?: string): Promise<void>;
-    /**
-     * Get snapshot metadata path
-     */
-    private getSnapshotPath;
-    /**
-     * Get snapshot content directory
-     */
-    private getSnapshotContentDir;
-    /**
-     * Create snapshot when user sends message
-     */
-    createSnapshotForMessage(sessionId: string, messageIndex: number, workspaceRoot?: string): Promise<void>;
-    /**
-     * List all snapshots for a session
-     */
-    listSnapshots(sessionId: string): Promise<Array<{
-        messageIndex: number;
-        timestamp: number;
-    }>>;
-    /**
-     * Rollback workspace to specific snapshot
-     */
-    rollbackToSnapshot(sessionId: string, messageIndex: number): Promise<number | null>;
-    /**
-     * Clear snapshot for a session
-     */
-    clearSnapshot(sessionId: string): Promise<void>;
-    /**
-     * Clear all snapshots for a session
-     */
-    clearAllSnapshots(sessionId: string): Promise<void>;
-}
-export declare const workspaceSnapshotManager: WorkspaceSnapshotManager;
-export {};