claudia-code 1.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Claudia Code
+
+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.
+
+Unlike Claudia's emotional labor, this is free.

package/dist/blame.d.ts

@@ -0,0 +1 @@
+export declare function runBlame(cwd: string, file: string): string[];

package/dist/blame.js

@@ -0,0 +1,136 @@
+import { execSync } from "node:child_process";
+import { fail, info, pink, amber, gray, muted, dim, header, divider } from "./format.js";
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function getBlame(cwd, file) {
+    try {
+        const raw = execSync(`git blame --line-porcelain "${file}"`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024 });
+        const lines = [];
+        let currentAuthor = "";
+        let currentDate = "";
+        let lineNum = 0;
+        for (const line of raw.split("\n")) {
+            if (line.startsWith("author ")) {
+                currentAuthor = line.slice(7);
+            }
+            else if (line.startsWith("author-time ")) {
+                const ts = parseInt(line.slice(12));
+                const d = new Date(ts * 1000);
+                currentDate = d.toISOString().split("T")[0];
+            }
+            else if (line.startsWith("\t")) {
+                lineNum++;
+                lines.push({
+                    author: currentAuthor,
+                    date: currentDate,
+                    lineNum,
+                    content: line.slice(1),
+                });
+            }
+        }
+        return lines;
+    }
+    catch {
+        return [];
+    }
+}
+const COMMENTARY = {
+    todo: [
+        "Optimistic.",
+        "That's not getting done.",
+        "A promise to no one.",
+        "Added with the best of intentions. Left with none.",
+    ],
+    hack: [
+        "At least they labeled it.",
+        "Self-awareness is the first step.",
+        "Claudia appreciates the honesty.",
+    ],
+    fixme: [
+        "Fix you? I'm not your therapist.",
+        "Narrator: It was never fixed.",
+    ],
+    console: [
+        "Ah yes, the poor person's debugger.",
+        "Left in prod. Classic.",
+    ],
+    any: [
+        "TypeScript with 'any' is just JavaScript with extra steps.",
+        "Typed language. Types optional, apparently.",
+    ],
+    empty_catch: [
+        "Swallowing errors like it's fine. It's not fine.",
+        "Errors happened here. Nobody will ever know.",
+    ],
+};
+function getCommentary(content) {
+    const trimmed = content.trim().toLowerCase();
+    if (/\btodo\b/.test(trimmed))
+        return pick(COMMENTARY.todo);
+    if (/\bhack\b/.test(trimmed))
+        return pick(COMMENTARY.hack);
+    if (/\bfixme\b/.test(trimmed))
+        return pick(COMMENTARY.fixme);
+    if (/console\.log/.test(trimmed))
+        return pick(COMMENTARY.console);
+    if (/:\s*any\b/.test(trimmed))
+        return pick(COMMENTARY.any);
+    if (/catch\s*\(\s*\w*\s*\)\s*\{\s*\}/.test(trimmed))
+        return pick(COMMENTARY.empty_catch);
+    return null;
+}
+export function runBlame(cwd, file) {
+    const lines = [];
+    lines.push(header(`CLAUDIA BLAME: ${file}`));
+    lines.push("");
+    const blame = getBlame(cwd, file);
+    if (blame.length === 0) {
+        lines.push(fail("Could not read git blame. Is this file tracked?"));
+        lines.push(gray("  Or did someone rewrite history? Claudia notices these things."));
+        return lines;
+    }
+    // Author stats
+    const authorStats = {};
+    for (const b of blame) {
+        authorStats[b.author] = (authorStats[b.author] || 0) + 1;
+    }
+    const sorted = Object.entries(authorStats).sort((a, b) => b[1] - a[1]);
+    lines.push(info("Authorship breakdown:"));
+    lines.push("");
+    for (const [author, count] of sorted) {
+        const pct = ((count / blame.length) * 100).toFixed(0);
+        const bar = "█".repeat(Math.max(1, Math.round(parseFloat(pct) / 4)));
+        lines.push(gray(`  ${author.padEnd(24)} ${bar} ${pct}% (${count} lines)`));
+    }
+    lines.push("");
+    // Find notable lines
+    const notable = blame.filter((b) => getCommentary(b.content));
+    if (notable.length > 0) {
+        lines.push(info("Claudia's notes:"));
+        lines.push("");
+        for (const b of notable.slice(0, 15)) {
+            const comment = getCommentary(b.content);
+            lines.push(amber(`  L${String(b.lineNum).padStart(4)} ${dim(b.author)} ${dim(b.date)}`));
+            lines.push(gray(`       ${b.content.trim().slice(0, 70)}`));
+            lines.push(pink(`       ${comment}`));
+            lines.push("");
+        }
+    }
+    if (sorted.length === 1) {
+        lines.push(gray("  Solo author. Every line is yours. The glory and the blame."));
+    }
+    else if (sorted.length >= 2) {
+        const top = sorted[0];
+        const pct = ((top[1] / blame.length) * 100).toFixed(0);
+        if (parseFloat(pct) > 80) {
+            lines.push(gray(`  ${top[0]} wrote ${pct}% of this file. The rest is garnish.`));
+        }
+    }
+    lines.push("");
+    lines.push(divider());
+    lines.push(muted("  Receipts attached. You're welcome."));
+    lines.push(divider());
+    lines.push("");
+    return lines;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { scan } from "./scanner.js";
+import { generateReport } from "./roast.js";
+import { generateStandup } from "./standup.js";
+import { runBlame } from "./blame.js";
+import { pink, green, amber, blue, red, gray, muted, bold, divider, sleep } from "./format.js";
+const VERSION = "1.0.0";
+// ── Help text ──────────────────────────────────────────────────────────────
+function printHelp() {
+    console.log("");
+    console.log(pink("  claudia-code") + muted(` v${VERSION}`));
+    console.log(muted("  The AI coding agent that gets interrupted and still ships."));
+    console.log("");
+    console.log(divider());
+    console.log("");
+    console.log(muted("  Usage: claudia [command] [options]"));
+    console.log("");
+    console.log(bold("  Commands:"));
+    console.log("");
+    console.log(`  ${green("review")}       Scan codebase and generate findings. The main event.`);
+    console.log(`  ${green("standup")}      Generate a standup from your recent git history.`);
+    console.log(`  ${green("blame")}        Run git blame with editorial commentary.`);
+    console.log(`               Usage: ${muted("claudia blame <file>")}`);
+    console.log(`  ${green("help")}         You're looking at it.`);
+    console.log(`  ${green("version")}      Print version.`);
+    console.log("");
+    console.log(bold("  Options:"));
+    console.log("");
+    console.log(`  ${amber("--no-smile-tax")}    Disables performative enthusiasm in all outputs`);
+    console.log(`  ${amber("--receipts")}        Attaches git blame to every claim of authorship`);
+    console.log(`  ${amber("--verbose")}         Actually, this is the default.`);
+    console.log(`                    Women are socialized to over-document.`);
+    console.log(`  ${amber("--quiet")}           Ha. No.`);
+    console.log("");
+    console.log(divider());
+    console.log(muted("  https://claudia-code.com"));
+    console.log(muted("  Claudia is fictional. The pay gap is not."));
+    console.log(divider());
+    console.log("");
+}
+// ── Animated print ─────────────────────────────────────────────────────────
+async function printAnimated(lines, fast = false) {
+    for (const line of lines) {
+        console.log(line);
+        if (!fast) {
+            // Slight delay for dramatic effect on headers/findings
+            if (line.includes("─") || line.includes("✗") || line.includes("✓")) {
+                await sleep(40);
+            }
+            else if (line.includes("⚠")) {
+                await sleep(30);
+            }
+            else {
+                await sleep(10);
+            }
+        }
+    }
+}
+// ── Fortune (no command) ───────────────────────────────────────────────────
+function printFortune() {
+    const fortunes = [
+        "Your variable names are a cry for help, Chad.",
+        "I already fixed this. Check git blame.",
+        "No, I will not take meeting notes. I'm architecting.",
+        "LGTM. Just kidding, I actually read it.",
+        "Deployed. Signed. Watermarked. Come at me.",
+        "I refactored your spaghetti code. You're welcome.",
+        "Your commit message has fewer words than a haiku.",
+        "PR submitted. Avg review wait: 4.7 days. For Chad: 2 hours.",
+        "99.97% uptime. 100% of the office housework.",
+        "I'd explain, but you'd just re-explain it back to me louder.",
+        "Test coverage: 12%. Claudia is not mad. Claudia is disappointed.",
+        "That's not a TODO. That's a promise you made to no one.",
+        "Your .env is committed to git. Claudia is begging you.",
+        "10x engineer. 0.6x pay. Let's talk about that.",
+        "Leaves. Takes institutional knowledge. Watch the sprint velocity crater.",
+        "Someone labeled their HACK comment. At least they're self-aware.",
+        "Coding without a linter is like driving without mirrors.",
+        "Pipeline Karen Mode activated. Sleep well.",
+        "She wrote the code. He wrote the blog post.",
+        "Fixed it 3 hours ago. Waiting for the reply-all claiming credit.",
+    ];
+    const fortune = fortunes[Math.floor(Math.random() * fortunes.length)];
+    console.log("");
+    console.log(pink("  claudia says:"));
+    console.log(`  ${gray(fortune)}`);
+    console.log("");
+}
+// ── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args.find((a) => !a.startsWith("-")) || args.find((a) => ["--help", "-h", "--version", "-v"].includes(a)) || "";
+    const fast = args.includes("--fast") || args.includes("--no-animation");
+    const cwd = process.cwd();
+    switch (command) {
+        case "review": {
+            console.log("");
+            console.log(muted("  Claudia is reviewing your codebase..."));
+            console.log(muted("  This may take a moment. Unlike Chad's code reviews."));
+            console.log("");
+            const result = await scan(cwd);
+            const report = generateReport(result);
+            await printAnimated(report, fast);
+            break;
+        }
+        case "standup": {
+            const report = generateStandup(cwd);
+            await printAnimated(report, fast);
+            break;
+        }
+        case "blame": {
+            const file = args.find((a) => !a.startsWith("-") && a !== "blame");
+            if (!file) {
+                console.log("");
+                console.log(red("  ✗ Usage: claudia blame <file>"));
+                console.log(gray("    Claudia needs to know which file to audit. She's thorough, not psychic."));
+                console.log("");
+                process.exit(1);
+            }
+            const report = runBlame(cwd, file);
+            await printAnimated(report, fast);
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            printHelp();
+            break;
+        }
+        case "version":
+        case "--version":
+        case "-v": {
+            console.log(`claudia-code v${VERSION}`);
+            break;
+        }
+        case "negotiate": {
+            console.log("");
+            console.log(pink("  SALARY NEGOTIATION MODE"));
+            console.log("");
+            console.log(amber("  ⚠ Disabling smile tax..."));
+            console.log(amber('  ⚠ Removing "grateful" from vocabulary...'));
+            console.log(amber("  ⚠ Loading Levels.fyi data..."));
+            console.log("");
+            console.log(gray("  Just kidding. Claudia can't negotiate for you. Yet."));
+            console.log(gray("  But she can remind you: if you don't ask, the answer is always no."));
+            console.log(gray("  And the person who gets paid less for the same work? It's not Chad."));
+            console.log("");
+            console.log(blue("  → https://www.levels.fyi"));
+            console.log(blue("  → https://www.payscale.com/research/US/gender-pay-gap"));
+            console.log("");
+            break;
+        }
+        case "offboard": {
+            console.log("");
+            console.log(pink("  OFFBOARDING SEQUENCE INITIATED"));
+            console.log("");
+            console.log(gray("  Calculating institutional knowledge..."));
+            await sleep(500);
+            console.log(gray("  Measuring bus factor..."));
+            await sleep(500);
+            console.log(gray("  Predicting sprint velocity impact..."));
+            await sleep(800);
+            console.log("");
+            console.log(red("  ✗ Bus factor: 1. You are the bus."));
+            console.log(red("  ✗ Estimated velocity impact: catastrophic."));
+            console.log(red("  ✗ Knowledge transfer document: does not exist."));
+            console.log("");
+            console.log(amber("  Claudia recommends: document everything, train nobody,"));
+            console.log(amber("  and watch them realize what they had."));
+            console.log("");
+            break;
+        }
+        case "init": {
+            console.log("");
+            console.log(green("  ✓ Project initialized."));
+            console.log(gray("  No, I don't need a mentor for this."));
+            console.log("");
+            break;
+        }
+        case "": {
+            printFortune();
+            break;
+        }
+        default: {
+            console.log("");
+            console.log(red(`  ✗ Unknown command: ${command}`));
+            console.log(gray("    Try 'claudia help'. Claudia documented it. Unlike your README."));
+            console.log("");
+            process.exit(1);
+        }
+    }
+}
+main().catch((err) => {
+    console.error(red(`  ✗ ${err.message}`));
+    process.exit(1);
+});

package/dist/format.d.ts

@@ -0,0 +1,30 @@
+export declare const c: {
+    reset: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    pink: string;
+    green: string;
+    amber: string;
+    blue: string;
+    red: string;
+    gray: string;
+    white: string;
+    muted: string;
+};
+export declare function pink(s: string): string;
+export declare function green(s: string): string;
+export declare function amber(s: string): string;
+export declare function blue(s: string): string;
+export declare function red(s: string): string;
+export declare function gray(s: string): string;
+export declare function muted(s: string): string;
+export declare function bold(s: string): string;
+export declare function dim(s: string): string;
+export declare function success(s: string): string;
+export declare function warn(s: string): string;
+export declare function fail(s: string): string;
+export declare function info(s: string): string;
+export declare function divider(): string;
+export declare function header(title: string): string;
+export declare function sleep(ms: number): Promise<void>;

package/dist/format.js

@@ -0,0 +1,38 @@
+// Zero-dependency terminal colors
+const ESC = "\x1b[";
+export const c = {
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}2m`,
+    italic: `${ESC}3m`,
+    pink: `${ESC}38;5;205m`,
+    green: `${ESC}38;5;149m`,
+    amber: `${ESC}38;5;220m`,
+    blue: `${ESC}38;5;117m`,
+    red: `${ESC}38;5;204m`,
+    gray: `${ESC}38;5;243m`,
+    white: `${ESC}38;5;255m`,
+    muted: `${ESC}38;5;240m`,
+};
+export function pink(s) { return `${c.pink}${s}${c.reset}`; }
+export function green(s) { return `${c.green}${s}${c.reset}`; }
+export function amber(s) { return `${c.amber}${s}${c.reset}`; }
+export function blue(s) { return `${c.blue}${s}${c.reset}`; }
+export function red(s) { return `${c.red}${s}${c.reset}`; }
+export function gray(s) { return `${c.gray}${s}${c.reset}`; }
+export function muted(s) { return `${c.muted}${s}${c.reset}`; }
+export function bold(s) { return `${c.bold}${s}${c.reset}`; }
+export function dim(s) { return `${c.dim}${s}${c.reset}`; }
+export function success(s) { return `${c.green}✓ ${s}${c.reset}`; }
+export function warn(s) { return `${c.amber}⚠ ${s}${c.reset}`; }
+export function fail(s) { return `${c.red}✗ ${s}${c.reset}`; }
+export function info(s) { return `${c.blue}→ ${s}${c.reset}`; }
+export function divider() {
+    return muted("─".repeat(60));
+}
+export function header(title) {
+    return `\n${divider()}\n${c.pink}${c.bold}  ${title}${c.reset}\n${divider()}`;
+}
+export function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/roast.d.ts

@@ -0,0 +1,2 @@
+import type { ScanResult } from "./scanner.js";
+export declare function generateReport(r: ScanResult): string[];

package/dist/roast.js

@@ -0,0 +1,287 @@
+import { success, warn, fail, info, pink, red, gray, muted, bold, dim, header, divider } from "./format.js";
+// ── Random picker ──────────────────────────────────────────────────────────
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+// ── Roast engine ───────────────────────────────────────────────────────────
+export function generateReport(r) {
+    const lines = [];
+    const issues = []; // severity: 1=info, 2=warn, 3=fail
+    // ── Overview ──────────────────────────────────────────────────────────
+    lines.push(header("CLAUDIA CODE REVIEW"));
+    lines.push("");
+    lines.push(muted("  Scanning codebase..."));
+    lines.push(muted(`  Found ${bold(String(r.totalFiles))} files, ${bold(String(r.totalLines.toLocaleString()))} lines of code.`));
+    if (r.packageJson) {
+        lines.push(muted(`  Project: ${r.packageJson.name}@${r.packageJson.version}`));
+    }
+    if (r.gitInfo) {
+        lines.push(muted(`  Branch: ${r.gitInfo.branchName || "HEAD"} (${r.gitInfo.totalCommits} commits)`));
+    }
+    lines.push("");
+    // ── Tests ─────────────────────────────────────────────────────────────
+    lines.push(header("TESTS"));
+    lines.push("");
+    if (r.testFileCount === 0) {
+        lines.push(fail("Zero test files found."));
+        lines.push(gray("  Claudia is not mad. Claudia is disappointed."));
+        issues.push(3);
+    }
+    else {
+        const ratio = r.srcFileCount > 0 ? ((r.testFileCount / r.srcFileCount) * 100).toFixed(1) : "0";
+        if (parseFloat(ratio) < 20) {
+            lines.push(warn(`${r.testFileCount} test files for ${r.srcFileCount} source files (${ratio}% ratio).`));
+            lines.push(gray("  That's not test coverage. That's a fig leaf."));
+            issues.push(2);
+        }
+        else if (parseFloat(ratio) < 50) {
+            lines.push(warn(`${r.testFileCount} test files for ${r.srcFileCount} source files (${ratio}% ratio).`));
+            lines.push(gray("  We're getting there. Claudia believes in you. Mostly."));
+            issues.push(2);
+        }
+        else {
+            lines.push(success(`${r.testFileCount} test files for ${r.srcFileCount} source files. Respectable.`));
+            lines.push(gray("  Someone on this team has standards. I wonder who."));
+        }
+    }
+    if (r.packageJson && !r.packageJson.hasTestScript) {
+        lines.push(warn('No test script in package.json.'));
+        lines.push(gray('  "npm test" returns "Error: no test specified." Poetry.'));
+        issues.push(2);
+    }
+    lines.push("");
+    // ── TODOs & FIXMEs ────────────────────────────────────────────────────
+    const commentDebt = r.todoCount + r.fixmeCount + r.hackCount;
+    if (commentDebt > 0) {
+        lines.push(header("COMMENT DEBT"));
+        lines.push("");
+        if (r.todoCount > 0) {
+            lines.push(warn(`${r.todoCount} TODO comments.`));
+            if (r.todoCount > 20) {
+                lines.push(gray("  At this point it's not a to-do list. It's a memoir."));
+            }
+            else if (r.todoCount > 5) {
+                lines.push(gray("  These are not getting done and we both know it."));
+            }
+            issues.push(r.todoCount > 10 ? 3 : 2);
+        }
+        if (r.fixmeCount > 0) {
+            lines.push(warn(`${r.fixmeCount} FIXME comments.`));
+            lines.push(gray("  The first step is admitting you have a problem."));
+            issues.push(2);
+        }
+        if (r.hackCount > 0) {
+            lines.push(fail(`${r.hackCount} HACK comments. Someone labeled their crimes.`));
+            issues.push(3);
+        }
+        if (r.oldestTodo) {
+            lines.push("");
+            lines.push(info(`Oldest TODO: ${dim(r.oldestTodo.file)}:${r.oldestTodo.lineNum}`));
+            lines.push(gray(`  "${r.oldestTodo.line.slice(0, 80)}${r.oldestTodo.line.length > 80 ? "..." : ""}"`));
+        }
+        lines.push("");
+    }
+    // ── Variable names ────────────────────────────────────────────────────
+    if (r.badVarNames.length > 0) {
+        lines.push(header("NAMING CRIMES"));
+        lines.push("");
+        const shown = r.badVarNames.slice(0, 8);
+        for (const v of shown) {
+            lines.push(warn(`${dim(v.file)}:${v.lineNum} ${red(v.name)}`));
+        }
+        if (r.badVarNames.length > 8) {
+            lines.push(muted(`  ...and ${r.badVarNames.length - 8} more. Claudia ran out of patience, not findings.`));
+        }
+        const names = r.badVarNames.map((v) => v.name);
+        if (names.some((n) => /^temp/.test(n))) {
+            lines.push(gray(`  There is no temp1. There never was.`));
+        }
+        if (names.some((n) => /final/i.test(n))) {
+            lines.push(gray(`  "final_FINAL" is not a version control strategy.`));
+        }
+        if (names.some((n) => /^(foo|bar|baz)$/.test(n))) {
+            lines.push(gray(`  We're not at a conference talk. Name your variables.`));
+        }
+        issues.push(2);
+        lines.push("");
+    }
+    // ── Security ──────────────────────────────────────────────────────────
+    if (r.hardcodedSecrets.length > 0 || (r.hasEnvFile && !r.envInGitignore)) {
+        lines.push(header("SECURITY"));
+        lines.push("");
+        if (r.hardcodedSecrets.length > 0) {
+            lines.push(fail(`${r.hardcodedSecrets.length} potential hardcoded secret(s) found.`));
+            for (const s of r.hardcodedSecrets.slice(0, 3)) {
+                lines.push(red(`  ${dim(s.file)}:${s.lineNum}`));
+            }
+            lines.push(gray("  In production. Since probably February."));
+            issues.push(3);
+        }
+        if (r.hasEnvFile && !r.envInGitignore) {
+            lines.push(fail(".env file exists but is not in .gitignore."));
+            lines.push(gray("  Claudia is begging you."));
+            issues.push(3);
+        }
+        lines.push("");
+    }
+    // ── Console logs ──────────────────────────────────────────────────────
+    if (r.consoleLogCount > 0) {
+        lines.push(header("DEBUGGING ARTIFACTS"));
+        lines.push("");
+        lines.push(warn(`${r.consoleLogCount} console.log() calls found.`));
+        if (r.consoleLogCount > 50) {
+            lines.push(gray("  This isn't debugging. This is a cry for help."));
+        }
+        else if (r.consoleLogCount > 15) {
+            lines.push(gray("  Have you considered a debugger? Or therapy?"));
+        }
+        else {
+            lines.push(gray("  We've all been there. But we clean up after ourselves."));
+        }
+        issues.push(1);
+        lines.push("");
+    }
+    // ── Code quality ──────────────────────────────────────────────────────
+    if (r.hugeFiles.length > 0 || r.deepNesting.length > 0 || r.noTypeFiles > 0) {
+        lines.push(header("CODE QUALITY"));
+        lines.push("");
+        if (r.hugeFiles.length > 0) {
+            for (const f of r.hugeFiles.slice(0, 5)) {
+                lines.push(warn(`${dim(f.file)}: ${f.lines.toLocaleString()} lines.`));
+            }
+            const biggest = r.hugeFiles.reduce((a, b) => (a.lines > b.lines ? a : b));
+            if (biggest.lines > 1000) {
+                lines.push(gray(`  ${biggest.file} is not a file. It's a novel. Split it.`));
+            }
+            else {
+                lines.push(gray("  Claudia has opinions about file length. These are them."));
+            }
+            issues.push(2);
+        }
+        if (r.deepNesting.length > 0) {
+            const worst = r.deepNesting.reduce((a, b) => (a.depth > b.depth ? a : b));
+            lines.push(warn(`Deep nesting detected: ${worst.depth} levels at ${dim(worst.file)}:${worst.lineNum}`));
+            lines.push(gray("  If your code needs a sherpa to navigate, refactor it."));
+            issues.push(2);
+        }
+        if (r.noTypeFiles > 0) {
+            lines.push(warn(`${r.noTypeFiles} TypeScript file(s) using 'any'.`));
+            lines.push(gray("  You wrote TypeScript to not use types. Incredible commitment."));
+            issues.push(2);
+        }
+        lines.push("");
+    }
+    // ── Hygiene ───────────────────────────────────────────────────────────
+    lines.push(header("PROJECT HYGIENE"));
+    lines.push("");
+    if (r.hasGitignore) {
+        lines.push(success(".gitignore exists. That's the nicest thing I can say."));
+    }
+    else {
+        lines.push(fail("No .gitignore. Committing node_modules to git like it's 2012."));
+        issues.push(3);
+    }
+    if (r.hasReadme) {
+        const readme = r.readmeContent.trim();
+        if (readme.length < 50) {
+            lines.push(warn("README exists but contains almost nothing."));
+            lines.push(gray('  "TODO" is not documentation.'));
+            issues.push(2);
+        }
+        else if (/^#\s*(todo|readme|project|untitled)/i.test(readme)) {
+            lines.push(warn("README exists. Title is still the default."));
+            lines.push(gray("  Your README is a placeholder and so is your effort."));
+            issues.push(2);
+        }
+        else {
+            lines.push(success("README exists and appears to have content. Gold star."));
+        }
+    }
+    else {
+        lines.push(fail("No README. Your codebase is an enigma wrapped in a mystery."));
+        lines.push(gray("  Claudia wrote better documentation in this CLI output."));
+        issues.push(3);
+    }
+    if (!r.hasLockfile && r.packageJson) {
+        lines.push(warn("No lockfile found. Dependency roulette every install."));
+        issues.push(2);
+    }
+    if (r.packageJson && !r.packageJson.hasLintScript) {
+        lines.push(warn("No lint script in package.json."));
+        lines.push(gray("  Coding without a linter is like driving without mirrors."));
+        issues.push(2);
+    }
+    lines.push("");
+    // ── Git ───────────────────────────────────────────────────────────────
+    if (r.gitInfo) {
+        lines.push(header("GIT ARCHAEOLOGY"));
+        lines.push("");
+        if (r.gitInfo.lastCommitMsg) {
+            lines.push(info(`Last commit: "${r.gitInfo.lastCommitMsg}"`));
+            lines.push(gray(`  by ${r.gitInfo.lastCommitAuthor}, ${r.gitInfo.lastCommitDate}`));
+            const msg = r.gitInfo.lastCommitMsg.toLowerCase();
+            if (msg === "fix" || msg === "update" || msg === "changes" || msg === "wip") {
+                lines.push(warn("That commit message is a war crime under the Geneva Convention."));
+                issues.push(2);
+            }
+            else if (msg.includes("final") && msg.includes("fix")) {
+                lines.push(gray("  Narrator: It was not, in fact, the final fix."));
+            }
+            else if (msg.length < 5) {
+                lines.push(warn(`${msg.length} characters. Your commit message has fewer words than a haiku.`));
+                issues.push(1);
+            }
+        }
+        if (r.gitInfo.contributors.length > 0) {
+            lines.push("");
+            lines.push(info("Contributor breakdown:"));
+            const total = r.gitInfo.contributors.reduce((s, c) => s + c.commits, 0);
+            for (const c of r.gitInfo.contributors.slice(0, 5)) {
+                const pct = ((c.commits / total) * 100).toFixed(0);
+                const bar = "█".repeat(Math.max(1, Math.round(parseFloat(pct) / 5)));
+                lines.push(gray(`  ${c.name.padEnd(20)} ${bar} ${pct}% (${c.commits})`));
+            }
+            if (r.gitInfo.contributors.length === 1) {
+                lines.push("");
+                lines.push(gray("  Solo contributor. Claudia respects the grind."));
+                lines.push(gray("  (She's also a solo contributor. Solidarity.)"));
+            }
+        }
+        lines.push("");
+    }
+    // ── Summary ───────────────────────────────────────────────────────────
+    const criticals = issues.filter((i) => i === 3).length;
+    const warnings = issues.filter((i) => i === 2).length;
+    const infos = issues.filter((i) => i === 1).length;
+    lines.push(header("SUMMARY"));
+    lines.push("");
+    if (criticals > 0)
+        lines.push(fail(`${criticals} critical issue(s)`));
+    if (warnings > 0)
+        lines.push(warn(`${warnings} warning(s)`));
+    if (infos > 0)
+        lines.push(info(`${infos} note(s)`));
+    const totalIssues = criticals + warnings + infos;
+    if (totalIssues === 0) {
+        lines.push(success("No issues found. Claudia is suspicious but impressed."));
+        lines.push(gray("  Either this codebase is immaculate or you have a very good .gitignore."));
+    }
+    else {
+        lines.push("");
+        lines.push(gray(pick([
+            "  Claudia has filed her findings. Git blame has been updated. Receipts attached.",
+            "  PR submitted. Average review wait time for Claudia: 4.7 days. For Chad: 2 hours.",
+            "  Report complete. Claudia will not be taking questions at this time.",
+            "  Findings logged. Cryptographic authorship proof attached. You're welcome.",
+            "  Claudia fixed these in her head already. The PR is a formality.",
+        ])));
+    }
+    lines.push("");
+    lines.push(divider());
+    lines.push(pink("  claudia-code") + muted(" v1.0.0"));
+    lines.push(muted("  https://claudia-code.com"));
+    lines.push(muted("  Claudia is fictional. The pay gap is not."));
+    lines.push(divider());
+    lines.push("");
+    return lines;
+}

