slapify 0.0.14 → 0.0.16

package/dist/cli.js

@@ -427,6 +427,7 @@ program
     .option("--credentials <profile>", "Default credentials profile to use")
     .option("-p, --parallel", "Run tests in parallel")
     .option("-w, --workers <n>", "Number of parallel workers (default: 4)", "4")
+    .option("--performance", "Run performance audit (scores, real-user metrics, framework & re-render analysis) and include in report")
     .action(async (files, options) => {
     try {
         // Load configuration
@@ -574,12 +575,28 @@ program
                             console.log(chalk.red(`    └─ ${stepResult.error}`));
                         }
                         // Show assumptions if any
-                        if (stepResult.assumptions && stepResult.assumptions.length > 0) {
+                        if (stepResult.assumptions &&
+                            stepResult.assumptions.length > 0) {
                             for (const assumption of stepResult.assumptions) {
                                 console.log(chalk.gray(`    └─ 💡 ${assumption}`));
                             }
                         }
-                    });
+                    }, !!options.performance);
+                    // Show perf summary inline if audit was run
+                    if (result.perfAudit) {
+                        const p = result.perfAudit;
+                        const parts = [];
+                        if (p.vitals.fcp)
+                            parts.push(`FCP ${p.vitals.fcp}ms`);
+                        if (p.vitals.lcp)
+                            parts.push(`LCP ${p.vitals.lcp}ms`);
+                        if (p.vitals.cls != null)
+                            parts.push(`CLS ${p.vitals.cls}`);
+                        const s = p.scores ?? p.lighthouse;
+                        if (s)
+                            parts.push(`Perf ${s.performance}/100`);
+                        console.log(chalk.cyan(`  ⚡ Perf: ${parts.join(" · ")}`));
+                    }
                     results.push(result);
                     // Print test summary
                     console.log("");
@@ -693,9 +710,9 @@ program
 program
     .command("generate <prompt>")
     .alias("gen")
-    .description("Generate a flow file from a natural language prompt")
+    .description("Generate a verified .flow file by running the goal as a task and recording what worked")
     .option("-d, --dir <directory>", "Directory to save flow", "tests")
