@cementic/cementic-test 0.2.4 → 0.2.6

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   genCmd
-} from "./chunk-3EE7LWWT.js";
+} from "./chunk-5QRDTCSM.js";
 
 // src/cli.ts
 import { Command as Command9 } from "commander";
@@ -182,21 +182,25 @@ 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);
@@ -205,6 +209,14 @@ function extractUrlMetadata(body) {
 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);
@@ -217,7 +229,7 @@ function normalizeOne(titleLine, body, source) {
   const id = parseId(clean);
   const metadataUrl = extractUrlMetadata(body);
   const cleanBody = stripCtMetadata(body);
-  const { steps, expected } = extractSections(cleanBody);
+  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");
@@ -226,7 +238,9 @@ function normalizeOne(titleLine, body, source) {
     title: stripIdPrefixFromTitle(clean, id),
     tags: tags.length ? tags : void 0,
     steps,
+    step_hints: stepHints.some((hint) => hint.selector) ? stepHints : void 0,
     expected,
+    assertion_hints: assertionHints.some((hint) => hint.playwright) ? assertionHints : void 0,
     needs_review: reviewReasons.length > 0,
     review_reasons: reviewReasons,
     source,
@@ -294,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-IO4KKGYY.js");
+      const { gen } = await import("./gen-RMRQOAD3.js");
       await gen({ lang: opts.lang || "ts", out: "tests/generated" });
     }
   });
@@ -324,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";
 
@@ -547,124 +561,937 @@ async function generateTcMarkdownWithAi(ctx) {
   return callOpenAi(apiKey, model, baseUrl, system, user);
 }
 
-// src/core/scrape.ts
-async function scrapePageSummary(url) {
-  try {
-    return await scrapeWithPlaywright(url);
-  } catch (pwErr) {
-    console.warn(`\u26A0\uFE0F  Playwright scrape failed (${pwErr?.message ?? pwErr}). Falling back to static fetch.`);
-    return scrapeWithFetch(url);
+// 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"
+  );
 }
-async function scrapeWithPlaywright(url) {
-  let chromium;
-  try {
-    ({ chromium } = await import("playwright-core"));
-  } catch {
-    ({ chromium } = await import("@playwright/test"));
+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("");
   }
-  const browser = await chromium.launch({ headless: true });
-  const context = await browser.newContext({
-    userAgent: "Mozilla/5.0 (compatible; CementicTest-scraper/1.0)"
+  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 }]
+    })
   });
-  const page = await context.newPage();
+  if (!response.ok) {
+    throw new Error(`Anthropic API ${response.status}: ${await response.text()}`);
+  }
+  const json = await response.json();
+  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 {
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 2e4 });
-    await page.waitForTimeout(800);
-    const summary = await page.evaluate(() => {
-      const text = (el) => el?.textContent?.replace(/\s+/g, " ").trim() ?? "";
-      const attr = (el, a) => el?.getAttribute(a)?.trim() ?? "";
-      const title = document.title?.trim() || void 0;
-      const headings = Array.from(document.querySelectorAll("h1, h2")).map((h) => text(h)).filter(Boolean).slice(0, 20);
-      const buttons = Array.from(
-        document.querySelectorAll('button, [role="button"]')
-      ).map((b) => attr(b, "aria-label") || text(b)).filter(Boolean).slice(0, 30);
-      const links = Array.from(document.querySelectorAll("a[href]")).map((a) => attr(a, "aria-label") || text(a)).filter(Boolean).slice(0, 50);
-      const inputs = [];
-      document.querySelectorAll("input, textarea, select").forEach((el) => {
-        const id = attr(el, "id");
-        const name = attr(el, "name") || void 0;
-        const ph = attr(el, "placeholder") || void 0;
-        const type = attr(el, "type") || void 0;
-        const testId = attr(el, "data-testid") || void 0;
-        let labelText;
-        if (id) {
-          const labelEl = document.querySelector(`label[for="${id}"]`);
-          if (labelEl) labelText = text(labelEl) || void 0;
+    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"
         }
-        if (!labelText) {
-          const closest = el.closest("label");
-          if (closest) labelText = text(closest).replace(ph ?? "", "").trim() || void 0;
+      ],
+      assertions: [
+        {
+          type: "visible",
+          selector: heading.selector,
+          expected: "visible",
+          human: `${heading.name || "Primary heading"} is visible`,
+          playwright: `await expect(page.${heading.selector}).toBeVisible();`
         }
-        if (labelText || ph || name || testId) {
-          inputs.push({ label: labelText, placeholder: ph, name, type, testId });
+      ],
+      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"
         }
-      });
-      const landmarks = Array.from(
-        document.querySelectorAll('[role="navigation"], [role="main"], [role="form"], nav, main, form')
-      ).map((el) => attr(el, "aria-label") || el.tagName.toLowerCase()).filter(Boolean);
-      const rawLength = document.documentElement.outerHTML.length;
-      return {
-        title,
-        headings,
-        buttons,
-        links,
-        inputs: inputs.slice(0, 30),
-        landmarks,
-        rawLength
-      };
+      ],
+      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 { url, ...summary };
+  }
+  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/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();
   }
 }
