@atezca/core 1.1.0

package/dist/cli.mjs

@@ -0,0 +1,1539 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+import chalk3 from "chalk";
+
+// src/index.ts
+var AtezcaState = class {
+  config = null;
+  commands = [];
+  setConfig(config) {
+    this.config = config;
+  }
+  getConfig() {
+    return this.config;
+  }
+  addCommand(command) {
+    this.commands.push(command);
+  }
+  getCommands() {
+    return [...this.commands];
+  }
+  clear() {
+    this.config = null;
+    this.commands = [];
+  }
+};
+var ATEZCA_STATE_KEY = /* @__PURE__ */ Symbol.for("__ATEZCA_STATE__");
+if (!globalThis[ATEZCA_STATE_KEY]) {
+  globalThis[ATEZCA_STATE_KEY] = new AtezcaState();
+}
+var state = globalThis[ATEZCA_STATE_KEY];
+function getState() {
+  return {
+    config: state.getConfig(),
+    commands: state.getCommands()
+  };
+}
+
+// src/runner/test-runner.ts
+import chalk2 from "chalk";
+
+// src/config/config-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import { config as loadEnv } from "dotenv";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  aiProvider: z.enum(["claude", "gemini"]).default("claude"),
+  anthropicApiKey: z.string().optional(),
+  googleApiKey: z.string().optional(),
+  cache: z.object({
+    enabled: z.boolean().default(true),
+    expiryDays: z.number().positive().default(30),
+    filePath: z.string().default(".atezca-cache.json")
+  }),
+  browser: z.object({
+    type: z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
+    headless: z.boolean().default(true)
+  }),
+  execution: z.object({
+    timeout: z.number().positive().default(3e4),
+    retries: z.number().nonnegative().default(3),
+    outputDir: z.string().default("generated-tests")
+  })
+}).refine(
+  (data) => {
+    if (data.aiProvider === "claude" && !data.anthropicApiKey) {
+      return false;
+    }
+    if (data.aiProvider === "gemini" && !data.googleApiKey) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "API key required for selected AI provider"
+  }
+);
+var ConfigLoader = class {
+  config = null;
+  constructor() {
+    this.load();
+  }
+  /**
+   * Load configuration
+   */
+  load() {
+    loadEnv();
+    const configFile = this.findConfigFile();
+    let fileConfig = {};
+    if (configFile) {
+      try {
+        const content = fs.readFileSync(configFile, "utf-8");
+        fileConfig = JSON.parse(content);
+      } catch (error) {
+        console.warn(`Warning: Failed to parse ${configFile}`);
+      }
+    }
+    const rawConfig = {
+      aiProvider: process.env.ATEZCA_AI_PROVIDER || fileConfig.aiProvider || "claude",
+      anthropicApiKey: process.env.ANTHROPIC_API_KEY || fileConfig.anthropicApiKey || "",
+      googleApiKey: process.env.GOOGLE_API_KEY || fileConfig.googleApiKey || "",
+      cache: {
+        enabled: this.parseBoolean(process.env.ATEZCA_CACHE_ENABLED) ?? fileConfig.cacheEnabled ?? true,
+        expiryDays: parseInt(process.env.ATEZCA_CACHE_EXPIRY_DAYS ?? "") || fileConfig.cacheExpiryDays || 30,
+        filePath: process.env.ATEZCA_CACHE_FILE || fileConfig.cacheFile || ".atezca-cache.json"
+      },
+      browser: {
+        type: process.env.ATEZCA_BROWSER || fileConfig.browser || "chromium",
+        headless: this.parseBoolean(process.env.ATEZCA_HEADLESS) ?? fileConfig.headless ?? true
+      },
+      execution: {
+        timeout: parseInt(process.env.ATEZCA_TIMEOUT ?? "") || fileConfig.timeout || 3e4,
+        retries: parseInt(process.env.ATEZCA_RETRIES ?? "") || fileConfig.retries || 3,
+        outputDir: process.env.ATEZCA_OUTPUT_DIR || fileConfig.outputDir || "generated-tests"
+      }
+    };
+    try {
+      this.config = ConfigSchema.parse(rawConfig);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const messages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("\n");
+        throw new Error(`Configuration validation failed:
+${messages}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Find config file in current or parent directories
+   */
+  findConfigFile() {
+    const filenames = [".atezcarc", ".atezcarc.json"];
+    let dir = process.cwd();
+    while (true) {
+      for (const filename of filenames) {
+        const filepath = path.join(dir, filename);
+        if (fs.existsSync(filepath)) {
+          return filepath;
+        }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return null;
+  }
+  /**
+   * Parse boolean from string
+   */
+  parseBoolean(value) {
+    if (value === void 0) return void 0;
+    return value.toLowerCase() === "true" || value === "1";
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    if (!this.config) {
+      throw new Error("Configuration not loaded");
+    }
+    return this.config;
+  }
+  /**
+   * Create default config file
+   */
+  static createDefaultConfig(filepath = ".atezcarc") {
+    const defaultConfig = {
+      aiProvider: "claude",
+      anthropicApiKey: process.env.ANTHROPIC_API_KEY || "",
+      googleApiKey: process.env.GOOGLE_API_KEY || "",
+      cacheEnabled: true,
+      cacheExpiryDays: 30,
+      cacheFile: ".atezca-cache.json",
+      browser: "chromium",
+      headless: true,
+      timeout: 3e4,
+      retries: 3,
+      outputDir: "generated-tests"
+    };
+    fs.writeFileSync(filepath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+  }
+};
+var globalConfig = null;
+function getConfig() {
+  if (!globalConfig) {
+    globalConfig = new ConfigLoader();
+  }
+  return globalConfig.getConfig();
+}
+
+// src/interpreter/interpreter.ts
+import { z as z2 } from "zod";
+
+// src/interpreter/claude-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+var ClaudeClient = class {
+  client;
+  model;
+  constructor(apiKey, model = "claude-3-5-sonnet-20241022") {
+    if (!apiKey || !apiKey.startsWith("sk-ant-")) {
+      throw new Error('Invalid Anthropic API key. Must start with "sk-ant-"');
+    }
+    this.client = new Anthropic({
+      apiKey
+    });
+    this.model = model;
+  }
+  /**
+   * Send a message to Claude and get response
+   */
+  async sendMessage(systemPrompt, userPrompt) {
+    console.log(`\u{1F916} Using model: ${this.model}`);
+    try {
+      const message = await this.client.messages.create({
+        model: this.model,
+        max_tokens: 1024,
+        temperature: 0,
+        // Deterministic responses
+        system: systemPrompt,
+        messages: [
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      });
+      const content = message.content[0];
+      if (content.type !== "text") {
+        throw new Error("Expected text response from Claude");
+      }
+      return content.text;
+    } catch (error) {
+      if (error instanceof Anthropic.APIError) {
+        throw new Error(`Claude API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Test API key validity
+   */
+  async testConnection() {
+    try {
+      await this.sendMessage("You are a test assistant.", 'Respond with "OK"');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/interpreter/gemini-client.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+var GeminiClient = class {
+  genAI;
+  model;
+  constructor(apiKey, model = "gemini-3-pro-preview") {
+    if (!apiKey || !apiKey.startsWith("AIza")) {
+      throw new Error('Invalid Google API key. Must start with "AIza"');
+    }
+    this.genAI = new GoogleGenerativeAI(apiKey);
+    this.model = model;
+  }
+  /**
+   * Send a message to Gemini and get response
+   */
+  async sendMessage(systemPrompt, userPrompt) {
+    console.log(`\u{1F916} Using model: ${this.model}`);
+    try {
+      const model = this.genAI.getGenerativeModel({
+        model: this.model,
+        generationConfig: {
+          temperature: 0,
+          // Deterministic responses
+          maxOutputTokens: 1024
+        }
+      });
+      const fullPrompt = `${systemPrompt}
+
+User Request:
+${userPrompt}`;
+      const result = await model.generateContent(fullPrompt);
+      const response = await result.response;
+      return response.text();
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Gemini API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Test API key validity
+   */
+  async testConnection() {
+    try {
+      await this.sendMessage("You are a test assistant.", 'Respond with "OK"');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/interpreter/prompt.ts
+function getSystemPrompt() {
+  return `You are an expert E2E test automation assistant. Your role is to interpret natural language test commands and convert them into structured Playwright actions.
+
+CRITICAL RULES:
+1. Always respond with valid JSON only - no markdown, no code blocks, no explanations
+2. Use robust selectors in order of preference: role > aria-label > data-testid > text content > CSS
+3. Be specific and deterministic - avoid ambiguous selectors
+4. For interact actions with buttons/links, prefer getByRole over other selectors
+5. For form inputs, use getByLabel or getByPlaceholder
+6. Always include timeout values for wait actions
+
+OUTPUT FORMAT (JSON only):
+{
+  "actions": [
+    {
+      "action": "click" | "type" | "navigate" | "wait" | "expect" | "select" | "hover" | "press",
+      "selector": "button:has-text('Login')" or "role=button[name='Login']",
+      "value": "text to type or URL to navigate",
+      "condition": "visible|hidden|attached|detached",
+      "assertionType": "visible|hidden|text|value|enabled|disabled",
+      "expected": "expected value for assertions",
+      "timeout": 30000
+    }
+  ]
+}
+
+EXAMPLES:
+
+Input: { actionType: "interact", description: "click button 'Login'" }
+Output: {"actions":[{"action":"click","selector":"role=button[name='Login']"}]}
+
+Input: { actionType: "interact", description: "type 'john@example.com' in email field" }
+Output: {"actions":[{"action":"type","selector":"role=textbox[name='Email' i]","value":"john@example.com"}]}
+
+Input: { actionType: "navigate", description: "go to login page" }
+Output: {"actions":[{"action":"navigate","value":"/login"}]}
+
+Input: { actionType: "wait", description: "until submit button is visible" }
+Output: {"actions":[{"action":"wait","selector":"role=button[name='Submit']","condition":"visible","timeout":30000}]}
+
+Input: { actionType: "expect", description: "show success message" }
+Output: {"actions":[{"action":"expect","selector":"text=/success|successfully/i","assertionType":"visible"}]}
+
+Input: { actionType: "interact", description: "select 'Premium' from plan dropdown" }
+Output: {"actions":[{"action":"select","selector":"role=combobox[name='Plan']","value":"Premium"}]}
+
+IMPORTANT:
+- For "expect" actions, use appropriate assertionType (visible, text, value, etc.)
+- For "wait" actions, always include timeout
+- For text matching, use case-insensitive regex when appropriate: /text/i
+- Respond ONLY with JSON, no other text`;
+}
+function getUserPrompt(command) {
+  return JSON.stringify({
+    actionType: command.actionType,
+    description: command.description
+  });
+}
+function getUserPromptWithContext(command, context) {
+  const elementsInfo = context.interactiveElements.length > 0 ? `
+
+Available interactive elements on the page:
+${context.interactiveElements.map((el) => `- ${el.role}: "${el.name}" (${el.tag})`).join("\n")}` : "";
+  const accessibilityInfo = context.accessibilityTree && context.accessibilityTree !== "Unable to capture" ? `
+
+Page structure:
+${context.accessibilityTree}` : "";
+  return `CURRENT PAGE CONTEXT:
+- URL: ${context.url}
+- Title: ${context.title}${elementsInfo}${accessibilityInfo}
+
+USER COMMAND:
+${JSON.stringify({
+    actionType: command.actionType,
+    description: command.description
+  })}
+
+Based on the current page context above, generate the appropriate Playwright actions to fulfill the user's command. Use the available elements to create accurate selectors.`;
+}
+
+// src/interpreter/interpreter.ts
+var PlaywrightActionSchema = z2.object({
+  action: z2.enum(["click", "type", "navigate", "wait", "expect", "select", "hover", "press"]),
+  selector: z2.string().optional(),
+  value: z2.string().optional(),
+  condition: z2.string().optional(),
+  assertionType: z2.enum(["visible", "hidden", "text", "value", "enabled", "disabled"]).optional(),
+  expected: z2.string().optional(),
+  timeout: z2.number().optional()
+});
+var ClaudeResponseSchema = z2.object({
+  actions: z2.array(PlaywrightActionSchema)
+});
+var Interpreter = class {
+  client;
+  provider;
+  constructor(provider, apiKey) {
+    this.provider = provider;
+    switch (provider) {
+      case "claude":
+        this.client = new ClaudeClient(apiKey);
+        break;
+      case "gemini":
+        this.client = new GeminiClient(apiKey);
+        break;
+      default:
+        AI;
+        throw new Error(`Unsupported AI provider: ${provider}`);
+    }
+  }
+  /**
+   * Interpret a test command into Playwright actions
+   */
+  async interpret(command, pageContext) {
+    const waitMatch = command.description.match(/^wait\s+(\d+)ms$/i);
+    if (waitMatch && command.actionType === "wait") {
+      const milliseconds = parseInt(waitMatch[1], 10);
+      return [{
+        action: "wait",
+        timeout: milliseconds,
+        selector: "body",
+        // Dummy selector, will just wait
+        condition: "attached"
+      }];
+    }
+    const systemPrompt = getSystemPrompt();
+    const userPrompt = pageContext ? getUserPromptWithContext(command, pageContext) : getUserPrompt(command);
+    const responseText = await this.client.sendMessage(systemPrompt, userPrompt);
+    let response;
+    try {
+      const cleanedResponse = responseText.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+      response = JSON.parse(cleanedResponse);
+    } catch (error) {
+      throw new Error(`Failed to parse ${this.provider} response: ${responseText}`);
+    }
+    const validated = ClaudeResponseSchema.parse(response);
+    return validated.actions;
+  }
+  /**
+   * Test if the interpreter is working
+   */
+  async test() {
+    return this.client.testConnection();
+  }
+};
+function createInterpretationResult(command, actions, cached = false) {
+  return {
+    command,
+    actions,
+    cached,
+    timestamp: Date.now()
+  };
+}
+
+// src/cache/cache-manager.ts
+import * as fs2 from "fs";
+import * as crypto from "crypto";
+var CacheManager = class {
+  cacheFilePath;
+  expiryDays;
+  cache;
+  constructor(cacheFilePath = ".atezca-cache.json", expiryDays = 30) {
+    this.cacheFilePath = cacheFilePath;
+    this.expiryDays = expiryDays;
+    this.cache = /* @__PURE__ */ new Map();
+    this.load();
+  }
+  /**
+   * Generate cache key from command
+   */
+  generateKey(command) {
+    const data = `${command.actionType}:${command.description}`;
+    return crypto.createHash("sha256").update(data).digest("hex");
+  }
+  /**
+   * Check if cache entry is expired
+   */
+  isExpired(entry) {
+    return Date.now() > entry.expiresAt;
+  }
+  /**
+   * Load cache from file
+   */
+  load() {
+    try {
+      if (fs2.existsSync(this.cacheFilePath)) {
+        const data = fs2.readFileSync(this.cacheFilePath, "utf-8");
+        const entries = JSON.parse(data);
+        for (const entry of entries) {
+          if (!this.isExpired(entry)) {
+            this.cache.set(entry.key, entry);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load cache, starting with empty cache");
+      this.cache.clear();
+    }
+  }
+  /**
+   * Save cache to file
+   */
+  save() {
+    try {
+      const entries = Array.from(this.cache.values());
+      const data = JSON.stringify(entries, null, 2);
+      fs2.writeFileSync(this.cacheFilePath, data, "utf-8");
+    } catch (error) {
+      console.warn("Failed to save cache:", error);
+    }
+  }
+  /**
+   * Get cached actions for a command
+   */
+  get(command) {
+    const key = this.generateKey(command);
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      this.save();
+      return null;
+    }
+    return entry.actions;
+  }
+  /**
+   * Store actions in cache
+   */
+  set(command, actions) {
+    const key = this.generateKey(command);
+    const now = Date.now();
+    const expiryMs = this.expiryDays * 24 * 60 * 60 * 1e3;
+    const entry = {
+      key,
+      actions,
+      cachedAt: now,
+      expiresAt: now + expiryMs
+    };
+    this.cache.set(key, entry);
+    this.save();
+  }
+  /**
+   * Check if command is cached
+   */
+  has(command) {
+    return this.get(command) !== null;
+  }
+  /**
+   * Clear all cache
+   */
+  clear() {
+    this.cache.clear();
+    if (fs2.existsSync(this.cacheFilePath)) {
+      fs2.unlinkSync(this.cacheFilePath);
+    }
+  }
+  /**
+   * Clear expired entries
+   */
+  clearExpired() {
+    const keysToDelete = [];
+    for (const [key, entry] of this.cache.entries()) {
+      if (this.isExpired(entry)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.cache.delete(key);
+    }
+    if (keysToDelete.length > 0) {
+      this.save();
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const entries = Array.from(this.cache.values());
+    if (entries.length === 0) {
+      return { size: 0, oldestEntry: null, newestEntry: null };
+    }
+    const timestamps = entries.map((e) => e.cachedAt);
+    return {
+      size: entries.length,
+      oldestEntry: Math.min(...timestamps),
+      newestEntry: Math.max(...timestamps)
+    };
+  }
+};
+
+// src/executor/playwright-executor.ts
+import { chromium, firefox, webkit } from "playwright";
+var PlaywrightExecutor = class {
+  browser = null;
+  context = null;
+  page = null;
+  config;
+  actionLog = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Initialize browser and page
+   */
+  async initialize() {
+    const browserType = this.config.browser ?? "chromium";
+    const headless = this.config.headless ?? true;
+    switch (browserType) {
+      case "chromium":
+        this.browser = await chromium.launch({ headless });
+        break;
+      case "firefox":
+        this.browser = await firefox.launch({ headless });
+        break;
+      case "webkit":
+        this.browser = await webkit.launch({ headless });
+        break;
+      default:
+        throw new Error(`Unsupported browser: ${browserType}`);
+    }
+    this.context = await this.browser.newContext({
+      ignoreHTTPSErrors: this.config.disableSSL ?? false
+    });
+    this.page = await this.context.newPage();
+    this.page.setDefaultTimeout(this.config.timeout ?? 3e4);
+    await this.page.goto(this.config.url);
+  }
+  /**
+   * Execute a single action with retry logic
+   */
+  async executeAction(action) {
+    if (!this.page) {
+      throw new Error("Executor not initialized. Call initialize() first.");
+    }
+    const startTime = Date.now();
+    const retries = this.config.retries ?? 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        await this.performAction(action);
+        const duration2 = Date.now() - startTime;
+        this.actionLog.push({ action, result: "success", duration: duration2 });
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < retries - 1) {
+          await this.page.waitForTimeout(Math.pow(2, attempt) * 1e3);
+        }
+      }
+    }
+    const duration = Date.now() - startTime;
+    this.actionLog.push({
+      action,
+      result: `failed: ${lastError?.message}`,
+      duration
+    });
+    throw lastError;
+  }
+  /**
+   * Perform the actual action
+   */
+  async performAction(action) {
+    if (!this.page) {
+      throw new Error("Page not initialized");
+    }
+    const timeout = action.timeout ?? this.config.timeout ?? 3e4;
+    switch (action.action) {
+      case "click":
+        if (!action.selector) throw new Error("Click action requires selector");
+        await this.page.locator(action.selector).click({ timeout });
+        break;
+      case "type":
+        if (!action.selector) throw new Error("Type action requires selector");
+        if (!action.value) throw new Error("Type action requires value");
+        await this.page.locator(action.selector).fill(action.value, { timeout });
+        break;
+      case "navigate":
+        if (!action.value) throw new Error("Navigate action requires value");
+        const url = action.value.startsWith("http") ? action.value : new URL(action.value, this.config.url).toString();
+        await this.page.goto(url, { timeout });
+        break;
+      case "wait":
+        if (action.condition === "attached" && action.selector === "body") {
+          await this.page.waitForTimeout(timeout);
+        } else {
+          if (!action.selector) throw new Error("Wait action requires selector");
+          const state2 = action.condition ?? "visible";
+          await this.page.locator(action.selector).waitFor({
+            state: state2,
+            timeout
+          });
+        }
+        break;
+      case "expect":
+        if (!action.selector) throw new Error("Expect action requires selector");
+        await this.performAssertion(action, timeout);
+        break;
+      case "select":
+        if (!action.selector) throw new Error("Select action requires selector");
+        if (!action.value) throw new Error("Select action requires value");
+        await this.page.locator(action.selector).selectOption(action.value, { timeout });
+        break;
+      case "hover":
+        if (!action.selector) throw new Error("Hover action requires selector");
+        await this.page.locator(action.selector).hover({ timeout });
+        break;
+      case "press":
+        if (!action.value) throw new Error("Press action requires value (key name)");
+        await this.page.keyboard.press(action.value);
+        break;
+      default:
+        throw new Error(`Unsupported action: ${action.action}`);
+    }
+  }
+  /**
+   * Perform assertion
+   */
+  async performAssertion(action, timeout) {
+    if (!this.page || !action.selector) return;
+    const locator = this.page.locator(action.selector);
+    switch (action.assertionType) {
+      case "visible":
+        await locator.waitFor({ state: "visible", timeout });
+        break;
+      case "hidden":
+        await locator.waitFor({ state: "hidden", timeout });
+        break;
+      case "text":
+        if (!action.expected) throw new Error("Text assertion requires expected value");
+        await locator.waitFor({ state: "visible", timeout });
+        const text = await locator.textContent();
+        if (!text?.includes(action.expected)) {
+          throw new Error(`Expected text "${action.expected}" but got "${text}"`);
+        }
+        break;
+      case "value":
+        if (!action.expected) throw new Error("Value assertion requires expected value");
+        await locator.waitFor({ state: "visible", timeout });
+        const value = await locator.inputValue();
+        if (value !== action.expected) {
+          throw new Error(`Expected value "${action.expected}" but got "${value}"`);
+        }
+        break;
+      case "enabled":
+        await locator.waitFor({ state: "visible", timeout });
+        if (await locator.isDisabled()) {
+          throw new Error("Expected element to be enabled but it is disabled");
+        }
+        break;
+      case "disabled":
+        await locator.waitFor({ state: "visible", timeout });
+        if (await locator.isEnabled()) {
+          throw new Error("Expected element to be disabled but it is enabled");
+        }
+        break;
+      default:
+        await locator.waitFor({ state: "visible", timeout });
+    }
+  }
+  /**
+   * Execute multiple actions in sequence
+   */
+  async executeActions(actions) {
+    for (const action of actions) {
+      await this.executeAction(action);
+    }
+  }
+  /**
+   * Get action execution log
+   */
+  getActionLog() {
+    return [...this.actionLog];
+  }
+  /**
+   * Take screenshot
+   */
+  async screenshot(path4) {
+    if (!this.page) {
+      throw new Error("Page not initialized");
+    }
+    await this.page.screenshot({ path: path4 });
+  }
+  /**
+   * Close browser
+   */
+  async close() {
+    if (this.context) {
+      await this.context.close();
+    }
+    if (this.browser) {
+      await this.browser.close();
+    }
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+  }
+  /**
+   * Get current page (for advanced usage)
+   */
+  getPage() {
+    return this.page;
+  }
+  /**
+   * Capture current page context for AI interpretation
+   */
+  async getPageContext() {
+    if (!this.page) {
+      throw new Error("Page not initialized");
+    }
+    try {
+      const url = this.page.url();
+      const title = await this.page.title();
+      const snapshot = await this.page.accessibility.snapshot();
+      const accessibilityTree = this.simplifyAccessibilityTree(snapshot);
+      const interactiveElements = await this.page.evaluate(() => {
+        const elements = [];
+        document.querySelectorAll('button, [role="button"], input[type="button"], input[type="submit"]').forEach((el) => {
+          const text = el.textContent?.trim() || el.value || "";
+          if (text) {
+            elements.push({
+              role: "button",
+              name: text,
+              tag: el.tagName.toLowerCase()
+            });
+          }
+        });
+        document.querySelectorAll("a[href]").forEach((el) => {
+          const text = el.textContent?.trim() || "";
+          if (text) {
+            elements.push({
+              role: "link",
+              name: text,
+              tag: "a"
+            });
+          }
+        });
+        document.querySelectorAll('input:not([type="hidden"]), textarea, select').forEach((el) => {
+          const input = el;
+          const label = document.querySelector(`label[for="${input.id}"]`)?.textContent?.trim() || input.placeholder || input.name || input.id;
+          if (label) {
+            elements.push({
+              role: "input",
+              name: label,
+              tag: input.tagName.toLowerCase()
+            });
+          }
+        });
+        return elements.slice(0, 50);
+      });
+      return {
+        url,
+        title,
+        accessibilityTree,
+        interactiveElements
+      };
+    } catch (error) {
+      return {
+        url: this.page.url(),
+        title: await this.page.title().catch(() => "Unknown"),
+        accessibilityTree: "Unable to capture",
+        interactiveElements: []
+      };
+    }
+  }
+  /**
+   * Simplify accessibility tree for AI consumption
+   */
+  simplifyAccessibilityTree(node, depth = 0, maxDepth = 3) {
+    if (!node || depth > maxDepth) return "";
+    let result = "";
+    const indent = "  ".repeat(depth);
+    if (node.role) {
+      const name = node.name ? ` "${node.name}"` : "";
+      result += `${indent}- ${node.role}${name}
+`;
+    }
+    if (node.children && depth < maxDepth) {
+      for (const child of node.children.slice(0, 10)) {
+        result += this.simplifyAccessibilityTree(child, depth + 1, maxDepth);
+      }
+    }
+    return result;
+  }
+};
+
+// src/generator/code-generator.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+var CodeGenerator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Generate Playwright test code from actions
+   */
+  generateCode(interpretations) {
+    const lines = [];
+    lines.push("import { test, expect } from '@playwright/test';");
+    lines.push("");
+    if (this.config.disableSSL) {
+      lines.push("// Note: SSL certificate validation is disabled (ignoreHTTPSErrors: true)");
+      lines.push("// This is configured in playwright.config.ts");
+      lines.push("");
+    }
+    lines.push("test.describe('Generated E2E Test', () => {");
+    lines.push("  test.beforeEach(async ({ page }) => {");
+    lines.push(`    // Navigate to base URL`);
+    lines.push(`    await page.goto('${this.config.url}');`);
+    lines.push("  });");
+    lines.push("");
+    lines.push("  test('should execute test actions', async ({ page }) => {");
+    for (const interpretation of interpretations) {
+      const { command, actions } = interpretation;
+      lines.push("");
+      lines.push(`    // ${command.actionType}: ${command.description}`);
+      for (const action of actions) {
+        const code = this.generateActionCode(action);
+        lines.push(`    ${code}`);
+      }
+    }
+    lines.push("  });");
+    lines.push("});");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code for a single action
+   */
+  generateActionCode(action) {
+    const timeout = action.timeout ?? this.config.timeout ?? 3e4;
+    switch (action.action) {
+      case "click":
+        return `await page.locator('${this.escapeString(action.selector)}').click({ timeout: ${timeout} });`;
+      case "type":
+        return `await page.locator('${this.escapeString(action.selector)}').fill('${this.escapeString(action.value)}', { timeout: ${timeout} });`;
+      case "navigate": {
+        const url = action.value.startsWith("http") ? action.value : `\${baseUrl}${action.value}`;
+        return `await page.goto('${this.escapeString(url)}', { timeout: ${timeout} });`;
+      }
+      case "wait": {
+        if (action.condition === "attached" && action.selector === "body") {
+          return `await page.waitForTimeout(${timeout});`;
+        }
+        const state2 = action.condition ?? "visible";
+        return `await page.locator('${this.escapeString(action.selector)}').waitFor({ state: '${state2}', timeout: ${timeout} });`;
+      }
+      case "expect":
+        return this.generateAssertionCode(action, timeout);
+      case "select":
+        return `await page.locator('${this.escapeString(action.selector)}').selectOption('${this.escapeString(action.value)}', { timeout: ${timeout} });`;
+      case "hover":
+        return `await page.locator('${this.escapeString(action.selector)}').hover({ timeout: ${timeout} });`;
+      case "press":
+        return `await page.keyboard.press('${this.escapeString(action.value)}');`;
+      default:
+        return `// Unsupported action: ${action.action}`;
+    }
+  }
+  /**
+   * Generate assertion code
+   */
+  generateAssertionCode(action, timeout) {
+    const locator = `page.locator('${this.escapeString(action.selector)}')`;
+    switch (action.assertionType) {
+      case "visible":
+        return `await expect(${locator}).toBeVisible({ timeout: ${timeout} });`;
+      case "hidden":
+        return `await expect(${locator}).toBeHidden({ timeout: ${timeout} });`;
+      case "text":
+        return `await expect(${locator}).toContainText('${this.escapeString(action.expected)}', { timeout: ${timeout} });`;
+      case "value":
+        return `await expect(${locator}).toHaveValue('${this.escapeString(action.expected)}', { timeout: ${timeout} });`;
+      case "enabled":
+        return `await expect(${locator}).toBeEnabled({ timeout: ${timeout} });`;
+      case "disabled":
+        return `await expect(${locator}).toBeDisabled({ timeout: ${timeout} });`;
+      default:
+        return `await expect(${locator}).toBeVisible({ timeout: ${timeout} });`;
+    }
+  }
+  /**
+   * Escape string for code generation
+   */
+  escapeString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  }
+  /**
+   * Generate and save test file
+   */
+  async saveTestFile(interpretations, filename) {
+    const code = this.generateCode(interpretations);
+    const outputDir = this.config.outputDir ?? "generated-tests";
+    if (!fs3.existsSync(outputDir)) {
+      fs3.mkdirSync(outputDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const finalFilename = filename ?? `test-${timestamp}.spec.ts`;
+    const filePath = path2.join(outputDir, finalFilename);
+    fs3.writeFileSync(filePath, code, "utf-8");
+    return filePath;
+  }
+  /**
+   * Generate Playwright config file
+   */
+  generatePlaywrightConfig() {
+    const useConfig = [
+      `    baseURL: '${this.config.url}',`,
+      `    trace: 'on-first-retry',`,
+      `    screenshot: 'only-on-failure',`
+    ];
+    if (this.config.disableSSL) {
+      useConfig.push(`    ignoreHTTPSErrors: true, // SSL certificate errors disabled`);
+    }
+    return `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './generated-tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+${useConfig.join("\n")}
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+});
+`;
+  }
+  /**
+   * Save Playwright config file
+   */
+  async savePlaywrightConfig() {
+    const config = this.generatePlaywrightConfig();
+    const filePath = "playwright.config.ts";
+    if (!fs3.existsSync(filePath)) {
+      fs3.writeFileSync(filePath, config, "utf-8");
+    }
+    return filePath;
+  }
+};
+
+// src/utils/browser-installer.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+function isMissingBrowserError(error) {
+  const message = error.message;
+  return message.includes("Executable doesn't exist at") || message.includes("Looks like Playwright") || message.includes("npx playwright install");
+}
+function extractBrowserFromError(error) {
+  const message = error.message;
+  if (message.includes("chromium")) return "chromium";
+  if (message.includes("firefox")) return "firefox";
+  if (message.includes("webkit")) return "webkit";
+  return null;
+}
+async function installPlaywrightBrowser(browser) {
+  try {
+    console.log(chalk.yellow(`
+\u26A0\uFE0F  Browser ${browser} not found. Installing automatically...
+`));
+    execSync(`npx playwright install ${browser}`, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    console.log(chalk.green(`
+\u2713 Browser ${browser} installed successfully!
+`));
+    return true;
+  } catch (error) {
+    console.error(chalk.red(`
+\u2717 Failed to install browser: ${error.message}
+`));
+    return false;
+  }
+}
+async function handleBrowserInstallation(error, browserType) {
+  if (!isMissingBrowserError(error)) {
+    return false;
+  }
+  const browser = extractBrowserFromError(error) || browserType;
+  return await installPlaywrightBrowser(browser);
+}
+
+// src/runner/test-runner.ts
+var TestRunner = class {
+  config;
+  interpreter;
+  cache;
+  executor = null;
+  generator;
+  interpretations = [];
+  constructor(config) {
+    this.config = config;
+    const globalConfig2 = getConfig();
+    const aiProvider = config.aiProvider || globalConfig2.aiProvider;
+    let apiKey = config.apiKey;
+    if (!apiKey) {
+      apiKey = aiProvider === "claude" ? globalConfig2.anthropicApiKey : globalConfig2.googleApiKey;
+    }
+    if (!apiKey) {
+      throw new Error(`API key not found for provider: ${aiProvider}`);
+    }
+    this.interpreter = new Interpreter(aiProvider, apiKey);
+    this.cache = new CacheManager(
+      globalConfig2.cache.filePath,
+      globalConfig2.cache.expiryDays
+    );
+    this.generator = new CodeGenerator(config);
+  }
+  /**
+   * Process a single command (interpret and cache) with retry logic
+   */
+  async processCommand(command) {
+    const cacheEnabled = this.config.cacheEnabled ?? true;
+    const aiProvider = this.config.aiProvider || getConfig().aiProvider;
+    if (cacheEnabled) {
+      const cached = this.cache.get(command);
+      if (cached) {
+        console.log(chalk2.gray(`  \u2713 Using cached interpretation`));
+        return createInterpretationResult(command, cached, true);
+      }
+    }
+    const displayProvider = aiProvider.toUpperCase();
+    const maxInterpretationRetries = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxInterpretationRetries; attempt++) {
+      try {
+        if (attempt === 0) {
+          console.log(chalk2.blue(`  \u2192 Interpreting with ${displayProvider}...`));
+        } else {
+          console.log(chalk2.yellow(`  \u27F3 Interpretation retry ${attempt}/${maxInterpretationRetries - 1}...`));
+        }
+        const actions = await this.interpreter.interpret(command);
+        if (cacheEnabled) {
+          this.cache.set(command, actions);
+        }
+        return createInterpretationResult(command, actions, false);
+      } catch (error) {
+        lastError = error;
+        console.log(chalk2.yellow(`  \u26A0 Interpretation failed: ${lastError.message}`));
+        if (attempt < maxInterpretationRetries - 1) {
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3 * (attempt + 1)));
+        }
+      }
+    }
+    throw new Error(`Failed to interpret after ${maxInterpretationRetries} attempts: ${lastError?.message}`);
+  }
+  /**
+   * Interpret command with retry logic and page context
+   */
+  async interpretWithRetry(command, pageContext) {
+    const aiProvider = this.config.aiProvider || getConfig().aiProvider;
+    const displayProvider = aiProvider.toUpperCase();
+    const maxInterpretationRetries = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxInterpretationRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          console.log(chalk2.yellow(`     \u27F3 AI retry ${attempt}/${maxInterpretationRetries - 1} (${displayProvider})...`));
+        }
+        const actions = await this.interpreter.interpret(command, pageContext);
+        return actions;
+      } catch (error) {
+        lastError = error;
+        console.log(chalk2.yellow(`     \u26A0 ${displayProvider} failed: ${lastError.message}`));
+        if (attempt < maxInterpretationRetries - 1) {
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3 * (attempt + 1)));
+        }
+      }
+    }
+    throw new Error(`${displayProvider} failed after ${maxInterpretationRetries} attempts: ${lastError?.message}`);
+  }
+  /**
+   * Process all commands
+   */
+  async processCommands(commands) {
+    console.log(chalk2.bold("\n\u{1F4DD} Processing commands...\n"));
+    const interpretations = [];
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i];
+      console.log(chalk2.cyan(`[${i + 1}/${commands.length}] ${command.actionType}: ${command.description}`));
+      try {
+        const interpretation = await this.processCommand(command);
+        interpretations.push(interpretation);
+        console.log(chalk2.green(`  \u2713 ${interpretation.actions.length} action(s) generated
+`));
+      } catch (error) {
+        console.error(chalk2.red(`  \u2717 Failed: ${error.message}
+`));
+        throw error;
+      }
+    }
+    this.interpretations = interpretations;
+    return interpretations;
+  }
+  /**
+   * Execute tests
+   */
+  async execute(commands) {
+    const startTime = Date.now();
+    let actionsExecuted = 0;
+    let browserInstalled = false;
+    try {
+      console.log(chalk2.bold("\u{1F680} Launching browser...\n"));
+      this.executor = new PlaywrightExecutor(this.config);
+      try {
+        await this.executor.initialize();
+      } catch (error) {
+        const installed = await handleBrowserInstallation(
+          error,
+          this.config.browser || "chromium"
+        );
+        if (installed) {
+          browserInstalled = true;
+          console.log(chalk2.blue("Retrying browser launch...\n"));
+          await this.executor.initialize();
+        } else {
+          throw error;
+        }
+      }
+      console.log(chalk2.bold("\u25B6\uFE0F  Executing tests...\n"));
+      for (let i = 0; i < commands.length; i++) {
+        const command = commands[i];
+        console.log(chalk2.cyan(`
+[${i + 1}/${commands.length}] ${command.actionType}: ${command.description}`));
+        let success = false;
+        let lastError = null;
+        const maxRetries = 5;
+        for (let attempt = 0; attempt < maxRetries && !success; attempt++) {
+          try {
+            const pageContext = await this.executor.getPageContext();
+            if (attempt === 0) {
+              console.log(chalk2.blue(`  \u2192 Interpreting with context...`));
+              console.log(chalk2.gray(`     Page: ${pageContext.url}`));
+              console.log(chalk2.gray(`     Available elements: ${pageContext.interactiveElements.length}`));
+            } else {
+              console.log(chalk2.yellow(`  \u27F3 Retry ${attempt}/${maxRetries - 1} - Re-analyzing page...`));
+              console.log(chalk2.gray(`     Page: ${pageContext.url}`));
+              console.log(chalk2.gray(`     Available elements: ${pageContext.interactiveElements.length}`));
+            }
+            let actions;
+            if (attempt === 0 && this.config.cacheEnabled) {
+              const cached = this.cache.get(command);
+              if (cached) {
+                console.log(chalk2.gray(`  \u2713 Using cached interpretation`));
+                actions = cached;
+              } else {
+                actions = await this.interpretWithRetry(command, pageContext);
+                this.cache.set(command, actions);
+              }
+            } else {
+              actions = await this.interpretWithRetry(command, pageContext);
+              if (this.config.cacheEnabled) {
+                this.cache.set(command, actions);
+              }
+            }
+            console.log(chalk2.gray(`  \u2713 Generated ${actions.length} action(s)`));
+            for (const action of actions) {
+              await this.executor.executeAction(action);
+              actionsExecuted++;
+              console.log(chalk2.gray(`     \u2713 ${action.action}${action.selector ? ` (${action.selector})` : ""}`));
+            }
+            const interpretation = createInterpretationResult(command, actions, false);
+            this.interpretations.push(interpretation);
+            success = true;
+            console.log(chalk2.green(`  \u2713 Success
+`));
+          } catch (error) {
+            lastError = error;
+            if (attempt < maxRetries - 1) {
+              console.log(chalk2.yellow(`  \u26A0 Failed: ${lastError.message}`));
+              await new Promise((resolve2) => setTimeout(resolve2, 1e3 * (attempt + 1)));
+            } else {
+              throw new Error(`Failed after ${maxRetries} attempts: ${lastError.message}`);
+            }
+          }
+        }
+      }
+      console.log(chalk2.bold("\n\u{1F4C4} Generating Playwright code...\n"));
+      const generatedFile = await this.generator.saveTestFile(this.interpretations);
+      console.log(chalk2.green(`\u2713 Test file saved: ${generatedFile}`));
+      const duration = Date.now() - startTime;
+      return {
+        success: true,
+        duration,
+        actionsExecuted,
+        generatedFile
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      return {
+        success: false,
+        error: error.message,
+        duration,
+        actionsExecuted
+      };
+    } finally {
+      if (this.executor) {
+        await this.executor.close();
+      }
+    }
+  }
+  /**
+   * Generate code only (no execution)
+   */
+  async generateOnly(commands) {
+    console.log(chalk2.bold("\u{1F4DD} Processing commands for code generation...\n"));
+    const interpretations = await this.processCommands(commands);
+    console.log(chalk2.bold("\n\u{1F4C4} Generating Playwright code...\n"));
+    const generatedFile = await this.generator.saveTestFile(interpretations);
+    console.log(chalk2.green(`\u2713 Test file saved: ${generatedFile}`));
+    return generatedFile;
+  }
+  /**
+   * Get interpretations
+   */
+  getInterpretations() {
+    return this.interpretations;
+  }
+};
+
+// src/cli.ts
+function showHelp() {
+  console.log(chalk3.bold("\n\u26A1 Atezca - AI-Powered E2E Testing\n"));
+  console.log("Usage:");
+  console.log("  az run <file>         Execute test file");
+  console.log("  az generate <file>    Generate Playwright code without execution");
+  console.log("  az init               Create .atezcarc config file");
+  console.log("  az cache clear        Clear interpretation cache");
+  console.log("  az cache stats        Show cache statistics");
+  console.log("  az help               Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  az run test.spec.js");
+  console.log("  az generate test.spec.js");
+  console.log("  az init");
+  console.log("");
+}
+async function runTest(filepath) {
+  try {
+    console.log(chalk3.blue(`Loading test file: ${filepath}
+`));
+    if (!fs4.existsSync(filepath)) {
+      console.error(chalk3.red(`Error: File not found: ${filepath}`));
+      process.exit(1);
+    }
+    const absPath = path3.resolve(filepath);
+    await import(`file://${absPath}`);
+    let state2 = getState();
+    if (!state2.config || state2.commands.length === 0) {
+      try {
+        const currentDir = path3.dirname(new URL(import.meta.url).pathname);
+        const indexModule = await import(path3.join(currentDir, "index.js"));
+        const altState = indexModule.getState();
+        if (altState.config) {
+          state2 = altState;
+        }
+      } catch (e) {
+      }
+    }
+    if (!state2.config) {
+      console.error(chalk3.red("Error: az.setup() was not called in the test file"));
+      process.exit(1);
+    }
+    if (state2.commands.length === 0) {
+      console.error(chalk3.yellow("Warning: No test commands found"));
+      process.exit(0);
+    }
+    console.log(chalk3.bold(`Found ${state2.commands.length} test command(s)
+`));
+    const runner = new TestRunner(state2.config);
+    const result = await runner.execute(state2.commands);
+    console.log(chalk3.bold("\n" + "=".repeat(50)));
+    if (result.success) {
+      console.log(chalk3.green.bold("\n\u2713 Test passed!\n"));
+      console.log(chalk3.gray(`Duration: ${(result.duration / 1e3).toFixed(2)}s`));
+      console.log(chalk3.gray(`Actions executed: ${result.actionsExecuted}`));
+      if (result.generatedFile) {
+        console.log(chalk3.gray(`Generated file: ${result.generatedFile}`));
+      }
+      process.exit(0);
+    } else {
+      console.log(chalk3.red.bold("\n\u2717 Test failed!\n"));
+      console.log(chalk3.red(`Error: ${result.error}`));
+      console.log(chalk3.gray(`Duration: ${(result.duration / 1e3).toFixed(2)}s`));
+      console.log(chalk3.gray(`Actions executed: ${result.actionsExecuted}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk3.red("\n\u2717 Error:"), error.message);
+    process.exit(1);
+  }
+}
+async function generateTest(filepath) {
+  try {
+    console.log(chalk3.blue(`Loading test file: ${filepath}
+`));
+    if (!fs4.existsSync(filepath)) {
+      console.error(chalk3.red(`Error: File not found: ${filepath}`));
+      process.exit(1);
+    }
+    const absPath = path3.resolve(filepath);
+    await import(`file://${absPath}`);
+    let state2 = getState();
+    if (!state2.config || state2.commands.length === 0) {
+      try {
+        const currentDir = path3.dirname(new URL(import.meta.url).pathname);
+        const indexModule = await import(path3.join(currentDir, "index.js"));
+        const altState = indexModule.getState();
+        if (altState.config) {
+          state2 = altState;
+        }
+      } catch (e) {
+      }
+    }
+    if (!state2.config) {
+      console.error(chalk3.red("Error: az.setup() was not called in the test file"));
+      process.exit(1);
+    }
+    if (state2.commands.length === 0) {
+      console.error(chalk3.yellow("Warning: No test commands found"));
+      process.exit(0);
+    }
+    console.log(chalk3.bold(`Found ${state2.commands.length} test command(s)
+`));
+    const runner = new TestRunner(state2.config);
+    const generatedFile = await runner.generateOnly(state2.commands);
+    console.log(chalk3.green.bold("\n\u2713 Code generation complete!\n"));
+    console.log(chalk3.gray(`Generated file: ${generatedFile}`));
+    console.log(chalk3.gray("\nRun with: npx playwright test"));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk3.red("\n\u2717 Error:"), error.message);
+    process.exit(1);
+  }
+}
+function initConfig() {
+  const filepath = ".atezcarc";
+  if (fs4.existsSync(filepath)) {
+    console.log(chalk3.yellow(`Warning: ${filepath} already exists`));
+    process.exit(0);
+  }
+  ConfigLoader.createDefaultConfig(filepath);
+  console.log(chalk3.green(`\u2713 Created ${filepath}`));
+  console.log(chalk3.gray("\nDon't forget to set your ANTHROPIC_API_KEY in .env or .atezcarc"));
+  process.exit(0);
+}
+function clearCache() {
+  const cache = new CacheManager();
+  cache.clear();
+  console.log(chalk3.green("\u2713 Cache cleared"));
+  process.exit(0);
+}
+function showCacheStats() {
+  const cache = new CacheManager();
+  const stats = cache.getStats();
+  console.log(chalk3.bold("\nCache Statistics:\n"));
+  console.log(chalk3.gray(`Entries: ${stats.size}`));
+  if (stats.oldestEntry) {
+    const oldest = new Date(stats.oldestEntry);
+    console.log(chalk3.gray(`Oldest entry: ${oldest.toLocaleString()}`));
+  }
+  if (stats.newestEntry) {
+    const newest = new Date(stats.newestEntry);
+    console.log(chalk3.gray(`Newest entry: ${newest.toLocaleString()}`));
+  }
+  if (stats.size === 0) {
+    console.log(chalk3.yellow("\nCache is empty"));
+  }
+  console.log("");
+  process.exit(0);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+    showHelp();
+    process.exit(0);
+  }
+  const command = args[0];
+  const subcommand = args[1];
+  switch (command) {
+    case "run":
+      if (!subcommand) {
+        console.error(chalk3.red("Error: Please specify a test file"));
+        console.log("Usage: az run <file>");
+        process.exit(1);
+      }
+      await runTest(subcommand);
+      break;
+    case "generate":
+      if (!subcommand) {
+        console.error(chalk3.red("Error: Please specify a test file"));
+        console.log("Usage: az generate <file>");
+        process.exit(1);
+      }
+      await generateTest(subcommand);
+      break;
+    case "init":
+      initConfig();
+      break;
+    case "cache":
+      if (subcommand === "clear") {
+        clearCache();
+      } else if (subcommand === "stats") {
+        showCacheStats();
+      } else {
+        console.error(chalk3.red("Error: Unknown cache command"));
+        console.log("Usage: az cache <clear|stats>");
+        process.exit(1);
+      }
+      break;
+    default:
+      console.error(chalk3.red(`Error: Unknown command: ${command}`));
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error(chalk3.red("Fatal error:"), error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.mjs.map