@lasso-ai/cli 1.5.0 → 2.0.0

package/dist/runtime/backend-interface.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Lasso Backend Interface - Unified Abstraction for Agent Backends
+ *
+ * This file defines the common interface for all agent backends:
+ * - Hosted model providers (Anthropic, OpenAI, Google, NVIDIA, Ollama)
+ * - Local coding agents (Claude Code, OpenCode, Codex CLI, Cursor)
+ *
+ * The Lasso Runtime uses this interface to delegate task execution while maintaining
+ * control over the overall workflow: Understand → Inspect → Plan → Execute → Verify → Recover → Complete
+ */
+import { AgentAction, Observation, AgentError, AgentPhase, ProjectContext, SelectionContext } from "./agent-runtime";
+export type { AgentAction, Observation, AgentError, AgentPhase, ProjectContext, SelectionContext } from "./agent-runtime";
+export type BackendType = "hosted_model" | "local_agent";
+export type BackendProvider = "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
+export interface BackendCapabilities {
+    /**
+     * Whether the backend can stream progress events in real-time
+     */
+    canStreamEvents: boolean;
+    /**
+     * Whether the backend can operate in an isolated workspace
+     * (required for safe pre-review execution)
+     */
+    canIsolateWorkspace: boolean;
+    /**
+     * Whether the backend provides structured diff output
+     * (vs. requiring post-execution diff generation)
+     */
+    providesStructuredDiffs: boolean;
+    /**
+     * Whether the backend supports session continuation across calls
+     */
+    supportsSessionContinuation: boolean;
+    /**
+     * Whether the backend can cancel running tasks
+     */
+    supportsCancellation: boolean;
+    /**
+     * Whether the backend has its own internal agentic loop
+     * (if true, Lasso should not run a competing loop around it)
+     */
+    hasInternalLoop: boolean;
+    /**
+     * File operations the backend can perform directly
+     */
+    supportedFileOperations: "read" | "write" | "both" | "none";
+    /**
+     * Whether the backend can run shell commands
+     */
+    canRunCommands: boolean;
+    /**
+     * Authentication method
+     */
+    authMethod: "api_key" | "cli_session" | "none" | "oauth";
+    /**
+     * Maximum file size for operations (in bytes), if any
+     */
+    maxFileSize?: number;
+    /**
+     * Commands that are forbidden (if any)
+     */
+    forbiddenCommands?: string[];
+}
+export interface BackendConfig {
+    /**
+     * Backend type
+     */
+    type: BackendType;
+    /**
+     * Provider identifier
+     */
+    provider: BackendProvider;
+    /**
+     * Model ID (for hosted models) or agent version (for local agents)
+     */
+    modelId?: string;
+    /**
+     * API key (for hosted models)
+     */
+    apiKey?: string;
+    /**
+     * Base URL (for hosted models like Ollama)
+     */
+    baseURL?: string;
+    /**
+     * Project path (for local agents)
+     */
+    projectPath?: string;
+    /**
+     * Additional provider-specific configuration
+     */
+    providerConfig?: Record<string, unknown>;
+}
+export interface TaskContext {
+    /**
+     * Unique task identifier
+     */
+    taskId: string;
+    /**
+     * User's prompt or instruction
+     */
+    userPrompt: string;
+    /**
+     * Project context
+     */
+    project: ProjectContext;
+    /**
+     * Selection context (if user selected a UI element)
+     */
+    selection?: SelectionContext;
+    /**
+     * Conversation history
+     */
+    conversation: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    /**
+     * Previous observations (for context)
+     */
+    previousObservations: Observation[];
+    /**
+     * Previous errors (for recovery)
+     */
+    previousErrors: AgentError[];
+    /**
+     * Current phase in Lasso's workflow
+     */
+    currentPhase: AgentPhase;
+    /**
+     * Constraints (max actions, safety level, etc.)
+     */
+    constraints: {
+        maxActions?: number;
+        safetyLevel?: "strict" | "standard" | "permissive";
+        allowedCommands?: string[];
+        forbiddenPaths?: string[];
+    };
+    /**
+     * Reference to the backend's own external session (e.g. Claude Code session id,
+     * Codex thread id, OpenCode ses_ id) for continuation when supported.
+     */
+    sessionRef?: {
+        id?: string;
+    };
+}
+export type BackendEventType = "task_started" | "task_progress" | "tool_started" | "tool_completed" | "file_read" | "file_modified" | "file_created" | "file_deleted" | "diff_available" | "verification_started" | "verification_completed" | "error" | "waiting_for_user" | "task_completed" | "task_cancelled" | "task_failed";
+export interface BackendEvent {
+    type: BackendEventType;
+    taskId: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+export interface BackendResult {
+    /**
+     * Whether the task completed successfully
+     */
+    success: boolean;
+    /**
+     * Final status
+     */
+    status: "completed" | "failed" | "cancelled" | "waiting";
+    /**
+     * Summary of what was done
+     */
+    summary: string;
+    /**
+     * File changes detected (normalized format)
+     */
+    fileChanges: Array<{
+        filePath: string;
+        operation: "created" | "modified" | "deleted";
+        oldContent?: string;
+        newContent?: string;
+    }>;
+    /**
+     * Actions taken (normalized to Lasso's AgentAction format where possible)
+     */
+    actions: AgentAction[];
+    /**
+     * Observations collected
+     */
+    observations: Observation[];
+    /**
+     * Errors encountered
+     */
+    errors: AgentError[];
+    /**
+     * Final conversation state (for continuation)
+     */
+    conversation?: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    /**
+     * Provider-specific metadata
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface IBackend {
+    /**
+     * Unique backend identifier
+     */
+    id: string;
+    /**
+     * Backend type
+     */
+    type: BackendType;
+    /**
+     * Provider name
+     */
+    provider: BackendProvider;
+    /**
+     * Model/agent ID
+     */
+    modelId: string;
+    /**
+     * Get backend capabilities
+     */
+    getCapabilities(): BackendCapabilities;
+    /**
+     * Check if backend is available and properly configured
+     *
+     * Returns detailed availability info including any authentication issues
+     */
+    checkAvailability(): Promise<{
+        available: boolean;
+        installed: boolean;
+        authenticated: boolean;
+        version?: string;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    /**
+     * Execute a task
+     *
+     * This is the main entry point for task execution.
+     * The backend should:
+     * 1. Start the task
+     * 2. Stream progress events via the callback
+     * 3. Return the final result
+     *
+     * For backends with internal loops (like Claude Code), this method
+     * should delegate to the agent and monitor its execution.
+     *
+     * For hosted models, this method should integrate with the existing
+     * ModelGateway and return structured responses.
+     */
+    executeTask(context: TaskContext, onEvent: (event: BackendEvent) => void, signal?: AbortSignal): Promise<BackendResult>;
+    /**
+     * Cancel a running task
+     *
+     * Only called if supportsCancellation is true
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Switch to a different backend/model
+     *
+     * This is called when the user switches providers mid-session.
+     * The backend should:
+     * 1. Return any context that can be transferred
+     * 2. Report what cannot be transferred (e.g., internal state)
+     */
+    switchBackend(newBackend: IBackend, context: TaskContext): Promise<{
+        transferableContext: Record<string, unknown>;
+        lostContext: string[];
+    }>;
+}
+export declare const DEFAULT_LOCAL_CAPABILITIES: BackendCapabilities;
+export declare const DEFAULT_HOSTED_CAPABILITIES: BackendCapabilities;

package/dist/runtime/backend-interface.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Lasso Backend Interface - Unified Abstraction for Agent Backends
+ *
+ * This file defines the common interface for all agent backends:
+ * - Hosted model providers (Anthropic, OpenAI, Google, NVIDIA, Ollama)
+ * - Local coding agents (Claude Code, OpenCode, Codex CLI, Cursor)
+ *
+ * The Lasso Runtime uses this interface to delegate task execution while maintaining
+ * control over the overall workflow: Understand → Inspect → Plan → Execute → Verify → Recover → Complete
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_HOSTED_CAPABILITIES = exports.DEFAULT_LOCAL_CAPABILITIES = void 0;
+// ============================================================================
+// Capability Defaults
+// ============================================================================
+exports.DEFAULT_LOCAL_CAPABILITIES = {
+    canStreamEvents: true,
+    canIsolateWorkspace: false,
+    providesStructuredDiffs: false,
+    supportsSessionContinuation: true,
+    supportsCancellation: true,
+    hasInternalLoop: true,
+    supportedFileOperations: "both",
+    canRunCommands: true,
+    authMethod: "cli_session",
+};
+exports.DEFAULT_HOSTED_CAPABILITIES = {
+    canStreamEvents: true,
+    canIsolateWorkspace: false,
+    providesStructuredDiffs: false,
+    supportsSessionContinuation: true,
+    supportsCancellation: true,
+    hasInternalLoop: false,
+    supportedFileOperations: "both",
+    canRunCommands: true,
+    authMethod: "api_key",
+};

package/dist/runtime/event-mapper.d.ts

@@ -0,0 +1,11 @@
+/**
+ * BackendEvent → AgentEvent (wire format) mapping.
+ *
+ * Shared by the server orchestrator (SSE) and the CLI LocalRuntime so both
+ * execution paths speak the identical event vocabulary.
+ */
+import { BackendEvent } from "./backend-interface";
+import { AgentEvent, AgentEventType } from "./agent-runtime";
+export declare function mapBackendEventType(backendType: string): AgentEventType;
+/** Convert one backend event into the runtime wire event. */
+export declare function toAgentEvent(sessionId: string, event: BackendEvent): AgentEvent;

package/dist/runtime/event-mapper.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * BackendEvent → AgentEvent (wire format) mapping.
+ *
+ * Shared by the server orchestrator (SSE) and the CLI LocalRuntime so both
+ * execution paths speak the identical event vocabulary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapBackendEventType = mapBackendEventType;
+exports.toAgentEvent = toAgentEvent;
+const BACKEND_TO_AGENT_TYPE = {
+    task_started: "agent_started",
+    task_progress: "agent_reasoning",
+    tool_started: "tool_started",
+    tool_completed: "tool_completed",
+    file_read: "observation",
+    file_modified: "file_changed",
+    file_created: "file_changed",
+    file_deleted: "file_changed",
+    diff_available: "file_changed",
+    verification_started: "verification_started",
+    verification_completed: "verification_completed",
+    error: "error",
+    waiting_for_user: "waiting_for_user",
+    task_completed: "agent_completed",
+    task_cancelled: "agent_cancelled",
+    task_failed: "agent_failed",
+};
+function mapBackendEventType(backendType) {
+    return BACKEND_TO_AGENT_TYPE[backendType] || "observation";
+}
+/** Convert one backend event into the runtime wire event. */
+function toAgentEvent(sessionId, event) {
+    return {
+        type: mapBackendEventType(event.type),
+        sessionId,
+        timestamp: event.timestamp,
+        data: event.data,
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lasso runtime core — shared by the server (hosted sessions, colocated
+ * self-host) and the CLI LocalRuntime (local coding agents on the user's
+ * machine). Single implementation of the review-first agent workflow.
+ */
+export * from "./agent-runtime";
+export * from "./backend-interface";
+export * from "./workspace-guard";
+export * from "./verification-engine";
+export * from "./agent-state-machine";
+export * from "./event-mapper";
+export * from "./review";
+export * from "./local-session-runner";
+export * from "./adapters/factory";
+export { LocalAgentAdapter, EventSink, newRunState } from "./adapters/local-agent-adapter";
+export type { LocalAgentConfig, CommandSpec, AgentRunState } from "./adapters/local-agent-adapter";
+export { ClaudeCodeAdapter } from "./adapters/claude-code-adapter";
+export { OpenCodeAdapter } from "./adapters/opencode-adapter";
+export { CodexCLIAdapter } from "./adapters/codex-cli-adapter";
+export { CursorAdapter } from "./adapters/cursor-adapter";

package/dist/runtime/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Lasso runtime core — shared by the server (hosted sessions, colocated
+ * self-host) and the CLI LocalRuntime (local coding agents on the user's
+ * machine). Single implementation of the review-first agent workflow.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorAdapter = exports.CodexCLIAdapter = exports.OpenCodeAdapter = exports.ClaudeCodeAdapter = exports.newRunState = exports.EventSink = exports.LocalAgentAdapter = void 0;
+__exportStar(require("./agent-runtime"), exports);
+__exportStar(require("./backend-interface"), exports);
+__exportStar(require("./workspace-guard"), exports);
+__exportStar(require("./verification-engine"), exports);
+__exportStar(require("./agent-state-machine"), exports);
+__exportStar(require("./event-mapper"), exports);
+__exportStar(require("./review"), exports);
+__exportStar(require("./local-session-runner"), exports);
+__exportStar(require("./adapters/factory"), exports);
+var local_agent_adapter_1 = require("./adapters/local-agent-adapter");
+Object.defineProperty(exports, "LocalAgentAdapter", { enumerable: true, get: function () { return local_agent_adapter_1.LocalAgentAdapter; } });
+Object.defineProperty(exports, "EventSink", { enumerable: true, get: function () { return local_agent_adapter_1.EventSink; } });
+Object.defineProperty(exports, "newRunState", { enumerable: true, get: function () { return local_agent_adapter_1.newRunState; } });
+var claude_code_adapter_1 = require("./adapters/claude-code-adapter");
+Object.defineProperty(exports, "ClaudeCodeAdapter", { enumerable: true, get: function () { return claude_code_adapter_1.ClaudeCodeAdapter; } });
+var opencode_adapter_1 = require("./adapters/opencode-adapter");
+Object.defineProperty(exports, "OpenCodeAdapter", { enumerable: true, get: function () { return opencode_adapter_1.OpenCodeAdapter; } });
+var codex_cli_adapter_1 = require("./adapters/codex-cli-adapter");
+Object.defineProperty(exports, "CodexCLIAdapter", { enumerable: true, get: function () { return codex_cli_adapter_1.CodexCLIAdapter; } });
+var cursor_adapter_1 = require("./adapters/cursor-adapter");
+Object.defineProperty(exports, "CursorAdapter", { enumerable: true, get: function () { return cursor_adapter_1.CursorAdapter; } });

package/dist/runtime/local-session-runner.d.ts

@@ -0,0 +1,60 @@
+/**
+ * LocalSessionRunner — the shared Mode-B workflow for local coding agents.
+ *
+ * Encodes the non-negotiable local-agent lifecycle exactly once:
+ *   backend.executeTask (agent owns its internal loop)
+ *   → guard.diff (authoritative change detection)
+ *   → review normalization (pendingChanges contract)
+ *   → workspace rollback BEFORE review (finally safety net)
+ *   → wire events (agent_completed / error) identical to the hosted SSE flow.
+ *
+ * Hosts (server orchestrator for colocated self-host, CLI LocalRuntime for
+ * the npm CLI) provide: a pre-captured WorkspaceGuard, the backend instance,
+ * the TaskContext, and an event sink. Persistence stays host-side.
+ */
+import { IBackend, TaskContext } from "./backend-interface";
+import { AgentEvent, AgentAction, AgentError, AgentPhase, Observation } from "./agent-runtime";
+import { WorkspaceGuard } from "./workspace-guard";
+import { PendingChange } from "./review";
+export interface LocalSessionOutcome {
+    /** Backend-reported success (terminal success signal + clean exit). */
+    success: boolean;
+    /** Session status to persist: waiting (review) | completed | failed. */
+    status: "waiting" | "completed" | "failed";
+    summary?: string;
+    /** Reviewable text changes (workspace already rolled back). */
+    changes: PendingChange[];
+    binaryPaths: string[];
+    /** Normalized actions replacing any backend-reported ones. */
+    actions: AgentAction[];
+    observations: Observation[];
+    errors: AgentError[];
+    conversation: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    externalSessionId?: string;
+    /** Suggested session metadata updates (backend provider/model/session id). */
+    metadata: Record<string, unknown>;
+}
+export interface LocalSessionRunnerOptions {
+    sessionId: string;
+    backend: IBackend;
+    /** Workspace captured BEFORE the agent ran. Consumed (diffed + restored). */
+    guard: WorkspaceGuard;
+    /** Sink for wire-format AgentEvents (forward to SSE / UI / in-memory). */
+    emit: (event: AgentEvent) => void;
+    /** Current phase, recorded on observations/errors. */
+    phase?: AgentPhase;
+}
+export declare class LocalSessionRunner {
+    private readonly options;
+    private restored;
+    constructor(options: LocalSessionRunnerOptions);
+    run(context: TaskContext, signal?: AbortSignal): Promise<LocalSessionOutcome>;
+    /** Diff + rollback in one step (restore happens before any review event). */
+    private finalizeReview;
+    /** WorkspaceGuard.restore is single-use; flag guards the safety-net double call. */
+    private restoreGuard;
+}

package/dist/runtime/local-session-runner.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * LocalSessionRunner — the shared Mode-B workflow for local coding agents.
+ *
+ * Encodes the non-negotiable local-agent lifecycle exactly once:
+ *   backend.executeTask (agent owns its internal loop)
+ *   → guard.diff (authoritative change detection)
+ *   → review normalization (pendingChanges contract)
+ *   → workspace rollback BEFORE review (finally safety net)
+ *   → wire events (agent_completed / error) identical to the hosted SSE flow.
+ *
+ * Hosts (server orchestrator for colocated self-host, CLI LocalRuntime for
+ * the npm CLI) provide: a pre-captured WorkspaceGuard, the backend instance,
+ * the TaskContext, and an event sink. Persistence stays host-side.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSessionRunner = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const review_1 = require("./review");
+const event_mapper_1 = require("./event-mapper");
+class LocalSessionRunner {
+    options;
+    restored = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async run(context, signal) {
+        const { sessionId, backend, guard, emit } = this.options;
+        const phase = this.options.phase || "execute";
+        let outcome;
+        try {
+            const result = await backend.executeTask(context, (event) => emit((0, event_mapper_1.toAgentEvent)(sessionId, event)), signal);
+            // Authoritative diff against the captured state, then rollback so the
+            // review happens against an untouched project.
+            const review = await this.finalizeReview();
+            const externalSessionId = result.metadata?.externalSessionId;
+            const metadata = {
+                backendProvider: backend.provider,
+                backendModel: backend.modelId,
+                ...(typeof externalSessionId === "string" ? { backendSessionId: externalSessionId } : {}),
+            };
+            let status;
+            if (review.changes.length > 0) {
+                // Changes await user approval — nothing has been applied.
+                status = "waiting";
+                emit({
+                    type: "agent_completed",
+                    sessionId,
+                    timestamp: Date.now(),
+                    data: {
+                        requiresReview: true,
+                        pendingChanges: review.changes.length,
+                        backend: backend.provider,
+                        success: result.success,
+                        summary: result.summary,
+                    },
+                });
+            }
+            else if (!result.success) {
+                status = "failed";
+                emit({
+                    type: "error",
+                    sessionId,
+                    timestamp: Date.now(),
+                    data: { error: result.summary || `${backend.provider} failed without producing changes` },
+                });
+            }
+            else {
+                status = "completed";
+                emit({
+                    type: "agent_completed",
+                    sessionId,
+                    timestamp: Date.now(),
+                    data: { requiresReview: false, summary: result.summary },
+                });
+            }
+            if (review.binaryPaths.length > 0) {
+                const observation = {
+                    id: node_crypto_1.default.randomUUID(),
+                    type: "file",
+                    summary: `${review.binaryPaths.length} binary file change${review.binaryPaths.length === 1 ? "" : "s"} detected (not reviewable as text)`,
+                    data: { binaryPaths: review.binaryPaths },
+                    timestamp: Date.now(),
+                    phase,
+                };
+                emit({ type: "observation", sessionId, timestamp: Date.now(), data: { summary: observation.summary } });
+                outcome = {
+                    success: result.success,
+                    status,
+                    summary: result.summary,
+                    changes: review.changes,
+                    binaryPaths: review.binaryPaths,
+                    actions: review.actions,
+                    observations: [...result.observations, observation],
+                    errors: [...result.errors],
+                    conversation: result.conversation || [],
+                    externalSessionId: typeof externalSessionId === "string" ? externalSessionId : undefined,
+                    metadata,
+                };
+            }
+            else {
+                outcome = {
+                    success: result.success,
+                    status,
+                    summary: result.summary,
+                    changes: review.changes,
+                    binaryPaths: [],
+                    actions: review.actions,
+                    observations: [...result.observations],
+                    errors: [...result.errors],
+                    conversation: result.conversation || [],
+                    externalSessionId: typeof externalSessionId === "string" ? externalSessionId : undefined,
+                    metadata,
+                };
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Backend execution failed";
+            await this.restoreGuard();
+            outcome = {
+                success: false,
+                status: "failed",
+                changes: [],
+                binaryPaths: [],
+                actions: [],
+                observations: [],
+                errors: [
+                    {
+                        id: node_crypto_1.default.randomUUID(),
+                        type: "execution",
+                        message,
+                        phase,
+                        timestamp: Date.now(),
+                        recoverable: false,
+                    },
+                ],
+                conversation: [],
+                metadata: {},
+            };
+            emit({
+                type: "error",
+                sessionId,
+                timestamp: Date.now(),
+                data: { error: message },
+            });
+        }
+        finally {
+            // Safety net: never leave un-reviewed changes on disk, even when the
+            // review path above already restored.
+            await this.restoreGuard();
+        }
+        return outcome;
+    }
+    /** Diff + rollback in one step (restore happens before any review event). */
+    async finalizeReview() {
+        const rawChanges = this.options.guard.diff();
+        await this.restoreGuard();
+        const review = (0, review_1.diffToReview)(rawChanges);
+        if (review.changes.length > 0) {
+            this.options.emit({
+                type: "file_changed",
+                sessionId: this.options.sessionId,
+                timestamp: Date.now(),
+                data: { changes: review.changes },
+            });
+        }
+        return review;
+    }
+    /** WorkspaceGuard.restore is single-use; flag guards the safety-net double call. */
+    async restoreGuard() {
+        if (this.restored)
+            return;
+        this.restored = true;
+        try {
+            await this.options.guard.restore();
+        }
+        catch (error) {
+            console.error("WorkspaceGuard restore failed:", error);
+        }
+    }
+}
+exports.LocalSessionRunner = LocalSessionRunner;