@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/cli/coordinates.js

@@ -0,0 +1,120 @@
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { NoGitWorldError, Repo } from "../index.js";
+import { World, WorldError } from "../world.js";
+import { CliUsageError } from "./parse.js";
+async function canonicalInvocationCwd(input) {
+    try {
+        return await realpath(input);
+    }
+    catch {
+        throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
+    }
+}
+async function discoverRepoAt(coordinate) {
+    try {
+        return { kind: "present", repo: await Repo.at({ path: coordinate }) };
+    }
+    catch (error) {
+        if (error instanceof NoGitWorldError)
+            return { kind: "absent", error };
+        throw error;
+    }
+}
+function repoPolicy(command) {
+    switch (command.command) {
+        case "bind":
+        case "amend":
+        case "deliver":
+        case "review":
+        case "arc":
+        case "abandon":
+        case "audit":
+        case "reconcile":
+        case "show":
+        case "region":
+            return { use: "required", acceptsExplicit: true };
+        case "ls":
+            return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
+        case "status":
+        case "tell":
+        case "history":
+            return { use: "optional", acceptsExplicit: false };
+        case "fork":
+            return { use: "optional", acceptsExplicit: true };
+        case "wait":
+        case "kill": {
+            const contractSelector = command.akuma.some((selector) => selector.startsWith("kei/"));
+            return { use: contractSelector ? "required" : "optional", acceptsExplicit: contractSelector };
+        }
+        case "call":
+            return {
+                use: command.contract === undefined ? "none" : "required",
+                acceptsExplicit: command.contract !== undefined,
+            };
+        case "settings":
+        case "task":
+        case "install":
+            return { use: "none", acceptsExplicit: false };
+    }
+}
+function refuseUnusedRepo(command) {
+    if (command.command === "call")
+        throw new CliUsageError("--repo has no consumer without --contract");
+    throw new CliUsageError(`--repo has no consumer for ${command.command}`);
+}
+export function assertExplicitRepoUse(command, repo) {
+    if (repo !== undefined && !repoPolicy(command).acceptsExplicit)
+        refuseUnusedRepo(command);
+}
+function repoFor(use, discovery) {
+    if (use === "none")
+        return undefined;
+    if (discovery.kind === "present")
+        return discovery.repo;
+    if (use === "required")
+        throw discovery.error;
+    return undefined;
+}
+async function resolveWorld(cwd, repo) {
+    try {
+        const resolution = await World.resolve({ cwd, ...(repo === undefined ? {} : { repositoryRoot: repo.root }) });
+        return {
+            root: resolution.root,
+            candidate: resolution.candidate,
+            async establish() {
+                try {
+                    return await resolution.establish();
+                }
+                catch (error) {
+                    if (error instanceof WorldError)
+                        throw new CliUsageError(error.message);
+                    throw error;
+                }
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof WorldError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+export async function resolveCliCoordinates(input) {
+    const processCwd = resolve(input.processCwd ?? ".");
+    const cwd = await canonicalInvocationCwd(resolve(processCwd, input.cwd ?? "."));
+    const invocationRepo = await discoverRepoAt(cwd);
+    const selectedRepo = input.repo === undefined
+        ? invocationRepo
+        : await discoverRepoAt(resolve(cwd, input.repo));
+    const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
+    const repo = repoFor(repoPolicy(input.command).use, selectedRepo);
+    const world = await resolveWorld(cwd, worldRepo);
+    return {
+        cwd,
+        ...(repo === undefined ? {} : { repo }),
+        world: world.root,
+        candidateWorld: world.candidate,
+        establishWorld: world.establish,
+    };
+}

package/build/src/cli/draft.d.ts

@@ -0,0 +1,8 @@
+import type { WorldRoot } from "../world.js";
+import type { BindDraftReceipt } from "./result.js";
+export declare class BindDraftError extends Error {
+    readonly original: unknown;
+    readonly draft: BindDraftReceipt;
+    constructor(original: unknown, draft: BindDraftReceipt);
+}
+export declare function preserveBindDraft(world: WorldRoot, markdown: string, now?: number): Promise<BindDraftReceipt>;

package/build/src/cli/draft.js

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, readdirSync, unlinkSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { repairDerivedFile, replaceFileDurably } from "../coordination/durable-file.js";
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1_000;
+const DRAFT_NAME = /^bind-[0-9a-f]{64}\.md$/u;
+export class BindDraftError extends Error {
+    original;
+    draft;
+    constructor(original, draft) {
+        super(original instanceof Error ? original.message : String(original));
+        this.name = "BindDraftError";
+        this.original = original;
+        this.draft = draft;
+    }
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sweep(directory, now) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (!entry.isFile() || !DRAFT_NAME.test(entry.name))
+            continue;
+        const path = join(directory, entry.name);
+        try {
+            if (now - lstatSync(path).mtimeMs > RETENTION_MS)
+                unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+export async function preserveBindDraft(world, markdown, now = Date.now()) {
+    const digest = createHash("sha256").update(markdown, "utf8").digest("hex");
+    const name = `bind-${digest}.md`;
+    const relativePath = `.keiyaku/draft/${name}`;
+    const directory = join(world, ".keiyaku", "draft");
+    const path = join(directory, name);
+    const warnings = [];
+    try {
+        mkdirSync(directory, { recursive: true });
+    }
+    catch (error) {
+        return { warning: `bind draft could not be preserved: ${diagnostic(error)}` };
+    }
+    try {
+        await repairDerivedFile(join(directory, ".gitignore"), "*\n");
+    }
+    catch (error) {
+        warnings.push(`bind draft ignore could not be maintained: ${diagnostic(error)}`);
+    }
+    try {
+        let equal = false;
+        try {
+            const status = lstatSync(path);
+            equal = status.isFile() && !status.isSymbolicLink() && readFileSync(path).equals(Buffer.from(markdown));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (equal) {
+            try {
+                const touched = new Date(now);
+                utimesSync(path, touched, touched);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                await replaceFileDurably(path, markdown);
+            }
+        }
+        else {
+            await replaceFileDurably(path, markdown);
+        }
+        if (!readFileSync(path).equals(Buffer.from(markdown))) {
+            throw new Error(`bind draft bytes do not match their content address: ${relativePath}`);
+        }
+    }
+    catch (error) {
+        warnings.push(`bind draft could not be preserved: ${diagnostic(error)}`);
+        return { warning: warnings.join("; ") };
+    }
+    try {
+        sweep(directory, now);
+    }
+    catch (error) {
+        warnings.push(`bind draft sweep failed: ${diagnostic(error)}`);
+    }
+    return {
+        path: relativePath,
+        ...(warnings.length === 0 ? {} : { warning: warnings.join("; ") }),
+    };
+}

package/build/src/cli/invoke.d.ts

@@ -1,17 +1,23 @@
-import { type Settings } from "../index.js";
+import { type ActorId, type ContractId, type Settings } from "../index.js";
 import { type AkumaInvocationResult } from "./commands/akuma-invoke.js";
 import { type InstallInvocationResult } from "./commands/install.js";
 import { type TaskInvocationResult } from "./commands/task-invoke.js";
 import { type ParsedExecution } from "./parse.js";
 import type { InvocationResult } from "./result.js";
-export type { AcceptedFact, DiffUnavailable, InvocationResult, Lag } from "./result.js";
+export type { AcceptedFact, InvocationResult, Lag } from "./result.js";
 type InvokeRuntime = Readonly<{
     cwd?: string;
     environment?: NodeJS.ProcessEnv;
-    readStdin?: () => string;
+    readStdin?: () => Promise<string>;
+    actor?: ActorId;
 }>;
 export type SettingsInvocationResult = Readonly<{
     kind: "settings";
     value: Settings;
 }>;
+export type GuidanceInvocationResult = Readonly<{
+    kind: "guidance";
+    contract: ContractId;
+    guidance: string;
+}>;
 export declare function invoke(invocation: ParsedExecution, runtime?: InvokeRuntime): Promise<InvocationResult | TaskInvocationResult | AkumaInvocationResult | SettingsInvocationResult | InstallInvocationResult>;