-async function scrapeWithFetch(url) {
-  const res = await fetch(url, {
-    headers: { "User-Agent": "CementicTest-scraper/1.0" }
-  });
-  if (!res.ok) {
-    throw new Error(`HTTP ${res.status} ${res.statusText} \u2014 ${url}`);
-  }
-  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).slice(0, 20);
-  const buttons = Array.from(html.matchAll(/<button[^>]*>([^<]*)<\/button>/gi)).map((m) => m[1].replace(/\s+/g, " ").trim()).filter(Boolean).slice(0, 30);
-  const links = Array.from(html.matchAll(/<a[^>]*>([^<]*)<\/a>/gi)).map((m) => m[1].replace(/\s+/g, " ").trim()).filter(Boolean).slice(0, 50);
-  const labelMap = /* @__PURE__ */ new Map();
-  for (const m of html.matchAll(/<label[^>]*for=["']?([^"'>\s]+)["']?[^>]*>([^<]*)<\/label>/gi)) {
-    const id = m[1], text = m[2].replace(/\s+/g, " ").trim();
-    if (id && text) labelMap.set(id, text);
+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: 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 = [];
-  for (const m of html.matchAll(/<input([^>]*)>/gi)) {
-    const attrs = m[1];
-    const name = attrs.match(/\bname=["']?([^"'>\s]+)["']?/i)?.[1];
-    const id = attrs.match(/\bid=["']?([^"'>\s]+)["']?/i)?.[1];
-    const ph = attrs.match(/\bplaceholder=["']([^"']*)["']/i)?.[1]?.trim();
-    const type = attrs.match(/\btype=["']?([^"'>\s]+)["']?/i)?.[1];
-    const testId = attrs.match(/\bdata-testid=["']([^"']*)["']/i)?.[1]?.trim();
-    const label = id ? labelMap.get(id) : void 0;
-    if (label || ph || name || testId) {
-      inputs.push({ label, placeholder: ph, name, type, testId });
+  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 {
-    url,
-    title,
-    headings,
-    buttons,
-    links,
-    inputs: inputs.slice(0, 30),
-    landmarks: [],
-    rawLength
+    buttons: buttons.slice(0, localMaxPerCategory),
+    inputs: inputs.slice(0, localMaxPerCategory),
+    links: links.slice(0, localMaxPerCategory),
+    headings: headings.slice(0, 20),
+    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) {
@@ -733,24 +1560,54 @@ async function runTcInteractive(params) {
     url,
     explicitPrefix: params.explicitPrefix
   });
-  mkdirSync3("cases", { recursive: true });
-  const fileName = `${prefix.toLowerCase()}-${slugify(feature)}.md`;
-  const fullPath = join3("cases", fileName);
+  mkdirSync4("cases", { recursive: true });
+  const fileName = `${prefix.toLowerCase()}-${slugify2(feature)}.md`;
+  const fullPath = join4("cases", fileName);
   let markdown;
   if (params.useAi) {
     let pageSummary = void 0;
     if (url) {
       try {
-        console.log(`\u{1F50D} Scraping page: ${url}`);
-        pageSummary = await scrapePageSummary(url);
-        console.log(
-          `   Found: ${pageSummary.headings.length} heading(s), ${pageSummary.inputs.length} input(s), ${pageSummary.buttons.length} button(s)`
-        );
+        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  Scrape failed (${e?.message ?? e}). Continuing without page context.`);
+        console.warn(`\u26A0\uFE0F  Capture flow failed (${e?.message ?? e}). Falling back to the legacy AI case writer.`);
+        if (params.captureOnly) {
+          return;
+        }
       }
     }
     try {
+      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,
@@ -771,7 +1628,7 @@ async function runTcInteractive(params) {
     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);
+  writeFileSync4(fullPath, markdown);
   console.log(`
 \u270D\uFE0F  Wrote ${numCases} case(s) \u2192 ${fullPath}`);
   console.log("\nNext steps:");
@@ -811,7 +1668,7 @@ Examples:
     }
   );
   addSharedOptions(
-    root.command("url").argument("<url>", "Page URL to use as scraping and AI context").description("Generate test cases with awareness of a specific live page")
+    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);
@@ -821,7 +1678,9 @@ Examples:
         feature: resolvedOpts.feature,
         appDescription: resolvedOpts.desc,
         numCases: resolvedOpts.count,
-        useAi: resolvedOpts.ai ?? false
+        useAi: resolvedOpts.ai ?? false,
+        headed: resolvedOpts.headed ?? false,
+        captureOnly: resolvedOpts.captureOnly ?? false
       });
     }
   );
@@ -853,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)) {
@@ -925,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:
@@ -957,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");