@lasso-ai/cli 1.1.5 → 1.2.1

package/CHANGELOG.md

@@ -9,6 +9,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **One-shot mode with global command bar**: Press ⌘K to open a command interface
+  anywhere in your app. Describe what you want to build (e.g., "Build a complete billing
+  system with invoices and payment tracking") and Lasso will plan, execute, and
+  validate the changes automatically. The agent runs through understand → plan →
+  execute → validate, with real-time progress visibility.
+- **`lasso create` command**: Create brand-new Lasso projects with framework scaffolding.
+  Supports Next.js, React, Vue, Svelte, and Solid with TypeScript and package manager
+  selection. Optionally describe your app during creation to trigger one-shot mode
+  automatically.
+- **`lasso doctor` command**: Diagnose configuration and integration problems.
+  Checks for `lasso.config.json`, API key configuration, framework detection, and
+  package.json presence.
+- **Scope management**: One-shot mode supports project-level (broad changes across
+  entire codebase) and component-level (targeted changes) scopes to prevent agents
+  from wandering through unrelated files.
 - **Agent task workflow**: concurrent prompts now appear in In progress and
   Completed tabs. Review-ready tasks expose a Review action, and accepted changes
   move the task to Completed.

package/README.md

@@ -78,6 +78,25 @@ Lasso works differently.
 
 ## Features
 
+### Two interaction modes
+
+Lasso now supports two equally powerful ways to build:
+
+**Visual Mode** (point-and-select)
+- Select a component in your running app
+- Describe the change you want
+- Review the diff
+- Accept to apply
+
+**One-Shot Mode** (⌘K command bar)
+- Press ⌘K anywhere to open the command bar
+- Describe what you want to build (e.g., "Build a complete billing system")
+- Lasso plans, executes, and validates automatically
+- Real-time progress visibility as the agent works
+
+These modes work together naturally: use one-shot to generate large features, then
+visual mode to refine specific parts.
+
 ### Visual selection
 
 Turn on Lasso Mode and interact with your application normally.
@@ -87,6 +106,17 @@ Turn on Lasso Mode and interact with your application normally.
 - Hover to see what will be selected
 - Select empty space to insert new UI
 
+### One-shot agent
+
+The one-shot agent follows a plan-execute-validate loop:
+
+1. **Understand**: Analyzes project structure, framework, and dependencies
+2. **Plan**: Generates execution steps (install, create, modify, delete, command)
+3. **Execute**: Runs each step with real-time progress updates
+4. **Validate**: Runs typecheck and build to verify changes
+
+Progress is visible throughout: "Step 1/5: Creating auth configuration", "Step 2/5: Adding login page", etc.
+
 ### Overlay toolbars
 
 The overlay includes a primary editing toolbar and a compact secondary toolbar.
@@ -333,6 +363,33 @@ and set `LASSO_API_KEY` — see [Team collaboration](#team-collaboration-realtim
 
 Your existing configuration files are **not modified**.
 
+### 2a. Create a new project
+
+Starting from scratch? Lasso can scaffold a new project for you:
+
+```bash
+lasso create my-app
+```
+
+You'll be prompted to choose:
+- Framework (Next.js, React, Vue, Svelte, Solid)
+- TypeScript preference
+- Package manager (pnpm, npm, yarn)
+
+Lasso then:
+- Creates the application scaffold
+- Installs dependencies
+- Connects Lasso automatically
+- Registers the project
+
+Optionally describe your app during creation to trigger one-shot mode:
+
+```bash
+lasso create my-app --prompt "A SaaS dashboard for managing customer invoices with billing and analytics"
+```
+
+Or describe it interactively after the scaffold is complete.
+
 ### 3. Select something
 
 Enable **Lasso Mode** from the floating toolbar.

package/dist/cli/agent.js

@@ -659,7 +659,7 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress, taskI
     });
 }
 async function proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress, taskId, onPrompt) {
-    const outputContract = `Return ONLY valid JSON in this exact shape: {"summary":"short explanation","changes":[{"filePath":"relative/path","oldString":"exact existing text","newString":"replacement text"}]}. Treat the supplied source context as read-only. Before returning, verify every oldString against that context. Use project-relative paths only. Do not edit files, run write commands, commit, or produce markdown fences.`;
+    const outputContract = `CRITICAL: You MUST return ONLY valid JSON with actual file changes. NEVER explain, describe, or analyze code without proposing edits. ALWAYS return JSON with at least one change when given a modification instruction. Format: {"summary":"brief action taken","changes":[{"filePath":"relative/path","oldString":"exact existing text","newString":"replacement text"}]}. Treat the supplied source context as read-only. Before returning, verify every oldString against that context. Use project-relative paths only. Do not edit files, run write commands, commit, or produce markdown fences. If you cannot find the exact text to change, search the provided context more carefully - do not give up and explain instead.`;
     const prompt = `${instruction}\n\n${outputContract}\n\nLasso has already assembled this source context:\n${context || "No matching source context was found."}`;
     const local = localCommand(config.provider, config.model, prompt);
     const command = local.command;
@@ -677,11 +677,11 @@ async function proposeChanges(cwd, input, config, signal, onProgress, onPrompt)
     const dragHint = input.context?.drag
         ? `\n\nDRAG REPOSITIONING TASK:\nThe user dragged this element by dx: ${input.context.drag.delta?.dx ?? 0}px, dy: ${input.context.drag.delta?.dy ?? 0}px to target coordinates (left: ${input.context.drag.targetRect?.left ?? 0}px, top: ${input.context.drag.targetRect?.top ?? 0}px). Modify the source code (CSS classes, Tailwind classes, flex/grid alignment, margin offsets, or positioning properties) so the element is accurately rendered at this target position.`
         : "";
-    const instruction = `Selection context:\n${JSON.stringify(input.element, null, 2)}\n${JSON.stringify(visualContext, null, 2)}\n\nConversation history:\n${history}\n\nPrevious change history for this selection:\n${priorChanges}\n\nRelevant source context:\n${context || "No matching source context was found. Ask for a more specific selection rather than inventing a file."}${dragHint}\n\nReturn ONLY JSON: {"summary":"short explanation","changes":[{"filePath":"relative/path","oldString":"exact text","newString":"replacement text"}]}`;
+    const instruction = `Selection context:\n${JSON.stringify(input.element, null, 2)}\n${JSON.stringify(visualContext, null, 2)}\n\nConversation history:\n${history}\n\nPrevious change history for this selection:\n${priorChanges}\n\nRelevant source context:\n${context || "No matching source context was found. Ask for a more specific selection rather than inventing a file."}${dragHint}\n\nCRITICAL: You MUST return ONLY JSON with actual file changes. Do NOT explain what you see or describe the code. Always propose concrete edits when given an instruction. Return JSON format: {"summary":"brief action taken","changes":[{"filePath":"relative/path","oldString":"exact existing text","newString":"replacement text"}]}`;
     if (config.provider === "claude-code" || config.provider === "codex" || config.provider === "opencode") {
         return proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress, input.taskId, onPrompt);
     }
