@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/config/settings/schema.js

@@ -0,0 +1,276 @@
+import { z } from "zod";
+import { CLAUDE_SETTING_SOURCES, } from "../../keiyaku.js";
+const tomlValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(tomlValueSchema),
+    z.record(z.string(), tomlValueSchema),
+]));
+const structuredTomlValueSchema = z.record(z.string(), tomlValueSchema);
+const executableSchema = z.string().superRefine((value, ctx) => {
+    if (value.length === 0 || /\s/.test(value) || value.includes("\"") || value.includes("'")) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "must be a single program name token with no spaces or quotes.",
+        });
+    }
+});
+const nonblankOptionalString = z
+    .string()
+    .refine((value) => value.trim().length > 0, { message: "must not be blank." })
+    .optional();
+const providerCommonFields = {
+    description: nonblankOptionalString,
+};
+const providerEnvSchema = z.record(z.string(), z.string()).optional();
+function refinePiEnvInjection(data, ctx) {
+    if (data.env === undefined)
+        return;
+    if (Object.keys(data.env).length === 0)
+        return;
+    ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["env"],
+        message: "env injection not supported for provider pi",
+    });
+}
+const CODEX_SDK_FORBIDDEN_THREAD_OPTIONS_KEYS = [
+    "model",
+    "modelReasoningEffort",
+    "sandboxMode",
+    "networkAccessEnabled",
+    "webSearchMode",
+    "approvalPolicy",
+    "workingDirectory",
+    "skipGitRepoCheck",
+];
+const FORBIDDEN_CONFIG_KEYS = [
+    "model",
+    "model_reasoning_effort",
+];
+function isConfigKeyForbidden(key) {
+    return FORBIDDEN_CONFIG_KEYS.includes(key);
+}
+const claudeSettingSourceSchema = z.enum(CLAUDE_SETTING_SOURCES);
+const writableRootItemSchema = z.string().superRefine((value, ctx) => {
+    if (value.length === 0) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not be empty." });
+        return;
+    }
+    if (value.startsWith("~")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not begin with tilde." });
+        return;
+    }
+    if (value.includes("\0")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not contain NUL byte." });
+        return;
+    }
+    if (/\$[A-Za-z_]/.test(value) || /\$\{/.test(value)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not contain environment variable references." });
+        return;
+    }
+});
+export const providerInstanceSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("codex-sdk"),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        profile: z.string().optional(),
+        config: structuredTomlValueSchema.optional(),
+        threadOptions: structuredTomlValueSchema.optional(),
+    })
+        .strict()
+        .superRefine((data, ctx) => {
+        if (data.threadOptions) {
+            for (const key of CODEX_SDK_FORBIDDEN_THREAD_OPTIONS_KEYS) {
+                if (key in data.threadOptions) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ["threadOptions", key],
+                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
+                    });
+                }
+            }
+        }
+        if (data.config) {
+            for (const key of Object.keys(data.config)) {
+                if (isConfigKeyForbidden(key)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ["config", key],
+                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
+                    });
+                }
+            }
+        }
+    }),
+    z
+        .object({
+        kind: z.literal("codex-app-server"),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        profile: z.string().optional(),
+        config: structuredTomlValueSchema.optional(),
+        writableRoots: z.array(writableRootItemSchema).optional(),
+        env: providerEnvSchema,
+    })
+        .strict()
+        .superRefine((data, ctx) => {
+        if (data.config) {
+            for (const key of Object.keys(data.config)) {
+                if (isConfigKeyForbidden(key)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ["config", key],
+                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
+                    });
+                }
+            }
+        }
+    }),
+    z
+        .object({
+        kind: z.literal("claude-agent-sdk"),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        settingSources: z.array(claudeSettingSourceSchema).optional(),
+        env: providerEnvSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("opencode-sdk"),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        env: providerEnvSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("pi"),
+        ...providerCommonFields,
+        env: providerEnvSchema,
+    })
+        .strict()
+        .superRefine(refinePiEnvInjection),
+]);
+const PROVIDER_INSTANCE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+export const providerInstanceNameSchema = z
+    .string()
+    .max(64, "must contain at most 64 characters.")
+    .regex(PROVIDER_INSTANCE_NAME_PATTERN, "must match ^[a-z0-9][a-z0-9-]*$.");
+export const BUILTIN_PROVIDER_INSTANCE_CANDIDATES = {
+    "codex-sdk": { name: "codex-sdk", source: "builtin", instance: { kind: "codex-sdk", executable: "codex" } },
+    "codex-app-server": {
+        name: "codex-app-server",
+        source: "builtin",
+        instance: { kind: "codex-app-server", executable: "codex" },
+    },
+    "claude-agent-sdk": {
+        name: "claude-agent-sdk",
+        source: "builtin",
+        instance: { kind: "claude-agent-sdk", executable: "claude", settingSources: ["project"] },
+    },
+    "opencode-sdk": {
+        name: "opencode-sdk",
+        source: "builtin",
+        instance: { kind: "opencode-sdk", executable: "opencode" },
+    },
+    pi: { name: "pi", source: "builtin", instance: { kind: "pi" } },
+};
+const AGENT_NAME_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*$/;
+export const agentNameSchema = z
+    .string()
+    .min(1, "must not be empty.")
+    .regex(AGENT_NAME_PATTERN, "must contain only alphanumeric characters, dots, and hyphens, and must not start or end with a separator.");
+function optionalTrimmedString() {
+    return z.string().transform((value) => {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }).optional();
+}
+function requiredTrimmedString(message) {
+    return z.string().transform((value, ctx) => {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message,
+            });
+            return z.NEVER;
+        }
+        return trimmed;
+    });
+}
+const gateCommandSchema = z
+    .object({
+    label: requiredTrimmedString("must not be empty."),
+    command: requiredTrimmedString("must not be empty.").superRefine((value, ctx) => {
+        if (/\s/.test(value) || value.includes("\"") || value.includes("'")) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "must be a single program name token with no spaces or quotes.",
+            });
+        }
+    }),
+    args: z.array(z.string()).optional(),
+})
+    .strict()
+    .transform((value) => ({
+    ...value,
+    args: value.args ?? [],
+}));
+const gateSchema = z
+    .object({
+    commands: z.array(gateCommandSchema).optional(),
+})
+    .strict();
+const WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS = 300_000;
+const WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS = 1;
+const WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS = 3_600_000;
+export const worktreeBootstrapSchema = z
+    .object({
+    command: z
+        .array(z.string())
+        .min(1, "command must be a nonempty argv array.")
+        .superRefine((items, ctx) => {
+        items.forEach((item, index) => {
+            if (item.trim().length === 0) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [index],
+                    message: "command items must be nonempty after trimming.",
+                });
+            }
+        });
+    }),
+    timeoutMs: z
+        .number()
+        .int("timeoutMs must be an integer.")
+        .min(WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS, `timeoutMs must be >= ${WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS}.`)
+        .max(WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS, `timeoutMs must be <= ${WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS}.`)
+        .optional(),
+})
+    .strict()
+    .transform((value) => ({
+    command: value.command,
+    timeoutMs: value.timeoutMs ?? WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS,
+}));
+const settingsSchema = z
+    .object({
+    default: agentNameSchema.optional(),
+    reviewer: agentNameSchema.optional(),
+    gate: gateSchema.optional(),
+    defaultBranch: optionalTrimmedString(),
+    worktreeBootstrap: worktreeBootstrapSchema.optional(),
+})
+    .strict();
+export const knobSchemas = {
+    default: agentNameSchema,
+    reviewer: agentNameSchema,
+    gate: gateSchema,
+    defaultBranch: optionalTrimmedString(),
+    worktreeBootstrap: worktreeBootstrapSchema,
+};

