@lasso-ai/cli 1.3.2 → 1.3.3

package/dist/cli/snapshot.d.ts

@@ -0,0 +1,33 @@
+export type FileSnapshot = {
+    filePath: string;
+    content: string | null;
+    hash: string;
+    timestamp: string;
+};
+export type TimelineSnapshot = {
+    id: string;
+    taskId: string;
+    summary: string;
+    files: FileSnapshot[];
+    createdAt: string;
+    parentSnapshotId?: string;
+};
+export type ConflictInfo = {
+    filePath: string;
+    expectedHash: string;
+    actualHash: string;
+    originalContent: string;
+    currentContent: string;
+};
+export declare function createSnapshot(cwd: string, taskId: string, summary: string, filePaths: string[], parentSnapshotId?: string): TimelineSnapshot;
+export declare function restoreSnapshot(cwd: string, snapshotId: string): boolean;
+export declare function detectConflicts(cwd: string, expectedFiles: Array<{
+    filePath: string;
+    content: string | null;
+    hash?: string;
+}>): ConflictInfo[];
+export declare function getTimeline(cwd: string, limit?: number): TimelineSnapshot[];
+export declare function deleteSnapshot(cwd: string, snapshotId: string): boolean;
+export declare function clearSnapshots(cwd: string): void;
+export declare function getSnapshotByTaskId(cwd: string, taskId: string): TimelineSnapshot | undefined;
+export declare function getLatestSnapshot(cwd: string): TimelineSnapshot | undefined;