-    const system = "You are Lasso, a careful source-code editing agent. Return only valid JSON. Each oldString must occur exactly once in its file. Never rewrite whole files. Keep changes focused on the request.";
+    const system = "You are Lasso, a source-code editing agent. Your ONLY job is to propose concrete file changes. NEVER explain, describe, or analyze code without proposing edits. ALWAYS return valid JSON with at least one change when the user requests a modification. Each oldString must occur exactly once in its file. Never rewrite whole files. Keep changes focused and minimal. If you cannot find the exact text to change, look harder at the provided context - do not give up and explain instead.";
     const model = config.model || (config.provider === "google" ? "gemini-2.5-flash" : config.provider === "openai" ? "gpt-4.1-mini" : config.provider === "ollama" ? "llama3.2" : "claude-sonnet-4-20250514");
     const image = input.context?.screenshots?.element || input.context?.screenshots?.full;
     const imageData = image?.replace(/^data:image\/[^;]+;base64,/, "");

package/dist/cli/bridge.d.ts

@@ -131,6 +131,12 @@ export type BridgeMessage = {
     audio: string;
     mimeType?: string;
     language?: string;
+} | {
+    type: "oneshot";
+    prompt: string;
+    scope: "project" | "component";
+    model?: string;
+    provider?: "anthropic" | "openai" | "google" | "ollama" | "cli";
 };
 type ModelOption = {
     id: string;

package/dist/cli/bridge.js

@@ -598,6 +598,49 @@ function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = expo
                     }));
                 }
             }