package/build/core/addressing.js

@@ -3,7 +3,7 @@ import { FlowError } from "../flow-error.js";
 import { listContractIds, readLedger } from "./ledger.js";
 import { isResponseArtifactId } from "./response-artifact-id.js";
 import { stableRepoRoot } from "./worktree-path.js";
-import { deriveContractState, isTerminalState, } from "./status.js";
+import { deriveContractState, isTerminalState, } from "./status/lifecycle.js";
 function normalizeAddressQuery(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
     if (!value.trim()) {

package/build/core/amend.js

@@ -4,10 +4,10 @@ import { FlowError } from "../flow-error.js";
 import { getCurrentBranch, isGitRepo } from "../git/branches.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { renderContractView } from "./render.js";
-import { deriveContractState, isTerminalState } from "./status.js";
+import { renderContractView } from "./contract-view.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
-import { resolveDefaultBranch } from "./status.js";
+import { resolveDefaultBranch } from "./status/drift.js";
 import { assertCleanWorkingTree } from "./arc.js";
 import { normalizeScopePattern } from "./scope.js";
 function requireAmendment(value) {

package/build/core/arc.js

@@ -9,9 +9,10 @@ import { normalizeInlineTitle } from "./markdown/titles.js";
 import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle, } from "./command-io.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { renderContractView } from "./render.js";
-import { findOpenArc, getMaxArc, sealOpenArc } from "./seal.js";
-import { deriveContractState, isTerminalState, resolveDefaultBranch } from "./status.js";
+import { renderContractView } from "./contract-view.js";
+import { findOpenArc, getMaxArc, sealCurrentArc } from "./seal.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { resolveDefaultBranch } from "./status/drift.js";
 import { persistResponseHistory } from "./transcripts.js";
 const DIRTY_WORKTREE_LIST_LIMIT = 10;
 const KEIYAKU_ARTIFACT_DIR_PREFIX = ".keiyaku/";
@@ -111,7 +112,7 @@ export async function openArc(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertArcOpenable(input.contractId, ledger.entries);
-    const sealed = await sealOpenArc({
+    const sealed = await sealCurrentArc({
         cwd: input.cwd,
         renderCwd: input.cwd,
         contractId: input.contractId,

package/build/core/bind-workspace.js

@@ -0,0 +1,123 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { KEIYAKU_FILE } from "../keiyaku.js";
+import { createGit, wrapGitError } from "../git/core.js";
+import { listContractIds, readLedger } from "./ledger.js";
+import { CONTRACT_PLACES } from "./places.js";
+import { renderContractView } from "./contract-view.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { contractWorktreePathFromBind, findBindEntry } from "./worktree-path.js";
+export async function createContractBranch(cwd, branch, base) {
+    const git = createGit(cwd);
+    try {
+        await git.raw(["branch", branch, base]);
+    }
+    catch (error) {
+        throw wrapGitError(`branch ${branch} ${base}`, error, cwd);
+    }
+}
+export async function defaultCreateWorktree(input) {
+    void input.id;
+    void input.base;
+    const git = createGit(input.cwd);
+    try {
+        await git.raw(["worktree", "add", input.worktreePath, input.branch]);
+    }
+    catch (error) {
+        throw wrapGitError(`worktree add ${input.worktreePath} ${input.branch}`, error, input.cwd);
+    }
+}
+export async function resolveTreeRoot(cwd, workspace, contractId, bind) {
+    const repoRoot = await fs.realpath(cwd);
+    if (workspace === "here")
+        return repoRoot;
+    return await contractWorktreePathFromBind(repoRoot, contractId, bind);
+}
+async function removeWorktree(cwd, worktreePath) {
+    const git = createGit(cwd);
+    try {
+        await git.raw(["worktree", "remove", "--force", worktreePath]);
+    }
+    catch (error) {
+        throw wrapGitError(`worktree remove ${worktreePath}`, error, cwd);
+    }
+}
+async function deleteBranch(cwd, branch) {
+    const git = createGit(cwd);
+    try {
+        await git.raw(["branch", "-D", branch]);
+    }
+    catch (error) {
+        throw wrapGitError(`branch -D ${branch}`, error, cwd);
+    }
+}
+/** Best-effort cleanup of resources created by the current bind attempt. */
+export async function cleanupCreatedBindResources(cwd, resources) {
+    const failures = [];
+    if (resources.keiyakuPath) {
+        try {
+            await fs.rm(resources.keiyakuPath, { force: true });
+        }
+        catch (error) {
+            failures.push(`delete ${resources.keiyakuPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (resources.worktreePath) {
+        try {
+            await removeWorktree(cwd, resources.worktreePath);
+        }
+        catch (error) {
+            failures.push(`remove worktree: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (resources.branch) {
+        try {
+            await deleteBranch(cwd, resources.branch);
+        }
+        catch (error) {
+            failures.push(`delete branch: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return failures;
+}
+export async function materializeContractView(input) {
+    const keiyakuPath = path.join(input.targetRoot, KEIYAKU_FILE);
+    await fs.mkdir(path.dirname(keiyakuPath), { recursive: true });
+    await fs.writeFile(keiyakuPath, renderContractView({ id: input.id, entries: input.entries }), "utf8");
+    return keiyakuPath;
+}
+async function occupiedWorktreePlaces(cwd) {
+    const occupied = new Set();
+    for (const id of await listContractIds(cwd)) {
+        const ledger = await readLedger(cwd, id);
+        if (!ledger || isTerminalState(deriveContractState(ledger.entries)))
+            continue;
+        const place = findBindEntry(ledger.entries)?.data.place;
+        if (place)
+            occupied.add(place);
+    }
+    return occupied;
+}
+function randomIndex(randomBytes, size) {
+    let value = 0;
+    for (const byte of randomBytes) {
+        value = (value * 256 + byte) % size;
+    }
+    return value;
+}
+function nextGenerationPlace(base, occupied) {
+    for (let generation = 2;; generation += 1) {
+        const candidate = `${base}${generation}`;
+        if (!occupied.has(candidate))
+            return candidate;
+    }
+}
+export async function allocateWorktreePlace(cwd, randomBytes) {
+    const occupied = await occupiedWorktreePlaces(cwd);
+    const candidates = CONTRACT_PLACES.filter((place) => !occupied.has(place));
+    if (candidates.length > 0) {
+        return candidates[randomIndex(randomBytes, candidates.length)];
+    }
+    const base = CONTRACT_PLACES[randomIndex(randomBytes, CONTRACT_PLACES.length)];
+    return nextGenerationPlace(base, occupied);
+}