@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/config/akuma-loader_v2.js

@@ -0,0 +1,222 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { z } from "zod";
+import { parseToAST } from "../core/markdown/parser.js";
+import { isGitRepo } from "../git/branches.js";
+import { BUILTIN_AGENT_PROFILES } from "../keiyaku.js";
+import { getKeiyakuHome } from "./env.js";
+import { agentNameSchema, providerInstanceNameSchema } from "./settings.js";
+const nonblankString = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
+const effortOptionsSchema = z.array(nonblankString).superRefine((values, ctx) => {
+    if (new Set(values).size !== values.length) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "must not contain duplicate values" });
+    }
+});
+const profileSchema = z
+    .object({
+    provider: providerInstanceNameSchema,
+    description: nonblankString.optional(),
+    model: nonblankString.optional(),
+    effort: nonblankString.optional(),
+    effortOptions: effortOptionsSchema.optional(),
+    access: z.enum(["read", "write", "auto"]).optional(),
+    network: z.enum(["disabled", "enabled"]).optional(),
+    webSearch: z.enum(["disabled", "cached", "live"]).optional(),
+})
+    .strict();
+function formatIssues(error) {
+    return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+function stripFrontMatterQuote(rawValue) {
+    const value = rawValue.trim();
+    if (value.length < 2)
+        return value;
+    const quote = value[0];
+    return (quote === "'" || quote === '"') && value.at(-1) === quote ? value.slice(1, -1) : value;
+}
+function splitFrontMatter(content) {
+    const ast = parseToAST(content, { allowSections: false });
+    if (ast.frontmatter === undefined) {
+        throw new Error("missing leading YAML frontmatter");
+    }
+    const lines = content.split(/\r?\n/);
+    let closingIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if ((lines[index] ?? "").trim() === "---") {
+            closingIndex = index;
+            break;
+        }
+    }
+    if (closingIndex === -1)
+        throw new Error("frontmatter is not closed");
+    const entries = [];
+    for (let index = 1; index < closingIndex; index += 1) {
+        const line = lines[index] ?? "";
+        const match = line.trim().match(/^([A-Za-z0-9_.-]+)\s*:\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1] ?? "";
+        const value = match[2] ?? "";
+        if (key === "effortOptions" && value.trim() === "") {
+            const options = [];
+            while (index + 1 < closingIndex) {
+                const item = lines[index + 1] ?? "";
+                if (item.trim().match(/^([A-Za-z0-9_.-]+)\s*:/))
+                    break;
+                const itemMatch = item.match(/^\s*-\s*(.*)$/);
+                if (!itemMatch)
+                    break;
+                options.push(stripFrontMatterQuote(itemMatch[1] ?? ""));
+                index += 1;
+            }
+            entries.push([key, options]);
+            continue;
+        }
+        entries.push([key, stripFrontMatterQuote(value)]);
+    }
+    return { entries, body: lines.slice(closingIndex + 1).join("\n") };
+}
+function freezeProfile(profile) {
+    if (profile.effortOptions === undefined)
+        return Object.freeze({ ...profile });
+    return Object.freeze({
+        ...profile,
+        effortOptions: Object.freeze([...profile.effortOptions]),
+    });
+}
+function freezeCandidate(candidate) {
+    if ("reason" in candidate && candidate.reason !== undefined) {
+        return Object.freeze({ ...candidate });
+    }
+    return Object.freeze({
+        ...candidate,
+        profile: freezeProfile(candidate.profile),
+    });
+}
+function decodeProfile(entries) {
+    const raw = {};
+    for (const [key, value] of entries) {
+        if (key === "effortOptions") {
+            raw[key] = value;
+            continue;
+        }
+        if (typeof value !== "string")
+            throw new Error(`${key} must be a scalar value`);
+        raw[key] = value;
+    }
+    const parsed = profileSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new Error(formatIssues(parsed.error));
+    if (parsed.data.effort !== undefined && parsed.data.effortOptions !== undefined && !parsed.data.effortOptions.includes(parsed.data.effort)) {
+        throw new Error("effort must be an exact member of effortOptions");
+    }
+    return freezeProfile(parsed.data);
+}
+async function readLayer(directory, source) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { candidates: [] };
+        return {
+            candidates: [],
+            directoryFailure: {
+                path: directory,
+                reason: `unable to read akuma directory (${error instanceof Error ? error.message : String(error)})`,
+            },
+        };
+    }
+    const candidates = [];
+    for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = path.join(directory, entry.name);
+        const name = path.basename(entry.name, ".md");
+        const nameResult = agentNameSchema.safeParse(name);
+        if (!nameResult.success) {
+            candidates.push(freezeCandidate({
+                name,
+                source,
+                path: file,
+                reason: `invalid akuma name: ${formatIssues(nameResult.error)}`,
+            }));
+            continue;
+        }
+        try {
+            const content = await fs.readFile(file, "utf-8");
+            const { entries: frontmatter, body } = splitFrontMatter(content);
+            candidates.push(freezeCandidate({
+                name,
+                source,
+                path: file,
+                body,
+                profile: decodeProfile(frontmatter),
+            }));
+        }
+        catch (error) {
+            candidates.push(freezeCandidate({
+                name,
+                source,
+                path: file,
+                reason: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    return { candidates };
+}
+function foldLayer(selected, shadows, allCandidates, source, layer) {
+    if (layer.directoryFailure !== undefined) {
+        allCandidates.push(freezeCandidate({
+            name: `${source}-akuma-directory`,
+            source,
+            path: layer.directoryFailure.path,
+            reason: layer.directoryFailure.reason,
+        }));
+    }
+    for (const candidate of layer.candidates) {
+        allCandidates.push(candidate);
+        const prior = selected[candidate.name];
+        if (prior !== undefined) {
+            shadows.push(Object.freeze({
+                name: prior.name,
+                source: prior.source,
+                path: prior.path,
+                shadowedBy: candidate.source,
+            }));
+        }
+        selected[candidate.name] = candidate;
+    }
+}
+export async function loadAkumaCatalogV2(cwd) {
+    const candidates = [];
+    const selected = {};
+    const shadows = [];
+    for (const [name, profile] of Object.entries(BUILTIN_AGENT_PROFILES)) {
+        const candidate = freezeCandidate({
+            name,
+            source: "builtin",
+            path: null,
+            body: "",
+            profile: freezeProfile({
+                provider: profile.provider,
+                ...(profile.description !== undefined ? { description: profile.description } : {}),
+                ...("model" in profile && profile.model !== undefined ? { model: profile.model } : {}),
+                ...("effort" in profile && profile.effort !== undefined ? { effort: profile.effort } : {}),
+                ...("effortOptions" in profile && profile.effortOptions !== undefined
+                    ? { effortOptions: Object.freeze([...profile.effortOptions]) }
+                    : {}),
+            }),
+        });
+        candidates.push(candidate);
+        selected[name] = candidate;
+    }
+    foldLayer(selected, shadows, candidates, "user", await readLayer(path.join(getKeiyakuHome(), "akuma"), "user"));
+    if (await isGitRepo(cwd)) {
+        foldLayer(selected, shadows, candidates, "project", await readLayer(path.join(cwd, ".keiyaku", "akuma"), "project"));
+    }
+    return Object.freeze({
+        candidates: Object.freeze(candidates),
+        selected: Object.freeze(selected),
+        shadows: Object.freeze(shadows),
+    });
+}

package/build/config/env-keys.js

@@ -9,9 +9,7 @@ export const DISABLE_SUBAGENT_SPAWN_ENV_KEY = "KEIYAKU_DISABLE_SUBAGENT_SPAWN";
 export const ENV_KEYS = {
     AGENT_OVERRIDE: "KEIYAKU_AGENT_OVERRIDE",
     DISABLE_SUBAGENT_SPAWN: DISABLE_SUBAGENT_SPAWN_ENV_KEY,
-    SUBAGENT_EXEC_TIMEOUT_MS: "KEIYAKU_SUBAGENT_EXEC_TIMEOUT_MS",
     SUBAGENT_EXEC_IDLE_TIMEOUT_MS: "KEIYAKU_SUBAGENT_EXEC_IDLE_TIMEOUT_MS",
-    SUBAGENT_PROGRESS_INTERVAL_MIN: "KEIYAKU_SUBAGENT_PROGRESS_INTERVAL_MIN",
     CODEX_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CODEX_EXEC_MAX_CAPTURE_CHARS",
     CLAUDE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CLAUDE_EXEC_MAX_CAPTURE_CHARS",
     OPENCODE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_OPENCODE_EXEC_MAX_CAPTURE_CHARS",
@@ -27,9 +25,7 @@ export const ENV_KEYS = {
 const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.AGENT_OVERRIDE, defaultValue: "", description: "Override default agent name", category: "subagent" },
     { key: ENV_KEYS.DISABLE_SUBAGENT_SPAWN, defaultValue: "0", description: "Disable subprocess subagent spawning when set to 1", category: "subagent" },
-    { key: ENV_KEYS.SUBAGENT_EXEC_TIMEOUT_MS, defaultValue: "2700000", description: "Subagent execution timeout in milliseconds", category: "subagent" },
     { key: ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS, defaultValue: "600000", description: "Subagent idle timeout in milliseconds", category: "subagent" },
-    { key: ENV_KEYS.SUBAGENT_PROGRESS_INTERVAL_MIN, defaultValue: "0", description: "Print subagent tool/activity summaries every N minutes when greater than 0", category: "subagent" },
     { key: ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Codex runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Claude runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "OpenCode runtime output/diagnostics capture cap", category: "subagent" },

package/build/config/env.js

@@ -138,9 +138,7 @@ function booleanFlagEnv(key) {
 const subagentSchema = z.object({
     nameOverride: z.string().default(getEnvDefaultValue(ENV_KEYS.AGENT_OVERRIDE)).transform((value) => value.trim()),
     disableSpawn: booleanFlagEnv(ENV_KEYS.DISABLE_SUBAGENT_SPAWN),
-    execTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_TIMEOUT_MS),
     execIdleTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS),
-    progressIntervalMin: nonNegativeIntEnv(ENV_KEYS.SUBAGENT_PROGRESS_INTERVAL_MIN),
 });
 const codexSchema = z.object({
     execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS),
@@ -174,9 +172,7 @@ const envSchema = z
     .object({
     [ENV_KEYS.AGENT_OVERRIDE]: z.string().optional(),
     [ENV_KEYS.DISABLE_SUBAGENT_SPAWN]: z.string().optional(),
-    [ENV_KEYS.SUBAGENT_EXEC_TIMEOUT_MS]: z.string().optional(),
     [ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS]: z.string().optional(),
-    [ENV_KEYS.SUBAGENT_PROGRESS_INTERVAL_MIN]: 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(),
@@ -196,9 +192,7 @@ const envSchema = z
     subagent: subagentSchema.parse({
         nameOverride: rawEnv[ENV_KEYS.AGENT_OVERRIDE],
         disableSpawn: rawEnv[ENV_KEYS.DISABLE_SUBAGENT_SPAWN],
-        execTimeoutMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_TIMEOUT_MS],
         execIdleTimeoutMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS],
-        progressIntervalMin: rawEnv[ENV_KEYS.SUBAGENT_PROGRESS_INTERVAL_MIN],
     }),
     codex: codexSchema.parse({
         execMaxCaptureChars: rawEnv[ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS],