prehello 0.0.0-stage → 1.0.0

package/dist/context.js

@@ -0,0 +1,329 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ctx = exports.WALK_CANDIDATES = void 0;
+exports.readFailWhy = readFailWhy;
+exports.lineCount = lineCount;
+exports.shingles = shingles;
+exports.jaccard = jaccard;
+const node_path_1 = __importDefault(require("node:path"));
+const agents_1 = require("./agents");
+const families_1 = require("./tokens/families");
+const fs_safe_1 = require("./fs-safe");
+const redact_1 = require("./redact");
+const fmt_1 = require("./util/fmt");
+const fixtures_1 = require("./fixtures");
+/** Entry budget for looking inside skipped fixture folders (only to count how many held agent files; nothing from them is reported). */
+const FIXTURE_PROBE_ENTRIES = 20_000;
+const FIXTURE_PROBE_TOTAL = 50_000;
+/** Human wording for a failed read; `verb` is "skipped" (rules, skills) or "not read" (instruction files). */
+function readFailWhy(reason, verb) {
+    switch (reason) {
+        case "too-large": return `larger than 4 MiB (Claude Code's own limit for startup files), ${verb}`;
+        case "binary": return `binary content, ${verb}`;
+        case "utf16": return `saved as UTF-16 (Windows PowerShell "> file" does this); coding agents read UTF-8, so it is ${verb}. Re-save it as UTF-8`;
+        case "symlink-escape": return `symlink points outside the project, ${verb === "skipped" ? "skipped" : "not followed"}`;
+        case "not-file": return `not a regular file, ${verb}`;
+        case "budget": return `${verb}: scan budget reached`;
+        default: return reason === "unreadable" ? `unreadable, ${verb}` : `${reason}, ${verb}`;
+    }
+}
+/** Names (files) and "dir/" entries looked for in every directory of the bounded project walk. */
+exports.WALK_CANDIDATES = [
+    "CLAUDE.md", "CLAUDE.local.md", ".claude/CLAUDE.md", "AGENTS.md", "AGENTS.override.md", "GEMINI.md",
+    ".cursor/rules/", ".cursor/skills/", ".agents/skills/", ".claude/skills/",
+];
+class Ctx {
+    opts;
+    counter;
+    warnings = [];
+    excluded = [];
+    findings = [];
+    docs = new Map(); // realpath -> info (for F2)
+    gitRoot;
+    seq = 0;
+    readCache = new Map();
+    findingKeys = new Set();
+    countCache = new Map();
+    walkCache;
+    /** Fixture folders skipped by the project walk that held agent files (counted, never read). */
+    fixturesSkipped = 0;
+    t0;
+    bytesRead = 0;
+    /** Set when a whole-scan budget (bytes or time) stopped reading; totals are then lower bounds. */
+    budgetHit;
+    budgetSkipped = 0;
+    constructor(opts, counter) {
+        this.opts = opts;
+        this.counter = counter;
+        this.gitRoot = (0, fs_safe_1.findGitRoot)(opts.cwd, opts.ceiling);
+        this.t0 = (opts.clock ?? Date.now)();
+    }
+    get maxScanBytes() {
+        return this.opts.maxScanBytes ?? fs_safe_1.DEFAULT_MAX_SCAN_BYTES;
+    }
+    get maxScanMs() {
+        return this.opts.maxScanMs ?? fs_safe_1.DEFAULT_MAX_SCAN_MS;
+    }
+    timeUp() {
+        if (this.budgetHit === "time")
+            return true;
+        if ((this.opts.clock ?? Date.now)() - this.t0 > this.maxScanMs) {
+            this.budgetHit = this.budgetHit ?? "time";
+            return true;
+        }
+        return false;
+    }
+    /** Is cwd a project folder (as opposed to a home directory, a drive root or a downloads folder)? .git, or an agent file at its top level. Never true for the home folder. */
+    isProjectDir() {
+        if (this.cwd === this.home)
+            return false;
+        if (this.gitRoot && this.gitRoot !== this.home)
+            return true;
+        return agents_1.AGENTS.flatMap((a) => a.projectMarkers).some((m) => m.endsWith("/") ? (0, fs_safe_1.isDir)(node_path_1.default.join(this.cwd, m.slice(0, -1))) : (0, fs_safe_1.isFile)(node_path_1.default.join(this.cwd, m)));
+    }
+    get cwd() {
+        return this.opts.cwd;
+    }
+    get home() {
+        return this.opts.home;
+    }
+    profile(agent) {
+        return (0, families_1.profileFor)(agent, this.counter.method, this.opts.claudeProfile);
+    }
+    display(p) {
+        return (0, redact_1.displayPath)(p, { cwd: this.cwd, home: this.home });
+    }
+    warn(msg) {
+        if (!this.warnings.includes(msg))
+            this.warnings.push(msg);
+    }
+    exclude(agent, p, reason) {
+        this.excluded.push({ agent, path: p, reason });
+    }
+    /** A machine-wide absolute location, re-rooted under --system-root when given. */
+    sys(abs) {
+        const root = this.opts.systemRoot;
+        if (!root)
+            return abs;
+        const rel = abs.replace(/^[A-Za-z]:/, "").replace(/\\/g, "/").replace(/^\/+/, "");
+        return node_path_1.default.join(root, ...rel.split("/"));
+    }
+    /** Directories from filesystem root (or ceiling) down to cwd, root-first. */
+    ancestorDirs() {
+        const dirs = [];
+        let dir = this.cwd;
+        for (;;) {
+            dirs.unshift(dir);
+            if (this.opts.ceiling && dir === this.opts.ceiling)
+                break;
+            const parent = node_path_1.default.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return dirs;
+    }
+    /** jail for project-tree files: the git root if the file is inside it, else its own directory. */
+    jailFor(dir) {
+        return this.gitRoot && (0, fs_safe_1.isInside)(dir, this.gitRoot) ? this.gitRoot : dir;
+    }
+    /** Skip fixture folders? Not when asked not to, and not when the scan root is itself inside one (scanning a fixture on purpose). */
+    skipFixtures() {
+        return !this.opts.includeFixtures && !(0, fixtures_1.rootIsInsideFixtures)(this.cwd);
+    }
+    walk() {
+        if (!this.walkCache) {
+            const skip = this.skipFixtures();
+            const w = (0, fs_safe_1.walkForFiles)(this.cwd, exports.WALK_CANDIDATES, { timeUp: () => this.timeUp(), skipDir: skip ? (0, fixtures_1.makeFixtureSkipper)(this.cwd) : undefined });
+            const notAProject = !this.isProjectDir();
+            if ((w.truncated || w.timedOut) && notAProject) {
+                // Walking a home folder, a drive root or ~/Downloads: whatever CLAUDE.md/AGENTS.md files happen to sit in the first
+                // 5,000 entries are random, not "your project". Reporting them would print junk token totals, so drop them.
+                this.walkCache = { ...w, hits: [], notAProject, skipped: [] };
+                this.warn(`${this.display(this.cwd) === "." ? "this folder" : this.display(this.cwd)} does not look like a project (no .git, no agent files at its top level) and holds more than ${fs_safe_1.MAX_WALK_ENTRIES} entries, so nested agent files were NOT scanned (they would be arbitrary). Run prehello on a project folder: prehello ~/code/my-project`);
+            }
+            else {
+                this.walkCache = { ...w, notAProject };
+                if (w.truncated)
+                    this.warn(`project walk stopped at ${fs_safe_1.MAX_WALK_ENTRIES} entries; nested files deeper in the tree may be missed`);
+                if (w.timedOut)
+                    this.warn("project walk stopped at the time budget; nested files may be missed");
+                this.fixturesSkipped = this.probeFixtures(w.skipped);
+            }
+        }
+        return this.walkCache;
+    }
+    /** How many skipped fixture folders hold agent files? A bounded, read-only look (names only); folders it cannot settle are not counted. */
+    probeFixtures(dirs) {
+        let left = FIXTURE_PROBE_TOTAL;
+        let n = 0;
+        for (const d of dirs) {
+            if (left <= 0 || this.timeUp())
+                break;
+            const p = (0, fs_safe_1.walkForFiles)(d, exports.WALK_CANDIDATES, { timeUp: () => this.timeUp(), includeRoot: true, stopAtFirstHit: true, maxEntries: Math.min(left, FIXTURE_PROBE_ENTRIES) });
+            left -= p.entries;
+            if (p.hits.length)
+                n++;
+        }
+        return n;
+    }
+    /** Cached, defensive read. Missing = silent; other failures become warnings (-> exit code 3). */
+    read(p, opts = {}) {
+        const key = `${p}|${opts.jail ?? ""}|${opts.maxBytes ?? ""}`;
+        let r = this.readCache.get(key);
+        if (!r) {
+            if (this.timeUp() || this.bytesRead >= this.maxScanBytes) {
+                // Budget spent: stop touching the disk. Missing files stay silent, everything else counts as skipped.
+                if (this.bytesRead >= this.maxScanBytes)
+                    this.budgetHit = this.budgetHit ?? "bytes";
+                r = (0, fs_safe_1.readTextSafe)(p, { ...opts, budgetBytes: 0 });
+                if (!r.ok && r.reason === "budget")
+                    this.budgetSkipped++;
+            }
+            else {
+                r = (0, fs_safe_1.readTextSafe)(p, { ...opts, budgetBytes: this.maxScanBytes - this.bytesRead });
+                if (r.ok)
+                    this.bytesRead += r.bytes;
+                else if (r.reason === "budget") {
+                    this.budgetHit = this.budgetHit ?? "bytes";
+                    this.budgetSkipped++;
+                }
+            }
+            this.readCache.set(key, r);
+            if (!r.ok && !opts.quiet && r.reason !== "missing" && r.reason !== "budget")
+                this.warn(`${this.display(p)}: ${readFailWhy(r.reason, "skipped")}`);
+        }
+        return r;
+    }
+    /** Called once at the end of a scan: one summary warning when a whole-scan budget cut the scan short. */
+    budgetSummary() {
+        if (!this.budgetHit)
+            return undefined;
+        const what = this.budgetHit === "time" ? `${Math.round(this.maxScanMs / 1000)} s time budget` : `${Math.round(this.maxScanBytes / 1048576)} MiB read budget`;
+        return `scan stopped at its ${what}${this.budgetSkipped ? `; ${this.budgetSkipped} file${this.budgetSkipped > 1 ? "s were" : " was"} not read` : ""}. Results are PARTIAL: totals are lower bounds. Scan a smaller folder, or raise the budget with --scan-budget-mb / --scan-budget-ms.`;
+    }
+    readJson(p) {
+        const r = this.read(p, { maxBytes: 64 * 1024 * 1024 });
+        if (!r.ok)
+            return undefined;
+        try {
+            return JSON.parse(r.text);
+        }
+        catch {
+            this.warn(`${this.display(p)}: could not parse as JSON, skipped`);
+            return undefined;
+        }
+    }
+    count(key, text) {
+        let n = this.countCache.get(key);
+        if (n === undefined) {
+            n = this.counter.count(text);
+            this.countCache.set(key, n);
+        }
+        return n;
+    }
+    addFinding(f, dedupeKey) {
+        const k = dedupeKey ?? `${f.id}|${f.agent}|${f.paths.join(",")}|${f.message}`;
+        if (this.findingKeys.has(k))
+            return;
+        this.findingKeys.add(k);
+        this.findings.push(f);
+    }
+    makeItem(a) {
+        const prof = this.profile(a.agent);
+        return {
+            id: `${a.agent}:${++this.seq}`,
+            agent: a.agent,
+            path: a.path,
+            kind: a.kind,
+            scope: a.scope,
+            loadMode: a.loadMode,
+            tokens: a.raw === null ? null : prof.apply(a.raw, a.kind === "mcp-server" ? "json" : "markdown"),
+            ...(a.raw === null ? { unmeasuredReason: a.unmeasuredReason ?? "not measurable" } : {}),
+            chars: a.chars ?? 0,
+            lines: a.lines ?? 0,
+            confidence: a.confidence,
+            evidence: a.evidence,
+            notes: a.notes ?? [],
+            cardLabel: a.cardLabel,
+            label: (0, fmt_1.sanitize)(a.label, 100),
+            ...(a.detail ? { detail: a.detail } : {}),
+            ...(a.group ? { group: a.group, groupLabel: a.groupLabel ?? a.group } : {}),
+        };
+    }
+    /** Per-document analysis shared by all agents: secrets (F9), guideline length (F1), shingles for duplicates (F2). */
+    analyzeDoc(agent, filePath, rawText, processed, rawTokens, guidelineLines) {
+        const real = (0, fs_safe_1.realpathOrSelf)(filePath);
+        const lines = lineCount(rawText);
+        const secretLines = (0, redact_1.findSecretLines)(rawText);
+        if (secretLines.length) {
+            this.addFinding({
+                id: "F9",
+                severity: "warn",
+                agent: "all",
+                message: `Possible secret on line${secretLines.length > 1 ? "s" : ""} ${secretLines.slice(0, 5).join(", ")}${secretLines.length > 5 ? ", …" : ""} of ${this.display(filePath)} (value not shown)`,
+                paths: [filePath],
+                confidence: "medium",
+                data: { lines: secretLines.slice(0, 50) },
+                fix: "Remove the secret from the instruction file and rotate it; agents send this file to a model provider.",
+            }, `F9|${real}`);
+        }
+        if (guidelineLines && lines > guidelineLines) {
+            this.addFinding({
+                id: "F1",
+                severity: "info",
+                agent,
+                message: `${this.display(filePath)} is ${lines} lines (documented guideline: under ${guidelineLines}); longer files can reduce adherence`,
+                paths: [filePath],
+                confidence: "medium",
+                data: { fileLines: lines, guidelineLines },
+                fix: "Split into scoped rules or move reference material out of the always-loaded file.",
+            });
+        }
+        let info = this.docs.get(real);
+        if (!info) {
+            info = { path: filePath, tokens: rawTokens, shingles: shingles(processed), agents: new Set() };
+            this.docs.set(real, info);
+        }
+        info.agents.add(agent);
+    }
+}
+exports.Ctx = Ctx;
+function lineCount(text) {
+    if (!text)
+        return 0;
+    return text.replace(/\n$/, "").split("\n").length;
+}
+function fnv(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return h >>> 0;
+}
+function shingles(text, k = 5) {
+    const words = text.toLowerCase().split(/\s+/).filter(Boolean);
+    const out = new Set();
+    if (words.length < k) {
+        if (words.length)
+            out.add(fnv(words.join(" ")));
+        return out;
+    }
+    for (let i = 0; i + k <= words.length; i++)
+        out.add(fnv(words.slice(i, i + k).join(" ")));
+    return out;
+}
+function jaccard(a, b) {
+    if (!a.size || !b.size)
+        return 0;
+    let inter = 0;
+    const [s, l] = a.size < b.size ? [a, b] : [b, a];
+    for (const x of s)
+        if (l.has(x))
+            inter++;
+    return inter / (a.size + b.size - inter);
+}

package/dist/diff.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffInputError = exports.DIFF_MARKER = void 0;
+exports.parseSnapshot = parseSnapshot;
+exports.diffSnapshots = diffSnapshots;
+exports.signedTok = signedTok;
+exports.headline = headline;
+exports.overThreshold = overThreshold;
+exports.renderDiffTerminal = renderDiffTerminal;
+exports.renderDiffMarkdown = renderDiffMarkdown;
+exports.diffJson = diffJson;
+exports.badgeJson = badgeJson;
+/**
+ * `prehello diff base.json head.json`: compare two saved reports (from `prehello --save` / `--json=`). Offline, no git:
+ * the GitHub Action (action.yml) produces the two snapshots. Item names come from the scanned repository, so every one
+ * goes through mdCode / sanitize before it is printed.
+ */
+const fmt_1 = require("./util/fmt");
+const markdown_1 = require("./render/markdown");
+const card_1 = require("./render/card");
+/** Starts with MD_MARKER_PREFIX (so --markdown=<file> can overwrite its own output) and is the sticky-comment marker the Action looks for. */
+exports.DIFF_MARKER = "<!-- generated by prehello diff -->";
+class DiffInputError extends Error {
+}
+exports.DiffInputError = DiffInputError;
+function parseSnapshot(text, what) {
+    let j;
+    try {
+        j = JSON.parse(text.replace(/^\uFEFF/, ""));
+    }
+    catch {
+        throw new DiffInputError(`${what} is not JSON; create it with: prehello --save ${what}`);
+    }
+    const s = j;
+    if (!s || typeof s !== "object" || s.tool?.name !== "prehello" || !Array.isArray(s.agents) || s.schemaVersion === undefined) {
+        throw new DiffInputError(`${what} is not a prehello report; create it with: prehello --save ${what}`);
+    }
+    return s;
+}
+const MAX_ITEMS = 10;
+const itemKey = (i) => `${i.kind}|${i.loadMode}|${i.path ?? i.label ?? i.id ?? ""}`;
+/** Counted when installed or when the repository has files for it (a CI runner has no agent installed). */
+const active = (a) => !!a && (!!a.detected || (a.items?.length ?? 0) > 0);
+function diffSnapshots(base, head) {
+    const notes = [];
+    if (String(base.schemaVersion) !== String(head.schemaVersion))
+        notes.push(`report schema differs (base ${base.schemaVersion}, head ${head.schemaVersion}); numbers may not be comparable`);
+    if (base.scan?.tokenizer?.method !== head.scan?.tokenizer?.method)
+        notes.push("base and head were counted with different tokenizers");
+    if (base.tool.version !== head.tool.version)
+        notes.push(`made by different prehello versions (base ${(0, fmt_1.sanitize)(base.tool.version, 20)}, head ${(0, fmt_1.sanitize)(head.tool.version, 20)}); part of the change may be the estimator`);
+    const ids = [...new Set([...base.agents, ...head.agents].map((a) => a.id))];
+    const agents = [];
+    for (const id of ids) {
+        const b = base.agents.find((a) => a.id === id);
+        const h = head.agents.find((a) => a.id === id);
+        if (!active(b) && !active(h))
+            continue;
+        const bt = active(b) ? b.totals.always.est : null;
+        const ht = active(h) ? h.totals.always.est : null;
+        const delta = (ht ?? 0) - (bt ?? 0);
+        const deferredDelta = (active(h) ? h.totals.deferred?.est ?? 0 : 0) - (active(b) ? b.totals.deferred?.est ?? 0 : 0);
+        if (b?.profile?.id && h?.profile?.id && b.profile.id !== h.profile.id)
+            notes.push(`${(0, fmt_1.sanitize)(h.name, 40)}: estimate profile changed (${(0, fmt_1.sanitize)(b.profile.id, 30)} -> ${(0, fmt_1.sanitize)(h.profile.id, 30)})`);
+        const bi = new Map((active(b) ? b.items ?? [] : []).filter((i) => i.loadMode === "always").map((i) => [itemKey(i), i]));
+        const hi = new Map((active(h) ? h.items ?? [] : []).filter((i) => i.loadMode === "always").map((i) => [itemKey(i), i]));
+        const changes = [];
+        for (const k of new Set([...bi.keys(), ...hi.keys()])) {
+            const x = bi.get(k);
+            const y = hi.get(k);
+            const bv = x?.tokens?.est ?? null;
+            const hv = y?.tokens?.est ?? null;
+            const d = Math.round((hv ?? 0) - (bv ?? 0));
+            if (x && y && d === 0)
+                continue;
+            const it = (y ?? x);
+            changes.push({ key: k, label: it.path ?? it.label ?? it.kind, kind: it.kind, base: x ? bv : null, head: y ? hv : null, delta: d });
+        }
+        changes.sort((p, q) => Math.abs(q.delta) - Math.abs(p.delta) || p.label.localeCompare(q.label));
+        agents.push({
+            id,
+            name: (h ?? b).name,
+            base: bt,
+            head: ht,
+            delta: Math.round(delta),
+            deltaPct: bt && bt >= 100 ? Math.round((delta / bt) * 1000) / 10 : null,
+            deferredDelta: Math.round(deferredDelta),
+            lowerBound: !!(b?.alwaysIsLowerBound || h?.alwaysIsLowerBound),
+            changes: changes.slice(0, MAX_ITEMS),
+            moreChanges: Math.max(0, changes.length - MAX_ITEMS),
+        });
+    }
+    return { base, head, agents, notes };
+}
+function signedTok(n) {
+    if (Math.round(n) === 0)
+        return "±0";
+    return (n > 0 ? "+" : "−") + (0, fmt_1.fmtTok)(Math.abs(n));
+}
+function headline(a) {
+    if (a.base === null)
+        return `${a.name}: new, ~${(0, fmt_1.fmtTok)(a.head ?? 0)} tokens before hello`;
+    if (a.head === null)
+        return `${a.name}: no longer detected (was ~${(0, fmt_1.fmtTok)(a.base)} tokens before hello)`;
+    if (a.delta === 0)
+        return `${a.name}: no change, ~${(0, fmt_1.fmtTok)(a.head)} tokens before hello`;
+    return `${a.name}: ${signedTok(a.delta)} tokens before hello (~${(0, fmt_1.fmtTok)(a.base)} → ~${(0, fmt_1.fmtTok)(a.head)}${a.deltaPct !== null ? `, ${a.deltaPct > 0 ? "+" : ""}${a.deltaPct}%` : ""})`;
+}
+const cell = (n) => (n === null ? "-" : (0, fmt_1.fmtTok)(n));
+const chg = (c) => (c.base === null ? "added" : c.head === null ? "removed" : "changed");
+function overThreshold(d, max) {
+    return d.agents.filter((a) => a.delta > max);
+}
+function renderDiffTerminal(d) {
+    const out = ["prehello diff (estimates; always-on context before your first message)", ""];
+    if (!d.agents.length)
+        out.push("No agent context found in either report.");
+    for (const a of d.agents) {
+        out.push((0, fmt_1.sanitize)(headline(a), 200));
+        for (const c of a.changes)
+            out.push(`    ${signedTok(c.delta).padStart(7)}  ${chg(c).padEnd(7)}  ${(0, fmt_1.sanitize)(c.label, 80)}`);
+        if (a.moreChanges)
+            out.push(`    … ${a.moreChanges} more changed item(s)`);
+        if (a.deferredDelta)
+            out.push(`    on demand (skill bodies, deferred tools): ${signedTok(a.deferredDelta)}`);
+    }
+    for (const n of d.notes)
+        out.push(`note: ${n}`);
+    return out.join("\n") + "\n";
+}
+function renderDiffMarkdown(d, opts = {}) {
+    const over = opts.threshold !== undefined ? overThreshold(d, opts.threshold) : [];
+    const out = [exports.DIFF_MARKER, "### prehello: context before hello", ""];
+    const moved = d.agents.filter((a) => a.delta !== 0 || a.base === null || a.head === null);
+    if (!d.agents.length)
+        out.push("No agent context (CLAUDE.md, AGENTS.md, rules, skills, MCP) found in this repository.");
+    else if (!moved.length)
+        out.push(`No change in always-on context. ${d.agents.map((a) => `${(0, markdown_1.mdCode)(a.name)} ~${(0, fmt_1.fmtTok)(a.head ?? 0)} tokens`).join(", ")}.`);
+    else {
+        out.push("| Agent | Base | Head | Change |", "|---|---:|---:|---:|");
+        for (const a of d.agents)
+            out.push(`| ${(0, markdown_1.mdCode)(a.name, true)} | ${cell(a.base)} | ${cell(a.head)}${a.lowerBound ? " (at least)" : ""} | **${signedTok(a.delta)}**${a.deltaPct !== null && a.delta ? ` (${a.deltaPct > 0 ? "+" : ""}${a.deltaPct}%)` : ""} |`);
+        out.push("");
+        for (const a of d.agents.filter((x) => x.changes.length)) {
+            out.push(`<details><summary>${summaryText(a.name)}: ${a.changes.length + a.moreChanges} changed item(s)</summary>`, "", "| Change | Item | Base | Head |", "|---:|---|---:|---:|");
+            for (const c of a.changes)
+                out.push(`| ${signedTok(c.delta)} | ${chg(c)} ${(0, markdown_1.mdCode)(c.label, true)} | ${cell(c.base)} | ${cell(c.head)} |`);
+            if (a.moreChanges)
+                out.push(`| | … ${a.moreChanges} more | | |`);
+            out.push("", "</details>", "");
+        }
+    }
+    if (over.length)
+        out.push("", `**Over the limit:** ${over.map((a) => `${(0, markdown_1.mdCode)(a.name)} grew ${signedTok(a.delta)} (limit +${(0, fmt_1.fmtTok)(opts.threshold)})`).join(", ")}.`);
+    for (const n of d.notes)
+        out.push("", `_Note: ${(0, fmt_1.sanitize)(n, 200).replace(/[_*`<>[\]]/g, " ")}_`);
+    out.push("", `<sub>Estimates (o200k-based, per-agent factors), not exact for any model. Only this repository's files are scanned. [prehello](https://${card_1.REPO_URL}) ${(0, fmt_1.sanitize)(d.head.tool.version, 20)}</sub>`);
+    return out.join("\n") + "\n";
+}
+function diffJson(d, threshold) {
+    return {
+        tool: { name: "prehello", version: d.head.tool.version },
+        kind: "diff",
+        agents: d.agents,
+        notes: d.notes,
+        ...(threshold !== undefined ? { threshold, overThreshold: overThreshold(d, threshold).map((a) => a.id) } : {}),
+    };
+}
+/** shields.io endpoint JSON (https://shields.io/badges/endpoint-badge). */
+function badgeJson(name, est, lowerBound) {
+    const color = est === null ? "lightgrey" : est < 5000 ? "brightgreen" : est < 15000 ? "green" : est < 30000 ? "yellow" : est < 60000 ? "orange" : "red";
+    return { schemaVersion: 1, label: "context before hello", message: est === null ? "unmeasured" : `${lowerBound ? "≥" : "~"}${(0, fmt_1.fmtTok)(est)} tokens (${name})`, color };
+}
+/** Plain text for inside <summary>: GitHub does not render Markdown there, so no backticks; HTML-escaped. */
+function summaryText(name) {
+    let t = name.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]+/g, " ").replace(/\s+/g, " ").trim();
+    if (t.length > 80)
+        t = t.slice(0, 77) + "...";
+    if (!t)
+        t = "(unnamed)";
+    return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/@/g, "&#64;").replace(/#/g, "&#35;");
+}

