@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/config/env.js

@@ -1,304 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { z } from "zod";
-import { isErrnoException } from "../errno.js";
-import { ENV_KEYS, getEnvDefaultValue } from "./env-keys.js";
-import { configureResponseArtifactCatalog } from "../core/response-artifact-catalog.js";
-import { createSqliteResponseArtifactCatalog } from "../core/response-artifact-catalog-sqlite.js";
-function readEnvHome(env = process.env) {
-    const value = env.KEIYAKU_HOME?.trim();
-    return value && value.length > 0 ? value : undefined;
-}
-export function getKeiyakuHome(env = process.env) {
-    return readEnvHome(env) ?? path.join(os.homedir(), ".keiyaku");
-}
-const DOTENV_FILE = ".env";
-function decodeQuotedValue(raw) {
-    if (raw.length < 2)
-        return raw;
-    const quote = raw[0];
-    if ((quote !== "\"" && quote !== "'") || raw[raw.length - 1] !== quote)
-        return raw;
-    const inner = raw.slice(1, -1);
-    if (quote === "'")
-        return inner;
-    return inner.replace(/\\([\\nrt"])/g, (_match, ch) => {
-        if (ch === "n")
-            return "\n";
-        if (ch === "r")
-            return "\r";
-        if (ch === "t")
-            return "\t";
-        if (ch === "\"")
-            return "\"";
-        return "\\";
-    });
-}
-function parseDotenv(text) {
-    const env = {};
-    for (const rawLine of text.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith("#"))
-            continue;
-        const cleaned = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
-        const eq = cleaned.indexOf("=");
-        if (eq <= 0)
-            continue;
-        const key = cleaned.slice(0, eq).trim();
-        const value = cleaned.slice(eq + 1).trim();
-        if (!key)
-            continue;
-        env[key] = decodeQuotedValue(value);
-    }
-    return env;
-}
-function readOptionalDotenv(filePath) {
-    try {
-        return parseDotenv(fs.readFileSync(filePath, "utf8"));
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return {};
-        }
-        throw error;
-    }
-}
-function loadKeiyakuDotenv(cwd = process.cwd()) {
-    return Object.freeze({
-        ...readOptionalDotenv(path.join(getKeiyakuHome(), DOTENV_FILE)),
-        ...readOptionalDotenv(path.join(cwd, ".keiyaku", DOTENV_FILE)),
-    });
-}
-function parsePositiveInt(value, key) {
-    const trimmed = value.trim();
-    const parsed = Number.parseInt(trimmed, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`${key} must be a positive integer, received '${value}'.`);
-    }
-    return parsed;
-}
-function positiveIntEnv(key) {
-    return z
-        .string()
-        .default(getEnvDefaultValue(key))
-        .transform((value, ctx) => {
-        try {
-            return parsePositiveInt(value, key);
-        }
-        catch (error) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: error instanceof Error ? error.message : `Invalid ${key}`,
-            });
-            return z.NEVER;
-        }
-    });
-}
-function strictPositiveIntEnv(key) {
-    return z
-        .string()
-        .default(getEnvDefaultValue(key))
-        .transform((value, ctx) => {
-        const trimmed = value.trim();
-        const parsed = Number(trimmed);
-        if (/^\d+$/.test(trimmed) && Number.isSafeInteger(parsed) && parsed > 0)
-            return parsed;
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `${key} must be a positive integer, received '${value}'.`,
-        });
-        return z.NEVER;
-    });
-}
-function parseNonNegativeInt(value, key) {
-    const trimmed = value.trim();
-    const parsed = Number.parseInt(trimmed, 10);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new Error(`${key} must be a non-negative integer, received '${value}'.`);
-    }
-    return parsed;
-}
-function nonNegativeIntEnv(key) {
-    return z
-        .string()
-        .default(getEnvDefaultValue(key))
-        .transform((value, ctx) => {
-        try {
-            return parseNonNegativeInt(value, key);
-        }
-        catch (error) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: error instanceof Error ? error.message : `Invalid ${key}`,
-            });
-            return z.NEVER;
-        }
-    });
-}
-function booleanFlagEnv(key) {
-    return z
-        .string()
-        .default(getEnvDefaultValue(key))
-        .transform((value, ctx) => {
-        const normalized = value.trim().toLowerCase();
-        if (["1", "true", "yes", "on"].includes(normalized))
-            return true;
-        if (["0", "false", "no", "off"].includes(normalized))
-            return false;
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `${key} must be one of 1/0, true/false, yes/no, on/off. Received '${value}'.`,
-        });
-        return z.NEVER;
-    });
-}
-const subagentSchema = z.object({
-    nameOverride: z.string().default(getEnvDefaultValue(ENV_KEYS.AGENT_OVERRIDE)).transform((value) => value.trim()),
-    disableSpawn: booleanFlagEnv(ENV_KEYS.DISABLE_SUBAGENT_SPAWN),
-    execIdleTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS),
-    execMaxDurationMs: nonNegativeIntEnv(ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS),
-});
-const codexSchema = z.object({
-    execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS),
-});
-const claudeSchema = z.object({
-    execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS),
-});
-const opencodeSchema = z.object({
-    execMaxCaptureChars: positiveIntEnv(ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS),
-});
-const debugSchema = z.object({
-    logPath: z.string().default(getEnvDefaultValue(ENV_KEYS.DEBUG_LOG_PATH)).transform((value) => value.trim()),
-    testSilent: booleanFlagEnv(ENV_KEYS.TEST_SILENT),
-});
-const gitSchema = z.object({
-    timeoutMs: positiveIntEnv(ENV_KEYS.GIT_TIMEOUT_MS),
-    noVerify: booleanFlagEnv(ENV_KEYS.GIT_NO_VERIFY),
-    noGpgSign: booleanFlagEnv(ENV_KEYS.GIT_NO_GPG_SIGN),
-});
-const reviewSchema = z.object({
-    enabled: booleanFlagEnv(ENV_KEYS.REVIEW_ENABLED),
-    minLines: nonNegativeIntEnv(ENV_KEYS.REVIEW_MIN_LINES),
-    resumeSession: booleanFlagEnv(ENV_KEYS.REVIEW_RESUME_SESSION),
-});
-const amendmentWarningSchema = z.object({
-    threshold: strictPositiveIntEnv(ENV_KEYS.AMENDMENT_WARNING_THRESHOLD),
-});
-const terminalSchema = z.object({
-    noColor: z.string().optional(),
-    forceColor: z.string().optional(),
-    term: z.string().optional(),
-});
-const envSchema = z
-    .object({
-    [ENV_KEYS.AGENT_OVERRIDE]: z.string().optional(),
-    [ENV_KEYS.DISABLE_SUBAGENT_SPAWN]: z.string().optional(),
-    [ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS]: z.string().optional(),
-    [ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS]: z.string().optional(),
-    [ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
-    [ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
-    [ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
-    [ENV_KEYS.DEBUG_LOG_PATH]: z.string().optional(),
-    [ENV_KEYS.TEST_SILENT]: z.string().optional(),
-    [ENV_KEYS.GIT_TIMEOUT_MS]: z.string().optional(),
-    [ENV_KEYS.GIT_NO_VERIFY]: z.string().optional(),
-    [ENV_KEYS.GIT_NO_GPG_SIGN]: z.string().optional(),
-    [ENV_KEYS.REVIEW_ENABLED]: z.string().optional(),
-    [ENV_KEYS.REVIEW_MIN_LINES]: z.string().optional(),
-    [ENV_KEYS.REVIEW_RESUME_SESSION]: z.string().optional(),
-    [ENV_KEYS.AMENDMENT_WARNING_THRESHOLD]: z.string().optional(),
-    NO_COLOR: z.string().optional(),
-    FORCE_COLOR: z.string().optional(),
-    TERM: z.string().optional(),
-})
-    .transform((rawEnv) => ({
-    subagent: subagentSchema.parse({
-        nameOverride: rawEnv[ENV_KEYS.AGENT_OVERRIDE],
-        disableSpawn: rawEnv[ENV_KEYS.DISABLE_SUBAGENT_SPAWN],
-        execIdleTimeoutMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS],
-        execMaxDurationMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS],
-    }),
-    codex: codexSchema.parse({
-        execMaxCaptureChars: rawEnv[ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS],
-    }),
-    claude: claudeSchema.parse({
-        execMaxCaptureChars: rawEnv[ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS],
-    }),
-    opencode: opencodeSchema.parse({
-        execMaxCaptureChars: rawEnv[ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS],
-    }),
-    debug: debugSchema.parse({
-        logPath: rawEnv[ENV_KEYS.DEBUG_LOG_PATH],
-        testSilent: rawEnv[ENV_KEYS.TEST_SILENT],
-    }),
-    git: gitSchema.parse({
-        timeoutMs: rawEnv[ENV_KEYS.GIT_TIMEOUT_MS],
-        noVerify: rawEnv[ENV_KEYS.GIT_NO_VERIFY],
-        noGpgSign: rawEnv[ENV_KEYS.GIT_NO_GPG_SIGN],
-    }),
-    review: reviewSchema.parse({
-        enabled: rawEnv[ENV_KEYS.REVIEW_ENABLED],
-        minLines: rawEnv[ENV_KEYS.REVIEW_MIN_LINES],
-        resumeSession: rawEnv[ENV_KEYS.REVIEW_RESUME_SESSION],
-    }),
-    amendmentWarning: amendmentWarningSchema.parse({
-        threshold: rawEnv[ENV_KEYS.AMENDMENT_WARNING_THRESHOLD],
-    }),
-    terminal: terminalSchema.parse({
-        noColor: rawEnv.NO_COLOR,
-        forceColor: rawEnv.FORCE_COLOR,
-        term: rawEnv.TERM,
-    }),
-}));
-function deepFreeze(value) {
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            if (item && typeof item === "object") {
-                deepFreeze(item);
-            }
-        }
-    }
-    else if (value && typeof value === "object") {
-        for (const child of Object.values(value)) {
-            if (child && typeof child === "object") {
-                deepFreeze(child);
-            }
-        }
-    }
-    return Object.freeze(value);
-}
-function snapshotEnv(env) {
-    const snapshot = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (typeof value === "string") {
-            snapshot[key] = value;
-        }
-    }
-    return Object.freeze(snapshot);
-}
-let activeConfig;
-export function initializeConfig(env = process.env, cwd = process.cwd()) {
-    const dotenvEnv = loadKeiyakuDotenv(cwd);
-    // `.keiyaku/.env` provides local defaults; real process env always wins.
-    const parsed = envSchema.parse({ ...dotenvEnv, ...env });
-    const frozen = deepFreeze(parsed);
-    const runtimeConfig = Object.freeze({
-        ...frozen,
-        runtimeEnv: snapshotEnv({ ...dotenvEnv, ...env }),
-    });
-    activeConfig = runtimeConfig;
-    const homeEnv = { ...process.env, ...env };
-    configureResponseArtifactCatalog(createSqliteResponseArtifactCatalog({ keiyakuHome: getKeiyakuHome(homeEnv) }));
-    return runtimeConfig;
-}
-export function getConfig() {
-    if (!activeConfig) {
-        throw new Error("Config has not been initialized. Call initializeConfig() before using getConfig().");
-    }
-    return activeConfig;
-}
-export function resetConfigForTests() {
-    activeConfig = undefined;
-    configureResponseArtifactCatalog(undefined);
-}

