@cementic/cementic-test 0.2.3 → 0.2.5

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
   genCmd
-} from "./chunk-J63TUHIV.js";
+} from "./chunk-5QRDTCSM.js";
 
 // src/cli.ts
 import { Command as Command9 } from "commander";
+import { createRequire } from "module";
 
 // src/commands/new.ts
 import { Command } from "commander";
@@ -16,12 +17,22 @@ import { dirname } from "path";
 import { platform, release } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
+function resolveTemplatePath(templateDir) {
+  const candidates = [
+    resolve(__dirname, `templates/${templateDir}`),
+    resolve(__dirname, `../templates/${templateDir}`),
+    resolve(__dirname, `../../templates/${templateDir}`),
+    resolve(process.cwd(), `templates/${templateDir}`)
+  ];
+  return candidates.find((candidate) => existsSync(candidate));
+}
 function newCmd() {
   const cmd = new Command("new").arguments("<projectName>").description("Scaffold a new CementicTest + Playwright project from scratch").addHelpText("after", `
 Examples:
   $ ct new my-awesome-test-suite
+  $ ct new e2e-ts --lang ts
   $ ct new e2e-tests --no-browsers
-`).option("--mode <mode>", "greenfield|enhance", "greenfield").option("--no-browsers", 'do not run "npx playwright install" during setup').action((projectName, opts) => {
+`).option("--mode <mode>", "greenfield|enhance", "greenfield").option("--lang <lang>", "Scaffold language (js|ts)", "js").option("--no-browsers", 'do not run "npx playwright install" during setup').action((projectName, opts) => {
     const root = process.cwd();
     const projectPath = join(root, projectName);
     console.log(`\u{1F680} Initializing new CementicTest project in ${projectName}...`);
@@ -30,18 +41,11 @@ Examples:
       process.exit(1);
     }
     mkdirSync(projectPath, { recursive: true });
-    let templatePath = resolve(__dirname, "templates/student-framework");
-    if (!existsSync(templatePath)) {
-      templatePath = resolve(__dirname, "../templates/student-framework");
-    }
-    if (!existsSync(templatePath)) {
-      templatePath = resolve(__dirname, "../../templates/student-framework");
-    }
-    if (!existsSync(templatePath)) {
-      templatePath = resolve(process.cwd(), "templates/student-framework");
-    }
-    if (!existsSync(templatePath)) {
-      console.error(`\u274C Could not locate template at ${templatePath}`);
+    const lang = opts.lang === "ts" ? "ts" : "js";
+    const templateDir = lang === "ts" ? "student-framework-ts" : "student-framework";
+    const templatePath = resolveTemplatePath(templateDir);
+    if (!templatePath) {
+      console.error(`\u274C Could not locate template "${templateDir}"`);
       console.error("Please ensure the package is built correctly with templates included.");
       process.exit(1);
     }
@@ -129,6 +133,10 @@ function parseId(title) {
   const m = title.match(/\b([A-Z]+-\d+)\b/);
   return m?.[1];
 }
+function stripIdPrefixFromTitle(title, id) {
+  if (!id) return title.trim();
+  return title.replace(new RegExp(`^${id}\\s*[\u2014\\-\u2013:]\\s*`), "").trim();
+}
 function splitCasesByHeading(fileText) {
   const lines = fileText.split(/\r?\n/);
   const blocks = [];
@@ -174,34 +182,69 @@ function extractSections(body) {
   const stepsBlock = sections["steps"] ?? "";
   const expectedBlock = sections["expected"] ?? sections["expected results"] ?? sections["then"] ?? "";
   const bullet = /^\s*(?:\d+\.|[-*])\s+(.+)$/gm;
-  const steps = Array.from(stepsBlock.matchAll(bullet)).map((m) => m[1].trim()) || [];
+  const parsedSteps = Array.from(stepsBlock.matchAll(bullet)).map((m) => parseHintedLine(m[1].trim(), "selector"));
+  const steps = parsedSteps.map((entry) => entry.text);
+  const stepHints = parsedSteps.map((entry) => ({ selector: entry.hint }));
   if (steps.length === 0) {
-    const alt = Array.from(body.matchAll(bullet)).map((m) => m[1].trim());
-    steps.push(...alt);
+    const alt = Array.from(body.matchAll(bullet)).map((m) => parseHintedLine(m[1].trim(), "selector"));
+    steps.push(...alt.map((entry) => entry.text));
+    stepHints.push(...alt.map((entry) => ({ selector: entry.hint })));
   }
-  const expectedLines = Array.from(expectedBlock.matchAll(bullet)).map(
-    (m) => m[1].trim()
-  );
+  const parsedExpected = Array.from(expectedBlock.matchAll(bullet)).map((m) => parseHintedLine(m[1].trim(), "playwright"));
+  const expectedLines = parsedExpected.map((entry) => entry.text);
+  const assertionHints = parsedExpected.map((entry) => ({ playwright: entry.hint }));
   if (expectedLines.length === 0) {
     const exp = Array.from(
       body.matchAll(/^\s*(?:Expected|Then|Verify|Assert)[^\n]*:?[\s-]*(.+)$/gim)
-    ).map((m) => m[1].trim());
-    expectedLines.push(...exp);
+    ).map((m) => parseHintedLine(m[1].trim(), "playwright"));
+    expectedLines.push(...exp.map((entry) => entry.text));
+    assertionHints.push(...exp.map((entry) => ({ playwright: entry.hint })));
   }
-  return { steps, expected: expectedLines };
+  return { steps, stepHints, expected: expectedLines, assertionHints };
+}
+function extractUrlMetadata(body) {
+  const match = body.match(/<!--\s*ct:url\s+(https?:\/\/[^\s>]+)\s*-->/i);
+  return match?.[1];
+}
+function stripCtMetadata(body) {
+  return body.replace(/^\s*<!--\s*ct:url\s+https?:\/\/[^\s>]+\s*-->\s*\n?/im, "");
+}
+function parseHintedLine(value, hintType) {
+  const match = value.match(new RegExp(`^(.*?)\\s*<!--\\s*${hintType}:\\s*([\\s\\S]*?)\\s*-->\\s*$`, "i"));
+  if (!match) return { text: value.trim() };
+  return {
+    text: match[1].trim(),
+    hint: match[2].trim() || void 0
+  };
+}
+function extractUrlFromSteps(steps) {
+  for (const step of steps) {
+    const match = step.match(/https?:\/\/[^\s'"]+/i);
+    if (match) return match[0];
+  }
+  return void 0;
 }
 function normalizeOne(titleLine, body, source) {
   const { clean, tags } = parseTags(titleLine);
   const id = parseId(clean);
-  const { steps, expected } = extractSections(body);
+  const metadataUrl = extractUrlMetadata(body);
+  const cleanBody = stripCtMetadata(body);
+  const { steps, stepHints, expected, assertionHints } = extractSections(cleanBody);
+  const reviewReasons = [];
+  if (steps.length === 0) reviewReasons.push("No steps section or bullets were parsed");
+  if (expected.length === 0) reviewReasons.push("No expected results section or assertions were parsed");
   return {
     id,
-    title: clean,
+    title: stripIdPrefixFromTitle(clean, id),
     tags: tags.length ? tags : void 0,
     steps,
+    step_hints: stepHints.some((hint) => hint.selector) ? stepHints : void 0,
     expected,
-    needs_review: steps.length === 0 || expected.length === 0,
-    source
+    assertion_hints: assertionHints.some((hint) => hint.playwright) ? assertionHints : void 0,
+    needs_review: reviewReasons.length > 0,
+    review_reasons: reviewReasons,
+    source,
+    url: metadataUrl ?? extractUrlFromSteps(steps)
   };
 }
 function normalizeCmd() {
@@ -265,7 +308,7 @@ Examples:
     }
     console.log(`\u2705 Normalized ${index.summary.parsed} case(s). Output \u2192 .cementic/normalized/`);
     if (opts.andGen) {
-      const { gen } = await import("./gen-54KYT3RO.js");
+      const { gen } = await import("./gen-RMRQOAD3.js");
       await gen({ lang: opts.lang || "ts", out: "tests/generated" });
     }
   });
@@ -295,8 +338,8 @@ function testCmd() {
 
 // src/commands/tc.ts
 import { Command as Command4 } from "commander";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 
@@ -353,88 +396,136 @@ function inferPrefix(params) {
 // src/core/llm.ts
 function buildSystemMessage() {
   return `
-You are a senior QA engineer and test case designer.
+You are a senior QA engineer and test automation specialist.
 
 Your job:
-- Take the context of a web feature or page,
-- And generate high-quality UI test cases
-- In a very strict Markdown format that another tool will parse.
+- Receive context about a web feature or page
+- Generate high-quality, realistic UI test cases
+- Format them in strict Markdown that a downstream parser will process
 
 You MUST follow this format exactly for each test case:
 
-# <ID> \u2014 <Short title> @<tag1> @<tag2> ...
+# <ID> \u2014 <Short title> @<tag1> @<tag2>
 ## Steps
-1. <step>
-2. <step>
+1. <user action>
+2. <user action>
 
 ## Expected Results
-- <assertion>
-- <assertion>
+- <verifiable outcome>
+- <verifiable outcome>
 
 Rules:
-- <ID> must be PREFIX-XXX where PREFIX is provided to you (e.g., AUTH, DASH, CART).
-- XXX must be a 3-digit number starting from the startIndex provided in the context.
-  For example: DASH-005, DASH-006, DASH-007 if startIndex is 5.
-- Use 1\u20133 tags per test (e.g., @smoke, @regression, @auth, @ui, @critical).
-- "Steps" should describe user actions in sequence.
-- "Expected Results" should describe verifiable outcomes (URL change, element visible, message shown, etc.).
-- Do NOT add any explanation before or after the test cases.
-- Output ONLY the test cases, back-to-back, in Markdown.
-- No code blocks, no extra headings outside the pattern described.
+- ID must be PREFIX-NNN where NNN is zero-padded 3 digits starting from startIndex
+- Use 1\u20133 tags: @smoke @regression @auth @ui @critical @happy-path @negative
+- Steps = concrete user actions ("Click the 'Sign In' button", "Fill in email with 'user@example.com'")
+- Expected Results = verifiable UI outcomes ("Error message 'Invalid credentials' is visible", "Page redirects to /dashboard")
+- Include both happy-path AND negative/edge-case tests
+- Do NOT explain or add preamble \u2014 output ONLY the test cases
+- No code blocks, no extra headings outside the pattern
 `.trim();
 }
 function buildUserMessage(ctx) {
   const lines = [];
-  lines.push(`App / Product description (optional):`);
+  lines.push(`App / product description:`);
   lines.push(ctx.appDescription || "N/A");
   lines.push("");
   lines.push(`Feature or page to test:`);
   lines.push(ctx.feature);
   lines.push("");
   if (ctx.url) {
-    lines.push(`Page URL:`);
-    lines.push(ctx.url);
+    lines.push(`Page URL: ${ctx.url}`);
     lines.push("");
   }
-  if (ctx.pageSummaryJson) {
-    lines.push(`Page structure summary (JSON):`);
-    lines.push("```json");
-    lines.push(JSON.stringify(ctx.pageSummaryJson, null, 2));
-    lines.push("```");
+  if (ctx.pageSummary) {
+    const s = ctx.pageSummary;
+    lines.push(`Live page analysis:`);
+    if (s.title) lines.push(`- Page title: ${s.title}`);
+    if (s.headings.length) {
+      lines.push(`- Headings: ${s.headings.join(" | ")}`);
+    }
+    if (s.inputs.length) {
+      const inputDescs = s.inputs.map((i) => {
+        const parts = [
+          i.label && `label="${i.label}"`,
+          i.placeholder && `placeholder="${i.placeholder}"`,
+          i.name && `name="${i.name}"`,
+          i.type && i.type !== "text" && `type="${i.type}"`,
+          i.testId && `data-testid="${i.testId}"`
+        ].filter(Boolean);
+        return parts.join(", ");
+      });
+      lines.push(`- Form inputs: ${inputDescs.join(" | ")}`);
+    }
+    if (s.buttons.length) {
+      lines.push(`- Buttons: ${s.buttons.join(" | ")}`);
+    }
+    if (s.links.length) {
+      lines.push(`- Links: ${s.links.slice(0, 20).join(" | ")}`);
+    }
     lines.push("");
   }
-  lines.push(`Test ID prefix to use: ${ctx.prefix}`);
-  lines.push(
-    `Start numbering from: ${String(ctx.startIndex).padStart(3, "0")}`
-  );
-  lines.push(`Number of test cases to generate: ${ctx.numCases}`);
+  lines.push(`Test ID prefix: ${ctx.prefix}`);
+  lines.push(`Start numbering from: ${String(ctx.startIndex).padStart(3, "0")}`);
+  lines.push(`Number of test cases: ${ctx.numCases}`);
   lines.push("");
-  lines.push(`Important formatting rules:`);
-  lines.push(`- Use IDs like ${ctx.prefix}-NNN where NNN is 3-digit, sequential from the start index.`);
-  lines.push(`- Each test case must follow this pattern exactly:`);
-  lines.push(`# ${ctx.prefix}-NNN \u2014 <short title> @tag1 @tag2`);
-  lines.push(`## Steps`);
-  lines.push(`1. ...`);
-  lines.push(`2. ...`);
-  lines.push(``);
-  lines.push(`## Expected Results`);
-  lines.push(`- ...`);
-  lines.push(`- ...`);
-  lines.push("");
-  lines.push(`Do NOT add any explanation before or after the test cases. Only output the test cases.`);
+  lines.push(`Include a mix of: happy-path flows, validation/error cases, and edge cases.`);
+  lines.push(`Output ONLY the test cases. No explanation, no preamble.`);
   return lines.join("\n");
 }
-async function generateTcMarkdownWithAi(ctx) {
-  const apiKey = process.env.CT_LLM_API_KEY || process.env.OPENAI_API_KEY || "";
-  if (!apiKey) {
-    throw new Error(
-      "No LLM API key found. Set CT_LLM_API_KEY or OPENAI_API_KEY."
-    );
+function detectProvider() {
+  const anthropicKey = process.env.ANTHROPIC_API_KEY ?? process.env.CT_ANTHROPIC_API_KEY ?? "";
+  const openaiKey = process.env.CT_LLM_API_KEY ?? process.env.OPENAI_API_KEY ?? "";
+  const explicitProvider = (process.env.CT_LLM_PROVIDER ?? "").toLowerCase();
+  if (explicitProvider === "anthropic" || anthropicKey && explicitProvider !== "openai") {
+    if (!anthropicKey) {
+      throw new Error(
+        "CT_LLM_PROVIDER=anthropic but no ANTHROPIC_API_KEY found.\nSet ANTHROPIC_API_KEY=your-key or switch to OPENAI_API_KEY."
+      );
+    }
+    return {
+      provider: "anthropic",
+      apiKey: anthropicKey,
+      model: process.env.CT_LLM_MODEL ?? "claude-sonnet-4-5",
+      baseUrl: "https://api.anthropic.com"
+    };
   }
-  const baseUrl = process.env.CT_LLM_BASE_URL || "https://api.openai.com/v1";
-  const model = process.env.CT_LLM_MODEL || "gpt-4.1-mini";
-  const system = buildSystemMessage();
-  const user = buildUserMessage(ctx);
+  if (openaiKey) {
+    return {
+      provider: "openai",
+      apiKey: openaiKey,
+      model: process.env.CT_LLM_MODEL ?? "gpt-4o-mini",
+      baseUrl: process.env.CT_LLM_BASE_URL ?? "https://api.openai.com/v1"
+    };
+  }
+  throw new Error(
+    "No LLM API key found.\n  For Claude:  export ANTHROPIC_API_KEY=your-key\n  For OpenAI:  export OPENAI_API_KEY=your-key\n  Any OpenAI-compatible endpoint: set CT_LLM_API_KEY + CT_LLM_BASE_URL"
+  );
+}
+async function callAnthropic(apiKey, model, system, user) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      system,
+      messages: [{ role: "user", content: user }]
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text}`);
+  }
+  const json = await response.json();
+  const content = json.content?.[0]?.text?.trim() ?? "";
+  if (!content) throw new Error("Anthropic response had no content");
+  return content;
+}
+async function callOpenAi(apiKey, model, baseUrl, system, user) {
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -443,76 +534,978 @@ async function generateTcMarkdownWithAi(ctx) {
     },
     body: JSON.stringify({
       model,
+      temperature: 0.2,
       messages: [
         { role: "system", content: system },
         { role: "user", content: user }
-      ],
-      temperature: 0.2
+      ]
     })
   });
   if (!response.ok) {
     const text = await response.text();
-    throw new Error(
-      `LLM request failed: ${response.status} ${response.statusText} \u2014 ${text}`
-    );
+    throw new Error(`OpenAI API error ${response.status}: ${text}`);
+  }
+  const json = await response.json();
+  const content = json.choices?.[0]?.message?.content?.trim() ?? "";
+  if (!content) throw new Error("OpenAI response had no content");
+  return content;
+}
+async function generateTcMarkdownWithAi(ctx) {
+  const { provider, apiKey, model, baseUrl } = detectProvider();
+  const system = buildSystemMessage();
+  const user = buildUserMessage(ctx);
+  console.log(`\u{1F916} Using ${provider === "anthropic" ? "Claude" : "OpenAI-compatible"} (${model})`);
+  if (provider === "anthropic") {
+    return callAnthropic(apiKey, model, system, user);
+  }
+  return callOpenAi(apiKey, model, baseUrl, system, user);
+}
+
+// src/core/analyse.ts
+async function analyseElements(elementMap, options = {}) {
+  const { verbose = false } = options;
+  const { provider, displayName, apiKey, model, baseUrl } = detectProvider2();
+  log(verbose, `
+[analyse] Sending capture to ${displayName} (${model})`);
+  const systemPrompt = buildSystemPrompt();
+  const userPrompt = buildUserPrompt(elementMap);
+  const rawResponse = provider === "anthropic" ? await callAnthropic2(apiKey, model, systemPrompt, userPrompt) : await callOpenAi2(apiKey, model, baseUrl ?? "https://api.openai.com/v1", systemPrompt, userPrompt);
+  const parsed = parseAnalysisJson(rawResponse);
+  return sanitizeAnalysis(parsed, elementMap);
+}
+function detectProvider2() {
+  const explicitProvider = (process.env.CT_LLM_PROVIDER ?? "").toLowerCase();
+  const providers = {
+    deepseek: {
+      provider: "deepseek",
+      displayName: "DeepSeek",
+      apiKey: process.env.DEEPSEEK_API_KEY ?? process.env.CT_DEEPSEEK_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.DEEPSEEK_MODEL ?? "deepseek-chat",
+      baseUrl: process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com/v1"
+    },
+    anthropic: {
+      provider: "anthropic",
+      displayName: "Claude",
+      apiKey: process.env.ANTHROPIC_API_KEY ?? process.env.CT_ANTHROPIC_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4-5"
+    },
+    gemini: {
+      provider: "gemini",
+      displayName: "Gemini",
+      apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.GEMINI_MODEL ?? "gemini-2.5-flash",
+      baseUrl: process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta/openai"
+    },
+    qwen: {
+      provider: "qwen",
+      displayName: "Qwen",
+      apiKey: process.env.QWEN_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.QWEN_MODEL ?? "qwen-plus",
+      baseUrl: process.env.QWEN_BASE_URL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+    },
+    kimi: {
+      provider: "kimi",
+      displayName: "Kimi",
+      apiKey: process.env.KIMI_API_KEY ?? process.env.MOONSHOT_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.KIMI_MODEL ?? "moonshot-v1-8k",
+      baseUrl: process.env.KIMI_BASE_URL ?? "https://api.moonshot.ai/v1"
+    },
+    openai: {
+      provider: "openai",
+      displayName: "OpenAI-compatible",
+      apiKey: process.env.OPENAI_API_KEY ?? process.env.CT_LLM_API_KEY ?? "",
+      model: process.env.CT_LLM_MODEL ?? process.env.OPENAI_MODEL ?? "gpt-4o-mini",
+      baseUrl: process.env.CT_LLM_BASE_URL ?? "https://api.openai.com/v1"
+    }
+  };
+  if (explicitProvider) {
+    if (!(explicitProvider in providers)) {
+      throw new Error(`Unsupported CT_LLM_PROVIDER="${explicitProvider}". Use deepseek, anthropic, gemini, qwen, kimi, or openai.`);
+    }
+    const selected = providers[explicitProvider];
+    if (!selected.apiKey) {
+      throw new Error(`CT_LLM_PROVIDER=${explicitProvider} is set but the matching API key is missing.`);
+    }
+    return selected;
+  }
+  for (const providerName of ["deepseek", "anthropic", "gemini", "qwen", "kimi", "openai"]) {
+    if (providers[providerName].apiKey) return providers[providerName];
+  }
+  throw new Error(
+    "No LLM API key found.\n  DeepSeek:   export DEEPSEEK_API_KEY=your-key\n  Anthropic:  export ANTHROPIC_API_KEY=your-key\n  Gemini:     export GEMINI_API_KEY=your-key\n  Qwen:       export QWEN_API_KEY=your-key\n  Kimi:       export KIMI_API_KEY=your-key\n  OpenAI:     export OPENAI_API_KEY=your-key"
+  );
+}
+function buildSystemPrompt() {
+  return `
+You are a senior QA automation engineer and Playwright expert working on CementicTest.
+
+Your job is to analyse a structured map of interactive elements extracted from a live web page,
+then produce a complete set of Playwright test scenarios.
+
+RULES:
+1. Use only selectors provided in the ElementMap.
+2. Every assertion must include an exact "playwright" field with a complete await expect(...) statement.
+3. Use clearly fake data like user@example.com.
+4. Include both happy-path and negative scenarios, but stay evidence-backed.
+5. Output only valid JSON matching the requested schema.
+6. Do not invent redirect targets, success pages, error text, password clearing, or security scenarios unless the capture explicitly supports them.
+7. If no status or alert region was captured, avoid scenarios that depend on unseen server-side validation messages.
+8. Prefer 3 to 5 realistic scenarios.
+
+OUTPUT SCHEMA:
+{
+  "url": string,
+  "feature": string,
+  "suggestedPrefix": string,
+  "scenarios": [
+    {
+      "id": string,
+      "title": string,
+      "tags": string[],
+      "steps": [
+        {
+          "action": "navigate"|"fill"|"click"|"select"|"check"|"keyboard"|"hover",
+          "selector": string,
+          "value": string,
+          "human": string
+        }
+      ],
+      "assertions": [
+        {
+          "type": string,
+          "selector": string,
+          "expected": string,
+          "human": string,
+          "playwright": string
+        }
+      ],
+      "narrator": string,
+      "codeLevel": "beginner"|"intermediate"|"advanced"
+    }
+  ],
+  "analysisNotes": string,
+  "audioSummary": string
+}`.trim();
+}
+function buildUserPrompt(elementMap) {
+  const lines = [];
+  lines.push("PAGE INFORMATION");
+  lines.push(`URL: ${elementMap.url}`);
+  lines.push(`Title: ${elementMap.title}`);
+  lines.push(`Captured in: ${elementMap.mode} mode`);
+  lines.push("");
+  for (const category of ["input", "button", "link", "heading", "status"]) {
+    const items = elementMap.elements.filter((element) => element.category === category);
+    if (items.length === 0) continue;
+    lines.push(`${category.toUpperCase()}S (${items.length} found):`);
+    for (const item of items.slice(0, category === "link" ? 10 : items.length)) {
+      lines.push(`  - [${item.confidence}] ${item.selector}`);
+      lines.push(`    Purpose: ${item.purpose}`);
+      if (item.selectorAlt.length > 0) {
+        lines.push(`    Fallbacks: ${item.selectorAlt.slice(0, 2).join(" | ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (elementMap.warnings.length > 0) {
+    lines.push("CAPTURE WARNINGS:");
+    for (const warning of elementMap.warnings) {
+      lines.push(`  - ${warning}`);
+    }
+    lines.push("");
+  }
+  const interactiveCount = elementMap.elements.filter((element) => element.category === "input" || element.category === "button" || element.category === "link").length;
+  const statusCount = elementMap.elements.filter((element) => element.category === "status").length;
+  lines.push("EVIDENCE CONSTRAINTS:");
+  lines.push(`  - Interactive elements captured: ${interactiveCount}`);
+  lines.push(`  - Status or alert regions captured: ${statusCount}`);
+  lines.push("  - If no redirect target is explicitly captured, do not assert a destination path.");
+  lines.push("  - If no status region was captured, avoid exact server-side credential error claims.");
+  lines.push("");
+  lines.push("Generate only the JSON response.");
+  return lines.join("\n");
+}
+async function callAnthropic2(apiKey, model, systemPrompt, userPrompt) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: [{ role: "user", content: userPrompt }]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Anthropic API ${response.status}: ${await response.text()}`);
   }
   const json = await response.json();
-  const content = json.choices?.[0]?.message?.content?.trim() || "";
-  if (!content) {
-    throw new Error("LLM response had no content");
+  const content = json.content?.[0]?.text?.trim() ?? "";
+  if (!content) throw new Error("Anthropic returned empty content");
+  return content;
+}
+async function callOpenAi2(apiKey, model, baseUrl, systemPrompt, userPrompt) {
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      temperature: 0.1,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI API ${response.status}: ${await response.text()}`);
   }
+  const json = await response.json();
+  const content = json.choices?.[0]?.message?.content?.trim() ?? "";
+  if (!content) throw new Error("OpenAI-compatible provider returned empty content");
   return content;
 }
