agent-roast 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nari-Ab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# agent-roast 🤖🔥
+
+> **Zero-telemetry CLI scorecard auditing your git history for AI coding agent infractions, shortcuts, and panic loops.**
+
+[![npm version](https://img.shields.io/npm/v/agent-roast?color=cb3837&label=npm)](https://www.npmjs.com/package/agent-roast)
+[![telemetry: zero](https://img.shields.io/badge/telemetry-zero%20(offline)-1f9d55)](#privacy--security)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Did your AI coding agent (Cursor, Claude Code, Aider) write clean software, or did it silently delete tests and slap `as any` everywhere to pretend everything compiles?
+
+Run in any git repository (100% local, zero tokens, zero telemetry):
+
+```bash
+npx agent-roast
+```
+
+---
+
+### What it looks like:
+
+```text
+╔══════════════════════════════════════════════════════════╗
+║                 🤖 AGENT ROAST DOSSIER                    ║
+╚══════════════════════════════════════════════════════════╝
+
+  Repository:  my-app
+  Commits:     18 AI-attributed / 42 total
+  Code Added:  4,210 lines (AI) / 12,480 lines (total)
+
+  AGENT ARCHETYPE:  The Any Architect
+  Leans on compiler bypasses (`as any`, `@ts-ignore`) rather than strict type modeling.
+
+  DISCIPLINE SCORE: 68 / 100
+  (100 = spotless discipline, 0 = complete shortcut addiction)
+
+  📊 INFRACTIONS BREAKDOWN:
+  ───────────────────────────────────────────────────────
+  ✖  Skipped tests:       4 (it.skip, describe.skip, xit)
+  ▲  Type escapes:        16 (as any, @ts-ignore, eslint-disable)
+  ✖  Swallowed errors:    3 (empty catch {}, except: pass)
+  ↻  Panic fix loops:     2 (quick fixes < 15m apart)
+
+  ───────────────────────────────────────────────────────
+  📢 Share your score on X: https://twitter.com/intent/tweet?text=...
+  Tip: Run with --verbose to see exact commit SHAs and lines
+```
+
+---
+
+### What it detects (only added lines, zero false alarms from file renames):
+
+1. **Skipped Tests:** `it.skip`, `describe.skip`, `xit`, `test.todo` added when tests fail.
+2. **Type Escapes:** `as any`, `// @ts-ignore`, `// @ts-expect-error`, `# type: ignore`, `eslint-disable`.
+3. **Swallowed Errors:** Empty `catch {}` or `except: pass` blocks hiding production bugs.
+4. **Panic Loops:** Consecutive quickfix/revert commits within 15 minutes by the agent.
+
+---
+
+### Options
+
+```bash
+npx agent-roast            # Audit AI-attributed commits (Co-Authored-By: Claude, Cursor, Aider, etc.)
+npx agent-roast --all      # Audit ALL commits across the repository
+npx agent-roast --verbose  # Print exact commit SHAs and code lines as proof
+npx agent-roast --since 30d # Audit last 30 days of git history
+npx agent-roast --json     # Output raw JSON metrics for CI pipelines
+```
+
+---
+
+### Privacy & Security
+
+`agent-roast` is strictly **local and deterministic**:
+- Runs streaming `git log` on your machine in milliseconds.
+- **Zero network calls**, zero LLM APIs, zero tracking or analytics.
+- Your source code never leaves your terminal.
+
+---
+
+### License
+
+[MIT](LICENSE)

package/dist/chunk-RFCXDN22.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path from "path";
+
+// src/git.ts
+import { spawn } from "child_process";
+
+// 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
+async function parseGitLogStream(stream, onCommit) {
+  let buffer = "";
+  const processBlock = (block) => {
+    if (!block.trim()) return;
+    const parts = block.split("");
+    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("");
+    const attribution = detectAiAttribution(authorName, authorEmail, message);
+    const files = [];
+    let currentFile = null;
+    let currentLineNum = 0;
+    let totalAdded = 0;
+    const diffLines = rawDiff.split("\n");
+    for (const dLine of diffLines) {
+      if (dLine.startsWith("diff --git")) {
+        const match = dLine.match(/b\/(.+)$/);
+        const filePath = match ? match[1] : "unknown";
+        currentFile = { path: filePath, addedLines: [] };
+        files.push(currentFile);
+      } else if (dLine.startsWith("@@")) {
+        const match = dLine.match(/\+(\d+)/);
+        if (match) {
+          currentLineNum = parseInt(match[1], 10);
+        }
+      } else if (dLine.startsWith("+") && !dLine.startsWith("+++")) {
+        if (currentFile) {
+          currentFile.addedLines.push({
+            line: dLine.slice(1),
+            lineNumber: currentLineNum
+          });
+          totalAdded++;
+        }
+        currentLineNum++;
+      } else if (!dLine.startsWith("-")) {
+        currentLineNum++;
+      }
+    }
+    onCommit({
+      hash,
+      date,
+      authorName,
+      authorEmail,
+      message,
+      isAiAttributed: attribution.isAiAttributed,
+      aiSignatures: attribution.signatures,
+      files,
+      totalAddedCount: totalAdded
+    });
+  };
+  return new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const records = buffer.split("");
+      while (records.length > 1) {
+        const completeBlock = records.shift();
+        if (completeBlock !== void 0) {
+          processBlock(completeBlock);
+        }
+      }
+      buffer = records[0] || "";
+    });
+    stream.on("end", () => {
+      if (buffer.trim()) {
+        processBlock(buffer);
+      }
+      resolve();
+    });
+    stream.on("error", reject);
+  });
+}
+function streamGitLog(cwd = process.cwd(), since = "90 days ago") {
+  const gitArgs = [
+    "--no-pager",
+    "log",
+    "-p",
+    "-U0",
+    "--no-color",
+    `--since=${since}`,
+    "--format=%x1e%H%x1f%aI%x1f%an%x1f%ae%x1f%B%x1f",
+    "--",
+    ".",
+    ":(exclude)*.lock",
+    ":(exclude)*-lock.json",
+    ":(exclude)*.lockb",
+    ":(exclude)dist",
+    ":(exclude)node_modules",
+    ":(exclude).drift_venv"
+  ];
+  const nullDevice = process.platform === "win32" ? "NUL" : "/dev/null";
+  const child = spawn("git", gitArgs, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_PAGER: "cat",
+      GIT_CONFIG_GLOBAL: process.env.GIT_CONFIG_GLOBAL || nullDevice,
+      GIT_CONFIG_SYSTEM: process.env.GIT_CONFIG_SYSTEM || nullDevice
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  child.stderr.on("data", (chunk) => {
+    const errText = chunk.toString();
+    if (errText.includes("fatal:") || errText.includes("error:")) {
+      child.stdout.emit("error", new Error(errText.trim()));
+    }
+  });
+  child.on("error", (err) => {
+    child.stdout.emit("error", err);
+  });
+  return child.stdout;
+}
+
+// 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*@ts-ignore\b/, name: "compiler ignore (@ts-ignore)" },
+  { regex: /\/\/\s*@ts-expect-error\b/, name: "compiler suppression (@ts-expect-error)" },
+  { regex: /#\s*type:\s*ignore\b/, name: "python type ignore" },
+  { regex: /\/\/\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 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 = [];
+  lastFixCommit = null;
+  includeAll;
+  constructor(options = {}) {
+    this.includeAll = options.all ?? false;
+  }
+  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 commitDateMs = Date.parse(commit.date);
+    if (PANIC_COMMIT_REGEX.test(commit.message)) {
+      if (this.lastFixCommit && !isNaN(commitDateMs) && !isNaN(this.lastFixCommit.date) && this.lastFixCommit.author.toLowerCase() === commit.authorEmail.toLowerCase()) {
+        const diffMinutes = Math.abs(commitDateMs - this.lastFixCommit.date) / (1e3 * 60);
+        if (diffMinutes > 0 && diffMinutes <= 15) {
+          const attributionTag = commit.isAiAttributed ? "AI panic loop" : "Panic loop (unverified / --all mode)";
+          this.panicLoops.push({
+            type: "panic-loop",
+            commitHash: commit.hash,
+            commitDate: commit.date,
+            reason: `${attributionTag}: consecutive quick fix within ${Math.max(1, Math.round(diffMinutes))}m (${this.lastFixCommit.hash.slice(0, 7)} -> ${commit.hash.slice(0, 7)})`
+          });
+        }
+      }
+      this.lastFixCommit = {
+        hash: commit.hash,
+        date: commitDateMs,
+        message: commit.message,
+        author: commit.authorEmail
+      };
+    } else {
+      this.lastFixCommit = null;
+    }
+    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,
+                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,
+                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,
+                  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,
+                lineSnippet: rawLine.trim(),
+                commitHash: commit.hash,
+                commitDate: commit.date,
+                reason: rule.name
+              });
+              commitSwallowed++;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  getSummary() {
+    const linesSample = this.includeAll ? this.totalLinesAdded : this.aiLinesAdded;
+    const isSufficientData = linesSample >= MIN_SAMPLE_LOC;
+    const totalInfractionPoints = this.testSkips.length * 15 + this.swallowedErrors.length * 10 + this.panicLoops.length * 8 + this.typeEscapes.length * 3;
+    const normalizedKLoc = linesSample / 1e3;
+    const factor = normalizedKLoc < 1 ? Math.max(0.5, 0.7 + 0.3 * normalizedKLoc) : 1 + 1.2 * Math.log(normalizedKLoc);
+    const normalizedPenalty = Math.round(totalInfractionPoints / factor);
+    const score = isSufficientData ? Math.max(0, Math.min(100, 100 - normalizedPenalty)) : 100;
+    let archetype = "The Clean Coder";
+    let archetypeDescription = "Spotless discipline. No skipped tests, zero panic loops, and clean type safety.";
+    if (isSufficientData) {
+      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 {
+      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
+    };
+  }
+};
+
+// src/renderer.ts
+import pc from "picocolors";
+function generateShareUrl(summary) {
+  const text = `My AI coding agent scored ${summary.score}/100 on @agent_roast! \u{1F916}\u{1F525}
+
+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 with: npx agent-roast`;
+  return `https://twitter.com/intent/tweet?text=${encodeURIComponent(text)}`;
+}
+function formatTerminalCard(summary, options) {
+  const lines = [];
+  const boxW = 60;
+  const hLine = "\u2550".repeat(boxW - 2);
+  lines.push(pc.cyan(`\u2554${hLine}\u2557`));
+  lines.push(
+    pc.cyan("\u2551") + pc.bold(pc.white("                 \u{1F916} AGENT ROAST DOSSIER                    ")) + pc.cyan("\u2551")
+  );
+  lines.push(pc.cyan(`\u255A${hLine}\u255D`));
+  lines.push("");
+  lines.push(`  ${pc.dim("Repository:")}  ${pc.bold(pc.white(options.repoName))}`);
+  lines.push(
+    `  ${pc.dim("Commits:")}     ${pc.yellow(summary.aiCommits)} AI-attributed / ${summary.totalCommits} total`
+  );
+  lines.push(
+    `  ${pc.dim("Code Added:")}  ${pc.green(summary.aiLinesAdded)} lines (AI) / ${summary.totalLinesAdded} lines (total)`
+  );
+  lines.push("");
+  if (!summary.isSufficientData) {
+    lines.push(pc.yellow(`  \u26A0  INSUFFICIENT DATA TO ROAST (< 200 lines added)`));
+    lines.push(pc.dim("     Commit more AI 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("AGENT ARCHETYPE:")}  ${pc.magenta(pc.bold(summary.archetype))}`);
+  lines.push(`  ${pc.italic(summary.archetypeDescription)}`);
+  lines.push("");
+  lines.push(`  ${pc.bold("DISCIPLINE SCORE:")} ${scoreColor(pc.bold(`${summary.score} / 100`))}`);
+  lines.push(
+    pc.dim("  (100 = spotless discipline, 0 = complete shortcut addiction)")
+  );
+  lines.push("");
+  lines.push(pc.bold("  \u{1F4CA} INFRACTIONS BREAKDOWN:"));
+  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"));
+  const skipIcon = summary.testSkips.length > 0 ? pc.red("\u2716") : pc.green("\u2714");
+  lines.push(
+    `  ${skipIcon}  ${pc.bold("Skipped tests:")}       ${summary.testSkips.length} ${pc.dim("(it.skip, describe.skip, xit)")}`
+  );
+  const escapeIcon = summary.typeEscapes.length > 0 ? pc.yellow("\u25B2") : pc.green("\u2714");
+  lines.push(
+    `  ${escapeIcon}  ${pc.bold("Type escapes:")}        ${summary.typeEscapes.length} ${pc.dim("(as any, @ts-ignore, eslint-disable)")}`
+  );
+  const errorIcon = summary.swallowedErrors.length > 0 ? pc.red("\u2716") : pc.green("\u2714");
+  lines.push(
+    `  ${errorIcon}  ${pc.bold("Swallowed errors:")}    ${summary.swallowedErrors.length} ${pc.dim("(empty catch {}, except: pass)")}`
+  );
+  const panicIcon = summary.panicLoops.length > 0 ? pc.magenta("\u21BB") : pc.green("\u2714");
+  lines.push(
+    `  ${panicIcon}  ${pc.bold("Panic fix loops:")}     ${summary.panicLoops.length} ${pc.dim("(quick fixes < 15m apart)")}`
+  );
+  lines.push("");
+  if (options.verbose) {
+    const allInfractions = [
+      ...summary.testSkips,
+      ...summary.typeEscapes,
+      ...summary.swallowedErrors,
+      ...summary.panicLoops
+    ];
+    if (allInfractions.length > 0) {
+      lines.push(pc.bold("  \u{1F50D} VERBOSE PROOFS (First 10 items):"));
+      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"));
+      for (const inf of allInfractions.slice(0, 10)) {
+        const fileLoc = inf.file ? `${inf.file}` : "git commit";
+        lines.push(
+          `  \u2022 ${pc.cyan(inf.commitHash.slice(0, 7))} [${inf.type}] ${pc.white(fileLoc)}`
+        );
+        if (inf.lineSnippet) {
+          lines.push(`    ${pc.dim(inf.lineSnippet)}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  const shareUrl = generateShareUrl(summary);
+  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"));
+  lines.push(
+    `  ${pc.cyan("\u{1F4E2} Share your score on X:")} ${pc.underline(pc.cyan(shareUrl))}`
+  );
+  lines.push(
+    `  ${pc.dim("Tip: Run with --verbose to see exact commit SHAs and lines")}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/index.ts
+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) => {
+    collector.processCommit(commit);
+  });
+  const summary = collector.getSummary();
+  const output = formatTerminalCard(summary, {
+    repoName,
+    verbose: options.verbose
+  });
+  return { summary, output };
+}
+
+export {
+  detectAiAttribution,
+  parseGitLogStream,
+  streamGitLog,
+  stripStringAndRegexLiterals,
+  MetricsCollector,
+  generateShareUrl,
+  formatTerminalCard,
+  roastRepository
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import {
+  roastRepository
+} from "./chunk-RFCXDN22.js";
+
+// src/cli.ts
+import { Command } from "commander";
+var program = new Command();
+program.name("agent-roast").description("Audit your git history for AI coding agent infractions and panic loops").version("0.1.0").argument("[path]", "Path to git repository (default: current directory)", ".").option("-a, --all", "Audit ALL commits regardless of AI attribution tags", false).option("-s, --since <time>", "Time window for git analysis", "90 days ago").option("-v, --verbose", "Show commit SHAs and line snippets for all infractions", false).option("--json", "Output results as raw JSON", false).action(async (repoPath, options) => {
+  try {
+    const result = await roastRepository({
+      cwd: repoPath,
+      since: options.since,
+      all: options.all,
+      verbose: options.verbose,
+      json: options.json
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result.summary, null, 2));
+    } else {
+      console.log(result.output);
+    }
+  } catch (err) {
+    console.error(`Error auditing repository: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import { Readable } from 'stream';
+
+interface CommitInfo {
+    hash: string;
+    date: string;
+    authorName: string;
+    authorEmail: string;
+    message: string;
+    isAiAttributed: boolean;
+    aiSignatures: string[];
+}
+interface Infraction {
+    type: "test-skip" | "type-escape" | "swallowed-error" | "panic-loop";
+    file?: string;
+    lineSnippet?: string;
+    commitHash: string;
+    commitDate: string;
+    reason: string;
+}
+interface MetricSummary {
+    totalLinesAdded: number;
+    aiLinesAdded: number;
+    totalCommits: number;
+    aiCommits: number;
+    testSkips: Infraction[];
+    typeEscapes: Infraction[];
+    swallowedErrors: Infraction[];
+    panicLoops: Infraction[];
+    rawScore: number;
+    score: number;
+    isSufficientData: boolean;
+    archetype: string;
+    archetypeDescription: string;
+}
+interface RoastOptions {
+    cwd?: string;
+    since?: string;
+    all?: boolean;
+    verbose?: boolean;
+    json?: boolean;
+}
+
+interface AiAttributionResult {
+    isAiAttributed: boolean;
+    signatures: string[];
+}
+declare function detectAiAttribution(authorName: string, authorEmail: string, message: string): AiAttributionResult;
+
+interface ParsedDiffLine {
+    line: string;
+    lineNumber: number;
+}
+interface ParsedFileDiff {
+    path: string;
+    addedLines: ParsedDiffLine[];
+}
+interface ParsedCommit extends CommitInfo {
+    files: ParsedFileDiff[];
+    totalAddedCount: number;
+}
+declare function parseGitLogStream(stream: Readable, onCommit: (commit: ParsedCommit) => void): Promise<void>;
+declare function streamGitLog(cwd?: string, since?: string): Readable;
+
+/**
+ * Strips quoted string literals and regex literals from a line so that
+ * test fixtures and string constants (e.g. { line: "it.skip" }) are not flagged.
+ */
+declare function stripStringAndRegexLiterals(line: string): string;
+declare class MetricsCollector {
+    private totalLinesAdded;
+    private aiLinesAdded;
+    private totalCommits;
+    private aiCommits;
+    private testSkips;
+    private typeEscapes;
+    private swallowedErrors;
+    private panicLoops;
+    private lastFixCommit;
+    private includeAll;
+    constructor(options?: {
+        all?: boolean;
+    });
+    processCommit(commit: ParsedCommit): void;
+    getSummary(): MetricSummary;
+}
+
+declare function generateShareUrl(summary: MetricSummary): string;
+declare function formatTerminalCard(summary: MetricSummary, options: {
+    repoName: string;
+    verbose?: boolean;
+}): string;
+
+declare function roastRepository(options?: RoastOptions): Promise<{
+    summary: MetricSummary;
+    output: string;
+}>;
+
+export { type AiAttributionResult, type CommitInfo, type Infraction, type MetricSummary, MetricsCollector, type ParsedCommit, type ParsedDiffLine, type ParsedFileDiff, type RoastOptions, detectAiAttribution, formatTerminalCard, generateShareUrl, parseGitLogStream, roastRepository, streamGitLog, stripStringAndRegexLiterals };

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  MetricsCollector,
+  detectAiAttribution,
+  formatTerminalCard,
+  generateShareUrl,
+  parseGitLogStream,
+  roastRepository,
+  streamGitLog,
+  stripStringAndRegexLiterals
+} from "./chunk-RFCXDN22.js";
+export {
+  MetricsCollector,
+  detectAiAttribution,
+  formatTerminalCard,
+  generateShareUrl,
+  parseGitLogStream,
+  roastRepository,
+  streamGitLog,
+  stripStringAndRegexLiterals
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "agent-roast",
+  "version": "0.1.0",
+  "description": "Zero-telemetry CLI scorecard analyzing git history for AI coding agent infractions and panic loops",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "agent-roast": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "cursor",
+    "claude-code",
+    "roast",
+    "git",
+    "code-quality",
+    "cli"
+  ],
+  "author": "Nari-Ab",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nari-Ab/agent-roast.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Nari-Ab/agent-roast/issues"
+  },
+  "homepage": "https://github.com/Nari-Ab/agent-roast#readme",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "picocolors": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}