@lasso-ai/cli 1.5.0 → 2.0.0

package/dist/runtime/review.d.ts

@@ -0,0 +1,24 @@
+/**
+ * WorkspaceGuard diff → review payload normalization.
+ *
+ * Shared by the server orchestrator and the CLI LocalRuntime: the guard diff
+ * is the authoritative record of what an agent changed, normalized into the
+ * pendingChanges contract consumed by the review UI and the apply flow.
+ */
+import { FileChange } from "./workspace-guard";
+import { AgentAction } from "./agent-runtime";
+export interface PendingChange {
+    filePath: string;
+    oldString: string;
+    newString: string;
+    operation: "created" | "modified" | "deleted";
+}
+export interface WorkspaceReview {
+    /** Reviewable (text) changes in the wire format used by the review UI. */
+    changes: PendingChange[];
+    /** Paths of binary changes — preserved for rollback, not shown as text. */
+    binaryPaths: string[];
+    /** Normalized session actions matching the reviewable changes. */
+    actions: AgentAction[];
+}
+export declare function diffToReview(rawChanges: FileChange[]): WorkspaceReview;

package/dist/runtime/review.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * WorkspaceGuard diff → review payload normalization.
+ *
+ * Shared by the server orchestrator and the CLI LocalRuntime: the guard diff
+ * is the authoritative record of what an agent changed, normalized into the
+ * pendingChanges contract consumed by the review UI and the apply flow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffToReview = diffToReview;
+function diffToReview(rawChanges) {
+    const binaryPaths = rawChanges.filter((c) => c.binary).map((c) => c.filePath);
+    const applyable = rawChanges.filter((c) => !c.binary);
+    const changes = applyable.map((change) => ({
+        filePath: change.filePath,
+        oldString: change.operation === "created" ? "" : change.oldContent ?? "",
+        newString: change.operation === "deleted" ? "" : change.newContent ?? "",
+        operation: change.operation,
+    }));
+    const actions = applyable.map((change) => ({
+        id: crypto.randomUUID(),
+        type: change.operation === "created" ? "create_file" : change.operation === "deleted" ? "delete_file" : "edit_file",
+        data: change.operation === "created"
+            ? { filePath: change.filePath, content: change.newContent }
+            : change.operation === "deleted"
+                ? { filePath: change.filePath }
+                : { filePath: change.filePath, oldString: change.oldContent ?? "", newString: change.newContent ?? "" },
+    }));
+    return { changes, binaryPaths, actions };
+}

package/dist/runtime/verification-engine.d.ts

@@ -0,0 +1,71 @@
+import { Observation, AgentError, AgentPhase } from "./agent-runtime";
+/**
+ * Verification Engine - Verifies changes after execution
+ *
+ * Mandatory verification step in the agent loop.
+ * Timeouts are failures or inconclusive observations, never proof of success.
+ */
+export interface VerificationConfig {
+    typecheckTimeout: number;
+    buildTimeout: number;
+    devServerTimeout: number;
+    browserTimeout: number;
+}
+export interface VerificationResult {
+    type: "typecheck" | "build" | "dev_server" | "browser";
+    success: boolean;
+    /** Set when the check could not meaningfully run (no tsconfig, no build script). */
+    skipped?: boolean;
+    /** Command that produced this result, when applicable. */
+    command?: string;
+    output?: string;
+    error?: string;
+    observations: Observation[];
+    errors: AgentError[];
+    duration: number;
+}
+export declare class VerificationEngine {
+    private projectPath;
+    private config;
+    constructor(projectPath: string, config?: Partial<VerificationConfig>);
+    /**
+     * Run all verifications
+     */
+    verifyAll(phase: AgentPhase): Promise<VerificationResult[]>;
+    /**
+     * Verify TypeScript type checking
+     */
+    verifyTypecheck(phase: AgentPhase): Promise<VerificationResult>;
+    /**
+     * Verify build
+     */
+    verifyBuild(phase: AgentPhase): Promise<VerificationResult>;
+    /**
+     * Verify dev server health
+     */
+    verifyDevServer(phase: AgentPhase): Promise<VerificationResult>;
+    /**
+     * Verify browser/runtime state
+     */
+    verifyBrowser(phase: AgentPhase): Promise<VerificationResult>;
+    /**
+     * Check if verification passed overall
+     */
+    allPassed(results: VerificationResult[]): boolean;
+    /**
+     * Get all verification errors
+     */
+    getErrors(results: VerificationResult[]): AgentError[];
+    /**
+     * Get all verification observations
+     */
+    getObservations(results: VerificationResult[]): Observation[];
+    /**
+     * Generate a unique ID
+     */
+    private generateId;
+    /** tsconfig.json (or any tsconfig.*.json) present in the project root. */
+    private hasTypeScriptConfig;
+    /** package.json with a non-empty build script. */
+    private hasBuildScript;
+}

