@descryy/core 0.1.0

package/dist/scoping/weights.js

@@ -0,0 +1,167 @@
+/**
+ * Scoring configuration for diff scoping — §12.4.
+ *
+ * ## The one number in the architecture that cannot be used as written
+ *
+ * §12.3's worked example decays a `CALLS` edge by **×1.0** on its first hop and
+ * by **×0.95** on its third. The 0.95 is the usable one; 1.0 is not, for two
+ * independent reasons:
+ *
+ * 1. **It breaks the premise of the whole engine.** §12.2 argues that hop count
+ *    is a poor proxy for importance and that expansion must stop on *score*. An
+ *    edge weight of 1.0 means a `CALLS` chain never decays — every node reachable
+ *    by calls scores exactly 1.0 forever, so the stopping rule degenerates into
+ *    "stop when the budget runs out", which is hop-count scoping wearing a
+ *    different name.
+ * 2. **It does not terminate.** With `EdgeConfidence` at 1.0 for an R3 edge, the
+ *    hop factor is exactly 1.0, and on a `CALLS` cycle the traversal never ends.
+ *    DEC-028 requires the factor to be strictly inside (0, 1).
+ *
+ * The defaults below therefore use 0.95, and §12.3's stated outcome still holds:
+ * the payment gateway three hops out survives and `logger.ts` two hops out is
+ * dropped. That test discriminates on the *shape* of the decay, not on whether
+ * the first hop was 1.00 or 0.95.
+ *
+ * ## Three parts of the architecture cannot all be true — and the resolution
+ *
+ * Writing this file surfaced a genuine inconsistency between §12.3, §12.4 and
+ * §12.7. Any two can hold; all three cannot.
+ *
+ * - **§12.3** needs *high* weights. Its worked example decays `CALLS` and
+ *   `PROPAGATES_TO` at ~0.95 so a three-hop chain still scores 0.90.
+ * - **§12.7** tiers on *absolute* thresholds — tier 2 above 0.7, tier 4 below
+ *   0.3 — which are only meaningful if a few hops of a strong edge stay high.
+ *   Scale the weights down for headroom and the payment gateway §12.3 calls
+ *   critical lands in tier 4, "dropped under budget pressure".
+ * - **§12.4** multiplies by `ChangeCouplingFactor` and
+ *   `IncidentCorrelationFactor` *at every hop*, and both are boosts above 1.0.
+ *   A weight of 0.95 with any coupling above 1.053 makes the hop factor exceed
+ *   1.0, at which point the score stops decaying and a cycle never terminates.
+ *
+ * **Resolution: the history factors adjust a node's score once, they do not
+ * compound per hop.** Path decay is the product of `edgeWeight × confidence`
+ * over the hops, strictly below 1 at every step, so termination is structural.
+ * Coupling and incident are then applied to the node's final score.
+ *
+ * This keeps §12.3's numbers exactly, keeps §12.7's thresholds meaningful, and
+ * keeps §12.4's terms doing the work they were introduced for. It is also more
+ * defensible than the literal formula: compounding a node's incident history at
+ * every hop of a path that merely *passes through* it counts the same evidence
+ * repeatedly, which the multiplicative form does silently. See DEC-037.
+ */
+import { EDGE_TYPES } from "@descryy/ir";
+import { DEFAULT_FANOUT_BUCKETS, maxAttenuation } from "./fanout.js";
+/**
+ * Default weights.
+ *
+ * **Tuning, not architecture.** §12 is marked `DECIDED, TUNING OPEN` and §32
+ * items 1 and 4 list edge weights as values to set from real traversal data.
+ * These are starting points chosen to reproduce §12.3's example, and the three
+ * that matter are the ones that example names: `CALLS`, `PROPAGATES_TO` and
+ * `IMPORTS`.
+ */
+export const DEFAULT_EDGE_WEIGHTS = {
+    // Structural: a change here really does reach the other side.
+    CALLS: 0.95,
+    PROPAGATES_TO: 0.95,
+    SERVES_API: 0.9,
+    USES_API: 0.9,
+    RETURNS: 0.85,
+    WRITES: 0.8,
+    READS: 0.75,
+    // A shape dependency is structural and real — change the type and the
+    // declaration that embeds it may stop compiling — but it is weaker than a
+    // call: the dependant names the type, it does not execute anything. Placed
+    // between READS and IMPLEMENTS, and provisional like every other value here.
+    USES_TYPE: 0.7,
+    IMPLEMENTS: 0.7,
+    INHERITS: 0.7,
+    // §12.3's example: an import is a weak signal and must decay fast, or
+    // `logger.ts` survives and the engine reports noise as impact.
+    IMPORTS: 0.4,
+    // Tests are reached deliberately by the test-discovery query rather than by
+    // impact decay, so this only needs to be non-zero.
+    TESTS: 0.5,
+    // History, not structure. Everything from the git source is R0 and capped at
+    // 0.5 confidence already (DEC-019); a low weight keeps it as a hint.
+    CHANGES_WITH: 0.35,
+    INCIDENT_CORRELATED: 0.3,
+    FIXED_BY: 0.3,
+};
+export const DEFAULT_SCOPING_CONFIG = {
+    edgeWeights: DEFAULT_EDGE_WEIGHTS,
+    fanOutBuckets: DEFAULT_FANOUT_BUCKETS,
+    maxCouplingFactor: 1.3,
+    maxIncidentFactor: 1.2,
+    maxScore: 1,
+    // §12.3's example drops `logger.ts` at 0.16 and keeps `utils.ts` at 0.40, so
+    // the prune point sits between them. Above it, §12.7's tier 4 (below 0.3) is
+    // kept but is the first thing budget pressure discards.
+    threshold: 0.2,
+};
+export class ScopingConfigError extends Error {
+    name = "ScopingConfigError";
+}
+/**
+ * Refuse a configuration that could fail to terminate — DEC-028's config-load half.
+ *
+ * The check is per edge type because the failure is: one type's weight, boosted
+ * to its declared maxima, reaching 1.0. A global average would hide exactly the
+ * case that matters.
+ */
+export function validateScopingConfig(config) {
+    if (!(config.maxScore > 0) || config.maxScore > 1) {
+        throw new ScopingConfigError(`maxScore must be within (0, 1]; got ${config.maxScore}`);
+    }
+    if (config.maxCouplingFactor < 1 || config.maxIncidentFactor < 1) {
+        throw new ScopingConfigError("coupling and incident factors are boosts and default to 1.0 (neutral); a maximum below 1 " +
+            "would penalise files with history rather than leaving them unaffected (§12.4)");
+    }
+    if (!(config.threshold > 0) || config.threshold >= 1) {
+        throw new ScopingConfigError(`threshold must be within (0, 1); got ${config.threshold}`);
+    }
+    // DEC-067's table, checked before it can reach the termination assertion.
+    const buckets = config.fanOutBuckets;
+    if (buckets.length === 0) {
+        throw new ScopingConfigError("fanOutBuckets must not be empty; use a single open bucket to disable attenuation");
+    }
+    let previous = -1;
+    for (const bucket of buckets) {
+        if (!(bucket.upTo > previous)) {
+            throw new ScopingConfigError(`fanOutBuckets must have strictly increasing bounds; ${bucket.label} (upTo ${bucket.upTo}) does not exceed ${previous}`);
+        }
+        previous = bucket.upTo;
+        if (!(bucket.multiplier > 0)) {
+            throw new ScopingConfigError(`fan-out multiplier for ${bucket.label} must be > 0; got ${bucket.multiplier}. Zero would ` +
+                `silently delete a real dependency from every blast radius that reaches it, which is a ` +
+                `missing edge wearing a score.`);
+        }
+    }
+    if (buckets[buckets.length - 1].upTo !== Number.POSITIVE_INFINITY) {
+        throw new ScopingConfigError(`the last fan-out bucket must be open (upTo: Infinity), or a node above ${previous} falls in no bucket`);
+    }
+    // DEC-028's config-load half, widened by DEC-067. Because history factors no
+    // longer compound per hop, the requirement is on the weight alone — and
+    // `maxConfidence` is 1.0 by definition, so a weight of 1.0 is exactly the
+    // non-terminating case. Attenuation multiplies into the same product, so a
+    // multiplier above 1.0 would make a weight that decays on its own stop
+    // decaying in transit. DEC-067 requires this check to widen *before* such a
+    // value ships, so it is written now while every multiplier is still <= 1.
+    const largest = maxAttenuation(buckets);
+    const offenders = [];
+    for (const type of EDGE_TYPES) {
+        const weight = config.edgeWeights[type];
+        if (!(weight > 0) || weight * largest >= 1) {
+            offenders.push(largest === 1 ? `${type} (${weight})` : `${type} (${weight} × ${largest})`);
+        }
+    }
+    if (offenders.length > 0) {
+        throw new ScopingConfigError(`these edge weights do not decay, so expansion stops on hop count rather than on score ` +
+            `(§12.2) and never terminates on a cyclic graph: ${offenders.join(", ")}. Required: ` +
+            `0 < edgeWeight × maxFanOutMultiplier × maxConfidence < 1, and maxConfidence is 1.0 by ` +
+            `definition (DEC-028, widened by DEC-067). ` +
+            `§12.3's own example uses ×1.0 for a CALLS hop and ×0.95 three hops later; the 0.95 is ` +
+            `the usable one.`);
+    }
+}
+//# sourceMappingURL=weights.js.map

