@cementic/cementic-test 0.2.3

package/dist/cli.js

@@ -0,0 +1,823 @@
+#!/usr/bin/env node
+import {
+  genCmd
+} from "./chunk-J63TUHIV.js";
+
+// src/cli.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/new.ts
+import { Command } from "commander";
+import { mkdirSync, writeFileSync, existsSync, readFileSync, cpSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { platform, release } from "os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+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-tests --no-browsers
+`).option("--mode <mode>", "greenfield|enhance", "greenfield").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}...`);
+    if (existsSync(projectPath)) {
+      console.error(`\u274C Directory ${projectName} already exists.`);
+      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}`);
+      console.error("Please ensure the package is built correctly with templates included.");
+      process.exit(1);
+    }
+    console.log(`\u{1F4E6} Copying template from ${templatePath}...`);
+    function copyRecursive(src, dest) {
+      if (statSync(src).isDirectory()) {
+        mkdirSync(dest, { recursive: true });
+        readdirSync(src).forEach((child) => {
+          copyRecursive(join(src, child), join(dest, child));
+        });
+      } else {
+        cpSync(src, dest);
+      }
+    }
+    copyRecursive(templatePath, projectPath);
+    if (platform() === "darwin") {
+      const osRelease = release();
+      const majorVersion = parseInt(osRelease.split(".")[0], 10);
+      if (majorVersion < 23) {
+        console.log("\u{1F34E} Detected macOS 13 or older. Adjusting versions for compatibility...");
+        const pkgJsonPath = join(projectPath, "package.json");
+        if (existsSync(pkgJsonPath)) {
+          try {
+            const pkgContent = readFileSync(pkgJsonPath, "utf-8");
+            const pkg = JSON.parse(pkgContent);
+            if (pkg.devDependencies) {
+              pkg.devDependencies["@playwright/test"] = "^1.48.2";
+              pkg.devDependencies["allure-playwright"] = "^2.15.1";
+              writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+              console.log("\u2705 Downgraded @playwright/test and allure-playwright for legacy macOS support.");
+            }
+          } catch (err) {
+            console.warn("\u26A0\uFE0F Failed to adjust package.json for OS compatibility:", err);
+          }
+        }
+      }
+    }
+    try {
+      execSync("git init", { cwd: projectPath, stdio: "ignore" });
+      const gitignorePath = join(projectPath, ".gitignore");
+      if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, "node_modules\n.env\ntest-results\nplaywright-report\n.cementic\n");
+      }
+    } catch (e) {
+      console.warn("\u26A0\uFE0F Failed to initialize git repository.");
+    }
+    console.log("\u{1F4E6} Installing dependencies...");
+    try {
+      execSync("npm install", { cwd: projectPath, stdio: "inherit" });
+    } catch (e) {
+      console.error('\u274C Failed to install dependencies. Please run "npm install" manually.');
+    }
+    if (opts.browsers !== false) {
+      console.log("\u{1F310} Installing Playwright browsers...");
+      try {
+        execSync("npx playwright install", { cwd: projectPath, stdio: "inherit" });
+      } catch (e) {
+        console.warn('\u26A0\uFE0F Failed to install browsers. Run "npx playwright install" manually.');
+      }
+    }
+    console.log(`
+\u2705 Project ${projectName} created successfully!`);
+    console.log(`
+To get started:
+`);
+    console.log(`  cd ${projectName}`);
+    console.log(`  npx playwright test`);
+    console.log(`
+Happy testing! \u{1F9EA}`);
+  });
+  return cmd;
+}
+
+// src/commands/normalize.ts
+import { Command as Command2 } from "commander";
+import fg from "fast-glob";
+import { readFileSync as readFileSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, statSync as statSync2 } from "fs";
+import { join as join2, basename, resolve as resolve2 } from "path";
+function parseTags(title) {
+  const tags = Array.from(title.matchAll(/@([\w-]+)/g)).map((m) => m[1]);
+  const clean = title.replace(/@[\w-]+/g, "").trim();
+  return { clean, tags };
+}
+function parseId(title) {
+  const m = title.match(/\b([A-Z]+-\d+)\b/);
+  return m?.[1];
+}
+function splitCasesByHeading(fileText) {
+  const lines = fileText.split(/\r?\n/);
+  const blocks = [];
+  let currentTitle = null;
+  let buf = [];
+  const flush = () => {
+    if (currentTitle !== null) {
+      blocks.push({ titleLine: currentTitle, body: buf.join("\n") });
+    }
+    buf = [];
+  };
+  for (const line of lines) {
+    const h1 = line.match(/^\s*#\s+(.+)$/);
+    if (h1) {
+      if (currentTitle !== null) flush();
+      currentTitle = h1[1].trim();
+    } else {
+      buf.push(line);
+    }
+  }
+  if (currentTitle !== null) flush();
+  if (blocks.length === 0) {
+    const first = lines.find((l) => l.trim());
+    const title = first?.replace(/^#\s*/, "").trim() || "Untitled";
+    return [{ titleLine: title, body: lines.join("\n") }];
+  }
+  return blocks;
+}
+function extractSections(body) {
+  const sectionRegex = /^\s*##\s*(.+?)\s*$/gim;
+  const sections = {};
+  let match;
+  const indices = [];
+  while (match = sectionRegex.exec(body)) {
+    indices.push({ name: match[1].toLowerCase(), index: match.index });
+  }
+  indices.push({ name: "__END__", index: body.length });
+  for (let i = 0; i < indices.length - 1; i++) {
+    const name = indices[i].name;
+    const slice = body.slice(indices[i].index, indices[i + 1].index);
+    sections[name] = slice;
+  }
+  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()) || [];
+  if (steps.length === 0) {
+    const alt = Array.from(body.matchAll(bullet)).map((m) => m[1].trim());
+    steps.push(...alt);
+  }
+  const expectedLines = Array.from(expectedBlock.matchAll(bullet)).map(
+    (m) => m[1].trim()
+  );
+  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);
+  }
+  return { steps, expected: expectedLines };
+}
+function normalizeOne(titleLine, body, source) {
+  const { clean, tags } = parseTags(titleLine);
+  const id = parseId(clean);
+  const { steps, expected } = extractSections(body);
+  return {
+    id,
+    title: clean,
+    tags: tags.length ? tags : void 0,
+    steps,
+    expected,
+    needs_review: steps.length === 0 || expected.length === 0,
+    source
+  };
+}
+function normalizeCmd() {
+  const cmd = new Command2("normalize").argument("<path>", "Input directory or file pattern containing test cases (Markdown, Text, CSV)").description("Convert human-readable test cases into machine-readable JSON format").addHelpText("after", `
+Examples:
+  $ ct normalize ./cases
+  $ ct normalize "cases/**/*.md"
+  $ ct normalize ./cases --and-gen --lang ts  (Normalize and generate tests in one go)
+`).option("--report", "Generate a summary report of the normalization process", true).option("--and-gen", "Automatically run test generation after normalization", false).option("--lang <lang>", "Target language for generation (ts|js) when using --and-gen", "ts").action(async (inputPath, opts) => {
+    let patterns = [];
+    try {
+      const abs = resolve2(inputPath);
+      if (statSync2(abs).isDirectory()) {
+        const base = inputPath.replace(/\/$/, "");
+        patterns = [`${base}/**/*.{md,markdown,txt,feature,csv,json}`];
+      } else {
+        patterns = [inputPath];
+      }
+    } catch {
+      patterns = [inputPath];
+    }
+    const files = await fg(patterns, { dot: false, onlyFiles: true });
+    if (files.length === 0) {
+      console.error(`No files found for: ${inputPath}`);
+      process.exit(2);
+    }
+    const outDir = ".cementic/normalized";
+    mkdirSync2(outDir, { recursive: true });
+    const index = {
+      summary: { total: 0, parsed: 0, withWarnings: 0 },
+      cases: []
+    };
+    for (const f of files) {
+      const content = readFileSync2(f, "utf8");
+      const blocks = splitCasesByHeading(content);
+      for (const block of blocks) {
+        const norm = normalizeOne(block.titleLine, block.body, f);
+        const stem = basename(f).replace(/\.[^/.]+$/, "");
+        const suffix = (norm.id || norm.title).replace(/[^\w-]+/g, "-");
+        const outFile = join2(outDir, `${stem}.${suffix}.json`);
+        writeFileSync2(outFile, JSON.stringify(norm, null, 2));
+        index.summary.total++;
+        index.summary.parsed++;
+        if (norm.needs_review) index.summary.withWarnings++;
+        index.cases.push({ file: f, normalized: outFile, status: norm.needs_review ? "warning" : "ok" });
+      }
+    }
+    writeFileSync2(join2(outDir, "_index.json"), JSON.stringify(index, null, 2));
+    if (opts.report !== false) {
+      const lines = [
+        "# Normalize Report",
+        "",
+        `Total cases: ${index.summary.total} | Parsed: ${index.summary.parsed} | With warnings: ${index.summary.withWarnings}`,
+        "",
+        "| Source File | Normalized JSON | Status |",
+        "|-------------|-----------------|--------|",
+        ...index.cases.map((c) => `| ${c.file} | ${c.normalized} | ${c.status} |`)
+      ];
+      mkdirSync2(".cementic/reports", { recursive: true });
+      writeFileSync2(".cementic/reports/normalize-report.md", lines.join("\n"));
+    }
+    console.log(`\u2705 Normalized ${index.summary.parsed} case(s). Output \u2192 .cementic/normalized/`);
+    if (opts.andGen) {
+      const { gen } = await import("./gen-54KYT3RO.js");
+      await gen({ lang: opts.lang || "ts", out: "tests/generated" });
+    }
+  });
+  return cmd;
+}
+
+// src/commands/test.ts
+import { Command as Command3 } from "commander";
+import { spawn } from "child_process";
+function testCmd() {
+  const cmd = new Command3("test").description('Run Playwright tests via "npx playwright test"').allowUnknownOption(true).allowExcessArguments(true).argument("[...pwArgs]", "Arguments to pass through to Playwright").action((pwArgs = []) => {
+    const child = spawn(
+      "npx",
+      ["playwright", "test", ...pwArgs],
+      {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+        // needed for Windows
+      }
+    );
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return cmd;
+}
+
+// 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 { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/core/prefix.ts
+var PREFIX_MAP = [
+  { keywords: ["login", "sign in", "signin", "auth", "authentication"], prefix: "AUTH" },
+  { keywords: ["dashboard", "home"], prefix: "DASH" },
+  { keywords: ["profile", "account"], prefix: "PROF" },
+  { keywords: ["cart", "basket"], prefix: "CART" },
+  { keywords: ["checkout", "payment", "pay"], prefix: "CHK" },
+  { keywords: ["order", "orders"], prefix: "ORD" },
+  { keywords: ["settings", "preferences", "config"], prefix: "SET" }
+];
+function normalizeText(text) {
+  return text.toLowerCase().trim();
+}
+function deriveFromFreeText(text) {
+  const norm = normalizeText(text);
+  for (const entry of PREFIX_MAP) {
+    if (entry.keywords.some((k) => norm.includes(k))) {
+      return entry.prefix;
+    }
+  }
+  const firstWord = norm.split(/\s+/).find((w) => /[a-z0-9]/.test(w));
+  if (!firstWord) return void 0;
+  return firstWord.replace(/[^a-z0-9]/gi, "").slice(0, 4).toUpperCase() || void 0;
+}
+function deriveFromUrl(url) {
+  try {
+    const u = new URL(url);
+    const segments = u.pathname.split("/").filter(Boolean);
+    const last = segments[segments.length - 1] || "";
+    if (!last) return void 0;
+    return deriveFromFreeText(last);
+  } catch {
+    return void 0;
+  }
+}
+function inferPrefix(params) {
+  if (params.explicitPrefix) {
+    return params.explicitPrefix.trim().toUpperCase();
+  }
+  if (params.featureText) {
+    const fromFeature = deriveFromFreeText(params.featureText);
+    if (fromFeature) return fromFeature;
+  }
+  if (params.url) {
+    const fromUrl = deriveFromUrl(params.url);
+    if (fromUrl) return fromUrl;
+  }
+  return "TC";
+}
+
+// src/core/llm.ts
+function buildSystemMessage() {
+  return `
+You are a senior QA engineer and test case designer.
+
+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.
+
+You MUST follow this format exactly for each test case:
+
+# <ID> \u2014 <Short title> @<tag1> @<tag2> ...
+## Steps
+1. <step>
+2. <step>
+
+## Expected Results
+- <assertion>
+- <assertion>
+
+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.
+`.trim();
+}
+function buildUserMessage(ctx) {
+  const lines = [];
+  lines.push(`App / Product description (optional):`);
+  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("");
+  }
+  if (ctx.pageSummaryJson) {
+    lines.push(`Page structure summary (JSON):`);
+    lines.push("```json");
+    lines.push(JSON.stringify(ctx.pageSummaryJson, null, 2));
+    lines.push("```");
+    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("");
+  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.`);
+  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."
+    );
+  }
+  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);
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      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}`
+    );
+  }
+  const json = await response.json();
+  const content = json.choices?.[0]?.message?.content?.trim() || "";
+  if (!content) {
+    throw new Error("LLM response had no content");
+  }
+  return content;
+}
+
+// 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);
+    }
+  }
+  return {
+    url,
+    title,
+    headings: headings.slice(0, 20),
+    buttons: buttons.slice(0, 30),
+    links,
+    inputs: inputs.slice(0, 30),
+    rawLength
+  };
+}
+
+// src/commands/tc.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tc";
+}
+function buildManualCasesMarkdown(opts) {
+  const { prefix, feature, url, numCases } = opts;
+  const startIndex = opts.startIndex ?? 1;
+  const lines = [];
+  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(`## Steps`);
+    lines.push(`1. Navigate to ${url ?? "<PAGE_URL>"}`);
+    lines.push(`2. Perform the main user action for this scenario`);
+    lines.push(`3. Observe the result`);
+    lines.push("");
+    lines.push(`## Expected Results`);
+    lines.push(`- The page responds correctly for this scenario`);
+    lines.push(`- UI reflects the expected change`);
+    lines.push("");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function promptBasicQuestions(opts) {
+  if (opts.feature) {
+    let n = opts.numCases ?? 3;
+    if (n < 1) n = 3;
+    if (n > 10) n = 10;
+    return {
+      feature: opts.feature,
+      appDescription: opts.appDescription || "",
+      numCases: n,
+      url: opts.url
+    };
+  }
+  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();
+  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,
+    feature: params.feature,
+    appDescription: params.appDescription,
+    numCases: params.numCases
+  });
+  const prefix = inferPrefix({
+    featureText: feature,
+    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)}`);
+  let markdown;
+  if (useAi) {
+    let pageSummaryJson = 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}`
+        );
+      } catch (e) {
+        console.warn(
+          `\u26A0\uFE0F Failed to scrape ${url} (${e?.message || e}). Continuing without page summary.`
+        );
+      }
+    }
+    try {
+      console.log("\u{1F916} AI: generating test cases...");
+      markdown = await generateTcMarkdownWithAi({
+        appDescription: appDescription || void 0,
+        feature,
+        url,
+        pageSummaryJson,
+        prefix,
+        startIndex: 1,
+        numCases
+      });
+      console.log("\u2705 AI: generated test case markdown.");
+    } 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.");
+    }
+  } else {
+    markdown = buildManualCasesMarkdown({
+      prefix,
+      feature,
+      url,
+      numCases,
+      startIndex: 1
+    });
+    console.log("\u{1F4DD} Manual: generated test case templates (no --ai).");
+  }
+  writeFileSync3(fullPath, markdown);
+  console.log(`\u270D\uFE0F Wrote ${numCases} test case(s) \u2192 ${fullPath}`);
+  console.log("Next steps:");
+  console.log("  ct normalize ./cases --and-gen --lang ts");
+  console.log("  ct test");
+}
+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
+    });
+  });
+  return root;
+}
+
+// src/commands/report.ts
+import { Command as Command5 } from "commander";
+import { spawn as spawn2 } from "child_process";
+function reportCmd() {
+  const cmd = new Command5("report").description("Open the Playwright HTML report").action(() => {
+    console.log("\u{1F4CA} Opening Playwright HTML report...");
+    const child = spawn2(
+      "npx",
+      ["playwright", "show-report"],
+      {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      }
+    );
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return cmd;
+}
+
+// src/commands/serve.ts
+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";
+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");
+    let executable = "npx";
+    let args = ["allure", "serve", "./allure-results"];
+    if (existsSync2(localAllureBin)) {
+      executable = "node";
+      args = [localAllureBin, "serve", "./allure-results"];
+    }
+    console.log(`> ${executable} ${args.join(" ")}`);
+    const child = spawn3(
+      executable,
+      args,
+      {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      }
+    );
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return cmd;
+}
+
+// src/commands/flow.ts
+import { Command as Command7 } from "commander";
+import { spawn as spawn4 } from "child_process";
+import { resolve as resolve3 } from "path";
+function runStep(cmd, args, stepName) {
+  return new Promise((resolve4, reject) => {
+    console.log(`
+\u{1F30A} Flow Step: ${stepName}`);
+    console.log(`> ${cmd} ${args.join(" ")}`);
+    const child = spawn4(cmd, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve4();
+      } else {
+        reject(new Error(`${stepName} failed with exit code ${code}`));
+      }
+    });
+  });
+}
+function flowCmd() {
+  const cmd = new Command7("flow").description("End-to-end flow: Normalize -> Generate -> Run Tests").argument("[casesDir]", "Directory containing test cases", "./cases").option("--lang <lang>", "Target language (ts|js)", "ts").option("--no-run", "Skip running tests").action(async (casesDir, opts) => {
+    const cliBin = resolve3(process.argv[1]);
+    try {
+      await runStep(process.execPath, [cliBin, "normalize", casesDir], "Normalize Cases");
+      await runStep(process.execPath, [cliBin, "gen", "--lang", opts.lang], "Generate Tests");
+      if (opts.run) {
+        await runStep(process.execPath, [cliBin, "test"], "Run Playwright Tests");
+      } else {
+        console.log("\n\u23ED\uFE0F  Skipping test execution (--no-run)");
+      }
+      console.log("\n\u2705 Flow completed successfully!");
+    } catch (err) {
+      console.error(`
+\u274C Flow failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// 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";
+var WORKFLOW_CONTENT = `name: Playwright Tests
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+jobs:
+  test:
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+    - name: Install dependencies
+      run: npm ci
+    - name: Install Playwright Browsers
+      run: npx playwright install --with-deps
+    - name: Run Playwright tests
+      run: npx playwright test
+    - uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: playwright-report
+        path: playwright-report/
+        retention-days: 30
+`;
+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");
+    console.log("\u{1F916} Setting up CI/CD workflow...");
+    if (!existsSync3(workflowsDir)) {
+      mkdirSync4(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");
+    console.log(`\u2705 CI workflow generated at: ${workflowFile}`);
+    console.log("Next steps:");
+    console.log("1. Commit and push the new file");
+    console.log('2. Check the "Actions" tab in your GitHub repository');
+  });
+  return cmd;
+}
+
+// src/cli.ts
+var program = new Command9();
+program.name("cementic-test").description("CementicTest CLI: cases \u2192 normalized \u2192 POM tests \u2192 Playwright").version("0.2.0");
+program.addCommand(newCmd());
+program.addCommand(normalizeCmd());
+program.addCommand(genCmd());
+program.addCommand(testCmd());
+program.addCommand(tcCmd());
+program.addCommand(reportCmd());
+program.addCommand(serveCmd());
+program.addCommand(flowCmd());
+program.addCommand(ciCmd());
+program.parseAsync(process.argv);
+//# sourceMappingURL=cli.js.map