+            else if (msg.type === "oneshot") {
+                console.log("[lasso] one-shot request:", msg.prompt, msg.scope);
+                if (!lassoKeyConfigured && !agentConfig) {
+                    socket.send(JSON.stringify({ type: "agent_status", status: "error", message: "Set your Lasso API key or configure an AI provider before using one-shot mode." }));
+                    return;
+                }
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : "codex";
+                const selectedConfig = localProvider
+                    ? { provider: cliProvider, model: msg.model || "claude-code:sonnet" }
+                    : { ...agentConfig, provider: (msg.provider || agentConfig.provider), model: msg.model || agentConfig.model };
+                const taskId = `oneshot-${Date.now()}`;
+                const controller = new AbortController();
+                taskControllers.set(taskId, controller);
+                socket.send(JSON.stringify({ type: "agent_status", taskId, status: "thinking", message: "Planning your request..." }));
+                // Import the one-shot agent function
+                const { runOneShotAgent } = await import("./oneshot.js");
+                runOneShotAgent(cwd, msg.prompt, msg.scope, selectedConfig, controller.signal, (status, message, detail) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status, message, detail }));
+                    }
+                }, (prompt) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_prompt", taskId, prompt }));
+                    }
+                }).then((result) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        if (result.ok) {
+                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "review", message: result.summary, changes: result.changes }));
+                        }
+                        else {
+                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: result.error || "One-shot agent failed" }));
+                        }
+                    }
+                }).catch((error) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "One-shot agent encountered an error" }));
+                    }
+                }).finally(() => {
+                    if (taskControllers.get(taskId) === controller)
+                        taskControllers.delete(taskId);
+                });
+            }
             else if (msg.type === "apply") {
                 try {
                     const snapshots = [];

package/dist/cli/create.d.ts

@@ -0,0 +1,16 @@
+export type Framework = "next" | "react" | "vue" | "svelte" | "solid";
+export type PackageManager = "pnpm" | "npm" | "yarn";
+interface CreateOptions {
+    name?: string;
+    framework?: Framework;
+    typescript?: boolean;
+    packageManager?: PackageManager;
+    prompt?: string;
+}
+interface CreateResult {
+    ok: boolean;
+    error?: string;
+    projectPath?: string;
+}
+export declare function createProject(options: CreateOptions): Promise<CreateResult>;
+export {};

package/dist/cli/create.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = createProject;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const project_1 = require("./project");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function detectPackageManager() {
+    const hasCommand = (cmd) => {
+        try {
+            (0, node_child_process_1.execSync)(cmd, { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (hasCommand("pnpm --version"))
+        return "pnpm";
+    if (hasCommand("yarn --version"))
+        return "yarn";
+    return "npm";
+}
+function getFrameworkCommand(framework, typescript, packageManager) {
+    const tsFlag = typescript ? "--typescript" : "--js";
+    const baseCommands = {
+        next: `npx create-next-app@latest`,
+        react: `npx create-react-app@latest`,
+        vue: `npx create-vite@latest`,
+        svelte: `npx create-svelte@latest`,
+        solid: `npx degit solidjs/templates/js`,
+    };
+    let command = baseCommands[framework];
+    if (framework === "next") {
+        command += ` ${tsFlag} --tailwind --eslint --app --src-dir --import-alias "@/*" --no-git`;
+    }
+    else if (framework === "react") {
+        command += ` ${typescript ? "--template typescript" : ""}`;
+    }
+    else if (framework === "vue") {
+        command += ` ${typescript ? "--template vue-ts" : "--template vanilla"}`;
+    }
+    else if (framework === "svelte") {
+        command += ` ${typescript ? "--template skeleton" : "--template skeleton"}`;
+    }
+    return command;
+}
+async function runCreateCommand(projectName, framework, typescript, packageManager, cwd) {
+    const projectPath = node_path_1.default.join(cwd, projectName);
+    if (node_fs_1.default.existsSync(projectPath)) {
+        return { ok: false, error: `Directory "${projectName}" already exists.` };
+    }
+    console.log(chalk_1.default.dim(`Creating ${chalk_1.default.cyan(projectName)} with ${chalk_1.default.cyan(framework)}...`));
+    try {
+        let command;
+        let args;
+        if (framework === "next") {
+            const tsFlag = typescript ? "--ts" : "--js";
+            const pmFlag = packageManager === "pnpm" ? "--use-pnpm" : packageManager === "yarn" ? "--use-yarn" : "--use-npm";
+            command = "npx";
+            args = ["create-next-app@latest", projectName, tsFlag, "--tailwind", "--eslint", "--app", "--src-dir", "--import-alias", "@/*", "--no-git", pmFlag];
+        }
+        else if (framework === "react") {
+            command = "npx";
+            args = ["create-react-app@latest", projectName, ...(typescript ? ["--template", "typescript"] : [])];
+        }
+        else if (framework === "vue") {
+            command = "npx";
+            args = ["create-vue@latest", projectName, ...(typescript ? ["--typescript"] : []), "--no-git", "--no-install"];
+        }
+        else if (framework === "svelte") {
+            command = "npx";
+            args = ["create-svelte@latest", projectName, ...(typescript ? ["--types", "typescript"] : ["--types", "checkjs"]), "--no-eslint", "--no-prettier", "--no-playwright", "--no-vitest", "--template", "skeleton"];
+        }
+        else if (framework === "solid") {
+            command = "npx";
+            args = ["degit", `solidjs/templates/${typescript ? "ts" : "js"}`, projectName];
+        }
+        else {
+            return { ok: false, error: `Unsupported framework: ${framework}` };
+        }
+        await new Promise((resolve, reject) => {
+            const proc = (0, node_child_process_1.spawn)(command, args, { cwd, stdio: "inherit" });
+            proc.on("close", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Command exited with code ${code}`));
+            });
+        });
+        if (framework === "vue" || framework === "svelte") {
+            console.log(chalk_1.default.dim(`Installing dependencies with ${chalk_1.default.cyan(packageManager)}...`));
+            const installCommand = packageManager === "pnpm" ? "pnpm" : packageManager === "yarn" ? "yarn" : "npm";
+            const installArgs = packageManager === "pnpm" ? ["install"] : packageManager === "yarn" ? [] : ["install"];
+            await new Promise((resolve, reject) => {
+                const proc = (0, node_child_process_1.spawn)(installCommand, installArgs, { cwd: projectPath, stdio: "inherit" });
+                proc.on("close", (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`Install command exited with code ${code}`));
+                });
+            });
+        }
+        return { ok: true, projectPath };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "unknown error";
+        return { ok: false, error: `Failed to create project: ${reason}` };
+    }
+}
+async function createProject(options) {
+    const cwd = process.cwd();
+    let { name, framework, typescript, packageManager } = options;
+    if (!name) {
+        const response = await (0, prompts_1.default)({
+            type: "text",
+            name: "name",
+            message: "Project name:",
+            initial: "my-app",
+            validate: (value) => {
+                if (!value.trim())
+                    return "Project name is required";
+                if (!/^[a-z0-9-]+$/.test(value))
+                    return "Project name must contain only lowercase letters, numbers, and hyphens";
+                return true;
+            },
+        });
+        name = response.name;
+    }
+    if (!name) {
+        return { ok: false, error: "Project name is required" };
+    }
+    if (!framework) {
+        const response = await (0, prompts_1.default)({
+            type: "select",
+            name: "framework",
+            message: "Choose a framework:",
+            choices: [
+                { title: "Next.js", value: "next" },
+                { title: "React", value: "react" },
+                { title: "Vue", value: "vue" },
+                { title: "Svelte", value: "svelte" },
+                { title: "Solid", value: "solid" },
+            ],
+        });
+        framework = response.framework;
+    }
+    if (!framework) {
+        return { ok: false, error: "Framework selection is required" };
+    }
+    if (typescript === undefined) {
+        const response = await (0, prompts_1.default)({
+            type: "select",
+            name: "typescript",
+            message: "Use TypeScript?",
+            choices: [
+                { title: "Yes", value: true },
+                { title: "No", value: false },
+            ],
+        });
+        typescript = response.typescript;
+    }
+    if (typescript === undefined) {
+        typescript = true;
+    }
+    if (!packageManager) {
+        const detected = await detectPackageManager();
+        const choices = [
+            { title: "pnpm", value: "pnpm" },
+            { title: "npm", value: "npm" },
+            { title: "yarn", value: "yarn" },
+        ];
+        const response = await (0, prompts_1.default)({
+            type: "select",
+            name: "packageManager",
+            message: "Package manager:",
+            choices,
+            initial: Math.max(0, choices.findIndex((c) => c.value === detected)),
+        });
+        packageManager = response.packageManager;
+    }
+    if (!packageManager) {
+        packageManager = "npm";
+    }
+    const createResult = await runCreateCommand(name, framework, typescript, packageManager, cwd);
+    if (!createResult.ok) {
+        return createResult;
+    }
+    const projectPath = createResult.projectPath;
+    console.log(chalk_1.default.green("✓") + " Created application");
+    console.log(chalk_1.default.green("✓") + " Installed dependencies");
+    const fileEnv = (0, project_1.readProjectEnv)(projectPath);
+    const initResult = await (0, project_1.initProject)(projectPath, fileEnv);
+    if (!initResult.ok) {
+        console.error(chalk_1.default.yellow("!") + ` Could not initialize Lasso: ${initResult.error}`);
+        console.log(chalk_1.default.dim(`Run ${chalk_1.default.cyan("lasso init")} in the project directory to complete setup.`));
+        return { ok: true, projectPath };
+    }
+    console.log(chalk_1.default.green("✓") + " Connected Lasso");
+    console.log(chalk_1.default.green("✓") + " Registered project");
+    // Ask if user wants to describe their app for one-shot building
+    if (!options.prompt) {
+        const describeResponse = await (0, prompts_1.default)({
+            type: "select",
+            name: "describe",
+            message: "Do you want to describe your app for Lasso to build initial features?",
+            choices: [
+                { title: "Yes, describe my app", value: true },
+                { title: "No, I'll start from scratch", value: false },
+            ],
+        });
+        if (describeResponse.describe) {
+            const promptResponse = await (0, prompts_1.default)({
+                type: "text",
+                name: "appPrompt",
+                message: "Describe what you're building (e.g., A SaaS dashboard for managing customer invoices with billing and analytics):",
+                validate: (value) => {
+                    if (!value.trim())
+                        return "Please describe your app";
+                    return true;
+                },
+            });
+            if (promptResponse.appPrompt) {
+                options.prompt = promptResponse.appPrompt;
+            }
+        }
+    }
+    if (options.prompt) {
+        console.log("");
+        console.log(chalk_1.default.dim(`✦ Lasso will build: ${chalk_1.default.cyan(options.prompt)}`));
+        console.log(chalk_1.default.dim(`  Open your app and press ${chalk_1.default.cyan("⌘K")} to track progress.`));
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("Your app is ready!"));
+    console.log("");
+    console.log(chalk_1.default.dim(`Next steps:`));
+    console.log(chalk_1.default.dim(`  cd ${chalk_1.default.cyan(name)}`));
+    console.log(chalk_1.default.dim(`  ${chalk_1.default.cyan("lasso dev")}`));
+    if (options.prompt) {
+        console.log(chalk_1.default.dim(`  Then use ${chalk_1.default.cyan("⌘K")} to trigger one-shot mode`));
+    }
+    console.log("");
+    console.log(chalk_1.default.dim(`Your app will be available at ${chalk_1.default.cyan("http://localhost:3000")}`));
+    return { ok: true, projectPath };
+}

package/dist/cli/index.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const bridge_1 = require("./bridge");
@@ -20,6 +21,7 @@ const install_1 = require("./host/install");
 const client_1 = require("./host/client");
 const registry_1 = require("./host/registry");
 const next_config_1 = require("./next-config");
+const create_1 = require("./create");
 const package_json_1 = __importDefault(require("../../package.json"));
 const VERSION = package_json_1.default.version;
 const program = new commander_1.Command();
@@ -81,6 +83,17 @@ program.command("init")
     console.log(chalk_1.default.dim(`  ${project_1.LASSO_CONFIG_FILE} — commit it so teammates share this project.`));
 });
 // prettier-ignore
+program.command("create [name]")
+    .description("Create a brand-new Lasso project with a framework scaffold")
+    .option("--prompt <prompt>", "Describe your app for one-shot building")
+    .action(async (name, options) => {
+    const result = await (0, create_1.createProject)({ name, prompt: options.prompt });
+    if (!result.ok) {
+        console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+        process.exit(1);
+    }
+});
+// prettier-ignore
 const daemon = program.command("daemon [action]")
     .description("Start/stop Lasso Host — the local .lasso domain server (start|status|stop|restart|install|uninstall)")
     .usage("[action]")
@@ -353,6 +366,57 @@ auth.command("logout").description("Remove the Lasso credential from this machin
     console.log(chalk_1.default.green("✓") + " Signed out. Revoke the key from the dashboard if you no longer need it.");
 });
 // prettier-ignore
+program.command("doctor")
+    .description("Diagnose configuration and integration problems")
+    .action(async () => {
+    const cwd = process.cwd();
+    console.log(chalk_1.default.bold("Lasso Doctor"));
+    console.log("");
+    // Check for lasso.config.json
+    const configPath = node_path_1.default.join(cwd, project_1.LASSO_CONFIG_FILE);
+    if (node_fs_1.default.existsSync(configPath)) {
+        console.log(chalk_1.default.green("✓") + ` ${project_1.LASSO_CONFIG_FILE} exists`);
+        try {
+            const config = JSON.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+            console.log(chalk_1.default.dim(`  Project ID: ${config.id}`));
+            if (config.domain)
+                console.log(chalk_1.default.dim(`  Domain: ${config.domain}`));
+        }
+        catch {
+            console.log(chalk_1.default.red("✗") + ` ${project_1.LASSO_CONFIG_FILE} is invalid`);
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow("!") + ` ${project_1.LASSO_CONFIG_FILE} not found. Run ${chalk_1.default.cyan("lasso init")} to create it.`);
+    }
+    // Check for API key
+    const credentials = (0, auth_1.loadCredentials)();
+    if (credentials) {
+        console.log(chalk_1.default.green("✓") + " Lasso API key configured");
+    }
+    else {
+        console.log(chalk_1.default.yellow("!") + " No Lasso API key found. Run " + chalk_1.default.cyan("lasso auth login"));
+    }
+    // Check framework
+    const framework = (0, framework_1.detectFramework)(cwd);
+    if (framework !== "unknown") {
+        console.log(chalk_1.default.green("✓") + ` Detected framework: ${framework}`);
+    }
+    else {
+        console.log(chalk_1.default.yellow("!") + " Could not detect a supported framework");
+    }
+    // Check package.json
+    const pkgPath = node_path_1.default.join(cwd, "package.json");
+    if (node_fs_1.default.existsSync(pkgPath)) {
+        console.log(chalk_1.default.green("✓") + " package.json exists");
+    }
+    else {
+        console.log(chalk_1.default.red("✗") + " package.json not found");
+    }
+    console.log("");
+    console.log(chalk_1.default.dim("Run ") + chalk_1.default.cyan("lasso dev") + chalk_1.default.dim(" to start development with Lasso."));
+});
+// prettier-ignore
 program.command("dev", { isDefault: true }).description("Start your dev server with the Lasso overlay attached").action(async () => {
     const cwd = process.cwd();
     const framework = (0, framework_1.detectFramework)(cwd);

package/dist/cli/oneshot.d.ts

@@ -0,0 +1,17 @@
+import type { AgentConfig, SourceChange } from "./agent";
+export interface OneShotResult {
+    ok: boolean;
+    summary?: string;
+    changes?: SourceChange[];
+    error?: string;
+}
+export interface ProgressCallback {
+    (status: "thinking" | "working" | "review" | "error" | "stopped", message: string, detail?: string): void;
+}
+export interface PromptCallback {
+    (prompt: {
+        question: string;
+        options?: string[];
+    }): void;
+}
+export declare function runOneShotAgent(cwd: string, prompt: string, scope: "project" | "component", config: AgentConfig, signal: AbortSignal, onProgress: ProgressCallback, onPrompt: PromptCallback): Promise<OneShotResult>;