+function parseAnalysisJson(raw) {
+  const stripped = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
+  try {
+    return JSON.parse(stripped);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse LLM response as JSON.
+Parse error: ${error?.message ?? error}
+Raw response:
+${raw.slice(0, 500)}`
+    );
+  }
+}
+function sanitizeAnalysis(analysis, elementMap) {
+  const selectors = new Set(elementMap.elements.map((element) => element.selector));
+  const rawScenarios = Array.isArray(analysis.scenarios) ? analysis.scenarios : [];
+  const currentUrl = new URL(elementMap.url);
+  const knownPaths = /* @__PURE__ */ new Set([
+    currentUrl.pathname,
+    ...elementMap.elements.filter((element) => element.category === "link").map((element) => {
+      const href = element.attributes?.href;
+      if (typeof href !== "string") return "";
+      try {
+        return new URL(href, elementMap.url).pathname;
+      } catch {
+        return href;
+      }
+    }).filter(Boolean)
+  ]);
+  const sanitizedScenarios = rawScenarios.map((scenario) => normalizeScenario(scenario, selectors)).filter((scenario) => scenario.steps.length > 0 && scenario.assertions.length > 0).map((scenario) => ({
+    ...scenario,
+    tags: scenario.tags.map(normalizeTag),
+    assertions: scenario.assertions.filter((assertion) => {
+      if (assertion.type !== "url") return true;
+      const combined = `${assertion.expected} ${assertion.human} ${assertion.playwright}`;
+      const pathMatch = combined.match(/\/[a-z0-9/_-]+/i);
+      if (!pathMatch) return true;
+      return knownPaths.has(pathMatch[0]);
+    })
+  })).filter((scenario) => scenario.assertions.length > 0).slice(0, 5);
+  const finalScenarios = sanitizedScenarios.length > 0 ? sanitizedScenarios : buildFallbackScenarios(elementMap, analysis.suggestedPrefix || "FLOW");
+  return {
+    ...analysis,
+    url: analysis.url || elementMap.url,
+    feature: analysis.feature || inferFeatureName(elementMap),
+    suggestedPrefix: (analysis.suggestedPrefix || inferPrefix2(elementMap)).toUpperCase(),
+    scenarios: finalScenarios,
+    analysisNotes: [
+      analysis.analysisNotes,
+      `Sanitized to ${finalScenarios.length} evidence-backed scenario(s) from ${rawScenarios.length} raw scenario(s).`
+    ].filter(Boolean).join(" "),
+    audioSummary: analysis.audioSummary || buildAudioSummary(analysis.feature || inferFeatureName(elementMap), finalScenarios)
+  };
+}
+function normalizeScenario(candidate, selectors) {
+  return {
+    id: candidate?.id ?? "FLOW-001",
+    title: candidate?.title ?? "Captured page flow",
+    tags: Array.isArray(candidate?.tags) ? candidate.tags : [],
+    steps: Array.isArray(candidate?.steps) ? candidate.steps.filter((step) => step?.selector === "page" || selectors.has(step?.selector)) : [],
+    assertions: Array.isArray(candidate?.assertions) ? candidate.assertions.filter((assertion) => assertion?.selector === "page" || selectors.has(assertion?.selector)) : [],
+    narrator: candidate?.narrator ?? "Let us run this captured test flow.",
+    codeLevel: candidate?.codeLevel ?? "beginner"
+  };
+}
+function buildFallbackScenarios(elementMap, prefix) {
+  const heading = elementMap.elements.find((element) => element.category === "heading");
+  const emailInput = elementMap.elements.find((element) => element.category === "input" && (element.attributes.type === "email" || /email/.test(`${element.name ?? ""} ${String(element.attributes.label ?? "")}`.toLowerCase())));
+  const passwordInput = elementMap.elements.find((element) => element.category === "input" && element.attributes.type === "password");
+  const submitButton = elementMap.elements.find((element) => element.category === "button" && /login|sign in|submit|continue/i.test(element.name ?? "")) ?? elementMap.elements.find((element) => element.category === "button");
+  const scenarios = [];
+  const tag = (value) => normalizeTag(value);
+  const nextId = (index) => `${prefix}-${String(900 + index).padStart(3, "0")}`;
+  if (heading) {
+    scenarios.push({
+      id: nextId(scenarios.length + 1),
+      title: "Page loads with expected heading",
+      tags: [tag("smoke"), tag("page-load")],
+      steps: [
+        {
+          action: "navigate",
+          selector: "page",
+          value: elementMap.url,
+          human: "Navigate to the captured page"
+        }
+      ],
+      assertions: [
+        {
+          type: "visible",
+          selector: heading.selector,
+          expected: "visible",
+          human: `${heading.name || "Primary heading"} is visible`,
+          playwright: `await expect(page.${heading.selector}).toBeVisible();`
+        }
+      ],
+      narrator: "We will first confirm that the expected page heading is visible.",
+      codeLevel: "beginner"
+    });
+  }
+  if (emailInput && passwordInput && submitButton) {
+    scenarios.push({
+      id: nextId(scenarios.length + 1),
+      title: "Submitting without a password keeps the user on the form",
+      tags: [tag("validation"), tag("negative")],
+      steps: [
+        {
+          action: "navigate",
+          selector: "page",
+          value: elementMap.url,
+          human: "Navigate to the captured page"
+        },
+        {
+          action: "fill",
+          selector: emailInput.selector,
+          value: "user@example.com",
+          human: "Fill in the email field"
+        },
+        {
+          action: "click",
+          selector: submitButton.selector,
+          value: "",
+          human: "Click the submit button"
+        }
+      ],
+      assertions: [
+        {
+          type: "url",
+          selector: "page",
+          expected: new URL(elementMap.url).pathname,
+          human: "User remains on the same page",
+          playwright: `await expect(page).toHaveURL('${elementMap.url}');`
+        },
+        {
+          type: "visible",
+          selector: passwordInput.selector,
+          expected: "visible",
+          human: "Password field stays visible for correction",
+          playwright: `await expect(page.${passwordInput.selector}).toBeVisible();`
+        }
+      ],
+      narrator: "Next we will leave the password blank and confirm the form does not advance.",
+      codeLevel: "beginner"
+    });
+  }
+  return scenarios.slice(0, 5);
+}
+function inferFeatureName(elementMap) {
+  const heading = elementMap.elements.find((element) => element.category === "heading" && element.name);
+  return heading?.name || elementMap.title || "Captured page";
+}
+function inferPrefix2(elementMap) {
+  const source = `${elementMap.title} ${elementMap.url}`.toLowerCase();
+  if (/\blogin|sign in|auth/.test(source)) return "AUTH";
+  if (/\bcheckout|cart|payment/.test(source)) return "CHK";
+  if (/\bdashboard/.test(source)) return "DASH";
+  return "FLOW";
+}
+function buildAudioSummary(feature, scenarios) {
+  return `We finished validating ${feature || "the captured page"} with ${scenarios.length} evidence-backed scenario${scenarios.length === 1 ? "" : "s"}.`;
+}
+function normalizeTag(value) {
+  const cleaned = String(value ?? "").trim().replace(/^@+/, "");
+  return cleaned ? `@${cleaned}` : "@ui";
+}
+function log(verbose, message) {
+  if (verbose) console.log(message);
+}
 
-// src/core/scrape.ts
-async function scrapePageSummary(url) {
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
-  }
-  const html = await res.text();
-  const rawLength = html.length;
-  const titleMatch = html.match(/<title[^>]*>([^<]*)<\/title>/i);
-  const title = titleMatch?.[1]?.trim() || void 0;
-  const headings = Array.from(html.matchAll(/<(h1|h2)[^>]*>([^<]*)<\/\1>/gi)).map((m) => m[2].replace(/\s+/g, " ").trim()).filter(Boolean);
-  const buttons = Array.from(html.matchAll(/<button[^>]*>([^<]*)<\/button>/gi)).map((m) => m[1].replace(/\s+/g, " ").trim()).filter(Boolean);
-  const links = Array.from(html.matchAll(/<a[^>]*>([^<]*)<\/a>/gi)).map((m) => m[1].replace(/\s+/g, " ").trim()).filter(Boolean).slice(0, 50);
-  const inputs = [];
-  const labelMap = /* @__PURE__ */ new Map();
-  for (const m of html.matchAll(/<label[^>]*for=["']?([^"'>\s]+)["']?[^>]*>([^<]*)<\/label>/gi)) {
-    const id = m[1];
-    const text = m[2].replace(/\s+/g, " ").trim();
-    if (id && text) labelMap.set(id, text);
-  }
-  for (const m of html.matchAll(/<input([^>]*)>/gi)) {
-    const attrs = m[1];
-    const nameMatch = attrs.match(/\bname=["']?([^"'>\s]+)["']?/i);
-    const idMatch = attrs.match(/\bid=["']?([^"'>\s]+)["']?/i);
-    const phMatch = attrs.match(/\bplaceholder=["']([^"']*)["']/i);
-    const id = idMatch?.[1];
-    const label = id ? labelMap.get(id) : void 0;
-    const ph = phMatch?.[1]?.trim();
-    const name = nameMatch?.[1];
-    const descriptor = label || ph || name;
-    if (descriptor) {
-      inputs.push(descriptor);
+// src/core/capture.ts
+var SETTLE_MS = 1200;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_PER_CATEGORY = 50;
+async function captureElements(url, options = {}) {
+  const {
+    headless = true,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    verbose = false,
+    userAgent = "Mozilla/5.0 (compatible; CementicTest/0.2.5 capture)"
+  } = options;
+  const chromium = await loadChromium();
+  const mode = headless ? "headless" : "headed";
+  log2(verbose, `
+[capture] Starting ${mode} capture: ${url}`);
+  const browser = await chromium.launch({
+    headless,
+    slowMo: headless ? 0 : 150
+  });
+  const context = await browser.newContext({
+    userAgent,
+    viewport: { width: 1280, height: 800 },
+    ignoreHTTPSErrors: true
+  });
+  const page = await context.newPage();
+  try {
+    log2(verbose, `  -> Navigating (timeout: ${timeoutMs}ms)`);
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: timeoutMs
+    });
+    log2(verbose, `  -> Waiting ${SETTLE_MS}ms for page settle`);
+    await page.waitForTimeout(SETTLE_MS);
+    log2(verbose, "  -> Extracting accessibility snapshot");
+    const a11ySnapshot = await getAccessibilitySnapshot(page, verbose);
+    log2(verbose, "  -> Extracting DOM data");
+    const domData = await page.evaluate(extractDomData);
+    const title = await page.title();
+    const finalUrl = page.url();
+    const elements = buildElementMap(domData);
+    const warnings = buildWarnings(elements, domData, a11ySnapshot);
+    const byCategory = {};
+    for (const element of elements) {
+      byCategory[element.category] = (byCategory[element.category] ?? 0) + 1;
     }
+    const result = {
+      url: finalUrl,
+      title,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode,
+      summary: {
+        totalElements: elements.length,
+        byCategory
+      },
+      elements,
+      warnings
+    };
+    log2(verbose, `  -> Captured ${elements.length} testable elements from "${title}"`);
+    return result;
+  } finally {
+    await browser.close();
   }
+}
+function toPageSummary(elementMap) {
+  const inputs = elementMap.elements.filter((element) => element.category === "input").slice(0, 30).map((element) => ({
+    label: asString(element.attributes.label),
+    placeholder: asString(element.attributes.placeholder),
+    name: asString(element.attributes.name),
+    type: asString(element.attributes.type),
+    testId: asString(element.attributes.testId)
+  }));
   return {
-    url,
-    title,
+    url: elementMap.url,
+    title: elementMap.title,
+    headings: elementMap.elements.filter((element) => element.category === "heading").map((element) => element.name ?? "").filter(Boolean).slice(0, 20),
+    buttons: elementMap.elements.filter((element) => element.category === "button").map((element) => element.name ?? "").filter(Boolean).slice(0, 30),
+    links: elementMap.elements.filter((element) => element.category === "link").map((element) => element.name ?? "").filter(Boolean).slice(0, 50),
+    inputs,
+    landmarks: [],
+    rawLength: elementMap.elements.length
+  };
+}
+async function loadChromium() {
+  try {
+    return (await import("playwright-core")).chromium;
+  } catch {
+  }
+  try {
+    return (await import("@playwright/test")).chromium;
+  } catch {
+  }
+  throw new Error(
+    'Playwright is required for live page capture. Install it in the target project with "npm install -D @playwright/test" and "npx playwright install chromium".'
+  );
+}
+function extractDomData() {
+  const localMaxPerCategory = 50;
+  const attr = (el, name) => el.getAttribute(name)?.trim() || void 0;
+  const text = (el) => el?.textContent?.replace(/\s+/g, " ").trim() || void 0;
+  const jsString = (value) => JSON.stringify(value);
+  const findLabel = (el) => {
+    const id = attr(el, "id");
+    if (id) {
+      const labelEl = document.querySelector(`label[for="${id}"]`);
+      if (labelEl) return text(labelEl);
+    }
+    const ariaLabel = attr(el, "aria-label");
+    if (ariaLabel) return ariaLabel;
+    const labelledBy = attr(el, "aria-labelledby");
+    if (labelledBy) {
+      const labelEl = document.getElementById(labelledBy);
+      if (labelEl) return text(labelEl);
+    }
+    const closestLabel = el.closest("label");
+    if (closestLabel) {
+      const raw = text(closestLabel) || "";
+      const placeholder = attr(el, "placeholder") || "";
+      return raw.replace(placeholder, "").trim() || void 0;
+    }
+    const previous = el.previousElementSibling;
+    if (previous?.tagName === "LABEL") return text(previous);
+    return void 0;
+  };
+  const buildSelector = (el, labelText, buttonText) => {
+    const testId = attr(el, "data-testid");
+    if (testId) return `getByTestId(${jsString(testId)})`;
+    const id = attr(el, "id");
+    if (id && !id.match(/^(ember|react|vue|ng|auto|rand)/i)) {
+      return `locator(${jsString(`#${id}`)})`;
+    }
+    const ariaLabel = attr(el, "aria-label");
+    if (ariaLabel) {
+      return `getByRole(${jsString(el.getAttribute("role") || el.tagName.toLowerCase())}, { name: ${jsString(ariaLabel)} })`;
+    }
+    if (labelText) {
+      const tag = el.tagName.toLowerCase();
+      if (tag === "input" || tag === "textarea" || tag === "select") {
+        return `getByLabel(${jsString(labelText)})`;
+      }
+    }
+    if (buttonText) return `getByRole('button', { name: ${jsString(buttonText)} })`;
+    const name = attr(el, "name");
+    if (name) return `locator(${jsString(`[name="${name}"]`)})`;
+    return null;
+  };
+  const buttons = [];
+  document.querySelectorAll('button, [role="button"], input[type="submit"], input[type="button"]').forEach((el) => {
+    const buttonText = attr(el, "aria-label") || text(el) || attr(el, "value");
+    const testId = attr(el, "data-testid");
+    const id = attr(el, "id");
+    const type = attr(el, "type");
+    const disabled = el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true";
+    const selector = buildSelector(el, void 0, buttonText);
+    if (buttonText || testId) {
+      buttons.push({
+        tag: el.tagName.toLowerCase(),
+        text: buttonText,
+        testId,
+        id,
+        type,
+        disabled,
+        selector,
+        cssPath: testId ? `[data-testid="${testId}"]` : id ? `#${id}` : null
+      });
+    }
+  });
+  const inputs = [];
+  document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select').forEach((el) => {
+    const label = findLabel(el);
+    const placeholder = attr(el, "placeholder");
+    const name = attr(el, "name");
+    const id = attr(el, "id");
+    const type = attr(el, "type") || el.tagName.toLowerCase();
+    const testId = attr(el, "data-testid");
+    const required = el.hasAttribute("required");
+    const selector = buildSelector(el, label);
+    if (label || placeholder || name || testId || id) {
+      inputs.push({
+        tag: el.tagName.toLowerCase(),
+        type,
+        label,
+        placeholder,
+        name,
+        id,
+        testId,
+        required,
+        selector,
+        cssPath: testId ? `[data-testid="${testId}"]` : id ? `#${id}` : name ? `[name="${name}"]` : null
+      });
+    }
+  });
+  const links = [];
+  document.querySelectorAll("a[href]").forEach((el) => {
+    const linkText = attr(el, "aria-label") || text(el);
+    const href = attr(el, "href");
+    const testId = attr(el, "data-testid");
+    if (!linkText || href === "#") return;
+    links.push({
+      text: linkText,
+      href,
+      testId,
+      external: Boolean(href?.startsWith("http") && !href.includes(window.location.hostname)),
+      selector: testId ? `getByTestId(${jsString(testId)})` : `getByRole('link', { name: ${jsString(linkText)} })`
+    });
+  });
+  const headings = [];
+  document.querySelectorAll("h1, h2, h3").forEach((el) => {
+    const headingText = text(el);
+    if (headingText) {
+      headings.push({
+        level: el.tagName.toLowerCase(),
+        text: headingText,
+        selector: `getByRole('heading', { name: ${jsString(headingText)} })`
+      });
+    }
+  });
+  const landmarks = [];
+  document.querySelectorAll("[role], main, nav, header, footer, aside, section[aria-label]").forEach((el) => {
+    const role = attr(el, "role") || el.tagName.toLowerCase();
+    const label = attr(el, "aria-label") || text(el)?.slice(0, 40);
+    if (role && label) landmarks.push({ role, label });
+  });
+  const statusRegions = [];
+  document.querySelectorAll('[role="alert"], [role="status"], [aria-live]').forEach((el) => {
+    const role = attr(el, "role") || "live";
+    statusRegions.push({
+      role,
+      ariaLive: attr(el, "aria-live"),
+      text: text(el),
+      selector: el.getAttribute("role") ? `getByRole(${jsString(role)})` : `locator('[aria-live]')`
+    });
+  });
+  const forms = [];
+  document.querySelectorAll("form").forEach((form, index) => {
+    forms.push({
+      id: attr(form, "id"),
+      label: attr(form, "aria-label") || attr(form, "aria-labelledby"),
+      action: attr(form, "action"),
+      method: attr(form, "method") || "get",
+      fieldCount: form.querySelectorAll("input, textarea, select").length,
+      index
+    });
+  });
+  return {
+    buttons: buttons.slice(0, localMaxPerCategory),
+    inputs: inputs.slice(0, localMaxPerCategory),
+    links: links.slice(0, localMaxPerCategory),
     headings: headings.slice(0, 20),
-    buttons: buttons.slice(0, 30),
-    links,
-    inputs: inputs.slice(0, 30),
-    rawLength
+    landmarks,
+    statusRegions,
+    forms,
+    pageUrl: window.location.href,
+    pageTitle: document.title
   };
 }