-    .option("--headed", "Show browser while analyzing")
+    .option("--headed", "Show browser window while running")
     .action(async (prompt, options) => {
     const configDir = getConfigDir();
     if (!configDir) {
@@ -703,156 +720,42 @@ program
         process.exit(1);
     }
     const config = loadConfig(configDir);
-    const readline = await import("readline");
-    console.log(chalk.blue("\n🤖 AI Flow Generator\n"));
-    // Step 1: Extract URL from prompt using AI
-    let spinner = ora("Analyzing prompt...").start();
-    const urlResponse = await generateText({
-        model: getModelFromConfig(config.llm),
-        prompt: `Extract the URL from this test request. If there's no URL mentioned, respond with "NO_URL".
-      
-Request: "${prompt}"
-
-Respond with ONLY the URL (e.g., https://example.com) or "NO_URL". Nothing else.`,
-        maxTokens: 100,
-    });
-    let url = urlResponse.text.trim();
-    spinner.stop();
-    // Step 2: If no URL, ask user
-    if (url === "NO_URL" || !url.startsWith("http")) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        url = await new Promise((resolve) => {
-            rl.question(chalk.cyan("Enter the URL to test: "), (answer) => {
-                rl.close();
-                resolve(answer.trim());
-            });
-        });
-        if (!url) {
-            console.log(chalk.red("No URL provided. Aborting."));
-            process.exit(1);
-        }
-    }
-    console.log(chalk.gray(`URL: ${url}\n`));
-    // Step 3: Open browser and get page snapshot
-    spinner = ora("Opening browser and analyzing page...").start();
-    const browser = new BrowserAgent({
-        ...config.browser,
-        headless: !options.headed,
+    console.log(chalk.blue("\n🤖 Flow Generator\n"));
+    console.log(chalk.gray("  Running the goal in the browser to discover the real path...\n"));
+    // Delegate to the task agent with save-flow enabled.
+    // The agent actually executes every step, handles login/captcha/popups,
+    // and writes only steps that are proven to work.
+    const { runTask } = await import("./task/runner.js");
+    let savedPath;
+    await runTask({
+        goal: prompt,
+        headed: options.headed,
+        saveFlow: true,
+        flowOutputDir: options.dir,
+        onEvent: (event) => {
+            if (event.type === "status_update") {
+                process.stdout.write(chalk.gray(`  → ${event.message}\n`));
+            }
+            if (event.type === "message") {
+                console.log(chalk.white(`\n${event.text}`));
+            }
+            if (event.type === "flow_saved") {
+                savedPath = event.path;
+            }
+            if (event.type === "done") {
+                console.log(chalk.green(`\n✅ Done`));
+            }
+            if (event.type === "error") {
+                console.log(chalk.red(`\n✗ ${event.error}`));
+            }
+        },
     });
-    try {
-        await browser.navigate(url);
-        await browser.wait(2000); // Wait for page to load
-        const snapshot = await browser.snapshot(true);
-        const pageTitle = await browser.getTitle();
-        spinner.succeed("Page analyzed");
-        // Step 4: Generate test steps using AI
-        spinner = ora("Generating test steps...").start();
-        const generationResponse = await generateText({
-            model: getModelFromConfig(config.llm),
-            system: `You are a test automation expert. Generate clear, actionable test steps for a .flow file.
-
-Rules:
-- Each step should be a single action or verification
-- Use natural language that describes WHAT to do, not HOW
-- Include [Optional] prefix for steps that might not always apply (popups, banners)
-- Include verification steps to confirm actions worked
-- Use "If X appears, do Y" for conditional handling
-- Keep steps concise but clear
-- Start with navigation to the URL
-- Generate a suitable filename (lowercase, hyphenated, no extension)
-
-Output format:
-FILENAME: suggested-name
-STEPS:
-Go to <url>
-Step 2 here
-Step 3 here
-...`,
-            prompt: `Generate test steps for this request:
-
-"${prompt}"
-
-Target URL: ${url}
-Page Title: ${pageTitle}
-
-Current page structure:
-${snapshot}
-
-Generate practical test steps that accomplish the user's goal.`,
-            maxTokens: 1500,
-        });
-        spinner.succeed("Test steps generated");
-        // Parse the response
-        const responseText = generationResponse.text;
-        const filenameMatch = responseText.match(/FILENAME:\s*(.+)/i);
-        const stepsMatch = responseText.match(/STEPS:\s*([\s\S]+)/i);
-        let filename = filenameMatch
-            ? filenameMatch[1]
-                .trim()
-                .replace(/[^a-z0-9-]/gi, "-")
-                .toLowerCase()
-            : "generated-test";
-        if (!filename.endsWith(".flow")) {
-            filename += ".flow";
-        }
-        const steps = stepsMatch
-            ? stepsMatch[1].trim()
-            : responseText.replace(/FILENAME:.+/i, "").trim();
-        // Close browser
-        await browser.close();
-        // Step 5: Show generated steps and confirm
-        console.log(chalk.blue("\n━━━ Generated Flow ━━━\n"));
-        console.log(chalk.white(steps));
-        console.log(chalk.blue("\n━━━━━━━━━━━━━━━━━━━━━━\n"));
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const confirm = await new Promise((resolve) => {
-            rl.question(chalk.cyan(`Save as ${options.dir}/${filename}? (Y/n/edit): `), (answer) => {
-                rl.close();
-                resolve(answer.trim().toLowerCase());
-            });
-        });
-        if (confirm === "n" || confirm === "no") {
-            console.log(chalk.yellow("Cancelled."));
-            return;
-        }
-        if (confirm === "e" || confirm === "edit") {
-            // Let user edit the filename
-            const rl2 = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            filename = await new Promise((resolve) => {
-                rl2.question(chalk.cyan("Filename: "), (answer) => {
-                    rl2.close();
-                    const name = answer.trim() || filename;
-                    resolve(name.endsWith(".flow") ? name : name + ".flow");
-                });
-            });
-        }
-        // Step 6: Save the file
-        const dir = options.dir;
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        const filepath = path.join(dir, filename);
-        const content = `# ${filename
-            .replace(".flow", "")
-            .replace(/-/g, " ")}\n# Generated from: ${prompt}\n\n${steps}\n`;
-        fs.writeFileSync(filepath, content);
-        console.log(chalk.green(`\n✓ Saved: ${filepath}`));
-        console.log(chalk.gray(`\nRun with: slapify run ${filepath}`));
+    if (savedPath) {
+        console.log(chalk.green(`\n✓ Flow saved: ${savedPath}`));
+        console.log(chalk.gray(`  Run with: slapify run ${savedPath}`));
     }
-    catch (error) {
-        spinner.fail("Error");
-        await browser.close();
-        console.error(chalk.red(`Error: ${error.message}`));
-        process.exit(1);
+    else {
+        console.log(chalk.yellow("\n⚠ No flow was saved. The agent may not have completed the goal."));
     }
 });
 // Fix command - analyze and fix failing tests
@@ -1312,5 +1215,340 @@ program
     };
     prompt();
 });
