@selfcure/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1562 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk6 from "chalk";
+import ora6 from "ora";
+import path8 from "path";
+import fs6 from "fs/promises";
+import { pathToFileURL as pathToFileURL5 } from "url";
+import { execSync as execSync3 } from "child_process";
+
+// src/init.ts
+import { input, select, password, confirm } from "@inquirer/prompts";
+import { writeFile, stat } from "fs/promises";
+import path from "path";
+import { PROVIDERS } from "@selfcure/generator";
+import { discoverProject } from "@selfcure/crawler";
+var PROVIDER_CHOICES = Object.values(PROVIDERS).map((p) => ({
+  name: p.envVar && process.env[p.envVar] ? `${p.label}  \u2713 (${p.envVar} detected)` : `${p.label}  \u2014 ${p.hint}`,
+  value: p.id
+}));
+async function detectSourceDir(cwd, projectRoot) {
+  const abs = path.resolve(cwd, projectRoot);
+  for (const candidate of ["src", "app", "pages", "components"]) {
+    try {
+      const s = await stat(path.join(abs, candidate));
+      if (s.isDirectory()) return `./${candidate}`;
+    } catch {
+    }
+  }
+  return projectRoot === "." ? "./src" : projectRoot;
+}
+async function detectExtensions(cwd) {
+  try {
+    const raw = await import("fs/promises").then((m) => m.readFile(path.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(raw);
+    const deps = { ...pkg["dependencies"] ?? {}, ...pkg["devDependencies"] ?? {} };
+    if ("@angular/core" in deps) return ["**/*.html", "**/*.ts"];
+    if ("vue" in deps) return ["**/*.vue"];
+    if ("nuxt" in deps) return ["**/*.vue"];
+    if ("svelte" in deps) return ["**/*.svelte"];
+    if ("react" in deps && "typescript" in deps) return ["**/*.tsx", "**/*.ts"];
+    if ("react" in deps) return ["**/*.jsx", "**/*.js"];
+    if ("next" in deps) return ["**/*.tsx", "**/*.ts"];
+  } catch {
+  }
+  return ["**/*.tsx", "**/*.jsx"];
+}
+function buildConfigContent(projectRoot, sourceDir, extensions, baseUrl, provider, model) {
+  const pr = JSON.stringify(projectRoot);
+  const sd = JSON.stringify(sourceDir);
+  const bu = JSON.stringify(baseUrl);
+  const pv = JSON.stringify(provider);
+  const mo = JSON.stringify(model);
+  const inc = JSON.stringify(extensions);
+  return [
+    "// selfcure.config.mjs",
+    "// See: https://github.com/ricardofrancocustodio/selfcure",
+    "export default {",
+    `  projectRoot: ${pr},`,
+    `  baseUrl: ${bu},`,
+    "",
+    "  // Required by selfcure lint, selfcure web, selfcure crawl",
+    `  rootDir: ${sd},`,
+    `  include: ${inc},`,
+    `  exclude: ["**/*.test.*", "**/*.spec.*", "**/*.stories.*"],`,
+    `  baseURL: ${bu},`,
+    "",
+    "  ai: {",
+    `    provider: ${pv},`,
+    `    model: ${mo},`,
+    "  },",
+    "",
+    "  discovery: {",
+    '    mode: "agentic",',
+    "    static: true,",
+    "    runtime: false,",
+    "    maxRoutes: 50,",
+    "    maxDepth: 3,",
+    "    includeHiddenStates: true,",
+    "    routeHints: [],",
+    '    ignore: ["node_modules", "dist", "coverage", ".git"],',
+    "  },",
+    "",
+    "  testability: {",
+    "    preferRoleLocators: true,",
+    "    suggestTestIds: true,",
+    "    minimumScore: 80,",
+    "  },",
+    "};",
+    ""
+  ].join("\n");
+}
+async function runInitWizard(cwd) {
+  console.log("");
+  console.log("selfcure init \u2014 agentic discovery setup");
+  console.log("");
+  const projectRoot = await input({
+    message: "Project root (relative to cwd)?",
+    default: "."
+  });
+  const baseUrl = await input({
+    message: "App base URL (dev server)?",
+    default: "http://localhost:3000"
+  });
+  const suggestedProvider = Object.values(PROVIDERS).find((p) => p.envVar && process.env[p.envVar])?.id ?? "anthropic";
+  const provider = await select({
+    message: "AI provider?",
+    choices: PROVIDER_CHOICES,
+    default: suggestedProvider
+  });
+  const meta = PROVIDERS[provider];
+  const model = await input({
+    message: "Model?",
+    default: meta.defaultGenerationModel
+  });
+  if (meta.envVar && !process.env[meta.envVar]) {
+    const apiKey = await password({
+      message: `${meta.label} API key (${meta.envVar})?`,
+      mask: "*"
+    });
+    if (apiKey) {
+      const envPath = path.join(cwd, ".env");
+      const line = `
+${meta.envVar}=${apiKey}
+`;
+      const { appendFile } = await import("fs/promises");
+      await appendFile(envPath, line, "utf-8");
+      console.log(`  \u2714 appended to ${path.relative(cwd, envPath)}`);
+    }
+  }
+  const runNow = await confirm({
+    message: "Run static project discovery now?",
+    default: true
+  });
+  const sourceDir = await detectSourceDir(cwd, projectRoot);
+  const extensions = await detectExtensions(cwd);
+  const configPath = path.join(cwd, "selfcure.config.mjs");
+  const configContent = buildConfigContent(projectRoot, sourceDir, extensions, baseUrl, provider, model);
+  await writeFile(configPath, configContent, "utf-8");
+  console.log(`
+\u2714  selfcure.config.mjs created`);
+  console.log(`   rootDir: ${sourceDir}   include: ${extensions.join(", ")}`);
+  if (runNow) {
+    console.log("");
+    const { default: ora7 } = await import("ora");
+    const spinner = ora7("Discovering project structure\u2026").start();
+    try {
+      const root = path.resolve(cwd, projectRoot);
+      const map = await discoverProject({ projectRoot: root });
+      const outDir = path.join(cwd, ".selfcure");
+      const { mkdir, writeFile: wf } = await import("fs/promises");
+      await mkdir(outDir, { recursive: true });
+      await wf(path.join(outDir, "project-map.json"), JSON.stringify(map, null, 2), "utf-8");
+      spinner.succeed(`Discovered ${map.routeCandidates.length} route candidate(s) \xB7 ${map.componentCandidates.length} component(s)`);
+      console.log(`  Framework: ${map.framework}   Package manager: ${map.packageManager}`);
+      if (map.devCommand) console.log(`  Dev:       ${map.devCommand}`);
+      console.log(`  Artifacts: .selfcure/project-map.json`);
+    } catch (err) {
+      spinner.warn(`Discovery skipped: ${String(err)}`);
+    }
+  }
+  console.log("\nNext steps:");
+  console.log("  selfcure discover          \u2014 (re)run static discovery");
+  console.log("  selfcure lint              \u2014 testability lint");
+  console.log("  selfcure a11y scan         \u2014 WCAG accessibility scan");
+  console.log("");
+}
+
+// src/lint.ts
+import { crawl, extractA11yEvidenceFromAll } from "@selfcure/crawler";
+import { analyze, runStaticAnalysis } from "@selfcure/analyzer";
+import { readFile, writeFile as writeFile2, mkdtemp, rm } from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { execSync as execSync2 } from "child_process";
+
+// src/git-providers.ts
+import { execSync } from "child_process";
+var githubProvider = {
+  id: "github",
+  displayName: "GitHub",
+  prKindLabel: "pull request",
+  ensureReady(_gitRoot) {
+    try {
+      execSync("gh auth status", { stdio: "pipe" });
+    } catch {
+      throw new Error(
+        "GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com then run: gh auth login"
+      );
+    }
+  },
+  resolveBaseBranch(configured, gitRoot) {
+    if (configured) return configured;
+    try {
+      const out = execSync(
+        "gh repo view --json defaultBranchRef --jq .defaultBranchRef.name",
+        { cwd: gitRoot, stdio: "pipe", encoding: "utf-8" }
+      );
+      return out.trim() || void 0;
+    } catch {
+      return void 0;
+    }
+  },
+  openPr({ gitRoot, branch, baseBranch, title, bodyFile }) {
+    const baseFlag = baseBranch ? ` --base ${JSON.stringify(baseBranch)}` : "";
+    const raw = execSync(
+      `gh pr create --title ${JSON.stringify(title)} --body-file ${JSON.stringify(bodyFile)} --head ${JSON.stringify(branch)}${baseFlag}`,
+      { cwd: gitRoot, stdio: "pipe", encoding: "utf-8" }
+    );
+    return raw.split("\n").filter((l) => l.startsWith("https://")).pop()?.trim() ?? raw.trim();
+  }
+};
+var gitlabProvider = {
+  id: "gitlab",
+  displayName: "GitLab",
+  prKindLabel: "merge request",
+  ensureReady(_gitRoot) {
+    try {
+      execSync("glab auth status", { stdio: "pipe" });
+    } catch {
+      throw new Error(
+        "GitLab CLI (glab) is not installed or not authenticated. Install from https://gitlab.com/gitlab-org/cli then run: glab auth login"
+      );
+    }
+  },
+  resolveBaseBranch(configured, gitRoot) {
+    if (configured) return configured;
+    try {
+      const out = execSync(
+        "glab repo view --output json",
+        { cwd: gitRoot, stdio: "pipe", encoding: "utf-8" }
+      );
+      const json = JSON.parse(out);
+      return json.default_branch || void 0;
+    } catch {
+      return void 0;
+    }
+  },
+  openPr({ gitRoot, branch, baseBranch, title, bodyFile }) {
+    const baseFlag = baseBranch ? ` --target-branch ${JSON.stringify(baseBranch)}` : "";
+    const raw = execSync(
+      `glab mr create --title ${JSON.stringify(title)} --description-file ${JSON.stringify(bodyFile)} --source-branch ${JSON.stringify(branch)}${baseFlag} --yes`,
+      { cwd: gitRoot, stdio: "pipe", encoding: "utf-8" }
+    );
+    const lines = raw.split("\n").map((l) => l.trim()).filter(Boolean);
+    const urlLine = lines.reverse().find((l) => /^https?:\/\//.test(l) || /https?:\/\/\S+/.test(l));
+    if (!urlLine) return raw.trim();
+    const match = urlLine.match(/https?:\/\/\S+/);
+    return match ? match[0] : urlLine;
+  }
+};
+function detectProvider(gitRoot, override = "auto") {
+  if (override === "github") return githubProvider;
+  if (override === "gitlab") return gitlabProvider;
+  try {
+    const url = execSync("git remote get-url origin", {
+      cwd: gitRoot,
+      stdio: "pipe",
+      encoding: "utf-8"
+    }).toString().trim();
+    if (/gitlab/i.test(url)) return gitlabProvider;
+    return githubProvider;
+  } catch {
+    return githubProvider;
+  }
+}
+
+// src/lint.ts
+function toKebab(s) {
+  return s.trim().replace(/([A-Z])/g, "-$1").replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function suggestTestId(el, index) {
+  if (el.label) return toKebab(el.label);
+  if (el.selectors?.id) return toKebab(el.selectors.id.replace(/^#/, ""));
+  if (el.selectors?.name) {
+    const m = el.selectors.name.match(/\[name=["']?([^"'\]]+)["']?\]/);
+    if (m) return toKebab(m[1]);
+  }
+  if (el.selectors?.ariaLabel) {
+    const m = el.selectors.ariaLabel.match(/\[aria-label=["']?([^"'\]]+)["']?\]/);
+    if (m) return toKebab(m[1]);
+  }
+  return `${el.type}-${index + 1}`;
+}
+function escRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function unwrap(sel, attr) {
+  if (!sel) return void 0;
+  const m = sel.match(new RegExp(`\\[${attr}=["']?([^"'\\]]+)["']?\\]`));
+  return m?.[1];
+}
+function existingTestId(el) {
+  const m = el.selectors.dataTestId?.match(/\[data-testid=["']?([^"'\]]+)["']?\]/);
+  return m?.[1];
+}
+function dedupeTestIdsPerFile(issuesByFile) {
+  for (const fileIssues of issuesByFile.values()) {
+    const used = /* @__PURE__ */ new Map();
+    for (const issue of fileIssues) {
+      const base = issue.suggestedTestId;
+      const n = (used.get(base) ?? 0) + 1;
+      used.set(base, n);
+      if (n > 1) issue.suggestedTestId = `${base}-${n}`;
+    }
+  }
+}
+function patchSource(source, issue, testId) {
+  const existing = existingTestId(issue.element);
+  if (issue.kind === "ambiguous" && existing && existing !== testId) {
+    const pat2 = new RegExp(`(\\bdata-testid=["'])${escRe(existing)}(["'])`, "g");
+    let done2 = false;
+    return source.replace(pat2, (m, pre, post) => {
+      if (done2) return m;
+      done2 = true;
+      return `${pre}${testId}${post}`;
+    });
+  }
+  const sels = issue.element.selectors;
+  let attr;
+  let val;
+  if (sels.id) {
+    attr = "id";
+    val = sels.id.replace(/^#/, "");
+  } else if (val = unwrap(sels.name, "name")) {
+    attr = "name";
+  } else if (val = unwrap(sels.ariaLabel, "aria-label")) {
+    attr = "aria-label";
+  }
+  if (!attr || !val) return source;
+  const pat = new RegExp(
+    `(<[a-zA-Z][^>]*?\\b${escRe(attr)}=["']${escRe(val)}["'][^>]*?)(?=\\s*/?>)`,
+    "g"
+  );
+  let done = false;
+  return source.replace(pat, (match) => {
+    if (done || match.includes("data-testid")) return match;
+    done = true;
+    return `${match} data-testid="${testId}"`;
+  });
+}
+async function runLint(config, opts) {
+  const components = await crawl({
+    rootDir: config.rootDir,
+    include: config.include,
+    exclude: config.exclude,
+    framework: config.framework
+  });
+  const results = await analyze(components);
+  let a11yFindings;
+  if (opts.a11y) {
+    const evidenceList = extractA11yEvidenceFromAll(components);
+    a11yFindings = runStaticAnalysis(evidenceList, { level: opts.wcag ?? "AA" });
+  }
+  const issues = [];
+  for (const r of results) {
+    r.interactiveElements.forEach((el, i) => {
+      const isAmbiguous = el.ambiguous;
+      const isLowScore = el.testabilityScore < opts.threshold;
+      if (!isAmbiguous && !isLowScore) return;
+      issues.push({
+        filePath: r.component.filePath,
+        componentName: r.component.componentName,
+        element: el,
+        suggestedTestId: suggestTestId(el, i),
+        kind: isAmbiguous ? "ambiguous" : "low-score",
+        ambiguityReason: el.ambiguityReason
+      });
+    });
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    if (!byFile.has(issue.filePath)) byFile.set(issue.filePath, []);
+    byFile.get(issue.filePath).push(issue);
+  }
+  dedupeTestIdsPerFile(byFile);
+  let fixedCount = 0;
+  let skippedCount = 0;
+  if (opts.fix && issues.length) {
+    for (const [filePath, fileIssues] of byFile) {
+      let source = await readFile(filePath, "utf-8");
+      let updated = source;
+      for (const issue of fileIssues) {
+        const patched = patchSource(updated, issue, issue.suggestedTestId);
+        if (patched !== updated) {
+          updated = patched;
+          issue.fixApplied = true;
+          fixedCount++;
+        } else {
+          skippedCount++;
+        }
+      }
+      if (updated !== source) {
+        await writeFile2(filePath, updated, "utf-8");
+      }
+    }
+  }
+  let prUrl;
+  if (opts.pr && fixedCount > 0) {
+    const cwd = path2.resolve(config.rootDir);
+    let gitRoot;
+    try {
+      gitRoot = execSync2("git rev-parse --show-toplevel", {
+        cwd,
+        stdio: "pipe",
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+      throw new Error(
+        "[selfcure --pr] Not inside a git repository. Run selfcure from a directory tracked by git."
+      );
+    }
+    const provider = detectProvider(gitRoot, config.lint?.gitProvider ?? "auto");
+    try {
+      provider.ensureReady(gitRoot);
+    } catch (err) {
+      throw new Error(`[selfcure --pr] ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const baseBranch = provider.resolveBaseBranch(config.lint?.prBaseBranch, gitRoot);
+    let originalBranch;
+    try {
+      originalBranch = execSync2("git rev-parse --abbrev-ref HEAD", {
+        cwd: gitRoot,
+        stdio: "pipe",
+        encoding: "utf-8"
+      }).trim();
+      if (originalBranch === "HEAD") originalBranch = void 0;
+    } catch {
+    }
+    const patchedFiles = [...byFile.keys()].filter((f) => byFile.get(f).some((i) => i.fixApplied));
+    try {
+      const statusOut = execSync2("git status --porcelain", {
+        cwd: gitRoot,
+        stdio: "pipe",
+        encoding: "utf-8"
+      }).trim();
+      if (statusOut) {
+        const patchedSet = new Set(
+          patchedFiles.map((f) => path2.relative(gitRoot, f).replace(/\\/g, "/"))
+        );
+        const dirtyUnrelated = statusOut.split("\n").map((l) => l.slice(3).trim()).filter((f) => !patchedSet.has(f));
+        if (dirtyUnrelated.length > 0) {
+          console.warn(
+            `[selfcure --pr] Warning: ${dirtyUnrelated.length} unrelated file(s) have uncommitted changes \u2014 they will NOT be included in the PR:
+` + dirtyUnrelated.map((f) => `  \u2022 ${f}`).join("\n")
+          );
+        }
+      }
+    } catch {
+    }
+    const applied = issues.filter((i) => i.fixApplied);
+    const ambiguousCnt = applied.filter((i) => i.kind === "ambiguous").length;
+    const lowScoreCnt = applied.length - ambiguousCnt;
+    const fileRows = patchedFiles.map((f) => {
+      const rel = path2.relative(gitRoot, f).replace(/\\/g, "/");
+      const fileIssues = byFile.get(f).filter((i) => i.fixApplied);
+      const ids = fileIssues.map((i) => `\`data-testid="${i.suggestedTestId}"\``).join(", ");
+      return `| \`${rel}\` | ${fileIssues.length} | ${ids} |`;
+    });
+    const whySummary = [];
+    if (lowScoreCnt > 0) {
+      whySummary.push(
+        `- **${lowScoreCnt}** element(s) had no stable selector (score < ${opts.threshold}/100) \u2014 \`data-testid\` added.`
+      );
+    }
+    if (ambiguousCnt > 0) {
+      whySummary.push(
+        `- **${ambiguousCnt}** locator(s) matched multiple elements in the same component \u2014 \`data-testid\` rewritten to a unique value.`
+      );
+    }
+    const body = [
+      "## selfcure lint \u2014 automated `data-testid` patches",
+      "",
+      "| Metric | Value |",
+      "|--------|-------|",
+      `| Files changed | ${patchedFiles.length} |`,
+      `| Elements patched | ${fixedCount} |`,
+      `| Unstable selectors fixed | ${lowScoreCnt} |`,
+      `| Ambiguous locators fixed | ${ambiguousCnt} |`,
+      "",
+      "### Changed files",
+      "",
+      "| File | Elements | Attributes added |",
+      "|------|----------|-----------------|",
+      ...fileRows,
+      "",
+      "### Why these changes?",
+      "",
+      ...whySummary,
+      "",
+      "> **Review before merging** \u2014 rename any `data-testid` value that does not match your project's naming convention.",
+      "> _Generated automatically by [selfcure](https://github.com/ricardofrancocustodio/selfcure)._"
+    ].join("\n");
+    const tmpDir = await mkdtemp(path2.join(os.tmpdir(), "selfcure-pr-"));
+    const bodyFile = path2.join(tmpDir, "body.md");
+    await writeFile2(bodyFile, body, "utf-8");
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const short = Date.now().toString(36).slice(-4);
+    const branch = `selfcure/lint-fix-${date}-${short}`;
+    const title = `chore(testids): add data-testid to ${fixedCount} element(s) \u2014 selfcure lint`;
+    try {
+      execSync2(`git checkout -b ${JSON.stringify(branch)}`, { cwd: gitRoot, stdio: "pipe" });
+      const relPaths = patchedFiles.map((f) => JSON.stringify(path2.relative(gitRoot, f))).join(" ");
+      execSync2(`git add -- ${relPaths}`, { cwd: gitRoot, stdio: "pipe" });
+      const commitMsg = `chore(testids): add data-testid via selfcure lint
+
+Patched ${fixedCount} element(s) across ${patchedFiles.length} file(s).
+Threshold: ${opts.threshold}/100`;
+      execSync2(`git commit -m ${JSON.stringify(commitMsg)}`, { cwd: gitRoot, stdio: "pipe" });
+      execSync2(`git push -u origin ${JSON.stringify(branch)}`, { cwd: gitRoot, stdio: "pipe" });
+      prUrl = provider.openPr({ gitRoot, branch, baseBranch, title, bodyFile });
+    } finally {
+      await rm(tmpDir, { recursive: true, force: true });
+      if (originalBranch) {
+        try {
+          execSync2(`git checkout ${JSON.stringify(originalBranch)}`, { cwd: gitRoot, stdio: "pipe" });
+        } catch {
+        }
+      }
+    }
+  }
+  return { issues, totalFiles: results.length, fixedCount, skippedCount, prUrl, a11yFindings };
+}
+
+// src/a11y.ts
+import chalk from "chalk";
+import ora from "ora";
+import path3 from "path";
+import fs from "fs/promises";
+import { pathToFileURL } from "url";
+import { crawl as crawl2, extractA11yEvidenceFromAll as extractA11yEvidenceFromAll2 } from "@selfcure/crawler";
+import {
+  runStaticAnalysis as runStaticAnalysis2,
+  loadFindings,
+  saveFindings,
+  mergeFindings,
+  emptyInventory,
+  runAudit
+} from "@selfcure/analyzer";
+import { runDynamicScan } from "@selfcure/runner";
+var SEVERITY_COLOR = {
+  critical: chalk.red,
+  major: chalk.yellow,
+  minor: chalk.cyan,
+  info: chalk.dim
+};
+function severityCounts(findings) {
+  return {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    major: findings.filter((f) => f.severity === "major").length,
+    minor: findings.filter((f) => f.severity === "minor").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+}
+function printA11ySection(findings, opts) {
+  const { isPro, wcagLevel, cwd } = opts;
+  const counts = severityCounts(findings);
+  console.log(chalk.bold(`Accessibility  WCAG ${wcagLevel}`));
+  if (findings.length === 0) {
+    console.log(chalk.dim("  0 issues"));
+    console.log("");
+    return;
+  }
+  const parts = [];
+  if (counts.critical > 0) parts.push(chalk.red.bold(`critical  ${counts.critical}`));
+  if (counts.major > 0) parts.push(chalk.yellow.bold(`major  ${counts.major}`));
+  if (counts.minor > 0) parts.push(chalk.cyan(`minor  ${counts.minor}`));
+  if (counts.info > 0) parts.push(chalk.dim(`info  ${counts.info}`));
+  console.log("  " + parts.join("  \xB7  "));
+  console.log("");
+  if (!isPro) {
+    console.log(chalk.bold.yellow("  \u2726 Full accessibility report available on the Pro plan"));
+    console.log(chalk.dim("    Enable with SELFCURE_PRO=1 or pro: true in your config."));
+    console.log("");
+    return;
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const f of findings) {
+    const list = byFile.get(f.sourceFile) ?? [];
+    list.push(f);
+    byFile.set(f.sourceFile, list);
+  }
+  for (const [filePath, filefindings] of byFile) {
+    const rel = path3.relative(cwd, filePath);
+    console.log(chalk.underline(rel));
+    for (const f of filefindings) {
+      const col = SEVERITY_COLOR[f.severity];
+      const rule = chalk.bold(f.ruleId.replace("a11y.", ""));
+      const loc = chalk.dim(`:${f.line}${f.column ? `:${f.column}` : ""}`);
+      console.log(`  ${col(f.severity.padEnd(8))}  ${rule}`);
+      console.log(chalk.dim(`    ${rel}${loc}  \u2014  ${f.message}`));
+    }
+    console.log("");
+  }
+}
+async function tryLoadConfig(configPath) {
+  const resolved = path3.resolve(configPath);
+  const exists = await fs.stat(resolved).then(() => true).catch(() => false);
+  if (!exists) return null;
+  try {
+    const { default: cfg } = await import(pathToFileURL(resolved).href);
+    return cfg;
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_SOURCE_GLOBS = ["**/*.{tsx,jsx,ts,js,vue}"];
+var DEFAULT_EXCLUDE = ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**"];
+function registerA11yCommands(program2) {
+  const a11y = program2.command("a11y").description("Accessibility WCAG commands \u2014 scan, audit, and CI gate");
+  a11y.command("scan").description("Scan source files for WCAG accessibility issues and update the findings inventory").option("-c, --config <path>", "path to selfcure.config.mjs", "./selfcure.config.mjs").option("--root <dir>", "project root (overrides config.rootDir)").option("--wcag <level>", "WCAG target level: A, AA, or AAA", "AA").option("--out <dir>", "output directory for findings file", ".selfcure").option("--app <name>", "application name for the findings file").option("--dynamic", "[Pro] also run live Playwright + axe-core scan").option("--base-url <url>", "app base URL for dynamic scan (e.g. http://localhost:3000)").option("--routes <routes>", "comma-separated routes to scan (default: /)", "/").option("--axe-source <path>", "local path or URL to axe-core script (default: CDN)").action(async (opts) => {
+    const spinner = ora("Scanning for accessibility issues\u2026").start();
+    try {
+      const config = await tryLoadConfig(opts.config);
+      const rootDir = opts.root ? path3.resolve(opts.root) : config?.["rootDir"] ? path3.resolve(String(config["rootDir"])) : process.cwd();
+      const include = config?.["include"] ?? DEFAULT_SOURCE_GLOBS;
+      const exclude = config?.["exclude"] ?? DEFAULT_EXCLUDE;
+      const wcagLevel = opts.wcag ?? "AA";
+      const components = await crawl2({ rootDir, include, exclude });
+      const evidenceList = extractA11yEvidenceFromAll2(components);
+      const newFindings = runStaticAnalysis2(evidenceList, { level: wcagLevel });
+      if (opts.dynamic) {
+        const baseUrl = opts.baseUrl;
+        if (!baseUrl) {
+          spinner.warn(chalk.yellow("--dynamic requires --base-url. Skipping dynamic scan."));
+        } else {
+          spinner.text = "Running dynamic Playwright + axe-core scan\u2026";
+          try {
+            const routes = opts.routes.split(",").map((r) => r.trim()).filter(Boolean);
+            const dynResult = await runDynamicScan({
+              baseURL: baseUrl,
+              routes,
+              level: wcagLevel,
+              axeSource: opts.axeSource
+            });
+            newFindings.push(...dynResult.findings);
+            if (dynResult.errors.length > 0) {
+              for (const e of dynResult.errors) {
+                console.warn(chalk.yellow(`  dynamic scan error on ${e.route}: ${e.error}`));
+              }
+            }
+          } catch (err) {
+            spinner.warn(chalk.yellow(`Dynamic scan failed: ${String(err)}`));
+          }
+        }
+      }
+      const outDir = path3.resolve(opts.out);
+      const outFile = path3.join(outDir, "a11y-findings.json");
+      const existing = await loadFindings(outFile);
+      const appName = opts.app ?? path3.basename(rootDir);
+      const base = existing.ok ? existing.inventory : emptyInventory({ app: appName, targetLevel: wcagLevel });
+      const merged = mergeFindings(base, newFindings);
+      await saveFindings(outFile, merged);
+      const open = merged.findings.filter((f) => f.status === "open");
+      const counts = severityCounts(open);
+      spinner.succeed(chalk.green(`Scan complete \u2014 ${components.length} file(s) scanned`));
+      console.log("");
+      if (open.length === 0) {
+        console.log(chalk.green("  0 accessibility issues"));
+      } else {
+        const parts = [];
+        if (counts.critical > 0) parts.push(chalk.red(`critical  ${counts.critical}`));
+        if (counts.major > 0) parts.push(chalk.yellow(`major  ${counts.major}`));
+        if (counts.minor > 0) parts.push(chalk.cyan(`minor  ${counts.minor}`));
+        if (counts.info > 0) parts.push(chalk.dim(`info  ${counts.info}`));
+        console.log("  " + parts.join("  \xB7  "));
+      }
+      const resolved = merged.findings.filter((f) => f.status === "resolved").length;
+      const suppressed = merged.findings.filter((f) => f.status === "suppressed").length;
+      if (resolved > 0) console.log(chalk.dim(`  ${resolved} resolved since last scan`));
+      if (suppressed > 0) console.log(chalk.dim(`  ${suppressed} suppressed`));
+      console.log(chalk.dim(`
+  findings written to  ${path3.relative(process.cwd(), outFile)}`));
+      console.log("");
+    } catch (err) {
+      spinner.fail(chalk.red(String(err)));
+      process.exit(1);
+    }
+  });
+  a11y.command("audit").description("Audit the accessibility findings inventory and optionally gate CI").option("--findings <path>", "path to findings file", ".selfcure/a11y-findings.json").option("--fail-on <sev>", "minimum severity that fails CI: info, minor, major, critical", "major").option("--ci", "exit non-zero when findings meet or exceed --fail-on severity").action(async (opts) => {
+    const spinner = ora("Loading accessibility findings\u2026").start();
+    try {
+      const findingsPath = path3.resolve(opts.findings);
+      const result = await loadFindings(findingsPath);
+      if (!result.ok) {
+        spinner.fail(chalk.red("Failed to load findings:"));
+        for (const e of result.errors) console.error(chalk.red(`  ${e}`));
+        process.exit(1);
+      }
+      spinner.stop();
+      const inventory = result.inventory;
+      const auditResult = runAudit(inventory, { failOn: opts.failOn });
+      const { counts, wouldFailCI } = auditResult;
+      console.log("");
+      console.log(chalk.bold("selfcure a11y audit"));
+      console.log(chalk.dim(`  ${path3.relative(process.cwd(), findingsPath)}  \xB7  WCAG ${inventory.targetLevel}`));
+      console.log("");
+      console.log(
+        chalk.dim("Open: ") + chalk.white(counts.open) + "  " + chalk.dim("Resolved: ") + chalk.white(counts.resolved) + "  " + chalk.dim("Suppressed: ") + chalk.white(counts.suppressed)
+      );
+      console.log("");
+      if (counts.open === 0) {
+        console.log(chalk.green.bold("\u2714 No open accessibility findings"));
+        console.log("");
+        return;
+      }
+      const open = inventory.findings.filter((f) => f.status === "open");
+      printA11ySection(open, { isPro: true, wcagLevel: inventory.targetLevel, cwd: process.cwd() });
+      if (opts.ci) {
+        if (wouldFailCI) {
+          console.log(chalk.red.bold(
+            `CI mode: exiting with code 1 (fail-on: ${opts.failOn} \u2014 found ` + [
+              counts.bySeverity.critical > 0 ? `${counts.bySeverity.critical} critical` : "",
+              counts.bySeverity.major > 0 ? `${counts.bySeverity.major} major` : ""
+            ].filter(Boolean).join(", ") + ")"
+          ));
+          process.exit(1);
+        } else {
+          console.log(chalk.green(`CI mode: passed (no findings at or above "${opts.failOn}")`));
+        }
+      }
+    } catch (err) {
+      spinner.fail(chalk.red(String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/testids.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import path4 from "path";
+import fs2 from "fs/promises";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { extractTestIds } from "@selfcure/crawler";
+import { loadInventory, audit } from "@selfcure/analyzer";
+var DEFAULT_SOURCE_GLOBS2 = ["**/*.{tsx,jsx,ts,js,vue,html}"];
+var DEFAULT_TEST_GLOBS = ["**/*.{spec,test}.{ts,js,tsx,jsx}", "**/*.e2e.{ts,js}"];
+var DEFAULT_EXCLUDE2 = ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**"];
+async function tryLoadConfig2(configPath) {
+  const resolved = path4.resolve(configPath);
+  const exists = await fs2.stat(resolved).then(() => true).catch(() => false);
+  if (!exists) return null;
+  try {
+    const { default: cfg } = await import(pathToFileURL2(resolved).href);
+    return cfg;
+  } catch {
+    return null;
+  }
+}
+function registerTestIdsCommands(program2) {
+  const testids = program2.command("testids").description("Test ID inventory \u2014 scan source for data-testid usage and audit against a governed contract");
+  testids.command("scan").description("Scan source and test files for data-testid usage and write observed results").option("-c, --config <path>", "path to selfcure.config.mjs", "./selfcure.config.mjs").option("--root <dir>", "project root (overrides config.rootDir)", "").option("--out <dir>", "output directory for scan results", ".selfcure").action(async (opts) => {
+    const spinner = ora2("Scanning for data-testid usage\u2026").start();
+    try {
+      const config = await tryLoadConfig2(opts.config);
+      const rootDir = opts.root ? path4.resolve(opts.root) : config?.["rootDir"] ? path4.resolve(String(config["rootDir"])) : process.cwd();
+      const sourceGlobs = config?.["include"] ?? DEFAULT_SOURCE_GLOBS2;
+      const exclude = config?.["exclude"] ?? DEFAULT_EXCLUDE2;
+      const result = await extractTestIds({
+        rootDir,
+        sourceGlobs,
+        testGlobs: DEFAULT_TEST_GLOBS,
+        exclude
+      });
+      const outDir = path4.resolve(opts.out);
+      await fs2.mkdir(outDir, { recursive: true });
+      const outFile = path4.join(outDir, "testids-scan.json");
+      await fs2.writeFile(outFile, JSON.stringify({ rootDir, ...result, generatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+      spinner.succeed(chalk2.green(`Scan complete \u2014 ${result.scannedFiles} file(s) scanned`));
+      console.log("");
+      const frontendCount = result.usages.filter((u) => u.kind === "frontend").length;
+      const testCount = result.usages.filter((u) => u.kind === "test").length;
+      const uniqueFe = new Set(result.usages.filter((u) => u.kind === "frontend").map((u) => u.value)).size;
+      console.log(chalk2.dim(`  frontend data-testid: `) + chalk2.white(`${uniqueFe} unique (${frontendCount} occurrences)`));
+      console.log(chalk2.dim(`  test getByTestId:     `) + chalk2.white(`${testCount} calls`));
+      console.log(chalk2.dim(`  results written to:   `) + chalk2.white(path4.relative(process.cwd(), outFile)));
+      console.log("");
+    } catch (err) {
+      spinner.fail(chalk2.red(String(err)));
+      process.exit(1);
+    }
+  });
+  testids.command("audit").description("Audit the testid-inventory.json contract against observed source usage").option("-c, --config <path>", "path to selfcure.config.mjs", "./selfcure.config.mjs").option("--root <dir>", "project root (overrides config.rootDir)", "").option("--inventory <path>", "path to inventory file", ".selfcure/testid-inventory.json").option("--ci", "exit non-zero when error-level issues exist").action(async (opts) => {
+    const spinner = ora2("Loading inventory and scanning source\u2026").start();
+    try {
+      const inventoryPath = path4.resolve(opts.inventory);
+      const inventoryResult = await loadInventory(inventoryPath);
+      if (!inventoryResult.ok) {
+        spinner.fail(chalk2.red("Failed to load inventory:"));
+        for (const e of inventoryResult.errors) console.error(chalk2.red(`  ${e}`));
+        process.exit(1);
+      }
+      const inventory = inventoryResult.inventory;
+      const config = await tryLoadConfig2(opts.config);
+      const rootDir = opts.root ? path4.resolve(opts.root) : config?.["rootDir"] ? path4.resolve(String(config["rootDir"])) : process.cwd();
+      const sourceGlobs = config?.["include"] ?? DEFAULT_SOURCE_GLOBS2;
+      const exclude = config?.["exclude"] ?? DEFAULT_EXCLUDE2;
+      const { usages, scannedFiles } = await extractTestIds({
+        rootDir,
+        sourceGlobs,
+        testGlobs: DEFAULT_TEST_GLOBS,
+        exclude
+      });
+      spinner.stop();
+      const result = audit(inventory, usages);
+      const { summary, issues } = result;
+      const errors = issues.filter((i) => i.severity === "error");
+      const warnings = issues.filter((i) => i.severity === "warning");
+      console.log("");
+      console.log(chalk2.bold("selfcure testids audit"));
+      console.log(chalk2.dim(`  ${scannedFiles} file(s) scanned \xB7 ${summary.totalObserved} unique frontend test IDs observed`));
+      console.log("");
+      if (issues.length === 0) {
+        console.log(chalk2.green.bold("\u2714 No issues found"));
+        console.log("");
+        return;
+      }
+      console.log(
+        (errors.length > 0 ? chalk2.red(`Errors: ${errors.length}`) : chalk2.dim("Errors: 0")) + "  " + (warnings.length > 0 ? chalk2.yellow(`Warnings: ${warnings.length}`) : chalk2.dim("Warnings: 0"))
+      );
+      console.log("");
+      for (const issue of issues) {
+        printIssue(issue);
+      }
+      if (opts.ci && errors.length > 0) {
+        console.log(chalk2.red.bold(`
+CI mode: exiting with code 1 (${errors.length} error(s) found)`));
+        process.exit(1);
+      }
+    } catch (err) {
+      spinner.fail(chalk2.red(String(err)));
+      process.exit(1);
+    }
+  });
+}
+function printIssue(issue) {
+  const severity = issue.severity === "error" ? chalk2.red("error") : chalk2.yellow("warn ");
+  const extra = issue.message ? chalk2.dim(` \u2014 ${issue.message}`) : "";
+  console.log(`${severity}  ${chalk2.bold(issue.rule)}  ${chalk2.white(issue.testId)}${extra}`);
+  if (issue.locations) {
+    for (const loc of issue.locations) {
+      console.log(chalk2.dim(`    ${loc}`));
+    }
+  }
+}
+
+// src/discover.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+import path5 from "path";
+import fs3 from "fs/promises";
+import { discoverProject as discoverProject2 } from "@selfcure/crawler";
+import { runRuntimeDiscovery } from "@selfcure/runner";
+import { buildTestabilityReport, summarizeReport } from "@selfcure/analyzer";
+import { buildDiscoveryInput, shouldUseLlm, runLlmDiscovery } from "@selfcure/generator";
+function frameworkLabel(f) {
+  const map = {
+    next: "Next.js",
+    nuxt: "Nuxt",
+    vue: "Vue",
+    angular: "Angular",
+    svelte: "Svelte",
+    react: "React (SPA)",
+    unknown: "Unknown"
+  };
+  return map[f] ?? f;
+}
+function scoreColor(score) {
+  if (score >= 80) return chalk3.green(String(score));
+  if (score >= 60) return chalk3.yellow(String(score));
+  return chalk3.red(String(score));
+}
+function confidenceBar(c) {
+  const pct = Math.round(c * 100);
+  const col = pct >= 90 ? chalk3.green : pct >= 70 ? chalk3.yellow : chalk3.dim;
+  return col(`${pct}%`);
+}
+function printSummary(map, cwd) {
+  console.log("");
+  console.log(chalk3.bold("selfcure discover"));
+  console.log("");
+  console.log(chalk3.dim("  Framework:       ") + chalk3.white(frameworkLabel(map.framework)));
+  console.log(chalk3.dim("  Package manager: ") + chalk3.white(map.packageManager));
+  if (map.devCommand) console.log(chalk3.dim("  Dev command:     ") + chalk3.white(map.devCommand));
+  if (map.buildCommand) console.log(chalk3.dim("  Build command:   ") + chalk3.white(map.buildCommand));
+  if (map.testCommand) console.log(chalk3.dim("  Test command:    ") + chalk3.white(map.testCommand));
+  console.log("");
+  const routes = map.routeCandidates;
+  if (routes.length === 0) {
+    console.log(chalk3.dim("  No route candidates found."));
+  } else {
+    console.log(chalk3.bold(`  Routes (${routes.length}):`));
+    for (const r of routes) {
+      const rel = path5.relative(cwd, r.filePath);
+      const dyn = r.isDynamic ? chalk3.dim(" [dynamic]") : "";
+      const conf = confidenceBar(r.confidence);
+      console.log(`    ${chalk3.cyan(r.path.padEnd(35))} ${conf.padEnd(8)}  ${chalk3.dim(rel)}${dyn}`);
+    }
+  }
+  if (map.componentCandidates.length > 0) {
+    console.log("");
+    console.log(chalk3.dim(`  ${map.componentCandidates.length} component candidate(s) found.`));
+  }
+}
+function registerDiscoverCommand(program2) {
+  program2.command("discover").description("Discover project structure, framework, and route candidates (static analysis)").option("--root <dir>", "project root to analyse (default: cwd)").option("--out <dir>", "output directory for discovery artifacts", ".selfcure").option("--runtime", "also render routes with Playwright (requires a running app)").option("--base-url <url>", "app base URL for runtime discovery (e.g. http://localhost:3000)").option("--screenshots", "capture screenshots during runtime discovery").option("--llm", "use LLM to suggest routes and hidden states when confidence is low").option("--provider <id>", "AI provider for --llm (anthropic|openai|google|groq|deepseek|ollama)").option("--model <name>", "model name for --llm").action(async (opts) => {
+    const cwd = process.cwd();
+    const root = opts.root ? path5.resolve(opts.root) : cwd;
+    const outDir = path5.resolve(opts.out);
+    const spinner = ora3("Discovering project structure\u2026").start();
+    let map;
+    try {
+      map = await discoverProject2({ projectRoot: root });
+    } catch (err) {
+      spinner.fail(chalk3.red(String(err)));
+      process.exit(1);
+      return;
+    }
+    await fs3.mkdir(outDir, { recursive: true });
+    const mapFile = path5.join(outDir, "project-map.json");
+    await fs3.writeFile(mapFile, JSON.stringify(map, null, 2), "utf-8");
+    spinner.stop();
+    printSummary(map, cwd);
+    console.log(chalk3.dim(`  Artifacts: ${path5.relative(cwd, mapFile)}`));
+    if (opts.runtime) {
+      const baseURL = opts.baseUrl;
+      if (!baseURL) {
+        console.log("");
+        console.log(chalk3.yellow("  --runtime requires --base-url <url> (e.g. http://localhost:3000)"));
+        console.log("");
+      } else {
+        const routes = map.routeCandidates.map((r) => r.path);
+        const rtSpinner = ora3(`Runtime discovery \u2014 ${routes.length} route(s) via Playwright\u2026`).start();
+        try {
+          const rtResult2 = await runRuntimeDiscovery({
+            baseURL,
+            routes,
+            outDir,
+            screenshots: opts.screenshots ?? false
+          });
+          const routeMapFile = path5.join(outDir, "route-map.json");
+          await fs3.writeFile(routeMapFile, JSON.stringify(rtResult2, null, 2), "utf-8");
+          const trReport = buildTestabilityReport(rtResult2);
+          const trFile = path5.join(outDir, "testability-report.json");
+          await fs3.writeFile(trFile, JSON.stringify(trReport, null, 2), "utf-8");
+          const summary = summarizeReport(trReport);
+          rtSpinner.stop();
+          console.log("");
+          console.log(chalk3.bold(`  Runtime results (${rtResult2.reachable}/${routes.length} reachable):`));
+          for (const r of rtResult2.routes) {
+            const icon = r.status === "reachable" ? chalk3.green("\u2713") : chalk3.red("\u2717");
+            const title = r.title ? chalk3.dim(` "${r.title.slice(0, 40)}"`) : "";
+            const els = r.status === "reachable" ? chalk3.dim(` \xB7 ${r.interactiveElements.length} elements`) : "";
+            const routeResult = trReport.routes.find((x) => x.route === r.route);
+            const score = routeResult && r.status === "reachable" ? "  score: " + scoreColor(routeResult.score) : "";
+            console.log(`    ${icon}  ${chalk3.cyan(r.route.padEnd(30))}${title}${els}${score}`);
+          }
+          console.log("");
+          console.log(chalk3.bold("  Testability:"));
+          if (summary.critical.length > 0) {
+            console.log(chalk3.red(`    Critical (< 60):  ${summary.critical.map((r) => r.route).join(", ")}`));
+          }
+          if (summary.warning.length > 0) {
+            console.log(chalk3.yellow(`    Warning  (< 80):  ${summary.warning.map((r) => r.route).join(", ")}`));
+          }
+          if (summary.healthy.length > 0) {
+            console.log(chalk3.green(`    Healthy  (\u2265 80):  ${summary.healthy.map((r) => r.route).join(", ")}`));
+          }
+          console.log(chalk3.dim(`    Overall score:    ${trReport.overall.score}/100`));
+          console.log("");
+          console.log(chalk3.dim(`  Artifacts: ${path5.relative(cwd, routeMapFile)}`));
+          console.log(chalk3.dim(`             ${path5.relative(cwd, trFile)}`));
+        } catch (err) {
+          rtSpinner.fail(chalk3.red(`Runtime discovery failed: ${String(err)}`));
+        }
+      }
+    } else if (map.routeCandidates.length > 0) {
+      console.log("");
+      console.log(chalk3.dim("  Tip: run with --runtime --base-url <url> to render routes live"));
+    }
+    const rtResult = void 0;
+    if (opts.llm) {
+      const needsLlm = shouldUseLlm(map, rtResult);
+      if (!needsLlm) {
+        console.log(chalk3.dim("  LLM skipped \u2014 deterministic confidence is high enough."));
+      } else {
+        const aiConfig = {
+          provider: opts.provider ?? "anthropic",
+          generationModel: opts.model
+        };
+        const llmSpinner = ora3("LLM discovery \u2014 asking model for route + hidden-state hints\u2026").start();
+        try {
+          const llmInput = buildDiscoveryInput(map, rtResult);
+          const llmOutput = await runLlmDiscovery(llmInput, aiConfig);
+          llmSpinner.stop();
+          console.log("");
+          console.log(chalk3.bold(`  LLM suggestions (confidence: ${Math.round(llmOutput.confidence * 100)}%):`));
+          if (llmOutput.routesToVisit.length > 0) {
+            console.log(chalk3.dim("    Routes to prioritise:"));
+            for (const r of llmOutput.routesToVisit) {
+              console.log(`      ${chalk3.cyan(r)}`);
+            }
+          }
+          if (llmOutput.hiddenStatesToExplore.length > 0) {
+            console.log(chalk3.dim("    Hidden states to explore:"));
+            for (const h of llmOutput.hiddenStatesToExplore) {
+              console.log(`      ${chalk3.cyan(h.route)}  \u2192  ${chalk3.dim(h.triggerHint)}`);
+            }
+          }
+          if (llmOutput.notes.length > 0) {
+            console.log(chalk3.dim("    Notes:"));
+            for (const n of llmOutput.notes) console.log(`      ${chalk3.dim(n)}`);
+          }
+          const hintsFile = path5.join(outDir, "llm-hints.json");
+          await fs3.writeFile(hintsFile, JSON.stringify(llmOutput, null, 2), "utf-8");
+          console.log(chalk3.dim(`  Artifacts: ${path5.relative(cwd, hintsFile)}`));
+        } catch (err) {
+          llmSpinner.fail(chalk3.red(`LLM discovery failed: ${String(err)}`));
+        }
+      }
+    } else if (!opts.runtime) {
+      console.log(chalk3.dim("  Tip: add --llm --provider anthropic to get AI route hints"));
+    }
+    console.log("");
+  });
+}
+
+// src/tml.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+import path6 from "path";
+import fs4 from "fs/promises";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { crawl as crawl3 } from "@selfcure/crawler";
+import { analyze as analyze2, enrichTmlWithInventory, loadInventory as loadInventory2, enrichTmlWithRuntime, loadRuntimeMap } from "@selfcure/analyzer";
+import { reportTml } from "@selfcure/reporter";
+async function resolveConfig(cwd, provided) {
+  const names = provided ? [path6.resolve(cwd, provided)] : [path6.resolve(cwd, "selfcure.config.mjs"), path6.resolve(cwd, "selfcure.config.js")];
+  for (const p of names) {
+    const exists = await fs4.stat(p).then(() => true).catch(() => false);
+    if (exists) {
+      const mod = await import(`${pathToFileURL3(p).href}?t=${Date.now()}`);
+      return { config: mod.default, resolved: p };
+    }
+  }
+  throw new Error(`selfcure.config.mjs not found in ${cwd}. Run selfcure init first.`);
+}
+var TML_COLORS = {
+  0: chalk4.red,
+  1: chalk4.yellow,
+  2: chalk4.blue,
+  3: chalk4.cyan,
+  4: chalk4.green
+};
+function tmlBadge(level, label) {
+  const color = TML_COLORS[level];
+  return color(`[TML-${level}:${label}]`);
+}
+function tmlBadgeShort(level) {
+  return TML_COLORS[level](`TML-${level}`);
+}
+async function runTmlAnalysis(cwd, configPath, inventoryPath, runtimeMapPath) {
+  const { config } = await resolveConfig(cwd, configPath);
+  const rootDir = path6.resolve(cwd, String(config["rootDir"] ?? config["projectRoot"] ?? "."));
+  const include = config["include"] ?? ["**/*.tsx", "**/*.jsx"];
+  const exclude = config["exclude"] ?? [];
+  const framework = config["framework"];
+  const components = await crawl3({ rootDir, include, exclude, framework });
+  const results = await analyze2(components);
+  const invFile = inventoryPath ? path6.resolve(cwd, inventoryPath) : path6.join(cwd, ".selfcure", "testid-inventory.json");
+  const invResult = await loadInventory2(invFile).catch(() => null);
+  if (invResult?.ok) enrichTmlWithInventory(results, invResult.inventory);
+  const rtFile = runtimeMapPath ? path6.resolve(cwd, runtimeMapPath) : path6.join(cwd, ".selfcure", "route-map.json");
+  const rtMap = await loadRuntimeMap(rtFile).catch(() => null);
+  if (rtMap) enrichTmlWithRuntime(results, rtMap, invResult?.ok ? invResult.inventory : void 0);
+  return { results, rootDir };
+}
+function printDistribution(results, cwd, minimumLevel) {
+  const dist = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0 };
+  let total = 0;
+  for (const r of results) {
+    for (const el of r.interactiveElements) {
+      if (!el.tml) continue;
+      dist[el.tml.level]++;
+      total++;
+    }
+  }
+  if (total === 0) {
+    console.log(chalk4.dim("  No interactive elements found."));
+    return;
+  }
+  console.log("");
+  console.log(chalk4.bold("Tag Maturity Distribution"));
+  console.log("");
+  const LABELS = {
+    0: "unusable",
+    1: "fragile",
+    2: "usable",
+    3: "stable",
+    4: "governed"
+  };
+  for (const lvl of [4, 3, 2, 1, 0]) {
+    const cnt = dist[lvl];
+    if (cnt === 0 && lvl > 1) continue;
+    const bar = "\u2588".repeat(Math.round(cnt / total * 20));
+    const pct = Math.round(cnt / total * 100);
+    const color = TML_COLORS[lvl];
+    const flag = lvl < minimumLevel && cnt > 0 ? chalk4.red(" \u2190 below minimum") : "";
+    console.log(
+      `  ${color(`TML-${lvl}`)} ${LABELS[lvl].padEnd(9)} ${color(bar.padEnd(20))} ${String(cnt).padStart(4)} (${String(pct).padStart(3)}%)${flag}`
+    );
+  }
+  console.log("");
+  console.log(chalk4.dim(`  Total interactive elements: ${total}`));
+}
+function printElementList(results, cwd, minimumLevel) {
+  const flagged = [];
+  for (const r of results) {
+    const rel = path6.relative(cwd, r.component.filePath);
+    for (const el of r.interactiveElements) {
+      if (!el.tml || el.tml.level >= minimumLevel) continue;
+      flagged.push({
+        filePath: r.component.filePath,
+        rel,
+        elType: el.type,
+        selector: el.selector,
+        level: el.tml.level,
+        label: el.tml.label,
+        changes: el.tml.requiredChanges.slice(0, 2).map((c) => c.description)
+      });
+    }
+  }
+  if (flagged.length === 0) {
+    console.log(chalk4.green(`  \u2713 All elements meet TML-${minimumLevel} or above.`));
+    return;
+  }
+  console.log(chalk4.bold(`Elements below TML-${minimumLevel} (${flagged.length}):`));
+  console.log("");
+  const byFile = /* @__PURE__ */ new Map();
+  for (const f of flagged) {
+    if (!byFile.has(f.filePath)) byFile.set(f.filePath, []);
+    byFile.get(f.filePath).push(f);
+  }
+  for (const [, items] of byFile) {
+    console.log(chalk4.underline(items[0].rel));
+    for (const item of items) {
+      console.log(
+        `  ${tmlBadgeShort(item.level).padEnd(16)}  ${chalk4.cyan(item.elType.padEnd(8))}  ${chalk4.dim(item.selector.slice(0, 32).padEnd(32))}`
+      );
+      for (const change of item.changes) {
+        console.log(`    ${chalk4.dim("\u2192")} ${chalk4.dim(change)}`);
+      }
+    }
+    console.log("");
+  }
+}
+function registerTmlCommands(program2) {
+  const tml = program2.command("tml").description("Tag Maturity Level \u2014 testability governance");
+  tml.command("report").description("Generate HTML + JSON TML report at .selfcure/tml-report.html").option("--config <path>", "Path to selfcure.config.mjs").option("--inventory <path>", "Path to testid-inventory.json").option("--out <dir>", "Output directory", ".selfcure").option("--minimum <level>", "Minimum TML level for findings (0\u20134)", "2").action(async (opts) => {
+    const cwd = process.cwd();
+    const minLvl = Math.max(0, Math.min(4, parseInt(opts.minimum, 10) || 2));
+    const outDir = path6.resolve(cwd, opts.out);
+    const spinner = ora4("Generating TML report\u2026").start();
+    try {
+      const { results } = await runTmlAnalysis(cwd, opts.config, opts.inventory, opts.runtimeMap ?? void 0);
+      const summary = await reportTml(results, { outputDir: outDir, minimumLevel: minLvl });
+      spinner.stop();
+      console.log("");
+      console.log(chalk4.green(`  \u2713 Report written`));
+      console.log(chalk4.dim(`    ${path6.relative(cwd, path6.join(outDir, "tml-report.html"))}`));
+      console.log(chalk4.dim(`    ${path6.relative(cwd, path6.join(outDir, "tml-report.json"))}`));
+      console.log("");
+      console.log(chalk4.dim(`  Total: ${summary.totalElements}  Violations: ${summary.violations}  TML \u2265 ${minLvl}`));
+      console.log("");
+    } catch (err) {
+      spinner.fail(chalk4.red(String(err)));
+      process.exit(1);
+    }
+  });
+  tml.command("scan").description("Compute TML for all interactive elements and print a distribution summary").option("--config <path>", "Path to selfcure.config.mjs").option("--inventory <path>", "Path to testid-inventory.json (default: .selfcure/testid-inventory.json)").option("--runtime-map <path>", "Path to route-map.json from selfcure discover --runtime (default: .selfcure/route-map.json)").option("--minimum <level>", "Minimum acceptable TML level for display (0\u20134)", "2").action(async (opts) => {
+    const cwd = process.cwd();
+    const minLvl = Math.max(0, Math.min(4, parseInt(opts.minimum, 10) || 2));
+    const spinner = ora4("Computing Tag Maturity Levels\u2026").start();
+    try {
+      const { results } = await runTmlAnalysis(cwd, opts.config, opts.inventory, opts.runtimeMap);
+      spinner.stop();
+      console.log("");
+      printDistribution(results, cwd, minLvl);
+      printElementList(results, cwd, minLvl);
+    } catch (err) {
+      spinner.fail(chalk4.red(String(err)));
+      process.exit(1);
+    }
+  });
+  tml.command("audit").description("Fail (exit 1) when elements fall below the configured minimum TML level").option("--config <path>", "Path to selfcure.config.mjs").option("--inventory <path>", "Path to testid-inventory.json").option("--minimum-level <level>", "Minimum acceptable TML (default: 2)", "2").option("--critical-minimum <lvl>", "Stricter minimum for critical routes (default: same as --minimum-level)").option("--ci", "Machine-readable output; exit 1 on failures").action(async (opts) => {
+    const cwd = process.cwd();
+    const minLvl = Math.max(0, Math.min(4, parseInt(opts.minimumLevel, 10) || 2));
+    const spinner = opts.ci ? null : ora4("Running TML audit\u2026").start();
+    try {
+      const { results } = await runTmlAnalysis(cwd, opts.config, opts.inventory, opts.runtimeMap ?? void 0);
+      spinner?.stop();
+      let violations = 0;
+      let total = 0;
+      for (const r of results) {
+        for (const el of r.interactiveElements) {
+          if (!el.tml) continue;
+          total++;
+          if (el.tml.level < minLvl) violations++;
+        }
+      }
+      if (opts.ci) {
+        console.log(JSON.stringify({ total, violations, minimumLevel: minLvl, passed: violations === 0 }));
+      } else {
+        printDistribution(results, cwd, minLvl);
+        if (violations === 0) {
+          console.log(chalk4.green(`  \u2713 TML audit passed \u2014 all ${total} element(s) meet TML-${minLvl} or above.`));
+        } else {
+          printElementList(results, cwd, minLvl);
+          console.log(chalk4.red(`  \u2717 TML audit failed \u2014 ${violations}/${total} element(s) below TML-${minLvl}.`));
+        }
+      }
+      if (violations > 0) process.exit(1);
+    } catch (err) {
+      spinner?.fail(chalk4.red(String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/export.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+import path7 from "path";
+import fs5 from "fs/promises";
+import { pathToFileURL as pathToFileURL4 } from "url";
+import { exportSonarQube } from "@selfcure/reporter";
+import { extractTestIds as extractTestIds2 } from "@selfcure/crawler";
+import { loadInventory as loadInventory3, audit as audit2 } from "@selfcure/analyzer";
+var DEFAULT_OUT = ".selfcure/sonar-issues.json";
+var DEFAULT_TEST_GLOBS2 = ["**/*.{spec,test}.{ts,js,tsx,jsx}", "**/*.e2e.{ts,js}"];
+var DEFAULT_EXCLUDE3 = ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**"];
+function parseLocation(loc) {
+  if (!loc) return {};
+  const m = loc.match(/^(.*):(\d+)$/);
+  if (m) return { filePath: m[1], line: Number(m[2]) };
+  return { filePath: loc };
+}
+function registerExportCommand(program2) {
+  program2.command("export").description("Export findings in an external tool format (SonarQube Generic Issue Import Format)").requiredOption("--format <name>", 'output format \u2014 currently only "sonarqube"').option("-c, --config <path>", "path to selfcure.config.mjs", "./selfcure.config.mjs").option("--out <path>", "output file", DEFAULT_OUT).option("--threshold <n>", "testability score below which an element is flagged", "65").option("--a11y", "include WCAG accessibility findings", false).option("--wcag <level>", "WCAG target level when using --a11y: A, AA, or AAA", "AA").option("--base-dir <dir>", "sonar.projectBaseDir \u2014 filePaths are made relative to it", "").option("--inventory <path>", "testid-inventory.json \u2014 include missing-testid (orphaned contract) issues").action(async (opts) => {
+    if (opts.format !== "sonarqube") {
+      console.error(chalk5.red(`Unsupported format "${opts.format}". Currently only "sonarqube" is supported.`));
+      process.exit(1);
+    }
+    const spinner = ora5("Analysing source files\u2026").start();
+    try {
+      const configPath = path7.resolve(opts.config);
+      const exists = await fs5.stat(configPath).then(() => true).catch(() => false);
+      if (!exists) {
+        spinner.fail(chalk5.red(`Config not found: ${opts.config}`));
+        process.exit(1);
+      }
+      const { default: config } = await import(pathToFileURL4(configPath).href);
+      const threshold = Number(opts.threshold ?? 65);
+      const wcag = opts.wcag ?? "AA";
+      const baseDir = opts.baseDir ? path7.resolve(opts.baseDir) : process.cwd();
+      const issues = [];
+      const summary = await runLint(config, {
+        threshold,
+        fix: false,
+        pr: false,
+        a11y: opts.a11y,
+        wcag
+      });
+      for (const issue of summary.issues) {
+        issues.push({
+          kind: issue.kind,
+          // 'ambiguous' | 'low-score'
+          filePath: issue.filePath,
+          message: issue.kind === "ambiguous" ? `Ambiguous selector "${issue.element.selector}" in ${issue.componentName} \u2014 ${(issue.ambiguityReason ?? "matches multiple elements").replace(/\.\s*$/, "")}. Add a unique data-testid="${issue.suggestedTestId}".` : `Low testability (score ${issue.element.testabilityScore}/100) for ${issue.element.type} in ${issue.componentName}. Add data-testid="${issue.suggestedTestId}".`
+        });
+      }
+      for (const f of summary.a11yFindings ?? []) {
+        issues.push({
+          kind: "a11y-violation",
+          filePath: f.sourceFile,
+          line: f.line,
+          wcagLevel: f.level,
+          ruleId: f.ruleId,
+          message: `${f.message} (WCAG ${f.level}: ${f.wcag.join(", ")}). ${f.remediation}`
+        });
+      }
+      if (opts.inventory) {
+        const inv = await loadInventory3(path7.resolve(opts.inventory));
+        if (!inv.ok) {
+          spinner.warn(chalk5.yellow(`Skipping --inventory: failed to load ${opts.inventory}`));
+        } else {
+          const rootDir = config.rootDir ? path7.resolve(config.rootDir) : process.cwd();
+          const { usages } = await extractTestIds2({
+            rootDir,
+            sourceGlobs: config.include ?? ["**/*.{tsx,jsx,ts,js,vue,html}"],
+            testGlobs: DEFAULT_TEST_GLOBS2,
+            exclude: config.exclude ?? DEFAULT_EXCLUDE3
+          });
+          const { issues: auditIssues } = audit2(inv.inventory, usages);
+          for (const ai of auditIssues.filter((i) => i.rule === "orphaned-inventory")) {
+            const loc = parseLocation(ai.locations?.[0]);
+            issues.push({
+              kind: "missing-testid",
+              filePath: loc.filePath ?? path7.resolve(opts.inventory),
+              line: loc.line,
+              message: ai.message ?? `data-testid="${ai.testId}" is in the inventory but missing from source.`
+            });
+          }
+        }
+      }
+      const report = await exportSonarQube(issues, opts.out, { projectBaseDir: baseDir });
+      spinner.stop();
+      console.log("");
+      console.log(chalk5.green.bold(`\u2714 SonarQube report written \u2014 ${report.issues.length} issue(s)`));
+      console.log(chalk5.dim(`  ${path7.relative(process.cwd(), path7.resolve(opts.out))}`));
+      console.log("");
+      console.log(chalk5.dim("  Point SonarQube at it with:"));
+      console.log(chalk5.dim(`    sonar.externalIssuesReportPaths=${opts.out}`));
+      console.log("");
+    } catch (err) {
+      spinner.fail(chalk5.red(String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+import { startWebServer } from "@selfcure/web";
+import { crawl as crawl4 } from "@selfcure/crawler";
+import { buildIdePrompt } from "@selfcure/analyzer";
+async function resolveConfigPath(provided) {
+  const DEFAULT = "./selfcure.config.mjs";
+  const LEGACY = "./selfcure.config.js";
+  if (provided !== DEFAULT) {
+    return path8.resolve(provided);
+  }
+  const mjs = path8.resolve(DEFAULT);
+  const js = path8.resolve(LEGACY);
+  const mjsExists = await fs6.stat(mjs).then(() => true).catch(() => false);
+  if (mjsExists) return mjs;
+  const jsExists = await fs6.stat(js).then(() => true).catch(() => false);
+  if (jsExists) return js;
+  return mjs;
+}
+var program = new Command();
+program.name("selfcure").description("AI-powered self-healing Playwright test CLI").version("0.1.0");
+program.command("init").description("Scaffold selfcure.config.mjs in the current project").action(async () => {
+  try {
+    await runInitWizard(process.cwd());
+  } catch (err) {
+    console.error(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("crawl [file]").description("Crawl source files and extract component metadata").option("-c, --config <path>", "path to selfcure.config.mjs (falls back to selfcure.config.js)", "./selfcure.config.mjs").action(async (file, opts) => {
+  const spinner = ora6("Crawling source files\u2026").start();
+  try {
+    const configPath = await resolveConfigPath(opts.config);
+    const configUrl = pathToFileURL5(configPath).href;
+    const { default: config } = await import(configUrl);
+    let components;
+    if (file) {
+      const abs = path8.resolve(file);
+      const stat2 = await fs6.stat(abs).catch(() => null);
+      if (!stat2) {
+        throw new Error(`Path not found: ${file}`);
+      }
+      if (stat2.isDirectory()) {
+        components = await crawl4({
+          rootDir: abs,
+          include: config.include,
+          exclude: config.exclude,
+          framework: config.framework
+        });
+      } else {
+        components = await crawl4({
+          rootDir: path8.dirname(abs),
+          include: [path8.basename(abs)],
+          exclude: [],
+          framework: config.framework
+        });
+      }
+    } else {
+      components = await crawl4({
+        rootDir: config.rootDir,
+        include: config.include,
+        exclude: config.exclude,
+        framework: config.framework
+      });
+    }
+    spinner.succeed(chalk6.green(`Crawl complete \u2014 ${components.length} component(s) found`));
+    for (const c of components) {
+      const propsInfo = c.props.length ? chalk6.dim(` (${c.props.length} prop${c.props.length > 1 ? "s" : ""}: ${c.props.map((p) => p.name).join(", ")})`) : "";
+      console.log(chalk6.dim(`  ${c.framework}  ${chalk6.white(c.componentName)}  \u2192  ${c.filePath}${propsInfo}`));
+    }
+  } catch (err) {
+    spinner.fail(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("run").description("Generate tests, run them, and self-heal failures automatically").option("-c, --config <path>", "path to selfcure.config.mjs (falls back to selfcure.config.js)", "./selfcure.config.mjs").action(async (_opts) => {
+  const spinner = ora6("Running selfcure pipeline\u2026").start();
+  try {
+    spinner.succeed(chalk6.green("Pipeline complete"));
+  } catch (err) {
+    spinner.fail(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("heal").description("Attempt to heal failing tests without re-generating the full suite").option("-c, --config <path>", "path to selfcure.config.mjs (falls back to selfcure.config.js)", "./selfcure.config.mjs").action(async (_opts) => {
+  const spinner = ora6("Healing failing tests\u2026").start();
+  try {
+    spinner.succeed(chalk6.green("Healing complete"));
+  } catch (err) {
+    spinner.fail(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("report").description("Generate HTML report from the last run results").option("-c, --config <path>", "path to selfcure.config.mjs (falls back to selfcure.config.js)", "./selfcure.config.mjs").action(async (_opts) => {
+  const spinner = ora6("Generating report\u2026").start();
+  try {
+    spinner.succeed(chalk6.green("Report generated"));
+  } catch (err) {
+    spinner.fail(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("lint").description("[Pro] Lint source files for unstable test selectors and suggest data-testid patches").option("-c, --config <path>", "path to selfcure.config.mjs (falls back to selfcure.config.js)", "./selfcure.config.mjs").option("--threshold <n>", "testability score below which an element is flagged", "65").option("--fix", "[Pro] apply data-testid patches to source files automatically").option("--pr", "[Pro] create a GitHub PR with the applied fixes (requires --fix)").option("--a11y", "[Pro] also run WCAG accessibility lint alongside testability").option("--wcag <level>", "WCAG target level when using --a11y: A, AA, or AAA", "AA").option("--prompt", "print a paste-ready prompt for your IDE AI agent (Copilot/Cursor) instead of the report \u2014 no API key needed").action(async (opts) => {
+  const spinner = ora6("Analysing source files\u2026").start();
+  try {
+    const configPath = await resolveConfigPath(opts.config);
+    const configUrl = pathToFileURL5(configPath).href;
+    const { default: config } = await import(configUrl);
+    const threshold = Number(opts.threshold ?? 65);
+    const isPro = config.pro === true || process.env["SELFCURE_PRO"] === "1";
+    if ((opts.fix || opts.pr) && !isPro) {
+      spinner.stop();
+      console.log("");
+      console.log(chalk6.bold.yellow("\u2726 Pro feature"));
+      console.log(chalk6.dim("  --fix and --pr are available on the Pro plan and above."));
+      console.log(chalk6.dim("  Enable Pro by setting SELFCURE_PRO=1 or pro: true in your config."));
+      console.log("");
+    }
+    const fix = opts.fix && isPro;
+    const pr = opts.pr && isPro && fix;
+    const a11y = Boolean(opts.a11y);
+    const summary = await runLint(config, { threshold, fix, pr, a11y, wcag: opts.wcag });
+    spinner.stop();
+    const { issues, totalFiles, fixedCount, skippedCount, prUrl, a11yFindings } = summary;
+    if (opts.prompt) {
+      if (issues.length === 0) {
+        console.error(chalk6.green(`No issues \u2014 nothing to fix (${totalFiles} file(s) scanned).`));
+        return;
+      }
+      const promptIssues = issues.map((i) => ({
+        filePath: i.filePath,
+        componentName: i.componentName,
+        elementType: i.element.type,
+        selector: i.element.selector,
+        kind: i.kind,
+        ambiguityReason: i.ambiguityReason,
+        suggestedTestId: i.suggestedTestId
+      }));
+      console.log(buildIdePrompt(promptIssues, { baseDir: process.cwd() }));
+      return;
+    }
+    console.log("");
+    if (issues.length === 0 && (!a11yFindings || a11yFindings.length === 0)) {
+      console.log(chalk6.green.bold("\u2714 selfcure lint \u2014 no issues found"));
+      console.log(chalk6.dim(`  ${totalFiles} file(s) scanned \u2014 all elements have a testability score \u2265 ${threshold}`));
+      if (a11yFindings) {
+        console.log(chalk6.dim(`  WCAG ${opts.wcag ?? "AA"} \u2014 0 accessibility issues`));
+      }
+      return;
+    }
+    console.log(
+      chalk6.bold(`selfcure lint \u2014 ${chalk6.yellow(issues.length)} issue(s) across `) + chalk6.bold(`${[...new Set(issues.map((i) => i.filePath))].length} file(s)`) + chalk6.dim(` \xB7 threshold: ${threshold}/100`)
+    );
+    console.log("");
+    const byFile = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      if (!byFile.has(issue.filePath)) byFile.set(issue.filePath, []);
+      byFile.get(issue.filePath).push(issue);
+    }
+    for (const [filePath, fileIssues] of byFile) {
+      console.log(chalk6.underline(path8.relative(process.cwd(), filePath)));
+      for (const issue of fileIssues) {
+        const score = issue.element.testabilityScore;
+        const scoreTxt = score >= 50 ? chalk6.yellow(`score: ${score}`) : chalk6.red(`score: ${score}`);
+        const fixTxt = issue.fixApplied ? chalk6.green(" \u2714 patched") : chalk6.dim(` \u2192 add data-testid="${issue.suggestedTestId}"`);
+        const tml = issue.element.tml;
+        const tmlTxt = tml ? "  " + tmlBadge(tml.level, tml.label) : "";
+        console.log(
+          `  ${chalk6.cyan(issue.element.type.padEnd(8))}  ${chalk6.dim(issue.element.selector.padEnd(30))}  ${scoreTxt}${tmlTxt}` + fixTxt
+        );
+      }
+      console.log("");
+    }
+    if (a11yFindings && a11yFindings.length > 0) {
+      console.log(chalk6.dim("\u2500".repeat(60)));
+      console.log("");
+      printA11ySection(a11yFindings, {
+        isPro,
+        wcagLevel: opts.wcag ?? "AA",
+        cwd: process.cwd()
+      });
+    }
+    if (fix) {
+      if (fixedCount > 0) {
+        console.log(chalk6.green(`\u2714 ${fixedCount} element(s) patched`) + (skippedCount > 0 ? chalk6.dim(` \xB7 ${skippedCount} skipped (no unique identifier found)`) : ""));
+      }
+      if (prUrl) {
+        console.log(chalk6.bold.green(`\u2714 PR opened: ${prUrl}`));
+      } else if (pr) {
+        console.log(chalk6.yellow("  PR creation skipped (no files changed)."));
+      }
+    } else if (!isPro) {
+      console.log(chalk6.bold.yellow("\u2726 Run with --fix to auto-patch source files  (Pro)"));
+      console.log(chalk6.bold.yellow("\u2726 Run with --fix --pr to open a GitHub PR   (Pro)"));
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(chalk6.red(String(err)));
+    process.exit(1);
+  }
+});
+program.command("mcp").description("Start the selfcure MCP server on stdio (consumable by Claude Desktop, Cursor, VS Code, etc.)").action(async () => {
+  await import("@selfcure/mcp");
+});
+program.command("web").description("Open the selfcure dashboard in the browser (zero-config: discover, crawl, lint, TML \u2014 all from the UI)").option("-p, --port <number>", "port to listen on", "3333").option("--no-open", "don't auto-open the browser").action((opts) => {
+  const port = Number(opts.port);
+  startWebServer(port, process.cwd(), { openBrowser: opts.open !== false });
+});
+program.command("stop").description("Kill any selfcure web server running on the given port").option("-p, --port <number>", "port to kill", "3333").action((opts) => {
+  const port = Number(opts.port);
+  try {
+    if (process.platform === "win32") {
+      execSync3(
+        `powershell -NonInteractive -Command "Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess | Sort-Object -Unique | ForEach-Object { Stop-Process -Id $_ -Force -ErrorAction SilentlyContinue }"`,
+        { stdio: "inherit" }
+      );
+    } else {
+      execSync3(`lsof -ti :${port} | xargs kill -9`, { stdio: "inherit" });
+    }
+    console.log(chalk6.green(`Port ${port} cleared.`));
+  } catch {
+    console.log(chalk6.yellow(`No process found on port ${port}.`));
+  }
+});
+registerDiscoverCommand(program);
+registerTmlCommands(program);
+registerTestIdsCommands(program);
+registerA11yCommands(program);
+registerExportCommand(program);
+program.parse();