package/dist/runtime/verification-engine.js

@@ -0,0 +1,374 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationEngine = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+class VerificationEngine {
+    projectPath;
+    config;
+    constructor(projectPath, config) {
+        this.projectPath = projectPath;
+        this.config = {
+            typecheckTimeout: config?.typecheckTimeout || 60000,
+            buildTimeout: config?.buildTimeout || 120000,
+            devServerTimeout: config?.devServerTimeout || 30000,
+            browserTimeout: config?.browserTimeout || 60000,
+        };
+    }
+    /**
+     * Run all verifications
+     */
+    async verifyAll(phase) {
+        const results = [];
+        // Type checking
+        const typecheckResult = await this.verifyTypecheck(phase);
+        results.push(typecheckResult);
+        // If typecheck failed, skip build
+        if (!typecheckResult.success) {
+            return results;
+        }
+        // Build
+        const buildResult = await this.verifyBuild(phase);
+        results.push(buildResult);
+        // If build failed, skip dev server check
+        if (!buildResult.success) {
+            return results;
+        }
+        // Dev server health
+        const devServerResult = await this.verifyDevServer(phase);
+        results.push(devServerResult);
+        // Browser check (placeholder)
+        const browserResult = await this.verifyBrowser(phase);
+        results.push(browserResult);
+        return results;
+    }
+    /**
+     * Verify TypeScript type checking
+     */
+    async verifyTypecheck(phase) {
+        const startTime = Date.now();
+        const observations = [];
+        const errors = [];
+        // Inconclusive without a tsconfig: never a pass and never a failure.
+        if (!this.hasTypeScriptConfig()) {
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "TypeScript check skipped (no tsconfig.json)",
+                data: { type: "typecheck", success: true, skipped: true },
+                timestamp: Date.now(),
+                phase,
+            });
+            return {
+                type: "typecheck",
+                success: true,
+                skipped: true,
+                observations,
+                errors,
+                duration: Date.now() - startTime,
+            };
+        }
+        try {
+            const command = "npx tsc --noEmit";
+            const { stdout, stderr } = await exec(command, {
+                cwd: this.projectPath,
+                timeout: this.config.typecheckTimeout,
+            });
+            const duration = Date.now() - startTime;
+            // Non-zero exit throws (caught below), so reaching here means tsc
+            // reported no type errors — stderr may still hold npm notices.
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "TypeScript check passed",
+                data: {
+                    type: "typecheck",
+                    success: true,
+                    output: stdout + stderr,
+                },
+                timestamp: Date.now(),
+                phase,
+            });
+            return {
+                type: "typecheck",
+                success: true,
+                command: "npx tsc --noEmit",
+                output: stdout + stderr,
+                observations,
+                errors,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "TypeScript check failed",
+                data: {
+                    type: "typecheck",
+                    success: false,
+                    error: error.message,
+                },
+                timestamp: Date.now(),
+                phase,
+            });
+            errors.push({
+                id: this.generateId(),
+                type: "verification",
+                message: error.message,
+                phase,
+                timestamp: Date.now(),
+                details: { stderr: error.stderr, stdout: error.stdout },
+                recoverable: true,
+            });
+            return {
+                type: "typecheck",
+                success: false,
+                command: "npx tsc --noEmit",
+                error: error.message,
+                observations,
+                errors,
+                duration,
+            };
+        }
+    }
+    /**
+     * Verify build
+     */
+    async verifyBuild(phase) {
+        const startTime = Date.now();
+        const observations = [];
+        const errors = [];
+        // Inconclusive when the project has no build script.
+        if (!this.hasBuildScript()) {
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "Build skipped (no build script)",
+                data: { type: "build", success: true, skipped: true },
+                timestamp: Date.now(),
+                phase,
+            });
+            return {
+                type: "build",
+                success: true,
+                skipped: true,
+                observations,
+                errors,
+                duration: Date.now() - startTime,
+            };
+        }
+        try {
+            // Try common build commands
+            const commands = ["npm run build", "pnpm build", "yarn build"];
+            let result;
+            let usedCommand = "";
+            let lastError = "";
+            for (const cmd of commands) {
+                try {
+                    result = await exec(cmd, {
+                        cwd: this.projectPath,
+                        timeout: this.config.buildTimeout,
+                    });
+                    usedCommand = cmd;
+                    break;
+                }
+                catch (err) {
+                    lastError = err?.stderr || err?.message || `${cmd} failed`;
+                    const managerMissing = err?.code === 127 || /command not found|ENOENT/i.test(String(err?.message || ""));
+                    if (!managerMissing) {
+                        // The build script ran and failed — don't mask it by trying
+                        // other package managers.
+                        break;
+                    }
+                    continue;
+                }
+            }
+            const duration = Date.now() - startTime;
+            if (!result) {
+                observations.push({
+                    id: this.generateId(),
+                    type: "build",
+                    summary: "Build failed",
+                    data: { type: "build", success: false, error: lastError },
+                    timestamp: Date.now(),
+                    phase,
+                });
+                errors.push({
+                    id: this.generateId(),
+                    type: "verification",
+                    message: "Build failed",
+                    phase,
+                    timestamp: Date.now(),
+                    details: { output: lastError },
+                    recoverable: true,
+                });
+                return {
+                    type: "build",
+                    success: false,
+                    command: "npm run build",
+                    error: "Build failed",
+                    output: lastError,
+                    observations,
+                    errors,
+                    duration,
+                };
+            }
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: `Build succeeded: ${usedCommand}`,
+                data: {
+                    type: "build",
+                    success: true,
+                    command: usedCommand,
+                },
+                timestamp: Date.now(),
+                phase,
+            });
+            return {
+                type: "build",
+                success: true,
+                command: usedCommand,
+                output: result.stdout,
+                observations,
+                errors,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "Build failed",
+                data: {
+                    type: "build",
+                    success: false,
+                    error: error.message,
+                },
+                timestamp: Date.now(),
+                phase,
+            });
+            errors.push({
+                id: this.generateId(),
+                type: "verification",
+                message: "Build failed",
+                phase,
+                timestamp: Date.now(),
+                details: { stderr: error.stderr, stdout: error.stdout },
+                recoverable: true,
+            });
+            return {
+                type: "build",
+                success: false,
+                error: error.message,
+                observations,
+                errors,
+                duration,
+            };
+        }
+    }
+    /**
+     * Verify dev server health
+     */
+    async verifyDevServer(phase) {
+        const startTime = Date.now();
+        const observations = [];
+        const errors = [];
+        // TODO: Implement actual dev server health check
+        // For now, just check if a dev server is likely running
+        observations.push({
+            id: this.generateId(),
+            type: "build",
+            summary: "Dev server health check skipped (not implemented)",
+            data: { type: "dev_server", success: true },
+            timestamp: Date.now(),
+            phase,
+        });
+        return {
+            type: "dev_server",
+            success: true,
+            observations,
+            errors,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Verify browser/runtime state
+     */
+    async verifyBrowser(phase) {
+        const startTime = Date.now();
+        const observations = [];
+        const errors = [];
+        // TODO: Implement actual browser checking via Puppeteer or similar
+        // For now, this is a placeholder
+        observations.push({
+            id: this.generateId(),
+            type: "browser",
+            summary: "Browser check skipped (not implemented)",
+            data: { type: "browser", success: true },
+            timestamp: Date.now(),
+            phase,
+        });
+        return {
+            type: "browser",
+            success: true,
+            observations,
+            errors,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check if verification passed overall
+     */
+    allPassed(results) {
+        return results.every((r) => r.success);
+    }
+    /**
+     * Get all verification errors
+     */
+    getErrors(results) {
+        return results.flatMap((r) => r.errors);
+    }
+    /**
+     * Get all verification observations
+     */
+    getObservations(results) {
+        return results.flatMap((r) => r.observations);
+    }
+    /**
+     * Generate a unique ID
+     */
+    generateId() {
+        return `ver_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /** tsconfig.json (or any tsconfig.*.json) present in the project root. */
+    hasTypeScriptConfig() {
+        try {
+            return node_fs_1.default.readdirSync(this.projectPath).some((name) => /^tsconfig(\..+)?\.json$/.test(name));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** package.json with a non-empty build script. */
+    hasBuildScript() {
+        try {
+            const raw = node_fs_1.default.readFileSync(node_path_1.default.join(this.projectPath, "package.json"), "utf8");
+            const pkg = JSON.parse(raw);
+            return typeof pkg?.scripts?.build === "string" && pkg.scripts.build.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.VerificationEngine = VerificationEngine;

package/dist/runtime/workspace-guard.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Workspace Guard - Capture, diff, and roll back project state.
+ *
+ * Lasso's non-negotiable review workflow requires:
+ *   1. Capture the original project state before an agent runs.
+ *   2. Collect resulting file changes after the agent runs.
+ *   3. Roll back to the original state so nothing is applied before review.
+ *   4. On approval, re-apply the changes; on rejection, leave the project untouched.
+ *
+ * The guard backs up every non-ignored file (in memory, or on disk for
+ * oversized files), computes a normalized diff against the captured state,
+ * and can restore the workspace exactly (content + permission bits + deletions).
+ */
+export interface FileChange {
+    /** Project-relative path using the platform separator */
+    filePath: string;
+    operation: "created" | "modified" | "deleted";
+    /** Full original text content (text files only) */
+    oldContent?: string;
+    /** Full new text content (text files only) */
+    newContent?: string;
+    /** True when the file is binary — contents are preserved for rollback but not reviewable as text */
+    binary?: boolean;
+}
+export interface WorkspaceGuardOptions {
+    /** Directory names that are never captured (defaults cover Node/tooling outputs) */
+    ignoreDirs?: string[];
+    /** Extra ignore predicates (relative path, isDirectory) */
+    ignore?: (relPath: string, isDir: boolean) => boolean;
+    /** Max bytes held in memory per file; larger files are copied to a temp dir (default 4MB) */
+    maxMemoryFileSize?: number;
+    /** Max total bytes held in memory before oversized handling kicks in per file (default 64MB) */
+    maxTotalBytes?: number;
+    /** Max directory recursion depth (default 32) */
+    maxDepth?: number;
+}
+export declare class WorkspaceGuard {
+    readonly root: string;
+    private readonly files;
+    private readonly skipped;
+    private readonly tempDir;
+    private readonly ignoreDirs;
+    private readonly ignoreFn?;
+    private tempDirCreated;
+    private disposed;
+    private constructor();
+    /**
+     * Capture the full current state of the workspace.
+     */
+    static capture(projectPath: string, options?: WorkspaceGuardOptions): Promise<WorkspaceGuard>;
+    /** Number of files captured (excludes ignored/skipped entries). */
+    get fileCount(): number;
+    /** Paths that could not be captured (symlinks, unreadable entries). */
+    get skippedPaths(): string[];
+    /**
+     * Compare the current on-disk state against the captured state.
+     * Must be called BEFORE restore() when collecting an agent's changes.
+     */
+    diff(): FileChange[];
+    /**
+     * Restore the workspace to the captured state:
+     * modified files are reverted, created files are deleted, deleted files are recreated.
+     */
+    restore(): Promise<void>;
+    /** Restore without comparing (used by dispose paths). */
+    dispose(): Promise<void>;
+    private listNewFiles;
+    private ensureTempDir;
+    private cleanupTemp;
+}