ai-diff-check 1.0.0

package/dist/chunk-7JKSFHII.js

@@ -0,0 +1,1525 @@
+// src/git/diff.ts
+import { execFileSync } from "child_process";
+var NotAGitRepoError = class extends Error {
+  constructor() {
+    super("Not a git repository \u2014 run ai-diff-check inside a repo.");
+  }
+};
+function git(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}
+function findRepoRoot(cwd) {
+  try {
+    return git(["rev-parse", "--show-toplevel"], cwd).trim();
+  } catch {
+    throw new NotAGitRepoError();
+  }
+}
+function resolveBaseRef(repoRoot, explicit) {
+  if (explicit) return explicit;
+  for (const ref of ["main", "master", "origin/main", "origin/master"]) {
+    try {
+      git(["rev-parse", "--verify", "--quiet", ref], repoRoot);
+      return ref;
+    } catch {
+    }
+  }
+  const root = git(["rev-list", "--max-parents=0", "HEAD"], repoRoot).trim().split("\n")[0];
+  if (!root) throw new Error("Could not resolve a base ref \u2014 pass one with --base.");
+  return root;
+}
+function getChangedFiles(repoRoot, baseRef) {
+  const raw = git(["diff", "--no-color", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/", baseRef, "--"], repoRoot);
+  return parseUnifiedDiff(raw);
+}
+function parseUnifiedDiff(raw) {
+  const files = [];
+  let current = null;
+  let oldLine = 0;
+  let newLine = 0;
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      current = { path: "", added: /* @__PURE__ */ new Map(), removed: /* @__PURE__ */ new Map(), status: "modified" };
+      files.push(current);
+    } else if (current && line.startsWith("--- ")) {
+      if (line.includes("/dev/null")) current.status = "added";
+      else if (line.startsWith("--- a/")) current.path = line.slice("--- a/".length);
+    } else if (current && line.startsWith("+++ ")) {
+      if (line.includes("/dev/null")) current.status = "deleted";
+      else current.path = line.slice("+++ b/".length);
+    } else if (current && line.startsWith("@@")) {
+      const m = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+      if (m) {
+        oldLine = Number(m[1]);
+        newLine = Number(m[2]);
+      }
+    } else if (current && line.startsWith("+")) {
+      current.added.set(newLine++, line.slice(1));
+    } else if (current && line.startsWith("-")) {
+      current.removed.set(oldLine++, line.slice(1));
+    }
+  }
+  return files.filter((f) => f.path !== "");
+}
+function diffStats(files) {
+  return {
+    files: files.length,
+    added: files.reduce((n, f) => n + f.added.size, 0),
+    removed: files.reduce((n, f) => n + f.removed.size, 0)
+  };
+}
+
+// src/report/terminal.ts
+import pc from "picocolors";
+var SEVERITY_ORDER = { error: 0, warn: 1, info: 2 };
+function sortFindings(findings) {
+  return [...findings].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+}
+function renderHeader(version, baseRef) {
+  return `
+  ${pc.bold(pc.yellow("ai-diff-check"))} ${pc.dim(`v${version} \u2014 reviewing working tree vs ${baseRef}`)}
+`;
+}
+function renderDiffLine(stats, elapsedMs) {
+  const files = `${stats.files} file${stats.files === 1 ? "" : "s"}`;
+  return `  ${pc.green("\u2713")} ${pc.dim("parsed diff")}        ${files} \xB7 +${stats.added.toLocaleString()} \u2212${stats.removed.toLocaleString()} ${pc.dim(`(${(elapsedMs / 1e3).toFixed(1)}s)`)}`;
+}
+function renderFindings(findings) {
+  const blocks = sortFindings(findings).map((f) => {
+    const mark = f.severity === "error" ? pc.red("\u2716") : f.severity === "warn" ? pc.yellow("\u26A0") : pc.cyan("\u2139");
+    const color = f.severity === "error" ? pc.red : f.severity === "warn" ? pc.yellow : pc.cyan;
+    const badge = color(pc.bold(f.check.toUpperCase()));
+    const loc = pc.dim(f.line ? `${f.file}:${f.line}` : f.file);
+    const fix = f.fix ? `
+    ${pc.dim("\u2192")} ${f.fix}` : "";
+    return `  ${mark} ${badge} ${pc.dim(`[${f.id}]`)}
+    ${loc}  ${f.message}${fix}`;
+  });
+  return blocks.join("\n\n");
+}
+function renderSummary(findings, stats, elapsedMs) {
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warns = findings.filter((f) => f.severity === "warn").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  const score = trustScore(findings, stats);
+  const scoreColor = score >= 80 ? pc.green : score >= 50 ? pc.yellow : pc.red;
+  const parts = [
+    `Diff trust score:  ${scoreColor(pc.bold(`${score}/100`))}`,
+    errors ? pc.red(pc.bold(`\u2716 ${errors} error${errors === 1 ? "" : "s"}`)) : pc.green("no errors"),
+    warns ? pc.yellow(`\u26A0 ${warns} warning${warns === 1 ? "" : "s"}`) : "",
+    infos ? pc.cyan(`\u2139 ${infos} note${infos === 1 ? "" : "s"}`) : "",
+    pc.dim(`${stats.files} files \xB7 ${(elapsedMs / 1e3).toFixed(1)}s`)
+  ].filter(Boolean);
+  return `
+  ${pc.dim("\u2500".repeat(56))}
+  ${parts.join("   ")}
+`;
+}
+function trustScore(findings, _stats) {
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warns = findings.filter((f) => f.severity === "warn").length;
+  return Math.max(0, 100 - errors * 18 - warns * 6);
+}
+
+// src/report/ci.ts
+var escapeData = (s) => s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+var escapeProp = (s) => escapeData(s).replace(/:/g, "%3A").replace(/,/g, "%2C");
+var COMMAND = { error: "error", warn: "warning", info: "notice" };
+function githubAnnotations(findings) {
+  return findings.map((f) => {
+    const props = [`file=${escapeProp(f.file)}`];
+    if (f.line !== void 0) props.push(`line=${f.line}`);
+    props.push(`title=${escapeProp(`${f.check.toUpperCase()} [${f.id}]`)}`);
+    const message = f.fix !== void 0 ? `${f.message} \u2192 ${f.fix}` : f.message;
+    return `::${COMMAND[f.severity]} ${props.join(",")}::${escapeData(message)}`;
+  });
+}
+
+// src/report/fix-prompt.ts
+function renderFixPrompt(findings) {
+  if (findings.length === 0) return "The diff is clean \u2014 nothing to fix.";
+  const lines = [
+    "Your last change failed its automated review (ai-diff-check). Fix ONLY the issues below.",
+    "Do not refactor unrelated code, do not add dependencies, do not delete tests to make checks pass.",
+    ""
+  ];
+  sortFindings(findings).forEach((f, i) => {
+    const loc = f.line !== void 0 ? `${f.file}:${f.line}` : f.file;
+    lines.push(`${i + 1}. [${f.severity}] ${loc} \u2014 ${f.message}`);
+    if (f.fix !== void 0) lines.push(`   Required fix: ${f.fix}`);
+  });
+  lines.push("");
+  lines.push("When done, run `ai-diff-check` \u2014 it must report no errors.");
+  return lines.join("\n");
+}
+
+// src/checks/util.ts
+import { readdirSync } from "fs";
+import { join, relative, sep } from "path";
+var CODE_FILE = /\.(?:ts|tsx|js|jsx|mts|cts|mjs|cjs)$/;
+var TEST_FILE = /(?:[._](?:test|spec)\.[cm]?[jt]sx?$|__tests__\/)/;
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage", "vendor"]);
+function walkCodeFiles(repoRoot) {
+  const found = [];
+  const stack = [repoRoot];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) stack.push(join(dir, entry.name));
+      } else if (entry.isFile() && CODE_FILE.test(entry.name)) {
+        found.push(relative(repoRoot, join(dir, entry.name)).split(sep).join("/"));
+      }
+    }
+  }
+  return found;
+}
+var DECL_RES = [
+  /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s+([A-Za-z_$][\w$]*)/,
+  /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/,
+  /^(?:export\s+)?const\s+([A-Za-z_$][\w$]*)[^=]*=\s*(?:async\s+)?(?:\(|function\b|[A-Za-z_$][\w$]*\s*=>)/
+];
+function scanTopLevelDecls(lines) {
+  const decls = [];
+  lines.forEach((text, i) => {
+    for (let p = 0; p < DECL_RES.length; p++) {
+      const name = DECL_RES[p].exec(text)?.[1];
+      if (name) {
+        decls.push({ name, line: i + 1, isClass: p === 1 });
+        break;
+      }
+    }
+  });
+  return decls;
+}
+function declSpan(lines, decl, decls) {
+  const next = decls.find((d) => d.line > decl.line)?.line ?? lines.length + 1;
+  for (let i = decl.line; i < lines.length && i + 1 < next; i++) {
+    if (/^[}\])]/.test(lines[i])) return { start: decl.line, end: i + 1 };
+  }
+  return { start: decl.line, end: next - 1 };
+}
+function shingles(tokens, k) {
+  const set = /* @__PURE__ */ new Set();
+  for (let i = 0; i + k <= tokens.length; i++) {
+    set.add(tokens.slice(i, i + k).join("\0"));
+  }
+  return set;
+}
+function jaccard(a, b) {
+  const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+  let intersection = 0;
+  for (const s of small) if (large.has(s)) intersection++;
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function stableId(prefix, key) {
+  let h = 5381;
+  for (let i = 0; i < key.length; i++) {
+    h = (h << 5) + h + key.charCodeAt(i) >>> 0;
+  }
+  return `${prefix}-${100 + h % 900}`;
+}
+
+// src/checks/stub.ts
+var MARK_A = "TODO";
+var MARK_B = "FIXME";
+var MARKER = new RegExp(`(?://|/\\*|\\*|#).*\\b(?:${MARK_A}|${MARK_B})\\b`);
+var MARKER_TOKEN = new RegExp(`\\b(${MARK_A}|${MARK_B})\\b`);
+var LINE_RULES = [
+  {
+    kind: "console",
+    match: /\bconsole\.(?:log|debug)\s*\(/,
+    message: () => "Leftover debug logging in new code",
+    fix: "remove the log or route it through your logger"
+  },
+  {
+    kind: "marker",
+    match: MARKER,
+    message: (line) => `Unresolved ${MARKER_TOKEN.exec(line)?.[1] ?? "task"} marker left in new code`,
+    fix: "resolve it, or track it in an issue before merging"
+  },
+  {
+    kind: "not-implemented",
+    match: /throw\s+new\s+\w*Error\s*\(\s*['"`][^'"`]*not[\s_-]?implemented/i,
+    message: () => 'Stubbed "not implemented" throw shipped in the diff',
+    fix: "implement the path or remove the dead branch"
+  },
+  {
+    // Single-line empty catch: `catch (e) {}`.
+    kind: "empty-catch",
+    match: /catch\s*(?:\([^)]*\))?\s*\{\s*\}/,
+    message: () => "Empty catch block silently swallows the error",
+    fix: "handle the error or at least log it \u2014 don't swallow it"
+  }
+];
+var EMPTY_CATCH_RULE = LINE_RULES[LINE_RULES.length - 1];
+var CATCH_OPEN = /catch\s*(?:\([^)]*\))?\s*\{\s*$/;
+var BARE_CLOSE = /^\s*\}\s*;?\s*$/;
+var stubCheck = {
+  name: "stub",
+  async run(ctx) {
+    const findings = [];
+    const seen = /* @__PURE__ */ new Map();
+    const push = (path, line, rule, text) => {
+      const snippet2 = text.trim();
+      const key = `${path}:${rule.kind}:${snippet2}`;
+      const occ = seen.get(key) ?? 0;
+      seen.set(key, occ + 1);
+      findings.push({
+        id: stableId("STUB", occ === 0 ? key : `${key}#${occ}`),
+        check: "stub",
+        severity: "warn",
+        file: path,
+        line,
+        message: rule.message(text),
+        fix: rule.fix
+      });
+    };
+    for (const file of ctx.files) {
+      const added = [...file.added.entries()].sort((a, b) => a[0] - b[0]);
+      for (const [lineNo, text] of added) {
+        if (CATCH_OPEN.test(text)) {
+          const next = file.added.get(lineNo + 1);
+          if (next !== void 0 && BARE_CLOSE.test(next)) {
+            push(file.path, lineNo, EMPTY_CATCH_RULE, text);
+            continue;
+          }
+        }
+        for (const rule of LINE_RULES) {
+          if (rule.match.test(text)) {
+            push(file.path, lineNo, rule, text);
+            break;
+          }
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// src/checks/oversize.ts
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+var JSX_FILE = /\.(?:tsx|jsx)$/;
+var REGROWTH_LINES = 50;
+var MIN_ADDED_IN_COMPONENT = 10;
+function countLines(content) {
+  const parts = content.split("\n");
+  return parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
+}
+function declLabel(d, isJsx) {
+  if (d.isClass) return d.name;
+  if (/^use[A-Z]/.test(d.name)) return `${d.name} (hook)`;
+  if (isJsx && /^[A-Z]/.test(d.name)) return `<${d.name}>`;
+  return d.name;
+}
+function proposeFileSplit(decls, isJsx) {
+  if (decls.length < 2) return "split components, hooks, and utils into their own modules";
+  const names = decls.slice(0, 4).map((d) => declLabel(d, isJsx));
+  const more = decls.length - 4;
+  return `split it up \u2014 ${names.join(", ")}${more > 0 ? ` (+${more} more)` : ""} can each live in their own module`;
+}
+var INNER_DECL = /^\s+(?:const|function)\s+([a-z_$][\w$]*)\s*[=(]/;
+function proposeComponentSplit(name, lines, span) {
+  const inner = [];
+  for (let i = span.start; i < span.end && inner.length < 3; i++) {
+    const m = INNER_DECL.exec(lines[i]);
+    if (m?.[1]) inner.push(m[1]);
+  }
+  return inner.length > 0 ? `extract pieces of <${name}> into hooks/subcomponents \u2014 e.g. ${inner.join(", ")}` : `break <${name}> into smaller subcomponents or hooks`;
+}
+function fileFinding(file, total, before, limit, fix) {
+  const message = file.status === "added" ? `New file is ${total} lines (limit ${limit})` : `File grew from ${before} to ${total} lines (limit ${limit})`;
+  return {
+    id: stableId("OVERSIZE", `${file.path}:file`),
+    check: "oversize",
+    severity: "warn",
+    file: file.path,
+    message,
+    fix
+  };
+}
+var oversizeCheck = {
+  name: "oversize",
+  async run(ctx) {
+    const findings = [];
+    for (const file of ctx.files) {
+      if (file.status === "deleted" || !CODE_FILE.test(file.path)) continue;
+      let content;
+      try {
+        content = readFileSync(join2(ctx.repoRoot, file.path), "utf8");
+      } catch {
+        continue;
+      }
+      const lines = content.split("\n");
+      const total = countLines(content);
+      const netGrowth = file.added.size - file.removed.size;
+      const before = total - netGrowth;
+      const isJsx = JSX_FILE.test(file.path);
+      const decls = scanTopLevelDecls(lines);
+      const fileLimit = ctx.config.maxFileLines;
+      const crossedLimit = before <= fileLimit && total > fileLimit;
+      const keptGrowing = before > fileLimit && netGrowth >= REGROWTH_LINES;
+      if (total > fileLimit && (crossedLimit || keptGrowing)) {
+        findings.push(fileFinding(file, total, before, fileLimit, proposeFileSplit(decls, isJsx)));
+        continue;
+      }
+      if (!isJsx) continue;
+      const compLimit = ctx.config.maxComponentLines;
+      for (const decl of decls) {
+        if (decl.isClass || !/^[A-Z]/.test(decl.name)) continue;
+        const span = declSpan(lines, decl, decls);
+        const size = span.end - span.start + 1;
+        if (size <= compLimit) continue;
+        let addedInside = 0;
+        for (const n of file.added.keys()) {
+          if (n >= span.start && n <= span.end) addedInside++;
+        }
+        if (addedInside < MIN_ADDED_IN_COMPONENT) continue;
+        findings.push({
+          id: stableId("OVERSIZE", `${file.path}:${decl.name}`),
+          check: "oversize",
+          severity: "warn",
+          file: file.path,
+          line: decl.line,
+          message: `<${decl.name}> is ${size} lines (limit ${compLimit})`,
+          fix: proposeComponentSplit(decl.name, lines, span)
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/checks/phantom-dep.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { builtinModules } from "module";
+var BUILTINS = new Set(builtinModules);
+var MAX_REGISTRY_LOOKUPS = 15;
+var REGISTRY_TIMEOUT_MS = 3e3;
+var IMPORT_PATTERNS = [
+  /^\s*(?:import|export)\b[^'"]*\bfrom\s+['"]([^'"]+)['"]/,
+  // import x from 'p' / export { x } from 'p'
+  /^\s*[}\])][^'"]*\bfrom\s+['"]([^'"]+)['"]/,
+  // closing line of a multi-line import
+  /^\s*import\s+['"]([^'"]+)['"]/,
+  // side-effect import
+  /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/,
+  // CJS
+  /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/
+  // dynamic import
+];
+function extractSpecifier(line) {
+  for (const re of IMPORT_PATTERNS) {
+    const name = re.exec(line)?.[1];
+    if (name) return name;
+  }
+  return null;
+}
+function packageName(spec) {
+  if (/^[./#~]/.test(spec)) return null;
+  if (spec.startsWith("node:")) return null;
+  const parts = spec.split("/");
+  const name = spec.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null : parts[0];
+  if (!name || BUILTINS.has(name)) return null;
+  if (!/^(@[a-z0-9~][\w.~-]*\/)?[a-z0-9~][a-z0-9._~-]*$/.test(name)) return null;
+  return name;
+}
+function typesPackage(name) {
+  return name.startsWith("@") ? `@types/${name.slice(1).replace("/", "__")}` : `@types/${name}`;
+}
+function loadTsconfigAliases(repoRoot) {
+  const aliases = { exact: /* @__PURE__ */ new Set(), prefixes: [] };
+  let raw;
+  try {
+    raw = readFileSync2(join3(repoRoot, "tsconfig.json"), "utf8");
+  } catch {
+    return aliases;
+  }
+  try {
+    const jsonc = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
+    const paths = JSON.parse(jsonc)?.compilerOptions?.paths;
+    if (paths && typeof paths === "object") {
+      for (const key of Object.keys(paths)) {
+        if (key.endsWith("*")) aliases.prefixes.push(key.slice(0, -1));
+        else aliases.exact.add(key);
+      }
+    }
+  } catch {
+  }
+  return aliases;
+}
+function isAliased(spec, aliases) {
+  return aliases.exact.has(spec) || aliases.prefixes.some((p) => spec.startsWith(p));
+}
+function readManifest(dir, cache) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) return cached;
+  let result = null;
+  try {
+    const pkg = JSON.parse(readFileSync2(join3(dir, "package.json"), "utf8"));
+    result = /* @__PURE__ */ new Set();
+    if (typeof pkg["name"] === "string") result.add(pkg["name"]);
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const deps = pkg[field];
+      if (deps && typeof deps === "object") for (const key of Object.keys(deps)) result.add(key);
+    }
+  } catch {
+    result = null;
+  }
+  cache.set(dir, result);
+  return result;
+}
+function collectDeclared(repoRoot, relPath, cache) {
+  const declared = /* @__PURE__ */ new Set();
+  let manifests = 0;
+  let dir = dirname(join3(repoRoot, relPath));
+  for (; ; ) {
+    const manifest = readManifest(dir, cache);
+    if (manifest) {
+      manifests++;
+      for (const name of manifest) declared.add(name);
+    }
+    if (dir === repoRoot) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { declared, manifests };
+}
+async function checkRegistry(name) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${name.replace("/", "%2F")}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS)
+    });
+    if (res.status === 404) return "missing";
+    if (res.ok) return "exists";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var phantomDepCheck = {
+  name: "phantom-dep",
+  async run(ctx) {
+    const manifestCache = /* @__PURE__ */ new Map();
+    const aliases = loadTsconfigAliases(ctx.repoRoot);
+    const undeclared = /* @__PURE__ */ new Map();
+    for (const file of ctx.files) {
+      if (file.status === "deleted" || !CODE_FILE.test(file.path)) continue;
+      const { declared, manifests } = collectDeclared(ctx.repoRoot, file.path, manifestCache);
+      if (manifests === 0) continue;
+      for (const [lineNo, text] of [...file.added.entries()].sort((a, b) => a[0] - b[0])) {
+        const trimmed = text.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+        const spec = extractSpecifier(text);
+        if (!spec || isAliased(spec, aliases)) continue;
+        const name = packageName(spec);
+        if (!name || declared.has(name) || declared.has(typesPackage(name))) continue;
+        if (existsSync(join3(ctx.repoRoot, spec.split("/")[0]))) continue;
+        const seen = undeclared.get(name);
+        if (seen) seen.count++;
+        else undeclared.set(name, { file: file.path, line: lineNo, count: 1 });
+      }
+    }
+    const verdicts = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...undeclared.keys()].slice(0, MAX_REGISTRY_LOOKUPS).map(async (name) => {
+        verdicts.set(name, await checkRegistry(name));
+      })
+    );
+    const findings = [];
+    for (const [name, occ] of undeclared) {
+      const verdict = verdicts.get(name) ?? "unknown";
+      const more = occ.count > 1 ? ` (and ${occ.count - 1} more place${occ.count > 2 ? "s" : ""})` : "";
+      const finding = {
+        id: stableId("PHANTOM", name),
+        check: "phantom-dep",
+        severity: "error",
+        file: occ.file,
+        line: occ.line,
+        message: "",
+        fix: ""
+      };
+      if (verdict === "missing") {
+        finding.message = `'${name}' does not exist on npm \u2014 likely a hallucinated import${more}`;
+        finding.fix = `remove it or find the real package \u2014 installing a lookalike name risks slopsquatting`;
+      } else if (verdict === "exists") {
+        finding.message = `'${name}' is imported but not declared in package.json${more}`;
+        finding.fix = `npm install ${name} \u2014 undeclared deps break on fresh installs`;
+      } else {
+        finding.message = `'${name}' is imported but not declared in package.json${more}`;
+        finding.fix = `npm install ${name} if it's real \u2014 could not reach the npm registry to verify`;
+      }
+      findings.push(finding);
+    }
+    return findings;
+  }
+};
+
+// src/checks/deletion.ts
+var ERROR_HANDLING = [/\btry\s*\{/, /\bcatch\s*[({]/, /\.catch\s*\(/];
+var GUARD_IF = [/\bif\s*\(\s*!(?!=)/, /\bif\b[^\n]*[=!]==?\s*(?:null|undefined)\b/, /\bif\b[^\n]*\btypeof\s+[\w.$]+\s*[=!]==?/];
+var GUARD_DIRECT = [
+  /\bthrow\s+new\s+\w*(?:Error|Exception)\w*\s*\(/,
+  /\b(?:validate|invariant|assert)\w*\s*\(/,
+  /\.safeParse\s*\(/,
+  /[sS]chema\.parse\s*\(/
+];
+var CONSEQUENCE = /\b(?:return|throw|continue|break)\b|process\.exit/;
+var TEST_LINE = /^\s*(?:it|test)(?:\.\w+)?\s*\(\s*(?:(['"`])(.*?)\1)?/;
+var norm = (s) => s.replace(/\s+/g, " ").trim();
+var snippet = (s) => {
+  const t = norm(s);
+  return t.length > 64 ? `${t.slice(0, 63)}\u2026` : t;
+};
+function isGuard(text, nextRemoved) {
+  if (GUARD_DIRECT.some((re) => re.test(text))) return true;
+  if (!GUARD_IF.some((re) => re.test(text))) return false;
+  return CONSEQUENCE.test(text) || nextRemoved !== void 0 && CONSEQUENCE.test(nextRemoved);
+}
+function sameCategoryAdded(category, text) {
+  if (category === "error-handling") return ERROR_HANDLING.some((re) => re.test(text));
+  return GUARD_DIRECT.some((re) => re.test(text)) || GUARD_IF.some((re) => re.test(text));
+}
+var deletionCheck = {
+  name: "deletion",
+  async run(ctx) {
+    const findings = [];
+    const seen = /* @__PURE__ */ new Map();
+    const push = (file, line, key, message, fix) => {
+      const occ = seen.get(key) ?? 0;
+      seen.set(key, occ + 1);
+      findings.push({
+        id: stableId("DEL", occ === 0 ? key : `${key}#${occ}`),
+        check: "deletion",
+        severity: "error",
+        file,
+        line,
+        message,
+        fix
+      });
+    };
+    const addedEverywhere = /* @__PURE__ */ new Set();
+    const addedTestNames = /* @__PURE__ */ new Set();
+    for (const f of ctx.files) {
+      for (const text of f.added.values()) {
+        addedEverywhere.add(norm(text));
+        const name = TEST_LINE.exec(text)?.[2];
+        if (name) addedTestNames.add(name);
+      }
+    }
+    const moved = (text) => addedEverywhere.has(norm(text));
+    for (const file of ctx.files) {
+      if (!CODE_FILE.test(file.path) || file.removed.size === 0) continue;
+      const removed = [...file.removed.entries()].sort((a, b) => a[0] - b[0]);
+      const addedTexts = [...file.added.values()];
+      if (TEST_FILE.test(file.path)) {
+        const removedTests = [];
+        for (const [lineNo, text] of removed) {
+          const m = TEST_LINE.exec(text);
+          if (!m || moved(text)) continue;
+          const name = m[2];
+          if (name !== void 0 && addedTestNames.has(name)) continue;
+          removedTests.push({ line: lineNo, name });
+        }
+        if (removedTests.length === 0) continue;
+        const first = removedTests[0];
+        const fix = "restore it \u2014 deleting tests to make a change pass hides regressions";
+        if (file.status === "deleted") {
+          const count = removedTests.length;
+          push(
+            file.path,
+            first.line,
+            `${file.path}:test-file`,
+            `Test file deleted (${count} test case${count === 1 ? "" : "s"})`,
+            fix
+          );
+          continue;
+        }
+        const addedCount = addedTexts.filter((t) => TEST_LINE.test(t)).length;
+        if (removedTests.length <= addedCount) continue;
+        const named = first.name !== void 0 ? `: "${first.name}"` : "";
+        const message = removedTests.length === 1 ? `Test case removed${named}` : `${removedTests.length} test cases removed, only ${addedCount} added back${first.name !== void 0 ? ` \u2014 including "${first.name}"` : ""}`;
+        push(file.path, first.line, `${file.path}:test`, message, fix);
+        continue;
+      }
+      if (file.status === "deleted") continue;
+      const ehSuppressed = addedTexts.some((t) => sameCategoryAdded("error-handling", t));
+      const guardSuppressed = addedTexts.some((t) => sameCategoryAdded("guard", t));
+      let block = [];
+      let prevLine = Number.MIN_SAFE_INTEGER;
+      const blocks = [];
+      for (const entry of removed) {
+        if (entry[0] !== prevLine + 1) {
+          block = [];
+          blocks.push(block);
+        }
+        block.push(entry);
+        prevLine = entry[0];
+      }
+      for (const blk of blocks) {
+        if (!ehSuppressed) {
+          const hit = blk.find(([, text]) => !moved(text) && ERROR_HANDLING.some((re) => re.test(text)));
+          if (hit) {
+            const promise = /\.catch\s*\(/.test(hit[1]);
+            push(
+              file.path,
+              hit[0],
+              `${file.path}:eh:${norm(hit[1])}`,
+              promise ? "promise .catch() removed \u2014 rejections now go unhandled" : "try/catch removed \u2014 errors here now propagate unhandled",
+              "restore the handling, or make the caller handle the error explicitly"
+            );
+          }
+        }
+        if (!guardSuppressed) {
+          const hit = blk.find(([lineNo, text]) => !moved(text) && isGuard(text, file.removed.get(lineNo + 1)));
+          if (hit) {
+            push(
+              file.path,
+              hit[0],
+              `${file.path}:guard:${norm(hit[1])}`,
+              `Guard removed: "${snippet(hit[1])}"`,
+              "restore it \u2014 or confirm the input can no longer be invalid"
+            );
+          }
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// src/checks/no-test.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+var MIN_LOGIC_TOUCHED = 5;
+var MIN_LOGIC_NEW = 10;
+var NOT_LOGIC = [
+  /^\s*$/,
+  /^\s*(?:\/\/|\/?\*)/,
+  // comments
+  /^\s*import\b/,
+  /^\s*export\s+(?:\{|\*|type\b|interface\b)/,
+  // re-exports and type exports
+  /^\s*(?:interface|type|declare)\b/,
+  /^[\s{}()[\];,]*$/
+  // punctuation-only
+];
+var LOGIC = /\breturn\b|\bthrow\b|\bawait\b|\bif\b|\belse\b|\bfor\b|\bwhile\b|\bswitch\b|=>|[\w$]\s*\(|=[^=>]/;
+var DECL_SIGNAL = /\bfunction\b|\bclass\b|=>/;
+function countLogicLines(texts) {
+  let count = 0;
+  for (const text of texts) {
+    if (NOT_LOGIC.some((re) => re.test(text))) continue;
+    if (LOGIC.test(text)) count++;
+  }
+  return count;
+}
+function moduleBase(path) {
+  const name = path.split("/").pop();
+  return name.replace(/\.[cm]?[jt]sx?$/, "").replace(/[._](?:test|spec)$/, "");
+}
+var RUNNERS = ["vitest", "jest", "mocha", "ava", "tap", "jasmine", "uvu"];
+function hasTestRunner(repoRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync3(join4(repoRoot, "package.json"), "utf8"));
+    for (const field of ["dependencies", "devDependencies"]) {
+      const deps = pkg[field];
+      if (deps && typeof deps === "object" && RUNNERS.some((r) => r in deps)) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function suggestTestPath(sourcePath, repoTests) {
+  const base = moduleBase(sourcePath);
+  const testDir = repoTests.find((t) => /^tests?\//.test(t))?.split("/")[0];
+  if (testDir) return `${testDir}/${base}.test.ts`;
+  const dir = sourcePath.split("/").slice(0, -1).join("/");
+  return `${dir === "" ? "" : `${dir}/`}${base}.test.ts`;
+}
+var noTestCheck = {
+  name: "no-test",
+  async run(ctx) {
+    const findings = [];
+    const sourceChanged = ctx.files.filter(
+      (f) => f.status !== "deleted" && CODE_FILE.test(f.path) && !TEST_FILE.test(f.path)
+    );
+    if (sourceChanged.length === 0) return findings;
+    const repoTests = walkCodeFiles(ctx.repoRoot).filter((p) => TEST_FILE.test(p));
+    if (repoTests.length === 0 && !hasTestRunner(ctx.repoRoot)) return findings;
+    const touchedTestBases = new Set(
+      ctx.files.filter((f) => TEST_FILE.test(f.path) && f.status !== "deleted").map((f) => moduleBase(f.path))
+    );
+    const repoTestByBase = /* @__PURE__ */ new Map();
+    for (const t of repoTests) {
+      const base = moduleBase(t);
+      if (!repoTestByBase.has(base)) repoTestByBase.set(base, t);
+    }
+    for (const file of sourceChanged) {
+      const base = moduleBase(file.path);
+      if (touchedTestBases.has(base)) continue;
+      const logic = countLogicLines(file.added.values());
+      const testPath = repoTestByBase.get(base);
+      if (testPath !== void 0) {
+        if (logic < MIN_LOGIC_TOUCHED) continue;
+        findings.push({
+          id: stableId("NOTEST", `${file.path}:stale`),
+          check: "no-test",
+          severity: "warn",
+          file: file.path,
+          message: `Logic changed (${logic} lines) but ${testPath} wasn't touched`,
+          fix: `update ${testPath} to cover the changed behavior`
+        });
+      } else {
+        if (logic < MIN_LOGIC_NEW) continue;
+        const texts = [...file.added.values()];
+        if (!texts.some((t) => DECL_SIGNAL.test(t))) continue;
+        findings.push({
+          id: stableId("NOTEST", `${file.path}:missing`),
+          check: "no-test",
+          severity: "warn",
+          file: file.path,
+          message: `${logic} lines of logic changed with no test file for this module`,
+          fix: `add ${suggestTestPath(file.path, repoTests)} to lock the behavior in`
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/checks/unreferenced.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+var ENTRY_FILE = /(?:^|\/)(?:index|main|cli)\.[cm]?[jt]sx?$/;
+var FRAMEWORK_FILE = /(?:^|\/)(?:pages|app|routes)\/|\.(?:config|stories)\.[cm]?[jt]sx?$|\.d\.ts$/;
+var MAGIC_NAMES = /* @__PURE__ */ new Set([
+  "metadata",
+  "revalidate",
+  "dynamic",
+  "config",
+  "runtime",
+  "viewport",
+  "getServerSideProps",
+  "getStaticProps",
+  "getStaticPaths",
+  "generateMetadata",
+  "generateStaticParams",
+  "loader",
+  "action",
+  "links",
+  "meta",
+  "headers",
+  "handle",
+  "ErrorBoundary",
+  "middleware"
+]);
+var EXPORT_DECL = /^\s*export\s+(?:async\s+)?(?:function\*?|class|abstract\s+class|const|let|var)\s+([A-Za-z_$][\w$]*)/;
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var unreferencedCheck = {
+  name: "unreferenced",
+  async run(ctx) {
+    const findings = [];
+    const candidates = [];
+    for (const file of ctx.files) {
+      if (file.status === "deleted") continue;
+      if (!/\.[cm]?[jt]sx?$/.test(file.path)) continue;
+      if (ENTRY_FILE.test(file.path) || FRAMEWORK_FILE.test(file.path) || TEST_FILE.test(file.path)) continue;
+      for (const [lineNo, text] of file.added) {
+        const name = EXPORT_DECL.exec(text)?.[1];
+        if (name === void 0 || MAGIC_NAMES.has(name)) continue;
+        candidates.push({ file: file.path, line: lineNo, name });
+      }
+    }
+    if (candidates.length === 0) return findings;
+    const repoFiles = walkCodeFiles(ctx.repoRoot);
+    const onDisk = new Set(repoFiles);
+    const contentCache = /* @__PURE__ */ new Map();
+    const read = (path) => {
+      let content = contentCache.get(path);
+      if (content === void 0) {
+        try {
+          content = readFileSync4(join5(ctx.repoRoot, path), "utf8");
+        } catch {
+          content = "";
+        }
+        contentCache.set(path, content);
+      }
+      return content;
+    };
+    for (const { file, line, name } of candidates) {
+      if (!onDisk.has(file)) continue;
+      const word = new RegExp(`\\b${escapeRegex(name)}\\b`);
+      const referencedElsewhere = repoFiles.some((other) => other !== file && word.test(read(other)));
+      if (referencedElsewhere) continue;
+      const ownMatches = read(file).match(new RegExp(`\\b${escapeRegex(name)}\\b`, "g"))?.length ?? 0;
+      const internalOnly = ownMatches >= 2;
+      findings.push({
+        id: stableId("UNREF", `${file}:${name}`),
+        check: "unreferenced",
+        severity: "warn",
+        file,
+        line,
+        message: internalOnly ? `export ${name} is only used inside this file` : `export ${name} is never referenced`,
+        fix: internalOnly ? "drop the export keyword \u2014 keep the module surface honest" : "remove it, or wire it up \u2014 dead exports invite drift"
+      });
+    }
+    return findings;
+  }
+};
+
+// src/checks/duplicate.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+var SIMILARITY_THRESHOLD = 0.8;
+var MIN_TOKENS = 40;
+var BODY_MIN_TOKENS = 30;
+var SHINGLE_K = 6;
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "return",
+  "const",
+  "let",
+  "var",
+  "function",
+  "class",
+  "new",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "await",
+  "async",
+  "yield",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "break",
+  "continue",
+  "default",
+  "import",
+  "export",
+  "from",
+  "extends",
+  "this",
+  "super",
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "void",
+  "delete",
+  "static",
+  "get",
+  "set"
+]);
+var TOKEN_RE = /(['"`])(?:\\.|(?!\1).)*\1|\d+(?:\.\d+)?|[A-Za-z_$][\w$]*|=>|===|!==|==|!=|<=|>=|&&|\|\||\?\?|\?\.|\.\.\.|[+\-*/%<>=!&|^~?:;,.(){}[\]]/g;
+function tokenize(code) {
+  const stripped = code.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+  const tokens = [];
+  for (const m of stripped.matchAll(TOKEN_RE)) {
+    const t = m[0];
+    if (t[0] === '"' || t[0] === "'" || t[0] === "`") tokens.push("S");
+    else if (/^\d/.test(t)) tokens.push("N");
+    else if (/^[A-Za-z_$]/.test(t)) tokens.push(KEYWORDS.has(t) ? t : "ID");
+    else tokens.push(t);
+  }
+  return tokens;
+}
+function extractFunctions(file, content) {
+  const lines = content.split("\n");
+  const decls = scanTopLevelDecls(lines);
+  const fns = [];
+  for (const decl of decls) {
+    const span = declSpan(lines, decl, decls);
+    const tokens = tokenize(lines.slice(span.start - 1, span.end).join("\n"));
+    if (tokens.length < MIN_TOKENS) continue;
+    const bodyTokens = tokenize(lines.slice(span.start, span.end).join("\n"));
+    fns.push({
+      file,
+      name: decl.name,
+      start: span.start,
+      end: span.end,
+      shingles: shingles(tokens, SHINGLE_K),
+      bodyShingles: bodyTokens.length >= BODY_MIN_TOKENS ? shingles(bodyTokens, SHINGLE_K) : null
+    });
+  }
+  return fns;
+}
+function similarity(a, b) {
+  const full = jaccard(a.shingles, b.shingles);
+  const body = a.bodyShingles !== null && b.bodyShingles !== null ? jaccard(a.bodyShingles, b.bodyShingles) : 0;
+  return Math.max(full, body);
+}
+var duplicateCheck = {
+  name: "duplicate",
+  async run(ctx) {
+    const findings = [];
+    const contentCache = /* @__PURE__ */ new Map();
+    const read = (path) => {
+      let content = contentCache.get(path);
+      if (content === void 0) {
+        try {
+          content = readFileSync5(join6(ctx.repoRoot, path), "utf8");
+        } catch {
+          content = null;
+        }
+        contentCache.set(path, content);
+      }
+      return content;
+    };
+    const candidates = [];
+    for (const file of ctx.files) {
+      if (file.status === "deleted" || !CODE_FILE.test(file.path) || TEST_FILE.test(file.path)) continue;
+      if (file.added.size === 0) continue;
+      const content = read(file.path);
+      if (content === null) continue;
+      for (const fn of extractFunctions(file.path, content)) {
+        if (file.added.has(fn.start)) candidates.push(fn);
+      }
+    }
+    if (candidates.length === 0) return findings;
+    const index = [];
+    for (const path of walkCodeFiles(ctx.repoRoot)) {
+      if (TEST_FILE.test(path)) continue;
+      const content = read(path);
+      if (content !== null) index.push(...extractFunctions(path, content));
+    }
+    const reportedPairs = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      let best = null;
+      let bestScore = 0;
+      for (const existing of index) {
+        if (existing.file === candidate.file && existing.start === candidate.start) continue;
+        const score = similarity(candidate, existing);
+        if (score > bestScore) {
+          bestScore = score;
+          best = existing;
+        }
+      }
+      if (best === null || bestScore < SIMILARITY_THRESHOLD) continue;
+      const pairKey = [`${candidate.file}:${candidate.start}`, `${best.file}:${best.start}`].sort().join("|");
+      if (reportedPairs.has(pairKey)) continue;
+      reportedPairs.add(pairKey);
+      const pct = Math.round(bestScore * 100);
+      findings.push({
+        id: stableId("DUP", `${candidate.file}:${candidate.name}`),
+        check: "duplicate",
+        severity: "error",
+        file: candidate.file,
+        line: candidate.start,
+        message: `${candidate.name}() is ${pct}% similar to ${best.name}() in ${best.file}:${best.start}`,
+        fix: `reuse ${best.name} from ${best.file} \u2014 extend it there if the behavior differs`
+      });
+    }
+    return findings;
+  }
+};
+
+// src/checks/standard.ts
+function globToRegex(glob) {
+  const pattern = glob.includes("/") ? glob : `**/${glob}`;
+  const segments = pattern.split("/");
+  let out = "^";
+  segments.forEach((segment, i) => {
+    const last = i === segments.length - 1;
+    if (segment === "**") {
+      out += last ? ".*" : "(?:[^/]+/)*";
+    } else {
+      out += segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]") + (last ? "" : "/");
+    }
+  });
+  return new RegExp(`${out}$`);
+}
+function compile(rule) {
+  const pattern = rule.pattern !== void 0 ? new RegExp(rule.pattern) : null;
+  const ban = rule.ban ?? null;
+  return {
+    rule,
+    key: ban ?? rule.pattern ?? "",
+    matches: (line) => ban !== null && line.includes(ban) || pattern !== null && pattern.test(line),
+    scope: rule.in !== void 0 ? globToRegex(rule.in) : null
+  };
+}
+function ruleFix(rule) {
+  if (rule.use !== void 0 && rule.docs !== void 0) return `use ${rule.use} (see ${rule.docs})`;
+  if (rule.use !== void 0) return `use ${rule.use}`;
+  if (rule.docs !== void 0) return `see ${rule.docs}`;
+  return void 0;
+}
+var standardCheck = {
+  name: "standard",
+  async run(ctx) {
+    const rules = ctx.config.standards;
+    if (rules === void 0 || rules.length === 0) return [];
+    const compiled = rules.map(compile);
+    const findings = [];
+    for (const file of ctx.files) {
+      if (file.status === "deleted" || file.added.size === 0) continue;
+      for (const { rule, key, matches, scope } of compiled) {
+        if (scope !== null ? !scope.test(file.path) : !CODE_FILE.test(file.path)) continue;
+        let firstLine = null;
+        let count = 0;
+        for (const [lineNo, text] of file.added) {
+          const trimmed = text.trim();
+          if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+          if (!matches(text)) continue;
+          count++;
+          if (firstLine === null || lineNo < firstLine) firstLine = lineNo;
+        }
+        if (firstLine === null) continue;
+        findings.push({
+          id: stableId("STD", `${key}:${file.path}`),
+          check: "standard",
+          severity: rule.severity ?? "warn",
+          file: file.path,
+          line: firstLine,
+          message: `"${key}" is banned in new code${count > 1 ? ` (${count}\xD7 in this file)` : ""}`,
+          fix: ruleFix(rule)
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/checks/reuse.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+var JSX_FILE2 = /\.(?:tsx|jsx)$/;
+var SIMILARITY_THRESHOLD2 = 0.8;
+var MIN_JSX_TOKENS = 25;
+var SHINGLE_K2 = 4;
+var JSX_BITS = /<\/?[A-Za-z][\w.]*|\/>|([A-Za-z][\w-]*)=(?=["'{])/g;
+function jsxTokens(code) {
+  const out = [];
+  for (const m of code.matchAll(JSX_BITS)) {
+    out.push(m[1] !== void 0 ? `${m[1]}=` : m[0]);
+  }
+  return out;
+}
+function extractComponents(file, content) {
+  const lines = content.split("\n");
+  const decls = scanTopLevelDecls(lines);
+  const comps = [];
+  for (const decl of decls) {
+    if (decl.isClass || !/^[A-Z]/.test(decl.name)) continue;
+    const span = declSpan(lines, decl, decls);
+    const tokens = jsxTokens(lines.slice(span.start - 1, span.end).join("\n"));
+    if (tokens.length < MIN_JSX_TOKENS) continue;
+    comps.push({ file, name: decl.name, start: span.start, shingles: shingles(tokens, SHINGLE_K2) });
+  }
+  return comps;
+}
+var reuseCheck = {
+  name: "reuse",
+  async run(ctx) {
+    const findings = [];
+    const contentCache = /* @__PURE__ */ new Map();
+    const read = (path) => {
+      let content = contentCache.get(path);
+      if (content === void 0) {
+        try {
+          content = readFileSync6(join7(ctx.repoRoot, path), "utf8");
+        } catch {
+          content = null;
+        }
+        contentCache.set(path, content);
+      }
+      return content;
+    };
+    const candidates = [];
+    for (const file of ctx.files) {
+      if (file.status === "deleted" || !JSX_FILE2.test(file.path) || TEST_FILE.test(file.path)) continue;
+      if (file.added.size === 0) continue;
+      const content = read(file.path);
+      if (content === null) continue;
+      for (const comp of extractComponents(file.path, content)) {
+        if (file.added.has(comp.start)) candidates.push(comp);
+      }
+    }
+    if (candidates.length === 0) return findings;
+    const index = [];
+    for (const path of walkCodeFiles(ctx.repoRoot)) {
+      if (!JSX_FILE2.test(path) || TEST_FILE.test(path)) continue;
+      const content = read(path);
+      if (content !== null) index.push(...extractComponents(path, content));
+    }
+    const reportedPairs = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      let best = null;
+      let bestScore = 0;
+      for (const existing of index) {
+        if (existing.file === candidate.file && existing.start === candidate.start) continue;
+        const score = jaccard(candidate.shingles, existing.shingles);
+        if (score > bestScore) {
+          bestScore = score;
+          best = existing;
+        }
+      }
+      if (best === null || bestScore < SIMILARITY_THRESHOLD2) continue;
+      const pairKey = [`${candidate.file}:${candidate.start}`, `${best.file}:${best.start}`].sort().join("|");
+      if (reportedPairs.has(pairKey)) continue;
+      reportedPairs.add(pairKey);
+      findings.push({
+        id: stableId("REUSE", `${candidate.file}:${candidate.name}`),
+        check: "reuse",
+        severity: "warn",
+        file: candidate.file,
+        line: candidate.start,
+        message: `<${candidate.name}> markup is ${Math.round(bestScore * 100)}% similar to <${best.name}> (${best.file}:${best.start})`,
+        fix: `reuse <${best.name}> from ${best.file} \u2014 extend it with props instead of forking the markup`
+      });
+    }
+    return findings;
+  }
+};
+
+// src/checks/index.ts
+var checks = [
+  phantomDepCheck,
+  deletionCheck,
+  duplicateCheck,
+  reuseCheck,
+  stubCheck,
+  oversizeCheck,
+  noTestCheck,
+  unreferencedCheck,
+  standardCheck
+];
+var SEVERITY_RANK = { error: 0, warn: 1, info: 2 };
+async function runChecks(ctx) {
+  const ignored = new Set(ctx.config.ignore);
+  const findings = [];
+  for (const check of checks) {
+    const results = await check.run(ctx);
+    for (const f of results) {
+      if (!ignored.has(f.id)) findings.push(f);
+    }
+  }
+  const byLocation = /* @__PURE__ */ new Map();
+  const kept = [];
+  for (const f of findings) {
+    if (f.line === void 0) {
+      kept.push(f);
+      continue;
+    }
+    const key = `${f.file}:${f.line}`;
+    const prev = byLocation.get(key);
+    if (prev === void 0) {
+      byLocation.set(key, f);
+      kept.push(f);
+    } else if (SEVERITY_RANK[f.severity] < SEVERITY_RANK[prev.severity]) {
+      kept[kept.indexOf(prev)] = f;
+      byLocation.set(key, f);
+    }
+  }
+  return kept;
+}
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  maxFileLines: 400,
+  maxComponentLines: 200,
+  strict: false,
+  standards: void 0,
+  ignore: []
+};
+
+// src/config.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+var CONFIG_FILE = "aidiff.config.json";
+var ConfigError = class extends Error {
+};
+function fail(message) {
+  throw new ConfigError(`${CONFIG_FILE}: ${message}`);
+}
+var SEVERITIES = ["error", "warn", "info"];
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function readPositiveInt(o, key) {
+  const v = o[key];
+  if (v === void 0) return void 0;
+  if (typeof v !== "number" || !Number.isInteger(v) || v < 1) fail(`"${key}" must be a positive integer`);
+  return v;
+}
+function readStringArray(o, key) {
+  const v = o[key];
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v) || v.some((s) => typeof s !== "string")) fail(`"${key}" must be an array of strings`);
+  return v;
+}
+function readStandards(o) {
+  const v = o["standards"];
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) fail('"standards" must be an array of rules');
+  return v.map((raw, i) => {
+    const at = `standards[${i}]`;
+    if (!isPlainObject(raw)) fail(`${at} must be an object`);
+    const rule = {};
+    for (const key of ["ban", "pattern", "in", "use", "docs"]) {
+      const field = raw[key];
+      if (field === void 0) continue;
+      if (typeof field !== "string" || field === "") fail(`${at}.${key} must be a non-empty string`);
+      rule[key] = field;
+    }
+    if (rule.ban === void 0 && rule.pattern === void 0) fail(`${at} needs a "ban" or a "pattern"`);
+    if (rule.pattern !== void 0) {
+      try {
+        new RegExp(rule.pattern);
+      } catch {
+        fail(`${at}.pattern is not a valid regex: ${rule.pattern}`);
+      }
+    }
+    const severity = raw["severity"];
+    if (severity !== void 0) {
+      if (typeof severity !== "string" || !SEVERITIES.includes(severity)) {
+        fail(`${at}.severity must be one of ${SEVERITIES.join(" | ")}`);
+      }
+      rule.severity = severity;
+    }
+    return rule;
+  });
+}
+function loadConfig(repoRoot) {
+  let raw;
+  try {
+    raw = readFileSync7(join8(repoRoot, CONFIG_FILE), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { ...DEFAULT_CONFIG };
+    fail(`could not be read: ${err.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    fail(`is not valid JSON \u2014 ${err.message}`);
+  }
+  if (!isPlainObject(parsed)) fail("must be a JSON object");
+  const strict = parsed["strict"];
+  if (strict !== void 0 && typeof strict !== "boolean") fail('"strict" must be a boolean');
+  const user = {
+    maxFileLines: readPositiveInt(parsed, "maxFileLines"),
+    maxComponentLines: readPositiveInt(parsed, "maxComponentLines"),
+    strict,
+    ignore: readStringArray(parsed, "ignore"),
+    standards: readStandards(parsed)
+  };
+  return {
+    maxFileLines: user.maxFileLines ?? DEFAULT_CONFIG.maxFileLines,
+    maxComponentLines: user.maxComponentLines ?? DEFAULT_CONFIG.maxComponentLines,
+    strict: user.strict ?? DEFAULT_CONFIG.strict,
+    standards: user.standards,
+    ignore: user.ignore ?? []
+  };
+}
+
+// src/commands.ts
+import { existsSync as existsSync2, readFileSync as readFileSync8, writeFileSync, appendFileSync, chmodSync } from "fs";
+import { join as join9 } from "path";
+var STARTER_CONFIG = `{
+  "maxFileLines": 400,
+  "maxComponentLines": 200,
+  "strict": false,
+  "ignore": [],
+  "standards": []
+}
+`;
+var HOOK_LINE = "npx ai-diff-check";
+function runInit(repoRoot) {
+  const out = [];
+  const configPath = join9(repoRoot, CONFIG_FILE);
+  if (existsSync2(configPath)) {
+    out.push(`${CONFIG_FILE} already exists \u2014 left untouched`);
+  } else {
+    writeFileSync(configPath, STARTER_CONFIG);
+    out.push(`wrote ${CONFIG_FILE}`);
+  }
+  const usesHusky = existsSync2(join9(repoRoot, ".husky"));
+  const hooksDir = usesHusky ? join9(repoRoot, ".husky") : join9(repoRoot, ".git", "hooks");
+  const label = usesHusky ? ".husky/pre-commit" : ".git/hooks/pre-commit";
+  if (!existsSync2(hooksDir)) {
+    out.push(`no .husky/ or .git/hooks/ found \u2014 add "${HOOK_LINE}" to your pre-commit hook manually`);
+    return out;
+  }
+  const hookPath = join9(hooksDir, "pre-commit");
+  if (!existsSync2(hookPath)) {
+    writeFileSync(hookPath, `#!/bin/sh
+${HOOK_LINE}
+`);
+    chmodSync(hookPath, 493);
+    out.push(`created ${label} \u2014 every commit now runs the vibe check`);
+  } else if (readFileSync8(hookPath, "utf8").includes("ai-diff-check")) {
+    out.push(`${label} already runs ai-diff-check \u2014 left untouched`);
+  } else {
+    appendFileSync(hookPath, `
+${HOOK_LINE}
+`);
+    out.push(`added "${HOOK_LINE}" to your existing ${label}`);
+  }
+  return out;
+}
+function addIgnore(repoRoot, id) {
+  const configPath = join9(repoRoot, CONFIG_FILE);
+  let config = {};
+  if (existsSync2(configPath)) {
+    try {
+      config = JSON.parse(readFileSync8(configPath, "utf8"));
+    } catch {
+      throw new ConfigError(`${CONFIG_FILE} is not valid JSON \u2014 fix it before adding ignores`);
+    }
+  }
+  const ignore = Array.isArray(config["ignore"]) ? config["ignore"] : [];
+  if (ignore.includes(id)) return `${id} is already on the ignore list`;
+  config["ignore"] = [...ignore, id];
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  return `${id} added to the ignore list in ${CONFIG_FILE}`;
+}
+
+// src/mcp.ts
+import { createInterface } from "readline";
+var PROTOCOL_FALLBACK = "2025-03-26";
+var VIBE_CHECK_TOOL = {
+  name: "vibe_check",
+  description: "Review the current git diff (uncommitted/branch changes only \u2014 never the whole repo) for AI-generated-code issues: hallucinated or undeclared imports, functions duplicating existing code, deleted error handling/guards/tests, leftover stubs (console.log, TODO, empty catch), oversized files/components, logic changes with untouched tests, unreferenced new exports, and violations of the project's own house rules. Call this after making code changes and fix everything it reports before declaring the task done.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      base: { type: "string", description: "git ref to diff against (default: main/master, then origin/*)" },
+      repo: { type: "string", description: "path inside the repository to check (default: server working directory)" }
+    },
+    additionalProperties: false
+  }
+};
+async function vibeCheck(args) {
+  const repoRoot = findRepoRoot(args.repo ?? process.cwd());
+  const config = loadConfig(repoRoot);
+  const baseRef = resolveBaseRef(repoRoot, args.base);
+  const files = getChangedFiles(repoRoot, baseRef);
+  const findings = sortFindings(await runChecks({ repoRoot, baseRef, files, config }));
+  const stats = diffStats(files);
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warns = findings.filter((f) => f.severity === "warn").length;
+  const header = `Trust score ${trustScore(findings, stats)}/100 \u2014 ${errors} error(s), ${warns} warning(s) across ${stats.files} changed file(s) (diff vs ${baseRef}).`;
+  return `${header}
+
+${renderFixPrompt(findings)}`;
+}
+function runMcpServer(version) {
+  const write = (msg) => {
+    process.stdout.write(`${JSON.stringify(msg)}
+`);
+  };
+  const reply = (id, result) => write({ jsonrpc: "2.0", id, result });
+  const replyError = (id, code, message) => write({ jsonrpc: "2.0", id, error: { code, message } });
+  const handle = async (msg) => {
+    const { id, method, params } = msg;
+    if (method === void 0) return;
+    if (id === void 0) return;
+    switch (method) {
+      case "initialize": {
+        const requested = params?.["protocolVersion"];
+        reply(id, {
+          protocolVersion: typeof requested === "string" ? requested : PROTOCOL_FALLBACK,
+          capabilities: { tools: {} },
+          serverInfo: { name: "ai-diff-check", version }
+        });
+        return;
+      }
+      case "ping":
+        reply(id, {});
+        return;
+      case "tools/list":
+        reply(id, { tools: [VIBE_CHECK_TOOL] });
+        return;
+      case "tools/call": {
+        if (params?.["name"] !== VIBE_CHECK_TOOL.name) {
+          replyError(id, -32602, `Unknown tool: ${String(params?.["name"])}`);
+          return;
+        }
+        try {
+          const text = await vibeCheck(params?.["arguments"] ?? {});
+          reply(id, { content: [{ type: "text", text }], isError: false });
+        } catch (err) {
+          const known = err instanceof NotAGitRepoError || err instanceof ConfigError;
+          const text = known ? err.message : `vibe_check failed: ${err.message}`;
+          reply(id, { content: [{ type: "text", text }], isError: true });
+        }
+        return;
+      }
+      default:
+        replyError(id, -32601, `Method not found: ${method}`);
+    }
+  };
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      replyError(null, -32700, "Parse error");
+      return;
+    }
+    void handle(msg);
+  });
+  rl.on("close", () => process.exit(0));
+}
+
+export {
+  NotAGitRepoError,
+  findRepoRoot,
+  resolveBaseRef,
+  getChangedFiles,
+  parseUnifiedDiff,
+  diffStats,
+  sortFindings,
+  renderHeader,
+  renderDiffLine,
+  renderFindings,
+  renderSummary,
+  trustScore,
+  githubAnnotations,
+  renderFixPrompt,
+  stubCheck,
+  oversizeCheck,
+  phantomDepCheck,
+  deletionCheck,
+  noTestCheck,
+  unreferencedCheck,
+  duplicateCheck,
+  standardCheck,
+  reuseCheck,
+  checks,
+  runChecks,
+  DEFAULT_CONFIG,
+  CONFIG_FILE,
+  ConfigError,
+  loadConfig,
+  runInit,
+  addIgnore,
+  runMcpServer
+};
+//# sourceMappingURL=chunk-7JKSFHII.js.map