@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/src/cli/parse.d.ts

@@ -0,0 +1,210 @@
+import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
+import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
+import { type ParsedInstallCommand } from "./commands/install.js";
+export { CliUsageError } from "./usage.js";
+declare const CONTRACT_COMMAND_SPECS: {
+    readonly bind: {
+        readonly positional: "none";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly task: "value";
+            readonly target: "value";
+            readonly here: "boolean";
+            readonly after: "repeat-value";
+            readonly gates: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly purpose: "Create one Contract from stdin Markdown.";
+    };
+    readonly amend: {
+        readonly positional: "optional";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly after: "repeat-value";
+            readonly "clear-after": "boolean";
+            readonly gates: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly purpose: "Apply stdin amendment operations to one Contract.";
+    };
+    readonly deliver: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly actor: "value";
+            readonly message: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--actor <actor>] [--json]";
+        readonly purpose: "Deliver one Contract candidate.";
+    };
+    readonly review: {
+        readonly positional: "optional";
+        readonly stdin: "optional";
+        readonly flags: {
+            readonly actor: "value";
+            readonly satisfied: "boolean";
+            readonly unsatisfied: "boolean";
+            readonly summary: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) [--summary <text>] [--actor <actor>] [--json] [-]";
+        readonly purpose: "Record one review verdict.";
+    };
+    readonly arc: {
+        readonly positional: "optional";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -";
+        readonly purpose: "Record stdin arc Markdown for one Contract.";
+    };
+    readonly abandon: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly actor: "value";
+            readonly note: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]";
+        readonly purpose: "Abandon one Contract with an optional note.";
+    };
+    readonly status: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "status [<contract>|@<contract>|<aku/...>] [--json]";
+        readonly purpose: "Read the world status board or one Contract projection.";
+    };
+    readonly audit: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "show-diff-body": "boolean";
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]";
+        readonly purpose: "Audit one Contract without mutation.";
+    };
+    readonly reconcile: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "retry-hooks": "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]";
+        readonly purpose: "Reconcile one Contract or the invocation world.";
+    };
+    readonly settings: {
+        readonly positional: "none";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "settings [--json]";
+        readonly purpose: "Read user and project Settings resources.";
+    };
+};
+export type Command = keyof typeof CONTRACT_COMMAND_SPECS;
+export declare function renderRootHelp(): string;
+export declare function renderContractHelp(command: Command): string;
+export declare function renderCommandUsage(command: ParsedCommand): string;
+type Output = Readonly<{
+    output: "text" | "json";
+}>;
+type Actor = Readonly<{
+    actor?: string;
+}>;
+export type ParsedBind = Output & Actor & Readonly<{
+    command: "bind";
+    task?: string;
+    target?: string;
+    workspace?: "here";
+    after?: readonly string[];
+    gates?: string;
+}>;
+export type ParsedAmend = Output & Actor & Readonly<{
+    command: "amend";
+    contract?: string;
+    after?: readonly string[];
+    clearAfter?: true;
+    gates?: string;
+}>;
+export type ParsedDeliver = Output & Actor & Readonly<{
+    command: "deliver";
+    contract?: string;
+    message?: string;
+}>;
+export type ParsedReview = Output & Actor & Readonly<{
+    command: "review";
+    contract?: string;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+    summaryFromStdin?: true;
+}>;
+export type ParsedArc = Output & Actor & Readonly<{
+    command: "arc";
+    contract?: string;
+}>;
+export type ParsedAbandon = Output & Actor & Readonly<{
+    command: "abandon";
+    contract?: string;
+    note?: string;
+}>;
+type ParsedStatus = Output & (Readonly<{
+    command: "status";
+    contract?: string;
+    akuma?: never;
+}> | Readonly<{
+    command: "status";
+    contract: string;
+    akuma: true;
+}>);
+export type ParsedAudit = Output & Readonly<{
+    command: "audit";
+    contract?: string;
+    showDiffBody: boolean;
+    actor?: string;
+}>;
+type ParsedReconcile = Output & Readonly<{
+    command: "reconcile";
+    contract?: string;
+    retryHooks: boolean;
+}>;
+export type ParsedSettings = Output & Readonly<{
+    command: "settings";
+}>;
+export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedAudit | ParsedReconcile | ParsedSettings | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+export type CliHelpCoordinate = Readonly<{
+    kind: "root";
+}> | Readonly<{
+    kind: "contract";
+    command: Command;
+}> | Readonly<{
+    kind: "task";
+    action?: TaskAction;
+}> | Readonly<{
+    kind: "install";
+}> | Readonly<{
+    kind: "akuma";
+    action: AkumaAction;
+}>;
+export type ParsedExecution = Readonly<{
+    cwd?: string;
+    command: ParsedCommand;
+}>;
+export type ParsedInvocation = ParsedExecution | Readonly<{
+    help: CliHelpCoordinate;
+}>;
+export declare function parseArgv(argv: readonly string[]): ParsedInvocation;