+// ─── Task command ─────────────────────────────────────────────────────────────
+program
+    .command("task [goal]")
+    .description("Run an autonomous AI agent task in plain English.\n" +
+    "  The agent decides everything: what to do, when to schedule, when to sleep.\n" +
+    "  Examples:\n" +
+    '    slapify task "Go to linkedin.com and like the latest 3 posts"\n' +
+    '    slapify task "Monitor my Gmail for new emails every 30 min and log subjects"\n' +
+    '    slapify task "Order breakfast from Swiggy every day at 8am"')
+    .option("--headed", "Show the browser window")
+    .option("--debug", "Show all tool calls and internal steps")
+    .option("--report", "Generate an HTML report after the task completes")
+    .option("--save-flow", "Save agent steps as a reusable .flow file when done")
+    .option("--session <id>", "Resume an existing task session")
+    .option("--list-sessions", "List all task sessions")
+    .option("--logs <id>", "Show logs for a task session")
+    .option("--max-iterations <n>", "Safety cap on agent iterations (default 200)", parseInt)
+    .action(async (goal, options) => {
+    // Sub-command: list sessions
+    if (options.listSessions) {
+        const { listSessions } = await import("./task/index.js");
+        const sessions = listSessions();
+        if (sessions.length === 0) {
+            console.log(chalk.gray("\nNo task sessions found.\n"));
+            return;
+        }
+        console.log(chalk.blue(`\n📋 Task Sessions (${sessions.length})\n`));
+        for (const s of sessions) {
+            const statusColor = s.status === "completed"
+                ? chalk.green
+                : s.status === "failed"
+                    ? chalk.red
+                    : s.status === "scheduled"
+                        ? chalk.blue
+                        : chalk.yellow;
+            console.log(`  ${statusColor("●")} ${chalk.bold(s.id)}\n` +
+                `    Goal: ${s.goal.slice(0, 70)}${s.goal.length > 70 ? "…" : ""}\n` +
+                `    Status: ${statusColor(s.status)}  Iterations: ${s.iteration}\n` +
+                `    Updated: ${new Date(s.updatedAt).toLocaleString()}\n`);
+        }
+        return;
+    }
+    // Sub-command: show logs
+    if (options.logs) {
+        const { loadSession } = await import("./task/index.js");
+        const { loadEvents } = await import("./task/session.js");
+        const session = loadSession(options.logs);
+        if (!session) {
+            console.log(chalk.red(`Session '${options.logs}' not found.`));
+            process.exit(1);
+        }
+        console.log(chalk.blue(`\n📜 Logs: ${session.id}\n`));
+        console.log(chalk.gray(`Goal: ${session.goal}\n`));
+        const events = loadEvents(options.logs);
+        for (const event of events) {
+            const ts = chalk.gray(new Date(event.ts).toLocaleTimeString());
+            if (event.type === "llm_response") {
+                if (event.text)
+                    console.log(`${ts} 🤔 ${chalk.cyan(event.text.slice(0, 120))}`);
+            }
+            else if (event.type === "tool_call") {
+                console.log(`${ts} 🔧 ${chalk.yellow(event.toolName)} → ${chalk.gray(JSON.stringify(event.result).slice(0, 80))}`);
+            }
+            else if (event.type === "tool_error") {
+                console.log(`${ts} ❌ ${chalk.red(event.toolName)} → ${chalk.red(event.error.slice(0, 80))}`);
+            }
+            else if (event.type === "memory_update") {
+                console.log(`${ts} 🧠 ${chalk.magenta("remember")} ${event.key} = ${event.value.slice(0, 60)}`);
+            }
+            else if (event.type === "scheduled") {
+                console.log(`${ts} ⏰ ${chalk.blue("schedule")} ${event.cron} — ${event.task}`);
+            }
+            else if (event.type === "sleeping_until") {
+                console.log(`${ts} 😴 ${chalk.blue("sleep")} until ${event.until}`);
+            }
+            else if (event.type === "session_end") {
+                console.log(`${ts} ✅ ${chalk.green("done")} ${event.summary.slice(0, 120)}`);
+            }
+        }
+        console.log("");
+        return;
+    }
+    // Determine goal
+    let taskGoal = goal || options.session ? goal : undefined;
+    // Resume without goal is fine — goal is stored in session
+    if (!taskGoal && !options.session) {
+        console.log(chalk.red('\nPlease provide a goal. Example:\n  slapify task "Go to example.com and check the title"\n'));
+        process.exit(1);
+    }
+    // If resuming, load the goal from session
+    if (!taskGoal && options.session) {
+        const { loadSession } = await import("./task/index.js");
+        const s = loadSession(options.session);
+        if (!s) {
+            console.log(chalk.red(`Session '${options.session}' not found.`));
+            process.exit(1);
+        }
+        taskGoal = s.goal;
+    }
+    // Check config
+    const configDir = getConfigDir();
+    if (!configDir) {
+        console.log(chalk.red('\nNo .slapify directory found. Run "slapify init" first.\n'));
+        process.exit(1);
+    }
+    // Track current session so SIGINT can generate report
+    let activeSession = null;
+    const generateAndPrintReport = async (session) => {
+        if (!options.report)
+            return;
+        try {
+            const { loadEvents, saveTaskReport } = await import("./task/index.js");
+            const events = loadEvents(session.id);
+            const reportPath = saveTaskReport(session, events);
+            console.log(chalk.cyan(`\n  📊 Report: ${reportPath}`));
+        }
+        catch (e) {
+            console.log(chalk.yellow(`  ⚠ Could not generate report: ${e?.message}`));
+        }
+    };
+    const debug = !!options.debug;
+    // Clear the "thinking..." spinner line
+    const clearLine = () => process.stdout.write("\x1b[2K\r");
+    const printEvent = (event) => {
+        switch (event.type) {
+            // ── Debug-only (verbose internal steps) ───────────────────────────
+            case "thinking":
+                if (debug)
+                    process.stdout.write(chalk.gray("  ⟳ thinking...\r"));
+                break;
+            case "message":
+                if (debug) {
+                    clearLine();
+                    console.log(chalk.gray(`  💬 ${event.text}`));
+                }
+                break;
+            case "tool_start":
+                if (debug) {
+                    clearLine();
+                    const argStr = JSON.stringify(event.args);
+                    console.log(chalk.dim(`  › ${chalk.cyan(event.toolName)} `) +
+                        chalk.gray(argStr.slice(0, 100) + (argStr.length > 100 ? "…" : "")));
+                }
+                break;
+            case "tool_done":
+                if (debug) {
+                    console.log(chalk.dim(`    ✓ ${event.result.slice(0, 120)}`));
+                }
+                break;
+            case "tool_error":
+                // Always show errors
+                clearLine();
+                console.log(chalk.red(`  ✗ ${event.toolName}: ${event.error.slice(0, 120)}`));
+                break;
+            // ── Always visible ────────────────────────────────────────────────
+            case "status_update":
+                clearLine();
+                console.log(chalk.white(`  ${event.message}`));
+                break;
+            case "human_input_needed":
+                // spinner is stopped by the trigger check above
+                console.log("\n" + chalk.yellow("─".repeat(60)));
+                console.log(chalk.yellow.bold("  🙋 Agent needs your input"));
+                console.log(chalk.white(`\n  ${event.question}`));
+                if (event.hint)
+                    console.log(chalk.gray(`  ${event.hint}`));
+                // Answer is handled via onHumanInput callback — just show the prompt here
+                break;
+            case "credentials_saved":
+                clearLine();
+                console.log(chalk.green(`  💾 Credentials saved: '${event.profileName}' (${event.credType}) → .slapify/credentials.yaml`));
+                break;
+            case "scheduled":
+                if (debug) {
+                    clearLine();
+                    console.log(chalk.dim(`  ⏰ scheduled: ${event.cron} — ${event.task}`));
+                }
+                break;
+            case "sleeping":
+                if (debug) {
+                    clearLine();
+                    console.log(chalk.dim(`  😴 sleeping until ${new Date(event.until).toLocaleString()}`));
+                }
+                break;
+            case "done":
+                clearLine();
+                console.log("\n" + chalk.green("─".repeat(60)));
+                console.log(chalk.green.bold("  ✅ Task complete!"));
+                console.log(chalk.white(`\n  ${event.summary}`));
+                console.log(chalk.green("─".repeat(60)));
+                break;
+            case "error":
+                clearLine();
+                console.log(chalk.red(`\n  ✗ Error: ${event.error}`));
+                break;
+        }
+    };
+    console.log(chalk.blue("\n🤖 Slapify Task Agent\n"));
+    console.log(chalk.white(`  Goal: ${taskGoal}`));
+    if (options.session)
+        console.log(chalk.gray(`  Resuming session: ${options.session}`));
+    console.log(chalk.gray([
+        options.report ? "  --report: HTML report on exit" : "",
+        debug ? "  --debug: verbose output" : "",
+        "  Ctrl+C to stop",
+    ]
+        .filter(Boolean)
+        .join("  ·  ") + "\n"));
+    console.log(chalk.gray("─".repeat(60)) + "\n");
+    // Thinking spinner for default (non-debug) mode
+    let spinnerInterval = null;
+    let spinnerPaused = false; // true while waiting for human input
+    const startSpinner = () => {
+        if (debug || spinnerPaused || spinnerInterval)
+            return;
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        let fi = 0;
+        spinnerInterval = setInterval(() => {
+            process.stdout.write(chalk.gray(`\r  ${frames[fi++ % frames.length]} working...`));
+        }, 80);
+    };
+    if (!debug)
+        startSpinner();
+    const { runTask } = await import("./task/index.js");
+    // SIGINT handler — generate report then exit gracefully
+    let sigintHandled = false;
+    const onSigint = async () => {
+        if (sigintHandled)
+            return;
+        sigintHandled = true;
+        clearInterval(spinnerInterval);
+        spinnerInterval = null;
+        spinnerPaused = true;
+        process.stdout.write("\x1b[2K\r");
+        console.log(chalk.yellow("\n  ⚡ Interrupted" +
+            (options.report ? " — generating report..." : "")));
+        if (activeSession) {
+            activeSession.status = "failed";
+            activeSession.finalSummary = "Task interrupted by user (Ctrl+C).";
+            const { saveSessionMeta } = await import("./task/session.js");
+            saveSessionMeta(activeSession);
+            await generateAndPrintReport(activeSession);
+        }
+        console.log(chalk.gray("  Goodbye.\n"));
+        process.exit(0);
+    };
+    process.once("SIGINT", onSigint);
+    try {
+        const stopSpinner = () => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+                spinnerInterval = null;
+            }
+            process.stdout.write("\x1b[2K\r");
+        };
+        const session = await runTask({
+            goal: taskGoal,
+            sessionId: options.session,
+            headed: options.headed,
+            saveFlow: options.saveFlow,
+            maxIterations: options.maxIterations,
+            onHumanInput: async (question, hint) => {
+                // Spinner is already stopped; block it from restarting while we read input
+                spinnerPaused = true;
+                stopSpinner();
+                // Read a full line from stdin cleanly
+                const readline = await import("readline");
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                    terminal: true,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question(`  ${chalk.cyan("›")} `, (ans) => {
+                        rl.close();
+                        resolve(ans.trim());
+                    });
+                });
+                console.log(chalk.yellow("─".repeat(60)) + "\n");
+                // Unblock and restart spinner
+                spinnerPaused = false;
+                startSpinner();
+                return answer;
+            },
+            onEvent: (event) => {
+                const isVisible = event.type === "status_update" ||
+                    event.type === "human_input_needed" ||
+                    event.type === "credentials_saved" ||
+                    event.type === "done" ||
+                    event.type === "error" ||
+                    event.type === "tool_error";
+                if (isVisible)
+                    stopSpinner();
+                printEvent(event);
+                // Restart spinner after visible output (but not if waiting for input or finished)
+                if (isVisible &&
+                    event.type !== "done" &&
+                    event.type !== "error" &&
+                    event.type !== "human_input_needed" // onHumanInput restarts it after input
+                ) {
+                    startSpinner();
+                }
+            },
+            onSessionUpdate: (s) => {
+                activeSession = s;
+            },
+        });
+        stopSpinner();
+        process.removeListener("SIGINT", onSigint);
+        console.log(chalk.gray(`\n  Session: ${session.id}`));
+        if (session.savedFlowPath) {
+            console.log(chalk.cyan(`  Flow saved: ${session.savedFlowPath}`));
+        }
+        if (Object.keys(session.memory).length > 0) {
+            console.log(chalk.gray(`  Memory (${Object.keys(session.memory).length} items):`));
+            for (const [k, v] of Object.entries(session.memory)) {
+                console.log(chalk.gray(`    • ${k}: ${v.slice(0, 80)}`));
+            }
+        }
+        // Always generate report after task completes
+        await generateAndPrintReport(session);
+        console.log("");
+    }
+    catch (err) {
+        process.removeListener("SIGINT", onSigint);
+        clearInterval(spinnerInterval);
+        spinnerInterval = null;
+        process.stdout.write("\x1b[2K\r");
+        console.error(chalk.red(`\n  Task failed: ${err?.message || err}`));
+        if (activeSession) {
+            await generateAndPrintReport(activeSession);
+        }
+        process.exit(1);
+    }
+});
 program.parse();
 //# sourceMappingURL=cli.js.map