@lasso-ai/cli 1.5.0 → 2.0.1

package/dist/runtime/agent-runtime.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Lasso Agentic Runtime - Core Type Definitions
+ *
+ * This file defines all the core contracts for the Lasso-owned agentic runtime.
+ * The model is an interchangeable intelligence provider; Lasso owns the loop.
+ */
+export type AgentPhase = "understand" | "inspect" | "plan" | "execute" | "verify" | "recover" | "complete";
+export type AgentStatus = "running" | "waiting" | "completed" | "failed" | "cancelled";
+export interface LassoAgentSession {
+    id: string;
+    phase: AgentPhase;
+    status: AgentStatus;
+    iteration: number;
+    userPrompt: string;
+    conversation: AgentMessage[];
+    observations: Observation[];
+    actions: AgentAction[];
+    completedActions: AgentAction[];
+    errors: AgentError[];
+    plan?: AgentPlan;
+    selection?: SelectionContext;
+    project: ProjectContext;
+    model: ModelMetadata;
+    createdAt: Date;
+    updatedAt: Date;
+    conversationUid?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentMessage {
+    id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SelectionContext {
+    element?: {
+        tag: string;
+        text?: string;
+        source?: string;
+        attributes?: Record<string, string>;
+    };
+    viewport?: {
+        width: number;
+        height: number;
+        scrollY?: number;
+        scrollHeight?: number;
+    };
+    route?: string;
+    screenshot?: string;
+}
+export interface ProjectContext {
+    projectId: string;
+    framework?: string;
+    hasTypeScript: boolean;
+    hasTailwind: boolean;
+    hasReact: boolean;
+    hasNext: boolean;
+    hasVite: boolean;
+    files: string[];
+    dependencies?: string[];
+    devDependencies?: string[];
+    currentRoute?: string;
+    sourceHints?: Record<string, string>;
+    pageContext?: {
+        route?: string;
+        title?: string;
+        viewport?: {
+            width: number;
+            height: number;
+            scrollY?: number;
+            scrollHeight?: number;
+        };
+        domSummary?: {
+            headings?: Array<{
+                level: number;
+                text: string;
+            }>;
+            sections?: Array<{
+                name: string;
+                textPreview: string;
+            }>;
+            buttons?: string[];
+            links?: string[];
+            visibleTextSnippet?: string;
+        };
+        runtimeErrors?: string[];
+        selectedElement?: SelectionContext["element"];
+        screenshot?: string;
+    };
+}
+export interface AgentPlan {
+    id: string;
+    goal: string;
+    steps: PlanStep[];
+    estimatedActions?: number;
+    createdAt: Date;
+}
+export interface PlanStep {
+    id: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed" | "failed";
+    actionCount?: number;
+}
+export type ObservationType = "file" | "search" | "command" | "browser" | "build" | "runtime" | "error" | "verification" | "tool";
+export interface Observation {
+    id: string;
+    type: ObservationType;
+    summary: string;
+    data?: unknown;
+    timestamp: number;
+    phase?: AgentPhase;
+    actionId?: string;
+}
+export type AgentAction = ReadFileAction | SearchCodeAction | InspectProjectAction | EditFileAction | CreateFileAction | DeleteFileAction | RunCommandAction | BrowserCheckAction;
+export interface BaseAction {
+    id: string;
+    data: Record<string, unknown>;
+}
+export interface ReadFileAction extends BaseAction {
+    type: "read_file";
+}
+export interface SearchCodeAction extends BaseAction {
+    type: "search_code";
+}
+export interface InspectProjectAction extends BaseAction {
+    type: "inspect_project";
+}
+export interface EditFileAction extends BaseAction {
+    type: "edit_file";
+}
+export interface CreateFileAction extends BaseAction {
+    type: "create_file";
+}
+export interface DeleteFileAction extends BaseAction {
+    type: "delete_file";
+}
+export interface RunCommandAction extends BaseAction {
+    type: "run_command";
+}
+export interface BrowserCheckAction extends BaseAction {
+    type: "browser_check";
+}
+export interface AgentError {
+    id: string;
+    type: "validation" | "execution" | "verification" | "timeout" | "permission" | "unknown";
+    message: string;
+    phase: AgentPhase;
+    actionId?: string;
+    timestamp: number;
+    details?: Record<string, unknown>;
+    recoverable: boolean;
+}
+export interface ModelMetadata {
+    provider: "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
+    id: string;
+    name?: string;
+}
+export interface LassoAgentContext {
+    session: {
+        id: string;
+        phase: AgentPhase;
+        iteration: number;
+    };
+    userPrompt: string;
+    conversation: AgentMessage[];
+    selection?: SelectionContext;
+    project: ProjectContext;
+    observations: Observation[];
+    previousActions: AgentAction[];
+    errors: AgentError[];
+    currentPlan?: AgentPlan;
+    availableTools: ToolDefinition[];
+    constraints: AgentConstraints;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    allowedPhases: AgentPhase[];
+    parameters?: Record<string, unknown>;
+}
+export interface AgentConstraints {
+    maxActionsPerTurn: number;
+    allowedPhases: AgentPhase[];
+    maxFileSize?: number;
+    allowedCommands?: string[];
+    forbiddenPaths?: string[];
+    safetyLevel?: "strict" | "standard" | "permissive";
+}
+export interface LassoModelResponse {
+    status: "continue" | "waiting" | "complete" | "failed";
+    reasoning: {
+        summary: string;
+    };
+    decision: {
+        type: "inspect" | "plan" | "execute" | "verify" | "recover" | "ask_user";
+        goal: string;
+    };
+    actions: AgentAction[];
+    expectedOutcome?: string;
+}
+export type AgentEventType = "agent_started" | "agent_reasoning" | "agent_completed" | "agent_failed" | "agent_cancelled" | "phase_changed" | "tool_started" | "tool_completed" | "observation" | "plan_created" | "file_changed" | "verification_started" | "verification_completed" | "error" | "model_changed" | "waiting_for_user";
+export interface AgentEvent {
+    type: AgentEventType;
+    sessionId: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+export interface AgentReasoningEvent extends AgentEvent {
+    type: "agent_reasoning";
+    data: {
+        summary: string;
+        decision?: string;
+    };
+}
+export interface PhaseChangedEvent extends AgentEvent {
+    type: "phase_changed";
+    data: {
+        from: AgentPhase;
+        to: AgentPhase;
+        reason?: string;
+    };
+}
+export interface ToolStartedEvent extends AgentEvent {
+    type: "tool_started";
+    data: {
+        actionType: string;
+        target?: string;
+    };
+}
+export interface ToolCompletedEvent extends AgentEvent {
+    type: "tool_completed";
+    data: {
+        actionType: string;
+        target?: string;
+        success: boolean;
+        duration?: number;
+    };
+}
+export interface ObservationEvent extends AgentEvent {
+    type: "observation";
+    data: {
+        observationType: ObservationType;
+        summary: string;
+        details?: unknown;
+    };
+}
+export interface VerificationStartedEvent extends AgentEvent {
+    type: "verification_started";
+    data: {
+        verificationType: "typecheck" | "build" | "runtime" | "browser";
+    };
+}
+export interface VerificationCompletedEvent extends AgentEvent {
+    type: "verification_completed";
+    data: {
+        verificationType: "typecheck" | "build" | "runtime" | "browser";
+        success: boolean;
+        duration?: number;
+        errors?: string[];
+    };
+}
+export interface ErrorEvent extends AgentEvent {
+    type: "error";
+    data: {
+        errorType: string;
+        message: string;
+        phase: AgentPhase;
+        recoverable: boolean;
+    };
+}
+export interface ModelChangedEvent extends AgentEvent {
+    type: "model_changed";
+    data: {
+        from: ModelMetadata;
+        to: ModelMetadata;
+    };
+}
+export interface WaitingForUserEvent extends AgentEvent {
+    type: "waiting_for_user";
+    data: {
+        question?: string;
+        options?: string[];
+        kind?: "input" | "single_select" | "multiselect";
+    };
+}

package/dist/runtime/agent-runtime.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Lasso Agentic Runtime - Core Type Definitions
+ *
+ * This file defines all the core contracts for the Lasso-owned agentic runtime.
+ * The model is an interchangeable intelligence provider; Lasso owns the loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/agent-state-machine.d.ts

@@ -0,0 +1,67 @@
+import { AgentPhase, LassoAgentSession, AgentAction } from "./agent-runtime";
+/**
+ * Lasso Agent State Machine
+ *
+ * Controls phase transitions and validates state changes.
+ * Lasso owns the transitions; the model can only suggest decisions.
+ */
+export declare class AgentStateMachine {
+    /**
+     * Valid phase transitions based on the current state
+     */
+    private static readonly TRANSITIONS;
+    /**
+     * Actions allowed in each phase
+     */
+    private static readonly ALLOWED_ACTIONS;
+    /**
+     * Check if a phase transition is valid
+     */
+    static canTransition(session: LassoAgentSession, toPhase: AgentPhase): boolean;
+    /**
+     * Attempt to transition to a new phase
+     * Returns success status and error message if invalid
+     */
+    static transition(session: LassoAgentSession, toPhase: AgentPhase, reason?: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Validate that an action is allowed in the current phase
+     */
+    static validateAction(session: LassoAgentSession, action: AgentAction): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Determine the next phase based on current state and model decision
+     */
+    static determineNextPhase(session: LassoAgentSession, modelDecision: {
+        type: string;
+        goal: string;
+    }): AgentPhase;
+    /**
+     * Check if the session is in a terminal state
+     */
+    static isTerminal(session: LassoAgentSession): boolean;
+    /**
+     * Check if the session can accept new actions
+     */
+    static canAcceptActions(session: LassoAgentSession): boolean;
+    /**
+     * Check if the session should trigger verification
+     */
+    static shouldVerify(session: LassoAgentSession): boolean;
+    /**
+     * Check if the session should trigger recovery
+     */
+    static shouldRecover(session: LassoAgentSession): boolean;
+    /**
+     * Check if the session can switch models
+     */
+    static canSwitchModel(session: LassoAgentSession): boolean;
+    /**
+     * Calculate the estimated number of remaining turns
+     */
+    static estimateRemainingTurns(session: LassoAgentSession): number;
+}

package/dist/runtime/agent-state-machine.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStateMachine = void 0;
+/**
+ * Lasso Agent State Machine
+ *
+ * Controls phase transitions and validates state changes.
+ * Lasso owns the transitions; the model can only suggest decisions.
+ */
+class AgentStateMachine {
+    /**
+     * Valid phase transitions based on the current state
+     */
+    static TRANSITIONS = {
+        understand: ["inspect", "complete"],
+        inspect: ["plan", "understand", "complete"],
+        plan: ["execute", "inspect", "understand", "complete"],
+        execute: ["verify", "plan", "inspect", "understand"],
+        verify: ["complete", "recover", "execute", "plan"],
+        recover: ["inspect", "plan", "execute", "verify", "understand"],
+        complete: [], // Terminal state
+    };
+    /**
+     * Actions allowed in each phase
+     */
+    static ALLOWED_ACTIONS = {
+        understand: [],
+        inspect: ["read_file", "search_code", "inspect_project"],
+        plan: [],
+        execute: ["edit_file", "create_file", "delete_file", "run_command"],
+        verify: ["browser_check", "run_command"],
+        recover: ["edit_file", "read_file", "run_command"],
+        complete: [],
+    };
+    /**
+     * Check if a phase transition is valid
+     */
+    static canTransition(session, toPhase) {
+        const currentPhase = session.phase;
+        const allowed = this.TRANSITIONS[currentPhase] || [];
+        return allowed.includes(toPhase);
+    }
+    /**
+     * Attempt to transition to a new phase
+     * Returns success status and error message if invalid
+     */
+    static transition(session, toPhase, reason) {
+        if (!this.canTransition(session, toPhase)) {
+            return {
+                success: false,
+                error: `Invalid phase transition from ${session.phase} to ${toPhase}`,
+            };
+        }
+        // Special checks for specific transitions
+        if (toPhase === "complete") {
+            if (session.actions.length === 0 && session.completedActions.length === 0) {
+                return {
+                    success: false,
+                    error: "Cannot complete without executing any actions",
+                };
+            }
+            if (session.status === "failed") {
+                return {
+                    success: false,
+                    error: "Cannot complete a failed session",
+                };
+            }
+        }
+        if (toPhase === "recover") {
+            if (session.errors.length === 0) {
+                return {
+                    success: false,
+                    error: "Cannot enter recovery phase without errors",
+                };
+            }
+        }
+        return { success: true };
+    }
+    /**
+     * Validate that an action is allowed in the current phase
+     */
+    static validateAction(session, action) {
+        const allowedActions = this.ALLOWED_ACTIONS[session.phase] || [];
+        const actionType = action.type;
+        if (!allowedActions.includes(actionType)) {
+            return {
+                valid: false,
+                error: `Action type "${actionType}" is not allowed in phase "${session.phase}"`,
+            };
+        }
+        // Additional validation for specific actions
+        if (action.type === "edit_file") {
+            const data = action.data;
+            if (!data.oldString && !data.newString) {
+                return {
+                    valid: false,
+                    error: "Edit action must have oldString or newString",
+                };
+            }
+        }
+        if (action.type === "run_command") {
+            const data = action.data;
+            if (!data.command || !data.command.trim()) {
+                return {
+                    valid: false,
+                    error: "Run command action must have a command",
+                };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * Determine the next phase based on current state and model decision
+     */
+    static determineNextPhase(session, modelDecision) {
+        const currentPhase = session.phase;
+        const decisionType = modelDecision.type;
+        // If model explicitly asks for a phase, validate it
+        if (decisionType === "inspect" && this.canTransition(session, "inspect")) {
+            return "inspect";
+        }
+        if (decisionType === "plan" && this.canTransition(session, "plan")) {
+            return "plan";
+        }
+        if (decisionType === "execute" && this.canTransition(session, "execute")) {
+            return "execute";
+        }
+        if (decisionType === "verify" && this.canTransition(session, "verify")) {
+            return "verify";
+        }
+        if (decisionType === "recover" && this.canTransition(session, "recover")) {
+            return "recover";
+        }
+        // Default progression based on current phase
+        switch (currentPhase) {
+            case "understand":
+                return "inspect";
+            case "inspect":
+                // If we have observations, move to plan
+                if (session.observations.length > 0) {
+                    return "plan";
+                }
+                return "inspect";
+            case "plan":
+                // If we have a plan, move to execute
+                if (session.plan) {
+                    return "execute";
+                }
+                return "plan";
+            case "execute":
+                // If we have completed actions, move to verify
+                if (session.completedActions.length > 0) {
+                    return "verify";
+                }
+                return "execute";
+            case "verify":
+                // If verification succeeded, complete; if failed, recover
+                const hasErrors = session.errors.some((e) => e.phase === "verify");
+                if (hasErrors) {
+                    return "recover";
+                }
+                return "complete";
+            case "recover":
+                // After recovery attempt, go back to verify
+                return "verify";
+            case "complete":
+                return "complete";
+            default:
+                return "understand";
+        }
+    }
+    /**
+     * Check if the session is in a terminal state
+     */
+    static isTerminal(session) {
+        return session.phase === "complete" || session.status === "failed" || session.status === "cancelled";
+    }
+    /**
+     * Check if the session can accept new actions
+     */
+    static canAcceptActions(session) {
+        return (session.status === "running" &&
+            session.phase !== "complete" &&
+            session.phase !== "understand");
+    }
+    /**
+     * Check if the session should trigger verification
+     */
+    static shouldVerify(session) {
+        return (session.phase === "execute" &&
+            session.completedActions.length > 0 &&
+            session.errors.filter((e) => e.phase === "execute").length === 0);
+    }
+    /**
+     * Check if the session should trigger recovery
+     */
+    static shouldRecover(session) {
+        return (session.phase === "verify" &&
+            session.errors.filter((e) => e.phase === "verify").length > 0);
+    }
+    /**
+     * Check if the session can switch models
+     */
+    static canSwitchModel(session) {
+        return session.status === "running" && session.phase !== "complete";
+    }
+    /**
+     * Calculate the estimated number of remaining turns
+     */
+    static estimateRemainingTurns(session) {
+        const { phase, plan, completedActions, errors } = session;
+        if (phase === "complete")
+            return 0;
+        if (phase === "understand")
+            return 5; // understand → inspect → plan → execute → verify
+        if (phase === "inspect")
+            return 4; // inspect → plan → execute → verify
+        if (phase === "plan")
+            return 3; // plan → execute → verify
+        if (phase === "execute") {
+            const remaining = (plan?.estimatedActions || 5) - completedActions.length;
+            return Math.max(remaining + 1, 2); // execute → verify
+        }
+        if (phase === "verify") {
+            if (errors.length > 0)
+                return 3; // verify → recover → verify
+            return 1; // verify → complete
+        }
+        if (phase === "recover")
+            return 2; // recover → verify
+        return 5;
+    }
+}
+exports.AgentStateMachine = AgentStateMachine;