@lasso-ai/cli 1.3.2 → 1.3.4

package/dist/cli/oneshot.js

@@ -209,16 +209,13 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
         const isConversational = await isConversationalPrompt(prompt, config, apiKey);
         console.log('[Lasso] Is conversational:', isConversational);
         // Browser inspection & snapshot steps - skip for simple conversational queries
+        // FAST CONTEXT: Skip detailed DOM analysis if pageContext is already provided
         if (pageContext && !isConversational) {
-            onProgress("thinking", "Inspecting browser page...", `Page: "${pageContext.title || "Landing page"}" (${pageContext.route || "/"})`);
+            onProgress("thinking", "Analyzing page context...", `Page: "${pageContext.title || "Landing page"}" (${pageContext.route || "/"})`);
+            // Skip the slow "Scrolling & analyzing" steps - the pageContext already has the data
+            // Only show viewport info if available
             if (pageContext.viewport) {
-                onProgress("thinking", "Capturing visual snapshot...", `Viewport: ${pageContext.viewport.width}x${pageContext.viewport.height} (Document height: ${pageContext.viewport.scrollHeight}px)`);
-            }
-            if (pageContext.domSummary) {
-                const sectionsCount = pageContext.domSummary.sections?.length || 0;
-                const headingsCount = pageContext.domSummary.headings?.length || 0;
-                const buttonsCount = pageContext.domSummary.buttons?.length || 0;
-                onProgress("thinking", "Scrolling & analyzing page sections...", `${sectionsCount} sections, ${headingsCount} headings, ${buttonsCount} CTAs detected`);
+                onProgress("thinking", "Ready to proceed...", `Viewport: ${pageContext.viewport.width}x${pageContext.viewport.height}`);
             }
         }
         else {
@@ -599,47 +596,69 @@ async function analyzeProject(cwd) {
     const hasReact = dependencies.includes("react") || devDependencies.includes("react");
     const hasNext = dependencies.includes("next") || devDependencies.includes("next");
     const hasVite = dependencies.includes("vite") || devDependencies.includes("vite");
-    // Scan directory structure
+    // FAST CONTEXT: Only scan top-level directories, not full recursive scan
+    // This is the key optimization - let the server-side agent handle file discovery
     const files = [];
     const directories = [];
     const appDirs = [];
     const pagesDirs = [];
-    const roots = ["src", "app", "pages", ".", "web", "lib", "components"];
+    const roots = ["src", "app", "pages", "components", "lib"];
     for (const root of roots) {
         const rootPath = node_path_1.default.join(cwd, root);
         if (!node_fs_1.default.existsSync(rootPath))
             continue;
-        const scanDir = (dir, base = "", depth = 0) => {
-            if (depth > 5)
-                return;
-            try {
-                const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".next") {
-                        continue;
-                    }
-                    const rel = base ? node_path_1.default.join(base, entry.name) : entry.name;
-                    if (entry.isDirectory()) {
-                        directories.push(rel);
-                        // Track app and pages directories
-                        if (entry.name === "app")
-                            appDirs.push(rel);
-                        if (entry.name === "pages")
-                            pagesDirs.push(rel);
-                        scanDir(node_path_1.default.join(dir, entry.name), rel, depth + 1);
-                    }
-                    else if (/\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
-                        files.push(rel);
+        // Only scan top-level (depth 0-1), not recursive
+        try {
+            const entries = node_fs_1.default.readdirSync(rootPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                    continue;
+                }
+                const rel = entry.name;
+                if (entry.isDirectory()) {
+                    directories.push(rel);
+                    // Track app and pages directories at top level
+                    if (entry.name === "app")
+                        appDirs.push(rel);
+                    if (entry.name === "pages")
+                        pagesDirs.push(rel);
+                    // Only scan one level deep for key directories
+                    if (["components", "lib", "hooks", "utils", "styles"].includes(entry.name)) {
+                        try {
+                            const subEntries = node_fs_1.default.readdirSync(node_path_1.default.join(rootPath, entry.name), { withFileTypes: true });
+                            for (const subEntry of subEntries) {
+                                if (!subEntry.name.startsWith(".") && !subEntry.isDirectory() && /\.(tsx?|jsx?|vue|svelte|css)$/i.test(subEntry.name)) {
+                                    files.push(node_path_1.default.join(rel, subEntry.name));
+                                }
+                            }
+                        }
+                        catch {
+                            // ignore scan errors
+                        }
                     }
                 }
+                else if (/\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
+                    files.push(rel);
+                }
             }
-            catch {
-                // ignore scan errors
+        }
+        catch {
+            // ignore scan errors
+        }
+        if (files.length > 20)
+            break; // Limit to 20 files for fast context
+    }
+    // Also check root directory for key files
+    try {
+        const rootEntries = node_fs_1.default.readdirSync(cwd, { withFileTypes: true });
+        for (const entry of rootEntries) {
+            if (!entry.isDirectory() && /\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
+                files.push(entry.name);
             }
-        };
-        scanDir(rootPath);
-        if (files.length > 100)
-            break;
+        }
+    }
+    catch {
+        // ignore scan errors
     }
     // Determine source root
     let sourceRoot = ".";
@@ -649,12 +668,9 @@ async function analyzeProject(cwd) {
         sourceRoot = ".";
     else if (directories.includes("src"))
         sourceRoot = "src";
-    // Detect App Router vs Pages Router
-    const appRouter = appDirs.length > 0 && appDirs.some(dir => {
-        const appPath = node_path_1.default.join(cwd, dir);
-        return node_fs_1.default.existsSync(node_path_1.default.join(appPath, "layout.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(appPath, "page.tsx"));
-    });
-    const pagesRouter = pagesDirs.length > 0 && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_app.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_document.tsx"));
+    // Detect App Router vs Pages Router (lightweight check)
+    const appRouter = appDirs.length > 0 && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "app", "layout.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "app", "page.tsx"));
+    const pagesRouter = pagesDirs.length > 0 && (node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_app.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_document.tsx")));
     return {
         framework: (0, framework_1.detectFramework)(cwd),
         hasTypeScript,

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];
+}