snow-ai 0.2.5 → 0.2.7

package/dist/utils/workspaceSnapshot.js

@@ -0,0 +1,299 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+/**
+ * Workspace Snapshot Manager
+ * Provides git-like version control for workspace files
+ */
+class WorkspaceSnapshotManager {
+    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
+        });
+        Object.defineProperty(this, "ignorePatterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                'node_modules/**',
+                '.git/**',
+                'dist/**',
+                'build/**',
+                '.snow/**',
+                '*.log',
+                '.DS_Store',
+                '*.swp',
+                '*.swo',
+                '*~',
+                '.vscode/**',
+                '.idea/**'
+            ]
+        });
+        this.snapshotsDir = path.join(os.homedir(), '.snow', 'snapshots');
+    }
+    /**
+     * Ensure snapshots directory exists
+     */
+    async ensureSnapshotsDir() {
+        await fs.mkdir(this.snapshotsDir, { recursive: true });
+    }
+    /**
+     * Calculate SHA256 hash of file content
+     */
+    async calculateFileHash(filePath) {
+        const content = await fs.readFile(filePath);
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Recursively scan directory and collect files
+     */
+    async scanDirectory(dirPath, basePath, fileStates) {
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                // Skip ignored patterns
+                if (this.ignorePatterns.some(pattern => {
+                    const normalized = pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
+                    return entry.name.match(new RegExp(normalized));
+                })) {
+                    continue;
+                }
+                const fullPath = path.join(dirPath, entry.name);
+                const relativePath = path.relative(basePath, fullPath);
+                if (entry.isDirectory()) {
+                    // Recursively scan subdirectory
+                    await this.scanDirectory(fullPath, basePath, fileStates);
+                }
+                else if (entry.isFile()) {
+                    try {
+                        const stats = await fs.stat(fullPath);
+                        const hash = await this.calculateFileHash(fullPath);
+                        fileStates.set(relativePath, {
+                            path: relativePath,
+                            hash,
+                            size: stats.size,
+                            mtime: stats.mtimeMs
+                        });
+                    }
+                    catch (error) {
+                        // Skip files that can't be read
+                        console.error(`Failed to process file ${relativePath}:`, error);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to scan directory ${dirPath}:`, error);
+        }
+    }
+    /**
+     * Scan workspace and build file state map
+     */
+    async scanWorkspace(workspaceRoot) {
+        const fileStates = new Map();
+        await this.scanDirectory(workspaceRoot, workspaceRoot, fileStates);
+        return fileStates;
+    }
+    /**
+     * Create a snapshot of current workspace state
+     */
+    async createSnapshot(sessionId, messageCount, workspaceRoot = process.cwd()) {
+        await this.ensureSnapshotsDir();
+        const files = await this.scanWorkspace(workspaceRoot);
+        this.activeSnapshot = {
+            sessionId,
+            messageCount,
+            timestamp: Date.now(),
+            workspaceRoot,
+            files
+        };
+        // Note: We don't save the snapshot to disk yet
+        // We'll only save changed files when rollback is triggered
+    }
+    /**
+     * Get snapshot metadata path
+     */
+    getSnapshotPath(sessionId) {
+        return path.join(this.snapshotsDir, `${sessionId}.json`);
+    }
+    /**
+     * Get snapshot content directory
+     */
+    getSnapshotContentDir(sessionId) {
+        return path.join(this.snapshotsDir, sessionId);
+    }
+    /**
+     * Create snapshot when user sends message
+     */
+    async createSnapshotForMessage(sessionId, messageIndex, workspaceRoot = process.cwd()) {
+        await this.ensureSnapshotsDir();
+        const snapshotContentDir = this.getSnapshotContentDir(`${sessionId}_${messageIndex}`);
+        await fs.mkdir(snapshotContentDir, { recursive: true });
+        // Scan current workspace state
+        const files = await this.scanWorkspace(workspaceRoot);
+        // Save file contents to snapshot directory
+        const fileBackups = [];
+        for (const [relativePath, fileState] of files) {
+            const fullPath = path.join(workspaceRoot, relativePath);
+            const backupPath = path.join(snapshotContentDir, relativePath);
+            try {
+                // Create directory structure
+                await fs.mkdir(path.dirname(backupPath), { recursive: true });
+                // Copy file to snapshot directory
+                await fs.copyFile(fullPath, backupPath);
+                fileBackups.push({
+                    path: relativePath,
+                    hash: fileState.hash
+                });
+            }
+            catch (error) {
+                console.error(`Failed to backup file ${relativePath}:`, error);
+            }
+        }
+        // Save snapshot metadata
+        const metadata = {
+            sessionId: `${sessionId}_${messageIndex}`,
+            messageCount: messageIndex,
+            timestamp: Date.now(),
+            workspaceRoot,
+            changedFiles: fileBackups.map(f => ({
+                path: f.path,
+                content: null, // Content stored separately in snapshot directory
+                existed: true
+            }))
+        };
+        const metadataPath = this.getSnapshotPath(`${sessionId}_${messageIndex}`);
+        await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    /**
+     * 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 metadataPath = path.join(this.snapshotsDir, file);
+                    const content = await fs.readFile(metadataPath, 'utf-8');
+                    const metadata = JSON.parse(content);
+                    snapshots.push({
+                        messageIndex: metadata.messageCount,
+                        timestamp: metadata.timestamp
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to list snapshots:', error);
+        }
+        return snapshots.sort((a, b) => b.messageIndex - a.messageIndex);
+    }
+    /**
+     * Rollback workspace to specific snapshot
+     */
+    async rollbackToSnapshot(sessionId, messageIndex) {
+        const snapshotId = `${sessionId}_${messageIndex}`;
+        const metadataPath = this.getSnapshotPath(snapshotId);
+        const snapshotContentDir = this.getSnapshotContentDir(snapshotId);
+        try {
+            // Load snapshot metadata
+            const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+            const metadata = JSON.parse(metadataContent);
+            // Get current workspace files
+            const currentFiles = await this.scanWorkspace(metadata.workspaceRoot);
+            // Find files that exist now but didn't exist in snapshot
+            // (these should be deleted)
+            const snapshotFilePaths = new Set(metadata.changedFiles.map(f => f.path));
+            for (const [relativePath] of currentFiles) {
+                if (!snapshotFilePaths.has(relativePath)) {
+                    // This file was created after snapshot, delete it
+                    const fullPath = path.join(metadata.workspaceRoot, relativePath);
+                    try {
+                        await fs.unlink(fullPath);
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete new file ${relativePath}:`, error);
+                    }
+                }
+            }
+            // Restore all files from snapshot
+            for (const fileBackup of metadata.changedFiles) {
+                const backupPath = path.join(snapshotContentDir, fileBackup.path);
+                const fullPath = path.join(metadata.workspaceRoot, fileBackup.path);
+                try {
+                    // Restore file from backup
+                    await fs.copyFile(backupPath, fullPath);
+                }
+                catch (error) {
+                    console.error(`Failed to restore file ${fileBackup.path}:`, error);
+                }
+            }
+            // Don't clean up snapshot - keep for future rollbacks
+            return metadata.messageCount;
+        }
+        catch (error) {
+            console.error('Failed to rollback workspace:', error);
+            return null;
+        }
+    }
+    /**
+     * Clear snapshot for a session
+     */
+    async clearSnapshot(sessionId) {
+        const metadataPath = this.getSnapshotPath(sessionId);
+        const snapshotContentDir = this.getSnapshotContentDir(sessionId);
+        try {
+            // Delete metadata
+            await fs.unlink(metadataPath);
+        }
+        catch (error) {
+            // Ignore if doesn't exist
+        }
+        try {
+            // Delete snapshot content directory
+            await fs.rm(snapshotContentDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            // Ignore if doesn't exist
+        }
+        if (this.activeSnapshot?.sessionId === sessionId) {
+            this.activeSnapshot = null;
+        }
+    }
+    /**
+     * 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)) {
+                    const filePath = path.join(this.snapshotsDir, file);
+                    if (file.endsWith('.json')) {
+                        await fs.unlink(filePath);
+                    }
+                    else {
+                        await fs.rm(filePath, { recursive: true, force: true });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to clear snapshots:', error);
+        }
+    }
+}
+export const workspaceSnapshotManager = new WorkspaceSnapshotManager();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.5",
+	"version": "0.2.7",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -63,6 +63,7 @@
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/diff": "^7.0.2",
 		"@types/figlet": "^1.7.0",
+		"@types/glob": "^8.1.0",
 		"@types/react": "^18.0.32",
 		"@types/ws": "^8.5.8",
 		"@vdemedes/prettier-config": "^2.0.1",