@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/akuma/providers/grok-build/index.js

@@ -1,5 +1,72 @@
-import { startAcpSession } from "../acp/core.js";
+import { startAcpSession, } from "../acp/core.js";
 const INTERJECT_METHOD = "x.ai/interject";
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nativeName(update) {
+    const wire = update;
+    return nonblank(update.name) ?? nonblank(wire.toolName);
+}
+function readCall(name, input) {
+    if (name !== "read_file" && name !== "hashline_read")
+        return undefined;
+    const sourcePath = nonblank(input.target_file);
+    const capturedPath = name === "read_file" ? nonblank(input.path) : undefined;
+    const path = sourcePath ?? capturedPath;
+    return path === undefined ? undefined : { kind: "read", path };
+}
+function contentSearchCall(name, input) {
+    if (name !== "grep" && name !== "hashline_grep")
+        return undefined;
+    const query = nonblank(input.pattern);
+    if (query === undefined)
+        return undefined;
+    const path = nonblank(input.path);
+    const glob = nonblank(input.glob);
+    return {
+        kind: "search",
+        query,
+        scope: "content",
+        ...(path === undefined ? {} : { path }),
+        ...(glob === undefined ? {} : { glob }),
+    };
+}
+function runCall(name, input) {
+    if (name !== "run_terminal_cmd")
+        return undefined;
+    const command = nonblank(input.command);
+    return command === undefined ? undefined : { kind: "run", command };
+}
+function webSearchCall(name, input) {
+    if (name !== "web_search")
+        return undefined;
+    const query = nonblank(input.query);
+    return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+}
+function fileChangeCall(name, input) {
+    if (name !== "search_replace")
+        return undefined;
+    const path = nonblank(input.file_path);
+    return path === undefined
+        ? undefined
+        : { kind: "fileChange", changes: [{ op: "unspecified", path }] };
+}
+export const interpretGrokTool = (update) => {
+    const name = nativeName(update);
+    const input = object(update.rawInput);
+    if (name === undefined || input === undefined)
+        return undefined;
+    return readCall(name, input)
+        ?? contentSearchCall(name, input)
+        ?? runCall(name, input)
+        ?? webSearchCall(name, input)
+        ?? fileChangeCall(name, input);
+};
 function optionAdmission(options) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Grok Build does not support the network option" };
@@ -59,10 +126,12 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
         };
-        return withInterject(await startAcpSession(launch, input, dependencies));
+        return withInterject(await startAcpSession(launch, input, {
+            ...dependencies,
+            interpretTool: interpretGrokTool,
+        }));
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: optionAdmission,
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

package/build/src/akuma/providers/opencode-sdk/events.js

