@davesheffer/hunch 1.7.0 → 1.8.0

package/dist/constitution/delta.js

@@ -0,0 +1,154 @@
+import { shortHash } from "../core/ids.js";
+import { commitChanges, fileAtRef, firstParent, revParse } from "../extractors/git.js";
+import { attributeCalls, parseSource } from "../extractors/parse.js";
+import { canonicalHash } from "./canonical.js";
+import { StructuralDeltaSchema, } from "./schema.js";
+const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const SKIP_SEGMENTS = new Set(["node_modules", ".git", ".hunch", "dist", "build", "coverage", ".next", "out", "vendor"]);
+const MAX_CODE_FILES = 64;
+const MAX_SOURCE_BYTES = 8 * 1024 * 1024;
+const MAX_FACTS = 128;
+function eligibleCode(file) {
+    return !!file
+        && CODE_EXT.test(file)
+        && !file.includes(".generated.")
+        && !file.split(/[\\/]/).some((segment) => SKIP_SEGMENTS.has(segment));
+}
+const symbolKey = (s) => `${s.kind}\0${s.name}`;
+const callKey = (c) => `${c.caller}\0${c.callee}\0${c.member ? "1" : "0"}`;
+function view(file, source) {
+    if (source == null || !eligibleCode(file))
+        return null;
+    const parsed = parseSource(file, source);
+    if (!parsed)
+        return null;
+    return viewOfParsed(parsed);
+}
+function viewOfParsed(parsed) {
+    const symbols = new Map(parsed.symbols.map((s) => [symbolKey(s), s]));
+    const byStart = new Map(parsed.symbols.map((s) => [s.startByte, s]));
+    const calls = new Map();
+    for (const [start, callees] of attributeCalls(parsed)) {
+        const caller = byStart.get(start);
+        if (!caller)
+            continue;
+        for (const [callee, member] of callees) {
+            const call = { caller: caller.name, callee, member };
+            calls.set(callKey(call), call);
+        }
+    }
+    return { symbols, calls, imports: new Set(parsed.imports) };
+}
+function symbolRef(file, symbol) {
+    return { file, name: symbol.name, kind: symbol.kind };
+}
+function callRef(file, call) {
+    return { file, ...call };
+}
+function importRef(file, specifier) {
+    return { file, specifier };
+}
+function sortByKey(items, key) {
+    return items.sort((a, b) => key(a).localeCompare(key(b)));
+}
+/** Compare exact git blobs at a commit and its first parent. No checkout,
+ * worktree, hook, or model/provider is involved. */
+export function extractStructuralDelta(root, commit) {
+    const after = revParse(commit, root);
+    const before = firstParent(after, root);
+    if (!before)
+        throw new Error(`commit ${commit} has no first parent; an initial snapshot cannot prove a fixing structural delta`);
+    const addedSymbols = [];
+    const removedSymbols = [];
+    const movedSymbols = [];
+    const addedCalls = [];
+    const removedCalls = [];
+    const addedImports = [];
+    const removedImports = [];
+    const files = new Set();
+    let codeFiles = 0;
+    let sourceBytes = 0;
+    for (const change of commitChanges(after, root)) {
+        const beforeFile = change.before;
+        const afterFile = change.after;
+        if (beforeFile)
+            files.add(beforeFile);
+        if (afterFile)
+            files.add(afterFile);
+        if (!eligibleCode(beforeFile) && !eligibleCode(afterFile))
+            continue;
+        if (++codeFiles > MAX_CODE_FILES)
+            throw new Error(`structural delta exceeds ${MAX_CODE_FILES} changed code files; narrow or split the evidence commit`);
+        const beforeSource = change.status === "copied" || !eligibleCode(beforeFile) ? null : fileAtRef(before, beforeFile, root);
+        const afterSource = !eligibleCode(afterFile) ? null : fileAtRef(after, afterFile, root);
+        sourceBytes += Buffer.byteLength(beforeSource ?? "") + Buffer.byteLength(afterSource ?? "");
+        if (sourceBytes > MAX_SOURCE_BYTES)
+            throw new Error(`structural delta exceeds ${MAX_SOURCE_BYTES} source bytes; narrow or split the evidence commit`);
+        const beforeView = beforeFile ? view(beforeFile, beforeSource) : null;
+        const afterView = afterFile ? view(afterFile, afterSource) : null;
+        if (!beforeView && !afterView)
+            continue;
+        const beforeSymbols = beforeView?.symbols ?? new Map();
+        const afterSymbols = afterView?.symbols ?? new Map();
+        for (const [key, symbol] of afterSymbols) {
+            if (!beforeSymbols.has(key))
+                addedSymbols.push(symbolRef(afterFile, symbol));
+            else if (change.status === "renamed" && beforeFile !== afterFile) {
+                movedSymbols.push({ from: beforeFile, to: afterFile, name: symbol.name, kind: symbol.kind });
+            }
+        }
+        for (const [key, symbol] of beforeSymbols) {
+            if (!afterSymbols.has(key))
+                removedSymbols.push(symbolRef(beforeFile, symbol));
+        }
+        const beforeCalls = beforeView?.calls ?? new Map();
+        const afterCalls = afterView?.calls ?? new Map();
+        for (const [key, call] of afterCalls) {
+            if (!beforeCalls.has(key))
+                addedCalls.push(callRef(afterFile, call));
+        }
+        for (const [key, call] of beforeCalls) {
+            if (!afterCalls.has(key))
+                removedCalls.push(callRef(afterFile ?? beforeFile, call));
+        }
+        const beforeImports = beforeView?.imports ?? new Set();
+        const afterImports = afterView?.imports ?? new Set();
+        for (const specifier of afterImports) {
+            if (!beforeImports.has(specifier))
+                addedImports.push(importRef(afterFile, specifier));
+        }
+        for (const specifier of beforeImports) {
+            if (!afterImports.has(specifier))
+                removedImports.push(importRef(afterFile ?? beforeFile, specifier));
+        }
+    }
+    const factCount = addedSymbols.length + removedSymbols.length + movedSymbols.length
+        + addedCalls.length + removedCalls.length + addedImports.length + removedImports.length;
+    if (factCount > MAX_FACTS)
+        throw new Error(`structural delta exceeds ${MAX_FACTS} extracted facts; narrow or split the evidence commit`);
+    const body = {
+        before_commit: before,
+        after_commit: after,
+        files: [...files].sort(),
+        symbols: {
+            added: sortByKey(addedSymbols, (s) => `${s.file}\0${s.kind}\0${s.name}`),
+            removed: sortByKey(removedSymbols, (s) => `${s.file}\0${s.kind}\0${s.name}`),
+            moved: sortByKey(movedSymbols, (s) => `${s.from}\0${s.to}\0${s.kind}\0${s.name}`),
+        },
+        calls: {
+            added: sortByKey(addedCalls, (c) => `${c.file}\0${callKey(c)}`),
+            removed: sortByKey(removedCalls, (c) => `${c.file}\0${callKey(c)}`),
+        },
+        imports: {
+            added: sortByKey(addedImports, (i) => `${i.file}\0${i.specifier}`),
+            removed: sortByKey(removedImports, (i) => `${i.file}\0${i.specifier}`),
+        },
+    };
+    const contentHash = canonicalHash(body);
+    return StructuralDeltaSchema.parse({
+        id: `delta_${shortHash(contentHash)}`,
+        ...body,
+        content_hash: contentHash,
+    });
+}
+//# sourceMappingURL=delta.js.map

