@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/akuma/archetype.js

@@ -19,11 +19,16 @@ export class AkumaArchetypeError extends Error {
         this.name = "AkumaArchetypeError";
     }
 }
-function archetypeDirectory(home) {
+function projectArchetypeDirectory(project) {
+    return project === undefined ? undefined : join(project, ".keiyaku", "akuma");
+}
+function homeArchetypeDirectory(home) {
     return join(home ?? join(homedir(), ".keiyaku"), "akuma");
 }
-async function archetypePaths(home) {
-    const directory = archetypeDirectory(home);
+function archetypeDirectories(input) {
+    return [projectArchetypeDirectory(input.project), homeArchetypeDirectory(input.home)].filter((directory) => directory !== undefined);
+}
+async function pathsInDirectory(directory) {
     try {
         return (await readdir(directory, { withFileTypes: true }))
             .flatMap((entry) => {
@@ -45,8 +50,37 @@ async function archetypePaths(home) {
         throw error;
     }
 }
+async function archetypePaths(input = {}) {
+    const scopes = await Promise.all(archetypeDirectories(input).map(pathsInDirectory));
+    const selected = new Map();
+    for (const scope of scopes) {
+        for (const entry of scope)
+            if (!selected.has(entry.name))
+                selected.set(entry.name, entry);
+    }
+    return [...selected.values()].sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
+}
+function sourceLookups(name, input, source) {
+    if (source === "home" || input.project === undefined) {
+        return [{ path: join(homeArchetypeDirectory(input.home), `${name}.md`), source: "home" }];
+    }
+    return [
+        { path: join(projectArchetypeDirectory(input.project), `${name}.md`), source: "project" },
+        { path: join(homeArchetypeDirectory(input.home), `${name}.md`), source: "home" },
+    ];
+}
+function rootLookups(name, input) {
+    return input.project === undefined ? sourceLookups(name, input, "home") : sourceLookups(name, input, "project");
+}
+function chainText(chain) {
+    return chain.join(" -> ");
+}
+function archetypeError(name, searched, reason, chain, guidance) {
+    const withChain = chain.length === 0 ? reason : `${reason} (base chain: ${chainText(chain)})`;
+    return new AkumaArchetypeError(name, searched, withChain, guidance);
+}
 export async function listArchetypes(input = {}) {
-    return (await archetypePaths(input.home)).map(({ name }) => name);
+    return (await archetypePaths(input)).map(({ name }) => name);
 }
 function archetypeField(values, key, required = false) {
     const value = values[key];
@@ -72,7 +106,7 @@ function archetypeReadonly(values) {
         throw new TypeError("Akuma readonly must be true");
     return true;
 }
-function decodeArchetype(name, path, markdown) {
+function parseArchetypeFrontmatter(markdown) {
     const lines = markdown.split(/\r?\n/u);
     if (lines[0]?.trim() !== "---")
         throw new TypeError("Akuma file must begin with YAML frontmatter");
@@ -86,8 +120,12 @@ function decodeArchetype(name, path, markdown) {
     if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
         throw new TypeError("Akuma frontmatter must be one mapping");
     }
-    const values = decoded;
-    const provider = archetypeField(values, "provider", true);
+    return { lines, closing, values: decoded };
+}
+function decodeArchetypeFields(values) {
+    const provider = archetypeField(values, "provider");
+    const baseValue = archetypeField(values, "base");
+    const base = baseValue === undefined ? undefined : archetypeName(baseValue);
     if ("access" in values)
         throw new TypeError("Akuma access is not supported; use readonly: true");
     const model = archetypeField(values, "model");
@@ -95,38 +133,115 @@ function decodeArchetype(name, path, markdown) {
     const readonly = archetypeReadonly(values);
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
     const description = archetypeField(values, "description");
-    const allowed = effectiveAllowedActions(values.allowed);
+    const allowedPresent = "allowed" in values;
+    const allowed = allowedPresent ? effectiveAllowedActions(values.allowed) : undefined;
     const systemPromptMode = archetypeEnum(values, "systemPromptMode", ["append", "replace"]);
+    return {
+        ...(base === undefined ? {} : { base }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(readonly === undefined ? {} : { readonly }),
+        ...(network === undefined ? {} : { network }),
+        ...(description === undefined ? {} : { description }),
+        ...(allowed === undefined ? {} : { allowed }),
+        allowedPresent,
+        ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
+    };
+}
+function decodeArchetype(name, path, markdown) {
+    const { lines, closing, values } = parseArchetypeFrontmatter(markdown);
+    const fields = decodeArchetypeFields(values);
     const systemPrompt = lines.slice(closing + 1).join("\n");
-    if (systemPromptMode !== undefined && systemPrompt.length === 0) {
+    if (fields.systemPromptMode !== undefined && systemPrompt.length === 0) {
         throw new TypeError("Akuma systemPromptMode requires a nonempty Markdown body");
     }
     return Object.freeze({
         name,
         path,
-        provider,
-        ...(description === undefined ? {} : { description }),
+        ...(fields.base === undefined ? {} : { base: fields.base }),
+        ...(fields.provider === undefined ? {} : { provider: fields.provider }),
+        ...(fields.description === undefined ? {} : { description: fields.description }),
         options: decodeProviderOptions({
-            ...(model === undefined ? {} : { model }),
-            ...(effort === undefined ? {} : { effort }),
-            ...(network === undefined ? {} : { network }),
+            ...(fields.model === undefined ? {} : { model: fields.model }),
+            ...(fields.effort === undefined ? {} : { effort: fields.effort }),
+            ...(fields.network === undefined ? {} : { network: fields.network }),
             ...(systemPrompt.length === 0
                 ? {}
                 : {
                     systemPrompt,
-                    systemPromptMode: systemPromptMode ?? "append",
+                    systemPromptMode: fields.systemPromptMode ?? "append",
                 }),
         }),
-        ...(readonly === undefined ? {} : { readonly }),
+        ...(fields.readonly === undefined ? {} : { readonly: fields.readonly }),
+        ...(fields.allowed === undefined ? {} : { allowed: fields.allowed }),
+        allowedPresent: fields.allowedPresent,
+    });
+}
+function mergeArchetype(base, local) {
+    const provider = local.provider ?? base?.provider;
+    if (provider === undefined)
+        throw new TypeError("Akuma provider must be a nonblank string");
+    const options = decodeProviderOptions({ ...(base?.options ?? {}), ...local.options });
+    const allowed = local.allowedPresent ? local.allowed : (base?.allowed ?? effectiveAllowedActions(undefined));
+    return Object.freeze({
+        name: local.name,
+        path: local.path,
+        provider,
+        ...(local.description === undefined
+            ? base?.description === undefined
+                ? {}
+                : { description: base.description }
+            : { description: local.description }),
+        options,
+        ...(local.readonly === true || base?.readonly === true ? { readonly: true } : {}),
         allowed,
     });
 }
+async function resolveArchetype(name, input, source, chain = []) {
+    if (chain.includes(name)) {
+        const lookups = source === undefined ? rootLookups(name, input) : sourceLookups(name, input, source);
+        throw archetypeError(name, lookups.map(({ path }) => path), "has a cyclic base reference", [...chain, name]);
+    }
+    const lookups = source === undefined ? rootLookups(name, input) : sourceLookups(name, input, source);
+    const searched = lookups.map(({ path }) => path);
+    for (const lookup of lookups) {
+        let markdown;
+        try {
+            markdown = await readFile(lookup.path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw archetypeError(name, [lookup.path], `could not be read: ${error instanceof Error ? error.message : String(error)}`, chain);
+        }
+        let local;
+        try {
+            local = decodeArchetype(name, lookup.path, markdown);
+        }
+        catch (error) {
+            throw archetypeError(name, [lookup.path], `is invalid: ${error instanceof Error ? error.message : String(error)}`, chain);
+        }
+        let inherited;
+        if (local.base !== undefined) {
+            inherited = await resolveArchetype(local.base, input, lookup.source, [...chain, name]);
+        }
+        try {
+            return mergeArchetype(inherited, local);
+        }
+        catch (error) {
+            throw archetypeError(name, [lookup.path], `is invalid: ${error instanceof Error ? error.message : String(error)}`, chain);
+        }
+    }
+    const missingChain = chain.length === 0 ? chain : [...chain, name];
+    throw archetypeError(name, searched, "was not found", missingChain, chain.length === 0 ? "use `keiyaku ls aku/` to list available Akuma" : undefined);
+}
 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.home)).map(async ({ name, path }) => {
+    const settled = await Promise.allSettled((await archetypePaths(input)).map(async ({ name, path }) => {
         try {
-            const definition = decodeArchetype(name, path, await readFile(path, "utf8"));
+            const definition = await resolveArchetype(name, input, undefined);
             return Object.freeze({
                 name: definition.name,
                 ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
@@ -134,6 +249,8 @@ export async function listArchetypeDefinitions(input = {}) {
             });
         }
         catch (error) {
+            if (error instanceof AkumaArchetypeError)
+                throw error;
             throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
         }
     }));
@@ -225,24 +342,6 @@ async function admitArchetype(archetype, settings, callReadonly) {
 }
 export async function loadArchetype(input) {
     const name = archetypeName(input.name);
-    const directory = archetypeDirectory(input.home);
-    const path = join(directory, `${name}.md`);
-    const missing = () => new AkumaArchetypeError(name, [path], "was not found", "use `keiyaku ls aku/` to list available Akuma");
-    let markdown;
-    try {
-        markdown = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            throw missing();
-        throw new AkumaArchetypeError(name, [path], `could not be read: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    try {
-        return await admitArchetype(decodeArchetype(name, path, markdown), input.settings, input.readonly);
-    }
-    catch (error) {
-        if (error instanceof AkumaArchetypeError)
-            throw error;
-        throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    const definition = await resolveArchetype(name, input, undefined);
+    return await admitArchetype(definition, input.settings, input.readonly);
 }

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

@@ -1,6 +1,7 @@
 import type { AkumaCallRequestChildLaunch } from "./call-request.js";
 import { type SessionFact, type Soul, type TellRow } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
+import { type WorldRoot } from "../world.js";
 import type { ProviderAdapter } from "./provider.js";
 import type { ErasedRequestCommand } from "./request-wire.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
@@ -13,7 +14,6 @@ export type BodyLaunch = Readonly<{
     initialBody?: string;
     refuseIfHeld?: boolean;
     completion?: Readonly<{
-        participantName?: string;
         contractId?: string;
     }>;
 }>;
@@ -49,8 +49,8 @@ type BodyRuntime = Readonly<{
     now(): string;
     spawnChild?(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess>;
     spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
-    upstream?: unknown;
-    commands: Readonly<Record<string, ErasedRequestCommand>>;
+    world: WorldRoot;
+    externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
@@ -61,7 +61,7 @@ export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: str
     log: string;
 }>;
 export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
-export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<"held" | void>;
+export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
 export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
-export declare function runAkumaBody(launch: BodyLaunch, upstream: unknown, commands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
+export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
 export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime): Promise<TellResult>;