@@ -59,6 +59,61 @@ function diagnostic(value) {
 function positiveLine(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
 }
+function nonnegativeCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function diffstat(value) {
+    if (value === undefined)
+        return undefined;
+    const added = nonnegativeCount(value.additions);
+    const removed = nonnegativeCount(value.deletions);
+    return added === undefined || removed === undefined ? undefined : { added, removed };
+}
+function fileChange(changes) {
+    return changes.length === 0 ? undefined : { kind: "fileChange", changes };
+}
+function change(op, path, stats) {
+    return stats === undefined ? { op, path } : { op, path, diffstat: stats };
+}
+function editCall(input, metadata) {
+    const path = text(input?.filePath);
+    if (path === undefined)
+        return undefined;
+    return fileChange([change("update", path, diffstat(object(metadata?.filediff)))]);
+}
+function writeCall(input, metadata) {
+    const path = text(metadata?.filepath) ?? text(input?.filePath);
+    const op = metadata?.exists === false ? "add"
+        : metadata?.exists === true ? "update" : undefined;
+    return path === undefined || op === undefined ? undefined : fileChange([change(op, path, undefined)]);
+}
+function applyPatchFile(value) {
+    const file = object(value);
+    if (file === undefined)
+        return undefined;
+    const type = file.type;
+    const op = type === "add" ? "add"
+        : type === "delete" ? "delete"
+            : type === "update" || type === "modify" || type === "move"
+                ? "update" : undefined;
+    const path = type === "move" ? text(file.movePath) : text(file.filePath);
+    return op === undefined || path === undefined ? undefined : change(op, path, diffstat(file));
+}
+function applyPatchCall(metadata) {
+    if (!Array.isArray(metadata?.files))
+        return undefined;
+    return fileChange(metadata.files.flatMap((value) => {
+        const next = applyPatchFile(value);
+        return next === undefined ? [] : [next];
+    }));
+}
+function strongerCall(previous, next) {
+    if (next === undefined)
+        return previous;
+    if (previous?.kind === "fileChange" && next.kind !== "fileChange")
+        return previous;
+    return next;
+}
 function runCall(name, value) {
     return name === "bash" || name === "shell"
         ? { kind: "run", command: text(value?.command) ?? name }
@@ -96,8 +151,9 @@ function searchCall(name, value) {
         ...(scope === "content" && glob !== undefined ? { glob } : {}),
     };
 }
-function callFor(name, input) {
+function callFor(name, input, metadata) {
     const value = object(input);
+    const meta = object(metadata);
     const lower = name.toLowerCase();
     if (lower === "bash" || lower === "shell")
         return runCall(lower, value);
@@ -105,6 +161,12 @@ function callFor(name, input) {
         return readCall(lower, value);
     if (lower === "grep" || lower === "glob" || lower === "search")
         return searchCall(lower, value);
+    if (lower === "edit")
+        return editCall(value, meta) ?? { kind: "other", display: name };
+    if (lower === "write")
+        return writeCall(value, meta) ?? { kind: "other", display: name };
+    if (lower === "apply_patch")
+        return applyPatchCall(meta) ?? { kind: "other", display: name };
     return { kind: "other", display: name };
 }
 function belongs(part, state) {
@@ -139,12 +201,12 @@ function mapToolPart(part, events, state) {
     const toolState = object(part.state);
     if (id === undefined || name === undefined || toolState === undefined)
         return;
+    const next = callFor(name, toolState.input, toolState.metadata);
     if ((toolState.status === "pending" || toolState.status === "running")
         && !state.tools.has(id) && !state.completedTools.has(id)) {
-        const call = callFor(name, toolState.input);
-        if (call === undefined)
+        if (next === undefined)
             return;
-        const observed = { name, call };
+        const observed = { name, call: next };
         state.tools.set(id, observed);
         events.emit({ type: "tool", phase: "started", id, ...observed });
         return;
@@ -152,14 +214,17 @@ function mapToolPart(part, events, state) {
     if ((toolState.status !== "completed" && toolState.status !== "error") || state.completedTools.has(id))
         return;
     const started = state.tools.get(id);
-    const call = started?.call ?? callFor(name, toolState.input);
+    const call = strongerCall(started?.call, next);
     if (call === undefined)
         return;
-    const observed = started ?? { name, call };
+    const observed = { name: started?.name ?? name, call };
     if (!state.tools.has(id)) {
         state.tools.set(id, observed);
         events.emit({ type: "tool", phase: "started", id, ...observed });
     }
+    else {
+        state.tools.set(id, observed);
+    }
     state.completedTools.add(id);
     events.emit({
         type: "tool",

package/build/src/akuma/providers/opencode-sdk/index.d.ts

@@ -1,33 +1,7 @@
-import { type ProviderAdapter, type Session } from "../../provider.js";
-import type { ResumeCoordinate } from "../../heart/index.js";
-import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 import { type OpencodeSdkLoader } from "./session.js";
 export type OpencodeProviderTestOptions = Readonly<{
     loader?: OpencodeSdkLoader;
 }>;
 export declare function createOpencodeProvider(input?: ProviderExecution | OpencodeProviderTestOptions): ProviderAdapter;
-export declare const opencodeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../heart/facts.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: ResumeCoordinate;
-    }>>;
-    start(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "fresh";
-        }>;
-    }>): Promise<Session>;
-    resume?(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "resume";
-            coordinate: ResumeCoordinate;
-        }>;
-    }>): Promise<Session>;
-}>;

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -205,7 +205,13 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await abortable(loadOpencode(execution, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
+    const runtime = await abortable(loadOpencode({
+        ...execution,
+        env: {
+            ...execution.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
+    }, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
     let closing;
     let iterator;
     const closeOnce = () => {
@@ -263,7 +269,6 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
     const execution = "kind" in input ? input : { name: OPENCODE_SDK_PROVIDER, kind: "opencode-sdk" };
     const loader = "loader" in input ? input.loader : undefined;
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
             try {
                 admit(options);
@@ -305,4 +310,3 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         },
     };
 }
-export const opencodeProvider = createOpencodeProvider();

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -3,7 +3,7 @@ import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;
 export type OpencodeSdkEvent = Pick<OpencodeClient["event"], "subscribe">;
-export type OpencodeSdkLoader = (cwd: string) => Promise<Readonly<{
+export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
         event: OpencodeSdkEvent;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -40,7 +40,7 @@ async function availablePort() {
 }
 export async function loadOpencode(execution, cwd, signal, loader) {
     if (loader) {
-        const loaded = await loader(cwd);
+        const loaded = await loader(cwd, execution);
         return { client: loaded.client, close: async () => { await loaded.close?.(); } };
     }
     const port = await availablePort();

package/build/src/akuma/providers/pi/events.js

@@ -1,4 +1,5 @@
 import { noteEvent, unknownEvent } from "../../provider.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
     agent_settled: "drop",
@@ -82,9 +83,21 @@ function searchCall(name, value) {
     };
 }
 function fileChangeCall(name, value) {
-    if ((name !== "edit" && name !== "write") || typeof value.path !== "string")
+    if (name !== "edit" || typeof value.path !== "string")
         return undefined;
-    return { kind: "fileChange", changes: [{ op: name === "write" ? "add" : "update", path: value.path }] };
+    return { kind: "fileChange", changes: [{ op: "update", path: value.path }] };
+}
+function refineEditCall(call, result) {
+    if (call.kind !== "fileChange")
+        return call;
+    const details = record(record(result)?.details);
+    if (typeof details?.patch !== "string")
+        return call;
+    const diffstat = diffstatFromUnifiedPatch(details.patch);
+    const change = call.changes[0];
+    if (diffstat === undefined || change === undefined)
+        return call;
+    return { kind: "fileChange", changes: [{ ...change, diffstat }] };
 }
 function toolCall(name, args) {
     const value = record(args) ?? {};
@@ -108,9 +121,10 @@ function translateToolEnd(event, state) {
     const started = state.tools.get(event.toolCallId);
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
+    const call = started?.call ?? { kind: "other", display: name };
     return [{
             type: "tool", phase: "completed", id: event.toolCallId, name,
-            call: started?.call ?? { kind: "other", display: name },
+            call: event.isError ? call : refineEditCall(call, event.result),
             result: { status: event.isError ? "error" : "ok" },
         }];
 }

package/build/src/akuma/providers/pi/index.js

@@ -1,9 +1,9 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
-const MODEL_PATTERN = /^[^/\s]+\/[^/\s]+$/u;
+const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
 function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
 function admitPiOptions(options) {
     if (options.network !== undefined)
@@ -48,6 +48,14 @@ async function piCreateOptions(sdk, input) {
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
+        ...(input.requests === undefined || input.options.readonly === true
+            ? {}
+            : { customTools: [createBashToolDefinition(input.cwd, {
+                        spawnHook: (context) => ({
+                            ...context,
+                            env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                        }),
+                    })] }),
     };
 }
 async function createPiSession(sdk, input, signal) {
@@ -176,7 +184,6 @@ export function createPiProvider(execution = { name: "pi", kind: "pi" }, load =
         return drivePi(await abortable(load(), signal), input, signal);
     };
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions: admitPiOptions,
         start: drive,
         resume: async (input) => {

package/build/src/akuma/providers/unified-patch.d.ts

@@ -0,0 +1,4 @@
+export declare function diffstatFromUnifiedPatch(patch: string): Readonly<{
+    added: number;
+    removed: number;
+}> | undefined;

package/build/src/akuma/providers/unified-patch.js

@@ -0,0 +1,14 @@
+export function diffstatFromUnifiedPatch(patch) {
+    const lines = patch.split("\n");
+    if (!lines.some((line) => /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(line)))
+        return undefined;
+    let added = 0;
+    let removed = 0;
+    for (const line of lines) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removed += 1;
+    }
+    return { added, removed };
+}

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

@@ -1,5 +1,5 @@
 import { type AllocatedAkuma } from "./identity.js";
-export declare const BIRTH_TIMEOUT_MS = 5000;
+export declare const BIRTH_TIMEOUT_MS = 30000;
 export declare function publishAkuma(input: Readonly<{
     worldPath: string;
     archetype: string;

package/build/src/akuma/publication.js

@@ -2,7 +2,7 @@ import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul, } from
 import { allocateAkumaDirectory, } from "./identity.js";
 import { abortableDelay } from "./abort.js";
 const POLL_MS = 25;
-export const BIRTH_TIMEOUT_MS = 5_000;
+export const BIRTH_TIMEOUT_MS = 30_000;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/build/src/akuma/request-serve.d.ts

@@ -0,0 +1,87 @@
+import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type TaskMutationRequest } from "../task/mutation.js";
+export type RequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+type UpstreamCall = Readonly<{
+    signal: AbortSignal;
+}>;
+type RequesterCall = UpstreamCall & Readonly<{
+    requester: AkuId;
+}>;
+type ContractCall = RequesterCall & Readonly<{
+    repoRoot: string;
+    contractId: string;
+}>;
+export type UpstreamExecutionPort = Readonly<{
+    wait(input: UpstreamCall & Readonly<{
+        targets: readonly AkuId[];
+        completion: "any" | "all";
+        timeoutMs?: number;
+    }>): Promise<unknown>;
+    tell(input: UpstreamCall & Readonly<{
+        target: AkuId;
+        body: string;
+        tellId: string;
+        recordedAt: string;
+    }>): Promise<unknown>;
+    kill(input: Readonly<{
+        targets: readonly AkuId[];
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkuId;
+            evidence: KillEvidence;
+        }>[];
+    }>>;
+    deliver(input: ContractCall & Readonly<{
+        message?: string;
+        includeDirty: boolean;
+    }>): Promise<Readonly<{
+        result: unknown;
+        deliveryFactId?: string;
+    }>>;
+    review(input: ContractCall & Readonly<{
+        verdict: "satisfied" | "unsatisfied";
+        summary?: string;
+    }>): Promise<Readonly<{
+        result: unknown;
+        reviewFactId?: string;
+    }>>;
+    task(input: RequesterCall & Readonly<{
+        world: string;
+        request: TaskMutationRequest;
+    }>): Promise<unknown>;
+}>;
+type PumpInput = Readonly<{
+    paths: AkumaPaths;
+    parent: Soul;
+    bodySequence: number;
+    now(): string;
+    spawn(launch: RequestChildLaunch): Promise<void>;
+    upstream?: UpstreamExecutionPort;
+    signal: AbortSignal;
+}>;
+export declare class BodyRequestPump {
+    private readonly input;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private readonly closeSignal;
+    private readonly executionSignal;
+    private readonly handled;
+    private readonly running;
+    private readonly cancelBody;
+    private admissionClosed;
+    private constructor();
+    static open(input: PumpInput): Promise<BodyRequestPump>;
+    private run;
+    close(): Promise<void>;
+    stopAdmission(): void;
+}
+export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
+export {};