@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/registry.js

@@ -1,9 +1,11 @@
 import { FlowError } from "../flow-error.js";
+import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
 import { appendRefLogWithRetry } from "./ref-log.js";
-import { isNegativeScopePattern, patternsOverlap } from "./scope.js";
+import { patternsOverlap, scopePathEvidence } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 export const REGISTRY_REF = "refs/keiyaku/registry";
+export const SCOPE_OVERLAP_PATH_PREVIEW_LIMIT = 10;
 function parseRegistryEntry(message) {
     const body = message.slice(message.indexOf("\n\n") + 2).trim();
     const parsed = JSON.parse(body);
@@ -38,9 +40,19 @@ async function activeRegistrations(cwd, entries) {
     return active;
 }
 export async function registerScope(cwd, input) {
-    let warnings = [];
+    let overlaps = [];
+    let trackedPaths;
+    try {
+        trackedPaths = (await createGit(cwd).raw(["ls-files", "-z"]))
+            .split("\0")
+            .filter(Boolean)
+            .sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    }
+    catch (error) {
+        throw wrapGitError("ls-files -z", error, cwd);
+    }
     const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
-        const nextWarnings = [];
+        const nextOverlaps = [];
         const active = await activeRegistrations(cwd, entries);
         if (input.exclusive && active.length > 0) {
             const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
@@ -55,19 +67,60 @@ export async function registerScope(cwd, input) {
                     `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
                 ].join(" "));
             }
-            for (const nextPattern of input.scope) {
-                if (isNegativeScopePattern(nextPattern))
+            const [nextEvidence, existingEvidence] = await Promise.all([
+                scopePathEvidence(cwd, input.scope, trackedPaths),
+                scopePathEvidence(cwd, existing.scope, trackedPaths),
+            ]);
+            const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
+            const concreteByPatterns = new Map();
+            for (const next of nextEvidence) {
+                const prior = existingByPath.get(next.path);
+                if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
                     continue;
+                const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
+                const group = concreteByPatterns.get(key) ?? {
+                    next: next.decisivePattern.pattern,
+                    existing: prior.decisivePattern.pattern,
+                    paths: [],
+                };
+                group.paths.push(next.path);
+                concreteByPatterns.set(key, group);
+            }
+            for (const concrete of concreteByPatterns.values()) {
+                const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
+                nextOverlaps.push({
+                    contracts: [input.contractId, existing.contract],
+                    patterns: [concrete.next, concrete.existing],
+                    kind: "concrete",
+                    paths: {
+                        preview,
+                        count: concrete.paths.length,
+                        truncated: preview.length < concrete.paths.length,
+                    },
+                });
+            }
+            for (const nextPattern of input.scope) {
                 for (const existingPattern of existing.scope) {
-                    if (isNegativeScopePattern(existingPattern))
-                        continue;
                     if (patternsOverlap(nextPattern, existingPattern)) {
-                        nextWarnings.push(`▲ scope overlaps registered active contract ${existing.contract}: ${nextPattern} overlaps ${existingPattern}; consider --after ${existing.contract}`);
+                        const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
+                            scopePathEvidence(cwd, [nextPattern], trackedPaths),
+                            scopePathEvidence(cwd, [existingPattern], trackedPaths),
+                        ]);
+                        const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
+                        const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
+                        if (!hasCurrentWitness) {
+                            nextOverlaps.push({
+                                contracts: [input.contractId, existing.contract],
+                                patterns: [nextPattern, existingPattern],
+                                kind: "potential",
+                                paths: { preview: [], count: 0, truncated: false },
+                            });
+                        }
                     }
                 }
             }
         }
-        warnings = nextWarnings;
+        overlaps = nextOverlaps;
         return {
             v: 1,
             kind: "register",
@@ -80,7 +133,7 @@ export async function registerScope(cwd, input) {
     });
     if (!result.ok)
         throw new FlowError("INTERNAL_STATE", `failed to register scope for ${input.contractId}: ${result.reason}`);
-    return { head: result.head, warnings };
+    return { head: result.head, overlaps };
 }
 export async function releaseScope(cwd, input) {
     const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, (entries) => {

package/build/core/renew-session.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
+import { syncDirectory } from "../fs/durability.js";
+import { deleteRecoveryRef } from "../git/refs.js";
+import { KEIYAKU_FILE } from "../keiyaku.js";
+import { renderContractView } from "./contract-view.js";
+import { readLedger } from "./ledger.js";
+import { latestBase } from "./status/drift.js";
+import { findRegisteredContractWorktreePath } from "./worktree-path.js";
+const RENEW_SESSION_DIRECTORY = path.join(".keiyaku", "recovery");
+const RENEW_SESSION_FILE = "renew-session.json";
+function isSha(value) {
+    return typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
+}
+function parseSession(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new FlowError("INTERNAL_STATE", "renew recovery session is malformed");
+    }
+    const value = raw;
+    const keys = Object.keys(value).sort();
+    const expected = ["commission", "newBase", "oldBase", "oldHead", "recoveryRef"];
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+        throw new FlowError("INTERNAL_STATE", "renew recovery session has unknown or missing fields");
+    }
+    if (typeof value.commission !== "string" || !value.commission ||
+        !isSha(value.oldBase) || !isSha(value.oldHead) || !isSha(value.newBase) ||
+        typeof value.recoveryRef !== "string" || !value.recoveryRef) {
+        throw new FlowError("INTERNAL_STATE", "renew recovery session has invalid coordinates");
+    }
+    return value;
+}
+async function sessionPath(cwd, commission) {
+    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
+    return worktree ? path.join(worktree, RENEW_SESSION_DIRECTORY, RENEW_SESSION_FILE) : undefined;
+}
+export async function readRenewRecoverySession(cwd, commission) {
+    const filePath = await sessionPath(cwd, commission);
+    if (!filePath)
+        return null;
+    try {
+        return parseSession(JSON.parse(await fs.readFile(filePath, "utf8")));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        if (error instanceof FlowError)
+            throw error;
+        throw new FlowError("INTERNAL_STATE", `cannot read renew recovery session for ${commission}`, { cause: error });
+    }
+}
+export async function writeRenewRecoverySession(cwd, session) {
+    const filePath = await sessionPath(cwd, session.commission);
+    if (!filePath) {
+        throw new FlowError("INTERNAL_STATE", `renew --resolve requires ${session.commission}'s registered contract worktree`);
+    }
+    const existing = await readRenewRecoverySession(cwd, session.commission);
+    if (existing) {
+        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is already open for ${session.commission}`, {
+            facts: { kind: "renew_session", commission: session.commission, nextAction: "continue-or-abort" },
+        });
+    }
+    const directory = path.dirname(filePath);
+    await fs.mkdir(directory, { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    await fs.writeFile(temporary, `${JSON.stringify(session)}\n`, { encoding: "utf8", flag: "wx" });
+    await fs.rename(temporary, filePath);
+    await syncDirectory(directory);
+    return filePath;
+}
+export async function removeRenewRecoverySession(cwd, commission) {
+    const filePath = await sessionPath(cwd, commission);
+    if (!filePath)
+        return;
+    try {
+        await fs.unlink(filePath);
+        await syncDirectory(path.dirname(filePath));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function publishedRenewForSession(ledger, session) {
+    const tail = ledger.entries.at(-1);
+    if (session.commission !== ledger.contractId ||
+        tail?.kind !== "renew" ||
+        tail.data.oldBase !== session.oldBase ||
+        tail.data.oldHead !== session.oldHead ||
+        tail.data.newBase !== session.newBase ||
+        latestBase(ledger.entries) !== session.newBase)
+        return null;
+    const previous = ledger.entries.at(-2);
+    return {
+        renew: tail,
+        seal: previous?.kind === "seal" && previous.data.sealedBy === "renew" ? previous : null,
+    };
+}
+export async function convergeRenewRecoverySession(cwd, commission) {
+    const session = await readRenewRecoverySession(cwd, commission);
+    if (!session)
+        return { state: "none" };
+    const ledger = await readLedger(cwd, commission);
+    if (!ledger)
+        return { state: "live", session };
+    const published = publishedRenewForSession(ledger, session);
+    if (!published)
+        return { state: "live", session };
+    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
+    if (!worktree) {
+        throw new FlowError("INTERNAL_STATE", `registered contract worktree disappeared for spent renew session ${commission}`);
+    }
+    await fs.writeFile(path.join(worktree, KEIYAKU_FILE), renderContractView({ id: commission, entries: ledger.entries }), "utf8");
+    const recoveryCleanup = await deleteRecoveryRef(cwd, session.recoveryRef, session.oldHead);
+    await removeRenewRecoverySession(cwd, commission);
+    return { state: "spent", session, ledger, ...published, recoveryCleanup };
+}
+export async function assertNoRenewRecoverySession(cwd, commission) {
+    const state = await convergeRenewRecoverySession(cwd, commission);
+    if (state.state === "none")
+        return null;
+    if (state.state === "spent")
+        return state;
+    throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${commission}`, {
+        facts: { kind: "renew_session", commission, nextAction: "continue-or-abort" },
+    });
+}