+function buildElementMap(domData) {
+  const elements = [];
+  for (const input2 of domData.inputs) {
+    const displayName = input2.label || input2.placeholder || input2.name || input2.testId;
+    if (!displayName) continue;
+    const selector = input2.selector || (input2.testId ? `getByTestId(${JSON.stringify(input2.testId)})` : null) || (input2.label ? `getByLabel(${JSON.stringify(input2.label)})` : null) || (input2.id ? `locator(${JSON.stringify(`#${input2.id}`)})` : null) || (input2.name ? `locator(${JSON.stringify(`[name="${input2.name}"]`)})` : null) || `locator(${JSON.stringify(`${input2.tag}[placeholder="${input2.placeholder ?? ""}"]`)})`;
+    const selectorAlt = [];
+    if (input2.id && !selector.includes(`#${input2.id}`)) selectorAlt.push(`locator(${JSON.stringify(`#${input2.id}`)})`);
+    if (input2.name && !selector.includes(input2.name)) selectorAlt.push(`locator(${JSON.stringify(`[name="${input2.name}"]`)})`);
+    if (input2.testId && !selector.includes(input2.testId)) selectorAlt.push(`getByTestId(${JSON.stringify(input2.testId)})`);
+    if (input2.placeholder && !selector.includes(input2.placeholder)) selectorAlt.push(`getByPlaceholder(${JSON.stringify(input2.placeholder)})`);
+    if (input2.label && !selector.includes(input2.label)) selectorAlt.push(`getByLabel(${JSON.stringify(input2.label)})`);
+    elements.push({
+      category: "input",
+      role: input2.type === "checkbox" ? "checkbox" : "textbox",
+      name: displayName,
+      selector,
+      selectorAlt,
+      purpose: input2.required ? `Required ${input2.type} field - "${displayName}"` : `${input2.type} field - "${displayName}"`,
+      confidence: input2.testId || input2.label || input2.id ? "high" : input2.placeholder ? "medium" : "low",
+      attributes: {
+        type: input2.type,
+        label: input2.label,
+        placeholder: input2.placeholder,
+        name: input2.name,
+        id: input2.id,
+        testId: input2.testId,
+        required: input2.required,
+        tag: input2.tag
+      }
+    });
+  }
+  for (const button of domData.buttons) {
+    const displayName = button.text || button.testId;
+    if (!displayName) continue;
+    const selector = button.selector || (button.testId ? `getByTestId(${JSON.stringify(button.testId)})` : null) || (button.text ? `getByRole('button', { name: ${JSON.stringify(button.text)} })` : null) || (button.id ? `locator(${JSON.stringify(`#${button.id}`)})` : null) || `locator('button')`;
+    const selectorAlt = [];
+    if (button.id && !selector.includes(button.id)) selectorAlt.push(`locator(${JSON.stringify(`#${button.id}`)})`);
+    if (button.testId && !selector.includes(button.testId)) selectorAlt.push(`getByTestId(${JSON.stringify(button.testId)})`);
+    if (button.text && !selector.includes(button.text)) selectorAlt.push(`getByText(${JSON.stringify(button.text)})`);
+    if (button.cssPath) selectorAlt.push(`locator(${JSON.stringify(button.cssPath)})`);
+    elements.push({
+      category: "button",
+      role: "button",
+      name: displayName,
+      selector,
+      selectorAlt,
+      purpose: button.disabled ? `Disabled button - "${displayName}"` : button.type === "submit" ? `Form submit button - "${displayName}"` : `Button - "${displayName}"`,
+      confidence: button.testId || button.text ? "high" : button.id ? "medium" : "low",
+      attributes: {
+        text: button.text,
+        testId: button.testId,
+        id: button.id,
+        type: button.type,
+        disabled: button.disabled,
+        tag: button.tag
+      }
+    });
+  }
+  for (const link of domData.links) {
+    elements.push({
+      category: "link",
+      role: "link",
+      name: link.text,
+      selector: link.selector,
+      selectorAlt: link.testId ? [`getByTestId(${JSON.stringify(link.testId)})`] : [],
+      purpose: link.external ? `External link to "${link.href}" - "${link.text}"` : `Internal navigation link - "${link.text}" -> ${link.href}`,
+      confidence: link.testId ? "high" : "medium",
+      attributes: {
+        text: link.text,
+        href: link.href,
+        testId: link.testId,
+        external: link.external
+      }
+    });
+  }
+  for (const heading of domData.headings) {
+    elements.push({
+      category: "heading",
+      role: "heading",
+      name: heading.text,
+      selector: heading.selector,
+      selectorAlt: [`getByText(${JSON.stringify(heading.text)})`],
+      purpose: `Page ${heading.level} heading - use to assert the correct page or section loaded`,
+      confidence: "medium",
+      attributes: {
+        level: heading.level,
+        text: heading.text
+      }
+    });
+  }
+  for (const status of domData.statusRegions) {
+    elements.push({
+      category: "status",
+      role: status.role,
+      name: status.text || status.role,
+      selector: status.selector,
+      selectorAlt: [],
+      purpose: "Live region - use to assert error messages, success toasts, and validation feedback",
+      confidence: "medium",
+      attributes: {
+        role: status.role,
+        ariaLive: status.ariaLive,
+        currentText: status.text
+      }
+    });
+  }
+  return elements;
+}
+function buildWarnings(elements, domData, a11ySnapshot) {
+  const warnings = [];
+  if (!a11ySnapshot) {
+    warnings.push("Playwright accessibility snapshot was unavailable. Capture continued using DOM extraction only.");
+  }
+  const lowConfidenceInputs = elements.filter((element) => element.category === "input" && element.confidence === "low");
+  if (lowConfidenceInputs.length > 0) {
+    warnings.push(
+      `${lowConfidenceInputs.length} input(s) have low-confidence selectors. Consider adding data-testid attributes to: ${lowConfidenceInputs.map((element) => element.name).filter(Boolean).join(", ")}`
+    );
+  }
+  if (domData.statusRegions.length === 0) {
+    warnings.push("No ARIA alert or status regions detected. Error message assertions may need manual selector adjustments after generation.");
+  }
+  for (const form of domData.forms) {
+    const hasSubmit = domData.buttons.some((button) => button.type === "submit");
+    if (form.fieldCount > 0 && !hasSubmit) {
+      warnings.push(
+        `Form ${form.id || `#${form.index}`} has ${form.fieldCount} field(s) but no detected submit button. It may use keyboard submit or a custom handler.`
+      );
+    }
+  }
+  if (domData.links.length >= MAX_PER_CATEGORY) {
+    warnings.push(`Link count hit the ${MAX_PER_CATEGORY} capture limit. Generation will focus on forms and buttons.`);
+  }
+  const interactive = elements.filter((element) => element.category === "button" || element.category === "input" || element.category === "link");
+  if (interactive.length === 0) {
+    warnings.push("No interactive elements detected. The page may require authentication, render later than the current settle window, or be mostly static content.");
+  }
+  return warnings;
+}
+function log2(verbose, message) {
+  if (verbose) console.log(message);
+}
+async function getAccessibilitySnapshot(page, verbose) {
+  if (!page.accessibility || typeof page.accessibility.snapshot !== "function") {
+    log2(verbose, "  -> Accessibility snapshot API unavailable; continuing with DOM-only capture");
+    return null;
+  }
+  try {
+    return await page.accessibility.snapshot({ interestingOnly: false });
+  } catch (error) {
+    log2(verbose, `  -> Accessibility snapshot failed (${error?.message ?? error}); continuing with DOM-only capture`);
+    return null;
+  }
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/core/report.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+function printCaptureReport(elementMap, analysis) {
+  console.log("");
+  console.log("=".repeat(60));
+  console.log("CementicTest Capture Report");
+  console.log("=".repeat(60));
+  console.log(`URL: ${elementMap.url}`);
+  console.log(`Title: ${elementMap.title}`);
+  console.log(`Captured: ${elementMap.timestamp} (${elementMap.mode})`);
+  console.log("");
+  console.log("Elements:");
+  for (const [category, count] of Object.entries(elementMap.summary.byCategory)) {
+    console.log(`  ${category}: ${count}`);
+  }
+  if (elementMap.warnings.length > 0) {
+    console.log("");
+    console.log("Warnings:");
+    for (const warning of elementMap.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+  if (analysis) {
+    console.log("");
+    console.log(`AI scenarios: ${analysis.scenarios.length}`);
+    console.log(`Feature: ${analysis.feature}`);
+    console.log(`Prefix: ${analysis.suggestedPrefix}`);
+  }
+  console.log("");
+}
+function saveCaptureJson(elementMap, analysis, outputDir = ".cementic/capture") {
+  mkdirSync3(outputDir, { recursive: true });
+  const fileName = `capture-${slugify(elementMap.url)}-${Date.now()}.json`;
+  const filePath = join3(outputDir, fileName);
+  writeFileSync3(filePath, JSON.stringify({
+    _meta: {
+      version: "0.2.5",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: "@cementic/cementic-test"
+    },
+    elementMap,
+    analysis: analysis ?? null
+  }, null, 2));
+  return filePath;
+}
+function buildCasesMarkdown(analysis) {
+  const lines = [];
+  for (const scenario of analysis.scenarios) {
+    lines.push(`# ${scenario.id} \u2014 ${scenario.title} ${scenario.tags.map(normalizeTag2).join(" ")}`.trim());
+    lines.push(`<!-- ct:url ${analysis.url} -->`);
+    lines.push(`<!-- ct:feature ${analysis.feature} -->`);
+    lines.push(`<!-- ct:generated-by capture -->`);
+    lines.push(`<!-- narrator: ${sanitizeComment(scenario.narrator)} -->`);
+    lines.push(`<!-- code-level: ${scenario.codeLevel} -->`);
+    lines.push("");
+    lines.push("## Steps");
+    scenario.steps.forEach((step, index) => {
+      const hint = step.selector && step.selector !== "page" ? ` <!-- selector: ${step.selector} -->` : "";
+      lines.push(`${index + 1}. ${step.human}${hint}`);
+    });
+    lines.push("");
+    lines.push("## Expected Results");
+    scenario.assertions.forEach((assertion) => {
+      const hint = assertion.playwright ? ` <!-- playwright: ${sanitizeComment(assertion.playwright)} -->` : "";
+      lines.push(`- ${assertion.human}${hint}`);
+    });
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function saveCasesMarkdown(analysis, outputDir = "cases", fileName) {
+  mkdirSync3(outputDir, { recursive: true });
+  const resolvedFileName = fileName ?? `${slugify(analysis.feature || analysis.url)}.md`;
+  const filePath = join3(outputDir, resolvedFileName);
+  writeFileSync3(filePath, buildCasesMarkdown(analysis));
+  return filePath;
+}
+function saveSpecPreview(analysis, outputDir = "tests/preview") {
+  if (analysis.scenarios.length === 0) return null;
+  mkdirSync3(outputDir, { recursive: true });
+  const fileName = `spec-preview-${slugify(analysis.url)}-${Date.now()}.spec.cjs`;
+  const filePath = join3(outputDir, fileName);
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * CementicTest Capture Preview");
+  lines.push(` * Generated from: ${analysis.url}`);
+  lines.push(` * Feature: ${analysis.feature}`);
+  lines.push(" */");
+  lines.push("");
+  lines.push(`const { test, expect } = require('@playwright/test');`);
+  lines.push("");
+  for (const scenario of analysis.scenarios) {
+    lines.push(`test(${JSON.stringify(`${scenario.id} \u2014 ${scenario.title}`)}, async ({ page }) => {`);
+    for (const step of scenario.steps) {
+      if (step.action === "navigate") {
+        lines.push(`  await page.goto(${JSON.stringify(step.value)});`);
+        continue;
+      }
+      if (step.selector === "page") continue;
+      const selector = `page.${step.selector}`;
+      if (step.action === "fill") lines.push(`  await ${selector}.fill(${JSON.stringify(step.value)});`);
+      if (step.action === "click") lines.push(`  await ${selector}.click();`);
+      if (step.action === "select") lines.push(`  await ${selector}.selectOption(${JSON.stringify(step.value)});`);
+      if (step.action === "check") lines.push(`  await ${selector}.check();`);
+      if (step.action === "keyboard") lines.push(`  await page.keyboard.press(${JSON.stringify(step.value)});`);
+      if (step.action === "hover") lines.push(`  await ${selector}.hover();`);
+    }
+    for (const assertion of scenario.assertions) {
+      lines.push(`  ${ensureStatement(assertion.playwright)}`);
+    }
+    lines.push("});");
+    lines.push("");
+  }
+  writeFileSync3(filePath, lines.join("\n"));
+  return filePath;
+}
+function slugify(value) {
+  return (value || "capture").replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase().slice(0, 60);
+}
+function normalizeTag2(value) {
+  const cleaned = String(value ?? "").trim();
+  if (!cleaned) return "@ui";
+  return cleaned.startsWith("@") ? cleaned : `@${cleaned}`;
+}
+function sanitizeComment(value) {
+  return String(value ?? "").replace(/-->/g, "-- >");
+}
+function ensureStatement(value) {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) return "// TODO: add assertion";
+  return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+}
 
 // src/commands/tc.ts
-function slugify(text) {
+function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tc";
 }
+function injectUrlMetadata(markdown, url) {
+  if (!url || /<!--\s*ct:url\s+/i.test(markdown)) return markdown;
+  const lines = markdown.split("\n");
+  const output2 = [];
+  for (let i = 0; i < lines.length; i++) {
+    output2.push(lines[i]);
+    if (/^\s*#\s+/.test(lines[i])) {
+      output2.push(`<!-- ct:url ${url} -->`);
+    }
+  }
+  return output2.join("\n");
+}
 function buildManualCasesMarkdown(opts) {
   const { prefix, feature, url, numCases } = opts;
   const startIndex = opts.startIndex ?? 1;
@@ -520,9 +1513,8 @@ function buildManualCasesMarkdown(opts) {
   for (let i = 0; i < numCases; i++) {
     const idx = startIndex + i;
     const id = `${prefix}-${String(idx).padStart(3, "0")}`;
-    const title = `${feature} - scenario ${idx}`;
-    const tags = "@regression @ui";
-    lines.push(`# ${id} \u2014 ${title} ${tags}`);
+    lines.push(`# ${id} \u2014 ${feature} - scenario ${idx} @regression @ui`);
+    if (url) lines.push(`<!-- ct:url ${url} -->`);
     lines.push(`## Steps`);
     lines.push(`1. Navigate to ${url ?? "<PAGE_URL>"}`);
     lines.push(`2. Perform the main user action for this scenario`);
@@ -538,12 +1530,10 @@ function buildManualCasesMarkdown(opts) {
 }
 async function promptBasicQuestions(opts) {
   if (opts.feature) {
-    let n = opts.numCases ?? 3;
-    if (n < 1) n = 3;
-    if (n > 10) n = 10;
+    const n = Math.min(Math.max(opts.numCases ?? 3, 1), 10);
     return {
       feature: opts.feature,
-      appDescription: opts.appDescription || "",
+      appDescription: opts.appDescription ?? "",
       numCases: n,
       url: opts.url
     };
@@ -551,16 +1541,13 @@ async function promptBasicQuestions(opts) {
   const rl = createInterface({ input, output });
   const feature = (await rl.question("\u{1F9E9} Feature or page to test: ")).trim();
   const appDescription = (await rl.question("\u{1F4DD} Short app description (optional): ")).trim();
-  const numCasesRaw = (await rl.question("\u{1F522} How many test cases? (1-10) [3]: ")).trim();
+  const numCasesRaw = (await rl.question("\u{1F522} How many test cases? (1\u201310) [3]: ")).trim();
   rl.close();
   let numCases = parseInt(numCasesRaw, 10);
   if (isNaN(numCases) || numCases < 1) numCases = 3;
   if (numCases > 10) numCases = 10;
   return { feature, appDescription, numCases, url: opts.url };
 }
-function hasAiFlagInArgv() {
-  return process.argv.includes("--ai");
-}
 async function runTcInteractive(params) {
   const { feature, appDescription, numCases, url } = await promptBasicQuestions({
     url: params.url,
@@ -573,87 +1560,130 @@ async function runTcInteractive(params) {
     url,
     explicitPrefix: params.explicitPrefix
   });
-  mkdirSync3("cases", { recursive: true });
-  const fileName = `${prefix.toLowerCase()}-${slugify(feature)}.md`;
-  const fullPath = join3("cases", fileName);
-  const useAi = hasAiFlagInArgv();
-  console.log(`\u2699\uFE0F Debug: useAi=${useAi}, argv=${JSON.stringify(process.argv)}`);
+  mkdirSync4("cases", { recursive: true });
+  const fileName = `${prefix.toLowerCase()}-${slugify2(feature)}.md`;
+  const fullPath = join4("cases", fileName);
   let markdown;
-  if (useAi) {
-    let pageSummaryJson = void 0;
+  if (params.useAi) {
+    let pageSummary = void 0;
     if (url) {
       try {
-        console.log(`\u{1F50D} Scraping page for AI context: ${url}`);
-        pageSummaryJson = await scrapePageSummary(url);
-        console.log(
-          `\u{1F50E} Scrape summary: title="${pageSummaryJson.title || ""}", headings=${pageSummaryJson.headings.length}, buttons=${pageSummaryJson.buttons.length}, inputs=${pageSummaryJson.inputs.length}`
-        );
+        console.log(`\u{1F50D} Capturing page: ${url}`);
+        const elementMap = await captureElements(url, {
+          headless: !(params.headed ?? false),
+          verbose: true
+        });
+        printCaptureReport(elementMap);
+        const jsonPath = saveCaptureJson(elementMap);
+        console.log(`\u{1F4C4} Saved capture JSON \u2192 ${jsonPath}`);
+        if (params.captureOnly) {
+          console.log("Capture-only mode requested. No test cases were generated.");
+          return;
+        }
+        const analysis = await analyseElements(elementMap, { verbose: true });
+        printCaptureReport(elementMap, analysis);
+        const previewPath = saveSpecPreview(analysis);
+        if (previewPath) {
+          console.log(`\u{1F9EA} Saved preview spec \u2192 ${previewPath}`);
+        }
+        const captureFileName = `${prefix.toLowerCase()}-${slugify2(feature)}.md`;
+        const generatedPath = saveCasesMarkdown(analysis, "cases", captureFileName);
+        console.log(`\u2705 Capture-based AI generated test cases \u2192 ${generatedPath}`);
+        console.log("\nNext steps:");
+        console.log(`  ct normalize ${generatedPath} --and-gen --lang ts`);
+        console.log("  ct test");
+        return;
       } catch (e) {
-        console.warn(
-          `\u26A0\uFE0F Failed to scrape ${url} (${e?.message || e}). Continuing without page summary.`
-        );
+        console.warn(`\u26A0\uFE0F  Capture flow failed (${e?.message ?? e}). Falling back to the legacy AI case writer.`);
+        if (params.captureOnly) {
+          return;
+        }
       }
     }
     try {
-      console.log("\u{1F916} AI: generating test cases...");
+      if (pageSummary === void 0 && url) {
+        const elementMap = await captureElements(url, {
+          headless: true,
+          verbose: false
+        });
+        pageSummary = toPageSummary(elementMap);
+      }
       markdown = await generateTcMarkdownWithAi({
         appDescription: appDescription || void 0,
         feature,
         url,
-        pageSummaryJson,
+        pageSummary,
         prefix,
         startIndex: 1,
         numCases
       });
-      console.log("\u2705 AI: generated test case markdown.");
+      markdown = injectUrlMetadata(markdown, url);
+      console.log("\u2705 AI generated test cases.");
     } catch (err) {
-      console.warn(
-        `\u26A0\uFE0F AI generation failed (${err?.message || err}). Falling back to manual templates.`
-      );
-      markdown = buildManualCasesMarkdown({
-        prefix,
-        feature,
-        url,
-        numCases,
-        startIndex: 1
-      });
-      console.log("\u{1F4DD} Manual: generated test case templates instead.");
+      console.warn(`\u26A0\uFE0F  AI generation failed (${err?.message ?? err}). Falling back to manual templates.`);
+      markdown = buildManualCasesMarkdown({ prefix, feature, url, numCases, startIndex: 1 });
+      console.log("\u{1F4DD} Generated manual test case templates instead.");
     }
   } else {
-    markdown = buildManualCasesMarkdown({
-      prefix,
-      feature,
-      url,
-      numCases,
-      startIndex: 1
-    });
-    console.log("\u{1F4DD} Manual: generated test case templates (no --ai).");
+    markdown = buildManualCasesMarkdown({ prefix, feature, url, numCases, startIndex: 1 });
+    console.log("\u{1F4DD} Generated manual test case templates (pass --ai to use AI).");
   }
-  writeFileSync3(fullPath, markdown);
-  console.log(`\u270D\uFE0F Wrote ${numCases} test case(s) \u2192 ${fullPath}`);
-  console.log("Next steps:");
+  writeFileSync4(fullPath, markdown);
+  console.log(`
+\u270D\uFE0F  Wrote ${numCases} case(s) \u2192 ${fullPath}`);
+  console.log("\nNext steps:");
   console.log("  ct normalize ./cases --and-gen --lang ts");
   console.log("  ct test");
 }
+function addSharedOptions(cmd) {
+  return cmd.option("--ai", "Use AI to generate test cases (requires API key)").option("--prefix <prefix>", "Explicit ID prefix, e.g. AUTH, DASH, CART").option("--feature <name>", "Feature name \u2014 skips interactive prompt").option("--desc <text>", "App description \u2014 skips interactive prompt").option("--count <n>", "Number of cases (1\u201310)", parseInt);
+}
+function resolveCommanderOpts(opts) {
+  if (typeof opts.optsWithGlobals === "function") {
+    return opts.optsWithGlobals();
+  }
+  if (typeof opts.opts === "function") {
+    return opts.opts();
+  }
+  return opts;
+}
 function tcCmd() {
-  const root = new Command4("tc").description("Create CT-style test cases (Markdown) under ./cases").option("--ai", "Use AI if configured (BYO LLM API key).", false).option("--prefix <prefix>", "Explicit ID prefix, e.g. AUTH, DASH, CART").option("--feature <name>", "Feature name (non-interactive)").option("--desc <text>", "App description (non-interactive)").option("--count <n>", "Number of cases (non-interactive)", parseInt).action(async (opts) => {
-    await runTcInteractive({
-      url: void 0,
-      explicitPrefix: opts.prefix,
-      feature: opts.feature,
-      appDescription: opts.desc,
-      numCases: opts.count
-    });
-  });
-  root.command("url").argument("<url>", "Page URL to use as context").option("--ai", "Use AI if configured (BYO LLM API key).", false).option("--prefix <prefix>", "Explicit ID prefix, e.g. AUTH, DASH, CART").option("--feature <name>", "Feature name (non-interactive)").option("--desc <text>", "App description (non-interactive)").option("--count <n>", "Number of cases (non-interactive)", parseInt).description("Create test cases with awareness of a specific page URL").action(async (url, opts) => {
-    await runTcInteractive({
-      url,
-      explicitPrefix: opts.prefix,
-      feature: opts.feature,
-      appDescription: opts.desc,
-      numCases: opts.count
-    });
-  });
+  const root = new Command4("tc").description("Create CementicTest case files (Markdown) under ./cases").addHelpText("after", `
+Examples:
+  $ ct tc --feature "Login form" --ai
+  $ ct tc --feature "Checkout" --count 5 --prefix CHK
+  $ ct tc url https://example.com/login --ai --feature "Auth"
+`);
+  addSharedOptions(root).action(
+    async (opts) => {
+      const resolvedOpts = resolveCommanderOpts(opts);
+      await runTcInteractive({
+        url: void 0,
+        explicitPrefix: resolvedOpts.prefix,
+        feature: resolvedOpts.feature,
+        appDescription: resolvedOpts.desc,
+        numCases: resolvedOpts.count,
+        useAi: resolvedOpts.ai ?? false
+      });
+    }
+  );
+  addSharedOptions(
+    root.command("url").argument("<url>", "Page URL to use as live capture and AI context").description("Generate test cases with capture-aware context from a specific live page").option("--headed", "Show the browser while capturing the page").option("--capture-only", "Run live page capture and save artifacts without generating cases")
+  ).action(
+    async (url, opts, command) => {
+      const resolvedOpts = resolveCommanderOpts(command ?? opts);
+      await runTcInteractive({
+        url,
+        explicitPrefix: resolvedOpts.prefix,
+        feature: resolvedOpts.feature,
+        appDescription: resolvedOpts.desc,
+        numCases: resolvedOpts.count,
+        useAi: resolvedOpts.ai ?? false,
+        headed: resolvedOpts.headed ?? false,
+        captureOnly: resolvedOpts.captureOnly ?? false
+      });
+    }
+  );
   return root;
 }
 
@@ -682,11 +1712,11 @@ function reportCmd() {
 import { Command as Command6 } from "commander";
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function serveCmd() {
   const cmd = new Command6("serve").description("Serve the Allure report").action(() => {
     console.log("\u{1F4CA} Serving Allure report...");
-    const localAllureBin = join4(process.cwd(), "node_modules", "allure-commandline", "bin", "allure");
+    const localAllureBin = join5(process.cwd(), "node_modules", "allure-commandline", "bin", "allure");
     let executable = "npx";
     let args = ["allure", "serve", "./allure-results"];
     if (existsSync2(localAllureBin)) {
@@ -754,8 +1784,8 @@ function flowCmd() {
 
 // src/commands/ci.ts
 import { Command as Command8 } from "commander";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
 var WORKFLOW_CONTENT = `name: Playwright Tests
 on:
   push:
@@ -786,19 +1816,19 @@ jobs:
 `;
 function ciCmd() {
   const cmd = new Command8("ci").description("Generate GitHub Actions workflow for CI").action(() => {
-    const githubDir = join5(process.cwd(), ".github");
-    const workflowsDir = join5(githubDir, "workflows");
-    const workflowFile = join5(workflowsDir, "cementic.yml");
+    const githubDir = join6(process.cwd(), ".github");
+    const workflowsDir = join6(githubDir, "workflows");
+    const workflowFile = join6(workflowsDir, "cementic.yml");
     console.log("\u{1F916} Setting up CI/CD workflow...");
     if (!existsSync3(workflowsDir)) {
-      mkdirSync4(workflowsDir, { recursive: true });
+      mkdirSync5(workflowsDir, { recursive: true });
       console.log(`Created directory: ${workflowsDir}`);
     }
     if (existsSync3(workflowFile)) {
       console.warn(`\u26A0\uFE0F  Workflow file already exists at ${workflowFile}. Skipping.`);
       return;
     }
-    writeFileSync4(workflowFile, WORKFLOW_CONTENT.trim() + "\n");
+    writeFileSync5(workflowFile, WORKFLOW_CONTENT.trim() + "\n");
     console.log(`\u2705 CI workflow generated at: ${workflowFile}`);
     console.log("Next steps:");
     console.log("1. Commit and push the new file");
@@ -808,8 +1838,10 @@ function ciCmd() {
 }
 
 // src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var program = new Command9();
-program.name("cementic-test").description("CementicTest CLI: cases \u2192 normalized \u2192 POM tests \u2192 Playwright").version("0.2.0");
+program.name("ct").description("CementicTest CLI: cases \u2192 normalized \u2192 POM tests \u2192 Playwright").version(version);
 program.addCommand(newCmd());
 program.addCommand(normalizeCmd());
 program.addCommand(genCmd());