package/dist/scoping/weights.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights.js","sourceRoot":"","sources":["../../src/scoping/weights.ts"],"names":[],"mappings":"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"}

package/dist/sources/git/diff.d.ts

@@ -0,0 +1,53 @@
+/**
+ * `gitDiff` — a live textual diff between two refs. §18's `get_git_diff`.
+ *
+ * `changedFiles` (`history.ts`) already answers "which files changed" — a
+ * bare path list. This answers "what changed in them" — per-file status and
+ * line counts always, plus the actual unified-diff patch text when it is
+ * cheap enough to hand to a model. §4's own worry ("the client's context
+ * window is not yours to spend") is the reason a patch is never returned
+ * unconditionally: a single large file rewrite can be tens of thousands of
+ * tokens, and a caller that wanted only "did this file change and how much"
+ * pays that cost with no way to decline it. `patchOmittedReason` names why,
+ * rather than silently shrinking the reply — the empty-denominator rule
+ * applies to a dropped patch exactly as it does to a dropped finding.
+ *
+ * One `git diff` invocation for every file at once, not one per file — a
+ * PR touching fifty files would otherwise spawn fifty processes. The output
+ * is a concatenation of per-file blocks, each beginning with a line
+ * `diff --git a/<path> b/<path>`; parsing splits on that boundary and reads
+ * the more specific `rename from`/`rename to`/`new file mode`/
+ * `deleted file mode`/`Binary files … differ`/`---`/`+++` lines within each
+ * block, which are unambiguous where the `diff --git` header line alone is
+ * not (a path containing the literal substring `" b/"` defeats that header's
+ * own regex — an accepted, narrow gap, not a silent one, since every other
+ * line used here does not share it).
+ */
+export interface GitDiffFile {
+    /** Path as it is known after the change (the only path for A/M/D). */
+    readonly path: string;
+    /** Set only when `status === "R"`. */
+    readonly fromPath: string | null;
+    readonly status: "A" | "M" | "D" | "R";
+    readonly binary: boolean;
+    /** `null` for a binary file — a line count is not a meaningful claim about one. */
+    readonly additions: number | null;
+    readonly deletions: number | null;
+    /** The unified diff text for this file, or `null` — see `patchOmittedReason`. */
+    readonly patch: string | null;
+    /** Non-null exactly when `patch` is null: why it was withheld. */
+    readonly patchOmittedReason: string | null;
+}
+export interface GitDiffOptions {
+    /** Scope the diff to these repo-relative paths. Default: the whole diff. */
+    readonly files?: readonly string[];
+    /** A file's patch is omitted (stats are still reported) above this many bytes. Default 20,000. */
+    readonly maxPatchBytes?: number;
+}
+/**
+ * `base...head` (three dots), matching `changedFiles`'s own reasoning: two
+ * dots would include everything changed on `base` since the branch point,
+ * misattributing someone else's history to this diff.
+ */
+export declare function gitDiff(cwd: string, base: string, head?: string, options?: GitDiffOptions): Promise<readonly GitDiffFile[]>;
+//# sourceMappingURL=diff.d.ts.map

