@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/akuma/archetype.js

@@ -1,16 +1,16 @@
-import { readFileSync, readdirSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { parseDocument } from "yaml";
 import { archetypeName } from "./identity.js";
-import { decodeProviderOptions } from "./provider.js";
-import { decodeProviderExecution, providerNamed } from "./providers/index.js";
+import { decodeProviderOptions, decodeProviderRecipe, } from "./provider-recipe.js";
+import { resolveProviderExecution } from "./providers/index.js";
 export class AkumaArchetypeError extends Error {
     archetype;
     searched;
     reason;
     kind = "akuma-archetype";
-    constructor(archetype, searched, reason) {
-        super(`Akuma archetype ${archetype} ${reason}\n${searched.map((path) => `searched ${path}`).join("\n")}`);
+    constructor(archetype, searched, reason, guidance) {
+        super([`\`${archetype}\` ${reason}`, ...(guidance === undefined ? [] : [guidance])].join("\n"));
         this.archetype = archetype;
         this.searched = searched;
         this.reason = reason;
@@ -21,27 +21,24 @@ function archetypeDirectory(settings) {
     const userPath = settings.scopes.user.path;
     return userPath === undefined ? null : join(dirname(userPath), "akuma");
 }
-export function listArchetypes(input) {
-    const directory = archetypeDirectory(input.settings);
+async function archetypePaths(settings) {
+    const directory = archetypeDirectory(settings);
     if (directory === null)
         return [];
     try {
-        return readdirSync(directory, { withFileTypes: true })
+        return (await readdir(directory, { withFileTypes: true }))
             .flatMap((entry) => {
-            if (!entry.isFile())
-                return [];
-            const filename = entry.name;
-            if (!filename.endsWith(".md"))
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
                 return [];
-            const name = filename.slice(0, -3);
+            const name = entry.name.slice(0, -3);
             try {
-                return [archetypeName(name)];
+                return [{ name: archetypeName(name), path: join(directory, entry.name) }];
             }
             catch {
                 return [];
             }
         })
-            .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+            .sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -49,12 +46,15 @@ export function listArchetypes(input) {
         throw error;
     }
 }
+export async function listArchetypes(input) {
+    return (await archetypePaths(input.settings)).map(({ name }) => name);
+}
 function archetypeField(values, key, required = false) {
     const value = values[key];
     if (value === undefined && !required)
         return undefined;
     if (typeof value !== "string" || value.trim().length === 0) {
-        throw new TypeError(`Archetype ${key} must be a nonblank string`);
+        throw new TypeError(`Akuma ${key} must be a nonblank string`);
     }
     return value;
 }
@@ -63,28 +63,37 @@ function archetypeEnum(values, key, allowed) {
     if (value === undefined)
         return undefined;
     if (!allowed.includes(value))
-        throw new TypeError(`Archetype ${key} must be one of ${allowed.join(", ")}`);
+        throw new TypeError(`Akuma ${key} must be one of ${allowed.join(", ")}`);
     return value;
 }
+function archetypeReadonly(values) {
+    if (!("readonly" in values))
+        return undefined;
+    if (values.readonly !== true)
+        throw new TypeError("Akuma readonly must be true");
+    return true;
+}
 function decodeArchetype(name, path, markdown) {
     const lines = markdown.split(/\r?\n/u);
     if (lines[0]?.trim() !== "---")
-        throw new TypeError("Archetype must begin with YAML frontmatter");
+        throw new TypeError("Akuma configuration must begin with YAML frontmatter");
     const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
     if (closing < 0)
-        throw new TypeError("Archetype frontmatter is not closed");
+        throw new TypeError("Akuma frontmatter is not closed");
     const document = parseDocument(lines.slice(1, closing).join("\n"), { uniqueKeys: true });
     if (document.errors.length > 0)
-        throw new TypeError(`Archetype frontmatter is invalid: ${document.errors[0].message}`);
+        throw new TypeError(`Akuma frontmatter is invalid: ${document.errors[0].message}`);
     const decoded = document.toJS();
     if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
-        throw new TypeError("Archetype frontmatter must be one mapping");
+        throw new TypeError("Akuma frontmatter must be one mapping");
     }
     const values = decoded;
     const provider = archetypeField(values, "provider", true);
+    if ("access" in values)
+        throw new TypeError("Akuma access is not supported; use readonly: true");
     const model = archetypeField(values, "model");
     const effort = archetypeField(values, "effort");
-    const access = archetypeEnum(values, "access", ["read", "write", "auto"]);
+    const readonly = archetypeReadonly(values);
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
     const description = archetypeField(values, "description");
     const systemPrompt = lines.slice(closing + 1).join("\n");
@@ -96,12 +105,33 @@ function decodeArchetype(name, path, markdown) {
         options: decodeProviderOptions({
             ...(model === undefined ? {} : { model }),
             ...(effort === undefined ? {} : { effort }),
-            ...(access === undefined ? {} : { access }),
+            ...(readonly === undefined ? {} : { readonly }),
             ...(network === undefined ? {} : { network }),
-            systemPrompt,
+            ...(systemPrompt.length === 0 ? {} : { systemPrompt }),
         }),
     });
 }
+export async function listArchetypeDefinitions(input) {
+    // Reads still run concurrently, but the reported failure is the first invalid
+    // definition in catalog byte order, not whichever read happened to finish first.
+    const settled = await Promise.allSettled((await archetypePaths(input.settings)).map(async ({ name, path }) => {
+        try {
+            const definition = decodeArchetype(name, path, await readFile(path, "utf8"));
+            return Object.freeze({
+                name: definition.name,
+                ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
+                ...(definition.description === undefined ? {} : { description: definition.description }),
+            });
+        }
+        catch (error) {
+            throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }));
+    const firstInvalid = settled.find((result) => result.status === "rejected");
+    if (firstInvalid !== undefined)
+        throw firstInvalid.reason;
+    return settled.map((result) => result.value);
+}
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value : null;
@@ -123,7 +153,7 @@ function configuredProvider(name, selected) {
     if (unknown !== undefined)
         throw new TypeError(`provider ${name} has unknown field ${unknown}`);
     optionalProviderText(value, name, "description");
-    return decodeProviderExecution({
+    return decodeProviderRecipe({
         name,
         kind: value.kind,
         ...(value.executable === undefined ? {} : { executable: value.executable }),
@@ -131,6 +161,16 @@ function configuredProvider(name, selected) {
         ...(value.env === undefined ? {} : { env: value.env }),
     });
 }
+const BUILTIN_EXECUTIONS = {
+    claude: { kind: "claude-agent-sdk" },
+    "codex-app-server": { kind: "codex-app-server" },
+    "opencode-sdk": { kind: "opencode-sdk" },
+    pi: { kind: "pi" },
+    "grok-build": {
+        kind: "grok-build",
+        executable: "grok",
+    },
+};
 function providerExecution(settings, name) {
     const view = settings.namespace("providers");
     if (view.kind === "failed")
@@ -138,43 +178,49 @@ function providerExecution(settings, name) {
     const selected = view.entries.find((entry) => entry.name === name)?.value;
     if (selected !== undefined)
         return configuredProvider(name, selected);
-    if (name === "claude")
-        return Object.freeze({ name, kind: "claude-agent-sdk" });
-    if (name === "codex-app-server")
-        return Object.freeze({ name, kind: "codex-app-server" });
+    const builtin = BUILTIN_EXECUTIONS[name];
+    if (builtin !== undefined)
+        return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
 function admitArchetype(archetype, settings) {
-    let execution;
+    let selected;
     try {
-        execution = providerExecution(settings, archetype.provider);
+        selected = resolveProviderExecution(providerExecution(settings, archetype.provider));
     }
     catch (error) {
         if (error instanceof TypeError)
             throw new AkumaArchetypeError(archetype.name, [archetype.path], `uses ${error.message}`);
         throw error;
     }
-    const adapter = providerNamed(execution);
+    const execution = selected.execution;
+    const adapter = selected.adapter;
     const admission = adapter.admitOptions(archetype.options);
     if (admission.kind === "refused") {
         throw new AkumaArchetypeError(archetype.name, [archetype.path], `is unsupported: ${admission.diagnostic}`);
     }
-    return Object.freeze({ ...archetype, provider: execution, adapter, options: admission.options });
+    return Object.freeze({
+        ...archetype,
+        provider: execution,
+        adapter,
+        options: admission.options,
+        ...(admission.readonly === undefined ? {} : { readonly: admission.readonly }),
+    });
 }
-export function loadArchetype(input) {
+export async function loadArchetype(input) {
     const name = archetypeName(input.name);
     const directory = archetypeDirectory(input.settings);
+    const missing = () => new AkumaArchetypeError(name, directory === null ? [] : [join(directory, `${name}.md`)], "was not found", "use `keiyaku ls aku/` to list available Akuma");
     if (directory === null)
-        throw new AkumaArchetypeError(name, [], "has no user Settings coordinate");
+        throw missing();
     const path = join(directory, `${name}.md`);
     let markdown;
     try {
-        markdown = readFileSync(path, "utf8");
+        markdown = await readFile(path, "utf8");
     }
     catch (error) {
-        if (error.code === "ENOENT") {
-            throw new AkumaArchetypeError(name, [path], "was not found");
-        }
+        if (error.code === "ENOENT")
+            throw missing();
         throw new AkumaArchetypeError(name, [path], `could not be read: ${error instanceof Error ? error.message : String(error)}`);
     }
     try {

package/build/src/akuma/body.d.ts

@@ -2,7 +2,7 @@ import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter } from "./provider.js";
 import { type RequestChildLaunch } from "./requests.js";
-import { type ProcessCollar } from "../runtime/proc/run.js";
+export declare const CONTROL_RESPONSE_MS = 1000;
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
     seed?: Omit<Soul, "createdAt">;
@@ -10,11 +10,9 @@ export type BodyLaunch = Readonly<{
     initialBody?: string;
 }>;
 type BodyRuntime = Readonly<{
-    collar: ProcessCollar;
     now(): string;
-    putDownOwnTree(collar: ProcessCollar): Promise<void>;
-    spawnChild?(launch: RequestChildLaunch): Promise<ProcessCollar>;
+    spawnChild?(launch: RequestChildLaunch): Promise<void>;
 }>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<void>;
-export declare function spawnAkumaBody(launch: BodyLaunch): Promise<ProcessCollar>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<void>;
 export {};