package/build/src/cli/parse.js

@@ -0,0 +1,375 @@
+import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
+import { isAkumaAction, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
+import { CliUsageError, usageLine } from "./usage.js";
+export { CliUsageError } from "./usage.js";
+const CONTRACT_COMMAND_SPECS = {
+    bind: {
+        positional: "none",
+        stdin: "required",
+        flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "value", json: "boolean" },
+        usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -",
+        purpose: "Create one Contract from stdin Markdown.",
+    },
+    amend: {
+        positional: "optional",
+        stdin: "required",
+        flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" },
+        usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -",
+        purpose: "Apply stdin amendment operations to one Contract.",
+    },
+    deliver: {
+        positional: "optional",
+        stdin: "none",
+        flags: { actor: "value", message: "value", json: "boolean" },
+        usage: "deliver [<contract>|@<contract>] [--message <text>] [--actor <actor>] [--json]",
+        purpose: "Deliver one Contract candidate.",
+    },
+    review: {
+        positional: "optional",
+        stdin: "optional",
+        flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
+        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) [--summary <text>] [--actor <actor>] [--json] [-]",
+        purpose: "Record one review verdict.",
+    },
+    arc: {
+        positional: "optional",
+        stdin: "required",
+        flags: { actor: "value", json: "boolean" },
+        usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -",
+        purpose: "Record stdin arc Markdown for one Contract.",
+    },
+    abandon: {
+        positional: "optional",
+        stdin: "none",
+        flags: { actor: "value", note: "value", json: "boolean" },
+        usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]",
+        purpose: "Abandon one Contract with an optional note.",
+    },
+    status: {
+        positional: "optional",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: "status [<contract>|@<contract>|<aku/...>] [--json]",
+        purpose: "Read the world status board or one Contract projection.",
+    },
+    audit: {
+        positional: "optional",
+        stdin: "none",
+        flags: { "show-diff-body": "boolean", actor: "value", json: "boolean" },
+        usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]",
+        purpose: "Audit one Contract without mutation.",
+    },
+    reconcile: {
+        positional: "optional",
+        stdin: "none",
+        flags: { "retry-hooks": "boolean", json: "boolean" },
+        usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]",
+        purpose: "Reconcile one Contract or the invocation world.",
+    },
+    settings: {
+        positional: "none",
+        stdin: "none",
+        flags: { json: "boolean" },
+        usage: "settings [--json]",
+        purpose: "Read user and project Settings resources.",
+    },
+};
+const ROOT_USAGE = "usage: keiyaku [-C <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
+export function renderRootHelp() {
+    return [
+        ROOT_USAGE,
+        "",
+        "global options:",
+        "  -C, --cwd <path>  Set the invocation working directory.",
+        "",
+        "commands:",
+        ...Object.values(CONTRACT_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]),
+        `  ${INSTALL_USAGE}`,
+        "    Install the Keiyaku skills into an agent harness.",
+        "  task ...",
+        "    Task coordination; see `keiyaku task --help`.",
+        ...renderAkumaRootRows(),
+    ].join("\n");
+}
+export function renderContractHelp(command) {
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+}
+function contractUsage(command) {
+    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+}
+export function renderCommandUsage(command) {
+    if (command.command === "install")
+        return renderInstallHelp();
+    if (command.command === "task")
+        return renderTaskUsage(command.action);
+    if (isAkumaAction(command.command))
+        return renderAkumaUsage(command.command);
+    return contractUsage(command.command);
+}
+function optionalFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function refuse(command, message) {
+    throw new CliUsageError(message, contractUsage(command));
+}
+function scanStdin(command, state, index, length) {
+    if (state.stdin)
+        refuse(command, "stdin marker '-' may appear only once");
+    if (index !== length - 1)
+        refuse(command, "stdin marker '-' must be the final argument");
+    if (CONTRACT_COMMAND_SPECS[command].stdin === "none")
+        refuse(command, `${command} reads no stdin`);
+    state.stdin = true;
+}
+function scanOption(command, argv, state, index) {
+    const token = argv[index];
+    const name = token.slice(2);
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    const kind = spec.flags[name];
+    if (kind === undefined)
+        refuse(command, `option ${token} is not valid for ${command}`);
+    if (state.flags[name] !== undefined && kind !== "repeat-value")
+        refuse(command, `duplicate option: ${token}`);
+    if (kind === "boolean") {
+        state.flags[name] = true;
+        return index;
+    }
+    const value = argv[index + 1];
+    if (value === undefined || value === "-" || value.startsWith("--"))
+        refuse(command, `${token} requires a value`);
+    if (kind === "repeat-value") {
+        const values = state.flags[name];
+        state.flags[name] = [...(Array.isArray(values) ? values : values === undefined ? [] : [values]), value];
+    }
+    else {
+        state.flags[name] = value;
+    }
+    return index + 1;
+}
+function scanArgv(argv) {
+    const candidate = argv[0];
+    if (!candidate || !Object.prototype.hasOwnProperty.call(CONTRACT_COMMAND_SPECS, candidate)) {
+        throw new CliUsageError(`unknown command: ${candidate ?? ""}`, renderRootHelp());
+    }
+    const command = candidate;
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    const state = { flags: {}, positionals: [], stdin: false };
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-") {
+            scanStdin(command, state, index, argv.length);
+            continue;
+        }
+        if (token.startsWith("--")) {
+            index = scanOption(command, argv, state, index);
+            continue;
+        }
+        state.positionals.push(token);
+    }
+    if (spec.positional === "none" && state.positionals.length > 0) {
+        refuse(command, `${command} accepts no contract`);
+    }
+    if (spec.positional === "optional" && state.positionals.length > 1) {
+        refuse(command, `${command} accepts at most one contract`);
+    }
+    if (spec.stdin === "required" && !state.stdin) {
+        refuse(command, `${command} requires stdin`);
+    }
+    const output = state.flags.json === true ? "json" : "text";
+    const actor = optionalFlag(state.flags, "actor");
+    return { command, ...state, output, ...(actor === undefined ? {} : { actor }) };
+}
+function parseBind(parts) {
+    const task = optionalFlag(parts.flags, "task");
+    const target = optionalFlag(parts.flags, "target");
+    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
+    const gates = optionalFlag(parts.flags, "gates");
+    return {
+        command: "bind",
+        ...(task === undefined ? {} : { task }),
+        ...(target === undefined ? {} : { target }),
+        ...(parts.flags.here === true ? { workspace: "here" } : {}),
+        ...(parts.flags.after === undefined ? {} : { after }),
+        ...(gates === undefined ? {} : { gates }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseAmend(parts) {
+    const contract = parts.positionals[0];
+    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
+    if (parts.flags["clear-after"] === true && after.length > 0)
+        refuse("amend", "--clear-after and --after are mutually exclusive");
+    const gates = optionalFlag(parts.flags, "gates");
+    return {
+        command: "amend",
+        ...(contract === undefined ? {} : { contract }),
+        ...(parts.flags.after === undefined ? {} : { after }),
+        ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
+        ...(gates === undefined ? {} : { gates }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseDeliver(parts) {
+    const contract = parts.positionals[0];
+    const message = optionalFlag(parts.flags, "message");
+    return {
+        command: "deliver",
+        ...(contract === undefined ? {} : { contract }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        ...(message === undefined ? {} : { message }),
+        output: parts.output,
+    };
+}
+function parseReview(parts) {
+    if (Number(parts.flags.satisfied === true) + Number(parts.flags.unsatisfied === true) !== 1) {
+        refuse("review", "review requires exactly one verdict flag");
+    }
+    const summary = optionalFlag(parts.flags, "summary");
+    if (parts.stdin && summary !== undefined)
+        refuse("review", "review stdin '-' and --summary are mutually exclusive");
+    const contract = parts.positionals[0];
+    return {
+        command: "review",
+        ...(contract === undefined ? {} : { contract }),
+        verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
+        ...(summary === undefined ? {} : { summary }),
+        ...(parts.stdin ? { summaryFromStdin: true } : {}),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseArc(parts) {
+    const contract = parts.positionals[0];
+    return {
+        command: "arc",
+        ...(contract === undefined ? {} : { contract }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseAbandon(parts) {
+    const contract = parts.positionals[0];
+    const note = optionalFlag(parts.flags, "note");
+    return {
+        command: "abandon",
+        ...(contract === undefined ? {} : { contract }),
+        ...(note === undefined ? {} : { note }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseStatus(parts) {
+    const contract = parts.positionals[0];
+    if (contract?.startsWith("aku/") === true) {
+        return {
+            command: "status",
+            contract,
+            akuma: true,
+            output: parts.output,
+        };
+    }
+    return {
+        command: "status",
+        ...(contract === undefined ? {} : { contract }),
+        output: parts.output,
+    };
+}
+function invocationOptions(argv) {
+    let cwd;
+    let stdinSeen = false;
+    const commandArgv = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token !== "-C" && token !== "--cwd") {
+            commandArgv.push(token);
+            if (token === "-")
+                stdinSeen = true;
+            continue;
+        }
+        if (stdinSeen)
+            throw new CliUsageError("stdin marker '-' must be the final argument", renderRootHelp());
+        if (cwd !== undefined)
+            throw new CliUsageError("-C/--cwd may appear only once", renderRootHelp());
+        const value = argv[index + 1];
+        if (value === undefined || value === "-" || value.startsWith("-")) {
+            throw new CliUsageError(`${token} requires a path`, renderRootHelp());
+        }
+        cwd = value;
+        index += 1;
+    }
+    return { ...(cwd === undefined ? {} : { cwd }), commandArgv };
+}
+function helpCoordinate(argv) {
+    const help = argv.indexOf("--help");
+    if (help < 0)
+        return null;
+    const words = argv.slice(0, help);
+    const root = words[0];
+    if (root === "task") {
+        const action = isTaskAction(words[1]) ? words[1] : undefined;
+        return { kind: "task", ...(action === undefined ? {} : { action }) };
+    }
+    if (root === "install")
+        return { kind: "install" };
+    if (isAkumaAction(root))
+        return { kind: "akuma", action: root };
+    if (root !== undefined && Object.hasOwn(CONTRACT_COMMAND_SPECS, root)) {
+        return { kind: "contract", command: root };
+    }
+    return { kind: "root" };
+}
+function parseCommand(parts) {
+    switch (parts.command) {
+        case "bind": return parseBind(parts);
+        case "amend": return parseAmend(parts);
+        case "deliver": return parseDeliver(parts);
+        case "review": return parseReview(parts);
+        case "arc": return parseArc(parts);
+        case "abandon": return parseAbandon(parts);
+        case "status": return parseStatus(parts);
+        case "audit": {
+            const contract = parts.positionals[0];
+            return {
+                command: "audit",
+                ...(contract === undefined ? {} : { contract }),
+                showDiffBody: parts.flags["show-diff-body"] === true,
+                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+                output: parts.output,
+            };
+        }
+        case "reconcile": {
+            const contract = parts.positionals[0];
+            return {
+                command: "reconcile",
+                ...(contract === undefined ? {} : { contract }),
+                retryHooks: parts.flags["retry-hooks"] === true,
+                output: parts.output,
+            };
+        }
+        case "settings": return { command: "settings", output: parts.output };
+    }
+}
+export function parseArgv(argv) {
+    const invocation = invocationOptions(argv);
+    const help = helpCoordinate(invocation.commandArgv);
+    if (help !== null)
+        return { help };
+    const task = invocation.commandArgv[0] === "task"
+        ? parseTaskCommand(invocation.commandArgv.slice(1))
+        : undefined;
+    const install = invocation.commandArgv[0] === "install"
+        ? parseInstallCommand(invocation.commandArgv.slice(1))
+        : undefined;
+    const akuma = isAkumaAction(invocation.commandArgv[0])
+        ? parseAkumaCommand(invocation.commandArgv)
+        : undefined;
+    return {
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
+    };
+}

package/build/src/cli/render/akuma-tool.d.ts

@@ -0,0 +1,11 @@
+import type { ActivityRow } from "../../akuma/index.js";
+type ToolRow = Extract<ActivityRow, {
+    kind: "tool";
+}>;
+export type ToolRepr = Readonly<{
+    label: string;
+    text: string;
+}>;
+/** Pure provider-neutral tool presentation; it performs no activity selection. */
+export declare function toolRepr(row: ToolRow): ToolRepr;
+export {};

package/build/src/cli/render/akuma-tool.js

@@ -0,0 +1,68 @@
+function oneLine(value) {
+    return value.replace(/\s+/gu, " ").trim();
+}
+function duration(milliseconds) {
+    if (milliseconds < 1_000)
+        return `${milliseconds}ms`;
+    const seconds = Math.round(milliseconds / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+function result(row) {
+    if (row.state === "running")
+        return undefined;
+    const disposition = row.state.exitCode !== undefined
+        ? row.state.exitCode === 0 ? "ok" : `exit ${row.state.exitCode}`
+        : row.state.status;
+    const parts = [
+        ...(row.call.kind === "run" && row.durationMs !== undefined ? [duration(row.durationMs)] : []),
+        ...(row.call.kind === "fileChange" && disposition === "ok" ? [] : [disposition]),
+        ...(row.state.message === undefined ? [] : [oneLine(row.state.message)]),
+    ];
+    return parts.length === 0 ? undefined : parts.join(" · ");
+}
+function fileChange(call) {
+    const first = call.changes[0];
+    if (first === undefined)
+        return { label: "edit", text: "files" };
+    const label = call.changes.length === 1
+        ? first.op === "add" ? "write" : first.op === "delete" ? "delete" : "edit"
+        : "edit";
+    const subject = call.changes.length === 1
+        ? oneLine(first.path)
+        : `${call.changes.length} files · ${oneLine(first.path)} ...`;
+    const complete = call.changes.every((change) => change.diffstat !== undefined);
+    if (!complete)
+        return { label, text: subject };
+    const totals = call.changes.reduce((sum, change) => ({
+        added: sum.added + change.diffstat.added,
+        removed: sum.removed + change.diffstat.removed,
+    }), { added: 0, removed: 0 });
+    return { label, text: `${subject} — +${totals.added} -${totals.removed}` };
+}
+/** Pure provider-neutral tool presentation; it performs no activity selection. */
+export function toolRepr(row) {
+    let core;
+    switch (row.call.kind) {
+        case "run":
+            core = { label: "run", text: `$ ${oneLine(row.call.command)}` };
+            break;
+        case "read":
+            core = { label: "read", text: oneLine(row.call.path) };
+            break;
+        case "search":
+            core = { label: "search", text: oneLine(row.call.query) };
+            break;
+        case "fileChange":
+            core = fileChange(row.call);
+            break;
+        case "other":
+            core = { label: "use", text: oneLine(row.call.display || row.name) };
+            break;
+    }
+    const suffix = result(row);
+    return suffix === undefined ? core : { ...core, text: `${core.text} — ${suffix}` };
+}

package/build/src/cli/render/akuma.d.ts

@@ -0,0 +1,6 @@
+import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
+import type { ParsedCommand } from "../parse.js";
+export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult): string;
+export declare function akumaExitCode(result: AkumaInvocationResult): number;
+export declare function akumaJsonValue(command: ParsedCommand, result: AkumaInvocationResult): unknown;
+export declare function renderAkumaJson(command: ParsedCommand, result: AkumaInvocationResult): string;