agent-roast 0.1.4 → 0.2.0

package/dist/chunk-FHRPVXCI.js

@@ -0,0 +1,1298 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path from "path";
+
+// src/git.ts
+import { spawn, spawnSync } from "child_process";
+import { PassThrough } from "stream";
+import { StringDecoder } from "string_decoder";
+
+// src/detector.ts
+var TRAILER_AI_PATTERNS = [
+  { regex: /Co-Authored-By:.*(?:Claude|Anthropic)/i, name: "trailer:claude" },
+  { regex: /Co-Authored-By:.*(?:Cursor|Anysphere)/i, name: "trailer:cursor" },
+  { regex: /Co-Authored-By:.*(?:Copilot|GitHub Copilot)/i, name: "trailer:copilot" },
+  { regex: /Co-Authored-By:.*(?:Aider|aider)/i, name: "trailer:aider" },
+  { regex: /Co-Authored-By:.*(?:Devin|cognition)/i, name: "trailer:devin" },
+  { regex: /Co-Authored-By:.*(?:Windsurf|Codeium)/i, name: "trailer:windsurf" },
+  { regex: /Co-Authored-By:.*(?:ChatGPT|OpenAI|GPT)/i, name: "trailer:gpt" }
+];
+var MESSAGE_AI_PATTERNS = [
+  { regex: /(?:Generated|Assisted|Created|Written) by Cursor/i, name: "message:cursor" },
+  { regex: /(?:Generated|Assisted|Created|Written) by Claude/i, name: "message:claude" },
+  { regex: /(?:Generated|Assisted|Created|Written) by Aider/i, name: "message:aider" },
+  { regex: /(?:Generated|Assisted|Created|Written) by Copilot/i, name: "message:copilot" },
+  { regex: /(?:Generated|Assisted|Created|Written) by Devin/i, name: "message:devin" }
+];
+var AUTHOR_AI_PATTERNS = [
+  { regex: /(?:claude|anthropic)/i, name: "author:claude" },
+  { regex: /(?:cursor|anysphere)/i, name: "author:cursor" },
+  { regex: /(?:copilot)/i, name: "author:copilot" },
+  { regex: /(?:aider)/i, name: "author:aider" },
+  { regex: /(?:devin)/i, name: "author:devin" },
+  { regex: /(?:\[bot\]|bot@|automation)/i, name: "author:bot" }
+];
+function detectAiAttribution(authorName, authorEmail, message) {
+  const signatures = [];
+  for (const { regex, name } of TRAILER_AI_PATTERNS) {
+    if (regex.test(message)) {
+      signatures.push(name);
+    }
+  }
+  for (const { regex, name } of MESSAGE_AI_PATTERNS) {
+    if (regex.test(message)) {
+      signatures.push(name);
+    }
+  }
+  const authorIdentity = `${authorName} <${authorEmail}>`;
+  for (const { regex, name } of AUTHOR_AI_PATTERNS) {
+    if (regex.test(authorIdentity)) {
+      signatures.push(name);
+    }
+  }
+  return {
+    isAiAttributed: signatures.length > 0,
+    signatures
+  };
+}
+
+// src/git.ts
+var RECORD_SEPARATOR = "__ROAST_REC__";
+var FIELD_SEPARATOR = "__ROAST_FIELD__";
+var GitError = class extends Error {
+  constructor(stderr, code) {
+    super(`git exited with code ${code}: ${stderr.trim() || "unknown error"}`);
+    this.stderr = stderr;
+    this.code = code;
+    this.name = "GitError";
+  }
+  stderr;
+  code;
+};
+var HERMETIC_GIT_FLAGS = [
+  "-c",
+  "core.quotepath=false",
+  "-c",
+  "diff.noprefix=false",
+  "-c",
+  "diff.mnemonicPrefix=false",
+  "--no-pager"
+];
+function getHermeticGitEnv(extraEnv) {
+  return {
+    ...process.env,
+    ...extraEnv,
+    GIT_PAGER: "cat",
+    GIT_CONFIG_NOSYSTEM: "1",
+    GIT_CONFIG_GLOBAL: extraEnv?.GIT_CONFIG_GLOBAL || process.env.GIT_CONFIG_GLOBAL || "/dev/null"
+  };
+}
+var MAX_RECORD_BUFFER_SIZE = 50 * 1024 * 1024;
+async function parseGitLogStream(stream, onCommit) {
+  let buffer = "";
+  let totalSkippedLongLines = 0;
+  let totalSkippedUnknownFiles = 0;
+  let scanFrom = 0;
+  let activeRecSep = null;
+  let activeFieldSep = null;
+  const processBlock = (block) => {
+    if (!block.trim()) return;
+    const fieldSep = activeFieldSep || (block.includes(FIELD_SEPARATOR) ? FIELD_SEPARATOR : "");
+    const parts = block.split(fieldSep);
+    if (parts.length < 5) return;
+    const hash = parts[0].trim();
+    const date = parts[1].trim();
+    const authorName = parts[2].trim();
+    const authorEmail = parts[3].trim();
+    const message = parts[4].trim();
+    const rawDiff = parts.slice(5).join(fieldSep);
+    const attribution = detectAiAttribution(authorName, authorEmail, message);
+    const { files, totalAdded, skippedLongLines, skippedUnknownFiles } = parseDiff(rawDiff);
+    totalSkippedLongLines += skippedLongLines;
+    totalSkippedUnknownFiles += skippedUnknownFiles;
+    onCommit(
+      {
+        hash,
+        date,
+        authorName,
+        authorEmail,
+        message,
+        isAiAttributed: attribution.isAiAttributed,
+        aiSignatures: attribution.signatures,
+        files,
+        totalAddedCount: totalAdded
+      },
+      { skippedLongLines, skippedUnknownFiles }
+    );
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const safeResolve = (val) => {
+      if (!settled) {
+        settled = true;
+        resolve(val);
+      }
+    };
+    const safeReject = (err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    };
+    const decoder = new StringDecoder("utf8");
+    stream.on("data", (chunk) => {
+      const chunkStr = typeof chunk === "string" ? chunk : decoder.write(chunk);
+      buffer += chunkStr;
+      if (buffer.length > MAX_RECORD_BUFFER_SIZE) {
+        const oomErr = new Error(`Git log record exceeded maximum buffer limit (${MAX_RECORD_BUFFER_SIZE} bytes).`);
+        stream.destroy(oomErr);
+        safeReject(oomErr);
+        return;
+      }
+      if (activeRecSep === null) {
+        if (buffer.includes(RECORD_SEPARATOR)) {
+          activeRecSep = RECORD_SEPARATOR;
+          activeFieldSep = FIELD_SEPARATOR;
+          scanFrom = 0;
+        } else if (buffer.includes("")) {
+          const first1e = buffer.indexOf("");
+          const remaining = buffer.slice(first1e);
+          if (remaining.length >= RECORD_SEPARATOR.length || !RECORD_SEPARATOR.startsWith(remaining)) {
+            activeRecSep = "";
+            activeFieldSep = "";
+            scanFrom = 0;
+          }
+        }
+      }
+      if (activeRecSep === null) {
+        return;
+      }
+      const recSep = activeRecSep;
+      let idx;
+      while ((idx = buffer.indexOf(recSep, scanFrom)) !== -1) {
+        const completeBlock = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + recSep.length);
+        scanFrom = 0;
+        try {
+          processBlock(completeBlock);
+        } catch (err) {
+          const errObj = err instanceof Error ? err : new Error(String(err));
+          stream.destroy(errObj);
+          safeReject(errObj);
+          return;
+        }
+      }
+      scanFrom = buffer.length;
+    });
+    stream.on("end", () => {
+      buffer += decoder.end();
+      if (buffer.trim()) {
+        try {
+          processBlock(buffer);
+        } catch (err) {
+          safeReject(err);
+          return;
+        }
+      }
+      safeResolve({ totalSkippedLongLines, totalSkippedUnknownFiles });
+    });
+    stream.on("error", safeReject);
+    stream.on("close", () => {
+      if (!settled) {
+        safeReject(new Error("Git log stream was closed prematurely before completion."));
+      }
+    });
+  });
+}
+var HUNK_REGEX = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var MAX_LINE_LENGTH = 4096;
+function unquoteGitPath(pathStr) {
+  let s = pathStr;
+  if (s.startsWith('"') && s.endsWith('"')) {
+    s = s.slice(1, -1);
+    const bytes = [];
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === "\\" && i + 1 < s.length) {
+        const next = s[i + 1];
+        if (next >= "0" && next <= "7") {
+          let octal = next;
+          let j = i + 2;
+          while (j < s.length && j < i + 4 && s[j] >= "0" && s[j] <= "7") {
+            octal += s[j];
+            j++;
+          }
+          bytes.push(parseInt(octal, 8));
+          i = j;
+        } else if (next === "a") {
+          bytes.push(7);
+          i += 2;
+        } else if (next === "b") {
+          bytes.push(8);
+          i += 2;
+        } else if (next === "f") {
+          bytes.push(12);
+          i += 2;
+        } else if (next === "n") {
+          bytes.push(10);
+          i += 2;
+        } else if (next === "r") {
+          bytes.push(13);
+          i += 2;
+        } else if (next === "t") {
+          bytes.push(9);
+          i += 2;
+        } else if (next === "v") {
+          bytes.push(11);
+          i += 2;
+        } else if (next === "\\") {
+          bytes.push(92);
+          i += 2;
+        } else if (next === '"') {
+          bytes.push(34);
+          i += 2;
+        } else {
+          const codePoint = s.codePointAt(i + 1);
+          const charStr = String.fromCodePoint(codePoint);
+          const buf = Buffer.from(charStr, "utf8");
+          for (const b of buf) bytes.push(b);
+          i += 1 + charStr.length;
+        }
+      } else {
+        const codePoint = s.codePointAt(i);
+        const charStr = String.fromCodePoint(codePoint);
+        const buf = Buffer.from(charStr, "utf8");
+        for (const b of buf) bytes.push(b);
+        i += charStr.length;
+      }
+    }
+    s = Buffer.from(bytes).toString("utf8");
+  }
+  if (s.startsWith("b/")) return s.slice(2);
+  if (s.startsWith("a/")) return s.slice(2);
+  return s;
+}
+function parseDiff(rawDiff) {
+  const files = [];
+  let currentFile = null;
+  let lineNo = 0;
+  let oldLeft = 0;
+  let newLeft = 0;
+  let totalAdded = 0;
+  let skippedLongLines = 0;
+  const diffLines = rawDiff.split("\n");
+  for (const rawLine of diffLines) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (oldLeft > 0 || newLeft > 0) {
+      const char = line[0];
+      if (char === "\\") {
+        continue;
+      }
+      if (char === "+") {
+        if (currentFile && !currentFile.deleted && currentFile.path !== "unknown") {
+          const content = line.slice(1);
+          if (content.length <= MAX_LINE_LENGTH) {
+            currentFile.addedLines.push({
+              line: content,
+              lineNumber: lineNo
+            });
+            totalAdded++;
+          } else {
+            skippedLongLines++;
+          }
+        }
+        lineNo++;
+        newLeft--;
+        continue;
+      }
+      if (char === "-") {
+        oldLeft--;
+        continue;
+      }
+      if (char === " ") {
+        oldLeft--;
+        newLeft--;
+        lineNo++;
+        continue;
+      }
+      oldLeft = 0;
+      newLeft = 0;
+    }
+    const hunkMatch = HUNK_REGEX.exec(line);
+    if (hunkMatch) {
+      oldLeft = hunkMatch[1] === void 0 ? 1 : parseInt(hunkMatch[1], 10);
+      lineNo = parseInt(hunkMatch[2], 10);
+      newLeft = hunkMatch[3] === void 0 ? 1 : parseInt(hunkMatch[3], 10);
+      continue;
+    }
+    if (line.startsWith("diff --git ")) {
+      const quotedMatch = line.match(/^diff --git ("(?:\\.|[^"])+") ("(?:\\.|[^"])+")$/);
+      let filePath = "unknown";
+      if (quotedMatch) {
+        filePath = unquoteGitPath(quotedMatch[2]);
+      } else {
+        const plainMatch = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+        if (plainMatch) {
+          filePath = plainMatch[2];
+        }
+      }
+      currentFile = { path: filePath, addedLines: [] };
+      files.push(currentFile);
+      continue;
+    }
+    if (line.startsWith("+++ /dev/null")) {
+      if (currentFile) {
+        currentFile.deleted = true;
+      }
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const rawPath = line.trimEnd().slice(4).trim();
+      const filePath = unquoteGitPath(rawPath);
+      if (currentFile) {
+        currentFile.path = filePath;
+      } else {
+        currentFile = { path: filePath, addedLines: [] };
+        files.push(currentFile);
+      }
+      continue;
+    }
+  }
+  let skippedUnknownFiles = 0;
+  for (const file of files) {
+    if (file.path === "unknown" && !file.deleted) {
+      skippedUnknownFiles++;
+    }
+  }
+  return { files, totalAdded, skippedLongLines, skippedUnknownFiles };
+}
+var COMMON_EXCLUDE_SPECS = [
+  "--",
+  ".",
+  ":(exclude,glob)**/*.lock",
+  ":(exclude,glob)**/*-lock.json",
+  ":(exclude,glob)**/*.lockb",
+  ":(exclude,glob)**/dist/**",
+  ":(exclude,glob)**/build/**",
+  ":(exclude,glob)**/node_modules/**",
+  ":(exclude,glob)**/*.min.js",
+  ":(exclude,glob)**/*.map"
+];
+function streamGitLog(cwd = process.cwd(), since = "90 days ago") {
+  const gitArgs = [
+    ...HERMETIC_GIT_FLAGS,
+    "log",
+    "-p",
+    "-U0",
+    "--no-color",
+    "--no-merges",
+    "--no-show-signature",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--encoding=UTF-8",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `--since=${since}`,
+    `--format=${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%B${FIELD_SEPARATOR}`,
+    ...COMMON_EXCLUDE_SPECS
+  ];
+  const output = new PassThrough();
+  const child = spawn("git", gitArgs, {
+    cwd,
+    env: getHermeticGitEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  child.stdout.on("data", (chunk) => {
+    output.write(chunk);
+  });
+  let stderrBuffer = "";
+  child.stderr.on("data", (chunk) => {
+    stderrBuffer += chunk.toString();
+  });
+  child.on("close", (code) => {
+    if (code !== 0) {
+      output.destroy(new GitError(stderrBuffer, code));
+    } else {
+      output.end();
+    }
+  });
+  child.on("error", (err) => {
+    output.destroy(err);
+  });
+  return output;
+}
+function streamGitDiff(cwd, baseSha, headSha) {
+  const gitArgs = [
+    ...HERMETIC_GIT_FLAGS,
+    "diff",
+    "-U0",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    "--end-of-options",
+    baseSha,
+    headSha,
+    ...COMMON_EXCLUDE_SPECS
+  ];
+  const output = new PassThrough();
+  const child = spawn("git", gitArgs, {
+    cwd,
+    env: getHermeticGitEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  child.stdout.on("data", (chunk) => {
+    output.write(chunk);
+  });
+  let stderrBuffer = "";
+  child.stderr.on("data", (chunk) => {
+    stderrBuffer += chunk.toString();
+  });
+  child.on("close", (code) => {
+    if (code !== 0) {
+      output.destroy(new GitError(stderrBuffer, code));
+    } else {
+      output.end();
+    }
+  });
+  child.on("error", (err) => {
+    output.destroy(err);
+  });
+  return output;
+}
+function resolveCommitSha(cwd, ref, roleName = "ref") {
+  const result = spawnSync(
+    "git",
+    [...HERMETIC_GIT_FLAGS, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`],
+    {
+      cwd,
+      env: getHermeticGitEnv(),
+      encoding: "utf8",
+      windowsHide: true
+    }
+  );
+  if (result.error) {
+    throw new GitResolutionError(`Git command execution failed: ${result.error.message}. Ensure git is installed and in your PATH.`);
+  }
+  if (result.status !== 0) {
+    const isShallow = checkIfShallow(cwd);
+    const shallowHint = isShallow ? "\nShallow clone detected: please configure actions/checkout with `fetch-depth: 0`." : "";
+    throw new GitResolutionError(
+      `${roleName} '${ref}' could not be resolved to a valid commit object.${shallowHint}
+Git output: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+  }
+  return result.stdout.trim();
+}
+function findMergeBase(cwd, baseSha, headSha) {
+  const result = spawnSync(
+    "git",
+    [...HERMETIC_GIT_FLAGS, "merge-base", "--end-of-options", baseSha, headSha],
+    {
+      cwd,
+      env: getHermeticGitEnv(),
+      encoding: "utf8",
+      windowsHide: true
+    }
+  );
+  if (result.error) {
+    throw new GitResolutionError(`Git command execution failed: ${result.error.message}. Ensure git is installed and in your PATH.`);
+  }
+  if (result.status !== 0) {
+    const isShallow = checkIfShallow(cwd);
+    const shallowHint = isShallow ? "\nShallow clone detected: repository history is truncated. Configure `fetch-depth: 0` in your workflow." : "";
+    throw new GitResolutionError(
+      `Could not find a common ancestor (merge-base) between base (${baseSha.slice(0, 7)}) and head (${headSha.slice(0, 7)}).${shallowHint}
+Git output: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+  }
+  return result.stdout.trim();
+}
+function checkIfShallow(cwd) {
+  try {
+    const res = spawnSync("git", [...HERMETIC_GIT_FLAGS, "rev-parse", "--is-shallow-repository"], {
+      cwd,
+      env: getHermeticGitEnv(),
+      encoding: "utf8",
+      windowsHide: true
+    });
+    return res.stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+var GitResolutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitResolutionError";
+  }
+};
+
+// src/metrics.ts
+var TEST_SKIP_PATTERNS = [
+  { regex: /(?:it|test|describe)\.skip\b/, name: "skipped test (it.skip / describe.skip)" },
+  { regex: /\b(?:xit|xtest)\(/, name: "disabled test (xit / xtest)" },
+  { regex: /@pytest\.mark\.skip\b/, name: "skipped pytest (@pytest.mark.skip)" },
+  { regex: /\bpytest\.skip\(/, name: "imperative pytest skip (pytest.skip)" },
+  { regex: /\btest\.todo\(/, name: "todo placeholder test" }
+];
+var COMMENT_DIRECTIVE_PATTERNS = [
+  { regex: /^\s*\/\/\s*@ts-ignore\b/, name: "compiler ignore (@ts-ignore)" },
+  { regex: /^\s*\/\/\s*@ts-expect-error\b/, name: "compiler suppression (@ts-expect-error)" },
+  { regex: /(?:^\s*#\s*type:\s*ignore\b|#\s*type:\s*ignore\s*$)/, name: "python type ignore" },
+  { regex: /^\s*\/\/\s*eslint-disable(?:-next-line)?\b/, name: "linter suppression (eslint-disable)" }
+];
+var CODE_TYPE_ESCAPE_PATTERNS = [
+  { regex: /\bas\s+any\b/, name: "type bypass (as any)" }
+];
+var SWALLOWED_ERROR_PATTERNS = [
+  { regex: /catch\s*(?:\([^)]*\))?\s*\{\s*\}/, name: "empty catch block (catch {})" },
+  { regex: /except(?:\s+[^:]*)?:\s*pass\b/, name: "silent python error swallow (except: pass)" }
+];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".vue",
+  ".svelte",
+  ".php",
+  ".rb",
+  ".cs",
+  ".cpp",
+  ".c"
+]);
+var IGNORED_PATH_REGEX = /(?:^|\/)(?:fixtures|__fixtures__|testdata|mocks|test_data|__snapshots__|sample[s]?)\//i;
+function isCodeFile(filePath) {
+  if (IGNORED_PATH_REGEX.test(filePath)) {
+    return false;
+  }
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return CODE_EXTENSIONS.has(ext);
+}
+function auditFileDiffs(files, commitHash = "HEAD", commitDate = (/* @__PURE__ */ new Date()).toISOString()) {
+  const infractions = [];
+  let hasSupportedChanges = false;
+  let filesInspected = 0;
+  let linesAdded = 0;
+  for (const file of files) {
+    if (file.deleted || file.path === "unknown") continue;
+    if (!isCodeFile(file.path)) continue;
+    hasSupportedChanges = true;
+    filesInspected++;
+    linesAdded += file.addedLines.length;
+    for (const added of file.addedLines) {
+      const rawLine = added.line;
+      const cleanedLine = stripStringAndRegexLiterals(rawLine);
+      const trimmedCleaned = cleanedLine.trim();
+      const isComment = isCommentOnlyLine(trimmedCleaned);
+      if (!isComment) {
+        for (const rule of TEST_SKIP_PATTERNS) {
+          if (rule.regex.test(cleanedLine)) {
+            infractions.push({
+              type: "test-skip",
+              file: file.path,
+              lineNumber: added.lineNumber,
+              lineSnippet: rawLine.trim(),
+              commitHash,
+              commitDate,
+              reason: rule.name
+            });
+            break;
+          }
+        }
+      }
+      let foundEscape = false;
+      for (const rule of COMMENT_DIRECTIVE_PATTERNS) {
+        if (rule.regex.test(cleanedLine)) {
+          infractions.push({
+            type: "type-escape",
+            file: file.path,
+            lineNumber: added.lineNumber,
+            lineSnippet: rawLine.trim(),
+            commitHash,
+            commitDate,
+            reason: rule.name
+          });
+          foundEscape = true;
+          break;
+        }
+      }
+      if (!foundEscape && !isComment) {
+        for (const rule of CODE_TYPE_ESCAPE_PATTERNS) {
+          if (rule.regex.test(cleanedLine)) {
+            infractions.push({
+              type: "type-escape",
+              file: file.path,
+              lineNumber: added.lineNumber,
+              lineSnippet: rawLine.trim(),
+              commitHash,
+              commitDate,
+              reason: rule.name
+            });
+            break;
+          }
+        }
+      }
+      if (!isComment) {
+        for (const rule of SWALLOWED_ERROR_PATTERNS) {
+          if (rule.regex.test(cleanedLine)) {
+            infractions.push({
+              type: "swallowed-error",
+              file: file.path,
+              lineNumber: added.lineNumber,
+              lineSnippet: rawLine.trim(),
+              commitHash,
+              commitDate,
+              reason: rule.name
+            });
+            break;
+          }
+        }
+      }
+    }
+  }
+  return { infractions, hasSupportedChanges, filesInspected, linesAdded };
+}
+function stripStringAndRegexLiterals(line) {
+  return line.replace(/(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/g, '""').replace(/\/(?=[^\/\s])(?:\\\/|[^\/\r\n])+\/[gimsuy]*/g, '""');
+}
+function isCommentOnlyLine(trimmedLine) {
+  return trimmedLine.startsWith("//") || trimmedLine.startsWith("/*") || trimmedLine.startsWith("*") || trimmedLine.startsWith("#");
+}
+var PANIC_COMMIT_REGEX = /\b(?:fix|quickfix|revert|hotfix|retry|patch|undo|workaround)\b/i;
+var MAX_INFRACTIONS_PER_COMMIT = 10;
+var MIN_SAMPLE_LOC = 200;
+var MetricsCollector = class {
+  totalLinesAdded = 0;
+  aiLinesAdded = 0;
+  totalCommits = 0;
+  aiCommits = 0;
+  testSkips = [];
+  typeEscapes = [];
+  swallowedErrors = [];
+  panicLoops = [];
+  skippedLongLines = 0;
+  skippedUnknownFiles = 0;
+  activePanicChain = null;
+  includeAll;
+  constructor(options = {}) {
+    this.includeAll = options.all ?? false;
+  }
+  recordSkipped(stats) {
+    if (stats.skippedLongLines) this.skippedLongLines += stats.skippedLongLines;
+    if (stats.skippedUnknownFiles) this.skippedUnknownFiles += stats.skippedUnknownFiles;
+  }
+  flushPanicChain() {
+    if (this.activePanicChain && this.activePanicChain.commitCount >= 2) {
+      const chain = this.activePanicChain;
+      const durationMinutes = Math.max(
+        1,
+        Math.round(Math.abs(chain.latestDate - chain.firstDate) / (1e3 * 60))
+      );
+      const attributionTag = chain.isAiAttributed ? "AI panic loop" : "Panic loop (unverified / --all mode)";
+      this.panicLoops.push({
+        type: "panic-loop",
+        commitHash: chain.latestHash,
+        commitDate: new Date(chain.latestDate).toISOString(),
+        reason: `${attributionTag}: chain of ${chain.commitCount} quick fixes across ${durationMinutes}m (${chain.firstHash.slice(0, 7)} -> ${chain.latestHash.slice(0, 7)})`
+      });
+    }
+    this.activePanicChain = null;
+  }
+  processCommit(commit) {
+    this.totalCommits++;
+    this.totalLinesAdded += commit.totalAddedCount;
+    const isTarget = this.includeAll || commit.isAiAttributed;
+    if (commit.isAiAttributed) {
+      this.aiCommits++;
+      this.aiLinesAdded += commit.totalAddedCount;
+    }
+    if (!isTarget) {
+      return;
+    }
+    const subject = commit.message.split("\n")[0];
+    const commitDateMs = Date.parse(commit.date);
+    const isFixCommit = PANIC_COMMIT_REGEX.test(subject);
+    const currentActiveFiles = new Set(
+      commit.files.filter((f) => !f.deleted && f.path !== "unknown").map((f) => f.path)
+    );
+    if (isFixCommit && !isNaN(commitDateMs)) {
+      if (this.activePanicChain && this.activePanicChain.author.toLowerCase() === commit.authorEmail.toLowerCase()) {
+        const diffMinutes = Math.abs(commitDateMs - this.activePanicChain.latestDate) / (1e3 * 60);
+        const touchedSameFiles = currentActiveFiles.size > 0 && [...currentActiveFiles].some((p) => this.activePanicChain.activeFiles.has(p));
+        if (diffMinutes > 0 && diffMinutes <= 15 && touchedSameFiles) {
+          this.activePanicChain.commitCount++;
+          this.activePanicChain.latestHash = commit.hash;
+          this.activePanicChain.latestDate = commitDateMs;
+          for (const p of currentActiveFiles) {
+            this.activePanicChain.activeFiles.add(p);
+          }
+          if (commit.isAiAttributed) {
+            this.activePanicChain.isAiAttributed = true;
+          }
+        } else {
+          this.flushPanicChain();
+          this.activePanicChain = {
+            firstHash: commit.hash,
+            latestHash: commit.hash,
+            firstDate: commitDateMs,
+            latestDate: commitDateMs,
+            commitCount: 1,
+            author: commit.authorEmail,
+            activeFiles: currentActiveFiles,
+            isAiAttributed: commit.isAiAttributed
+          };
+        }
+      } else {
+        this.flushPanicChain();
+        this.activePanicChain = {
+          firstHash: commit.hash,
+          latestHash: commit.hash,
+          firstDate: commitDateMs,
+          latestDate: commitDateMs,
+          commitCount: 1,
+          author: commit.authorEmail,
+          activeFiles: currentActiveFiles,
+          isAiAttributed: commit.isAiAttributed
+        };
+      }
+    } else {
+      this.flushPanicChain();
+    }
+    let commitSkips = 0;
+    let commitEscapes = 0;
+    let commitSwallowed = 0;
+    for (const file of commit.files) {
+      if (!isCodeFile(file.path)) {
+        continue;
+      }
+      for (const added of file.addedLines) {
+        const rawLine = added.line;
+        const cleanedLine = stripStringAndRegexLiterals(rawLine);
+        const trimmedCleaned = cleanedLine.trim();
+        const isComment = isCommentOnlyLine(trimmedCleaned);
+        if (!isComment && commitSkips < MAX_INFRACTIONS_PER_COMMIT) {
+          for (const rule of TEST_SKIP_PATTERNS) {
+            if (rule.regex.test(cleanedLine)) {
+              this.testSkips.push({
+                type: "test-skip",
+                file: file.path,
+                lineNumber: added.lineNumber,
+                lineSnippet: rawLine.trim(),
+                commitHash: commit.hash,
+                commitDate: commit.date,
+                reason: rule.name
+              });
+              commitSkips++;
+              break;
+            }
+          }
+        }
+        if (commitEscapes < MAX_INFRACTIONS_PER_COMMIT) {
+          for (const rule of COMMENT_DIRECTIVE_PATTERNS) {
+            if (rule.regex.test(cleanedLine)) {
+              this.typeEscapes.push({
+                type: "type-escape",
+                file: file.path,
+                lineNumber: added.lineNumber,
+                lineSnippet: rawLine.trim(),
+                commitHash: commit.hash,
+                commitDate: commit.date,
+                reason: rule.name
+              });
+              commitEscapes++;
+              break;
+            }
+          }
+          if (!isComment && commitEscapes < MAX_INFRACTIONS_PER_COMMIT) {
+            for (const rule of CODE_TYPE_ESCAPE_PATTERNS) {
+              if (rule.regex.test(cleanedLine)) {
+                this.typeEscapes.push({
+                  type: "type-escape",
+                  file: file.path,
+                  lineNumber: added.lineNumber,
+                  lineSnippet: rawLine.trim(),
+                  commitHash: commit.hash,
+                  commitDate: commit.date,
+                  reason: rule.name
+                });
+                commitEscapes++;
+                break;
+              }
+            }
+          }
+        }
+        if (!isComment && commitSwallowed < MAX_INFRACTIONS_PER_COMMIT) {
+          for (const rule of SWALLOWED_ERROR_PATTERNS) {
+            if (rule.regex.test(cleanedLine)) {
+              this.swallowedErrors.push({
+                type: "swallowed-error",
+                file: file.path,
+                lineNumber: added.lineNumber,
+                lineSnippet: rawLine.trim(),
+                commitHash: commit.hash,
+                commitDate: commit.date,
+                reason: rule.name
+              });
+              commitSwallowed++;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  getSummary() {
+    this.flushPanicChain();
+    const linesSample = this.includeAll ? this.totalLinesAdded : this.aiLinesAdded;
+    const isSufficientData = linesSample >= MIN_SAMPLE_LOC;
+    const codeInfractionPoints = this.testSkips.length * 15 + this.swallowedErrors.length * 10 + this.typeEscapes.length * 3;
+    let panicInfractionPoints = 0;
+    for (const loop of this.panicLoops) {
+      const countMatch = loop.reason.match(/chain of (\d+) quick fixes/);
+      const chainLen = countMatch ? parseInt(countMatch[1], 10) : 2;
+      panicInfractionPoints += Math.round(8 * (1 + Math.log(chainLen)));
+    }
+    panicInfractionPoints = Math.min(panicInfractionPoints, 40);
+    const totalInfractionPoints = codeInfractionPoints + panicInfractionPoints;
+    const kLoc = linesSample / 1e3;
+    const effectiveKLoc = kLoc + 0.5;
+    const codeDensity = codeInfractionPoints / effectiveKLoc;
+    const panicDensity = panicInfractionPoints / effectiveKLoc;
+    const R0 = 15;
+    const R1 = 10;
+    const score = isSufficientData ? Math.max(0, Math.min(100, Math.round(100 * Math.exp(-(codeDensity / R0 + panicDensity / R1))))) : null;
+    let archetype = "The Clean Coder";
+    let archetypeDescription = "Spotless discipline. No skipped tests, zero panic loops, and clean type safety.";
+    if (score !== null) {
+      if (score >= 90) {
+        if (totalInfractionPoints === 0) {
+          archetype = "The Clean Coder";
+          archetypeDescription = "Spotless discipline. No skipped tests, zero panic loops, and clean type safety.";
+        } else {
+          archetype = "The Pragmatic Builder";
+          archetypeDescription = "Overwhelmingly disciplined. Only rare, isolated shortcuts across thousands of lines.";
+        }
+      } else {
+        const testSkipPoints = this.testSkips.length * 15;
+        const panicPoints = this.panicLoops.length * 8;
+        const escapePoints = this.typeEscapes.length * 3;
+        const swallowPoints = this.swallowedErrors.length * 10;
+        const maxPoints = Math.max(testSkipPoints, panicPoints, escapePoints, swallowPoints);
+        if (maxPoints === panicPoints && this.panicLoops.length >= 2) {
+          archetype = "The Panic Looper";
+          archetypeDescription = "Prone to rapid-fire fix and revert thrashing cycles when wrestling stubborn bugs.";
+        } else if (maxPoints === testSkipPoints && this.testSkips.length >= 3) {
+          archetype = "The Silent Vandal";
+          archetypeDescription = "When test suites push back, tends to disable or skip tests to keep pipelines green.";
+        } else if (maxPoints === escapePoints && this.typeEscapes.length >= 5) {
+          archetype = "The Any Architect";
+          archetypeDescription = "Leans on compiler bypasses (`as any`, `@ts-ignore`) rather than strict type modeling.";
+        } else if (maxPoints === swallowPoints && this.swallowedErrors.length >= 2) {
+          archetype = "The Secret Keeper";
+          archetypeDescription = "Tends to silence errors with empty catch blocks, obscuring runtime failures.";
+        } else if (score < 50) {
+          archetype = "The Chaos Gremlin";
+          archetypeDescription = "Mixes multiple shortcuts: skipped tests, type bypasses, and quick patches under pressure.";
+        } else {
+          archetype = "The Shortcut Specialist";
+          archetypeDescription = "Frequently cuts corners on edge cases, prioritizing delivery speed over rigour.";
+        }
+      }
+    }
+    return {
+      schemaVersion: "1.0.0",
+      totalLinesAdded: this.totalLinesAdded,
+      aiLinesAdded: this.aiLinesAdded,
+      totalCommits: this.totalCommits,
+      aiCommits: this.aiCommits,
+      testSkips: this.testSkips,
+      typeEscapes: this.typeEscapes,
+      swallowedErrors: this.swallowedErrors,
+      panicLoops: this.panicLoops,
+      rawScore: totalInfractionPoints,
+      score,
+      isSufficientData,
+      archetype,
+      archetypeDescription,
+      skippedLongLines: this.skippedLongLines,
+      skippedUnknownFiles: this.skippedUnknownFiles
+    };
+  }
+};
+
+// src/renderer.ts
+import pc from "picocolors";
+function generateShareUrl(summary) {
+  const scoreDisplay = summary.score !== null ? `${summary.score}/100` : "N/A";
+  const text = `My AI coding agent scored ${scoreDisplay} on agent-roast.
+
+Archetype: ${summary.archetype}
+Infractions:
+\u2022 ${summary.testSkips.length} skipped tests
+\u2022 ${summary.typeEscapes.length} type escapes
+\u2022 ${summary.panicLoops.length} panic revert loops
+
+Audit your repo: npx agent-roast`;
+  return `https://twitter.com/intent/tweet?text=${encodeURIComponent(text)}`;
+}
+function formatTerminalCard(summary, options) {
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `${pc.bold(pc.cyan("agent-roast"))} ${pc.dim("\u2014 git discipline audit")} ${pc.white(options.repoName)}`
+  );
+  lines.push(
+    `  ${pc.dim("commits:")} ${pc.yellow(summary.aiCommits)} AI / ${summary.totalCommits} total   ${pc.dim("lines added:")} ${pc.green(summary.aiLinesAdded)} AI / ${summary.totalLinesAdded} total`
+  );
+  lines.push("");
+  if (!summary.isSufficientData || summary.score === null) {
+    lines.push(pc.yellow(`  insufficient data (< 200 lines added by AI)`));
+    lines.push(pc.dim("  commit more code and run `npx agent-roast` again."));
+    lines.push("");
+    return lines.join("\n");
+  }
+  let scoreColor = pc.green;
+  if (summary.score < 60) scoreColor = pc.red;
+  else if (summary.score < 80) scoreColor = pc.yellow;
+  lines.push(
+    `  ${pc.bold("SCORE:")} ${scoreColor(pc.bold(`${summary.score} / 100`))}  ${pc.dim("\xB7")}  ${pc.magenta(pc.bold(summary.archetype))}`
+  );
+  lines.push(`  ${pc.dim(summary.archetypeDescription)}`);
+  lines.push("");
+  const totalInfractions = summary.testSkips.length + summary.typeEscapes.length + summary.swallowedErrors.length + summary.panicLoops.length;
+  lines.push(pc.bold(`  INFRACTIONS (${totalInfractions})`));
+  lines.push(pc.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (summary.panicLoops.length > 0) {
+    lines.push(
+      `  ${pc.magenta("\u25CF")} ${pc.bold("panic-loop")} (${summary.panicLoops.length})  ${pc.dim("consecutive quick fixes < 15m apart")}`
+    );
+    const sample = summary.panicLoops[0];
+    lines.push(`      ${pc.dim(sample.reason)}`);
+  }
+  if (summary.typeEscapes.length > 0) {
+    lines.push(
+      `  ${pc.yellow("\u25CF")} ${pc.bold("type-escape")} (${summary.typeEscapes.length})  ${pc.dim("compiler bypasses (as any, @ts-ignore)")}`
+    );
+    const sample = summary.typeEscapes[0];
+    if (sample.file) {
+      lines.push(`      ${pc.dim(`${sample.file}: ${sample.lineSnippet || ""}`)}`);
+    }
+  }
+  if (summary.testSkips.length > 0) {
+    lines.push(
+      `  ${pc.red("\u25CF")} ${pc.bold("test-skip")} (${summary.testSkips.length})  ${pc.dim("skipped or disabled tests")}`
+    );
+    const sample = summary.testSkips[0];
+    if (sample.file) {
+      lines.push(`      ${pc.dim(`${sample.file}: ${sample.lineSnippet || ""}`)}`);
+    }
+  }
+  if (summary.swallowedErrors.length > 0) {
+    lines.push(
+      `  ${pc.red("\u25CF")} ${pc.bold("swallowed-error")} (${summary.swallowedErrors.length})  ${pc.dim("empty catch blocks or except: pass")}`
+    );
+    const sample = summary.swallowedErrors[0];
+    if (sample.file) {
+      lines.push(`      ${pc.dim(`${sample.file}: ${sample.lineSnippet || ""}`)}`);
+    }
+  }
+  if (totalInfractions === 0) {
+    lines.push(`  ${pc.green("\u25CF")} ${pc.dim("zero infractions detected across all inspected lines.")}`);
+  }
+  lines.push("");
+  if (options.verbose) {
+    if (summary.skippedLongLines || summary.skippedUnknownFiles) {
+      lines.push(pc.bold("  PARSER AUDIT STATS:"));
+      lines.push(pc.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      if (summary.skippedLongLines) {
+        lines.push(`  ${pc.dim("skipped long lines (> 4096 chars):")} ${pc.yellow(summary.skippedLongLines)}`);
+      }
+      if (summary.skippedUnknownFiles) {
+        lines.push(`  ${pc.dim("skipped files with unparseable path:")} ${pc.yellow(summary.skippedUnknownFiles)}`);
+      }
+      lines.push("");
+    }
+    const allInfractions = [
+      ...summary.testSkips,
+      ...summary.typeEscapes,
+      ...summary.swallowedErrors,
+      ...summary.panicLoops
+    ];
+    if (allInfractions.length > 0) {
+      lines.push(pc.bold("  EVIDENCE (First 10 occurrences):"));
+      lines.push(pc.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      for (const inf of allInfractions.slice(0, 10)) {
+        const fileLoc = inf.file ? `${inf.file}${inf.lineNumber ? `:${inf.lineNumber}` : ""}` : "commit history";
+        lines.push(
+          `  \u25CF ${pc.cyan(inf.commitHash.slice(0, 7))} [${inf.type}] ${pc.white(fileLoc)}`
+        );
+        if (inf.lineSnippet) {
+          lines.push(`      ${pc.dim(`\u2514\u2500 ${inf.lineSnippet}`)}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  lines.push(
+    `  ${pc.dim("Share score:")} ${pc.cyan(generateShareUrl(summary))}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function formatPrTerminalCard(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `${pc.bold(pc.cyan("agent-roast"))} ${pc.dim("\u2014 pull request audit")} ${pc.white(`${result.baseSha.slice(0, 7)}...${result.headSha.slice(0, 7)}`)}`
+  );
+  if (!result.hasSupportedChanges) {
+    lines.push(`  ${pc.dim("no supported source changes detected in pull request.")}`);
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push(
+    `  ${pc.dim("files inspected:")} ${result.filesInspected}   ${pc.dim("lines added:")} ${result.linesAdded}`
+  );
+  lines.push("");
+  if (result.infractions.length === 0) {
+    lines.push(`  ${pc.green("PASS")} ${pc.dim("zero infractions detected across all pull request changes.")}`);
+  } else {
+    lines.push(pc.bold(`  INFRACTIONS DETECTED (${result.infractions.length})`));
+    lines.push(pc.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const inf of result.infractions) {
+      const isFailedRule = result.failedRules.includes(inf.type);
+      const badge = isFailedRule ? pc.red("FAIL") : pc.yellow("WARN");
+      const loc = `${inf.file || "unknown"}:${inf.lineNumber || 1}`;
+      lines.push(`  ${badge} [${inf.type}] ${pc.white(loc)} \u2014 ${pc.dim(inf.reason)}`);
+      if (inf.lineSnippet) {
+        lines.push(`      ${pc.dim(`\u2514\u2500 ${inf.lineSnippet}`)}`);
+      }
+    }
+  }
+  lines.push("");
+  if (result.failedRules.length > 0) {
+    lines.push(
+      `  ${pc.red(pc.bold("BLOCKING FAILURE:"))} ${result.failedRules.length} rule(s) violated in --fail-on: ${result.failedRules.join(", ")}`
+    );
+  } else {
+    lines.push(`  ${pc.green(pc.bold("PASSED:"))} no blocking infractions.`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function sortInfractionsDeterministic(infractions) {
+  const getLevelRank = (type) => {
+    return type === "test-skip" || type === "swallowed-error" ? 0 : 1;
+  };
+  return [...infractions].sort((a, b) => {
+    const rankDiff = getLevelRank(a.type) - getLevelRank(b.type);
+    if (rankDiff !== 0) return rankDiff;
+    const fileA = a.file || "";
+    const fileB = b.file || "";
+    if (fileA !== fileB) return fileA.localeCompare(fileB);
+    return (a.lineNumber || 0) - (b.lineNumber || 0);
+  });
+}
+function formatGithubAnnotations(result) {
+  const outputLines = [];
+  const sorted = sortInfractionsDeterministic(result.infractions);
+  const MAX_PER_LEVEL = 10;
+  let errorCount = 0;
+  let warnCount = 0;
+  let omittedCount = 0;
+  for (const inf of sorted) {
+    if (!inf.file || inf.file === "unknown") continue;
+    const isError = result.failedRules.includes(inf.type) || inf.type === "test-skip" || inf.type === "swallowed-error";
+    const line = inf.lineNumber || 1;
+    const title = inf.reason.replace(/[\r\n]/g, " ");
+    const msg = (inf.lineSnippet || inf.reason).replace(/[\r\n]/g, " ");
+    if (isError) {
+      if (errorCount < MAX_PER_LEVEL) {
+        outputLines.push(`::error file=${inf.file},line=${line},title=${title}::${msg}`);
+        errorCount++;
+      } else {
+        omittedCount++;
+      }
+    } else {
+      if (warnCount < MAX_PER_LEVEL) {
+        outputLines.push(`::warning file=${inf.file},line=${line},title=${title}::${msg}`);
+        warnCount++;
+      } else {
+        omittedCount++;
+      }
+    }
+  }
+  if (omittedCount > 0) {
+    outputLines.push(
+      `::notice::And ${omittedCount} more infractions omitted from annotations. See step summary for full report.`
+    );
+  }
+  return outputLines.join("\n");
+}
+function formatGithubStepSummary(result) {
+  const lines = [];
+  lines.push("### agent-roast Pull Request Audit");
+  lines.push("");
+  if (!result.hasSupportedChanges) {
+    lines.push("No supported source file changes detected in this pull request.");
+    return lines.join("\n");
+  }
+  const statusBadge = result.passed ? "Passed" : `Failed (${result.failedRules.join(", ")})`;
+  lines.push(`| Status | Base | Head | Files | Lines Added | Infractions |`);
+  lines.push(`| --- | --- | --- | --- | --- | --- |`);
+  lines.push(
+    `| **${statusBadge}** | \`${result.baseSha.slice(0, 7)}\` | \`${result.headSha.slice(0, 7)}\` | ${result.filesInspected} | ${result.linesAdded} | ${result.infractions.length} |`
+  );
+  lines.push("");
+  if (result.infractions.length > 0) {
+    lines.push("#### Infractions");
+    lines.push("");
+    lines.push("| Type | File:Line | Description | Snippet |");
+    lines.push("| --- | --- | --- | --- |");
+    const sorted = sortInfractionsDeterministic(result.infractions);
+    for (const inf of sorted) {
+      const loc = inf.file ? `\`${inf.file}:${inf.lineNumber || 1}\`` : "*history*";
+      const snippet = inf.lineSnippet ? `\`${inf.lineSnippet.replace(/\|/g, "\\|")}\`` : "-";
+      lines.push(`| \`${inf.type}\` | ${loc} | ${inf.reason} | ${snippet} |`);
+    }
+    lines.push("");
+  } else {
+    lines.push("Clean pull request: zero shortcuts or bypassed checks detected.");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/types.ts
+var VALID_DETECTORS = [
+  "test-skip",
+  "type-escape",
+  "swallowed-error",
+  "panic-loop"
+];
+
+// src/index.ts
+var InvalidDetectorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDetectorError";
+  }
+};
+async function roastRepository(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const since = options.since || "90 days ago";
+  const repoName = path.basename(cwd);
+  const collector = new MetricsCollector({ all: options.all });
+  const gitStream = streamGitLog(cwd, since);
+  await parseGitLogStream(gitStream, (commit, stats) => {
+    collector.processCommit(commit);
+    collector.recordSkipped(stats);
+  });
+  const summary = collector.getSummary();
+  const output = formatTerminalCard(summary, {
+    repoName,
+    verbose: options.verbose
+  });
+  return { summary, output };
+}
+async function auditPullRequest(options) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const format = options.format || "terminal";
+  const failOn = (options.failOn || ["test-skip"]).map((s) => s.trim()).filter(Boolean);
+  for (const det of failOn) {
+    if (!VALID_DETECTORS.includes(det)) {
+      throw new InvalidDetectorError(
+        `Unknown detector '${det}' in --fail-on. Valid options: ${VALID_DETECTORS.join(", ")}`
+      );
+    }
+  }
+  const baseSha = resolveCommitSha(cwd, options.base, "Base ref");
+  const headSha = resolveCommitSha(cwd, options.head, "Head ref");
+  const mergeBaseSha = findMergeBase(cwd, baseSha, headSha);
+  const diffStream = streamGitDiff(cwd, mergeBaseSha, headSha);
+  let rawDiff = "";
+  await new Promise((resolve, reject) => {
+    diffStream.on("data", (chunk) => {
+      rawDiff += chunk.toString();
+    });
+    diffStream.on("end", () => resolve());
+    diffStream.on("error", reject);
+  });
+  const { files, skippedLongLines, skippedUnknownFiles } = parseDiff(rawDiff);
+  const audit = auditFileDiffs(files, headSha);
+  const infractions = audit.infractions;
+  const defectDensityPer100Lines = audit.linesAdded > 0 ? Math.round(infractions.length / audit.linesAdded * 100 * 100) / 100 : 0;
+  const failedRules = [...new Set(
+    infractions.filter((inf) => failOn.includes(inf.type)).map((inf) => inf.type)
+  )];
+  const passed = failedRules.length === 0;
+  const exitCode = passed ? 0 : 1;
+  const result = {
+    schemaVersion: "1.0.0",
+    baseSha,
+    headSha,
+    mergeBaseSha,
+    hasSupportedChanges: audit.hasSupportedChanges,
+    filesInspected: audit.filesInspected,
+    linesAdded: audit.linesAdded,
+    defectDensityPer100Lines,
+    infractions,
+    failedRules,
+    passed,
+    skippedLongLines,
+    skippedUnknownFiles,
+    output: "",
+    exitCode
+  };
+  if (format === "json") {
+    result.output = JSON.stringify(result, null, 2);
+  } else if (format === "github") {
+    result.output = formatGithubAnnotations(result);
+  } else {
+    result.output = formatPrTerminalCard(result);
+  }
+  return result;
+}
+
+export {
+  detectAiAttribution,
+  RECORD_SEPARATOR,
+  FIELD_SEPARATOR,
+  GitError,
+  HERMETIC_GIT_FLAGS,
+  getHermeticGitEnv,
+  parseGitLogStream,
+  unquoteGitPath,
+  parseDiff,
+  streamGitLog,
+  streamGitDiff,
+  resolveCommitSha,
+  findMergeBase,
+  GitResolutionError,
+  isCodeFile,
+  auditFileDiffs,
+  stripStringAndRegexLiterals,
+  MetricsCollector,
+  generateShareUrl,
+  formatTerminalCard,
+  formatPrTerminalCard,
+  formatGithubAnnotations,
+  formatGithubStepSummary,
+  VALID_DETECTORS,
+  InvalidDetectorError,
+  roastRepository,
+  auditPullRequest
+};