@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/git/integration.js

@@ -1,10 +1,10 @@
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId, gitObjectIdForSnapshot, mintChangeId, mintSnapshotId } from "./identity.js";
-import { GitPlumbingError, readRef, runGit, runGitWithEnvironment, } from "./repository.js";
+import { decodeGitNameOnly, decodeGitNumstat, GitPlumbingError, readRef, runGit, runGitWithEnvironment, } from "./repository.js";
 const REQUIRED_GIT = "2.38";
-function runAllowingNonzero(repository, args, input) {
+async function runAllowingNonzero(repository, args, input) {
     try {
-        return { stdout: runGit(repository, args, input), stderr: Buffer.alloc(0), status: 0 };
+        return { stdout: await runGit(repository, args, input), stderr: Buffer.alloc(0), status: 0 };
     }
     catch (error) {
         if (!(error instanceof GitPlumbingError))
@@ -12,29 +12,51 @@ function runAllowingNonzero(repository, args, input) {
         return { stdout: error.stdout, stderr: error.stderr, status: error.status };
     }
 }
-function stablePatchId(repository, predecessor, tree) {
-    const diff = runGit(repository, ["diff", "--binary", gitObjectIdForSnapshot(predecessor), tree]);
-    const output = runGit(repository, ["patch-id", "--stable"], diff).toString("utf8").trim();
-    const separator = output.indexOf(" ");
-    const identity = output.length === 0
-        ? runGit(repository, ["hash-object", "-t", "blob", "--stdin"], diff).toString("utf8").trim()
-        : separator < 0 ? output : output.slice(0, separator);
-    return mintChangeId(identity);
+/** Mint the one worktree-content identity shared by review and delivery. */
+export async function worktreeChangeId(repository, input, tender) {
+    const patch = await runGit(repository, [
+        "-c", "core.quotePath=false",
+        "-c", "core.abbrev=40",
+        "-c", "diff.algorithm=myers",
+        "-c", "diff.renames=false",
+        "-c", "diff.indentHeuristic=false",
+        "-c", "diff.suppressBlankEmpty=false",
+        "diff",
+        "--no-ext-diff",
+        "--no-textconv",
+        "--no-indent-heuristic",
+        "--no-renames",
+        "--full-index",
+        "--binary",
+        "--no-color",
+        "--diff-algorithm=myers",
+        "--unified=3",
+        "--src-prefix=a/",
+        "--dst-prefix=b/",
+        "--inter-hunk-context=0",
+        "--no-relative",
+        "--ignore-submodules=none",
+        "--submodule=short",
+        gitObjectIdForSnapshot(input.coordinates.start),
+        tender.tree,
+    ]);
+    const id = (await runGit(repository, ["patch-id", "--verbatim"], patch)).toString("utf8").trim().split(/\s/, 1)[0] ?? "";
+    return mintChangeId(id === "" ? "0000000000000000000000000000000000000000" : id);
 }
 /** Materialize the exact integration tree against its observed predecessor. */
-export function materializeIntegrationSnapshot(repository, tree, parent, input) {
-    const commit = runGitWithEnvironment(repository, ["commit-tree", tree, "-p", gitObjectIdForSnapshot(parent)], `${input.message ?? `${input.contractId}: ${input.title}`}\n\nKeiyaku-Contract: ${input.contractId}\n`, {
+export async function materializeIntegrationSnapshot(repository, tree, parent, input) {
+    const commit = (await runGitWithEnvironment(repository, ["commit-tree", tree, "-p", gitObjectIdForSnapshot(parent)], `${input.message ?? `${input.contractId}: ${input.title}`}\n\nKeiyaku-Contract: ${input.contractId}\n`, {
         GIT_AUTHOR_NAME: "Keiyaku",
         GIT_AUTHOR_EMAIL: "keiyaku@localhost",
         GIT_COMMITTER_NAME: "Keiyaku",
         GIT_COMMITTER_EMAIL: "keiyaku@localhost",
         GIT_AUTHOR_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
         GIT_COMMITTER_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
-    }).toString("utf8").trim();
+    })).toString("utf8").trim();
     return mintSnapshotId(commit);
 }
-function isAncestor(repository, ancestor, descendant) {
-    const result = runAllowingNonzero(repository, [
+async function isAncestor(repository, ancestor, descendant) {
+    const result = await runAllowingNonzero(repository, [
         "merge-base",
         "--is-ancestor",
         gitObjectIdForSnapshot(ancestor),
@@ -50,8 +72,8 @@ function isAncestor(repository, ancestor, descendant) {
         message: "git merge-base --is-ancestor failed",
     });
 }
-function commonAncestor(repository, left, right) {
-    const result = runAllowingNonzero(repository, [
+async function commonAncestor(repository, left, right) {
+    const result = await runAllowingNonzero(repository, [
         "merge-base",
         gitObjectIdForSnapshot(left),
         gitObjectIdForSnapshot(right),
@@ -67,8 +89,8 @@ function commonAncestor(repository, left, right) {
     }
     return mintSnapshotId(result.stdout.toString("utf8").trim());
 }
-function supportsMergeTree(repository) {
-    return runAllowingNonzero(repository, ["merge-tree", "--write-tree", "--stdin"], "").status === 0;
+async function supportsMergeTree(repository) {
+    return (await runAllowingNonzero(repository, ["merge-tree", "--write-tree", "--stdin"], "")).status === 0;
 }
 function nulFields(output) {
     const fields = output.toString("utf8").split("\0");
@@ -76,11 +98,11 @@ function nulFields(output) {
         throw new Error("Git merge-tree output is not NUL terminated");
     return fields.slice(0, -1);
 }
-function mergedTree(repository, contractId, base, targetHead, tenderTree) {
-    if (!supportsMergeTree(repository)) {
+async function mergedTree(repository, contractId, base, targetHead, tenderTree) {
+    if (!(await supportsMergeTree(repository))) {
         return { kind: "refused", refusal: { kind: "integration-unsupported", contractId, requiredGit: REQUIRED_GIT } };
     }
-    const result = runAllowingNonzero(repository, [
+    const result = await runAllowingNonzero(repository, [
         "merge-tree",
         "--write-tree",
         "--no-messages",
@@ -117,7 +139,7 @@ function mergedTree(repository, contractId, base, targetHead, tenderTree) {
         message: "git merge-tree --write-tree failed",
     });
 }
-export function planIntegration(repository, input, tender, requireBranchesToBeUpToDate) {
+export async function planIntegration(repository, input, tender, requireBranchesToBeUpToDate) {
     const target = input.coordinates.target;
     if (target === undefined) {
         return {
@@ -125,18 +147,17 @@ export function planIntegration(repository, input, tender, requireBranchesToBeUp
             data: {
                 predecessor: input.coordinates.start,
                 tree: tender.tree,
-                changeId: stablePatchId(repository, input.coordinates.start, tender.tree),
             },
         };
     }
-    const observed = readRef(repository, target);
+    const observed = await readRef(repository, target);
     if (observed === null) {
         return { kind: "refused", refusal: { kind: "target-missing", contractId: input.contractId } };
     }
     const targetHead = mintSnapshotId(observed);
     let tree;
     if (requireBranchesToBeUpToDate) {
-        if (!isAncestor(repository, targetHead, tender.head)) {
+        if (!(await isAncestor(repository, targetHead, tender.head))) {
             return {
                 kind: "refused",
                 refusal: {
@@ -150,7 +171,7 @@ export function planIntegration(repository, input, tender, requireBranchesToBeUp
         tree = tender.tree;
     }
     else {
-        const base = commonAncestor(repository, tender.head, targetHead);
+        const base = await commonAncestor(repository, tender.head, targetHead);
         if (base === null) {
             return {
                 kind: "refused",
@@ -162,7 +183,7 @@ export function planIntegration(repository, input, tender, requireBranchesToBeUp
                 },
             };
         }
-        const merged = mergedTree(repository, input.contractId, base, targetHead, tender.tree);
+        const merged = await mergedTree(repository, input.contractId, base, targetHead, tender.tree);
         if (merged.kind === "refused")
             return merged;
         tree = merged.data;
@@ -172,20 +193,12 @@ export function planIntegration(repository, input, tender, requireBranchesToBeUp
         data: {
             predecessor: targetHead,
             tree,
-            changeId: stablePatchId(repository, targetHead, tree),
         },
     };
 }
-/** Prepare the integration-derived review subject from one captured tender. */
-export function prepareReviewIntegration(repository, input, tender, workspace) {
-    const integration = planIntegration(repository, input, tender, false);
-    return integration.kind === "refused"
-        ? integration
-        : { kind: "prepared", data: { changeId: integration.data.changeId, ...(workspace === undefined ? {} : { workspace }) } };
-}
-function deliverySnapshotAvailability(repository, predecessor, candidate) {
+async function deliverySnapshotAvailability(repository, predecessor, candidate) {
     const objects = [gitObjectIdForSnapshot(predecessor), gitObjectIdForSnapshot(candidate)];
-    const types = runGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`).toString("ascii").trimEnd().split("\n").map((record) => record.split(" ")[1]);
+    const types = (await runGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`)).toString("ascii").trimEnd().split("\n").map((record) => record.split(" ")[1]);
     if (types.includes("missing"))
         return "unavailable";
     if (types.some((type) => type !== "commit")) {
@@ -193,21 +206,44 @@ function deliverySnapshotAvailability(repository, predecessor, candidate) {
     }
     return "available";
 }
+/** Compute predecessor-to-candidate scope from the exact integration trees. */
+export async function readDeliveryScope(repository, predecessor, candidate, includePaths) {
+    const scope = decodeGitNumstat(await runGit(repository, [
+        "diff",
+        "--numstat",
+        "-z",
+        gitObjectIdForSnapshot(predecessor),
+        gitObjectIdForSnapshot(candidate),
+    ]));
+    if (!includePaths)
+        return scope;
+    return {
+        ...scope,
+        paths: decodeGitNameOnly(await runGit(repository, [
+            "diff",
+            "--name-only",
+            "--no-renames",
+            "-z",
+            gitObjectIdForSnapshot(predecessor),
+            gitObjectIdForSnapshot(candidate),
+        ])),
+    };
+}
 /** Read a recorded integration pair's patch, or null when Git no longer has it. */
-export function readDeliveryDiff(repository, predecessor, candidate) {
-    if (deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
+export async function readDeliveryDiff(repository, predecessor, candidate) {
+    if (await deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
         return null;
     try {
-        return runGit(repository, [
+        return (await runGit(repository, [
             "diff",
             "--no-ext-diff",
             "--no-color",
             gitObjectIdForSnapshot(predecessor),
             gitObjectIdForSnapshot(candidate),
-        ]).toString("utf8");
+        ])).toString("utf8");
     }
     catch (error) {
-        if (deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
+        if (await deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
             return null;
         throw error;
     }

package/build/src/git/observe.d.ts

@@ -33,14 +33,16 @@ export type BindCoordinatesObservation = Readonly<{
     target?: string;
     branch: string | null;
 }>;
-export declare function normalizeTargetBranch(repository: GitRepository, input: string): string | null;
+export declare function normalizeTargetBranch(repository: GitRepository, input: string): Promise<string | null>;
 /** Read one worktree's attached branch, or null for detached HEAD. */
-export declare function currentBranch(repository: GitRepository, path?: string): string | null;
+export declare function currentBranch(repository: GitRepository, path?: string): Promise<string | null>;
 /** Observe bind's tender start and optional reward target without creating persistent state. */
-export declare function observeBindCoordinates(repository: GitRepository, requestedTarget?: string): BindCoordinatesObservation | null;
+export declare function observeBindCoordinates(repository: GitRepository, requestedTarget?: string): Promise<BindCoordinatesObservation | null>;
 export declare function observeActiveContractWorld(observation: GitReadObservation): Promise<ActiveContractWorldObservation>;
 export declare function observeContractWorld(observation: GitReadObservation, requested?: readonly ContractId[]): Promise<ContractWorldObservation>;
 export declare function observeContractsForAdmissionAt(repository: GitRepository, channel: GitDecodeChannel, ids: readonly ContractId[], selection?: GitTreeSelection): Promise<GitDecisionObservation>;
+/** Observe selected Contract journals and their current direct prerequisites in one Git epoch. */
+export declare function observeGitForAdmissionAt(repository: GitRepository, channel: GitDecodeChannel, ids: readonly ContractId[], selection?: GitTreeSelection): Promise<GitDecisionObservation>;
 export declare function withContractReadObservationAt<Value>(repository: GitRepository, channel: GitDecodeChannel, id: ContractId, consume: (observation: GitReadObservation) => Value | PromiseLike<Value>): Promise<Value>;
 /** Observe targeted Contract journals within an already frozen Git epoch. */
 export declare function observeContractsForAdmissionInObservationAt(observation: GitReadObservation, ids: readonly ContractId[]): Promise<GitDecisionObservation>;

package/build/src/git/observe.js

@@ -19,7 +19,7 @@ export async function observeDeliveryTargetAt(observation, state) {
     return { head, drift: head !== expected };
 }
 const TARGET_COORDINATES_FORMAT = "%(refname)%00%(objectname)%00";
-export function normalizeTargetBranch(repository, input) {
+export async function normalizeTargetBranch(repository, input) {
     if (input.includes("\0"))
         return null;
     const prefix = "refs/heads/";
@@ -30,7 +30,7 @@ export function normalizeTargetBranch(repository, input) {
     if (branch.length === 0 || branch.startsWith("-") || isKeiyakuOwnedRef(target))
         return null;
     try {
-        const checked = runGit(repository, ["check-ref-format", "--branch", branch]).toString("utf8").trim();
+        const checked = (await runGit(repository, ["check-ref-format", "--branch", branch])).toString("utf8").trim();
         return checked === branch ? target : null;
     }
     catch (error) {
@@ -40,14 +40,14 @@ export function normalizeTargetBranch(repository, input) {
     }
 }
 /** Read one worktree's attached branch, or null for detached HEAD. */
-export function currentBranch(repository, path) {
+export async function currentBranch(repository, path) {
     try {
-        const ref = runGit(repository, [
+        const ref = (await runGit(repository, [
             ...(path === undefined ? [] : ["-C", path]),
             "symbolic-ref",
             "--quiet",
             "HEAD",
-        ]).toString("utf8").trim();
+        ])).toString("utf8").trim();
         return ref.startsWith("refs/heads/") ? ref : null;
     }
     catch (error) {
@@ -66,12 +66,12 @@ function structuredFields(output, fieldCount) {
     return fields.slice(0, -1);
 }
 /** Observe bind's tender start and optional reward target without creating persistent state. */
-export function observeBindCoordinates(repository, requestedTarget) {
+export async function observeBindCoordinates(repository, requestedTarget) {
     if (requestedTarget === undefined) {
         try {
             return {
-                start: mintSnapshotId(runGit(repository, ["rev-parse", "--verify", "HEAD"]).toString("utf8").trim()),
-                branch: currentBranch(repository),
+                start: mintSnapshotId((await runGit(repository, ["rev-parse", "--verify", "HEAD"])).toString("utf8").trim()),
+                branch: await currentBranch(repository),
             };
         }
         catch {
@@ -81,7 +81,7 @@ export function observeBindCoordinates(repository, requestedTarget) {
     if (isKeiyakuOwnedRef(requestedTarget)) {
         throw new Error(`bind target names a Keiyaku-owned ref: ${requestedTarget}`);
     }
-    const output = runGit(repository, [
+    const output = await runGit(repository, [
         "for-each-ref",
         `--format=${TARGET_COORDINATES_FORMAT}`,
         "--",
@@ -93,7 +93,7 @@ export function observeBindCoordinates(repository, requestedTarget) {
     if (target !== requestedTarget || start === undefined)
         malformedBindCoordinatesOutput();
     try {
-        return { target, start: mintSnapshotId(start), branch: currentBranch(repository) };
+        return { target, start: mintSnapshotId(start), branch: await currentBranch(repository) };
     }
     catch {
         malformedBindCoordinatesOutput();
@@ -218,7 +218,7 @@ export async function observeContractWorld(observation, requested = []) {
     };
 }
 async function observeTargetedContractsAt(observation, ids) {
-    return observeTargetedContractsFromSnapshotAt(observation.snapshot, observation.readBlobs, ids);
+    return await observeTargetedContractsFromSnapshotAt(observation.snapshot, observation.readBlobs, ids);
 }
 async function observeTargetedContractsFromSnapshotAt(snapshot, readBlobsAt, ids) {
     const paths = ids.flatMap(contractJournalPaths);
@@ -243,7 +243,13 @@ export async function observeContractsForAdmissionAt(repository, channel, ids, s
     return withGitTargetedReadObservation(repository, channel, {
         paths: [...ids.flatMap(contractJournalPaths), ...(selection.paths ?? [])],
         ...(selection.subtrees === undefined ? {} : { subtrees: selection.subtrees }),
-    }, (observation) => observeContractsForAdmissionInObservationAt(observation, ids));
+    }, async (observation) => await observeContractsForAdmissionInObservationAt(observation, ids));
+}
+/** Observe selected Contract journals and their current direct prerequisites in one Git epoch. */
+export async function observeGitForAdmissionAt(repository, channel, ids, selection = {}) {
+    const observation = await observeContractsForAdmissionAt(repository, channel, ids, selection);
+    const prerequisites = [...new Set(ids.flatMap((id) => observation.decision.get(id)?.terms.after ?? []))];
+    return await extendContractsForAdmissionAt(channel, observation, prerequisites);
 }
 export function withContractReadObservationAt(repository, channel, id, consume) {
     return withGitTargetedReadObservation(repository, channel, {

package/build/src/git/read-observation.js

@@ -100,7 +100,7 @@ function batchObjectReader(repository) {
         const cached = cache.get(oid);
         if (cached !== undefined)
             return cached;
-        const requested = tail.then(() => read(oid));
+        const requested = tail.then(async () => await read(oid));
         tail = requested.then(() => undefined, () => undefined);
         cache.set(oid, requested);
         return requested;
@@ -280,7 +280,7 @@ export async function withGitDecodeChannel(repository, consume) {
     return result;
 }
 async function observeEpoch(repository, channel, selection, consume) {
-    const commit = readRef(repository, GIT_REF);
+    const commit = await readRef(repository, GIT_REF);
     let active = true;
     const refs = new Map();
     const assertActive = () => {
@@ -291,10 +291,10 @@ async function observeEpoch(repository, channel, selection, consume) {
         assertActive();
         let resolved = refs.get(ref);
         if (resolved === undefined) {
-            resolved = Promise.resolve().then(() => readRef(repository, ref));
+            resolved = readRef(repository, ref);
             refs.set(ref, resolved);
         }
-        return resolved;
+        return await resolved;
     };
     const readBlobResults = async (oids) => {
         assertActive();
@@ -326,7 +326,7 @@ async function observeEpoch(repository, channel, selection, consume) {
             const commitObject = (await channel.readObjects([commit])).get(commit);
             if (commitObject === undefined)
                 throw new Error(`missing state commit result: ${commit}`);
-            const tree = commitTree(commitObject, commit);
+            const tree = await commitTree(commitObject, commit);
             const observed = selection === null
                 ? await completeTree(channel, tree)
                 : await readGitTreeSelection(channel, tree, selection);
@@ -353,9 +353,9 @@ async function observeEpoch(repository, channel, selection, consume) {
         throw failure;
     return result;
 }
-export function withGitReadObservation(repository, channel, consume) {
-    return observeEpoch(repository, channel, null, consume);
+export async function withGitReadObservation(repository, channel, consume) {
+    return await observeEpoch(repository, channel, null, consume);
 }
-export function withGitTargetedReadObservation(repository, channel, selection, consume) {
-    return observeEpoch(repository, channel, selection, consume);
+export async function withGitTargetedReadObservation(repository, channel, selection, consume) {
+    return await observeEpoch(repository, channel, selection, consume);
 }

package/build/src/git/reconcile.d.ts

@@ -22,6 +22,7 @@ type ReconcileInput = Readonly<{
     hooks: WorktreeHooks;
     retryHooks: boolean;
     retainTerminalWorktree?: boolean;
+    place?: string;
 }>;
 type WorktreeRetained = Readonly<{
     kind: "worktree-retained";
@@ -53,6 +54,7 @@ type ReconcileBatchOptions = Readonly<{
     hooks: WorktreeHooks;
     retryHooks: boolean;
     retainTerminalWorktree: boolean;
+    places?: ReadonlyMap<ContractId, string>;
 }>;
 /** Reconcile each discovered Contract through its own serialized, fresh observation. */
 export declare function reconcileBatch(repository: GitRepository, channel: GitDecodeChannel, contracts: Iterable<ContractId>, options: ReconcileBatchOptions): Promise<readonly ReconcileBatchItem[]>;