slapify 0.0.0

package/dist/cli.js

@@ -0,0 +1,1181 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import path from "path";
+import fs from "fs";
+import dotenv from "dotenv";
+import { loadConfig, loadCredentials, getConfigDir, } from "./config/loader.js";
+import { parseFlowFile, findFlowFiles, validateFlowFile, getFlowSummary, } from "./parser/flow.js";
+import { TestRunner } from "./runner/index.js";
+import { ReportGenerator } from "./report/generator.js";
+import { BrowserAgent } from "./browser/agent.js";
+import { generateText } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createMistral } from "@ai-sdk/mistral";
+import { createGroq } from "@ai-sdk/groq";
+// Load environment variables
+dotenv.config();
+/**
+ * Get AI model based on config
+ */
+function getModelFromConfig(llmConfig) {
+    switch (llmConfig.provider) {
+        case "anthropic": {
+            const anthropic = createAnthropic({ apiKey: llmConfig.api_key });
+            return anthropic(llmConfig.model);
+        }
+        case "openai": {
+            const openai = createOpenAI({ apiKey: llmConfig.api_key });
+            return openai(llmConfig.model);
+        }
+        case "google": {
+            const google = createGoogleGenerativeAI({ apiKey: llmConfig.api_key });
+            return google(llmConfig.model);
+        }
+        case "mistral": {
+            const mistral = createMistral({ apiKey: llmConfig.api_key });
+            return mistral(llmConfig.model);
+        }
+        case "groq": {
+            const groq = createGroq({ apiKey: llmConfig.api_key });
+            return groq(llmConfig.model);
+        }
+        case "ollama": {
+            const ollama = createOpenAI({
+                apiKey: "ollama",
+                baseURL: llmConfig.base_url || "http://localhost:11434/v1",
+            });
+            return ollama(llmConfig.model);
+        }
+        default:
+            throw new Error(`Unsupported provider: ${llmConfig.provider}`);
+    }
+}
+const program = new Command();
+program
+    .name("slapify")
+    .description("AI-powered test automation using natural language flow files")
+    .version("0.1.0");
+// Init command
+program
+    .command("init")
+    .description("Initialize Slapify in the current directory")
+    .option("-y, --yes", "Skip prompts and use defaults")
+    .action(async (options) => {
+    const readline = await import("readline");
+    // Check if already initialized
+    if (fs.existsSync(".slapify")) {
+        console.log(chalk.yellow("Slapify is already initialized in this directory."));
+        console.log(chalk.gray("Delete .slapify folder to reinitialize."));
+        return;
+    }
+    console.log(chalk.blue.bold("\n🖐️  Welcome to Slapify!\n"));
+    console.log(chalk.gray("AI-powered E2E testing that slaps - by slaps.dev\n"));
+    // Import the new functions
+    const { findSystemBrowsers, initConfig: doInit } = await import("./config/loader.js");
+    let provider = "anthropic";
+    let model;
+    let browserPath;
+    let useSystemBrowser;
+    const providerInfo = {
+        anthropic: {
+            name: "Anthropic (Claude)",
+            envVar: "ANTHROPIC_API_KEY",
+            defaultModel: "claude-haiku-4-5-20251001",
+            models: [
+                {
+                    id: "claude-haiku-4-5-20251001",
+                    name: "Haiku 4.5 - fast & cheap ($1/5M tokens)",
+                    recommended: true,
+                },
+                {
+                    id: "claude-sonnet-4-20250514",
+                    name: "Sonnet 4 - more capable ($3/15M tokens)",
+                },
+                { id: "custom", name: "Enter custom model ID" },
+            ],
+        },
+        openai: {
+            name: "OpenAI",
+            envVar: "OPENAI_API_KEY",
+            defaultModel: "gpt-4o-mini",
+            models: [
+                {
+                    id: "gpt-4o-mini",
+                    name: "GPT-4o Mini - fast & cheap ($0.15/0.6M tokens)",
+                    recommended: true,
+                },
+                { id: "gpt-4.1-mini", name: "GPT-4.1 Mini - newer" },
+                { id: "gpt-4o", name: "GPT-4o - more capable ($2.5/10M tokens)" },
+                { id: "custom", name: "Enter custom model ID" },
+            ],
+        },
+        google: {
+            name: "Google (Gemini)",
+            envVar: "GOOGLE_API_KEY",
+            defaultModel: "gemini-2.0-flash",
+            models: [
+                {
+                    id: "gemini-2.0-flash",
+                    name: "Gemini 2.0 Flash - fastest & cheapest",
+                    recommended: true,
+                },
+                { id: "gemini-1.5-flash", name: "Gemini 1.5 Flash - stable" },
+                { id: "gemini-1.5-pro", name: "Gemini 1.5 Pro - more capable" },
+                { id: "custom", name: "Enter custom model ID" },
+            ],
+        },
+        mistral: {
+            name: "Mistral",
+            envVar: "MISTRAL_API_KEY",
+            askModel: true,
+            defaultModel: "mistral-small-latest",
+        },
+        groq: {
+            name: "Groq (Fast inference)",
+            envVar: "GROQ_API_KEY",
+            askModel: true,
+            defaultModel: "llama-3.3-70b-versatile",
+        },
+        ollama: {
+            name: "Ollama (Local)",
+            envVar: "",
+            askModel: true,
+            defaultModel: "llama3",
+        },
+    };
+    if (options.yes) {
+        // Use defaults
+        console.log(chalk.gray("Using default settings...\n"));
+    }
+    else {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+        // Step 1: LLM Provider
+        console.log(chalk.cyan("1. Choose your LLM provider:\n"));
+        console.log("   1) Anthropic (Claude) " + chalk.green("- recommended"));
+        console.log("   2) OpenAI (GPT-4)");
+        console.log("   3) Google (Gemini)");
+        console.log("   4) Mistral");
+        console.log("   5) Groq " + chalk.gray("- fast & free tier"));
+        console.log("   6) Ollama " + chalk.gray("- local, no API key"));
+        console.log("");
+        const providerChoice = await question(chalk.white("   Select [1]: "));
+        const providerMap = {
+            "1": "anthropic",
+            "2": "openai",
+            "3": "google",
+            "4": "mistral",
+            "5": "groq",
+            "6": "ollama",
+        };
+        provider = providerMap[providerChoice] || "anthropic";
+        const info = providerInfo[provider];
+        console.log(chalk.green(`   ✓ Using ${info.name}\n`));
+        // Step 1b: Model Selection
+        if (info.models && info.models.length > 0) {
+            console.log(chalk.cyan("   Choose model:\n"));
+            info.models.forEach((m, i) => {
+                const rec = m.recommended ? chalk.green(" ← recommended") : "";
+                console.log(`   ${i + 1}) ${m.name}${rec}`);
+            });
+            console.log("");
+            const modelChoice = await question(chalk.white("   Select [1]: "));
+            const modelIdx = parseInt(modelChoice) - 1 || 0;
+            const selectedModel = info.models[modelIdx];
+            if (selectedModel?.id === "custom") {
+                const customModel = await question(chalk.white("   Enter model ID: "));
+                model = customModel.trim() || info.defaultModel;
+            }
+            else {
+                model = selectedModel?.id || info.defaultModel;
+            }
+            console.log(chalk.green(`   ✓ Using model: ${model}\n`));
+        }
+        else if (info.askModel) {
+            // For Mistral, Groq, Ollama - ask for model ID directly
+            console.log(chalk.gray(`   Enter model ID (default: ${info.defaultModel})`));
+            if (provider === "ollama") {
+                console.log(chalk.gray("   Common models: llama3, mistral, codellama, phi3"));
+            }
+            else if (provider === "groq") {
+                console.log(chalk.gray("   Common models: llama-3.3-70b-versatile, mixtral-8x7b-32768"));
+            }
+            else if (provider === "mistral") {
+                console.log(chalk.gray("   Common models: mistral-small-latest, mistral-large-latest"));
+            }
+            console.log("");
+            const modelInput = await question(chalk.white(`   Model [${info.defaultModel}]: `));
+            model = modelInput.trim() || info.defaultModel;
+            console.log(chalk.green(`   ✓ Using model: ${model}\n`));
+            if (provider === "ollama") {
+                console.log(chalk.gray("   Make sure Ollama is running: ollama serve"));
+                console.log("");
+            }
+        }
+        // Step 2: API Key Verification (skip for Ollama)
+        if (provider !== "ollama") {
+            console.log(chalk.cyan("2. API Key verification:\n"));
+            const envVar = info.envVar;
+            let apiKey = process.env[envVar];
+            if (apiKey) {
+                console.log(chalk.gray(`   Found ${envVar} in environment`));
+            }
+            else {
+                console.log(chalk.yellow(`   ${envVar} not found in environment`));
+                console.log(chalk.gray("   You can set it now or add it to your shell config later.\n"));
+                const keyInput = await question(chalk.white(`   Enter API key (or press Enter to skip): `));
+                if (keyInput.trim()) {
+                    apiKey = keyInput.trim();
+                }
+            }
+            if (apiKey) {
+                const verifyChoice = await question(chalk.white("   Verify API key with test call? (Y/n): "));
+                if (verifyChoice.toLowerCase() !== "n") {
+                    const verifySpinner = ora("   Verifying API key...").start();
+                    try {
+                        // Make a minimal test call
+                        const testConfig = {
+                            provider,
+                            model: model || info.defaultModel || "test",
+                            api_key: apiKey,
+                        };
+                        const testModel = getModelFromConfig(testConfig);
+                        const response = await generateText({
+                            model: testModel,
+                            prompt: "Reply with only the word 'pong'",
+                            maxTokens: 10,
+                        });
+                        if (response.text.toLowerCase().includes("pong")) {
+                            verifySpinner.succeed(chalk.green("API key verified! ✓"));
+                        }
+                        else {
+                            verifySpinner.succeed(chalk.green("API key works! (got response)"));
+                        }
+                    }
+                    catch (error) {
+                        verifySpinner.fail(chalk.red("API key verification failed"));
+                        console.log(chalk.red(`   Error: ${error.message}`));
+                        console.log(chalk.yellow("\n   You can still continue - check your API key later."));
+                    }
+                }
+                else {
+                    console.log(chalk.gray("   Skipping verification\n"));
+                }
+            }
+            else {
+                console.log(chalk.yellow(`\n   Remember to set ${envVar} before running tests.`));
+            }
+            console.log("");
+        }
+        // Step 3: Browser Setup
+        console.log(chalk.cyan(`${provider === "ollama" ? "2" : "3"}. Browser setup:\n`));
+        const systemBrowsers = findSystemBrowsers();
+        if (systemBrowsers.length > 0) {
+            console.log("   Found browsers on your system:");
+            systemBrowsers.forEach((b, i) => {
+                console.log(chalk.gray(`   ${i + 1}) ${b.name}`));
+            });
+            console.log(chalk.gray(`   ${systemBrowsers.length + 1}) Download Chromium (~170MB)`));
+            console.log(chalk.gray(`   ${systemBrowsers.length + 2}) Enter custom path`));
+            console.log("");
+            const browserChoice = await question(chalk.white(`   Select [1]: `));
+            const choiceNum = parseInt(browserChoice) || 1;
+            if (choiceNum <= systemBrowsers.length) {
+                browserPath = systemBrowsers[choiceNum - 1].path;
+                useSystemBrowser = true;
+                console.log(chalk.green(`   ✓ Using ${systemBrowsers[choiceNum - 1].name}\n`));
+            }
+            else if (choiceNum === systemBrowsers.length + 2) {
+                const customPath = await question(chalk.white("   Enter browser path: "));
+                if (customPath.trim()) {
+                    browserPath = customPath.trim();
+                    useSystemBrowser = true;
+                    console.log(chalk.green(`   ✓ Using custom browser\n`));
+                }
+            }
+            else {
+                useSystemBrowser = false;
+                console.log(chalk.green("   ✓ Will download Chromium on first run\n"));
+            }
+        }
+        else {
+            console.log("   No browsers found. Options:");
+            console.log(chalk.gray("   1) Download Chromium automatically (~170MB)"));
+            console.log(chalk.gray("   2) Enter custom browser path"));
+            console.log("");
+            const browserChoice = await question(chalk.white("   Select [1]: "));
+            if (browserChoice === "2") {
+                const customPath = await question(chalk.white("   Enter browser path: "));
+                if (customPath.trim()) {
+                    browserPath = customPath.trim();
+                    useSystemBrowser = true;
+                    console.log(chalk.green("   ✓ Using custom browser\n"));
+                }
+            }
+            else {
+                useSystemBrowser = false;
+                console.log(chalk.green("   ✓ Will download Chromium on first run\n"));
+            }
+        }
+        rl.close();
+    }
+    // Initialize
+    const spinner = ora("Creating configuration...").start();
+    try {
+        doInit(process.cwd(), {
+            provider,
+            model,
+            browserPath,
+            useSystemBrowser,
+        });
+        spinner.succeed("Slapify initialized!");
+        console.log("");
+        console.log(chalk.green("Created:"));
+        console.log("  📁 .slapify/config.yaml      - Configuration");
+        console.log("  🔐 .slapify/credentials.yaml - Credentials (gitignored)");
+        console.log("  📝 tests/example.flow       - Sample test");
+        console.log("");
+        const info = providerInfo[provider];
+        console.log(chalk.yellow("Next steps:"));
+        console.log("");
+        if (provider === "ollama") {
+            console.log(chalk.white(`  1. Make sure Ollama is running:`));
+            console.log(chalk.cyan(`     ollama serve`));
+            console.log(chalk.cyan(`     ollama pull llama3`));
+        }
+        else {
+            console.log(chalk.white(`  1. Set your API key:`));
+            console.log(chalk.cyan(`     export ${info.envVar}=your-key-here`));
+        }
+        console.log("");
+        console.log(chalk.white(`  2. Run the example test:`));
+        console.log(chalk.cyan(`     slapify run tests/example.flow`));
+        console.log("");
+        console.log(chalk.white(`  3. Create your own tests:`));
+        console.log(chalk.cyan(`     slapify create my-first-test`));
+        console.log(chalk.cyan(`     slapify generate "test login for myapp.com"`));
+        console.log("");
+        console.log(chalk.gray("  Config can be modified anytime in .slapify/config.yaml"));
+        console.log("");
+    }
+    catch (error) {
+        spinner.fail(error.message);
+        process.exit(1);
+    }
+});
+// Install command (for agent-browser)
+program
+    .command("install")
+    .description("Install browser dependencies")
+    .action(() => {
+    const spinner = ora("Checking agent-browser...").start();
+    if (BrowserAgent.isInstalled()) {
+        spinner.succeed("agent-browser is already installed");
+    }
+    else {
+        spinner.text = "Installing agent-browser...";
+        try {
+            BrowserAgent.install();
+            spinner.succeed("Browser dependencies installed!");
+        }
+        catch (error) {
+            spinner.fail(`Installation failed: ${error.message}`);
+            process.exit(1);
+        }
+    }
+});
+// Run command
+program
+    .command("run [files...]")
+    .description("Run flow test files")
+    .option("--headed", "Run browser in headed mode (visible)")
+    .option("--report [format]", "Generate report folder (html, markdown, json)")
+    .option("--output <dir>", "Output directory for reports", "./test-reports")
+    .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")
+    .action(async (files, options) => {
+    try {
+        // Load configuration
+        const configDir = getConfigDir();
+        if (!configDir) {
+            console.log(chalk.red('No .slapify directory found. Run "slapify init" first.'));
+            process.exit(1);
+        }
+        const config = loadConfig(configDir);
+        const credentials = loadCredentials(configDir);
+        // Apply CLI options
+        if (options.headed) {
+            config.browser = { ...config.browser, headless: false };
+        }
+        // Only enable screenshots if report is requested
+        const generateReport = options.report !== undefined;
+        config.report = {
+            ...config.report,
+            format: typeof options.report === "string" ? options.report : "html",
+            output_dir: options.output,
+            screenshots: generateReport, // Only take screenshots for reports
+        };
+        // Find flow files
+        let flowFiles = [];
+        if (files.length === 0) {
+            // Run all flow files in tests directory
+            const testsDir = path.join(process.cwd(), "tests");
+            if (fs.existsSync(testsDir)) {
+                flowFiles = await findFlowFiles(testsDir);
+            }
+        }
+        else {
+            for (const file of files) {
+                if (fs.statSync(file).isDirectory()) {
+                    const found = await findFlowFiles(file);
+                    flowFiles.push(...found);
+                }
+                else {
+                    flowFiles.push(file);
+                }
+            }
+        }
+        if (flowFiles.length === 0) {
+            console.log(chalk.yellow("No .flow files found to run."));
+            process.exit(0);
+        }
+        const reporter = new ReportGenerator(config.report);
+        const results = [];
+        const isParallel = options.parallel && flowFiles.length > 1;
+        const workers = parseInt(options.workers) || 4;
+        if (isParallel) {
+            // Parallel execution
+            console.log(chalk.blue.bold(`\n━━━ Running ${flowFiles.length} tests in parallel (${workers} workers) ━━━\n`));
+            const pending = [...flowFiles];
+            const running = new Map();
+            const testStatus = new Map();
+            // Initialize status
+            for (const file of flowFiles) {
+                const name = path.basename(file, ".flow");
+                testStatus.set(name, chalk.gray("⏳ pending"));
+            }
+            const printStatus = () => {
+                // Clear and reprint status
+                process.stdout.write("\x1B[" + flowFiles.length + "A"); // Move cursor up
+                for (const file of flowFiles) {
+                    const name = path.basename(file, ".flow");
+                    const status = testStatus.get(name) || "";
+                    process.stdout.write("\x1B[2K"); // Clear line
+                    console.log(`  ${name}: ${status}`);
+                }
+            };
+            // Print initial status
+            for (const file of flowFiles) {
+                const name = path.basename(file, ".flow");
+                console.log(`  ${name}: ${testStatus.get(name)}`);
+            }
+            const runTest = async (file) => {
+                const flow = parseFlowFile(file);
+                const name = flow.name;
+                testStatus.set(name, chalk.cyan("▶ running..."));
+                printStatus();
+                try {
+                    const runner = new TestRunner(config, credentials);
+                    const result = await runner.runFlow(flow);
+                    results.push(result);
+                    if (result.status === "passed") {
+                        testStatus.set(name, chalk.green(`✓ passed (${result.passedSteps}/${result.totalSteps} steps, ${(result.duration / 1000).toFixed(1)}s)`));
+                    }
+                    else {
+                        testStatus.set(name, chalk.red(`✗ failed (${result.failedSteps} failed, ${result.passedSteps} passed)`));
+                    }
+                }
+                catch (error) {
+                    testStatus.set(name, chalk.red(`✗ error: ${error.message}`));
+                }
+                printStatus();
+            };
+            // Process with worker limit
+            while (pending.length > 0 || running.size > 0) {
+                // Start new tasks up to worker limit
+                while (pending.length > 0 && running.size < workers) {
+                    const file = pending.shift();
+                    const promise = runTest(file).then(() => {
+                        running.delete(file);
+                    });
+                    running.set(file, promise);
+                }
+                // Wait for at least one to complete
+                if (running.size > 0) {
+                    await Promise.race(running.values());
+                }
+            }
+            console.log(""); // Extra newline after parallel run
+        }
+        else {
+            // Sequential execution
+            for (const file of flowFiles) {
+                const flow = parseFlowFile(file);
+                const summary = getFlowSummary(flow);
+                // Print test header
+                console.log("");
+                console.log(chalk.blue.bold(`━━━ ${flow.name} ━━━`));
+                console.log(chalk.gray(`    ${summary.totalSteps} steps (${summary.requiredSteps} required, ${summary.optionalSteps} optional)`));
+                console.log("");
+                try {
+                    const runner = new TestRunner(config, credentials);
+                    const result = await runner.runFlow(flow, (stepResult) => {
+                        // Real-time step output
+                        const step = stepResult.step;
+                        const statusIcon = stepResult.status === "passed"
+                            ? chalk.green("✓")
+                            : stepResult.status === "failed"
+                                ? chalk.red("✗")
+                                : chalk.yellow("⊘");
+                        const optionalTag = step.optional
+                            ? chalk.gray(" [optional]")
+                            : "";
+                        const retriedTag = stepResult.retried
+                            ? chalk.yellow(" [retried]")
+                            : "";
+                        const duration = chalk.gray(`(${(stepResult.duration / 1000).toFixed(1)}s)`);
+                        console.log(`  ${statusIcon} ${step.text}${optionalTag}${retriedTag} ${duration}`);
+                        // Show error inline if failed
+                        if (stepResult.status === "failed" && stepResult.error) {
+                            console.log(chalk.red(`    └─ ${stepResult.error}`));
+                        }
+                        // Show assumptions if any
+                        if (stepResult.assumptions && stepResult.assumptions.length > 0) {
+                            for (const assumption of stepResult.assumptions) {
+                                console.log(chalk.gray(`    └─ 💡 ${assumption}`));
+                            }
+                        }
+                    });
+                    results.push(result);
+                    // Print test summary
+                    console.log("");
+                    if (result.status === "passed") {
+                        console.log(chalk.green.bold(`  ✓ PASSED`) +
+                            chalk.gray(` (${result.passedSteps}/${result.totalSteps} steps in ${(result.duration / 1000).toFixed(1)}s)`));
+                    }
+                    else {
+                        console.log(chalk.red.bold(`  ✗ FAILED`) +
+                            chalk.gray(` (${result.failedSteps} failed, ${result.passedSteps} passed)`));
+                    }
+                    // Auto-handled info
+                    if (result.autoHandled.length > 0) {
+                        console.log(chalk.gray(`  ℹ Auto-handled: ${result.autoHandled.join(", ")}`));
+                    }
+                }
+                catch (error) {
+                    console.log(chalk.red(`  ✗ ERROR: ${error.message}`));
+                }
+            }
+        }
+        // Final summary
+        console.log("");
+        console.log(chalk.blue.bold("━━━ Summary ━━━"));
+        const passed = results.filter((r) => r.status === "passed").length;
+        const failed = results.filter((r) => r.status === "failed").length;
+        const totalSteps = results.reduce((sum, r) => sum + r.totalSteps, 0);
+        const passedSteps = results.reduce((sum, r) => sum + r.passedSteps, 0);
+        console.log(chalk.gray(`  ${results.length} test file(s), ${totalSteps} total steps`));
+        if (failed === 0) {
+            console.log(chalk.green.bold(`  ✓ All ${passed} test(s) passed! (${passedSteps}/${totalSteps} steps)`));
+        }
+        else {
+            console.log(chalk.red.bold(`  ✗ ${failed}/${results.length} test(s) failed`));
+        }
+        // Generate suite report if requested and multiple files
+        if (generateReport && results.length > 0) {
+            let reportPath;
+            if (results.length === 1) {
+                reportPath = reporter.saveAsFolder(results[0]);
+            }
+            else {
+                reportPath = reporter.saveSuiteAsFolder(results);
+            }
+            console.log(chalk.cyan(`\n  📄 Report: ${reportPath}`));
+        }
+        console.log("");
+        if (failed > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+// Create command
+program
+    .command("create <name>")
+    .description("Create a new flow file")
+    .option("-d, --dir <directory>", "Directory to create flow in", "tests")
+    .action(async (name, options) => {
+    const readline = await import("readline");
+    // Ensure directory exists
+    const dir = options.dir;
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Generate filename
+    const filename = name.endsWith(".flow") ? name : `${name}.flow`;
+    const filepath = path.join(dir, filename);
+    if (fs.existsSync(filepath)) {
+        console.log(chalk.red(`File already exists: ${filepath}`));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`\nCreating: ${filepath}`));
+    console.log(chalk.gray("Enter your test steps (one per line). Empty line to finish.\n"));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const lines = [`# ${name}`, ""];
+    let lineNum = 1;
+    const askLine = () => {
+        return new Promise((resolve) => {
+            rl.question(chalk.cyan(`${lineNum}. `), (answer) => {
+                resolve(answer);
+            });
+        });
+    };
+    while (true) {
+        const line = await askLine();
+        if (line === "") {
+            break;
+        }
+        lines.push(line);
+        lineNum++;
+    }
+    rl.close();
+    if (lines.length <= 2) {
+        console.log(chalk.yellow("\nNo steps entered. File not created."));
+        return;
+    }
+    // Write file
+    fs.writeFileSync(filepath, lines.join("\n") + "\n");
+    console.log(chalk.green(`\n✓ Created: ${filepath}`));
+    console.log(chalk.gray(`  ${lineNum - 1} steps`));
+    console.log(chalk.gray(`\nRun with: slapify run ${filepath}`));
+});
+// Generate command - AI-powered flow generation
+program
+    .command("generate <prompt>")
+    .alias("gen")
+    .description("Generate a flow file from a natural language prompt")
+    .option("-d, --dir <directory>", "Directory to save flow", "tests")
+    .option("--headed", "Show browser while analyzing")
+    .action(async (prompt, options) => {
+    const configDir = getConfigDir();
+    if (!configDir) {
+        console.log(chalk.red('No .slapify directory found. Run "slapify init" first.'));
+        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,
+    });
+    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}`));
+    }
+    catch (error) {
+        spinner.fail("Error");
+        await browser.close();
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+// Fix command - analyze and fix failing tests
+program
+    .command("fix <file>")
+    .description("Analyze a failing test and suggest/apply fixes")
+    .option("--auto", "Automatically apply suggested fixes without confirmation")
+    .option("--headed", "Run browser in headed mode for debugging")
+    .action(async (file, options) => {
+    const configDir = getConfigDir();
+    if (!configDir) {
+        console.log(chalk.red('No .slapify directory found. Run "slapify init" first.'));
+        process.exit(1);
+    }
+    if (!fs.existsSync(file)) {
+        console.log(chalk.red(`File not found: ${file}`));
+        process.exit(1);
+    }
+    const config = loadConfig(configDir);
+    const credentials = loadCredentials(configDir);
+    if (options.headed) {
+        config.browser = { ...config.browser, headless: false };
+    }
+    // Enable screenshots for diagnosis
+    config.report = { ...config.report, screenshots: true };
+    const readline = await import("readline");
+    let spinner = ora("Running test to identify failures...").start();
+    try {
+        // Step 1: Run the test to see what fails
+        const flow = parseFlowFile(file);
+        const runner = new TestRunner(config, credentials);
+        const failedSteps = [];
+        const result = await runner.runFlow(flow, (stepResult) => {
+            if (stepResult.status === "failed" && stepResult.error) {
+                failedSteps.push({
+                    step: stepResult.step.text,
+                    error: stepResult.error,
+                    line: stepResult.step.line,
+                    screenshot: stepResult.screenshot,
+                });
+            }
+        });
+        if (result.status === "passed") {
+            spinner.succeed("Test passed! No fixes needed.");
+            return;
+        }
+        spinner.info(`Found ${failedSteps.length} failing step(s)`);
+        if (failedSteps.length === 0) {
+            console.log(chalk.yellow("No specific step failures to fix."));
+            return;
+        }
+        // Step 2: Read the original flow file
+        const originalContent = fs.readFileSync(file, "utf-8");
+        const lines = originalContent.split("\n");
+        // Step 3: Use AI to analyze and suggest fixes
+        spinner = ora("Analyzing failures and generating fixes...").start();
+        const failureDetails = failedSteps
+            .map((f) => `Line ${f.line}: "${f.step}"\n  Error: ${f.error}`)
+            .join("\n\n");
+        const analysisResponse = await generateText({
+            model: getModelFromConfig(config.llm),
+            system: `You are a test automation expert. Analyze failing test steps and suggest fixes.
+
+Original flow file:
+\`\`\`
+${originalContent}
+\`\`\`
+
+Failing steps:
+${failureDetails}
+
+Based on the errors, suggest fixes for the flow file. Common issues and fixes:
+1. Element not found → Try more descriptive text, add wait, or make step optional
+2. Timeout → Add explicit wait or increase timeout
+3. Navigation error → Add wait after navigation, or split into smaller steps
+4. Element obscured → Add step to close popup/modal first
+5. Stale element → Add wait for page to stabilize
+
+Respond with JSON:
+{
+  "analysis": "Brief explanation of what's wrong",
+  "fixes": [
+    {
+      "line": 5,
+      "original": "Click the submit button",
+      "fixed": "Click the Submit button",
+      "reason": "Button text is capitalized"
+    }
+  ],
+  "additions": [
+    {
+      "afterLine": 4,
+      "step": "[Optional] Wait for page to load",
+      "reason": "Page might still be loading"
+    }
+  ]
+}`,
+            prompt: "Analyze the failures and suggest specific fixes.",
+            maxTokens: 1500,
+        });
+        spinner.succeed("Analysis complete");
+        // Parse the response
+        const jsonMatch = analysisResponse.text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            console.log(chalk.red("Could not parse AI response"));
+            return;
+        }
+        const suggestions = JSON.parse(jsonMatch[0]);
+        // Step 4: Display suggestions
+        console.log(chalk.blue("\n━━━ Analysis ━━━\n"));
+        console.log(chalk.white(suggestions.analysis));
+        if (suggestions.fixes?.length > 0 || suggestions.additions?.length > 0) {
+            console.log(chalk.blue("\n━━━ Suggested Fixes ━━━\n"));
+            if (suggestions.fixes?.length > 0) {
+                for (const fix of suggestions.fixes) {
+                    console.log(chalk.yellow(`Line ${fix.line}:`));
+                    console.log(chalk.red(`  - ${fix.original}`));
+                    console.log(chalk.green(`  + ${fix.fixed}`));
+                    console.log(chalk.gray(`  Reason: ${fix.reason}\n`));
+                }
+            }
+            if (suggestions.additions?.length > 0) {
+                console.log(chalk.yellow("New steps to add:"));
+                for (const add of suggestions.additions) {
+                    console.log(chalk.green(`  + After line ${add.afterLine}: ${add.step}`));
+                    console.log(chalk.gray(`    Reason: ${add.reason}\n`));
+                }
+            }
+            // Step 5: Apply fixes
+            let shouldApply = options.auto;
+            if (!shouldApply) {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question(chalk.cyan("Apply these fixes? (y/N): "), (answer) => {
+                        rl.close();
+                        resolve(answer.trim().toLowerCase());
+                    });
+                });
+                shouldApply = answer === "y" || answer === "yes";
+            }
+            if (shouldApply) {
+                // Apply fixes to lines
+                let newLines = [...lines];
+                const lineOffsets = new Map(); // Track line number changes
+                // Apply modifications first
+                if (suggestions.fixes) {
+                    for (const fix of suggestions.fixes) {
+                        const lineIdx = fix.line - 1;
+                        if (lineIdx >= 0 && lineIdx < newLines.length) {
+                            newLines[lineIdx] = fix.fixed;
+                        }
+                    }
+                }
+                // Apply additions (in reverse order to maintain line numbers)
+                if (suggestions.additions) {
+                    const sortedAdditions = [...suggestions.additions].sort((a, b) => b.afterLine - a.afterLine);
+                    for (const add of sortedAdditions) {
+                        const afterIdx = add.afterLine;
+                        newLines.splice(afterIdx, 0, add.step);
+                    }
+                }
+                // Write the fixed file
+                const newContent = newLines.join("\n");
+                // Backup original
+                const backupPath = file + ".backup";
+                fs.writeFileSync(backupPath, originalContent);
+                // Write fixed version
+                fs.writeFileSync(file, newContent);
+                console.log(chalk.green(`\n✓ Fixes applied to ${file}`));
+                console.log(chalk.gray(`  Backup saved to ${backupPath}`));
+                console.log(chalk.gray(`\nRun again with: slapify run ${file}`));
+            }
+            else {
+                console.log(chalk.yellow("No changes made."));
+            }
+        }
+        else {
+            console.log(chalk.yellow("\nNo automatic fixes suggested."));
+            console.log(chalk.gray("The failures may require manual investigation."));
+        }
+    }
+    catch (error) {
+        spinner.fail("Error");
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+// Validate command
+program
+    .command("validate [files...]")
+    .description("Validate flow files for syntax issues")
+    .action(async (files) => {
+    let flowFiles = [];
+    if (files.length === 0) {
+        const testsDir = path.join(process.cwd(), "tests");
+        if (fs.existsSync(testsDir)) {
+            flowFiles = await findFlowFiles(testsDir);
+        }
+    }
+    else {
+        flowFiles = files;
+    }
+    if (flowFiles.length === 0) {
+        console.log(chalk.yellow("No .flow files found."));
+        return;
+    }
+    let hasWarnings = false;
+    for (const file of flowFiles) {
+        try {
+            const flow = parseFlowFile(file);
+            const warnings = validateFlowFile(flow);
+            const summary = getFlowSummary(flow);
+            if (warnings.length > 0) {
+                hasWarnings = true;
+                console.log(chalk.yellow(`⚠️  ${file}`));
+                for (const warning of warnings) {
+                    console.log(chalk.yellow(`   ${warning}`));
+                }
+            }
+            else {
+                console.log(chalk.green(`✅ ${file}`));
+                console.log(chalk.gray(`   ${summary.totalSteps} steps (${summary.requiredSteps} required, ${summary.optionalSteps} optional)`));
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(`❌ ${file}`));
+            console.log(chalk.red(`   ${error.message}`));
+            hasWarnings = true;
+        }
+    }
+    if (hasWarnings) {
+        process.exit(1);
+    }
+});
+// List command
+program
+    .command("list")
+    .description("List all flow files")
+    .action(async () => {
+    const testsDir = path.join(process.cwd(), "tests");
+    if (!fs.existsSync(testsDir)) {
+        console.log(chalk.yellow("No tests directory found."));
+        return;
+    }
+    const flowFiles = await findFlowFiles(testsDir);
+    if (flowFiles.length === 0) {
+        console.log(chalk.yellow("No .flow files found."));
+        return;
+    }
+    console.log(chalk.blue(`\nFound ${flowFiles.length} flow file(s):\n`));
+    for (const file of flowFiles) {
+        const flow = parseFlowFile(file);
+        const summary = getFlowSummary(flow);
+        const relativePath = path.relative(process.cwd(), file);
+        console.log(`  ${chalk.white(relativePath)}`);
+        console.log(chalk.gray(`    ${summary.totalSteps} steps (${summary.requiredSteps} required, ${summary.optionalSteps} optional)`));
+    }
+    console.log("");
+});
+// Credentials command
+program
+    .command("credentials")
+    .description("List configured credential profiles")
+    .action(() => {
+    const configDir = getConfigDir();
+    if (!configDir) {
+        console.log(chalk.red('No .slapify directory found. Run "slapify init" first.'));
+        process.exit(1);
+    }
+    const credentials = loadCredentials(configDir);
+    const profiles = Object.keys(credentials.profiles);
+    if (profiles.length === 0) {
+        console.log(chalk.yellow("No credential profiles configured."));
+        console.log(chalk.gray("Edit .slapify/credentials.yaml to add profiles."));
+        return;
+    }
+    console.log(chalk.blue(`\nConfigured credential profiles:\n`));
+    for (const name of profiles) {
+        const profile = credentials.profiles[name];
+        console.log(`  ${chalk.white(name)} (${profile.type})`);
+        if (profile.username) {
+            console.log(chalk.gray(`    username: ${profile.username}`));
+        }
+        if (profile.email) {
+            console.log(chalk.gray(`    email: ${profile.email}`));
+        }
+        if (profile.totp_secret) {
+            console.log(chalk.gray(`    2FA: TOTP configured`));
+        }
+        if (profile.fixed_otp) {
+            console.log(chalk.gray(`    2FA: Fixed OTP configured`));
+        }
+    }
+    console.log("");
+});
+// Interactive mode
+program
+    .command("interactive [url]")
+    .alias("i")
+    .description("Run steps interactively")
+    .option("--headed", "Run browser in headed mode")
+    .action(async (url, options) => {
+    console.log(chalk.blue("\n🧪 Slapify Interactive Mode"));
+    console.log(chalk.gray('Type test steps and press Enter to execute. Type "exit" to quit.\n'));
+    const configDir = getConfigDir();
+    if (!configDir) {
+        console.log(chalk.red('No .slapify directory found. Run "slapify init" first.'));
+        process.exit(1);
+    }
+    const config = loadConfig(configDir);
+    const credentials = loadCredentials(configDir);
+    if (options.headed) {
+        config.browser = { ...config.browser, headless: false };
+    }
+    const runner = new TestRunner(config, credentials);
+    if (url) {
+        console.log(chalk.gray(`Navigating to ${url}...`));
+        // Would navigate here
+    }
+    // Simple readline interface
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const prompt = () => {
+        rl.question(chalk.cyan("> "), async (input) => {
+            const trimmed = input.trim();
+            if (trimmed.toLowerCase() === "exit" ||
+                trimmed.toLowerCase() === "quit") {
+                console.log(chalk.gray("\nGoodbye!"));
+                rl.close();
+                process.exit(0);
+            }
+            if (!trimmed) {
+                prompt();
+                return;
+            }
+            // Execute the step
+            console.log(chalk.gray(`Executing: ${trimmed}`));
+            // Would execute step here
+            console.log(chalk.green("✓ Done"));
+            prompt();
+        });
+    };
+    prompt();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map