package/dist/fixtures.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Test-fixture folders. A repository that tests an agent tool (prehello itself, linters for AGENTS.md, skill validators, ...) keeps
+ * sample AGENTS.md / CLAUDE.md / .cursor/rules / skills under test/fixtures/**. Those files are not loaded by any agent, so the
+ * project walk skips such folders by default (`--include-fixtures` brings them back).
+ *
+ * Pure functions over path segments; callers split paths on BOTH separators so Windows paths work.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSegments = splitSegments;
+exports.isFixtureSegment = isFixtureSegment;
+exports.rootIsInsideFixtures = rootIsInsideFixtures;
+exports.makeFixtureSkipper = makeFixtureSkipper;
+/** Names that mean "test data" wherever they appear below the scan root. */
+const FIXTURE_NAMES = new Set(["fixtures", "__fixtures__", "fixture", "testdata", "test-data", "__mocks__", "__snapshots__"]);
+/** Names that are too generic on their own: only fixtures when they sit under one of TEST_PARENTS. */
+const GENERIC_NAMES = new Set(["snapshots", "golden", "goldens"]);
+const TEST_PARENTS = new Set(["test", "tests", "__tests__", "spec", "specs", "e2e", "cypress", "testdata", "test-data"]);
+function splitSegments(p) {
+    return p.split(/[\\/]+/).filter(Boolean);
+}
+/**
+ * Is segment `i` of `segs` a fixture folder? `segs` = the segments from some root down to the folder, folder last at `i`.
+ * Comparison is case-insensitive (macOS and Windows filesystems are).
+ */
+function isFixtureSegment(segs, i) {
+    const name = segs[i].toLowerCase();
+    if (FIXTURE_NAMES.has(name))
+        return true;
+    if (!GENERIC_NAMES.has(name))
+        return false;
+    for (let j = 0; j < i; j++)
+        if (TEST_PARENTS.has(segs[j].toLowerCase()))
+            return true;
+    return false;
+}
+/** Is the scan root itself inside a fixture folder (so the user is deliberately scanning a fixture)? Then nothing is skipped. */
+function rootIsInsideFixtures(cwd) {
+    const segs = splitSegments(cwd);
+    for (let i = 0; i < segs.length; i++)
+        if (isFixtureSegment(segs, i))
+            return true;
+    return false;
+}
+/**
+ * Directory filter for the walk below `cwd`. `rel` = segments below the root (folder last). The root's own last segment counts as a
+ * possible test parent for generic names (scanning `repo/test` should still skip `test/golden`).
+ */
+function makeFixtureSkipper(cwd) {
+    const base = splitSegments(cwd).slice(-1);
+    return (_name, rel) => isFixtureSegment([...base, ...rel], base.length + rel.length - 1);
+}