package/dist/sources/git/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/sources/git/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAwBH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,kEAAkE;IAClE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,kGAAkG;IAClG,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAmED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,SAAS,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAqCjC"}

package/dist/sources/git/diff.js

@@ -0,0 +1,140 @@
+/**
+ * `gitDiff` — a live textual diff between two refs. §18's `get_git_diff`.
+ *
+ * `changedFiles` (`history.ts`) already answers "which files changed" — a
+ * bare path list. This answers "what changed in them" — per-file status and
+ * line counts always, plus the actual unified-diff patch text when it is
+ * cheap enough to hand to a model. §4's own worry ("the client's context
+ * window is not yours to spend") is the reason a patch is never returned
+ * unconditionally: a single large file rewrite can be tens of thousands of
+ * tokens, and a caller that wanted only "did this file change and how much"
+ * pays that cost with no way to decline it. `patchOmittedReason` names why,
+ * rather than silently shrinking the reply — the empty-denominator rule
+ * applies to a dropped patch exactly as it does to a dropped finding.
+ *
+ * One `git diff` invocation for every file at once, not one per file — a
+ * PR touching fifty files would otherwise spawn fifty processes. The output
+ * is a concatenation of per-file blocks, each beginning with a line
+ * `diff --git a/<path> b/<path>`; parsing splits on that boundary and reads
+ * the more specific `rename from`/`rename to`/`new file mode`/
+ * `deleted file mode`/`Binary files … differ`/`---`/`+++` lines within each
+ * block, which are unambiguous where the `diff --git` header line alone is
+ * not (a path containing the literal substring `" b/"` defeats that header's
+ * own regex — an accepted, narrow gap, not a silent one, since every other
+ * line used here does not share it).
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { cleanGitEnv } from "./env.js";
+const execFileAsync = promisify(execFile);
+// Always strips GIT_DIR/GIT_WORK_TREE/GIT_INDEX_FILE/GIT_COMMON_DIR — see env.ts.
+function run(command, args, options) {
+    return execFileAsync(command, args, {
+        ...options,
+        encoding: "utf8",
+        env: cleanGitEnv(),
+    });
+}
+const DEFAULT_MAX_PATCH_BYTES = 20_000;
+function stripPrefix(path, prefix) {
+    return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+function parseDiffBlock(block) {
+    const lines = block.split("\n");
+    const header = /^diff --git a\/(.*) b\/(.*)$/.exec(lines[0] ?? "");
+    let fromPath = null;
+    let toPath = null;
+    let isNew = false;
+    let isDeleted = false;
+    let isRename = false;
+    let binary = false;
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+        if (line.startsWith("new file mode"))
+            isNew = true;
+        else if (line.startsWith("deleted file mode"))
+            isDeleted = true;
+        else if (line.startsWith("rename from ")) {
+            isRename = true;
+            fromPath = line.slice("rename from ".length);
+        }
+        else if (line.startsWith("rename to ")) {
+            isRename = true;
+            toPath = line.slice("rename to ".length);
+        }
+        else if (line.startsWith("Binary files ")) {
+            binary = true;
+        }
+        else if (line.startsWith("--- ")) {
+            const p = line.slice(4);
+            if (p !== "/dev/null" && !isRename)
+                fromPath = stripPrefix(p, "a/");
+        }
+        else if (line.startsWith("+++ ")) {
+            const p = line.slice(4);
+            if (p !== "/dev/null")
+                toPath = stripPrefix(p, "b/");
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions += 1;
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions += 1;
+        }
+    }
+    const path = toPath ?? (header ? header[2] : null) ?? fromPath;
+    if (path === null || path === undefined)
+        return null;
+    const status = isRename ? "R" : isNew ? "A" : isDeleted ? "D" : "M";
+    return {
+        path,
+        fromPath: status === "R" ? fromPath : null,
+        status,
+        binary,
+        additions: binary ? 0 : additions,
+        deletions: binary ? 0 : deletions,
+    };
+}
+/**
+ * `base...head` (three dots), matching `changedFiles`'s own reasoning: two
+ * dots would include everything changed on `base` since the branch point,
+ * misattributing someone else's history to this diff.
+ */
+export async function gitDiff(cwd, base, head = "HEAD", options = {}) {
+    const maxPatchBytes = options.maxPatchBytes ?? DEFAULT_MAX_PATCH_BYTES;
+    const args = ["diff", "-M", `${base}...${head}`];
+    if (options.files !== undefined && options.files.length > 0)
+        args.push("--", ...options.files);
+    const { stdout } = await run("git", args, { cwd, maxBuffer: 256 * 1024 * 1024 });
+    if (stdout.trim() === "")
+        return [];
+    const blocks = stdout.split(/\n(?=diff --git )/);
+    const files = [];
+    for (const block of blocks) {
+        if (!block.startsWith("diff --git "))
+            continue;
+        const parsed = parseDiffBlock(block);
+        if (parsed === null)
+            continue;
+        const bytes = Buffer.byteLength(block, "utf8");
+        const overCap = !parsed.binary && bytes > maxPatchBytes;
+        files.push({
+            path: parsed.path,
+            fromPath: parsed.fromPath,
+            status: parsed.status,
+            binary: parsed.binary,
+            additions: parsed.binary ? null : parsed.additions,
+            deletions: parsed.binary ? null : parsed.deletions,
+            patch: parsed.binary || overCap ? null : block,
+            patchOmittedReason: parsed.binary
+                ? "binary file — no textual patch"
+                : overCap
+                    ? `diff for this file is ${bytes} bytes, over the ${maxPatchBytes}-byte cap — narrow ` +
+                        '"files" to fetch it on its own, or raise "maxPatchBytes"'
+                    : null,
+        });
+    }
+    return files;
+}
+//# sourceMappingURL=diff.js.map