package/build/config/provider-policy-ownership.js

@@ -1,10 +0,0 @@
-import { getProviderRegistration } from "../agents/providers/registry.js";
-const EMPTY_OWNERSHIP = Object.freeze({
-    access: Object.freeze([]),
-    network: Object.freeze([]),
-    webSearch: Object.freeze([]),
-});
-export function nativePolicyOwnership(instanceName, instance) {
-    const owned = getProviderRegistration(instance.kind).nativePolicyOwnership(instanceName, instance);
-    return owned ?? EMPTY_OWNERSHIP;
-}

package/build/config/settings/disease.js

@@ -1,33 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-export function findSettingsDiseasesForKnob(diseases, knob) {
-    return diseases.filter((disease) => disease.knob === knob || disease.knob === undefined);
-}
-export function formatSettingsDiseases(diseases) {
-    return diseases.map((disease) => {
-        const where = disease.knob ? `${disease.coordinate}:${disease.knob}` : `${disease.coordinate}:(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 for diseased knob '${knob}'.`, {
-        facts: {
-            kind: "invalid_settings",
-            diseases: hits.map((disease) => ({
-                source: disease.source,
-                coordinate: disease.coordinate,
-                ...(disease.knob !== undefined ? { knob: disease.knob } : {}),
-                reason: disease.reason,
-            })),
-        },
-    });
-}

package/build/config/settings/knobs.js

@@ -1,14 +0,0 @@
-export const PROJECTION_ADOPTION_TIMEOUT_DEFAULT_MS = 30_000;
-export const PROJECTION_ADOPTION_TIMEOUT_MIN_MS = 1_000;
-export const PROJECTION_ADOPTION_TIMEOUT_MAX_MS = 600_000;
-export const KNOWN_SETTINGS_KNOBS = ["default", "reviewer", "gate", "defaultBranch", "worktreeBootstrap", "projectionAdoptionTimeoutMs"];
-export const KNOWN_SETTINGS_ROOT_KEYS = [...KNOWN_SETTINGS_KNOBS, "providers"];
-export function resolveProjectionAdoptionTimeoutMs(settings) {
-    return settings?.projectionAdoptionTimeoutMs ?? PROJECTION_ADOPTION_TIMEOUT_DEFAULT_MS;
-}
-export function resolveDefaultAgentName(settings) {
-    return settings?.default ?? "akuma-codex";
-}
-export function resolveReviewerAgentName(settings) {
-    return settings?.reviewer ?? resolveDefaultAgentName(settings);
-}

package/build/config/settings/loader.js

@@ -1,275 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { getProviderRegistration } from "../../agents/providers/registry.js";
-import { isErrnoException } from "../../errno.js";
-import { SETTINGS_FILE } from "../../keiyaku.js";
-import { getKeiyakuHome } from "../env.js";
-import { KNOWN_SETTINGS_KNOBS, KNOWN_SETTINGS_ROOT_KEYS } from "./knobs.js";
-import { BUILTIN_PROVIDER_INSTANCE_CANDIDATES, knobSchemas, providerInstanceNameSchema, providerInstanceSchema, } from "./schema.js";
-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(settingsSource, providerSource, rawProviders) {
-    if (!isPlainObject(rawProviders)) {
-        return {
-            candidates: [],
-            disease: { ...settingsSource, 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: providerSource,
-                coordinate: settingsSource.coordinate,
-                reason: formatProviderInstanceIssues(name, nameResult.error),
-            });
-            continue;
-        }
-        const instanceResult = providerInstanceSchema.safeParse(rawInstance);
-        if (!instanceResult.success) {
-            candidates.push({
-                name,
-                source: providerSource,
-                coordinate: settingsSource.coordinate,
-                reason: formatProviderInstanceIssues(name, instanceResult.error),
-            });
-            continue;
-        }
-        const instance = instanceResult.data;
-        const registration = getProviderRegistration(instance.kind);
-        const writableRoots = registration.rejectsGlobalWritableRoots &&
-            instance &&
-            typeof instance === "object" &&
-            "writableRoots" in instance
-            ? instance.writableRoots
-            : undefined;
-        if (writableRoots !== undefined && providerSource === "global") {
-            let relativeIndex;
-            for (let i = 0; i < writableRoots.length; i++) {
-                if (!path.posix.isAbsolute(writableRoots[i])) {
-                    relativeIndex = i;
-                    break;
-                }
-            }
-            if (relativeIndex !== undefined) {
-                candidates.push({
-                    name,
-                    source: providerSource,
-                    coordinate: settingsSource.coordinate,
-                    reason: `providers.${name}.writableRoots.${relativeIndex}: writableRoots item must be an absolute path for global provider instances`,
-                });
-                continue;
-            }
-        }
-        candidates.push({ name, source: providerSource, coordinate: settingsSource.coordinate, 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(settingsSource, providerSource, read) {
-    if (!read.found) {
-        return { settingsSource, partial: {}, diseases: [], providerCandidates: [] };
-    }
-    if (read.parseError !== undefined) {
-        return {
-            settingsSource,
-            partial: {},
-            diseases: [{ ...settingsSource, reason: `settings root is unreadable (${read.parseError})` }],
-            providerCandidates: [],
-        };
-    }
-    if (!isPlainObject(read.raw)) {
-        return {
-            settingsSource,
-            partial: {},
-            diseases: [{ ...settingsSource, 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({
-                ...settingsSource,
-                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(settingsSource, 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" && settingsSource.source === "global") {
-            diseases.push({
-                ...settingsSource,
-                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({
-                ...settingsSource,
-                knob,
-                reason: formatZodIssues(result.error),
-            });
-            continue;
-        }
-        if (result.data === undefined)
-            continue;
-        partial[knob] = result.data;
-    }
-    return { settingsSource, 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;
-}
-function collectKnobSources(global, local) {
-    const sources = {};
-    for (const knob of KNOWN_SETTINGS_KNOBS) {
-        if (global.partial[knob] !== undefined)
-            sources[knob] = global.settingsSource;
-        if (local.partial[knob] !== undefined)
-            sources[knob] = local.settingsSource;
-    }
-    return sources;
-}
-export async function loadKeiyakuSettings(cwd) {
-    const localSettingsPath = path.join(cwd, SETTINGS_FILE);
-    const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
-    const globalSource = { source: "global", coordinate: globalSettingsPath };
-    const localSource = { source: "local", coordinate: localSettingsPath };
-    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: [{ ...localSource, reason: `settings root is unreadable (${reason})` }],
-            knobSources: {},
-            providerInstances: builtinProviderInstanceCatalog(),
-        };
-    }
-    const globalCollected = collectSourceDiseases(globalSource, "global", globalRead);
-    const localCollected = collectSourceDiseases(localSource, "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,
-        knobSources: collectKnobSources(globalCollected, localCollected),
-        providerInstances,
-    };
-}

package/build/config/settings/provider-instance-fields.js

@@ -1,51 +0,0 @@
-import { z } from "zod";
-// Local leaf copy of the Claude setting-source vocabulary so this module never
-// imports keiyaku.js (which re-exports the provider registry and would cycle).
-const CLAUDE_SETTING_SOURCES = ["project", "user", "local"];
-export const tomlValueSchema = z.lazy(() => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.array(tomlValueSchema),
-    z.record(z.string(), tomlValueSchema),
-]));
-export const structuredTomlValueSchema = z.record(z.string(), tomlValueSchema);
-export 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.",
-        });
-    }
-});
-export const nonblankOptionalString = z
-    .string()
-    .refine((value) => value.trim().length > 0, { message: "must not be blank." })
-    .optional();
-export const providerCommonFields = {
-    description: nonblankOptionalString,
-};
-export const providerEnvSchema = z.record(z.string(), z.string()).optional();
-export const FORBIDDEN_CONFIG_KEYS = ["model", "model_reasoning_effort"];
-export function isConfigKeyForbidden(key) {
-    return FORBIDDEN_CONFIG_KEYS.includes(key);
-}
-export const claudeSettingSourceSchema = z.enum(CLAUDE_SETTING_SOURCES);
-export 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;
-    }
-});