snow-ai 0.4.15 → 0.4.17

package/dist/utils/incrementalSnapshot.js

@@ -1,383 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { logger } from '../utils/logger.js';
-/**
- * Incremental Snapshot Manager
- * Only backs up files that are actually modified by tools
- */
-class IncrementalSnapshotManager {
-    constructor() {
-        Object.defineProperty(this, "snapshotsDir", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "activeSnapshot", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        this.snapshotsDir = path.join(os.homedir(), '.snow', 'snapshots');
-    }
-    /**
-     * Ensure snapshots directory exists
-     */
-    async ensureSnapshotsDir() {
-        await fs.mkdir(this.snapshotsDir, { recursive: true });
-    }
-    /**
-     * Get snapshot file path
-     */
-    getSnapshotPath(sessionId, messageIndex) {
-        return path.join(this.snapshotsDir, `${sessionId}_${messageIndex}.json`);
-    }
-    /**
-     * Create a new snapshot for a message
-     */
-    async createSnapshot(sessionId, messageIndex) {
-        this.activeSnapshot = {
-            sessionId,
-            messageIndex,
-            timestamp: Date.now(),
-            backups: []
-        };
-    }
-    /**
-     * Backup a file before modification
-     * Call this BEFORE modifying the file
-     */
-    async backupFile(filePath) {
-        if (!this.activeSnapshot) {
-            // No active snapshot, skip
-            return;
-        }
-        // Check if already backed up
-        if (this.activeSnapshot.backups.some(b => b.path === filePath)) {
-            return;
-        }
-        try {
-            // Try to read existing file
-            const content = await fs.readFile(filePath, 'utf-8');
-            this.activeSnapshot.backups.push({
-                path: filePath,
-                content,
-                existed: true
-            });
-        }
-        catch (error) {
-            // File doesn't exist, record as non-existent
-            this.activeSnapshot.backups.push({
-                path: filePath,
-                content: null,
-                existed: false
-            });
-        }
-        // Save snapshot to disk
-        await this.saveSnapshot();
-    }
-    /**
-     * Save current snapshot to disk
-     */
-    async saveSnapshot() {
-        if (!this.activeSnapshot) {
-            return;
-        }
-        await this.ensureSnapshotsDir();
-        const snapshotPath = this.getSnapshotPath(this.activeSnapshot.sessionId, this.activeSnapshot.messageIndex);
-        await fs.writeFile(snapshotPath, JSON.stringify(this.activeSnapshot, null, 2));
-    }
-    /**
-     * Commit snapshot (called after message completes successfully)
-     */
-    async commitSnapshot() {
-        // Keep the snapshot for future rollback
-        this.activeSnapshot = null;
-    }
-    /**
-     * List all snapshots for a session
-     */
-    async listSnapshots(sessionId) {
-        await this.ensureSnapshotsDir();
-        const snapshots = [];
-        try {
-            const files = await fs.readdir(this.snapshotsDir);
-            for (const file of files) {
-                if (file.startsWith(sessionId) && file.endsWith('.json')) {
-                    const snapshotPath = path.join(this.snapshotsDir, file);
-                    const content = await fs.readFile(snapshotPath, 'utf-8');
-                    const metadata = JSON.parse(content);
-                    snapshots.push({
-                        messageIndex: metadata.messageIndex,
-                        timestamp: metadata.timestamp,
-                        fileCount: metadata.backups.length
-                    });
-                }
-            }
-        }
-        catch (error) {
-            logger.error('Failed to list snapshots:', error);
-        }
-        return snapshots.sort((a, b) => b.messageIndex - a.messageIndex);
-    }
-    /**
-     * Rollback to a specific snapshot
-     */
-    async rollbackToSnapshot(sessionId, messageIndex) {
-        const snapshotPath = this.getSnapshotPath(sessionId, messageIndex);
-        try {
-            const content = await fs.readFile(snapshotPath, 'utf-8');
-            const snapshot = JSON.parse(content);
-            // Restore all backed up files
-            for (const backup of snapshot.backups) {
-                try {
-                    if (backup.existed && backup.content !== null) {
-                        // Restore original file content
-                        await fs.writeFile(backup.path, backup.content, 'utf-8');
-                    }
-                    else if (!backup.existed) {
-                        // Delete file that was created
-                        try {
-                            await fs.unlink(backup.path);
-                        }
-                        catch (error) {
-                            // File may not exist, ignore
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`Failed to restore file ${backup.path}:`, error);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to rollback snapshot:', error);
-            return false;
-        }
-    }
-    /**
-     * Get list of files that will be affected by rollback to a specific message index
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to rollback to (inclusive)
-     * @returns Array of file paths that will be rolled back
-     */
-    async getFilesToRollback(sessionId, targetMessageIndex) {
-        await this.ensureSnapshotsDir();
-        try {
-            const files = await fs.readdir(this.snapshotsDir);
-            const filesToRollback = new Set();
-            // Load all snapshots for this session
-            for (const file of files) {
-                if (file.startsWith(sessionId) && file.endsWith('.json')) {
-                    const snapshotPath = path.join(this.snapshotsDir, file);
-                    const content = await fs.readFile(snapshotPath, 'utf-8');
-                    const metadata = JSON.parse(content);
-                    // Include files from snapshots >= targetMessageIndex
-                    if (metadata.messageIndex >= targetMessageIndex) {
-                        for (const backup of metadata.backups) {
-                            // Convert to relative path for better display
-                            const relativePath = path.relative(process.cwd(), backup.path);
-                            filesToRollback.add(relativePath || backup.path);
-                        }
-                    }
-                }
-            }
-            return Array.from(filesToRollback).sort();
-        }
-        catch (error) {
-            console.error('Failed to get files to rollback:', error);
-            return [];
-        }
-    }
-    /**
-     * Rollback all snapshots after a specific message index
-     * This is used when user selects to rollback to a specific message
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to rollback to (inclusive)
-     * @returns Number of files rolled back
-     */
-    async rollbackToMessageIndex(sessionId, targetMessageIndex) {
-        await this.ensureSnapshotsDir();
-        try {
-            const files = await fs.readdir(this.snapshotsDir);
-            const snapshots = [];
-            // Load all snapshots for this session
-            for (const file of files) {
-                if (file.startsWith(sessionId) && file.endsWith('.json')) {
-                    const snapshotPath = path.join(this.snapshotsDir, file);
-                    const content = await fs.readFile(snapshotPath, 'utf-8');
-                    const metadata = JSON.parse(content);
-                    snapshots.push({
-                        messageIndex: metadata.messageIndex,
-                        path: snapshotPath,
-                        metadata
-                    });
-                }
-            }
-            // Filter snapshots that are >= targetMessageIndex and sort in descending order
-            // We rollback from newest to oldest to ensure correct restoration
-            const snapshotsToRollback = snapshots
-                .filter(s => s.messageIndex >= targetMessageIndex)
-                .sort((a, b) => b.messageIndex - a.messageIndex);
-            let totalFilesRolledBack = 0;
-            // Rollback each snapshot in reverse chronological order
-            for (const snapshot of snapshotsToRollback) {
-                for (const backup of snapshot.metadata.backups) {
-                    try {
-                        if (backup.existed && backup.content !== null) {
-                            // Restore original file content
-                            await fs.writeFile(backup.path, backup.content, 'utf-8');
-                            totalFilesRolledBack++;
-                        }
-                        else if (!backup.existed) {
-                            // Delete file that was created
-                            try {
-                                await fs.unlink(backup.path);
-                                totalFilesRolledBack++;
-                            }
-                            catch (error) {
-                                // File may not exist, ignore
-                            }
-                        }
-                    }
-                    catch (error) {
-                        console.error(`Failed to restore file ${backup.path}:`, error);
-                    }
-                }
-            }
-            return totalFilesRolledBack;
-        }
-        catch (error) {
-            console.error('Failed to rollback to message index:', error);
-            return 0;
-        }
-    }
-    /**
-     * Delete all snapshots >= targetMessageIndex
-     * This is used when user rolls back conversation to clean up snapshot files
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to delete from (inclusive)
-     */
-    async deleteSnapshotsFromIndex(sessionId, targetMessageIndex) {
-        await this.ensureSnapshotsDir();
-        try {
-            const files = await fs.readdir(this.snapshotsDir);
-            let deletedCount = 0;
-            for (const file of files) {
-                if (file.startsWith(sessionId) && file.endsWith('.json')) {
-                    const snapshotPath = path.join(this.snapshotsDir, file);
-                    const content = await fs.readFile(snapshotPath, 'utf-8');
-                    const metadata = JSON.parse(content);
-                    // Delete snapshots with messageIndex >= targetMessageIndex
-                    if (metadata.messageIndex >= targetMessageIndex) {
-                        try {
-                            await fs.unlink(snapshotPath);
-                            deletedCount++;
-                        }
-                        catch (error) {
-                            console.error(`Failed to delete snapshot file ${snapshotPath}:`, error);
-                        }
-                    }
-                }
-            }
-            return deletedCount;
-        }
-        catch (error) {
-            console.error('Failed to delete snapshots from index:', error);
-            return 0;
-        }
-    }
-    /**
-     * Clear all snapshots for a session
-     */
-    async clearAllSnapshots(sessionId) {
-        await this.ensureSnapshotsDir();
-        try {
-            const files = await fs.readdir(this.snapshotsDir);
-            for (const file of files) {
-                if (file.startsWith(sessionId) && file.endsWith('.json')) {
-                    const filePath = path.join(this.snapshotsDir, file);
-                    await fs.unlink(filePath);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to clear snapshots:', error);
-        }
-    }
-    /**
-     * Get active snapshot
-     */
-    getActiveSnapshot() {
-        return this.activeSnapshot;
-    }
-    /**
-     * Capture workspace state before terminal command
-     */
-    async captureWorkspaceState(workspaceRoot = process.cwd()) {
-        const fileStates = new Map();
-        const scanDir = async (dirPath) => {
-            try {
-                const entries = await fs.readdir(dirPath, { withFileTypes: true });
-                for (const entry of entries) {
-                    // Skip ignored directories
-                    if (entry.isDirectory()) {
-                        const dirName = entry.name;
-                        if (dirName === 'node_modules' || dirName === '.git' || dirName === 'dist' ||
-                            dirName === 'build' || dirName === '.snow' || dirName.startsWith('.')) {
-                            continue;
-                        }
-                        await scanDir(path.join(dirPath, entry.name));
-                    }
-                    else if (entry.isFile()) {
-                        const fullPath = path.join(dirPath, entry.name);
-                        try {
-                            const stats = await fs.stat(fullPath);
-                            fileStates.set(fullPath, {
-                                mtime: stats.mtimeMs,
-                                size: stats.size
-                            });
-                        }
-                        catch (error) {
-                            // Skip files that can't be read
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                // Skip directories that can't be accessed
-            }
-        };
-        await scanDir(workspaceRoot);
-        return fileStates;
-    }
-    /**
-     * Detect and backup changed files after terminal command
-     */
-    async backupChangedFiles(beforeState, workspaceRoot = process.cwd()) {
-        const afterState = await this.captureWorkspaceState(workspaceRoot);
-        // Find modified and new files
-        for (const [filePath, afterStats] of afterState) {
-            const beforeStats = beforeState.get(filePath);
-            if (!beforeStats) {
-                // New file created - backup as non-existent
-                await this.backupFile(filePath);
-            }
-            else if (beforeStats.mtime !== afterStats.mtime || beforeStats.size !== afterStats.size) {
-                // File modified - backup original (if not already backed up)
-                await this.backupFile(filePath);
-            }
-        }
-        // Find deleted files
-        for (const [filePath] of beforeState) {
-            if (!afterState.has(filePath)) {
-                // File deleted - backup original content
-                await this.backupFile(filePath);
-            }
-        }
-    }
-}
-export const incrementalSnapshotManager = new IncrementalSnapshotManager();

package/dist/utils/index.d.ts

@@ -1,11 +0,0 @@
-import { Command } from '../types/index.js';
-import './commands/clear.js';
-import './commands/resume.js';
-export { Logger, LogLevel, logger } from './logger.js';
-export { default as defaultLogger } from './logger.js';
-export declare function formatCommand(command: Command): string;
-export declare function parseInput(input: string): {
-    command: string;
-    args: string[];
-};
-export declare function sanitizeInput(input: string): string;

package/dist/utils/index.js

@@ -1,18 +0,0 @@
-// Import commands to register them
-import './commands/clear.js';
-import './commands/resume.js';
-// Export logger
-export { Logger, LogLevel, logger } from './logger.js';
-export { default as defaultLogger } from './logger.js';
-export function formatCommand(command) {
-    return `${command.name.padEnd(12)} ${command.description}`;
-}
-export function parseInput(input) {
-    const parts = input.trim().split(' ');
-    const command = parts[0] || '';
-    const args = parts.slice(1);
-    return { command, args };
-}
-export function sanitizeInput(input) {
-    return input.trim().replace(/[<>]/g, '');
-}

package/dist/utils/languageConfig.d.ts

@@ -1,21 +0,0 @@
-export type Language = 'en' | 'zh' | 'zh-TW' | 'ja' | 'ko' | 'es';
-interface LanguageConfig {
-    language: Language;
-}
-/**
- * Load language configuration from file system
- */
-export declare function loadLanguageConfig(): LanguageConfig;
-/**
- * Save language configuration to file system
- */
-export declare function saveLanguageConfig(config: LanguageConfig): void;
-/**
- * Get current language setting
- */
-export declare function getCurrentLanguage(): Language;
-/**
- * Set language and persist to file system
- */
-export declare function setCurrentLanguage(language: Language): void;
-export {};

package/dist/utils/languageConfig.js

@@ -1,61 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-const CONFIG_DIR = join(homedir(), '.snow');
-const LANGUAGE_CONFIG_FILE = join(CONFIG_DIR, 'language.json');
-const DEFAULT_CONFIG = {
-    language: 'en',
-};
-function ensureConfigDirectory() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-}
-/**
- * Load language configuration from file system
- */
-export function loadLanguageConfig() {
-    ensureConfigDirectory();
-    if (!existsSync(LANGUAGE_CONFIG_FILE)) {
-        saveLanguageConfig(DEFAULT_CONFIG);
-        return DEFAULT_CONFIG;
-    }
-    try {
-        const configData = readFileSync(LANGUAGE_CONFIG_FILE, 'utf-8');
-        const config = JSON.parse(configData);
-        return {
-            ...DEFAULT_CONFIG,
-            ...config,
-        };
-    }
-    catch (error) {
-        // If config file is corrupted, return default config
-        return DEFAULT_CONFIG;
-    }
-}
-/**
- * Save language configuration to file system
- */
-export function saveLanguageConfig(config) {
-    ensureConfigDirectory();
-    try {
-        const configData = JSON.stringify(config, null, 2);
-        writeFileSync(LANGUAGE_CONFIG_FILE, configData, 'utf-8');
-    }
-    catch (error) {
-        console.error('Failed to save language config:', error);
-    }
-}
-/**
- * Get current language setting
- */
-export function getCurrentLanguage() {
-    const config = loadLanguageConfig();
-    return config.language;
-}
-/**
- * Set language and persist to file system
- */
-export function setCurrentLanguage(language) {
-    saveLanguageConfig({ language });
-}

package/dist/utils/logger.d.ts

@@ -1,37 +0,0 @@
-export declare enum LogLevel {
-    ERROR = 0,
-    WARN = 1,
-    INFO = 2,
-    DEBUG = 3
-}
-export interface LoggerConfig {
-    logDir?: string;
-    maxFileSize?: number;
-    dateFormat?: string;
-}
-export declare class Logger {
-    private readonly logDir;
-    private readonly maxFileSize;
-    constructor(config?: LoggerConfig);
-    private ensureLogDirectory;
-    private formatDate;
-    private formatTimestamp;
-    private getLogFilePath;
-    private shouldRotateLog;
-    private rotateLog;
-    private writeLog;
-    error(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    debug(message: string, meta?: any): void;
-    log(level: LogLevel, message: string, meta?: any): void;
-}
-declare const logger: {
-    error(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    debug(message: string, meta?: any): void;
-    log(level: LogLevel, message: string, meta?: any): void;
-};
-export default logger;
-export { logger };

package/dist/utils/logger.js

@@ -1,122 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { homedir } from 'node:os';
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 1] = "WARN";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
-})(LogLevel || (LogLevel = {}));
-export class Logger {
-    constructor(config = {}) {
-        Object.defineProperty(this, "logDir", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maxFileSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.logDir = config.logDir || path.join(homedir(), '.snow', 'log');
-        this.maxFileSize = config.maxFileSize || 10 * 1024 * 1024; // 10MB
-        this.ensureLogDirectory();
-    }
-    ensureLogDirectory() {
-        if (!fs.existsSync(this.logDir)) {
-            fs.mkdirSync(this.logDir, { recursive: true });
-        }
-    }
-    formatDate(date) {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const day = String(date.getDate()).padStart(2, '0');
-        return `${year}-${month}-${day}`;
-    }
-    formatTimestamp(date) {
-        return date.toISOString();
-    }
-    getLogFilePath(level) {
-        const dateString = this.formatDate(new Date());
-        const levelName = LogLevel[level].toLowerCase();
-        return path.join(this.logDir, `${dateString}-${levelName}.log`);
-    }
-    shouldRotateLog(filePath) {
-        if (!fs.existsSync(filePath)) {
-            return false;
-        }
-        const stats = fs.statSync(filePath);
-        return stats.size >= this.maxFileSize;
-    }
-    rotateLog(filePath) {
-        const timestamp = Date.now();
-        const ext = path.extname(filePath);
-        const basename = path.basename(filePath, ext);
-        const dirname = path.dirname(filePath);
-        const rotatedPath = path.join(dirname, `${basename}-${timestamp}${ext}`);
-        fs.renameSync(filePath, rotatedPath);
-    }
-    writeLog(level, message, meta) {
-        const timestamp = this.formatTimestamp(new Date());
-        const levelName = LogLevel[level].toUpperCase().padEnd(5);
-        const logEntry = {
-            timestamp,
-            level: levelName.trim(),
-            message,
-            ...(meta && { meta }),
-        };
-        const logLine = JSON.stringify(logEntry) + '\n';
-        const filePath = this.getLogFilePath(level);
-        if (this.shouldRotateLog(filePath)) {
-            this.rotateLog(filePath);
-        }
-        fs.appendFileSync(filePath, logLine, 'utf8');
-    }
-    error(message, meta) {
-        this.writeLog(LogLevel.ERROR, message, meta);
-    }
-    warn(message, meta) {
-        this.writeLog(LogLevel.WARN, message, meta);
-    }
-    info(message, meta) {
-        this.writeLog(LogLevel.INFO, message, meta);
-    }
-    debug(message, meta) {
-        this.writeLog(LogLevel.DEBUG, message, meta);
-    }
-    log(level, message, meta) {
-        this.writeLog(level, message, meta);
-    }
-}
-// Lazy initialization to avoid blocking startup
-let _defaultLogger = null;
-function getDefaultLogger() {
-    if (!_defaultLogger) {
-        _defaultLogger = new Logger();
-    }
-    return _defaultLogger;
-}
-// Create a proxy object that lazily initializes the logger
-const logger = {
-    error(message, meta) {
-        getDefaultLogger().error(message, meta);
-    },
-    warn(message, meta) {
-        getDefaultLogger().warn(message, meta);
-    },
-    info(message, meta) {
-        getDefaultLogger().info(message, meta);
-    },
-    debug(message, meta) {
-        getDefaultLogger().debug(message, meta);
-    },
-    log(level, message, meta) {
-        getDefaultLogger().log(level, message, meta);
-    },
-};
-export default logger;
-export { logger };