package/dist/sources/git/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../src/sources/git/diff.ts"],"names":[],"mappings":"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"}

package/dist/sources/git/env.d.ts

@@ -0,0 +1,2 @@
+export declare function cleanGitEnv(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+//# sourceMappingURL=env.d.ts.map

package/dist/sources/git/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/sources/git/env.ts"],"names":[],"mappings":"AAeA,wBAAgB,WAAW,CAAC,IAAI,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,UAAU,CAIpF"}

package/dist/sources/git/env.js

@@ -0,0 +1,21 @@
+/**
+ * The variables git exports into every hook and injects into every
+ * subprocess it spawns. Left in place, an inherited `GIT_DIR` (or
+ * `GIT_WORK_TREE`/`GIT_INDEX_FILE`/`GIT_COMMON_DIR`) overrides repository
+ * discovery even when a git subprocess is given an explicit `cwd` — confirmed
+ * directly: `GIT_DIR=<other>/.git` with `cwd` pointed elsewhere still
+ * initialises `<other>/.git`, not a repository at `cwd`.
+ *
+ * Anything here that shells out to git against a caller-supplied path must
+ * not inherit these, or a caller running inside a git hook (which always has
+ * `GIT_DIR` set) silently operates on the hook's own repository instead of
+ * the one it was given.
+ */
+const LEAKY_GIT_VARS = ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"];
+export function cleanGitEnv(base = process.env) {
+    const env = { ...base };
+    for (const key of LEAKY_GIT_VARS)
+        delete env[key];
+    return env;
+}
+//# sourceMappingURL=env.js.map

package/dist/sources/git/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../../src/sources/git/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,CAAU,CAAC;AAEjG,MAAM,UAAU,WAAW,CAAC,OAA0B,OAAO,CAAC,GAAG;IAC/D,MAAM,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC;IACxB,KAAK,MAAM,GAAG,IAAI,cAAc;QAAE,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/sources/git/history.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Reading git history.
+ *
+ * No dependency: `git` is invoked directly. A library would buy parsing help and
+ * cost a dependency in a package that has none by design, and the format below
+ * is chosen so parsing is unambiguous rather than clever.
+ *
+ * ## Renames are resolved, not ignored
+ *
+ * `CHANGES_WITH` is file-to-file, and `FILE` identity is DEC-004's documented
+ * path fallback — a file's only stable name *is* its path. So a rename silently
+ * splits a file's history in two: the co-change weight built up over two years
+ * resets to zero, and nothing in the output reveals it happened. That is the
+ * exact failure DEC-004 exists to prevent, arriving through the one node type
+ * that cannot avoid it.
+ *
+ * The fix is `-M` plus a canonicalisation pass: history is walked newest-first,
+ * and every historical path is mapped forward to the name the file has today. It
+ * makes DEC-004's guarantee total for files that git can *follow*; where git's
+ * rename detection fails (a rewrite with no similarity), the guarantee stays
+ * partial and that is now a bounded, stated gap rather than an unbounded one.
+ */
+export interface CommitChange {
+    /** Path as it is known **today**, after following renames forward. */
+    readonly path: string;
+    readonly status: "A" | "M" | "D" | "R" | "C";
+    /** Set only when `status` is `"R"` or `"C"` and the source line named it. */
+    readonly fromPath?: string;
+}
+export interface Commit {
+    readonly sha: string;
+    /** Author timestamp, epoch seconds. Never part of any identity. */
+    readonly timestamp: number;
+    readonly subject: string;
+    readonly body: string;
+    readonly changes: readonly CommitChange[];
+}
+export interface HistoryOptions {
+    /** Cap on commits read. History is long and the tail is rarely informative. */
+    readonly maxCommits?: number;
+    /** Ignore commits touching more than this many files — see the note below. */
+    readonly maxFilesPerCommit?: number;
+}
+export declare function gitHead(cwd: string): Promise<string>;
+export declare function isGitRepository(cwd: string): Promise<boolean>;
+/**
+ * Read history newest-first, with renames followed forward to today's paths.
+ *
+ * `--no-merges` is deliberate: a merge commit's file list is the union of both
+ * branches, so counting it as co-change would report every file in a large merge
+ * as coupled to every other. That is the single largest source of false
+ * `CHANGES_WITH` edges, and it is free to exclude.
+ */
+export declare function readHistory(cwd: string, options?: HistoryOptions): Promise<Commit[]>;
+export interface PathLogOptions {
+    /** Cap on commits returned. Default 20 — this is a live, on-demand read, not a bulk ingestion. */
+    readonly maxCommits?: number;
+}
+/** One commit that touched the followed path, as it was known *at that commit* — not forward-canonicalised. */
+export interface PathLogCommit {
+    readonly sha: string;
+    readonly timestamp: number;
+    readonly subject: string;
+    readonly body: string;
+    readonly status: "A" | "M" | "D" | "R" | "C";
+    /** The path as this commit names it — the historical name for a commit at or before a later rename. */
+    readonly path: string;
+    /** Set only when `status` is `"R"` or `"C"`. */
+    readonly fromPath: string | null;
+}
+export interface PathLogResult {
+    readonly commits: readonly PathLogCommit[];
+    /**
+     * How many commits touch this path in total, independent of `maxCommits`.
+     * A second, cheap `git log --format=%H` count — not `commits.length`,
+     * which stops at the cap — so a caller can tell "here are the 20 most
+     * recent" from "here are all 3 there are" without guessing from the cap.
+     */
+    readonly totalTouching: number;
+}
+/**
+ * Live commit history for one file, right now — distinct from `history.ts`'s
+ * `changesWith`, which only reads the graph's stored `CHANGES_WITH` ledger
+ * built once at `analyze` time. `--follow` tracks the file across renames;
+ * unlike `readHistory`'s whole-repo walk, each commit here reports its own
+ * historical name rather than today's — the rename itself is part of what a
+ * caller asking "what happened to this file" wants to see.
+ */
+export declare function logForPath(cwd: string, path: string, options?: PathLogOptions): Promise<PathLogResult>;
+/**
+ * Resolve one commit directly by sha, bypassing both `readHistory`'s
+ * reachability filter and its `--no-merges` exclusion.
+ *
+ * `readHistory` walks history from `HEAD` only — co-change must stay scoped to
+ * mainline, or work in progress on other branches would pollute
+ * `CHANGES_WITH` — and drops merge commits, because a merge's file list is
+ * the union of both branches (see the module doc). Both are correct for
+ * co-change. Neither is correct for resolving what a revert commit names:
+ * `git revert`'s `This reverts commit <sha>` line can point at a commit that
+ * **is** a merge ("Revert Merge pull request #N"), or at a commit that is
+ * real and still in the object database but not an ancestor of `HEAD` — an
+ * abandoned branch, or one deleted after a squash/rebase merge whose objects
+ * have not yet been garbage-collected. Neither case means the commit does
+ * not exist; `readHistory`'s index just cannot see it.
+ *
+ * `git cat-file` and `git diff-tree` operate on the object database directly
+ * and enforce neither constraint, so this is the fallback `createGitSource`
+ * uses once `readHistory`'s own index has already missed a revert target.
+ *
+ * Returns `null` only when the object genuinely does not exist — the
+ * squash-merge case, where the original commit was never an ancestor of
+ * anything that survived and its object is gone from the store. That is the
+ * one case nothing can resolve; the caller must disclose it rather than
+ * drop it silently (CLAUDE.md rule 7 — every fallback is labelled).
+ *
+ * File paths returned here are **not** forward-canonicalised through
+ * `readHistory`'s rename map — this commit was never visited by that walk.
+ * A file renamed on mainline *after* this commit landed will show under its
+ * name at the time, not today's name. That is a narrower, disclosed version
+ * of the same rename gap the module doc already states for the primary walk.
+ */
+export declare function resolveCommitBySha(cwd: string, sha: string, maxFilesPerCommit?: number): Promise<Commit | null>;
+/**
+ * Files changed between two refs — the input to PR analysis.
+ *
+ * `base...head` (three dots) rather than `base..head`, and the difference is the
+ * whole point: two dots diffs the two tips, so every file changed on `base`
+ * since the branch point appears in the result as though the PR had touched it.
+ * On a branch a week behind `main` that is most of the diff, and the blast
+ * radius it produces belongs to somebody else's change. Three dots diffs against
+ * the merge base, which is what a reviewer is actually looking at.
+ *
+ * Deletions are included. A deleted file's nodes may still be in the graph, and
+ * *what called the thing you just removed* is the most useful question a diff
+ * can be asked.
+ */
+export declare function changedFiles(cwd: string, base: string, head?: string): Promise<string[]>;
+/** `git show --name-only` for one commit, with today's paths where known. */
+export declare function filesInCommit(cwd: string, sha: string): Promise<string[]>;
+//# sourceMappingURL=history.d.ts.map

package/dist/sources/git/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/sources/git/history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AA0BH,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC7C,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG1D;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE;AA0BD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA4D9F;AAED,MAAM,WAAW,cAAc;IAC7B,kGAAkG;IAClG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,+GAA+G;AAC/G,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC7C,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAuDxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,iBAAiB,SAAK,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoExB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,SAAS,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CASnB;AAED,6EAA6E;AAC7E,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAU/E"}