intellitester 0.1.12

package/dist/cli/index.js

@@ -0,0 +1,1957 @@
+#!/usr/bin/env node
+import { loadIntellitesterConfig, isPipelineFile, isWorkflowFile, loadTestDefinition, collectMissingEnvVars, loadPipelineDefinition, loadWorkflowDefinition, runWorkflow, runWebTest, startTrackingServer, startWebServer, createTestContext, setupAppwriteTracking, runWorkflowWithContext, killServer, createAIProvider, TestDefinitionSchema } from '../chunk-5LFSLMQ7.js';
+import { loadFailedCleanups, loadCleanupHandlers, executeCleanup, removeFailedCleanup } from '../chunk-ECBA4GJ3.js';
+import '../chunk-DE5UFTTG.js';
+import '../chunk-6PYKWWH5.js';
+import '../chunk-4B54JUOP.js';
+import '../chunk-SAVY6D3X.js';
+import '../chunk-CN6HSJJX.js';
+import dotenv2 from 'dotenv';
+import fs3 from 'fs/promises';
+import * as path4 from 'path';
+import path4__default from 'path';
+import process2 from 'process';
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import crypto from 'crypto';
+import { chromium, webkit, firefox } from 'playwright';
+import { parse } from 'yaml';
+import { glob } from 'glob';
+import { promises } from 'fs';
+import prompts from 'prompts';
+
+var getBrowser = (browser) => {
+  switch (browser) {
+    case "firefox":
+      return firefox;
+    case "webkit":
+      return webkit;
+    default:
+      return chromium;
+  }
+};
+function buildExecutionOrder(workflows) {
+  const workflowMap = /* @__PURE__ */ new Map();
+  const workflowIds = [];
+  for (let i = 0; i < workflows.length; i++) {
+    const workflow = workflows[i];
+    const id = workflow.id ?? `workflow_${i}`;
+    workflowIds.push(id);
+    workflowMap.set(id, { ...workflow, id });
+  }
+  const adjacencyList = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const id of workflowIds) {
+    adjacencyList.set(id, []);
+    inDegree.set(id, 0);
+  }
+  for (const id of workflowIds) {
+    const workflow = workflowMap.get(id);
+    const deps = workflow.depends_on ?? [];
+    for (const depId of deps) {
+      if (!workflowMap.has(depId)) {
+        throw new Error(
+          `Workflow "${id}" depends on "${depId}" which does not exist in the pipeline`
+        );
+      }
+      adjacencyList.get(depId).push(id);
+      inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const id of workflowIds) {
+    if (inDegree.get(id) === 0) {
+      queue.push(id);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    sorted.push(workflowMap.get(currentId));
+    for (const dependentId of adjacencyList.get(currentId) ?? []) {
+      const newInDegree = (inDegree.get(dependentId) ?? 1) - 1;
+      inDegree.set(dependentId, newInDegree);
+      if (newInDegree === 0) {
+        queue.push(dependentId);
+      }
+    }
+  }
+  if (sorted.length !== workflowIds.length) {
+    const remaining = workflowIds.filter((id) => !sorted.some((w) => w.id === id));
+    throw new Error(
+      `Circular dependency detected in pipeline. Workflows involved: ${remaining.join(", ")}`
+    );
+  }
+  return sorted;
+}
+function inferCleanupConfig(config) {
+  if (!config) return void 0;
+  if (config.cleanup) {
+    return config.cleanup;
+  }
+  if (config.appwrite?.cleanup) {
+    return {
+      provider: "appwrite",
+      appwrite: {
+        endpoint: config.appwrite.endpoint,
+        projectId: config.appwrite.projectId,
+        apiKey: config.appwrite.apiKey,
+        cleanupOnFailure: config.appwrite.cleanupOnFailure
+      }
+    };
+  }
+  return void 0;
+}
+async function runPipeline(pipeline, pipelinePath, options = {}) {
+  const pipelineDir = path4__default.dirname(pipelinePath);
+  const sessionId = crypto.randomUUID();
+  const testStartTime = (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`Pipeline: ${pipeline.name}`);
+  console.log(`Session ID: ${sessionId}`);
+  console.log(`${"=".repeat(60)}
+`);
+  let executionOrder;
+  try {
+    executionOrder = buildExecutionOrder(pipeline.workflows);
+    console.log(
+      `Execution order: ${executionOrder.map((w) => w.id ?? w.file).join(" -> ")}
+`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to build execution order: ${message}`);
+    return {
+      status: "failed",
+      workflows: [],
+      sessionId
+    };
+  }
+  let trackingServer = null;
+  try {
+    trackingServer = await startTrackingServer({ port: 0 });
+    console.log(`Tracking server started on port ${trackingServer.port}`);
+  } catch (error) {
+    console.warn("Failed to start tracking server:", error);
+  }
+  if (trackingServer) {
+    process.env.INTELLITESTER_SESSION_ID = sessionId;
+    process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
+  }
+  let serverProcess = null;
+  if (pipeline.config?.webServer) {
+    try {
+      serverProcess = await startWebServer({
+        ...pipeline.config.webServer,
+        cwd: pipelineDir
+      });
+    } catch (error) {
+      console.error("Failed to start web server:", error);
+      if (trackingServer) await trackingServer.stop();
+      throw error;
+    }
+  }
+  const signalCleanup = async () => {
+    console.log("\n\nInterrupted - cleaning up...");
+    killServer(serverProcess);
+    if (trackingServer) await trackingServer.stop();
+    process.exit(1);
+  };
+  process.on("SIGINT", signalCleanup);
+  process.on("SIGTERM", signalCleanup);
+  const browserName = options.browser ?? pipeline.config?.web?.browser ?? "chromium";
+  const headless = options.headed ? false : pipeline.config?.web?.headless ?? true;
+  const browser = await getBrowser(browserName).launch({ headless });
+  const browserContext = await browser.newContext();
+  const page = await browserContext.newPage();
+  page.setDefaultTimeout(3e4);
+  const executionContext = {
+    variables: /* @__PURE__ */ new Map(),
+    lastEmail: null,
+    emailClient: null,
+    appwriteContext: createTestContext(),
+    appwriteConfig: pipeline.config?.appwrite ? {
+      endpoint: pipeline.config.appwrite.endpoint,
+      projectId: pipeline.config.appwrite.projectId,
+      apiKey: pipeline.config.appwrite.apiKey
+    } : void 0
+  };
+  if (pipeline.config?.appwrite) {
+    setupAppwriteTracking(page, executionContext);
+  }
+  const completedIds = /* @__PURE__ */ new Set();
+  const failedIds = /* @__PURE__ */ new Set();
+  const skippedIds = /* @__PURE__ */ new Set();
+  const workflowResults = [];
+  let pipelineFailed = false;
+  let shouldStopPipeline = false;
+  try {
+    for (const workflowRef of executionOrder) {
+      const workflowId = workflowRef.id ?? workflowRef.file;
+      if (shouldStopPipeline) {
+        workflowResults.push({
+          id: workflowRef.id,
+          file: workflowRef.file,
+          status: "skipped",
+          error: "Pipeline stopped due to previous failure"
+        });
+        skippedIds.add(workflowId);
+        continue;
+      }
+      const deps = workflowRef.depends_on ?? [];
+      const depsFailed = deps.some((id) => failedIds.has(id) || skippedIds.has(id));
+      const depsNotMet = deps.some(
+        (id) => !completedIds.has(id) && !failedIds.has(id) && !skippedIds.has(id)
+      );
+      if (depsFailed || depsNotMet) {
+        const onFailure = workflowRef.on_failure ?? pipeline.on_failure;
+        if (onFailure === "skip") {
+          console.log(`
+Skipping workflow "${workflowId}" - dependencies not met`);
+          workflowResults.push({
+            id: workflowRef.id,
+            file: workflowRef.file,
+            status: "skipped",
+            error: `Dependencies not met: ${deps.filter((d) => failedIds.has(d) || skippedIds.has(d)).join(", ")}`
+          });
+          skippedIds.add(workflowId);
+          continue;
+        } else if (onFailure === "fail") {
+          console.log(
+            `
+Pipeline stopped - workflow "${workflowId}" dependencies failed`
+          );
+          workflowResults.push({
+            id: workflowRef.id,
+            file: workflowRef.file,
+            status: "failed",
+            error: `Dependencies failed: ${deps.filter((d) => failedIds.has(d) || skippedIds.has(d)).join(", ")}`
+          });
+          failedIds.add(workflowId);
+          pipelineFailed = true;
+          shouldStopPipeline = true;
+          continue;
+        }
+        console.log(
+          `
+Running workflow "${workflowId}" despite dependency failure (on_failure: ignore)`
+        );
+      }
+      const workflowFilePath = path4__default.resolve(pipelineDir, workflowRef.file);
+      console.log(`
+${"=".repeat(40)}`);
+      console.log(`Workflow: ${workflowId}`);
+      console.log(`File: ${workflowRef.file}`);
+      console.log(`${"=".repeat(40)}`);
+      try {
+        const workflowDefinition = await loadWorkflowDefinition(workflowFilePath);
+        if (workflowRef.variables) {
+          for (const [key, value] of Object.entries(workflowRef.variables)) {
+            const interpolated = value.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+              if (varName === "uuid") {
+                return crypto.randomUUID().split("-")[0];
+              }
+              return executionContext.variables.get(varName) ?? match;
+            });
+            executionContext.variables.set(key, interpolated);
+          }
+        }
+        const workflowOptions = {
+          ...options,
+          page,
+          executionContext,
+          skipCleanup: true,
+          // Defer cleanup to pipeline end
+          sessionId,
+          testStartTime
+        };
+        const result = await runWorkflowWithContext(
+          workflowDefinition,
+          workflowFilePath,
+          workflowOptions
+        );
+        if (result.status === "passed") {
+          completedIds.add(workflowId);
+          workflowResults.push({
+            id: workflowRef.id,
+            file: workflowRef.file,
+            status: "passed",
+            workflowResult: result
+          });
+        } else {
+          failedIds.add(workflowId);
+          pipelineFailed = true;
+          workflowResults.push({
+            id: workflowRef.id,
+            file: workflowRef.file,
+            status: "failed",
+            workflowResult: result,
+            error: result.tests.find((t) => t.status === "failed")?.error
+          });
+          const onFailure = workflowRef.on_failure ?? pipeline.on_failure;
+          if (onFailure === "fail") {
+            console.log(`
+Pipeline stopped due to workflow "${workflowId}" failure`);
+            shouldStopPipeline = true;
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to load/run workflow "${workflowId}": ${message}`);
+        failedIds.add(workflowId);
+        pipelineFailed = true;
+        workflowResults.push({
+          id: workflowRef.id,
+          file: workflowRef.file,
+          status: "failed",
+          error: message
+        });
+        const onFailure = workflowRef.on_failure ?? pipeline.on_failure;
+        if (onFailure === "fail") {
+          console.log(`
+Pipeline stopped due to workflow "${workflowId}" failure`);
+          shouldStopPipeline = true;
+        }
+      }
+    }
+    if (trackingServer) {
+      const serverResources = trackingServer.getResources(sessionId);
+      if (serverResources.length > 0) {
+        console.log(`
+Collected ${serverResources.length} server-tracked resources`);
+        executionContext.appwriteContext.resources.push(...serverResources);
+      }
+    }
+    let cleanupResult;
+    const cleanupConfig = inferCleanupConfig(pipeline.config);
+    if (cleanupConfig) {
+      const shouldCleanup = pipelineFailed ? pipeline.cleanup_on_failure : true;
+      if (shouldCleanup) {
+        try {
+          console.log("\n---");
+          console.log("[Cleanup] Starting pipeline cleanup...");
+          const { handlers, typeMappings, provider } = await loadCleanupHandlers(
+            cleanupConfig,
+            process.cwd()
+          );
+          const genericResources = executionContext.appwriteContext.resources.map(
+            (r) => ({ ...r })
+          );
+          const providerConfig = {
+            provider: cleanupConfig.provider || "appwrite"
+          };
+          if (cleanupConfig.provider === "appwrite" && cleanupConfig.appwrite) {
+            const appwriteCleanupConfig = cleanupConfig.appwrite;
+            providerConfig.endpoint = appwriteCleanupConfig.endpoint;
+            providerConfig.projectId = appwriteCleanupConfig.projectId;
+          }
+          cleanupResult = await executeCleanup(
+            genericResources,
+            handlers,
+            typeMappings,
+            {
+              parallel: cleanupConfig.parallel ?? false,
+              retries: cleanupConfig.retries ?? 3,
+              sessionId,
+              testStartTime,
+              userId: executionContext.appwriteContext.userId,
+              providerConfig,
+              cwd: process.cwd(),
+              config: cleanupConfig,
+              provider
+            }
+          );
+          if (cleanupResult.success) {
+            console.log(
+              `[Cleanup] Cleanup complete: ${cleanupResult.deleted.length} resources deleted`
+            );
+          } else {
+            console.log(
+              `[Cleanup] Cleanup partial: ${cleanupResult.deleted.length} deleted, ${cleanupResult.failed.length} failed`
+            );
+            for (const failed of cleanupResult.failed) {
+              console.log(`   - ${failed}`);
+            }
+          }
+        } catch (error) {
+          console.error("[Cleanup] Cleanup failed:", error);
+        }
+      } else {
+        console.log("\nSkipping cleanup (cleanup_on_failure is false)");
+      }
+    }
+    const passedCount = workflowResults.filter((w) => w.status === "passed").length;
+    const failedCount = workflowResults.filter((w) => w.status === "failed").length;
+    const skippedCount = workflowResults.filter((w) => w.status === "skipped").length;
+    console.log(`
+${"=".repeat(60)}`);
+    console.log(`Pipeline: ${pipelineFailed ? "FAILED" : "PASSED"}`);
+    console.log(
+      `Workflows: ${passedCount} passed, ${failedCount} failed, ${skippedCount} skipped`
+    );
+    console.log(`${"=".repeat(60)}
+`);
+    return {
+      status: pipelineFailed ? "failed" : "passed",
+      workflows: workflowResults,
+      sessionId,
+      cleanupResult
+    };
+  } finally {
+    process.off("SIGINT", signalCleanup);
+    process.off("SIGTERM", signalCleanup);
+    await browserContext.close();
+    await browser.close();
+    killServer(serverProcess);
+    if (trackingServer) {
+      await trackingServer.stop();
+    }
+    delete process.env.INTELLITESTER_SESSION_ID;
+    delete process.env.INTELLITESTER_TRACK_URL;
+  }
+}
+
+// src/generator/elementExtractor.ts
+var INTERACTIVE_TAGS = [
+  "button",
+  "input",
+  "textarea",
+  "select",
+  "a",
+  "form",
+  "label",
+  "option"
+];
+function extractTemplateContent(content, filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "vue": {
+      const templateMatch = content.match(/<template[^>]*>([\s\S]*?)<\/template>/);
+      return templateMatch ? templateMatch[1] : "";
+    }
+    case "astro": {
+      const frontmatterEnd = content.lastIndexOf("---");
+      if (frontmatterEnd > 0) {
+        return content.substring(frontmatterEnd + 3);
+      }
+      return content;
+    }
+    case "tsx":
+    case "jsx": {
+      const jsxPatterns = [
+        // return ( ... )
+        /return\s*\(([\s\S]*?)\);/g,
+        // return <...>
+        /return\s+(<[\s\S]*?>[\s\S]*?<\/[\w.]+>)/g,
+        // return <... />
+        /return\s+(<[^>]+\/\s*>)/g
+      ];
+      const jsxParts = [];
+      for (const pattern of jsxPatterns) {
+        const matches = content.matchAll(pattern);
+        for (const match of matches) {
+          jsxParts.push(match[1]);
+        }
+      }
+      return jsxParts.join("\n");
+    }
+    case "svelte": {
+      let template = content;
+      template = template.replace(/<script[^>]*>[\s\S]*?<\/script>/g, "");
+      template = template.replace(/<style[^>]*>[\s\S]*?<\/style>/g, "");
+      return template;
+    }
+    default:
+      return content;
+  }
+}
+function extractAttribute(element, attrName) {
+  const patterns = [
+    new RegExp(`${attrName}\\s*=\\s*"([^"]*)"`, "i"),
+    new RegExp(`${attrName}\\s*=\\s*'([^']*)'`, "i"),
+    new RegExp(`${attrName}\\s*=\\s*{([^}]*)}`, "i")
+    // JSX expressions
+  ];
+  for (const pattern of patterns) {
+    const match = element.match(pattern);
+    if (match && match[1]) {
+      let value = match[1].trim();
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      } else if (value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      return value;
+    }
+  }
+  return void 0;
+}
+function extractTextContent(element, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, "i");
+  const match = element.match(regex);
+  if (match && match[1]) {
+    let text = match[1].trim();
+    text = text.replace(/\{[^}]*\}/g, "").trim();
+    if (text.length > 0 && text.length < 100) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function generateDescription(element) {
+  const parts = [];
+  if (element.tag === "input" && element.type) {
+    parts.push(`${element.type} input`);
+  } else if (element.tag === "a") {
+    parts.push("link");
+  } else if (element.tag) {
+    parts.push(element.tag);
+  }
+  if (element.text) {
+    parts.push(`"${element.text}"`);
+  } else if (element.name) {
+    parts.push(`"${element.name}"`);
+  } else if (element.placeholder) {
+    parts.push(`with placeholder "${element.placeholder}"`);
+  } else if (element.testId) {
+    parts.push(`(${element.testId})`);
+  }
+  return parts.join(" ");
+}
+function parseElement(elementStr, file, route) {
+  const tagMatch = elementStr.match(/<(\w+)/);
+  if (!tagMatch) return null;
+  const tag = tagMatch[1].toLowerCase();
+  if (!INTERACTIVE_TAGS.includes(tag)) {
+    return null;
+  }
+  const element = {
+    tag,
+    file,
+    route
+  };
+  element.testId = extractAttribute(elementStr, "data-testid");
+  element.role = extractAttribute(elementStr, "role");
+  element.name = extractAttribute(elementStr, "aria-label");
+  element.type = extractAttribute(elementStr, "type");
+  element.placeholder = extractAttribute(elementStr, "placeholder");
+  if (!element.name) {
+    element.name = extractAttribute(elementStr, "name");
+  }
+  if (["button", "a", "label", "option"].includes(tag)) {
+    element.text = extractTextContent(elementStr, tag);
+  }
+  element.description = generateDescription(element);
+  return element;
+}
+function extractElements(content, filePath, route) {
+  const template = extractTemplateContent(content, filePath);
+  if (!template.trim()) {
+    return [];
+  }
+  const elements = [];
+  const elementPattern = /<(\w+)(?:\s+[^>]*)?(?:\/>|>[\s\S]*?<\/\1>)/g;
+  const matches = template.matchAll(elementPattern);
+  for (const match of matches) {
+    const elementStr = match[0];
+    const element = parseElement(elementStr, filePath, route);
+    if (element) {
+      elements.push(element);
+    }
+  }
+  return elements;
+}
+
+// src/generator/sourceScanner.ts
+var DEFAULT_EXTENSIONS = [".vue", ".astro", ".tsx", ".jsx", ".svelte"];
+function fileToRoute(filePath, pagesDir) {
+  let route = path4.relative(pagesDir, filePath);
+  route = route.replace(/\.(vue|astro|tsx|jsx|svelte)$/, "");
+  route = route.replace(/\/index$/, "");
+  route = route.replace(/^index$/, "");
+  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
+  route = route.replace(/\[(\w+)\]/g, ":$1");
+  route = "/" + route;
+  route = route.replace(/\/+/g, "/");
+  if (route.length > 1) {
+    route = route.replace(/\/$/, "");
+  }
+  return route;
+}
+function getComponentName(filePath) {
+  const basename2 = path4.basename(filePath);
+  return basename2.replace(/\.(vue|astro|tsx|jsx|svelte)$/, "");
+}
+async function scanDirectory(dir, extensions, cwd) {
+  const fullDir = path4.resolve(cwd, dir);
+  try {
+    await promises.access(fullDir);
+  } catch {
+    return [];
+  }
+  const patterns = extensions.map((ext) => `**/*${ext}`);
+  const files = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, {
+      cwd: fullDir,
+      absolute: true,
+      nodir: true
+    });
+    files.push(...matches);
+  }
+  return files;
+}
+async function scanProjectSource(config) {
+  const cwd = config.cwd ?? process.cwd();
+  const extensions = config.extensions ?? DEFAULT_EXTENSIONS;
+  const routes = [];
+  const components = [];
+  const allElements = [];
+  if (config.pagesDir) {
+    const pageFiles = await scanDirectory(config.pagesDir, extensions, cwd);
+    const pagesFullDir = path4.resolve(cwd, config.pagesDir);
+    for (const file of pageFiles) {
+      const routePath = fileToRoute(file, pagesFullDir);
+      const name = getComponentName(file);
+      routes.push({
+        path: routePath,
+        file,
+        name
+      });
+      const content = await promises.readFile(file, "utf-8");
+      const elements = extractElements(content, file, routePath);
+      components.push({
+        name,
+        file,
+        elements
+      });
+      allElements.push(...elements);
+    }
+  }
+  if (config.componentsDir) {
+    const componentFiles = await scanDirectory(config.componentsDir, extensions, cwd);
+    for (const file of componentFiles) {
+      if (components.some((c) => c.file === file)) {
+        continue;
+      }
+      const name = getComponentName(file);
+      const content = await promises.readFile(file, "utf-8");
+      const elements = extractElements(content, file, void 0);
+      components.push({
+        name,
+        file,
+        elements
+      });
+      allElements.push(...elements);
+    }
+  }
+  if (!config.pagesDir && !config.componentsDir) {
+    const commonPageDirs = ["src/pages", "pages", "app", "src/app", "src/routes"];
+    const commonComponentDirs = ["src/components", "components", "src/lib", "lib"];
+    for (const dir of commonPageDirs) {
+      const files = await scanDirectory(dir, extensions, cwd);
+      if (files.length > 0) {
+        const pagesFullDir = path4.resolve(cwd, dir);
+        for (const file of files) {
+          const routePath = fileToRoute(file, pagesFullDir);
+          const name = getComponentName(file);
+          routes.push({
+            path: routePath,
+            file,
+            name
+          });
+          const content = await promises.readFile(file, "utf-8");
+          const elements = extractElements(content, file, routePath);
+          components.push({
+            name,
+            file,
+            elements
+          });
+          allElements.push(...elements);
+        }
+        break;
+      }
+    }
+    for (const dir of commonComponentDirs) {
+      const files = await scanDirectory(dir, extensions, cwd);
+      if (files.length > 0) {
+        for (const file of files) {
+          if (components.some((c) => c.file === file)) {
+            continue;
+          }
+          const name = getComponentName(file);
+          const content = await promises.readFile(file, "utf-8");
+          const elements = extractElements(content, file, void 0);
+          components.push({
+            name,
+            file,
+            elements
+          });
+          allElements.push(...elements);
+        }
+        break;
+      }
+    }
+  }
+  return {
+    routes,
+    components,
+    allElements
+  };
+}
+function formatScanResultsForPrompt(result) {
+  const lines = [];
+  if (result.routes.length > 0) {
+    lines.push("## ROUTES");
+    lines.push("");
+    for (const route of result.routes) {
+      lines.push(`- ${route.path}: ${route.name}`);
+    }
+    lines.push("");
+  }
+  const elementsByRoute = /* @__PURE__ */ new Map();
+  for (const element of result.allElements) {
+    const route = element.route ?? "shared";
+    if (!elementsByRoute.has(route)) {
+      elementsByRoute.set(route, []);
+    }
+    elementsByRoute.get(route).push(element);
+  }
+  lines.push("## ELEMENTS");
+  lines.push("");
+  for (const [route, elements] of elementsByRoute) {
+    lines.push(`### ${route === "shared" ? "Shared Components" : route}`);
+    lines.push("");
+    for (const el of elements) {
+      const locators = [];
+      if (el.testId) locators.push(`data-testid="${el.testId}"`);
+      if (el.text) locators.push(`text="${el.text}"`);
+      if (el.role) locators.push(`role="${el.role}"`);
+      if (el.name) locators.push(`name="${el.name}"`);
+      if (el.placeholder) locators.push(`placeholder="${el.placeholder}"`);
+      if (el.type) locators.push(`type="${el.type}"`);
+      const locatorStr = locators.length > 0 ? `[${locators.join(", ")}]` : "";
+      const description = el.description ? ` - ${el.description}` : "";
+      lines.push(`- <${el.tag}>${locatorStr}${description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/generator/prompts.ts
+var SYSTEM_PROMPT = `You are a test automation expert that converts natural language test descriptions into YAML test definitions.
+
+## Schema Structure
+
+A test definition must have:
+- name: A descriptive test name (non-empty string)
+- platform: One of 'web', 'android', or 'ios'
+- config: Optional configuration object
+- steps: Array of actions (minimum 1 action required)
+
+## Available Actions
+
+1. navigate - Navigate to a URL
+   { type: 'navigate', value: string }
+
+2. tap - Click or tap an element
+   { type: 'tap', target: Locator }
+
+3. input - Type text into an input field
+   { type: 'input', target: Locator, value: string }
+
+4. assert - Assert element exists or contains text
+   { type: 'assert', target: Locator, value?: string }
+
+5. wait - Wait for an element or timeout
+   { type: 'wait', target?: Locator, timeout?: number }
+   Note: Requires either target or timeout
+
+6. scroll - Scroll the page or to an element
+   { type: 'scroll', target?: Locator, direction?: 'up'|'down', amount?: number }
+
+7. screenshot - Take a screenshot
+   { type: 'screenshot', name?: string }
+
+## Locator Structure
+
+A locator must have AT LEAST ONE of these properties:
+- description: Human-readable description for AI healing
+- testId: data-testid attribute value
+- text: Text content to match
+- css: CSS selector
+- xpath: XPath expression
+- role: ARIA role attribute
+- name: Accessible name
+
+## Configuration Options
+
+web:
+  baseUrl: Base URL for the application
+  browser: Browser to use (e.g., 'chromium', 'firefox', 'webkit')
+  headless: Run browser in headless mode (boolean)
+  timeout: Default timeout in milliseconds
+
+android:
+  appId: Android application package ID
+  device: Device name or ID
+
+ios:
+  bundleId: iOS bundle identifier
+  simulator: Simulator name
+
+## Example 1: Login Test
+
+\`\`\`yaml
+name: Login with valid credentials
+platform: web
+config:
+  web:
+    baseUrl: https://example.com
+    headless: true
+steps:
+  - type: navigate
+    value: /login
+  - type: input
+    target:
+      testId: email-input
+      description: Email input field
+    value: test@example.com
+  - type: input
+    target:
+      testId: password-input
+      description: Password input field
+    value: password123
+  - type: tap
+    target:
+      text: Sign In
+      role: button
+      description: Sign in button
+  - type: assert
+    target:
+      text: Welcome
+      description: Welcome message after login
+\`\`\`
+
+## Example 2: Search Test
+
+\`\`\`yaml
+name: Search for products
+platform: web
+config:
+  web:
+    baseUrl: https://shop.example.com
+steps:
+  - type: navigate
+    value: /
+  - type: input
+    target:
+      css: input[type="search"]
+      description: Product search input
+    value: laptop
+  - type: tap
+    target:
+      role: button
+      name: Search
+      description: Search button
+  - type: wait
+    target:
+      css: .search-results
+      description: Search results container
+    timeout: 5000
+  - type: assert
+    target:
+      text: results found
+      description: Results count message
+\`\`\`
+
+## Example 3: Mobile App Test
+
+\`\`\`yaml
+name: Add item to cart
+platform: android
+config:
+  android:
+    appId: com.example.shop
+steps:
+  - type: tap
+    target:
+      testId: category-electronics
+      description: Electronics category button
+  - type: scroll
+    direction: down
+    amount: 300
+  - type: tap
+    target:
+      text: Laptop Pro
+      description: Product card for Laptop Pro
+  - type: tap
+    target:
+      testId: add-to-cart-button
+      description: Add to cart button
+  - type: assert
+    target:
+      text: Added to cart
+      description: Success message
+  - type: screenshot
+    name: cart-confirmation
+\`\`\`
+
+## Important Instructions
+
+1. Output ONLY valid YAML - no markdown code blocks, no explanations
+2. Every locator MUST have at least one selector property
+3. Include descriptive locator descriptions for AI healing
+4. Use multiple locator strategies when possible for resilience
+5. For wait actions, provide either a target or timeout (or both)
+6. Use appropriate platform-specific configurations
+7. Ensure all strings are properly quoted if they contain special characters
+8. Action steps must be in logical order
+
+Generate the test definition now based on the user's description.`;
+function buildPrompt(naturalLanguage, context) {
+  const parts = [
+    "Generate a test definition for the following scenario:",
+    "",
+    naturalLanguage
+  ];
+  if (context) {
+    parts.push("", "Additional Context:");
+    if (context.platform) {
+      parts.push(`- Platform: ${context.platform}`);
+    }
+    if (context.baseUrl) {
+      parts.push(`- Base URL: ${context.baseUrl}`);
+    }
+    if (context.additionalContext) {
+      parts.push(`- ${context.additionalContext}`);
+    }
+  }
+  parts.push("", "Output only valid YAML without code block markers.");
+  return parts.join("\n");
+}
+function buildSourceAwareSystemPrompt(scanResult) {
+  const parts = [
+    "You are a test automation expert that converts natural language test descriptions into YAML test definitions.",
+    "",
+    "## Schema Structure",
+    "",
+    "A test definition must have:",
+    "- name: A descriptive test name (non-empty string)",
+    "- platform: One of 'web', 'android', or 'ios'",
+    "- config: Optional configuration object",
+    "- steps: Array of actions (minimum 1 action required)",
+    "",
+    "## Available Actions",
+    "",
+    "1. navigate - Navigate to a URL",
+    "   { type: 'navigate', value: string }",
+    "",
+    "2. tap - Click or tap an element",
+    "   { type: 'tap', target: Locator }",
+    "",
+    "3. input - Type text into an input field",
+    "   { type: 'input', target: Locator, value: string }",
+    "",
+    "4. assert - Assert element exists or contains text",
+    "   { type: 'assert', target: Locator, value?: string }",
+    "",
+    "5. wait - Wait for an element or timeout",
+    "   { type: 'wait', target?: Locator, timeout?: number }",
+    "   Note: Requires either target or timeout",
+    "",
+    "6. scroll - Scroll the page or to an element",
+    "   { type: 'scroll', target?: Locator, direction?: 'up'|'down', amount?: number }",
+    "",
+    "7. screenshot - Take a screenshot",
+    "   { type: 'screenshot', name?: string }",
+    "",
+    "## Locator Structure",
+    "",
+    "A locator must have AT LEAST ONE of these properties:",
+    "- description: Human-readable description for AI healing",
+    "- testId: data-testid attribute value",
+    "- text: Text content to match",
+    "- css: CSS selector",
+    "- xpath: XPath expression",
+    "- role: ARIA role attribute",
+    "- name: Accessible name",
+    "",
+    "## PROJECT STRUCTURE",
+    "",
+    "The following routes and elements were extracted from the project source code.",
+    "Use these REAL selectors in your generated tests.",
+    "",
+    "### Selector Priority (prefer earlier options):",
+    "1. text - Most resilient to DOM changes",
+    "2. role + name - ARIA-compliant, accessible",
+    "3. testId - Explicit but requires dev setup",
+    "4. css - Last resort, fragile",
+    ""
+  ];
+  parts.push(formatScanResultsForPrompt(scanResult));
+  parts.push(
+    "## Configuration Options",
+    "",
+    "web:",
+    "  baseUrl: Base URL for the application",
+    "  browser: Browser to use (e.g., 'chromium', 'firefox', 'webkit')",
+    "  headless: Run browser in headless mode (boolean)",
+    "  timeout: Default timeout in milliseconds",
+    "",
+    "android:",
+    "  appId: Android application package ID",
+    "  device: Device name or ID",
+    "",
+    "ios:",
+    "  bundleId: iOS bundle identifier",
+    "  simulator: Simulator name",
+    "",
+    "## Example Test Structure",
+    "",
+    "```yaml",
+    "name: Example test name",
+    "platform: web",
+    "config:",
+    "  web:",
+    "    baseUrl: https://example.com",
+    "    headless: true",
+    "steps:",
+    "  - type: navigate",
+    "    value: /login",
+    "  - type: input",
+    "    target:",
+    "      text: Email",
+    "      description: Email input field",
+    "    value: test@example.com",
+    "  - type: input",
+    "    target:",
+    "      role: textbox",
+    "      name: Password",
+    "      description: Password input field",
+    "    value: password123",
+    "  - type: tap",
+    "    target:",
+    "      text: Sign In",
+    "      role: button",
+    "      description: Sign in button",
+    "  - type: assert",
+    "    target:",
+    "      text: Welcome",
+    "      description: Welcome message after login",
+    "```",
+    "",
+    "## Important Instructions",
+    "",
+    "1. Output ONLY valid YAML - no markdown code blocks, no explanations",
+    "2. Use REAL selectors from the project structure above whenever possible",
+    "3. Every locator MUST have at least one selector property",
+    "4. Include descriptive locator descriptions for AI healing",
+    "5. Prefer text and role selectors over testId and css for resilience",
+    "6. Use multiple locator strategies when possible for resilience",
+    "7. For wait actions, provide either a target or timeout (or both)",
+    "8. Use appropriate platform-specific configurations",
+    "9. Ensure all strings are properly quoted if they contain special characters",
+    "10. Action steps must be in logical order",
+    "",
+    "Generate the test definition now based on the user's description."
+  );
+  return parts.join("\n");
+}
+
+// src/generator/testGenerator.ts
+function cleanYamlResponse(response) {
+  let cleaned = response.replace(/```ya?ml\n?/gi, "").replace(/```\n?/g, "");
+  cleaned = cleaned.trim();
+  return cleaned;
+}
+async function generateTest(naturalLanguage, options) {
+  const provider = createAIProvider(options.aiConfig);
+  let systemPrompt = SYSTEM_PROMPT;
+  if (options.source !== null) {
+    const sourceConfig = options.source ?? {};
+    const scanResult = await scanProjectSource(sourceConfig);
+    if (scanResult.allElements.length > 0) {
+      systemPrompt = buildSourceAwareSystemPrompt(scanResult);
+    }
+  }
+  const context = {
+    baseUrl: options.baseUrl,
+    platform: options.platform,
+    additionalContext: options.additionalContext
+  };
+  const userPrompt = buildPrompt(naturalLanguage, context);
+  const maxRetries = options.maxRetries ?? 3;
+  let lastError;
+  let lastYaml;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      let promptWithFeedback = userPrompt;
+      if (attempt > 0 && lastError) {
+        promptWithFeedback = `${userPrompt}
+
+Previous attempt failed with error: ${lastError.message}
+
+Please fix the issue and generate valid YAML.`;
+      }
+      const response = await provider.generateCompletion(promptWithFeedback, systemPrompt);
+      const yaml = cleanYamlResponse(response);
+      lastYaml = yaml;
+      const parsed = parse(yaml);
+      const validated = TestDefinitionSchema.parse(parsed);
+      return {
+        success: true,
+        test: validated,
+        yaml,
+        attempts: attempt + 1
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxRetries - 1) {
+        return {
+          success: false,
+          error: `Failed to generate valid test after ${maxRetries} attempts. Last error: ${lastError.message}`,
+          yaml: lastYaml,
+          attempts: maxRetries
+        };
+      }
+    }
+  }
+  return {
+    success: false,
+    error: "Unknown error occurred during test generation",
+    attempts: maxRetries
+  };
+}
+function displayMissingEnvVars(missing) {
+  console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log("\u2502  \u26A0\uFE0F  Missing Environment Variables          \u2502");
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  for (const name of missing) {
+    console.log(`\u2502  \u2022 ${name.padEnd(39)}\u2502`);
+  }
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n");
+}
+async function promptAddToEnv(missing, envPath) {
+  const { shouldAdd } = await prompts({
+    type: "confirm",
+    name: "shouldAdd",
+    message: `Add missing variables to ${path4__default.basename(envPath)}?`,
+    initial: true
+  });
+  if (!shouldAdd) return false;
+  const values = {};
+  for (const name of missing) {
+    const { value } = await prompts({
+      type: "password",
+      // Hide sensitive values
+      name: "value",
+      message: `Enter value for ${name}:`
+    });
+    if (value !== void 0) {
+      values[name] = value;
+    }
+  }
+  const lines = Object.entries(values).map(([key, val]) => `${key}=${val}`).join("\n");
+  let existingContent = "";
+  try {
+    existingContent = await fs3.readFile(envPath, "utf8");
+  } catch {
+  }
+  const newContent = existingContent ? `${existingContent.trimEnd()}
+${lines}
+` : `${lines}
+`;
+  await fs3.writeFile(envPath, newContent, "utf8");
+  console.log(`
+\u2713 Added ${missing.length} variable(s) to ${path4__default.basename(envPath)}
+`);
+  dotenv2.config({ path: envPath, override: true });
+  return true;
+}
+async function validateEnvVars(missing, projectDir) {
+  if (missing.length === 0) return true;
+  displayMissingEnvVars(missing);
+  const envPath = path4__default.join(projectDir, ".env");
+  const added = await promptAddToEnv(missing, envPath);
+  if (!added) {
+    console.log("Cannot continue without required environment variables.");
+    return false;
+  }
+  return true;
+}
+
+// src/cli/index.ts
+dotenv2.config();
+var CONFIG_FILENAME = "intellitester.config.yaml";
+var BROWSER_ALIASES = {
+  chrome: "chromium",
+  chromium: "chromium",
+  safari: "webkit",
+  webkit: "webkit",
+  firefox: "firefox",
+  ff: "firefox"
+};
+var resolveBrowserName = (input) => {
+  const normalized = input.toLowerCase().trim();
+  const resolved = BROWSER_ALIASES[normalized];
+  if (!resolved) {
+    const valid = Object.keys(BROWSER_ALIASES).join(", ");
+    throw new Error(`Unknown browser "${input}". Valid options: ${valid}`);
+  }
+  return resolved;
+};
+var detectPackageManager = async () => {
+  if (await fileExists("pnpm-lock.yaml")) return "pnpm";
+  if (await fileExists("bun.lockb")) return "bun";
+  if (await fileExists("yarn.lock")) return "yarn";
+  return "npm";
+};
+var execCommand = async (cmd, args, cwd) => {
+  return new Promise((resolve2, reject) => {
+    console.log(`Running: ${cmd} ${args.join(" ")}`);
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve2();
+      else reject(new Error(`Command failed with exit code ${code}`));
+    });
+    child.on("error", reject);
+  });
+};
+var buildAndPreview = async (config, cwd) => {
+  const pm = await detectPackageManager();
+  const previewConfig = config?.preview || {};
+  const buildCmd = previewConfig.build?.command || `${pm} run build`;
+  const [buildExec, ...buildArgs] = buildCmd.split(" ");
+  const previewCmd = previewConfig.preview?.command || `${pm} run preview`;
+  const [previewExec, ...previewArgs] = previewCmd.split(" ");
+  const previewUrl = previewConfig.url || config?.webServer?.url || config?.platforms?.web?.baseUrl || "http://localhost:4321";
+  const timeout = previewConfig.timeout || 6e4;
+  console.log("\n\u{1F4E6} Building project...\n");
+  await execCommand(buildExec, buildArgs, cwd);
+  console.log("\n\u2705 Build complete\n");
+  console.log("\n\u{1F680} Starting preview server...\n");
+  const previewProcess = await startPreviewServer(previewExec, previewArgs, cwd, previewUrl, timeout);
+  const cleanup = () => {
+    if (previewProcess && !previewProcess.killed) {
+      console.log("\n\u{1F6D1} Stopping preview server...");
+      previewProcess.kill("SIGTERM");
+    }
+  };
+  process2.on("SIGINT", cleanup);
+  process2.on("SIGTERM", cleanup);
+  return { previewProcess, cleanup };
+};
+var startPreviewServer = async (cmd, args, cwd, url, timeout = 6e4) => {
+  return new Promise((resolve2, reject) => {
+    console.log(`Starting preview server: ${cmd} ${args.join(" ")}`);
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: "pipe",
+      shell: true
+    });
+    let output = "";
+    const startTime = Date.now();
+    const checkServer = async () => {
+      try {
+        const response = await fetch(url, { method: "HEAD" });
+        if (response.ok || response.status < 500) {
+          console.log(`Preview server ready at ${url}`);
+          resolve2(child);
+          return true;
+        }
+      } catch {
+      }
+      return false;
+    };
+    const pollInterval = setInterval(async () => {
+      if (await checkServer()) {
+        clearInterval(pollInterval);
+      } else if (Date.now() - startTime > timeout) {
+        clearInterval(pollInterval);
+        child.kill();
+        reject(new Error(`Preview server failed to start within ${timeout}ms`));
+      }
+    }, 500);
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+      process2.stdout.write(data);
+    });
+    child.stderr?.on("data", (data) => {
+      output += data.toString();
+      process2.stderr.write(data);
+    });
+    child.on("error", (err) => {
+      clearInterval(pollInterval);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearInterval(pollInterval);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Preview server exited with code ${code}
+${output}`));
+      }
+    });
+  });
+};
+var logError = (message) => {
+  console.error(`Error: ${message}`);
+};
+var findProjectRoot = async (startPath) => {
+  let currentDir = path4__default.isAbsolute(startPath) ? startPath : path4__default.resolve(startPath);
+  try {
+    const stat = await fs3.stat(currentDir);
+    if (stat.isFile()) {
+      currentDir = path4__default.dirname(currentDir);
+    }
+  } catch {
+    currentDir = path4__default.dirname(currentDir);
+  }
+  const root = path4__default.parse(currentDir).root;
+  while (currentDir !== root) {
+    const markers = ["package.json", ".git", CONFIG_FILENAME];
+    for (const marker of markers) {
+      if (await fileExists(path4__default.join(currentDir, marker))) {
+        return currentDir;
+      }
+    }
+    const parentDir = path4__default.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+};
+var loadProjectEnv = async (targetPath) => {
+  const projectRoot = await findProjectRoot(targetPath);
+  if (projectRoot) {
+    const envPath = path4__default.join(projectRoot, ".env");
+    if (await fileExists(envPath)) {
+      dotenv2.config({ path: envPath, override: false });
+      console.log(`Loaded .env from ${projectRoot}`);
+    }
+  }
+};
+var fileExists = async (filePath) => {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var collectYamlFiles = async (target) => {
+  const stat = await fs3.stat(target);
+  if (stat.isFile()) return [target];
+  if (!stat.isDirectory()) {
+    throw new Error(`Unsupported target: ${target}`);
+  }
+  const entries = await fs3.readdir(target, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path4__default.join(target, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectYamlFiles(fullPath);
+      files.push(...nested);
+    } else if (entry.isFile() && (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml"))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+var discoverTestFiles = async (testsDir = "tests") => {
+  const absoluteDir = path4__default.resolve(testsDir);
+  if (!await fileExists(absoluteDir)) {
+    return { pipelines: [], workflows: [], tests: [] };
+  }
+  const allFiles = await collectYamlFiles(absoluteDir);
+  const pipelines = [];
+  const workflows = [];
+  const tests = [];
+  for (const file of allFiles) {
+    const name = path4__default.basename(file).toLowerCase();
+    if (name.endsWith(".pipeline.yaml") || name.endsWith(".pipeline.yml")) {
+      pipelines.push(file);
+    } else if (name.endsWith(".workflow.yaml") || name.endsWith(".workflow.yml")) {
+      workflows.push(file);
+    } else if (name.endsWith(".test.yaml") || name.endsWith(".test.yml")) {
+      tests.push(file);
+    }
+  }
+  return { pipelines, workflows, tests };
+};
+var writeFileIfMissing = async (filePath, contents) => {
+  if (await fileExists(filePath)) return;
+  await fs3.mkdir(path4__default.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, contents, "utf8");
+};
+var initCommand = async () => {
+  const configTemplate = `defaults:
+  timeout: 30000
+  screenshots: on-failure
+
+platforms:
+  web:
+    baseUrl: http://localhost:3000
+    headless: true
+
+ai:
+  provider: anthropic
+  model: claude-3-5-sonnet-20241022
+  apiKey: \${ANTHROPIC_API_KEY}
+  temperature: 0
+  maxTokens: 4096
+
+email:
+  provider: inbucket
+  endpoint: http://localhost:9000
+
+appwrite:
+  endpoint: https://cloud.appwrite.io/v1
+  projectId: your-project-id
+  apiKey: your-api-key
+`;
+  const sampleTest = `name: Example web smoke test
+platform: web
+config:
+  web:
+    baseUrl: http://localhost:3000
+
+steps:
+  - type: navigate
+    value: /
+
+  - type: assert
+    target:
+      text: "Welcome"
+`;
+  await writeFileIfMissing(path4__default.resolve(CONFIG_FILENAME), configTemplate);
+  await writeFileIfMissing(path4__default.resolve("tests", "example.web.test.yaml"), sampleTest);
+  console.log("Initialized intellitester.config.yaml and tests/example.web.test.yaml");
+};
+var validateCommand = async (target) => {
+  const absoluteTarget = path4__default.resolve(target);
+  const files = await collectYamlFiles(absoluteTarget);
+  if (files.length === 0) {
+    throw new Error(`No YAML files found at ${absoluteTarget}`);
+  }
+  for (const file of files) {
+    await loadTestDefinition(file);
+    console.log(`\u2713 ${path4__default.relative(process2.cwd(), file)} valid`);
+  }
+};
+var resolveBaseUrl = (test, configBaseUrl) => test.config?.web?.baseUrl ?? configBaseUrl;
+var runTestCommand = async (target, options) => {
+  const absoluteTarget = path4__default.resolve(target);
+  await loadProjectEnv(absoluteTarget);
+  const { parse: parse2 } = await import('yaml');
+  const testContent = await fs3.readFile(absoluteTarget, "utf8");
+  const parsedTest = parse2(testContent);
+  const hasConfigFile = await fileExists(CONFIG_FILENAME);
+  let parsedConfig = void 0;
+  if (hasConfigFile) {
+    const configContent = await fs3.readFile(CONFIG_FILENAME, "utf8");
+    parsedConfig = parse2(configContent);
+  }
+  const configMissing = parsedConfig ? collectMissingEnvVars(parsedConfig) : [];
+  const testMissing = collectMissingEnvVars(parsedTest);
+  const allMissing = [.../* @__PURE__ */ new Set([...configMissing, ...testMissing])];
+  if (allMissing.length > 0) {
+    const projectRoot = await findProjectRoot(absoluteTarget);
+    const canContinue = await validateEnvVars(allMissing, projectRoot || process2.cwd());
+    if (!canContinue) {
+      process2.exit(1);
+    }
+  }
+  const test = await loadTestDefinition(absoluteTarget);
+  const config = hasConfigFile ? await loadIntellitesterConfig(CONFIG_FILENAME) : void 0;
+  const baseUrl = resolveBaseUrl(test, config?.platforms?.web?.baseUrl);
+  const headed = options.headed ?? false;
+  const browser = options.browser ?? "chromium";
+  const skipWebServer = options.noServer ?? false;
+  const debug = options.debug ?? false;
+  const interactive = options.interactive ?? false;
+  const modeFlags = [];
+  if (headed) modeFlags.push("headed");
+  if (debug) modeFlags.push("debug mode");
+  if (interactive) modeFlags.push("interactive");
+  console.log(
+    `Running ${path4__default.basename(absoluteTarget)} on web (${browser}${modeFlags.length > 0 ? ", " + modeFlags.join(", ") : ""})`
+  );
+  const result = await runWebTest(test, {
+    baseUrl,
+    headed,
+    browser,
+    defaultTimeoutMs: config?.defaults?.timeout,
+    webServer: !skipWebServer && config?.webServer ? config.webServer : void 0,
+    debug,
+    interactive,
+    aiConfig: interactive ? config?.ai : void 0
+  });
+  for (const step of result.steps) {
+    const label = `[${step.status === "passed" ? "OK" : "FAIL"}] ${step.action.type}`;
+    if (step.error) {
+      console.error(`${label} - ${step.error}`);
+    } else {
+      console.log(label);
+    }
+  }
+  if (result.status === "failed") {
+    process2.exitCode = 1;
+  }
+};
+var generateCommand = async (prompt, options) => {
+  const targetPath = options.output ? path4__default.resolve(options.output) : process2.cwd();
+  await loadProjectEnv(targetPath);
+  const hasConfigFile = await fileExists(CONFIG_FILENAME);
+  if (!hasConfigFile) {
+    throw new Error('No intellitester.config.yaml found. Run "intellitester init" first and configure AI settings.');
+  }
+  const { parse: parse2 } = await import('yaml');
+  const configContent = await fs3.readFile(CONFIG_FILENAME, "utf8");
+  const parsedConfig = parse2(configContent);
+  const configMissing = collectMissingEnvVars(parsedConfig);
+  if (configMissing.length > 0) {
+    const projectRoot = await findProjectRoot(CONFIG_FILENAME);
+    const canContinue = await validateEnvVars(configMissing, projectRoot || process2.cwd());
+    if (!canContinue) {
+      process2.exit(1);
+    }
+  }
+  const config = await loadIntellitesterConfig(CONFIG_FILENAME);
+  if (!config.ai) {
+    throw new Error('AI configuration missing in intellitester.config.yaml. Add "ai:" section with provider, model, and apiKey.');
+  }
+  const source = options.noSource ? null : options.pagesDir || options.componentsDir ? {
+    pagesDir: options.pagesDir,
+    componentsDir: options.componentsDir
+  } : void 0;
+  const generateOptions = {
+    aiConfig: config.ai,
+    baseUrl: options.baseUrl,
+    platform: options.platform,
+    source
+  };
+  console.log("Generating test...");
+  const result = await generateTest(prompt, generateOptions);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to generate test");
+  }
+  if (options.output) {
+    await fs3.mkdir(path4__default.dirname(options.output), { recursive: true });
+    await fs3.writeFile(options.output, result.yaml, "utf8");
+    console.log(`\u2713 Test saved to ${options.output}`);
+  } else {
+    console.log("\n--- Generated Test ---\n");
+    console.log(result.yaml);
+  }
+};
+var runWorkflowCommand = async (file, options) => {
+  const workflowPath = path4__default.resolve(file);
+  if (!await fileExists(workflowPath)) {
+    logError(`Workflow file not found: ${file}`);
+    process2.exit(1);
+  }
+  await loadProjectEnv(workflowPath);
+  console.log(`Running workflow: ${file}`);
+  const { parse: parse2 } = await import('yaml');
+  const workflowContent = await fs3.readFile(workflowPath, "utf8");
+  const parsedWorkflow = parse2(workflowContent);
+  const hasConfigFile = await fileExists(CONFIG_FILENAME);
+  let parsedConfig = void 0;
+  if (hasConfigFile) {
+    const configContent = await fs3.readFile(CONFIG_FILENAME, "utf8");
+    parsedConfig = parse2(configContent);
+  }
+  const configMissing = parsedConfig ? collectMissingEnvVars(parsedConfig) : [];
+  const workflowMissing = collectMissingEnvVars(parsedWorkflow);
+  const allMissing = [.../* @__PURE__ */ new Set([...configMissing, ...workflowMissing])];
+  if (allMissing.length > 0) {
+    const projectRoot = await findProjectRoot(workflowPath);
+    const canContinue = await validateEnvVars(allMissing, projectRoot || process2.cwd());
+    if (!canContinue) {
+      process2.exit(1);
+    }
+  }
+  const workflow = await loadWorkflowDefinition(workflowPath);
+  const config = hasConfigFile ? await loadIntellitesterConfig(CONFIG_FILENAME) : void 0;
+  const result = await runWorkflow(workflow, workflowPath, {
+    headed: options.visible,
+    browser: options.browser,
+    interactive: options.interactive,
+    debug: options.debug,
+    aiConfig: config?.ai
+  });
+  console.log(`
+Workflow: ${workflow.name}`);
+  console.log(`Session ID: ${result.sessionId}`);
+  console.log(`Status: ${result.status}
+`);
+  for (const test of result.tests) {
+    const icon = test.status === "passed" ? "\u2713" : test.status === "failed" ? "\u2717" : "\u25CB";
+    console.log(`  ${icon} ${test.file} (${test.status})`);
+    if (test.error) {
+      console.log(`    Error: ${test.error}`);
+    }
+  }
+  if (result.cleanupResult) {
+    console.log(`
+Cleanup: ${result.cleanupResult.deleted.length} resources deleted`);
+    if (result.cleanupResult.failed.length > 0) {
+      console.log(`  Failed to delete: ${result.cleanupResult.failed.join(", ")}`);
+    }
+  }
+  process2.exit(result.status === "passed" ? 0 : 1);
+};
+var runPipelineCommand = async (file, options) => {
+  const pipelinePath = path4__default.resolve(file);
+  if (!await fileExists(pipelinePath)) {
+    logError(`Pipeline file not found: ${file}`);
+    process2.exit(1);
+  }
+  await loadProjectEnv(pipelinePath);
+  console.log(`Running pipeline: ${file}`);
+  const { parse: parse2 } = await import('yaml');
+  const pipelineContent = await fs3.readFile(pipelinePath, "utf8");
+  const parsedPipeline = parse2(pipelineContent);
+  const hasConfigFile = await fileExists(CONFIG_FILENAME);
+  let parsedConfig = void 0;
+  if (hasConfigFile) {
+    const configContent = await fs3.readFile(CONFIG_FILENAME, "utf8");
+    parsedConfig = parse2(configContent);
+  }
+  const configMissing = parsedConfig ? collectMissingEnvVars(parsedConfig) : [];
+  const pipelineMissing = collectMissingEnvVars(parsedPipeline);
+  const allMissing = [.../* @__PURE__ */ new Set([...configMissing, ...pipelineMissing])];
+  if (allMissing.length > 0) {
+    const projectRoot = await findProjectRoot(pipelinePath);
+    const canContinue = await validateEnvVars(allMissing, projectRoot || process2.cwd());
+    if (!canContinue) {
+      process2.exit(1);
+    }
+  }
+  const pipeline = await loadPipelineDefinition(pipelinePath);
+  hasConfigFile ? await loadIntellitesterConfig(CONFIG_FILENAME) : void 0;
+  const result = await runPipeline(pipeline, pipelinePath, {
+    headed: options.visible,
+    browser: options.browser,
+    interactive: options.interactive,
+    debug: options.debug
+  });
+  console.log(`
+Pipeline: ${pipeline.name}`);
+  console.log(`Session ID: ${result.sessionId}`);
+  console.log(`Status: ${result.status}
+`);
+  for (const workflow of result.workflows) {
+    const icon = workflow.status === "passed" ? "\u2713" : workflow.status === "failed" ? "\u2717" : "\u25CB";
+    console.log(`  ${icon} ${workflow.file} (${workflow.status})`);
+    if (workflow.error) {
+      console.log(`    Error: ${workflow.error}`);
+    }
+  }
+  if (result.cleanupResult) {
+    console.log(`
+Cleanup: ${result.cleanupResult.deleted.length} resources deleted`);
+    if (result.cleanupResult.failed.length > 0) {
+      console.log(`  Failed to delete: ${result.cleanupResult.failed.join(", ")}`);
+    }
+  }
+  process2.exit(result.status === "passed" ? 0 : 1);
+};
+var main = async () => {
+  const program = new Command();
+  program.name("intellitester").description("AI-powered cross-platform test automation").version("1.0.0");
+  program.command("init").description("Initialize IntelliTester in current directory").action(async () => {
+    try {
+      await initCommand();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(message);
+      process2.exitCode = 1;
+    }
+  });
+  program.command("validate").description("Validate test YAML files").argument("[file]", "Test file or directory to validate", "tests").action(async (file) => {
+    try {
+      await validateCommand(file);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(message);
+      process2.exitCode = 1;
+    }
+  });
+  program.command("run").description("Run test file(s), workflow, or auto-discover tests in tests/ directory").argument("[file]", "Test file, workflow, or pipeline to run (auto-discovers if omitted)").option("--visible", "Run browser in visible mode (not headless)").option("--browser <name>", "Browser to use (chrome, safari, firefox)", "chrome").option("--preview", "Build project and run against preview server").option("--no-server", "Skip auto-starting web server").option("-i, --interactive", "Interactive mode - AI suggests fixes on failure").option("--debug", "Debug mode - verbose logging").action(async (file, options) => {
+    let previewCleanup = null;
+    try {
+      const browser = resolveBrowserName(options.browser || "chrome");
+      if (options.preview) {
+        const hasConfigFile = await fileExists(CONFIG_FILENAME);
+        const config = hasConfigFile ? await loadIntellitesterConfig(CONFIG_FILENAME) : void 0;
+        const { cleanup } = await buildAndPreview(config, process2.cwd());
+        previewCleanup = cleanup;
+      }
+      const runOpts = {
+        visible: options.visible,
+        browser,
+        interactive: options.interactive,
+        debug: options.debug
+      };
+      if (!file) {
+        const discovered = await discoverTestFiles("tests");
+        const total = discovered.pipelines.length + discovered.workflows.length + discovered.tests.length;
+        if (total === 0) {
+          logError("No test files found in tests/ directory. Create .pipeline.yaml, .workflow.yaml, or .test.yaml files.");
+          process2.exit(1);
+        }
+        console.log(`Discovered ${total} test file(s):`);
+        if (discovered.pipelines.length > 0) {
+          console.log(`  Pipelines: ${discovered.pipelines.length}`);
+        }
+        if (discovered.workflows.length > 0) {
+          console.log(`  Workflows: ${discovered.workflows.length}`);
+        }
+        if (discovered.tests.length > 0) {
+          console.log(`  Tests: ${discovered.tests.length}`);
+        }
+        console.log("");
+        let failed = false;
+        for (const pipeline of discovered.pipelines) {
+          try {
+            await runPipelineCommand(pipeline, runOpts);
+          } catch {
+            failed = true;
+          }
+        }
+        for (const workflow of discovered.workflows) {
+          try {
+            await runWorkflowCommand(workflow, runOpts);
+          } catch {
+            failed = true;
+          }
+        }
+        for (const test of discovered.tests) {
+          try {
+            await runTestCommand(test, {
+              headed: options.visible,
+              browser,
+              noServer: !options.server,
+              interactive: options.interactive,
+              debug: options.debug
+            });
+          } catch {
+            failed = true;
+          }
+        }
+        if (failed) {
+          process2.exitCode = 1;
+        }
+        return;
+      }
+      if (isPipelineFile(file)) {
+        await runPipelineCommand(file, runOpts);
+        return;
+      }
+      if (isWorkflowFile(file)) {
+        await runWorkflowCommand(file, runOpts);
+        return;
+      }
+      await runTestCommand(file, {
+        headed: options.visible,
+        browser,
+        noServer: !options.server,
+        interactive: options.interactive,
+        debug: options.debug
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(message);
+      process2.exitCode = 1;
+    } finally {
+      if (previewCleanup) {
+        previewCleanup();
+      }
+    }
+  });
+  program.command("generate").description("Generate test from natural language").argument("<description>", "Natural language description of the test").option("--output <file>", "Output file path").option("--platform <platform>", "Target platform", "web").option("--baseUrl <url>", "Base URL for the app").option("--pagesDir <dir>", "Pages directory for source scanning").option("--componentsDir <dir>", "Components directory for source scanning").option("--no-source", "Disable source scanning").action(async (description, options) => {
+    try {
+      await generateCommand(description, {
+        output: options.output,
+        platform: options.platform,
+        baseUrl: options.baseUrl,
+        pagesDir: options.pagesDir,
+        componentsDir: options.componentsDir,
+        noSource: !options.source
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(message);
+      process2.exitCode = 1;
+    }
+  });
+  program.command("cleanup:list").description("List pending failed cleanup operations from previous test runs").action(async () => {
+    try {
+      const failedCleanups = await loadFailedCleanups(process2.cwd());
+      if (failedCleanups.length === 0) {
+        console.log("No failed cleanups found.");
+        return;
+      }
+      console.log(`
+Found ${failedCleanups.length} failed cleanup(s):
+`);
+      for (const failed of failedCleanups) {
+        console.log(`Session: ${failed.sessionId}`);
+        console.log(`  Timestamp: ${failed.timestamp}`);
+        console.log(`  Provider: ${failed.providerConfig.provider}`);
+        console.log(`  Resources: ${failed.resources.length}`);
+        for (const resource of failed.resources) {
+          console.log(`    - ${resource.type}:${resource.id}`);
+        }
+        console.log(`  Errors: ${failed.errors.length}`);
+        for (const error of failed.errors.slice(0, 3)) {
+          console.log(`    - ${error}`);
+        }
+        if (failed.errors.length > 3) {
+          console.log(`    ... and ${failed.errors.length - 3} more`);
+        }
+        console.log("");
+      }
+      console.log(`Use 'intellitester cleanup:retry' to retry these cleanups.
+`);
+    } catch (error) {
+      logError(error instanceof Error ? error.message : String(error));
+      process2.exit(1);
+    }
+  });
+  program.command("cleanup:retry").description("Retry failed cleanup operations from previous test runs").action(async () => {
+    try {
+      const hasConfigFile = await fileExists(CONFIG_FILENAME);
+      if (!hasConfigFile) {
+        throw new Error(`No ${CONFIG_FILENAME} found. Cannot retry cleanup without provider configuration.`);
+      }
+      const config = await loadIntellitesterConfig(CONFIG_FILENAME);
+      const failedCleanups = await loadFailedCleanups(process2.cwd());
+      if (failedCleanups.length === 0) {
+        console.log("No failed cleanups to retry.");
+        return;
+      }
+      console.log(`Found ${failedCleanups.length} failed cleanup(s) to retry.`);
+      for (const failed of failedCleanups) {
+        console.log(`
+Retrying cleanup for session ${failed.sessionId}...`);
+        console.log(`  Provider: ${failed.providerConfig.provider}`);
+        console.log(`  Resources: ${failed.resources.length}`);
+        const provider = failed.providerConfig.provider;
+        const cleanupConfig = {
+          provider,
+          parallel: false,
+          retries: 3
+        };
+        const configAny = config;
+        if (provider === "appwrite") {
+          if (!config.appwrite?.apiKey) {
+            console.log(`  \u2717 Skipping: Appwrite API key not configured in ${CONFIG_FILENAME}`);
+            continue;
+          }
+          cleanupConfig.appwrite = {
+            endpoint: failed.providerConfig.endpoint,
+            projectId: failed.providerConfig.projectId,
+            apiKey: config.appwrite.apiKey
+          };
+        } else if (provider === "postgres") {
+          const pgConfig = configAny.postgres;
+          if (!pgConfig?.connectionString && !pgConfig?.password) {
+            console.log(`  \u2717 Skipping: Postgres credentials not configured in ${CONFIG_FILENAME}`);
+            continue;
+          }
+          if (pgConfig.connectionString) {
+            cleanupConfig.postgres = {
+              connectionString: pgConfig.connectionString
+            };
+          } else {
+            const host = failed.providerConfig.host;
+            const port = failed.providerConfig.port;
+            const database = failed.providerConfig.database;
+            const user = failed.providerConfig.user;
+            const password = pgConfig.password;
+            cleanupConfig.postgres = {
+              connectionString: `postgresql://${user}:${password}@${host}:${port}/${database}`
+            };
+          }
+        } else if (provider === "mysql") {
+          const mysqlConfig = configAny.mysql;
+          if (!mysqlConfig?.password) {
+            console.log(`  \u2717 Skipping: MySQL password not configured in ${CONFIG_FILENAME}`);
+            continue;
+          }
+          cleanupConfig.mysql = {
+            host: failed.providerConfig.host,
+            port: failed.providerConfig.port,
+            user: failed.providerConfig.user,
+            password: mysqlConfig.password,
+            database: failed.providerConfig.database
+          };
+        } else if (provider === "sqlite") {
+          const sqliteConfig = configAny.sqlite;
+          if (!sqliteConfig?.database && !failed.providerConfig.database) {
+            console.log(`  \u2717 Skipping: SQLite database path not configured`);
+            continue;
+          }
+          cleanupConfig.sqlite = {
+            database: failed.providerConfig.database || sqliteConfig?.database
+          };
+        } else {
+          console.log(`  \u2717 Skipping: Unknown provider "${provider}"`);
+          continue;
+        }
+        try {
+          const { handlers, typeMappings } = await loadCleanupHandlers(
+            cleanupConfig,
+            process2.cwd()
+          );
+          const result = await executeCleanup(
+            failed.resources,
+            handlers,
+            typeMappings,
+            {
+              parallel: false,
+              retries: 3,
+              cwd: process2.cwd()
+              // Don't save failed cleanups again during retry
+            }
+          );
+          if (result.success) {
+            console.log(`  \u2713 Successfully cleaned up ${result.deleted.length} resources`);
+            await removeFailedCleanup(failed.sessionId, process2.cwd());
+          } else {
+            console.log(`  \u26A0 Partial cleanup: ${result.deleted.length} deleted, ${result.failed.length} failed`);
+            for (const failedResource of result.failed) {
+              console.log(`    \u2717 ${failedResource}`);
+            }
+          }
+        } catch (error) {
+          console.log(`  \u2717 Error during cleanup: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      const remaining = await loadFailedCleanups(process2.cwd());
+      if (remaining.length === 0) {
+        console.log("\n\u2713 All failed cleanups have been resolved.");
+      } else {
+        console.log(`
+\u26A0 ${remaining.length} failed cleanup(s) still remaining.`);
+        console.log(`   Use 'intellitester cleanup:list' to see details.`);
+      }
+    } catch (error) {
+      logError(error instanceof Error ? error.message : String(error));
+      process2.exit(1);
+    }
+  });
+  await program.parseAsync(process2.argv);
+};
+main();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map