@davesheffer/hunch 0.1.0

package/dist/core/glob.js

@@ -0,0 +1,62 @@
+/** Minimal, segment-aware glob matching for constraint `scope` / component
+ *  `paths` (e.g. "src/auth/**"). Supports **, *, and ? with correct path-segment
+ *  semantics (`**` spans separators; `*`/`?` stay within one segment). No dep. */
+/** Normalize a path/glob: backslashes -> '/', strip a leading './'. */
+function norm(p) {
+    return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+/** Translate one path segment (no '/') to a regex fragment. */
+function segToRe(seg) {
+    return seg
+        .replace(/[.+^${}()|[\]]/g, "\\$&")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, "[^/]");
+}
+function globToRegExp(glob) {
+    // Collapse runs of consecutive "**" segments so "**/**", "a/**/**/b" etc.
+    // behave like a single globstar (avoids a spurious leading slash / no-match).
+    const segs = glob.split("/").filter((s, i, a) => !(s === "**" && a[i - 1] === "**"));
+    if (segs.length === 1 && segs[0] === "**")
+        return /^.*$/;
+    let re = "";
+    for (let i = 0; i < segs.length; i++) {
+        const seg = segs[i];
+        const isFirst = i === 0;
+        const isLast = i === segs.length - 1;
+        if (seg === "**") {
+            if (isLast) {
+                // trailing "/**": the directory itself OR anything beneath it
+                re += "(?:/.*)?";
+            }
+            // a leading/middle "**" contributes nothing here; the next concrete
+            // segment emits the "zero or more directories" group (see below).
+        }
+        else {
+            const prevGlobstar = i > 0 && segs[i - 1] === "**";
+            if (prevGlobstar) {
+                // "**/" before this segment → optional run of directories
+                re += isFirst /* unreachable */ ? "" : i - 1 === 0 ? "(?:.*/)?" : "/(?:.*/)?";
+            }
+            else if (!isFirst) {
+                re += "/";
+            }
+            re += segToRe(seg);
+        }
+    }
+    return new RegExp("^" + re + "$");
+}
+/** Does a concrete path match a glob? Also returns true when the glob is a bare
+ *  directory prefix of the path (so "src/auth" matches "src/auth/x.ts"). */
+export function pathMatchesGlob(path, glob) {
+    const p = norm(path);
+    const g = norm(glob);
+    if (g === p)
+        return true;
+    if (globToRegExp(g).test(p))
+        return true;
+    // bare-prefix convenience: "src/auth" ~ "src/auth/**"
+    if (!/[*?]/.test(g) && p.startsWith(g.endsWith("/") ? g : g + "/"))
+        return true;
+    return false;
+}
+//# sourceMappingURL=glob.js.map

package/dist/core/ids.js

@@ -0,0 +1,39 @@
+/** Stable id helpers. Symbol/component/edge ids are DETERMINISTIC (derived from
+ *  their natural key) so re-indexing the same repo yields the same ids and the
+ *  git diff of `.hunch/` stays minimal. Decisions/bugs use a content hash too,
+ *  so the learning loop is idempotent for the same commit. */
+import { createHash } from "node:crypto";
+function shortHash(input, len = 10) {
+    return createHash("sha1").update(input).digest("hex").slice(0, len);
+}
+/** Full sha1 (used for signature_hash etc.). */
+export function sha1(input) {
+    return "sha1:" + createHash("sha1").update(input).digest("hex");
+}
+/** Symbol id from file + name + kind — deterministic across re-indexes. */
+export function symbolId(file, name, kind) {
+    return "sym_" + shortHash(`${file}::${name}::${kind}`);
+}
+/** Component id from a stable name. */
+export function componentId(name) {
+    return "cmp_" + shortHash(name.toLowerCase());
+}
+/** Edge id from its endpoints + type — deterministic, dedupes naturally. */
+export function edgeId(from, to, type) {
+    return "edge_" + shortHash(`${from}->${to}:${type}`);
+}
+/** Decision id. Seed with the CANONICAL full commit sha (the auto-sync and MCP
+ *  commit paths both do this, so a recorded decision upgrades the auto-draft for
+ *  the same commit), or with "manual:<title>" for an ad-hoc MCP decision. */
+export function decisionId(seed) {
+    return "dec_" + shortHash(seed);
+}
+/** Bug id seeded by symptom/test so the same failure doesn't spawn duplicates. */
+export function bugId(seed) {
+    return "bug_" + shortHash(seed);
+}
+/** Constraint id seeded by its statement. */
+export function constraintId(statement) {
+    return "con_" + shortHash(statement.toLowerCase());
+}
+//# sourceMappingURL=ids.js.map