package/dist/cli/snapshot.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSnapshot = createSnapshot;
+exports.restoreSnapshot = restoreSnapshot;
+exports.detectConflicts = detectConflicts;
+exports.getTimeline = getTimeline;
+exports.deleteSnapshot = deleteSnapshot;
+exports.clearSnapshots = clearSnapshots;
+exports.getSnapshotByTaskId = getSnapshotByTaskId;
+exports.getLatestSnapshot = getLatestSnapshot;
+// src/cli/snapshot.ts
+// Local history snapshot system for safe concurrent edits
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const SNAPSHOTS_DIR = ".lasso/snapshots";
+const TIMELINE_FILE = ".lasso/timeline.json";
+const MAX_SNAPSHOTS = 50;
+// Ensure snapshots directory exists
+function ensureSnapshotsDir(cwd) {
+    const dir = node_path_1.default.join(cwd, SNAPSHOTS_DIR);
+    if (!node_fs_1.default.existsSync(dir)) {
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+// Generate content hash
+function hashContent(content) {
+    return node_crypto_1.default.createHash("sha256").update(content).digest("hex");
+}
+// Generate unique snapshot ID
+function generateSnapshotId() {
+    return `snap-${Date.now()}-${node_crypto_1.default.randomBytes(4).toString("hex")}`;
+}
+// Load timeline from disk
+function loadTimeline(cwd) {
+    const timelinePath = node_path_1.default.join(cwd, TIMELINE_FILE);
+    try {
+        if (node_fs_1.default.existsSync(timelinePath)) {
+            const data = node_fs_1.default.readFileSync(timelinePath, "utf8");
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // File might be corrupted, start fresh
+    }
+    return [];
+}
+// Save timeline to disk
+function saveTimeline(cwd, timeline) {
+    const timelinePath = node_path_1.default.join(cwd, TIMELINE_FILE);
+    try {
+        node_fs_1.default.writeFileSync(timelinePath, JSON.stringify(timeline, null, 2));
+    }
+    catch (error) {
+        console.warn("[lasso] Failed to save timeline:", error);
+    }
+}
+// Create a snapshot of current file states
+function createSnapshot(cwd, taskId, summary, filePaths, parentSnapshotId) {
+    ensureSnapshotsDir(cwd);
+    const snapshotId = generateSnapshotId();
+    const files = [];
+    const timestamp = new Date().toISOString();
+    for (const filePath of filePaths) {
+        const fullPath = node_path_1.default.resolve(cwd, filePath);
+        let content = null;
+        let hash = "";
+        try {
+            if (node_fs_1.default.existsSync(fullPath)) {
+                content = node_fs_1.default.readFileSync(fullPath, "utf8");
+                hash = hashContent(content);
+            }
+        }
+        catch (error) {
+            console.warn(`[lasso] Failed to snapshot ${filePath}:`, error);
+        }
+        files.push({
+            filePath,
+            content,
+            hash,
+            timestamp,
+        });
+    }
+    const snapshot = {
+        id: snapshotId,
+        taskId,
+        summary,
+        files,
+        createdAt: timestamp,
+        parentSnapshotId,
+    };
+    // Update timeline
+    const timeline = loadTimeline(cwd);
+    timeline.unshift(snapshot);
+    // Trim old snapshots
+    if (timeline.length > MAX_SNAPSHOTS) {
+        const removed = timeline.splice(MAX_SNAPSHOTS);
+        // Cleanup old snapshot files
+        for (const old of removed) {
+            cleanupSnapshotFiles(cwd, old.id);
+        }
+    }
+    saveTimeline(cwd, timeline);
+    return snapshot;
+}
+// Restore a snapshot
+function restoreSnapshot(cwd, snapshotId) {
+    const timeline = loadTimeline(cwd);
+    const snapshot = timeline.find((s) => s.id === snapshotId);
+    if (!snapshot) {
+        console.warn(`[lasso] Snapshot ${snapshotId} not found`);
+        return false;
+    }
+    try {
+        for (const file of snapshot.files) {
+            const fullPath = node_path_1.default.resolve(cwd, file.filePath);
+            if (file.content === null) {
+                // File didn't exist, delete if it exists now
+                if (node_fs_1.default.existsSync(fullPath)) {
+                    node_fs_1.default.unlinkSync(fullPath);
+                }
+            }
+            else {
+                // Restore file content
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+                node_fs_1.default.writeFileSync(fullPath, file.content);
+            }
+        }
+        console.log(`[lasso] Restored snapshot ${snapshotId}: ${snapshot.summary}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[lasso] Failed to restore snapshot ${snapshotId}:`, error);
+        return false;
+    }
+}
+// Check for conflicts between expected and current file states
+function detectConflicts(cwd, expectedFiles) {
+    const conflicts = [];
+    for (const expected of expectedFiles) {
+        const fullPath = node_path_1.default.resolve(cwd, expected.filePath);
+        const expectedHash = expected.hash || (expected.content ? hashContent(expected.content) : "");
+        try {
+            if (!node_fs_1.default.existsSync(fullPath)) {
+                // File doesn't exist but was expected
+                if (expected.content !== null) {
+                    conflicts.push({
+                        filePath: expected.filePath,
+                        expectedHash,
+                        actualHash: "file-missing",
+                        originalContent: expected.content || "",
+                        currentContent: "",
+                    });
+                }
+                continue;
+            }
+            const currentContent = node_fs_1.default.readFileSync(fullPath, "utf8");
+            const actualHash = hashContent(currentContent);
+            if (expectedHash !== actualHash) {
+                conflicts.push({
+                    filePath: expected.filePath,
+                    expectedHash,
+                    actualHash,
+                    originalContent: expected.content || "",
+                    currentContent,
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`[lasso] Failed to check conflict for ${expected.filePath}:`, error);
+        }
+    }
+    return conflicts;
+}
+// Get timeline history
+function getTimeline(cwd, limit = 20) {
+    const timeline = loadTimeline(cwd);
+    return timeline.slice(0, limit);
+}
+// Delete a snapshot
+function deleteSnapshot(cwd, snapshotId) {
+    const timeline = loadTimeline(cwd);
+    const index = timeline.findIndex((s) => s.id === snapshotId);
+    if (index === -1) {
+        return false;
+    }
+    timeline.splice(index, 1);
+    saveTimeline(cwd, timeline);
+    cleanupSnapshotFiles(cwd, snapshotId);
+    return true;
+}
+// Cleanup snapshot-specific files (if we implement per-snapshot storage)
+function cleanupSnapshotFiles(cwd, snapshotId) {
+    // Currently all data is in timeline.json, but if we add per-snapshot files,
+    // this is where we'd clean them up
+}
+// Clear all snapshots
+function clearSnapshots(cwd) {
+    const timelinePath = node_path_1.default.join(cwd, TIMELINE_FILE);
+    try {
+        if (node_fs_1.default.existsSync(timelinePath)) {
+            node_fs_1.default.unlinkSync(timelinePath);
+        }
+        const snapshotsDir = node_path_1.default.join(cwd, SNAPSHOTS_DIR);
+        if (node_fs_1.default.existsSync(snapshotsDir)) {
+            node_fs_1.default.rmSync(snapshotsDir, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        console.warn("[lasso] Failed to clear snapshots:", error);
+    }
+}
+// Get snapshot by task ID
+function getSnapshotByTaskId(cwd, taskId) {
+    const timeline = loadTimeline(cwd);
+    return timeline.find((s) => s.taskId === taskId);
+}
+// Get latest snapshot
+function getLatestSnapshot(cwd) {
+    const timeline = loadTimeline(cwd);
+    return timeline[0];
+}