@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,122 +1,10 @@
 import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
 import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
+import type { CatalogQuery } from "../index.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
+import { type ContractCommand as Command } from "./commands/contract.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 type { Command };
 export declare function renderRootHelp(): string;
 export declare function renderContractHelp(command: Command): string;
 export declare function renderCommandUsage(command: ParsedCommand): string;
@@ -145,6 +33,7 @@ export type ParsedDeliver = Output & Actor & Readonly<{
     command: "deliver";
     contract?: string;
     message?: string;
+    includeDirty: boolean;
 }>;
 export type ParsedReview = Output & Actor & Readonly<{
     command: "review";
@@ -171,10 +60,15 @@ type ParsedStatus = Output & (Readonly<{
     contract: string;
     akuma: true;
 }>);
+export type ParsedLs = Output & Readonly<{
+    command: "ls";
+    query: CatalogQuery;
+}>;
 export type ParsedAudit = Output & Readonly<{
     command: "audit";
     contract?: string;
-    showDiffBody: boolean;
+    includeDirty: boolean;
+    showDiff: boolean;
     actor?: string;
 }>;
 type ParsedReconcile = Output & Readonly<{
@@ -185,7 +79,16 @@ type ParsedReconcile = Output & Readonly<{
 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 ParsedRegion = Output & Readonly<{
+    command: "region";
+    contract?: string;
+    overlap: boolean;
+    path?: string;
+}>;
+export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | (Output & Readonly<{
+    command: "show";
+    contract?: string;
+}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{
@@ -202,6 +105,7 @@ export type CliHelpCoordinate = Readonly<{
 }>;
 export type ParsedExecution = Readonly<{
     cwd?: string;
+    repo?: string;
     command: ParsedCommand;
 }>;
 export type ParsedInvocation = ParsedExecution | Readonly<{

package/build/src/cli/parse.js

@@ -1,87 +1,17 @@
 import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
-import { isAkumaAction, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
-import { CliUsageError, usageLine } from "./usage.js";
+import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS } from "./commands/contract.js";
+import { CliUsageError, isBlankInput, 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 ...] [-]";
+const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
 export function renderRootHelp() {
     return [
         ROOT_USAGE,
         "",
         "global options:",
         "  -C, --cwd <path>  Set the invocation working directory.",
+        "  --repo <path>     Select the Git repository coordinate.",
         "",
         "commands:",
         ...Object.values(CONTRACT_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]),
@@ -94,7 +24,8 @@ export function renderRootHelp() {
 }
 export function renderContractHelp(command) {
     const spec = CONTRACT_COMMAND_SPECS[command];
-    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    return command === "amend" ? `${help}\n\n${AMEND_MINIMAL_STDIN_HELP}` : help;
 }
 function contractUsage(command) {
     return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
@@ -140,6 +71,8 @@ function scanOption(command, argv, state, index) {
     const value = argv[index + 1];
     if (value === undefined || value === "-" || value.startsWith("--"))
         refuse(command, `${token} requires a value`);
+    if (isBlankInput(value))
+        refuse(command, `${token} requires a nonblank value`);
     if (kind === "repeat-value") {
         const values = state.flags[name];
         state.flags[name] = [...(Array.isArray(values) ? values : values === undefined ? [] : [values]), value];
@@ -167,6 +100,8 @@ function scanArgv(argv) {
             index = scanOption(command, argv, state, index);
             continue;
         }
+        if (isBlankInput(token))
+            refuse(command, `${command} requires a nonblank value`);
         state.positionals.push(token);
     }
     if (spec.positional === "none" && state.positionals.length > 0) {
@@ -222,6 +157,7 @@ function parseDeliver(parts) {
         ...(contract === undefined ? {} : { contract }),
         ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         ...(message === undefined ? {} : { message }),
+        includeDirty: parts.flags["include-dirty"] === true,
         output: parts.output,
     };
 }
@@ -230,8 +166,9 @@ function parseReview(parts) {
         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");
+    if (parts.stdin === (summary !== undefined)) {
+        refuse("review", "review requires exactly one of --summary <text> or stdin '-'");
+    }
     const contract = parts.positionals[0];
     return {
         command: "review",
@@ -279,13 +216,50 @@ function parseStatus(parts) {
         output: parts.output,
     };
 }
+function parseShow(parts) {
+    const contract = parts.positionals[0];
+    return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
+}
+function parseRegion(parts) {
+    const contract = parts.positionals[0];
+    const path = optionalFlag(parts.flags, "path");
+    const overlap = parts.flags.overlap === true;
+    if (path !== undefined && (contract !== undefined || overlap))
+        refuse("region", "--path cannot combine with a contract or --overlap");
+    return {
+        command: "region",
+        ...(contract === undefined ? {} : { contract }),
+        ...(path === undefined ? {} : { path }),
+        overlap,
+        output: parts.output,
+    };
+}
+function parseLs(parts) {
+    const path = parts.positionals[0];
+    if (path === "task/")
+        return { command: "ls", query: { kind: "tasks" }, output: parts.output };
+    if (path === "kei/")
+        return { command: "ls", query: { kind: "contracts" }, output: parts.output };
+    try {
+        const query = parseAkumaCatalogPath(path);
+        if (query === null)
+            refuse("ls", "ls requires an identity directory with a trailing slash");
+        return { command: "ls", query, output: parts.output };
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        refuse("ls", error instanceof Error ? error.message : "invalid ls directory");
+    }
+}
 function invocationOptions(argv) {
     let cwd;
+    let repo;
     let stdinSeen = false;
     const commandArgv = [];
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
-        if (token !== "-C" && token !== "--cwd") {
+        if (token !== "-C" && token !== "--cwd" && token !== "--repo") {
             commandArgv.push(token);
             if (token === "-")
                 stdinSeen = true;
@@ -293,16 +267,27 @@ function invocationOptions(argv) {
         }
         if (stdinSeen)
             throw new CliUsageError("stdin marker '-' must be the final argument", renderRootHelp());
-        if (cwd !== undefined)
+        if (token === "--repo" && repo !== undefined) {
+            throw new CliUsageError("--repo may appear only once", renderRootHelp());
+        }
+        if (token !== "--repo" && cwd !== undefined) {
             throw new CliUsageError("-C/--cwd may appear only once", renderRootHelp());
+        }
         const value = argv[index + 1];
-        if (value === undefined || value === "-" || value.startsWith("-")) {
+        if (value === undefined || value === "-" || value.startsWith("-") || isBlankInput(value)) {
             throw new CliUsageError(`${token} requires a path`, renderRootHelp());
         }
-        cwd = value;
+        if (token === "--repo")
+            repo = value;
+        else
+            cwd = value;
         index += 1;
     }
-    return { ...(cwd === undefined ? {} : { cwd }), commandArgv };
+    return {
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(repo === undefined ? {} : { repo }),
+        commandArgv,
+    };
 }
 function helpCoordinate(argv) {
     const help = argv.indexOf("--help");
@@ -332,12 +317,15 @@ function parseCommand(parts) {
         case "arc": return parseArc(parts);
         case "abandon": return parseAbandon(parts);
         case "status": return parseStatus(parts);
+        case "show": return parseShow(parts);
+        case "ls": return parseLs(parts);
         case "audit": {
             const contract = parts.positionals[0];
             return {
                 command: "audit",
                 ...(contract === undefined ? {} : { contract }),
-                showDiffBody: parts.flags["show-diff-body"] === true,
+                includeDirty: parts.flags["include-dirty"] === true,
+                showDiff: parts.flags.diff === true,
                 ...(parts.actor === undefined ? {} : { actor: parts.actor }),
                 output: parts.output,
             };
@@ -352,6 +340,7 @@ function parseCommand(parts) {
             };
         }
         case "settings": return { command: "settings", output: parts.output };
+        case "region": return parseRegion(parts);
     }
 }
 export function parseArgv(argv) {
@@ -359,6 +348,11 @@ export function parseArgv(argv) {
     const help = helpCoordinate(invocation.commandArgv);
     if (help !== null)
         return { help };
+    if (invocation.commandArgv[0] === "ls"
+        && (invocation.commandArgv.length === 1
+            || (invocation.commandArgv.length === 2 && invocation.commandArgv[1] === "--json"))) {
+        return { help: { kind: "contract", command: "ls" } };
+    }
     const task = invocation.commandArgv[0] === "task"
         ? parseTaskCommand(invocation.commandArgv.slice(1))
         : undefined;
@@ -370,6 +364,7 @@ export function parseArgv(argv) {
         : undefined;
     return {
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
         command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
     };
 }

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

@@ -0,0 +1,6 @@
+/**
+ * Unwrap only complete provider transport launchers. This is deliberately not
+ * a shell parser: uncertainty preserves the persisted command's presentation.
+ */
+/** Return a display subject only when the full transport shape is unambiguous. */
+export declare function normalizeToolCommand(command: string): string;

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

@@ -0,0 +1,144 @@
+/**
+ * Unwrap only complete provider transport launchers. This is deliberately not
+ * a shell parser: uncertainty preserves the persisted command's presentation.
+ */
+const HORIZONTAL_WHITESPACE = new Set([" ", "\t"]);
+const UNSUPPORTED_UNQUOTED = new Set(["$", "`", "|", "&", ";", "<", ">", "(", ")"]);
+const DOUBLE_QUOTE_ESCAPES = new Set(["\"", "\\", "$", "`"]);
+const POWERSHELL_OPTION_FLAGS = new Set(["-nologo", "-noprofile"]);
+const POWERSHELL_COMMAND_FLAGS = new Set(["-command", "-c"]);
+const SCAN_FAIL = { ok: false };
+function scanned(index, value) {
+    return { ok: true, index, value };
+}
+function isLineBoundary(character) {
+    return character === "\n" || character === "\r";
+}
+function isAbsoluteExecutable(value) {
+    return value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value);
+}
+function executableName(value) {
+    const segments = value.split(/[\\/]/u);
+    return segments[segments.length - 1].toLowerCase();
+}
+function isBashOrZsh(value) {
+    const name = executableName(value);
+    return (value === "bash" || value === "zsh" || isAbsoluteExecutable(value))
+        && (name === "bash" || name === "zsh");
+}
+function isPowerShell(value) {
+    const name = executableName(value);
+    return (value.toLowerCase() === "powershell" || value.toLowerCase() === "pwsh" || isAbsoluteExecutable(value))
+        && (name === "powershell" || name === "powershell.exe" || name === "pwsh" || name === "pwsh.exe");
+}
+function scanSingleQuoted(command, index) {
+    const end = command.indexOf("'", index + 1);
+    return end < 0 ? SCAN_FAIL : scanned(end + 1, command.slice(index + 1, end));
+}
+function scanDoubleQuotedEscape(command, index) {
+    const next = command[index + 1];
+    if (next === undefined || isLineBoundary(next))
+        return SCAN_FAIL;
+    return scanned(index + 2, DOUBLE_QUOTE_ESCAPES.has(next) ? next : `\\${next}`);
+}
+function scanDoubleQuoted(command, index) {
+    let cursor = index + 1;
+    let value = "";
+    while (cursor < command.length) {
+        const quoted = command[cursor];
+        if (quoted === "\"")
+            return scanned(cursor + 1, value);
+        if (quoted === "$" || quoted === "`")
+            return SCAN_FAIL;
+        if (quoted === "\\") {
+            const escaped = scanDoubleQuotedEscape(command, cursor);
+            if (!escaped.ok)
+                return SCAN_FAIL;
+            value += escaped.value;
+            cursor = escaped.index;
+            continue;
+        }
+        value += quoted;
+        cursor += 1;
+    }
+    return SCAN_FAIL;
+}
+function scanUnquotedEscape(command, index) {
+    const next = command[index + 1];
+    if (next === undefined || isLineBoundary(next))
+        return SCAN_FAIL;
+    return scanned(index + 2, next);
+}
+function scanTokenSegment(command, index) {
+    const character = command[index];
+    if (isLineBoundary(character) || UNSUPPORTED_UNQUOTED.has(character))
+        return SCAN_FAIL;
+    if (character === "'")
+        return scanSingleQuoted(command, index);
+    if (character === "\"")
+        return scanDoubleQuoted(command, index);
+    if (character === "\\")
+        return scanUnquotedEscape(command, index);
+    return scanned(index + 1, character);
+}
+function scanToken(command, index) {
+    let cursor = index;
+    let value = "";
+    let consumed = false;
+    while (cursor < command.length && !HORIZONTAL_WHITESPACE.has(command[cursor])) {
+        const segment = scanTokenSegment(command, cursor);
+        if (!segment.ok)
+            return SCAN_FAIL;
+        value += segment.value;
+        cursor = segment.index;
+        consumed = true;
+    }
+    return consumed ? scanned(cursor, value) : SCAN_FAIL;
+}
+function parseTransportArgv(command) {
+    const argv = [];
+    let index = 0;
+    while (index < command.length) {
+        while (HORIZONTAL_WHITESPACE.has(command[index]))
+            index += 1;
+        if (index === command.length)
+            break;
+        if (isLineBoundary(command[index]))
+            return undefined;
+        const token = scanToken(command, index);
+        if (!token.ok)
+            return undefined;
+        argv.push(token.value);
+        index = token.index;
+    }
+    return argv;
+}
+function unwrapBashOrZsh(argv) {
+    const [shell, flag, script] = argv;
+    if (argv.length !== 3 || !shell || !script || !isBashOrZsh(shell))
+        return undefined;
+    return flag === "-c" || flag === "-lc" ? script : undefined;
+}
+function unwrapPowerShell(argv) {
+    const [shell, ...arguments_] = argv;
+    if (!shell || !isPowerShell(shell) || arguments_.length < 2)
+        return undefined;
+    const options = new Set();
+    for (let index = 0; index < arguments_.length - 1; index += 1) {
+        const flag = arguments_[index].toLowerCase();
+        if (POWERSHELL_COMMAND_FLAGS.has(flag)) {
+            return index === arguments_.length - 2 && arguments_[index + 1] ? arguments_[index + 1] : undefined;
+        }
+        if (!POWERSHELL_OPTION_FLAGS.has(flag) || options.has(flag))
+            return undefined;
+        options.add(flag);
+    }
+    return undefined;
+}
+/** Return a display subject only when the full transport shape is unambiguous. */
+export function normalizeToolCommand(command) {
+    const argv = parseTransportArgv(command);
+    if (!argv)
+        return command;
+    return unwrapBashOrZsh(argv) ?? unwrapPowerShell(argv) ?? command;
+}

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

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

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

@@ -1,3 +1,4 @@
+import { normalizeToolCommand } from "./akuma-tool-command.js";
 function oneLine(value) {
     return value.replace(/\s+/gu, " ").trim();
 }
@@ -12,7 +13,7 @@ function duration(milliseconds) {
     return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
 }
 function result(row) {
-    if (row.state === "running")
+    if (row.state === "active" || row.state === "unsettled")
         return undefined;
     const disposition = row.state.exitCode !== undefined
         ? row.state.exitCode === 0 ? "ok" : `exit ${row.state.exitCode}`
@@ -24,6 +25,31 @@ function result(row) {
     ];
     return parts.length === 0 ? undefined : parts.join(" · ");
 }
+function readText(call) {
+    const path = oneLine(call.path);
+    if (call.offset !== undefined && call.limit !== undefined) {
+        return `${path} · L${call.offset}-${call.offset + call.limit - 1}`;
+    }
+    if (call.offset !== undefined)
+        return `${path} · from L${call.offset}`;
+    if (call.limit !== undefined)
+        return `${path} · ${call.limit} lines`;
+    return path;
+}
+function searchLabel(scope) {
+    if (scope === "files")
+        return "find";
+    if (scope === "web")
+        return "web";
+    return "search";
+}
+function searchText(call) {
+    return [
+        oneLine(call.query),
+        ...(call.path === undefined ? [] : [oneLine(call.path)]),
+        ...(call.glob === undefined ? [] : [oneLine(call.glob)]),
+    ].join(" · ");
+}
 function fileChange(call) {
     const first = call.changes[0];
     if (first === undefined)
@@ -48,13 +74,13 @@ export function toolRepr(row) {
     let core;
     switch (row.call.kind) {
         case "run":
-            core = { label: "run", text: `$ ${oneLine(row.call.command)}` };
+            core = { label: "run", text: `$ ${oneLine(normalizeToolCommand(row.call.command))}`, overflow: "middle-ellipsis" };
             break;
         case "read":
-            core = { label: "read", text: oneLine(row.call.path) };
+            core = { label: "read", text: readText(row.call) };
             break;
         case "search":
-            core = { label: "search", text: oneLine(row.call.query) };
+            core = { label: searchLabel(row.call.scope), text: searchText(row.call) };
             break;
         case "fileChange":
             core = fileChange(row.call);
@@ -64,5 +90,9 @@ export function toolRepr(row) {
             break;
     }
     const suffix = result(row);
-    return suffix === undefined ? core : { ...core, text: `${core.text} — ${suffix}` };
+    if (suffix === undefined)
+        return core;
+    return core.overflow === "middle-ellipsis"
+        ? { ...core, suffix: ` — ${suffix}` }
+        : { ...core, text: `${core.text} — ${suffix}` };
 }