@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/akuma/provider.js

@@ -87,9 +87,9 @@ function decodeDiffstat(value) {
 }
 function decodeFileChangeMember(value) {
     const change = object(value);
-    if (change === null || (change.op !== "add" && change.op !== "update"
-        && change.op !== "delete" && change.op !== "unspecified")
-        || typeof change.path !== "string")
+    if (change === null ||
+        (change.op !== "add" && change.op !== "update" && change.op !== "delete" && change.op !== "unspecified") ||
+        typeof change.path !== "string")
         return null;
     const diffstat = decodeDiffstat(change.diffstat);
     if (diffstat === null)
@@ -114,12 +114,18 @@ function decodeToolCall(value) {
     if (call === null)
         return null;
     switch (call.kind) {
-        case "run": return decodeRunCall(call);
-        case "read": return decodeReadCall(call);
-        case "search": return decodeSearchCall(call);
-        case "fileChange": return decodeFileChangeCall(call);
-        case "other": return decodeOtherCall(call);
-        default: return null;
+        case "run":
+            return decodeRunCall(call);
+        case "read":
+            return decodeReadCall(call);
+        case "search":
+            return decodeSearchCall(call);
+        case "fileChange":
+            return decodeFileChangeCall(call);
+        case "other":
+            return decodeOtherCall(call);
+        default:
+            return null;
     }
 }
 function decodeToolResult(value) {
@@ -143,13 +149,26 @@ function decodeToolEvent(event) {
         return null;
     const call = decodeToolCall(event.call);
     if (call !== null && event.phase === "started" && event.result === undefined) {
-        return { type: "tool", phase: "started", id: event.id, name: event.name, call,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            type: "tool",
+            phase: "started",
+            id: event.id,
+            name: event.name,
+            call,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     const result = decodeToolResult(event.result);
     if (call !== null && event.phase === "completed" && result !== null) {
-        return { type: "tool", phase: "completed", id: event.id, name: event.name, call, result,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            type: "tool",
+            phase: "completed",
+            id: event.id,
+            name: event.name,
+            call,
+            result,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     return null;
 }
@@ -159,15 +178,20 @@ function decodeTypedEvent(type, event) {
     const truncated = event.truncated === true ? { truncated: true } : {};
     switch (type) {
         case "assistant":
-        case "thought": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "note": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "unknown": return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
+        case "thought":
+            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "note":
+            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "unknown":
+            return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
         case "session": {
             const coordinate = decodeResumeCoordinate(event.coordinate);
             return coordinate === null ? null : { type, coordinate };
         }
-        case "tool": return decodeToolEvent(event);
-        default: return type;
+        case "tool":
+            return decodeToolEvent(event);
+        default:
+            return type;
     }
 }
 export function decodeAgentEvent(value) {
@@ -181,37 +205,49 @@ export function decodeAgentEvent(value) {
 }
 function boundedToolCall(call) {
     switch (call.kind) {
-        case "run": return { value: { kind: call.kind, command: boundedEventText(call.command) }, truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT };
-        case "read": return {
-            value: {
-                kind: call.kind,
-                path: boundedEventText(call.path),
-                ...(call.offset === undefined ? {} : { offset: call.offset }),
-                ...(call.limit === undefined ? {} : { limit: call.limit }),
-            },
-            truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT,
-        };
-        case "search": return {
-            value: {
-                kind: call.kind,
-                query: boundedEventText(call.query),
-                ...(call.scope === undefined ? {} : { scope: call.scope }),
-                ...(call.path === undefined ? {} : { path: boundedEventText(call.path) }),
-                ...(call.glob === undefined ? {} : { glob: boundedEventText(call.glob) }),
-            },
-            truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT
-                || (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT)
-                || (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
-        };
-        case "fileChange": return {
-            value: {
-                kind: call.kind,
-                changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
-            },
-            truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
-        };
-        case "other": return { value: { kind: call.kind, display: boundedEventText(call.display) }, truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT };
-        default: return call;
+        case "run":
+            return {
+                value: { kind: call.kind, command: boundedEventText(call.command) },
+                truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        case "read":
+            return {
+                value: {
+                    kind: call.kind,
+                    path: boundedEventText(call.path),
+                    ...(call.offset === undefined ? {} : { offset: call.offset }),
+                    ...(call.limit === undefined ? {} : { limit: call.limit }),
+                },
+                truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        case "search":
+            return {
+                value: {
+                    kind: call.kind,
+                    query: boundedEventText(call.query),
+                    ...(call.scope === undefined ? {} : { scope: call.scope }),
+                    ...(call.path === undefined ? {} : { path: boundedEventText(call.path) }),
+                    ...(call.glob === undefined ? {} : { glob: boundedEventText(call.glob) }),
+                },
+                truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT ||
+                    (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT) ||
+                    (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
+            };
+        case "fileChange":
+            return {
+                value: {
+                    kind: call.kind,
+                    changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
+                },
+                truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
+            };
+        case "other":
+            return {
+                value: { kind: call.kind, display: boundedEventText(call.display) },
+                truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        default:
+            return call;
     }
 }
 function boundedToolResult(result) {
@@ -230,22 +266,28 @@ export function encodeAgentEvent(event) {
         ...(changed || ("truncated" in event && event.truncated === true) ? { truncated: true } : {}),
     });
     switch (event.type) {
-        case "session": return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
-        case "assistant": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
-        case "thought": return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
-        case "note": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
-        case "unknown": return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
+        case "session":
+            return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
+        case "assistant":
+            return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "thought":
+            return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
+        case "note":
+            return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "unknown":
+            return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
         case "tool": {
             const call = boundedToolCall(event.call);
             const name = boundedEventText(event.name);
             const result = event.phase === "completed" ? boundedToolResult(event.result) : undefined;
-            return marked(event.phase === "started" ? {
-                type: event.type,
-                id: event.id,
-                phase: event.phase,
-                name,
-                call: call.value,
-            }
+            return marked(event.phase === "started"
+                ? {
+                    type: event.type,
+                    id: event.id,
+                    phase: event.phase,
+                    name,
+                    call: call.value,
+                }
                 : {
                     type: event.type,
                     id: event.id,
@@ -255,7 +297,8 @@ export function encodeAgentEvent(event) {
                     result: result.value,
                 }, name !== event.name || call.truncated || result?.truncated === true);
         }
-        default: return event;
+        default:
+            return event;
     }
 }
 export function boundedEventText(value) {

package/build/src/akuma/providers/acp/config.js

@@ -12,16 +12,15 @@ export function decodeAcpConfig(value) {
         throw new TypeError("ACP provider config must be an object");
     }
     const config = value;
-    const unknown = Object.keys(config)
-        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg", "systemPromptMode"].includes(key));
+    const unknown = Object.keys(config).find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg", "systemPromptMode"].includes(key));
     if (unknown !== undefined)
         throw new TypeError(`ACP provider config has unknown field ${unknown}`);
-    if (!Array.isArray(config.argvBefore)
-        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+    if (!Array.isArray(config.argvBefore) ||
+        config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
         throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
     }
-    if (!Array.isArray(config.argvAfter)
-        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+    if (!Array.isArray(config.argvAfter) ||
+        config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
         throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
     }
     const modelArg = argumentName(config, "modelArg");

package/build/src/akuma/providers/acp/core.js

@@ -18,12 +18,14 @@ function diagnostic(acp, error) {
     return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
 }
 function createAcpClient(acp, onUpdate) {
-    return acp.client({ name: "keiyaku" })
+    return acp
+        .client({ name: "keiyaku" })
         .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
 }
 function promptResult(response) {
-    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens"
-        || response.stopReason === "max_turn_requests") {
+    if (response.stopReason === "end_turn" ||
+        response.stopReason === "max_tokens" ||
+        response.stopReason === "max_turn_requests") {
         return { kind: "answered", answer: "" };
     }
     return { kind: "failed", diagnostic: `ACP prompt ended ${response.stopReason}` };
@@ -62,7 +64,9 @@ function createAcpTurn(acp, connection, interpret) {
     let state = EMPTY_ACP_EVENT_STATE;
     let terminal = false;
     let resolveCompletion;
-    const completion = new Promise((resolve) => { resolveCompletion = resolve; });
+    const completion = new Promise((resolve) => {
+        resolveCompletion = resolve;
+    });
     const update = (next) => {
         if (terminal)
             return;
@@ -95,9 +99,7 @@ function createAcpTurn(acp, connection, interpret) {
         for (const event of flushed.events)
             events.emit(event);
         events.end();
-        resolveCompletion(completionResult.kind === "answered"
-            ? { ...completionResult, answer: flushed.state.answer }
-            : completionResult);
+        resolveCompletion(completionResult.kind === "answered" ? { ...completionResult, answer: flushed.state.answer } : completionResult);
     };
     return {
         events,
@@ -109,10 +111,15 @@ function createAcpTurn(acp, connection, interpret) {
 }
 function beginAcpPrompt(context, child, turn, sessionId, input) {
     const { acp, agent } = context;
-    void agent.request(acp.methods.agent.session.prompt, {
+    void agent
+        .request(acp.methods.agent.session.prompt, {
         sessionId,
-        prompt: [{ type: "text", text: input.body }, ...input.launchTells.map(({ text }) => ({ type: "text", text }))],
-    }).then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(acp, error) }, () => child.endInputAndDrain()));
+        prompt: [
+            { type: "text", text: input.body },
+            ...input.launchTells.map(({ text }) => ({ type: "text", text })),
+        ],
+    })
+        .then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(acp, error) }, () => child.endInputAndDrain()));
     void child.exited.then((exit) => turn.finish({
         kind: "failed",
         diagnostic: exit.stderr || `ACP process exited${exit.code === null ? "" : ` with code ${exit.code}`}`,

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

@@ -13,9 +13,7 @@ export function flushAcpEvents(state, boundary = []) {
     };
 }
 function appendBlock(state, type, text, messageId) {
-    const newAssistantMessage = type === "assistant"
-        && messageId !== undefined
-        && state.assistantMessageId !== messageId;
+    const newAssistantMessage = type === "assistant" && messageId !== undefined && state.assistantMessageId !== messageId;
     const flushed = state.open === null || (state.open.type === type && !newAssistantMessage)
         ? { events: [], state }
         : flushAcpEvents(state);
@@ -23,12 +21,8 @@ function appendBlock(state, type, text, messageId) {
         events: flushed.events,
         state: {
             ...flushed.state,
-            answer: type === "assistant"
-                ? `${newAssistantMessage ? "" : flushed.state.answer}${text}`
-                : flushed.state.answer,
-            assistantMessageId: type === "assistant" && messageId !== undefined
-                ? messageId
-                : flushed.state.assistantMessageId,
+            answer: type === "assistant" ? `${newAssistantMessage ? "" : flushed.state.answer}${text}` : flushed.state.answer,
+            assistantMessageId: type === "assistant" && messageId !== undefined ? messageId : flushed.state.assistantMessageId,
             open: { type, text: `${flushed.state.open?.text ?? ""}${text}` },
         },
     };
@@ -42,9 +36,7 @@ function object(value) {
         : undefined;
 }
 function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1
-        ? value
-        : undefined;
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
 }
 function otherCall(name) {
     return { kind: "other", display: name };
@@ -84,9 +76,7 @@ function standardCall(update, name) {
         const path = nonblank(input?.path);
         const glob = nonblank(input?.glob);
         const scope = input?.scope;
-        const searchScope = scope === "content" || scope === "files" || scope === "web"
-            ? scope
-            : undefined;
+        const searchScope = scope === "content" || scope === "files" || scope === "web" ? scope : undefined;
         return {
             kind: "search",
             query,
@@ -115,33 +105,52 @@ export function mapAcpUpdate(update, previous, interpret) {
             const text = update.content.type === "text" ? update.content.text : undefined;
             if (text === undefined)
                 return flushAcpEvents(previous, [unknownEvent(`${update.sessionUpdate}/${update.content.type}`)]);
-            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null
-                ? update.messageId
-                : undefined);
+            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null ? update.messageId : undefined);
         }
-        case "user_message_chunk": return flushAcpEvents(previous);
+        case "user_message_chunk":
+            return flushAcpEvents(previous);
         case "tool_call":
         case "tool_call_update": {
             const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
                 tools.delete(update.toolCallId);
-                return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
+                return flushAcpEvents({ ...previous, tools }, [
+                    {
+                        type: "tool",
+                        phase: "completed",
+                        id: update.toolCallId,
+                        ...observed,
+                        result: { status: update.status === "completed" ? "ok" : "error" },
+                    },
+                ]);
             }
             const started = tools.has(update.toolCallId);
             tools.set(update.toolCallId, observed);
             return started
                 ? flushAcpEvents({ ...previous, tools })
-                : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);
+                : flushAcpEvents({ ...previous, tools }, [
+                    { type: "tool", phase: "started", id: update.toolCallId, ...observed },
+                ]);
         }
-        case "plan": return flushAcpEvents(previous, [noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`)]);
-        case "available_commands_update": return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
-        case "current_mode_update": return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
-        case "config_option_update": return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
-        case "session_info_update": return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
-        case "usage_update": return flushAcpEvents(previous);
+        case "plan":
+            return flushAcpEvents(previous, [
+                noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`),
+            ]);
+        case "available_commands_update":
+            return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
+        case "current_mode_update":
+            return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
+        case "config_option_update":
+            return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
+        case "session_info_update":
+            return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
+        case "usage_update":
+            return flushAcpEvents(previous);
         case "plan_update":
-        case "plan_removed": return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
-        default: return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
+        case "plan_removed":
+            return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
+        default:
+            return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
     }
 }

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

@@ -15,20 +15,24 @@ function optionAdmission(options, config) {
         if (config.systemPromptArg === undefined) {
             return { kind: "refused", diagnostic: "ACP provider has no systemPrompt argument mapping" };
         }
-        if (options.systemPromptMode !== undefined
-            && options.systemPromptMode !== (config.systemPromptMode ?? "replace")) {
-            return { kind: "refused", diagnostic: "ACP provider systemPromptMode does not match the configured argument mode" };
+        if (options.systemPromptMode !== undefined && options.systemPromptMode !== (config.systemPromptMode ?? "replace")) {
+            return {
+                kind: "refused",
+                diagnostic: "ACP provider systemPromptMode does not match the configured argument mode",
+            };
         }
     }
     return {
         kind: "admitted",
         options,
-        ...(options.readonly === undefined ? {} : {
-            readonly: {
-                enforcement: "none",
-                diagnostic: "ACP cannot remove task-surface mutation capabilities",
-            },
-        }),
+        ...(options.readonly === undefined
+            ? {}
+            : {
+                readonly: {
+                    enforcement: "none",
+                    diagnostic: "ACP cannot remove task-surface mutation capabilities",
+                },
+            }),
     };
 }
 function argv(execution, config, options) {

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

@@ -1,4 +1,4 @@
-import { noteEvent, unknownEvent, } from "../../provider.js";
+import { noteEvent, unknownEvent } from "../../provider.js";
 export const CLAUDE_MESSAGE_DISPOSITIONS = {
     assistant: "assistant",
     auth_status: "auth",
@@ -181,9 +181,7 @@ function editResult(result) {
 }
 function notebookResult(result) {
     const path = nonblank(object(result)?.notebook_path);
-    return path === undefined
-        ? undefined
-        : { kind: "fileChange", changes: [{ op: "update", path }] };
+    return path === undefined ? undefined : { kind: "fileChange", changes: [{ op: "update", path }] };
 }
 function structuredFileChange(name, result) {
     if (name === "Write")
@@ -198,10 +196,9 @@ function toolCall(name, input) {
     if (run !== undefined)
         return run;
     const path = startedPath(name, value);
-    return readCall(name, path, value)
-        ?? searchCall(name, value)
-        ?? fileChangeCall(name, path)
-        ?? { kind: "other", display: name };
+    return (readCall(name, path, value) ??
+        searchCall(name, value) ??
+        fileChangeCall(name, path) ?? { kind: "other", display: name });
 }
 function assistantEvents(message, events, state) {
     if (message.aborted === true)
@@ -212,7 +209,8 @@ function assistantEvents(message, events, state) {
     }
     const text = message.message.content
         .filter((block) => block.type === "text")
-        .map((block) => block.text).join("");
+        .map((block) => block.text)
+        .join("");
     if (text.length > 0)
         events.emit({ type: "assistant", text });
     for (const block of message.message.content) {
@@ -244,9 +242,7 @@ function toolResultEvents(message, events, state) {
             continue;
         state.tools.delete(id);
         const failed = value.is_error === true;
-        const structured = failed
-            ? undefined
-            : structuredFileChange(observed.name, message.tool_use_result);
+        const structured = failed ? undefined : structuredFileChange(observed.name, message.tool_use_result);
         events.emit({
             type: "tool",
             phase: "completed",

package/build/src/akuma/providers/claude/index.d.ts

@@ -5,6 +5,7 @@ import type { ResumeCoordinate } from "../../provider.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
 type ClaudeExecution = Readonly<{
     executable?: string;
+    config?: Readonly<Record<string, unknown>>;
     env?: Readonly<Record<string, string>>;
 }>;
 export type ClaudeSdk = Readonly<{