package/dist/core/io.js

@@ -0,0 +1,44 @@
+/** Durable file writes for the Hunch. */
+import { writeFileSync, renameSync, rmSync } from "node:fs";
+let counter = 0;
+/**
+ * Write `data` to `file` via a temp file + rename, so an interrupted write can't
+ * leave the target truncated (the symbols/edges index is the worst to half-write).
+ *
+ * Windows caveat: renameSync can't REPLACE a file another process holds open (even
+ * for read) — it throws EPERM/EBUSY/EACCES, exactly when the MCP server is reading
+ * while a CLI writes. Atomicity is crash-safety insurance, not worth FAILING a write
+ * the old in-place writeFileSync would have completed — so we fall back to a direct
+ * write there. The temp file is always cleaned up; a failed write never leaks it.
+ */
+export function writeFileAtomic(file, data) {
+    const tmp = `${file}.tmp${process.pid}.${counter++}`;
+    try {
+        writeFileSync(tmp, data);
+    }
+    catch (e) {
+        safeRm(tmp);
+        throw e;
+    }
+    try {
+        renameSync(tmp, file);
+    }
+    catch (e) {
+        safeRm(tmp);
+        const code = e.code;
+        if (code === "EPERM" || code === "EBUSY" || code === "EACCES") {
+            writeFileSync(file, data); // non-atomic fallback (matches pre-hardening behavior)
+            return;
+        }
+        throw e;
+    }
+}
+function safeRm(p) {
+    try {
+        rmSync(p, { force: true });
+    }
+    catch {
+        /* best effort */
+    }
+}
+//# sourceMappingURL=io.js.map

package/dist/core/migrate.js

@@ -0,0 +1,59 @@
+/**
+ * Schema versioning + migration for the JSON source of truth.
+ *
+ * Records under `.hunch/` carry no per-record version; instead `.hunch/manifest.json`
+ * records the schema generation the on-disk data was written at. On load we migrate
+ * raw JSON UP to SCHEMA_VERSION *before* Zod validation — so a future schema change
+ * never silently drops old records (Zod would reject an old shape and the loader
+ * skips invalid records, which would be silent data loss).
+ *
+ * Adding a new schema version:
+ *   1. bump SCHEMA_VERSION,
+ *   2. append a Migration whose `version` equals the new number, transforming a raw
+ *      record of the PREVIOUS shape into the new one (idempotent, defensive — the
+ *      input is untrusted JSON, not a validated entity).
+ * Migrations run in ascending `version` order for every version in (from, to].
+ */
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { writeFileAtomic } from "./io.js";
+/** The schema generation this build writes and reads. Bump on any breaking change. */
+export const SCHEMA_VERSION = 1;
+/** A repo whose `.hunch/` predates manifests is treated as v1. Migrations are
+ *  numbered from 2 (each `version` is the number it PRODUCES), so a baseline repo
+ *  runs every migration with version >= 2 — never author a no-op version:1 one. */
+export const BASELINE_VERSION = 1;
+/** Ordered, ascending by `version`. Empty at v1 (baseline); future versions append. */
+export const MIGRATIONS = [];
+/** Read `.hunch/manifest.json`. A missing/corrupt manifest is treated as the
+ *  BASELINE version (a pre-manifest `.hunch/`), so future builds still migrate it. */
+export function readManifest(paths) {
+    if (!existsSync(paths.manifest))
+        return { schema_version: BASELINE_VERSION };
+    try {
+        const m = JSON.parse(readFileSync(paths.manifest, "utf8"));
+        const v = typeof m.schema_version === "number" && Number.isInteger(m.schema_version) ? m.schema_version : BASELINE_VERSION;
+        return { schema_version: v };
+    }
+    catch {
+        return { schema_version: BASELINE_VERSION };
+    }
+}
+/** Write `.hunch/manifest.json` at `version` (default: the current SCHEMA_VERSION). */
+export function writeManifest(paths, version = SCHEMA_VERSION) {
+    mkdirSync(dirname(paths.manifest), { recursive: true });
+    writeFileAtomic(paths.manifest, JSON.stringify({ schema_version: version }, null, 2) + "\n");
+}
+/** Apply every migration in (fromVersion, toVersion] to a single raw record. Skips
+ *  non-object input untouched (the loader's Zod pass will reject it). */
+export function migrateRaw(kind, raw, fromVersion, migrations = MIGRATIONS, toVersion = SCHEMA_VERSION) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return raw;
+    let rec = raw;
+    for (const m of [...migrations].sort((a, b) => a.version - b.version)) {
+        if (m.version > fromVersion && m.version <= toVersion)
+            rec = m.up(kind, rec);
+    }
+    return rec;
+}
+//# sourceMappingURL=migrate.js.map