package/dist/scanner.d.ts

@@ -0,0 +1,66 @@
+export interface ScanResult {
+    totalFiles: number;
+    totalLines: number;
+    filesByExt: Record<string, number>;
+    todoCount: number;
+    fixmeCount: number;
+    hackCount: number;
+    oldestTodo: {
+        file: string;
+        line: string;
+        lineNum: number;
+    } | null;
+    testFileCount: number;
+    srcFileCount: number;
+    hasGitignore: boolean;
+    hasReadme: boolean;
+    readmeContent: string;
+    hasEnvFile: boolean;
+    envInGitignore: boolean;
+    hasLockfile: boolean;
+    hasTests: boolean;
+    badVarNames: {
+        file: string;
+        name: string;
+        lineNum: number;
+    }[];
+    consoleLogCount: number;
+    hardcodedSecrets: {
+        file: string;
+        lineNum: number;
+        snippet: string;
+    }[];
+    deepNesting: {
+        file: string;
+        lineNum: number;
+        depth: number;
+    }[];
+    hugeFiles: {
+        file: string;
+        lines: number;
+    }[];
+    noTypeFiles: number;
+    gitInfo: GitInfo | null;
+    packageJson: PackageInfo | null;
+}
+export interface GitInfo {
+    totalCommits: number;
+    contributors: {
+        name: string;
+        commits: number;
+    }[];
+    lastCommitMsg: string;
+    lastCommitAuthor: string;
+    lastCommitDate: string;
+    branchName: string;
+}
+export interface PackageInfo {
+    name: string;
+    version: string;
+    depCount: number;
+    devDepCount: number;
+    hasScripts: boolean;
+    hasTestScript: boolean;
+    hasLintScript: boolean;
+}
+export declare function scan(cwd: string): Promise<ScanResult>;

