@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/config/settings.js

@@ -1,533 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { z } from "zod";
-import { isErrnoException } from "../errno.js";
-import { FlowError } from "../flow-error.js";
-import { CLAUDE_SETTING_SOURCES, SETTINGS_FILE, } from "../keiyaku.js";
-import { getKeiyakuHome } from "./env.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 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(),
-    })
-        .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(),
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("opencode-sdk"),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-    })
-        .strict(),
-    z
-        .object({
-        kind: z.literal("pi"),
-        ...providerCommonFields,
-    })
-        .strict(),
-]);
-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 KNOWN_SETTINGS_KNOBS = ["default", "reviewer", "gate", "defaultBranch", "worktreeBootstrap"];
-const KNOWN_SETTINGS_ROOT_KEYS = [...KNOWN_SETTINGS_KNOBS, "providers"];
-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();
-const knobSchemas = {
-    default: agentNameSchema,
-    reviewer: agentNameSchema,
-    gate: gateSchema,
-    defaultBranch: optionalTrimmedString(),
-    worktreeBootstrap: worktreeBootstrapSchema,
-};
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepMerge(base, override) {
-    if (!isPlainObject(base) || !isPlainObject(override)) {
-        return override;
-    }
-    const merged = { ...base };
-    for (const [key, value] of Object.entries(override)) {
-        merged[key] = key in merged ? deepMerge(merged[key], value) : value;
-    }
-    return merged;
-}
-function formatZodIssues(error) {
-    return error.issues
-        .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
-        .join("; ");
-}
-async function readSettingsSource(filePath) {
-    try {
-        const text = await fs.readFile(filePath, "utf-8");
-        try {
-            return { found: true, raw: JSON.parse(text) };
-        }
-        catch (error) {
-            const reason = error instanceof SyntaxError
-                ? `invalid JSON: ${error.message}`
-                : error instanceof Error
-                    ? error.message
-                    : String(error);
-            return { found: true, raw: undefined, parseError: reason };
-        }
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return { found: false };
-        }
-        const reason = error instanceof Error ? error.message : String(error);
-        return { found: true, raw: undefined, parseError: reason };
-    }
-}
-function builtinProviderInstanceCatalog() {
-    return { selected: { ...BUILTIN_PROVIDER_INSTANCE_CANDIDATES }, shadows: [] };
-}
-function formatProviderInstanceIssues(name, error) {
-    return error.issues
-        .map((issue) => {
-        const suffix = issue.path.length === 0 ? "" : `.${issue.path.join(".")}`;
-        return `providers.${name}${suffix}: ${issue.message}`;
-    })
-        .join("; ");
-}
-function collectProviderCandidates(source, rawProviders) {
-    if (!isPlainObject(rawProviders)) {
-        return {
-            candidates: [],
-            disease: { source: source === "project" ? "local" : "global", knob: "providers", reason: "providers: must be a JSON object" },
-        };
-    }
-    const candidates = [];
-    for (const [name, rawInstance] of Object.entries(rawProviders)) {
-        const nameResult = providerInstanceNameSchema.safeParse(name);
-        if (!nameResult.success) {
-            candidates.push({
-                name,
-                source,
-                reason: formatProviderInstanceIssues(name, nameResult.error),
-            });
-            continue;
-        }
-        const instanceResult = providerInstanceSchema.safeParse(rawInstance);
-        if (!instanceResult.success) {
-            candidates.push({
-                name,
-                source,
-                reason: formatProviderInstanceIssues(name, instanceResult.error),
-            });
-            continue;
-        }
-        const instance = instanceResult.data;
-        if (instance.kind === "codex-app-server" && instance.writableRoots !== undefined && source === "global") {
-            let relativeIndex;
-            for (let i = 0; i < instance.writableRoots.length; i++) {
-                if (!path.posix.isAbsolute(instance.writableRoots[i])) {
-                    relativeIndex = i;
-                    break;
-                }
-            }
-            if (relativeIndex !== undefined) {
-                candidates.push({
-                    name,
-                    source,
-                    reason: `providers.${name}.writableRoots.${relativeIndex}: writableRoots item must be an absolute path for global provider instances`,
-                });
-                continue;
-            }
-        }
-        candidates.push({ name, source, instance: instanceResult.data });
-    }
-    return { candidates };
-}
-function mergeProviderCandidates(catalog, candidates) {
-    const selected = { ...catalog.selected };
-    const shadows = [...catalog.shadows];
-    for (const candidate of candidates) {
-        const prior = selected[candidate.name];
-        if (prior !== undefined) {
-            shadows.push({ name: candidate.name, source: prior.source, shadowedBy: candidate.source });
-        }
-        selected[candidate.name] = candidate;
-    }
-    return { selected, shadows };
-}
-function collectSourceDiseases(source, providerSource, read) {
-    if (!read.found) {
-        return { partial: {}, diseases: [], providerCandidates: [] };
-    }
-    if (read.parseError !== undefined) {
-        return {
-            partial: {},
-            diseases: [{ source, reason: `settings root is unreadable (${read.parseError})` }],
-            providerCandidates: [],
-        };
-    }
-    if (!isPlainObject(read.raw)) {
-        return {
-            partial: {},
-            diseases: [{ source, reason: "settings root must be a JSON object" }],
-            providerCandidates: [],
-        };
-    }
-    const diseases = [];
-    const partial = {};
-    let providerCandidates = [];
-    const raw = read.raw;
-    for (const key of Object.keys(raw)) {
-        if (!KNOWN_SETTINGS_ROOT_KEYS.includes(key)) {
-            diseases.push({
-                source,
-                knob: key,
-                reason: key === "agents"
-                    ? 'settings key "agents" has been removed; define profiles in .keiyaku/akuma/<name>.md'
-                    : `unknown settings key "${key}"`,
-            });
-        }
-    }
-    if ("providers" in raw) {
-        const collectedProviders = collectProviderCandidates(providerSource, raw.providers);
-        providerCandidates = collectedProviders.candidates;
-        if (collectedProviders.disease !== undefined)
-            diseases.push(collectedProviders.disease);
-    }
-    for (const knob of KNOWN_SETTINGS_KNOBS) {
-        if (!(knob in raw))
-            continue;
-        // worktreeBootstrap is project-layer only. Global/user presence is a named
-        // disease and never contributes execution authority.
-        if (knob === "worktreeBootstrap" && source === "global") {
-            diseases.push({
-                source,
-                knob,
-                reason: "worktreeBootstrap is project-only and never supplies a value from global settings",
-            });
-            continue;
-        }
-        const schema = knobSchemas[knob];
-        const result = schema.safeParse(raw[knob]);
-        if (!result.success) {
-            diseases.push({
-                source,
-                knob,
-                reason: formatZodIssues(result.error),
-            });
-            continue;
-        }
-        if (result.data === undefined)
-            continue;
-        partial[knob] = result.data;
-    }
-    return { partial, diseases, providerCandidates };
-}
-function mergeSettingsKnobs(base, override) {
-    // worktreeBootstrap is whole-value project authority; never field-merge it.
-    const { worktreeBootstrap: baseBootstrap, ...baseRest } = base;
-    const { worktreeBootstrap: overrideBootstrap, ...overrideRest } = override;
-    const mergedRaw = deepMerge(baseRest, overrideRest);
-    if (!isPlainObject(mergedRaw)) {
-        return overrideBootstrap !== undefined
-            ? { ...override, worktreeBootstrap: overrideBootstrap }
-            : { ...override };
-    }
-    const merged = {};
-    for (const knob of KNOWN_SETTINGS_KNOBS) {
-        if (knob === "worktreeBootstrap")
-            continue;
-        if (knob in mergedRaw) {
-            merged[knob] = mergedRaw[knob];
-        }
-    }
-    const bootstrap = overrideBootstrap ?? baseBootstrap;
-    if (bootstrap !== undefined)
-        merged.worktreeBootstrap = bootstrap;
-    return merged;
-}
-export function findSettingsDiseasesForKnob(diseases, knob) {
-    return diseases.filter((disease) => disease.knob === knob);
-}
-export function formatSettingsDiseases(diseases) {
-    return diseases.map((disease) => {
-        const where = disease.knob ? `${disease.source}:${disease.knob}` : `${disease.source}:(root)`;
-        return `${where}: ${disease.reason}`;
-    });
-}
-/**
- * Reject when a named knob is diseased and was not admitted into knobs.
- * A healthy value from another source still wins; only failed-and-unset knobs reject.
- */
-export function assertSettingsKnobUsable(loaded, knob) {
-    const knobs = loaded.knobs;
-    if (knobs !== null && knobs[knob] !== undefined)
-        return;
-    const hits = findSettingsDiseasesForKnob(loaded.diseases, knob);
-    if (hits.length === 0)
-        return;
-    throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (diseased knob '${knob}').`, {
-        hints: formatSettingsDiseases(hits),
-    });
-}
-export async function loadKeiyakuSettings(cwd) {
-    const localSettingsPath = path.join(cwd, SETTINGS_FILE);
-    const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
-    let globalRead;
-    let localRead;
-    try {
-        [globalRead, localRead] = await Promise.all([
-            readSettingsSource(globalSettingsPath),
-            readSettingsSource(localSettingsPath),
-        ]);
-    }
-    catch (error) {
-        // loadKeiyakuSettings never throws; unexpected I/O becomes a local root disease.
-        const reason = error instanceof Error ? error.message : String(error);
-        return {
-            knobs: null,
-            diseases: [{ source: "local", reason: `settings root is unreadable (${reason})` }],
-            providerInstances: builtinProviderInstanceCatalog(),
-        };
-    }
-    const globalCollected = collectSourceDiseases("global", "global", globalRead);
-    const localCollected = collectSourceDiseases("local", "project", localRead);
-    const diseases = [...globalCollected.diseases, ...localCollected.diseases];
-    let providerInstances = builtinProviderInstanceCatalog();
-    providerInstances = mergeProviderCandidates(providerInstances, globalCollected.providerCandidates);
-    providerInstances = mergeProviderCandidates(providerInstances, localCollected.providerCandidates);
-    let knobs = null;
-    if (globalRead.found || localRead.found) {
-        knobs = mergeSettingsKnobs(globalCollected.partial, localCollected.partial);
-    }
-    // Empty object still means "settings files were present"; callers treat null as absent files.
-    return { knobs, diseases, providerInstances };
-}
-export function resolveDefaultAgentName(settings) {
-    return settings?.default ?? "akuma-codex";
-}
-export function resolveReviewerAgentName(settings) {
-    return settings?.reviewer ?? resolveDefaultAgentName(settings);
-}