@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/cli/main.js

@@ -1,13 +1,20 @@
+import { AkumaWorldScopeError } from "../index.js";
 import { CliUsageError, parseArgv, renderContractHelp, renderRootHelp, } from "./parse.js";
 import { renderText } from "./render/text.js";
 import { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } from "./render/task.js";
-import { akumaExitCode, renderAkumaJson, renderAkumaText } from "./render/akuma.js";
+import { akumaExitCode, akumaRawAnswer, renderAkumaJson, renderAkumaText } from "./render/akuma.js";
 import { isParsedAkumaCommand, renderAkumaHelp } from "./commands/akuma.js";
 import { installExitCode, renderInstallHelp, renderInstallText } from "./commands/install.js";
 import { renderTaskHelp } from "./commands/task.js";
 import { renderSettingsText, settingsJsonValue } from "./render/settings.js";
 import { renderCatalogText } from "./render/catalog.js";
+import { BindDraftError } from "./draft.js";
+import { renderBindDraftReceipt } from "./render/refusal.js";
 function writeTask(command, result) {
+    const context = {
+        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+        color: false,
+    };
     if (command.output === "json")
         process.stdout.write(`${JSON.stringify(result)}\n`);
     else if (command.action === "compose" && typeof result === "object" && result !== null && "kind" in result && result.kind === "incomplete") {
@@ -17,7 +24,7 @@ function writeTask(command, result) {
         process.stdout.write(result.draft);
     }
     else
-        process.stdout.write(`${renderTaskText(command, result)}\n`);
+        process.stdout.write(`${renderTaskText(command, result, context)}\n`);
     return taskExitCode(result);
 }
 function writeAkuma(command, result) {
@@ -25,8 +32,9 @@ function writeAkuma(command, result) {
         columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
         color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
     });
-    const rawLast = command.command === "history" && command.last && command.output === "text";
-    process.stdout.write(rawLast ? output : `${output}\n`);
+    const raw = command.output === "text"
+        && ((command.command === "history" && command.last) || akumaRawAnswer(result) !== undefined);
+    process.stdout.write(raw ? output : `${output}\n`);
     return akumaExitCode(result);
 }
 function renderHelp(coordinate) {
@@ -49,6 +57,7 @@ function writeCatalog(command, result) {
     process.stdout.write(`${command.output === "json" ? JSON.stringify(result.catalog) : renderCatalogText(result.catalog)}\n`);
     return 0;
 }
+// eslint-disable-next-line complexity -- output dispatch is the single CLI presentation boundary.
 function writeResult(command, result) {
     if (command.command === "install") {
         const value = result;
@@ -71,6 +80,11 @@ function writeResult(command, result) {
         return writeGuidance(command, contractResult);
     if (contractResult.kind === "catalog")
         return writeCatalog(command, contractResult);
+    if (contractResult.kind === "region") {
+        const output = command.output === "json" ? JSON.stringify(contractResult.region) : renderText(contractResult);
+        process.stdout.write(`${output}\n`);
+        return 0;
+    }
     const output = command.output === "json"
         ? JSON.stringify(contractResult.kind === "status" ? contractResult.report : contractResult)
         : renderText(contractResult, {
@@ -80,19 +94,33 @@ function writeResult(command, result) {
     process.stdout.write(`${output}\n`);
     return contractResult.kind === "refused" ? 1 : contractResult.kind === "retry" ? 2 : 0;
 }
+function writeWorldScopeRefusal(error, output) {
+    const body = output === "json"
+        ? JSON.stringify(error.refusal)
+        : `${error.refusal.kind} ${error.refusal.world} ${error.refusal.ids.join(" ")}`;
+    process.stderr.write(`${body}\n`);
+    return 1;
+}
 export async function main(argv = process.argv.slice(2)) {
+    let output = "text";
     try {
         const parsed = parseArgv(argv);
         if ("help" in parsed) {
             process.stdout.write(`${renderHelp(parsed.help)}\n`);
             return 0;
         }
+        output = parsed.command.output;
         const { invoke } = await import("./invoke.js");
         const result = await invoke(parsed, { cwd: process.cwd() });
         return writeResult(parsed.command, result);
     }
     catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return error instanceof CliUsageError ? 1 : 3;
+        if (error instanceof AkumaWorldScopeError)
+            return writeWorldScopeRefusal(error, output);
+        const original = error instanceof BindDraftError ? error.original : error;
+        process.stderr.write(`${original instanceof Error ? original.message : String(original)}\n`);
+        if (error instanceof BindDraftError)
+            process.stderr.write(`${renderBindDraftReceipt(error.draft)}\n`);
+        return original instanceof CliUsageError ? 1 : 3;
     }
 }

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

@@ -67,7 +67,8 @@ export type ParsedLs = Output & Readonly<{
 export type ParsedAudit = Output & Readonly<{
     command: "audit";
     contract?: string;
-    showDiffBody: boolean;
+    includeDirty: boolean;
+    showDiff: boolean;
     actor?: string;
 }>;
 type ParsedReconcile = Output & Readonly<{
@@ -78,10 +79,16 @@ type ParsedReconcile = Output & Readonly<{
 export type ParsedSettings = Output & Readonly<{
     command: "settings";
 }>;
+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 | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{

package/build/src/cli/parse.js

@@ -1,8 +1,8 @@
 import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
 import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
-import { CONTRACT_COMMAND_SPECS } from "./commands/contract.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 ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
 export function renderRootHelp() {
@@ -24,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);
@@ -70,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];
@@ -97,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) {
@@ -161,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",
@@ -214,6 +220,20 @@ 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/")
@@ -254,7 +274,7 @@ function invocationOptions(argv) {
             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());
         }
         if (token === "--repo")
@@ -304,7 +324,8 @@ function parseCommand(parts) {
             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,
             };
@@ -319,6 +340,7 @@ function parseCommand(parts) {
             };
         }
         case "settings": return { command: "settings", output: parts.output };
+        case "region": return parseRegion(parts);
     }
 }
 export function parseArgv(argv) {

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,5 +1,5 @@
-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<{

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)}`, overflow: "middle-ellipsis" };
+            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);

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

@@ -1,6 +1,7 @@
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
 import { type TextRenderContext } from "./terminal.js";
+export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
 export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult, context?: TextRenderContext): string;
 export declare function akumaExitCode(result: AkumaInvocationResult): number;
 export declare function akumaJsonValue(command: ParsedCommand, result: AkumaInvocationResult): unknown;