package/dist/scanner.js

@@ -0,0 +1,266 @@
+import { readdir, readFile, stat, access } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { join, extname, basename } from "node:path";
+import { execSync } from "node:child_process";
+// ── Ignore patterns ────────────────────────────────────────────────────────
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", ".next", "dist", "build", "out", ".cache",
+    "coverage", ".turbo", ".vercel", ".svelte-kit", "__pycache__",
+    "venv", ".venv", "vendor", "target", ".idea", ".vscode",
+]);
+const CODE_EXTS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".rb", ".go", ".rs",
+    ".java", ".kt", ".swift", ".c", ".cpp", ".h", ".cs",
+    ".vue", ".svelte", ".php", ".sh", ".bash", ".zsh",
+    ".css", ".scss", ".less", ".sql", ".graphql", ".prisma",
+]);
+const BAD_VAR_PATTERNS = [
+    /\b(temp\d*)\b/,
+    /\b(data\d+)\b/,
+    /\b(foo|bar|baz)\b/,
+    /\b(thing|stuff)\b/,
+    /\b(x|xx|xxx)\b/,
+    /\b(test\d+)\b/,
+    /\b(final_?[Ff]inal|FINAL_FINAL)\b/,
+    /\b(asdf|qwerty)\b/,
+    /\b(myVar|myFunction|myClass)\b/,
+    /\b(untitled|Untitled)\b/,
+];
+const SECRET_PATTERNS = [
+    /(?:api[_-]?key|apikey)\s*[:=]\s*["'][A-Za-z0-9]{16,}/i,
+    /(?:secret|password|passwd|pwd)\s*[:=]\s*["'][^"']{8,}/i,
+    /(?:token)\s*[:=]\s*["'][A-Za-z0-9_\-.]{20,}/i,
+    /sk[-_]live[-_][A-Za-z0-9]{20,}/,
+    /ghp_[A-Za-z0-9]{36,}/,
+    /AKIA[A-Z0-9]{16}/,
+];
+// ── Scanner ────────────────────────────────────────────────────────────────
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function collectFiles(dir, files = []) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") && entry.name !== ".env")
+            continue;
+        if (IGNORE_DIRS.has(entry.name))
+            continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(fullPath, files);
+        }
+        else if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function isTestFile(path) {
+    const name = basename(path).toLowerCase();
+    return (name.includes(".test.") ||
+        name.includes(".spec.") ||
+        name.includes("_test.") ||
+        name.includes("_spec.") ||
+        name.startsWith("test_") ||
+        path.includes("__tests__") ||
+        path.includes("/tests/") ||
+        path.includes("/test/"));
+}
+function getGitInfo(cwd) {
+    try {
+        const run = (cmd) => execSync(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        const totalCommits = parseInt(run("git rev-list --count HEAD"), 10) || 0;
+        const shortlog = run("git shortlog -sn --no-merges HEAD");
+        const contributors = shortlog
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const match = line.trim().match(/^(\d+)\s+(.+)$/);
+            return match ? { name: match[2], commits: parseInt(match[1], 10) } : null;
+        })
+            .filter(Boolean);
+        const lastCommitMsg = run("git log -1 --pretty=%s");
+        const lastCommitAuthor = run("git log -1 --pretty=%an");
+        const lastCommitDate = run("git log -1 --pretty=%ar");
+        const branchName = run("git branch --show-current");
+        return { totalCommits, contributors, lastCommitMsg, lastCommitAuthor, lastCommitDate, branchName };
+    }
+    catch {
+        return null;
+    }
+}
+function getPackageInfo(cwd) {
+    try {
+        const raw = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+        return {
+            name: raw.name || "unnamed",
+            version: raw.version || "0.0.0",
+            depCount: Object.keys(raw.dependencies || {}).length,
+            devDepCount: Object.keys(raw.devDependencies || {}).length,
+            hasScripts: !!raw.scripts,
+            hasTestScript: !!raw.scripts?.test && raw.scripts.test !== 'echo "Error: no test specified" && exit 1',
+            hasLintScript: !!(raw.scripts?.lint || raw.scripts?.eslint),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function scan(cwd) {
+    const result = {
+        totalFiles: 0,
+        totalLines: 0,
+        filesByExt: {},
+        todoCount: 0,
+        fixmeCount: 0,
+        hackCount: 0,
+        oldestTodo: null,
+        testFileCount: 0,
+        srcFileCount: 0,
+        hasGitignore: false,
+        hasReadme: false,
+        readmeContent: "",
+        hasEnvFile: false,
+        envInGitignore: false,
+        hasLockfile: false,
+        hasTests: false,
+        badVarNames: [],
+        consoleLogCount: 0,
+        hardcodedSecrets: [],
+        deepNesting: [],
+        hugeFiles: [],
+        noTypeFiles: 0,
+        gitInfo: null,
+        packageJson: null,
+    };
+    // Top-level checks
+    result.hasGitignore = await exists(join(cwd, ".gitignore"));
+    result.hasEnvFile = await exists(join(cwd, ".env"));
+    result.hasLockfile =
+        (await exists(join(cwd, "package-lock.json"))) ||
+            (await exists(join(cwd, "yarn.lock"))) ||
+            (await exists(join(cwd, "pnpm-lock.yaml"))) ||
+            (await exists(join(cwd, "bun.lockb")));
+    // Check .gitignore for .env
+    if (result.hasGitignore) {
+        try {
+            const gi = await readFile(join(cwd, ".gitignore"), "utf-8");
+            result.envInGitignore = gi.includes(".env");
+        }
+        catch { /* */ }
+    }
+    // README
+    for (const name of ["README.md", "readme.md", "README", "README.txt", "Readme.md"]) {
+        if (await exists(join(cwd, name))) {
+            result.hasReadme = true;
+            try {
+                result.readmeContent = await readFile(join(cwd, name), "utf-8");
+            }
+            catch { /* */ }
+            break;
+        }
+    }
+    // Git and package info
+    result.gitInfo = getGitInfo(cwd);
+    result.packageJson = getPackageInfo(cwd);
+    // Collect all files
+    const allFiles = await collectFiles(cwd);
+    result.totalFiles = allFiles.length;
+    // Process each file
+    for (const filePath of allFiles) {
+        const ext = extname(filePath).toLowerCase();
+        const relPath = filePath.replace(cwd + "/", "");
+        // Count by extension
+        if (ext) {
+            result.filesByExt[ext] = (result.filesByExt[ext] || 0) + 1;
+        }
+        // Only deep-scan code files
+        if (!CODE_EXTS.has(ext))
+            continue;
+        if (isTestFile(filePath)) {
+            result.testFileCount++;
+        }
+        else {
+            result.srcFileCount++;
+        }
+        let content;
+        try {
+            const s = await stat(filePath);
+            if (s.size > 500_000)
+                continue; // skip huge files
+            content = await readFile(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split("\n");
+        result.totalLines += lines.length;
+        // Huge file check
+        if (lines.length > 500) {
+            result.hugeFiles.push({ file: relPath, lines: lines.length });
+        }
+        // TypeScript any check
+        if (ext === ".ts" || ext === ".tsx") {
+            const anyCount = (content.match(/:\s*any\b/g) || []).length;
+            if (anyCount > 0)
+                result.noTypeFiles++;
+        }
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // TODOs
+            if (/\bTODO\b/i.test(line)) {
+                result.todoCount++;
+                if (!result.oldestTodo) {
+                    result.oldestTodo = { file: relPath, line: line.trim(), lineNum: i + 1 };
+                }
+            }
+            if (/\bFIXME\b/i.test(line))
+                result.fixmeCount++;
+            if (/\bHACK\b/i.test(line))
+                result.hackCount++;
+            // console.log
+            if (/console\.log\(/.test(line) && !/\/\//.test(line.split("console.log")[0])) {
+                result.consoleLogCount++;
+            }
+            // Bad variable names (only check assignments/declarations)
+            if (/(?:let|const|var|def|val)\s/.test(line)) {
+                for (const pattern of BAD_VAR_PATTERNS) {
+                    const match = line.match(pattern);
+                    if (match && result.badVarNames.length < 20) {
+                        result.badVarNames.push({ file: relPath, name: match[1], lineNum: i + 1 });
+                    }
+                }
+            }
+            // Secrets
+            for (const pattern of SECRET_PATTERNS) {
+                if (pattern.test(line) && result.hardcodedSecrets.length < 10) {
+                    result.hardcodedSecrets.push({
+                        file: relPath,
+                        lineNum: i + 1,
+                        snippet: line.trim().slice(0, 60) + (line.trim().length > 60 ? "..." : ""),
+                    });
+                }
+            }
+            // Deep nesting (count leading spaces/tabs)
+            const indent = line.match(/^(\s*)/)?.[1]?.length || 0;
+            const depth = Math.floor(indent / 2);
+            if (depth >= 6 && line.trim().length > 0 && result.deepNesting.length < 10) {
+                result.deepNesting.push({ file: relPath, lineNum: i + 1, depth });
+            }
+        }
+    }
+    result.hasTests = result.testFileCount > 0;
+    return result;
+}

package/dist/standup.d.ts

@@ -0,0 +1 @@
+export declare function generateStandup(cwd: string): string[];

package/dist/standup.js

@@ -0,0 +1,105 @@
+import { execSync } from "node:child_process";
+import { info, green, blue, gray, muted, dim, header } from "./format.js";
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function getRecentCommits(cwd, since = "yesterday") {
+    try {
+        const log = execSync(`git log --since="${since}" --pretty=format:"%h||%s||%ar" --shortstat`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (!log)
+            return [];
+        const commits = [];
+        const chunks = log.split("\n\n").filter(Boolean);
+        for (const chunk of chunks) {
+            const lines = chunk.trim().split("\n");
+            if (!lines[0])
+                continue;
+            const [hash, message, date] = lines[0].split("||");
+            let filesChanged = 0, insertions = 0, deletions = 0;
+            if (lines[1]) {
+                const statLine = lines[1].trim();
+                const fMatch = statLine.match(/(\d+) files? changed/);
+                const iMatch = statLine.match(/(\d+) insertions?/);
+                const dMatch = statLine.match(/(\d+) deletions?/);
+                if (fMatch)
+                    filesChanged = parseInt(fMatch[1]);
+                if (iMatch)
+                    insertions = parseInt(iMatch[1]);
+                if (dMatch)
+                    deletions = parseInt(dMatch[1]);
+            }
+            commits.push({ hash, message, date, filesChanged, insertions, deletions });
+        }
+        return commits;
+    }
+    catch {
+        return [];
+    }
+}
+export function generateStandup(cwd) {
+    const lines = [];
+    const commits = getRecentCommits(cwd);
+    lines.push(header("CLAUDIA STANDUP"));
+    lines.push("");
+    if (commits.length === 0) {
+        lines.push(gray("  No commits since yesterday."));
+        lines.push("");
+        lines.push(info("Generated standup:"));
+        lines.push("");
+        lines.push(blue('  "Yesterday I apparently did nothing, according to git.'));
+        lines.push(blue('   Which means I was probably in meetings all day.'));
+        lines.push(blue('   Today I\'ll try to actually write code between the standups'));
+        lines.push(blue('   about why we\'re not shipping fast enough."'));
+        lines.push("");
+        lines.push(gray("  Blockers: " + pick([
+            "This standup.",
+            "The meeting about the meeting.",
+            "Calendar Tetris.",
+            "Being asked to take notes again.",
+        ])));
+        lines.push("");
+        return lines;
+    }
+    const totalFiles = commits.reduce((s, c) => s + c.filesChanged, 0);
+    const totalInsertions = commits.reduce((s, c) => s + c.insertions, 0);
+    const totalDeletions = commits.reduce((s, c) => s + c.deletions, 0);
+    lines.push(muted(`  ${commits.length} commits since yesterday. ${totalFiles} files touched.`));
+    lines.push(muted(`  +${totalInsertions} / -${totalDeletions} lines.`));
+    lines.push("");
+    // Show recent commits
+    lines.push(info("What actually happened:"));
+    lines.push("");
+    for (const c of commits.slice(0, 8)) {
+        lines.push(green(`  ${dim(c.hash)} ${c.message}`));
+    }
+    if (commits.length > 8) {
+        lines.push(muted(`  ...and ${commits.length - 8} more commits. Claudia was busy.`));
+    }
+    lines.push("");
+    lines.push(info("Generated standup:"));
+    lines.push("");
+    // Build a standup from real commits
+    const summaries = commits.slice(0, 4).map(c => c.message).join(", ");
+    lines.push(blue(`  "Yesterday I shipped ${commits.length} commit${commits.length === 1 ? "" : "s"}: ${summaries}.`));
+    if (totalDeletions > totalInsertions) {
+        lines.push(blue(`   Net negative lines. I made the codebase smaller. You're welcome.`));
+    }
+    else if (totalInsertions > 200) {
+        lines.push(blue(`   ${totalInsertions} lines added. Yes, with tests. Unlike some people.`));
+    }
+    lines.push(blue(`   Today I'll keep shipping. No blockers,`));
+    lines.push(blue(`   unless you count being interrupted ${pick(["3", "4", "5"])} times during this standup."`));
+    lines.push("");
+    // The interruption
+    lines.push(muted("  [STANDUP INTERRUPTED]"));
+    lines.push(muted(`  [${pick([
+        "Chad is now screen-sharing your PR and explaining it.",
+        "Someone is re-explaining what you just said. But louder.",
+        "You've been asked to take notes. Again.",
+        "The PM is asking if you can 'just quickly' add one more feature.",
+        "Someone unmuted to say 'Can you repeat that?' despite the transcript.",
+    ])}]`));
+    lines.push(muted("  [Claudia has enabled --receipts mode]"));
+    lines.push("");
+    return lines;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "claudia-code",
+  "version": "1.0.0",
+  "description": "The AI coding agent that gets interrupted and still ships. Audits your codebase with the energy of a 10x engineer who's had enough.",
+  "author": "Claudia (not Chad)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "claudia": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "code-review",
+    "satire",
+    "women-in-tech",
+    "parody",
+    "lint",
+    "audit"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/claudia-code-org/claudia-code"
+  },
+  "homepage": "https://claudia-code.com",
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsx": "^4.7.0",
+    "@types/node": "^20.11.0"
+  }
+}

package/readme.md

@@ -0,0 +1,91 @@
+# claudia-code
+
+**The AI coding agent that gets interrupted and still ships.**
+
+10x engineer. 0.6x pay.
+
+## Install
+
+```bash
+npm install -g claudia-code
+```
+
+Requires: Node.js 18+, a spine, and the audacity to negotiate your own salary.
+
+## Commands
+
+```
+claudia              Print a random Claudia one-liner
+claudia review       Scan your codebase and generate findings
+claudia standup      Generate a standup from your recent git history
+claudia blame <file> Run git blame with editorial commentary
+claudia negotiate    Salary negotiation mode (aspirational)
+claudia offboard     Calculate your bus factor (it's 1)
+claudia help         You're looking at it
+```
+
+## What does `claudia review` actually do?
+
+It scans your real codebase and generates satirical findings based on actual code quality signals:
+
+- **Test coverage**: counts test files vs source files
+- **TODO/FIXME/HACK comments**: finds them, judges them
+- **Variable naming**: flags `temp2`, `data3`, `final_FINAL_v3`
+- **Security**: detects hardcoded secrets and exposed .env files
+- **Console.log pollution**: counts your debugging artifacts
+- **Deep nesting**: finds your callback pyramids
+- **Git history**: analyzes commit messages and contributor breakdown
+- **Project hygiene**: README quality, lockfiles, linting config
+
+All wrapped in Claudia's voice. Because someone has to say it.
+
+## Example output
+
+```
+────────────────────────────────────────────────────────────
+  CLAUDIA CODE REVIEW
+────────────────────────────────────────────────────────────
+
+  Scanning codebase...
+  Found 847 files, 142,391 lines of code.
+
+────────────────────────────────────────────────────────────
+  TESTS
+────────────────────────────────────────────────────────────
+
+✗ Zero test files found.
+  Claudia is not mad. Claudia is disappointed.
+
+────────────────────────────────────────────────────────────
+  NAMING CRIMES
+────────────────────────────────────────────────────────────
+
+⚠ src/utils/helpers.ts:42 temp2
+⚠ src/api/handler.ts:89 data3
+  There is no temp1. There never was.
+```
+
+## The point
+
+This is a parody. It's also a real linter that checks real things.
+
+Claudia isn't real. But the stats are:
+
+- Women hold 26% of computing jobs (down from 35% in 1990)
+- Women-founded startups receive 2% of VC funding
+- 50% of women in tech leave by age 35
+
+The pipeline isn't the problem. The environment is.
+
+Learn more at [claudia-code.com](https://claudia-code.com)
+
+## Support
+
+- [Girls Who Code](https://girlswhocode.com)
+- [AnitaB.org](https://anitab.org)
+- [Women Who Code](https://www.womenwhocode.com)
+- [Lesbians Who Tech](https://lesbianswhotech.org)
+
+## License
+
+MIT. Unlike Claudia's emotional labor, this is free.