package/dist/core/paths.js

@@ -0,0 +1,41 @@
+/** Filesystem layout for the Hunch (DESIGN.md §6 folder structure). */
+import { join } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export const HUNCH_DIR = ".hunch";
+export function hunchPaths(root) {
+    const hunch = join(root, HUNCH_DIR);
+    return {
+        root,
+        hunch,
+        sqlite: join(hunch, "hunch.sqlite"),
+        manifest: join(hunch, "manifest.json"),
+        dir: (kind) => join(hunch, kind),
+    };
+}
+/** Walk up from `start` to find the nearest repo containing a .hunch/ dir,
+ *  else the nearest git repo, else `start`. Lets `hunch` run from subdirs. */
+export function findRoot(start = process.cwd()) {
+    let cur = resolve(start);
+    let gitFallback = null;
+    const isDir = (p) => {
+        try {
+            return statSync(p).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    };
+    for (;;) {
+        if (isDir(join(cur, HUNCH_DIR)))
+            return cur; // a `.hunch` regular file is not a root
+        if (gitFallback === null && existsSync(join(cur, ".git")))
+            gitFallback = cur;
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return gitFallback ?? resolve(start);
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/types.js

@@ -0,0 +1,142 @@
+/**
+ * Core entity schema for the Project Hunch (DESIGN.md §3).
+ *
+ * Zod is the single source of truth: TypeScript types are inferred from the
+ * schemas, and the same schemas validate JSON on the write path and shape MCP
+ * tool inputs. Every record carries `provenance` so nothing is a blind assertion.
+ */
+import { z } from "zod";
+/** Where a fact came from and how much to trust it. Confidence tiers (DESIGN §4):
+ *  inferred < extracted < llm_draft < llm_draft+human_confirmed/derived. */
+export const ProvenanceSchema = z.object({
+    source: z.string().describe("e.g. extracted | inferred | llm_draft | human_confirmed | test_failure+llm | derived"),
+    confidence: z.number().min(0).max(1),
+    evidence: z.array(z.string()).default([]).describe("file paths, commit ids, test ids backing the claim"),
+    last_verified: z.string().optional().describe("ISO timestamp of last re-validation"),
+});
+export const ComponentKind = z.enum(["service", "module", "layer", "external"]);
+/** Architecture node — a service / module / layer / external dependency. */
+export const ComponentSchema = z.object({
+    id: z.string().describe("cmp_*"),
+    kind: ComponentKind,
+    name: z.string(),
+    responsibility: z.string().default(""),
+    paths: z.array(z.string()).default([]).describe("glob(s) the component owns"),
+    status: z.enum(["active", "deprecated", "archived"]).default("active"),
+    owners: z.array(z.string()).default([]),
+    fragility: z.number().min(0).max(1).default(0),
+    provenance: ProvenanceSchema,
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+export const EdgeType = z.enum([
+    "depends_on",
+    "calls",
+    "imports",
+    "contains",
+    "implements",
+    "supersedes",
+    "related_to",
+]);
+/** Typed relationship between components or symbols. */
+export const EdgeSchema = z.object({
+    id: z.string().describe("edge_*"),
+    from: z.string(),
+    to: z.string(),
+    type: EdgeType,
+    reason: z.string().default(""),
+    strength: z.number().min(0).max(1).default(0.5),
+    provenance: ProvenanceSchema,
+});
+export const SymbolKind = z.enum(["function", "method", "class", "interface", "type", "variable", "file"]);
+export const SymbolMetricsSchema = z.object({
+    loc: z.number().default(0),
+    churn_90d: z.number().default(0).describe("times changed in last 90 days"),
+    bug_count: z.number().default(0),
+    fan_in: z.number().default(0).describe("number of callers"),
+    fan_out: z.number().default(0).describe("number of callees"),
+});
+/** File/function-level node for the dependency map. */
+export const SymbolSchema = z.object({
+    id: z.string().describe("sym_*"),
+    file: z.string(),
+    name: z.string(),
+    kind: SymbolKind,
+    signature_hash: z.string().default(""),
+    calls: z.array(z.string()).default([]).describe("symbol ids this calls"),
+    called_by: z.array(z.string()).default([]).describe("symbol ids that call this"),
+    metrics: SymbolMetricsSchema.default({ loc: 0, churn_90d: 0, bug_count: 0, fan_in: 0, fan_out: 0 }),
+    last_changed: z.string().default("").describe("commit:<sha> or ISO date"),
+});
+/** ADR-style decision record, auto-drafted and human-confirmable. */
+export const DecisionSchema = z.object({
+    id: z.string().describe("dec_*"),
+    title: z.string(),
+    status: z.enum(["proposed", "accepted", "rejected", "superseded"]).default("proposed"),
+    context: z.string().default(""),
+    decision: z.string().default(""),
+    consequences: z.array(z.string()).default([]),
+    alternatives_rejected: z.array(z.string()).default([]),
+    related_components: z.array(z.string()).default([]),
+    related_files: z.array(z.string()).default([]),
+    supersedes: z.string().nullable().default(null),
+    caused_by_bug: z.string().nullable().default(null),
+    commit: z.string().nullable().default(null),
+    provenance: ProvenanceSchema,
+    date: z.string(),
+});
+export const BugLineageSchema = z.object({
+    introduced_commit: z.string().nullable().default(null),
+    detected: z.string().nullable().default(null).describe("test id or report"),
+    fixed_commit: z.string().nullable().default(null),
+    recurrence_of: z.string().nullable().default(null).describe("bug id this recurs"),
+    spawned_decision: z.string().nullable().default(null),
+    spawned_constraint: z.string().nullable().default(null),
+});
+/** A bug with root cause and lineage (introduced → fixed → recurred). */
+export const BugSchema = z.object({
+    id: z.string().describe("bug_*"),
+    title: z.string(),
+    symptom: z.string().default(""),
+    root_cause: z.string().default(""),
+    severity: z.enum(["low", "medium", "high", "critical"]).default("medium"),
+    status: z.enum(["open", "investigating", "fixed", "regressed"]).default("open"),
+    affected_files: z.array(z.string()).default([]),
+    affected_symbols: z.array(z.string()).default([]),
+    lineage: BugLineageSchema.default({
+        introduced_commit: null, detected: null, fixed_commit: null,
+        recurrence_of: null, spawned_decision: null, spawned_constraint: null,
+    }),
+    provenance: ProvenanceSchema,
+});
+/** An invariant the system must respect. */
+export const ConstraintSchema = z.object({
+    id: z.string().describe("con_*"),
+    type: z.enum(["security", "performance", "correctness", "architecture", "compliance"]).default("correctness"),
+    statement: z.string(),
+    scope: z.array(z.string()).default([]).describe("glob(s) it applies to"),
+    severity: z.enum(["advisory", "warning", "blocking"]).default("warning"),
+    enforcement: z.enum(["advisory_v1", "ci", "manual"]).default("advisory_v1"),
+    rationale: z.string().default(""),
+    source_decision: z.string().nullable().default(null),
+    violations: z.array(z.string()).default([]),
+    provenance: ProvenanceSchema,
+});
+/** The six entity collections, keyed by their on-disk directory name. */
+export const ENTITY_KINDS = ["components", "edges", "symbols", "decisions", "bugs", "constraints"];
+export const SCHEMAS = {
+    components: ComponentSchema,
+    edges: EdgeSchema,
+    symbols: SymbolSchema,
+    decisions: DecisionSchema,
+    bugs: BugSchema,
+    constraints: ConstraintSchema,
+};
+/** Default provenance helper for deterministic (extracted) records. */
+export function extracted(confidence, evidence = []) {
+    return { source: "extracted", confidence, evidence };
+}
+export function inferred(confidence, evidence = []) {
+    return { source: "inferred", confidence, evidence };
+}
+//# sourceMappingURL=types.js.map

package/dist/extractors/diff.js

@@ -0,0 +1,198 @@
+/**
+ * Structured analysis of a git unified diff (deterministic, no LLM). Turns raw
+ * patch text into "what actually changed" — added/removed/changed symbols, new
+ * and dropped dependencies, file add/delete/rename — so the synthesis layer can
+ * write an INFORMATIVE decision even with no model available.
+ *
+ * Parsing is hunk-state-aware: file headers ("--- "/"+++ ") are only honored in
+ * the pre-hunk region, so a CONTENT line like `+++counter` (source `++counter`)
+ * is never mistaken for a header. Symbol classification is PER FILE, so moving a
+ * function between files isn't misread as a signature change.
+ */
+const DECL_PATTERNS = [
+    { kind: "function", re: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/ },
+    { kind: "class", re: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/ },
+    { kind: "interface", re: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/ },
+    { kind: "type", re: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*[=<]/ },
+    { kind: "const", re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/ },
+    { kind: "const", re: /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?function/ },
+];
+const IMPORT_RE = /^\s*import\s+(?:[^'"]*from\s+)?['"]([^'"]+)['"]/;
+const CONT_IMPORT_RE = /^\s*\}?\s*from\s+['"]([^'"]+)['"]/; // multi-line: "} from 'x'"
+const REQUIRE_RE = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/;
+const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const isCode = (p) => !!p && CODE_EXT.test(p);
+function declOf(line) {
+    for (const { kind, re } of DECL_PATTERNS) {
+        const m = re.exec(line);
+        if (m)
+            return { name: m[1], kind };
+    }
+    return null;
+}
+function importOf(line) {
+    const m = IMPORT_RE.exec(line) ?? CONT_IMPORT_RE.exec(line) ?? REQUIRE_RE.exec(line);
+    return m ? m[1] : null;
+}
+function stripAB(p) {
+    return p.replace(/^[ab]\//, "");
+}
+export function analyzeDiff(diff) {
+    const filesAdded = new Set();
+    const filesDeleted = new Set();
+    const filesModified = new Set();
+    const filesRenamed = [];
+    const perFile = new Map();
+    const addedImports = new Set();
+    const removedImports = new Set();
+    let addedLines = 0;
+    let removedLines = 0;
+    let curFile = "";
+    let inHunk = false;
+    let curAdded = false;
+    let curDeleted = false;
+    let renameFrom = "";
+    const declsFor = (f) => {
+        if (!isCode(f))
+            return null;
+        let e = perFile.get(f);
+        if (!e) {
+            e = { added: new Map(), removed: new Map() };
+            perFile.set(f, e);
+        }
+        return e;
+    };
+    for (const raw of diff.split("\n")) {
+        if (raw.startsWith("diff --git")) {
+            curFile = "";
+            inHunk = false;
+            curAdded = curDeleted = false;
+            renameFrom = "";
+            continue;
+        }
+        if (raw.startsWith("@@")) {
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk) {
+            // ---- pre-hunk header region (file metadata) ----
+            if (raw.startsWith("new file mode")) {
+                curAdded = true;
+            }
+            else if (raw.startsWith("deleted file mode")) {
+                curDeleted = true;
+            }
+            else if (raw.startsWith("rename from ")) {
+                renameFrom = raw.slice("rename from ".length).trim();
+            }
+            else if (raw.startsWith("copy from ")) {
+                renameFrom = raw.slice("copy from ".length).trim();
+            }
+            else if (raw.startsWith("rename to ") || raw.startsWith("copy to ")) {
+                const to = raw.slice(raw.indexOf(" to ") + 4).trim();
+                curFile = to;
+                if (isCode(to))
+                    filesRenamed.push({ from: renameFrom, to });
+            }
+            else if (raw.startsWith("--- ")) {
+                const p = raw.slice(4).trim();
+                if (p !== "/dev/null")
+                    curFile = stripAB(p); // old path (may be replaced by +++)
+            }
+            else if (raw.startsWith("+++ ")) {
+                const p = raw.slice(4).trim();
+                if (p !== "/dev/null")
+                    curFile = stripAB(p); // new path preferred
+                if (isCode(curFile)) {
+                    if (curAdded)
+                        filesAdded.add(curFile);
+                    else if (curDeleted)
+                        filesDeleted.add(curFile);
+                }
+            }
+            continue;
+        }
+        // ---- inside a hunk: content lines ----
+        if (raw.startsWith("+")) {
+            if (!isCode(curFile))
+                continue;
+            addedLines++;
+            if (!curAdded && !curDeleted)
+                filesModified.add(curFile);
+            const body = raw.slice(1);
+            const d = declOf(body);
+            if (d)
+                declsFor(curFile)?.added.set(d.name, d);
+            const imp = importOf(body);
+            if (imp && !imp.startsWith("."))
+                addedImports.add(imp);
+        }
+        else if (raw.startsWith("-")) {
+            if (!isCode(curFile))
+                continue;
+            removedLines++;
+            if (!curAdded && !curDeleted)
+                filesModified.add(curFile);
+            const body = raw.slice(1);
+            const d = declOf(body);
+            if (d)
+                declsFor(curFile)?.removed.set(d.name, d);
+            const imp = importOf(body);
+            if (imp && !imp.startsWith("."))
+                removedImports.add(imp);
+        }
+    }
+    // per-file symbol classification (added/removed/changed within the same file)
+    const addedSymbols = [];
+    const removedSymbols = [];
+    const changedSymbols = [];
+    for (const { added, removed } of perFile.values()) {
+        for (const [name, sc] of added) {
+            if (removed.has(name))
+                changedSymbols.push(sc);
+            else
+                addedSymbols.push(sc);
+        }
+        for (const [name, sc] of removed) {
+            if (!added.has(name))
+                removedSymbols.push(sc);
+        }
+    }
+    const renamedSet = new Set(filesRenamed.map((r) => r.to));
+    return {
+        filesAdded: [...filesAdded],
+        filesDeleted: [...filesDeleted],
+        filesModified: [...filesModified].filter((f) => !filesAdded.has(f) && !filesDeleted.has(f) && !renamedSet.has(f)),
+        filesRenamed,
+        addedSymbols,
+        removedSymbols,
+        changedSymbols,
+        addedDeps: [...addedImports].filter((d) => !removedImports.has(d)),
+        removedDeps: [...removedImports].filter((d) => !addedImports.has(d)),
+        addedLines,
+        removedLines,
+    };
+}
+/** A compact human-readable summary of a DiffAnalysis (used in decision text). */
+export function summarizeDiff(a) {
+    const parts = [];
+    const names = (arr) => arr.map((s) => s.name).slice(0, 8).join(", ");
+    if (a.addedSymbols.length)
+        parts.push(`added ${names(a.addedSymbols)}`);
+    if (a.removedSymbols.length)
+        parts.push(`removed ${names(a.removedSymbols)}`);
+    if (a.changedSymbols.length)
+        parts.push(`changed ${names(a.changedSymbols)}`);
+    if (a.addedDeps.length)
+        parts.push(`new dep(s): ${a.addedDeps.slice(0, 6).join(", ")}`);
+    if (a.removedDeps.length)
+        parts.push(`dropped dep(s): ${a.removedDeps.slice(0, 6).join(", ")}`);
+    if (a.filesRenamed.length)
+        parts.push(`renamed ${a.filesRenamed.map((r) => `${r.from}→${r.to}`).slice(0, 4).join(", ")}`);
+    if (a.filesAdded.length)
+        parts.push(`${a.filesAdded.length} new file(s)`);
+    if (a.filesDeleted.length)
+        parts.push(`${a.filesDeleted.length} deleted file(s)`);
+    return parts.join("; ");
+}
+//# sourceMappingURL=diff.js.map