@lasso-ai/cli 1.1.5 → 1.2.0

package/dist/cli/oneshot.js

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOneShotAgent = runOneShotAgent;
+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 execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, onPrompt) {
+    try {
+        if (signal.aborted) {
+            return { ok: false, error: "Operation was cancelled" };
+        }
+        // Phase 1: Understand & Plan
+        onProgress("thinking", "Analyzing project structure...", "Scanning files and dependencies");
+        const projectStructure = await analyzeProject(cwd);
+        const framework = detectFramework(cwd);
+        onProgress("thinking", "Planning implementation...", `Detected ${framework} framework`);
+        // Phase 2: Generate execution plan
+        const plan = await generatePlan(prompt, scope, projectStructure, framework, config, signal);
+        if (signal.aborted) {
+            return { ok: false, error: "Operation was cancelled during planning" };
+        }
+        onProgress("thinking", "Execution plan ready", `${plan.steps.length} steps identified`);
+        // Phase 3: Execute plan step by step
+        const allChanges = [];
+        for (let i = 0; i < plan.steps.length; i++) {
+            if (signal.aborted) {
+                return { ok: false, error: "Operation was cancelled during execution" };
+            }
+            const step = plan.steps[i];
+            onProgress("working", `Step ${i + 1}/${plan.steps.length}: ${step.description}`, step.detail || "");
+            const stepResult = await executeStep(cwd, step, config, signal, onProgress, onPrompt);
+            if (!stepResult.ok) {
+                return { ok: false, error: `Failed at step ${i + 1}: ${stepResult.error}` };
+            }
+            if (stepResult.changes) {
+                allChanges.push(...stepResult.changes);
+            }
+            onProgress("working", `Step ${i + 1}/${plan.steps.length} complete`, step.description);
+        }
+        // Phase 4: Validate
+        onProgress("working", "Validating changes...", "Running typecheck and build");
+        const validationResult = await validateChanges(cwd, framework);
+        if (!validationResult.ok) {
+            onProgress("error", "Validation failed", validationResult.error);
+            // Still return the changes for review, but flag the error
+            return {
+                ok: true,
+                summary: `Completed with validation warnings: ${validationResult.error}`,
+                changes: allChanges
+            };
+        }
+        onProgress("review", "Implementation complete", `${allChanges.length} files modified`);
+        return {
+            ok: true,
+            summary: `Successfully implemented: ${prompt}`,
+            changes: allChanges,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "Unknown error";
+        return { ok: false, error: `One-shot agent failed: ${reason}` };
+    }
+}
+async function analyzeProject(cwd) {
+    const pkgPath = node_path_1.default.join(cwd, "package.json");
+    const pkg = node_fs_1.default.existsSync(pkgPath) ? JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf8")) : {};
+    const dependencies = Object.keys(pkg.dependencies || {});
+    const devDependencies = Object.keys(pkg.devDependencies || {});
+    const hasTypeScript = dependencies.includes("typescript") || devDependencies.includes("typescript") || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json"));
+    const hasTailwind = dependencies.includes("tailwindcss") || devDependencies.includes("tailwindcss");
+    const hasReact = dependencies.includes("react") || devDependencies.includes("react");
+    const hasNext = dependencies.includes("next") || devDependencies.includes("next");
+    const hasVite = dependencies.includes("vite") || devDependencies.includes("vite");
+    // Scan src directory
+    const files = [];
+    const srcPath = node_path_1.default.join(cwd, "src");
+    if (node_fs_1.default.existsSync(srcPath)) {
+        const scanDir = (dir, base = "") => {
+            const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+                    scanDir(node_path_1.default.join(dir, entry.name), node_path_1.default.join(base, entry.name));
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".js") || entry.name.endsWith(".jsx"))) {
+                    files.push(node_path_1.default.join(base, entry.name));
+                }
+            }
+        };
+        scanDir(srcPath);
+    }
+    return {
+        framework: detectFramework(cwd),
+        hasTypeScript,
+        hasTailwind,
+        hasReact,
+        hasNext,
+        hasVite,
+        dependencies,
+        devDependencies,
+        files,
+    };
+}
+function detectFramework(cwd) {
+    const pkgPath = node_path_1.default.join(cwd, "package.json");
+    if (node_fs_1.default.existsSync(pkgPath)) {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.next)
+            return "next";
+        if (deps.vite)
+            return "vite";
+        if (deps.react)
+            return "react";
+    }
+    return "unknown";
+}
+async function generatePlan(prompt, scope, structure, framework, config, signal) {
+    // For now, return a simple plan. In a real implementation, this would use the LLM
+    // to analyze the prompt and generate a detailed execution plan.
+    const steps = [];
+    // This is a placeholder - in production, this would call the LLM to generate
+    // a detailed plan based on the user's prompt
+    steps.push({
+        description: "Analyze requirements",
+        detail: "Understanding what needs to be built",
+        type: "command",
+        command: "echo 'Planning phase'",
+    });
+    return { steps };
+}
+async function executeStep(cwd, step, config, signal, onProgress, onPrompt) {
+    if (signal.aborted) {
+        return { ok: false, error: "Cancelled" };
+    }
+    switch (step.type) {
+        case "install":
+            if (step.target) {
+                await execAsync(`npm install ${step.target}`, { cwd });
+            }
+            return { ok: true };
+        case "create":
+            if (step.target && step.content) {
+                const filePath = node_path_1.default.join(cwd, step.target);
+                const dir = node_path_1.default.dirname(filePath);
+                node_fs_1.default.mkdirSync(dir, { recursive: true });
+                node_fs_1.default.writeFileSync(filePath, step.content, "utf8");
+                return {
+                    ok: true,
+                    changes: [{
+                            filePath: step.target,
+                            oldString: "",
+                            newString: step.content,
+                        }]
+                };
+            }
+            return { ok: false, error: "Missing target or content for create step" };
+        case "modify":
+            if (step.target && step.content) {
+                const filePath = node_path_1.default.join(cwd, step.target);
+                if (node_fs_1.default.existsSync(filePath)) {
+                    const oldContent = node_fs_1.default.readFileSync(filePath, "utf8");
+                    node_fs_1.default.writeFileSync(filePath, step.content, "utf8");
+                    return {
+                        ok: true,
+                        changes: [{
+                                filePath: step.target,
+                                oldString: oldContent,
+                                newString: step.content,
+                            }]
+                    };
+                }
+                return { ok: false, error: `File not found: ${step.target}` };
+            }
+            return { ok: false, error: "Missing target or content for modify step" };
+        case "delete":
+            if (step.target) {
+                const filePath = node_path_1.default.join(cwd, step.target);
+                if (node_fs_1.default.existsSync(filePath)) {
+                    node_fs_1.default.unlinkSync(filePath);
+                    return { ok: true };
+                }
+            }
+            return { ok: true }; // Don't fail if file doesn't exist
+        case "command":
+            if (step.command) {
+                await execAsync(step.command, { cwd });
+                return { ok: true };
+            }
+            return { ok: false, error: "Missing command for command step" };
+        default:
+            return { ok: false, error: `Unknown step type: ${step.type}` };
+    }
+}
+async function validateChanges(cwd, framework) {
+    try {
+        // Run typecheck if TypeScript is available
+        if (node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json"))) {
+            try {
+                await execAsync("npx tsc --noEmit", { cwd, timeout: 30000 });
+            }
+            catch (error) {
+                return { ok: false, error: "TypeScript typecheck failed" };
+            }
+        }
+        // Run build if applicable
+        if (framework === "next") {
+            try {
+                await execAsync("npx next build", { cwd, timeout: 120000 });
+            }
+            catch (error) {
+                return { ok: false, error: "Next.js build failed" };
+            }
+        }
+        else if (framework === "vite") {
+            try {
+                await execAsync("npm run build", { cwd, timeout: 120000 });
+            }
+            catch (error) {
+                return { ok: false, error: "Vite build failed" };
+            }
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "Unknown validation error";
+        return { ok: false, error: reason };
+    }
+}

package/dist/cli/server/next.js

@@ -12,8 +12,8 @@ const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
 const PUBLIC_PORT = 3000; // what the user opens in the browser
 const INTERNAL_PORT = 3055; // where the real `next dev` actually runs
-function serveOverlayBundle(res) {
-    const bundlePath = (0, node_path_1.resolve)(process.cwd(), "node_modules/lasso/dist/overlay.js");
+function serveOverlayBundle(res, cwd) {
+    const bundlePath = (0, node_path_1.resolve)(cwd, "node_modules/lasso/dist/overlay.js");
     // when running from within the Lasso repo itself (not yet published),
     // this resolves relative to Lasso's own dist folder instead — adjust
     // the path to point at your actual dist/overlay.js location for now.
@@ -55,7 +55,7 @@ async function startNextServer(cwd) {
     //    proxy everything else through to Next
     const server = node_http_1.default.createServer((req, res) => {
         if (req.url === "/__lasso/overlay.js") {
-            serveOverlayBundle(res);
+            serveOverlayBundle(res, cwd);
             return;
         }
         proxy.web(req, res, { headers: { "accept-encoding": "identity" } }, (err) => {

package/dist/cli/server/vite.js

@@ -14,7 +14,7 @@ const node_module_1 = require("node:module");
 // console.log("[lasso] overlay placeholder loaded");
 // alert("Lasso overlay injected successfully!");
 // `;
-function lassoInjectPlugin(bridgePort = 3056) {
+function lassoInjectPlugin(bridgePort = 3056, cwd) {
     return {
         name: "lasso-inject",
         transformIndexHtml(html) {
@@ -22,7 +22,7 @@ function lassoInjectPlugin(bridgePort = 3056) {
         },
         configureServer(server) {
             server.middlewares.use("/__lasso/overlay.js", (req, res) => {
-                const bundlePath = (0, node_path_2.resolve)(process.cwd(), "node_modules/lasso/dist/overlay.js");
+                const bundlePath = (0, node_path_2.resolve)(cwd, "node_modules/lasso/dist/overlay.js");
                 res.setHeader("Content-Type", "application/javascript");
                 res.end((0, node_fs_1.readFileSync)(bundlePath, "utf-8"));
             });
@@ -42,7 +42,7 @@ async function startViteServer(cwd) {
     const server = await createServer({
         root: cwd,
         server: { open: false },
-        plugins: [lassoInjectPlugin()],
+        plugins: [lassoInjectPlugin(3056, cwd)],
     });
     await server.listen();
     console.log(chalk_1.default.green("✓") + " Vite dev server running with Lasso attached");