package/dist/constitution/disposition.js

@@ -0,0 +1,141 @@
+import { shortHash } from "../core/ids.js";
+import { canonicalHash } from "./canonical.js";
+import { policyProofHash } from "./composition.js";
+import { HistoryDispositionClassificationSchema, HistoryDispositionSchema, } from "./schema.js";
+export function historyDispositionContentHash(disposition) {
+    const { id: _id, content_hash: _contentHash, ...body } = disposition;
+    return canonicalHash(body);
+}
+export function historyDispositionJudgmentHash(disposition) {
+    const { id: _id, content_hash: _contentHash, created_at: _createdAt, ...judgment } = disposition;
+    return canonicalHash(judgment);
+}
+export function compileHistoryDisposition(policy, proof, receipt, classification, actor, reason, opts = {}) {
+    const parsedClassification = HistoryDispositionClassificationSchema.parse(classification);
+    const policyHash = policyProofHash(policy, opts.composition ?? []);
+    if (policy.proof !== proof.id)
+        throw new Error(`policy ${policy.id} does not link proof ${proof.id}`);
+    if (proof.policy_hash !== policyHash)
+        throw new Error(`proof ${proof.id} does not match current policy semantics`);
+    if (proof.data_class !== policy.data_class)
+        throw new Error(`proof ${proof.id} does not match policy ${policy.id} data class`);
+    if (receipt.leg !== "accepted_history" || receipt.result !== "violated") {
+        throw new Error("history dispositions apply only to violated accepted-history replay receipts");
+    }
+    if (receipt.policy_hash !== proof.policy_hash)
+        throw new Error(`receipt ${receipt.deterministic_hash} does not match proof policy semantics`);
+    if (!proof.replay_receipts.some((candidate) => candidate.leg === receipt.leg && candidate.commit === receipt.commit && candidate.result === receipt.result && candidate.deterministic_hash === receipt.deterministic_hash)) {
+        throw new Error(`receipt ${receipt.deterministic_hash} is not embedded in proof ${proof.id}`);
+    }
+    const createdAt = opts.now ?? new Date().toISOString();
+    const body = {
+        policy_id: policy.id,
+        proof_id: proof.id,
+        policy_hash: proof.policy_hash,
+        plan_hash: proof.plan_hash,
+        commit: receipt.commit,
+        receipt_hash: receipt.deterministic_hash,
+        classification: parsedClassification,
+        actor,
+        reason: reason.trim(),
+        supersedes: opts.supersedes ?? null,
+        data_class: policy.data_class,
+        created_at: createdAt,
+    };
+    const contentHash = canonicalHash(body);
+    return HistoryDispositionSchema.parse({
+        id: `disp_${shortHash(contentHash)}`,
+        content_hash: contentHash,
+        ...body,
+    });
+}
+/** Resolve the append-only supersession chain without trusting timestamps.
+ * Missing parents, cross-hit links, branches, and cycles fail visibly. */
+export function currentHistoryDispositions(records) {
+    const byId = new Map(records.map((record) => [record.id, record]));
+    if (byId.size !== records.length)
+        throw new Error("duplicate history disposition id");
+    const childCount = new Map();
+    for (const record of records) {
+        if (!record.supersedes)
+            continue;
+        const parent = byId.get(record.supersedes);
+        if (!parent)
+            throw new Error(`history disposition ${record.id} supersedes missing ${record.supersedes}`);
+        if (parent.policy_id !== record.policy_id || parent.proof_id !== record.proof_id || parent.commit !== record.commit) {
+            throw new Error(`history disposition ${record.id} supersedes a different policy/proof/commit hit`);
+        }
+        childCount.set(parent.id, (childCount.get(parent.id) ?? 0) + 1);
+        if (childCount.get(parent.id) > 1)
+            throw new Error(`history disposition ${parent.id} has a branched supersession chain`);
+    }
+    for (const record of records) {
+        const visited = new Set();
+        let cursor = record;
+        while (cursor?.supersedes) {
+            if (visited.has(cursor.id))
+                throw new Error(`history disposition chain contains a cycle at ${cursor.id}`);
+            visited.add(cursor.id);
+            cursor = byId.get(cursor.supersedes);
+        }
+    }
+    const current = records
+        .filter((record) => !childCount.has(record.id))
+        .sort((left, right) => left.policy_id.localeCompare(right.policy_id) || left.proof_id.localeCompare(right.proof_id) || left.commit.localeCompare(right.commit));
+    const currentByHit = new Set();
+    for (const record of current) {
+        const key = `${record.policy_id}:${record.proof_id}:${record.commit}`;
+        if (currentByHit.has(key))
+            throw new Error(`history hit ${record.commit} has multiple current dispositions`);
+        currentByHit.add(key);
+    }
+    return current;
+}
+export function assessHistoryDispositions(proof, records) {
+    const current = currentHistoryDispositions(records).filter((record) => record.proof_id === proof.id);
+    const violations = proof.replay_receipts.filter((receipt) => receipt.leg === "accepted_history" && receipt.result === "violated");
+    const counts = {
+        true_positive_actionable: 0,
+        true_positive_accepted_exception: 0,
+        false_positive_selector: 0,
+        false_positive_semantics: 0,
+        false_positive_stale: 0,
+        unknown_insufficient_parser: 0,
+    };
+    if (violations.length !== proof.accepted_history.violated) {
+        return {
+            current,
+            bound: [],
+            missing_commits: violations.map((receipt) => receipt.commit),
+            unresolved_count: proof.accepted_history.violated,
+            counts,
+            blocking_error: "blocking proof accepted-history violation summary does not match its replay receipts",
+        };
+    }
+    const bound = [];
+    const missing = [];
+    for (const receipt of violations) {
+        const candidates = current.filter((record) => record.commit === receipt.commit);
+        const disposition = candidates.find((record) => record.receipt_hash === receipt.deterministic_hash && record.policy_hash === proof.policy_hash && record.plan_hash === proof.plan_hash);
+        if (!disposition) {
+            missing.push(receipt.commit);
+            continue;
+        }
+        bound.push(disposition);
+        counts[disposition.classification] += 1;
+    }
+    let blockingError = null;
+    if (missing.length)
+        blockingError = "blocking proof has unclassified accepted-history violation hits";
+    else if (counts.false_positive_selector + counts.false_positive_semantics + counts.false_positive_stale > 0) {
+        blockingError = "blocking proof has a human-classified accepted-history false positive; repair and re-prove the policy first";
+    }
+    else if (counts.unknown_insufficient_parser > 0) {
+        blockingError = "blocking proof has an accepted-history hit classified unknown for insufficient parser support";
+    }
+    else if (counts.true_positive_accepted_exception > 0) {
+        blockingError = "blocking proof has an accepted exception that requires separately proved parent/exception composition";
+    }
+    return { current, bound, missing_commits: missing, unresolved_count: missing.length, counts, blocking_error: blockingError };
+}
+//# sourceMappingURL=disposition.js.map