@astrosheep/keiyaku 4.6.4 → 4.6.7

package/build/src/cli/commands/contract.js

@@ -1,7 +1,7 @@
 import { listArchetypeDefinitions } from "../../akuma/archetype.js";
 import { executionChannel } from "../../akuma/requests.js";
 import { Akumas, Keiyaku, KeiyakuError, nuke } from "../../index.js";
-import { kanshi, observeKanshi, selectKanshi, selectRegion } from "../../kanshi/index.js";
+import { kanshi, kanshiCategory, observeKanshi, selectKanshi, selectRegion } from "../../kanshi/index.js";
 import { resolveNamedAddress } from "../../library/address.js";
 import { composeContractLibrary, observeKeiyaku } from "../../library/contract-composition.js";
 import { validateArcMarkdown, validateContractMarkdown } from "../../library/input.js";
@@ -14,14 +14,14 @@ import { BindDraftError, preserveBindDraft } from "../draft.js";
 import { snapshotText } from "../render/akuma-activity.js";
 import { renderAkumaCatalogue, renderArchetypeCatalogue, renderContractCatalogue, renderTaskCatalogue, } from "../render/catalog.js";
 import { renderAccepted, renderContractHistory, renderRetry } from "../render/contract.js";
-import { renderKanshiText } from "../render/kanshi.js";
+import { renderKanshiCategoryText, renderKanshiText } from "../render/kanshi.js";
 import { nukeExitCode, renderNukeText } from "../render/nuke.js";
 import { reconcileHasFailure, renderReconcile } from "../render/reconcile.js";
 import { renderConflictMaterialized, renderRefusal } from "../render/refusal.js";
 import { renderRegionText } from "../render/region.js";
 import { renderSettingsText, settingsJsonValue } from "../render/settings.js";
 import { canonicalContractSelector, contractFromInput, resolveContractId, resolveKanshiContract, } from "../selectors.js";
-import { displayContext, writeJson, writeStdout } from "../streams.js";
+import { displayContext, emit, writeJson, writeStdout } from "../streams.js";
 import { CliUsageError, isBlankInput } from "../usage.js";
 import { amendFromCommand } from "./amend.js";
 import { bindFromCommand } from "./bind.js";
@@ -120,11 +120,8 @@ function renderContractAnswer(answer, project, context) {
     }
 }
 async function finishContractAnswer(answer, output, project) {
-    if (output === "json")
-        writeJson(answer);
-    else
-        writeStdout(renderContractAnswer(answer, project, displayContext()));
-    return contractExitCode(answer);
+    const text = () => renderContractAnswer(answer, project, displayContext());
+    return emit(output, answer, text, contractExitCode(answer));
 }
 async function selectedContract(repo, selector, scope) {
     const id = await resolveContractId(repo, selector, scope);
@@ -187,11 +184,8 @@ async function runBind(command, input, library) {
         if (answer.kind !== "refused")
             return await finishContractAnswer(answer, command.output);
         const draft = await bindDraftReceipt(coordinates.establishWorld, markdown);
-        if (command.output === "json")
-            writeJson(answer);
-        else
-            writeStdout(renderRefusal(refusedInvocation(answer), draft, displayContext()));
-        return 1;
+        const text = () => renderRefusal(refusedInvocation(answer), draft, displayContext());
+        return emit(command.output, answer, text, 1);
     }
     catch (error) {
         if (error instanceof Error && "executionReceipt" in error)
@@ -247,6 +241,7 @@ async function runReview(command, runtime, seat) {
         answer = await seat.contract.review({
             verdict: command.verdict,
             ...(summary === undefined ? {} : { summary }),
+            ...(seat.actor === undefined ? {} : { actor: seat.actor }),
             ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
         }, { ...(driver === undefined ? {} : { observe: driver.observe }) });
     }
@@ -265,11 +260,8 @@ async function runArc(command, runtime, seat) {
         if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
             throw error;
         const refusal = { kind: "invalid-document", diagnostic: error.message };
-        if (command.output === "json")
-            writeJson({ kind: "refused", operation: "arc", contract: seat.id, refusal });
-        else
-            writeStdout(renderRefusal({ operation: "arc", contract: seat.id, refusal }, undefined, displayContext()));
-        return 1;
+        const refused = { kind: "refused", operation: "arc", contract: seat.id, refusal };
+        return emit(command.output, refused, () => renderRefusal(refused, undefined, displayContext()), 1);
     }
     const answer = await seat.contract.arc({
         markdown,
@@ -325,11 +317,7 @@ function statusRefusal(operation, contract) {
 }
 async function runSettings(coordinates, home, output) {
     const value = await settingsAt(coordinates.world ?? undefined, home);
-    if (output === "json")
-        writeJson(settingsJsonValue(value));
-    else
-        writeStdout(renderSettingsText(value, displayContext().columns));
-    return 0;
+    return emit(output, settingsJsonValue(value), () => renderSettingsText(value, displayContext().columns), 0);
 }
 async function runNuke(command, coordinates) {
     if (coordinates.world === null)
@@ -338,11 +326,7 @@ async function runNuke(command, coordinates) {
         world: coordinates.world,
         ...(command.confirm === undefined ? {} : { confirm: command.confirm }),
     });
-    if (command.output === "json")
-        writeJson(result);
-    else
-        writeStdout(renderNukeText(result));
-    return nukeExitCode(result);
+    return emit(command.output, result, () => renderNukeText(result), nukeExitCode(result));
 }
 async function runLs(command, coordinates, home) {
     const query = command.query;
@@ -351,11 +335,7 @@ async function runLs(command, coordinates, home) {
             repo: requiredRepo(coordinates),
             ...(query.limit === undefined ? {} : { limit: query.limit }),
         });
-        if (command.output === "json")
-            writeJson(list);
-        else
-            writeStdout(renderContractCatalogue(list));
-        return 0;
+        return emit(command.output, list, () => renderContractCatalogue(list), 0);
     }
     if (query.kind === "archetypes") {
         const list = await listArchetypeDefinitions({
@@ -363,11 +343,7 @@ async function runLs(command, coordinates, home) {
             ...(query.limit === undefined ? {} : { limit: query.limit }),
             ...(home === undefined ? {} : { home }),
         });
-        if (command.output === "json")
-            writeJson(list);
-        else
-            writeStdout(renderArchetypeCatalogue(list));
-        return 0;
+        return emit(command.output, list, () => renderArchetypeCatalogue(list), 0);
     }
     if (coordinates.world === null)
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
@@ -379,21 +355,13 @@ async function runLs(command, coordinates, home) {
         });
         if (listed.kind !== "accepted")
             throw new Error("Task list did not return an accepted observation");
-        if (command.output === "json")
-            writeJson(listed);
-        else
-            writeStdout(renderTaskCatalogue(listed.value, query.namespace ?? []));
-        return 0;
+        return emit(command.output, listed, () => renderTaskCatalogue(listed.value, query.namespace ?? []), 0);
     }
     const listed = await Akumas.of(coordinates.world).list({
         ...(query.archetype === undefined ? {} : { archetype: query.archetype }),
         ...(query.limit === undefined ? {} : { limit: query.limit }),
     });
-    if (command.output === "json")
-        writeJson(listed);
-    else
-        writeStdout(renderAkumaCatalogue(listed, query.archetype ?? null));
-    return 0;
+    return emit(command.output, listed, () => renderAkumaCatalogue(listed, query.archetype ?? null), 0);
 }
 async function readAkumaStatus(akuma, alias, coordinates) {
     if (coordinates.world === null)
@@ -437,17 +405,10 @@ async function runStatusGuidance(command, coordinates) {
     const selected = await selectedContract(repo, command.contract, coordinates.cwd);
     const guidance = await selected.contract.guidance();
     if (guidance === null) {
-        if (command.output === "json")
-            writeJson(null);
-        else
-            writeStdout(renderRefusal(statusRefusal("status", selected.id), undefined, displayContext()));
-        return 1;
+        const refusal = statusRefusal("status", selected.id);
+        return emit(command.output, null, () => renderRefusal(refusal, undefined, displayContext()), 1);
     }
-    if (command.output === "json")
-        writeJson(guidance);
-    else
-        writeStdout(guidance);
-    return 0;
+    return emit(command.output, guidance, () => guidance, 0);
 }
 async function runStatusSelection(command, coordinates) {
     const selectors = command.selectors;
@@ -474,63 +435,43 @@ async function runStatusSelection(command, coordinates) {
         if (command.output === "text")
             blocks.push(resolved.project());
     }
-    if (command.output === "json")
-        writeJson(values);
-    else
-        writeStdout(blocks.join("\n\n"));
-    return 0;
+    return emit(command.output, values, () => blocks.join("\n\n"), 0);
 }
-async function runStatus(command, coordinates) {
-    if (command.guidance === true)
-        return await runStatusGuidance(command, coordinates);
-    if ("selectors" in command && command.selectors !== undefined)
-        return await runStatusSelection({ ...command, selectors: command.selectors }, coordinates);
-    if (command.akuma === true && command.contract !== undefined) {
-        const resolved = await readAkumaStatus(command.contract, undefined, coordinates);
-        if (command.output === "json")
-            writeJson(resolved.value);
-        else
-            writeStdout(resolved.project());
-        return 0;
-    }
+async function runStatusCategory(command, coordinates) {
+    if (command.category === "contract")
+        requiredRepo(coordinates);
+    const report = await kanshiCategory({
+        world: coordinates.world,
+        ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+        category: command.category,
+        ...(command.limit === undefined ? {} : { limit: command.limit }),
+    });
+    return emit(command.output, report, () => renderKanshiCategoryText(report, displayContext()), 0);
+}
+async function runStatusIdentity(command, coordinates) {
     if (command.contract === undefined) {
         const report = await kanshi({
             world: coordinates.world,
             ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
         });
-        if (command.output === "json")
-            writeJson(report);
-        else
-            writeStdout(renderKanshiText(report, displayContext(), "world"));
-        return 0;
+        return emit(command.output, report, () => renderKanshiText(report, displayContext(), "world"), 0);
     }
     if (command.contract.startsWith("@")) {
         const resolved = await namedStatus(command.contract, coordinates, await observeKanshi({
             world: coordinates.world,
             ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
         }));
-        if (command.output === "json")
-            writeJson(resolved.value);
-        else
-            writeStdout(resolved.project());
-        return 0;
+        return emit(command.output, resolved.value, () => resolved.project(), 0);
     }
     if (command.contract.startsWith("kei/")) {
         const repo = requiredRepo(coordinates);
         const contract = canonicalContractSelector(command.contract);
         const report = await kanshi({ world: coordinates.world, repo, contract });
         if (report.contracts.kind === "present" && report.contracts.value.rows.length === 0) {
-            if (command.output === "json")
-                writeJson(statusRefusal("status", contract).refusal);
-            else
-                writeStdout(renderRefusal(statusRefusal("status", contract), undefined, displayContext()));
-            return 1;
+            const refusal = statusRefusal("status", contract);
+            return emit(command.output, refusal.refusal, () => renderRefusal(refusal, undefined, displayContext()), 1);
         }
-        if (command.output === "json")
-            writeJson(report);
-        else
-            writeStdout(renderKanshiText(report, displayContext(), "contract"));
-        return 0;
+        return emit(command.output, report, () => renderKanshiText(report, displayContext(), "contract"), 0);
     }
     const report = await kanshi({
         world: coordinates.world,
@@ -538,28 +479,31 @@ async function runStatus(command, coordinates) {
     });
     const contract = resolveKanshiContract(report, command.contract);
     const selected = selectKanshi({ report, contract });
-    if (command.output === "json")
-        writeJson(selected);
-    else
-        writeStdout(renderKanshiText(selected, displayContext(), "contract"));
-    return 0;
+    return emit(command.output, selected, () => renderKanshiText(selected, displayContext(), "contract"), 0);
+}
+async function runStatus(command, coordinates) {
+    if (command.guidance === true)
+        return await runStatusGuidance(command, coordinates);
+    if (command.category !== undefined)
+        return await runStatusCategory(command, coordinates);
+    if ("selectors" in command && command.selectors !== undefined)
+        return await runStatusSelection({ ...command, selectors: command.selectors }, coordinates);
+    if (command.akuma === true && command.contract !== undefined) {
+        const resolved = await readAkumaStatus(command.contract, undefined, coordinates);
+        return emit(command.output, resolved.value, () => resolved.project(), 0);
+    }
+    return await runStatusIdentity(command, coordinates);
 }
 async function runRegion(command, coordinates) {
     const repo = requiredRepo(coordinates);
-    const emit = (section) => {
-        if (command.output === "json")
-            writeJson(section);
-        else
-            writeStdout(renderRegionText(section));
-        return 0;
-    };
+    const emitSection = (section) => emit(command.output, section, () => renderRegionText(section), 0);
     if (command.paths !== undefined) {
         const report = await kanshi({ world: coordinates.world, repo, region: { kind: "path", patterns: command.paths } });
-        return emit(report.region ?? { kind: "absent" });
+        return emitSection(report.region ?? { kind: "absent" });
     }
     const report = await kanshi({ world: coordinates.world, repo, region: { kind: "declarations" } });
     if (command.contract === undefined)
-        return emit(report.region ?? { kind: "absent" });
+        return emitSection(report.region ?? { kind: "absent" });
     const contract = resolveKanshiContract(report, command.contract);
     const observed = await observeKeiyaku({ repo, id: contract });
     if (observed.kind === "missing" || observed.row.phase === "claimed" || observed.row.phase === "abandoned") {
@@ -574,8 +518,8 @@ async function runRegion(command, coordinates) {
         return 1;
     }
     if (report.region?.kind !== "present" || report.region.value.kind !== "declarations")
-        return emit(report.region ?? { kind: "absent" });
-    return emit({
+        return emitSection(report.region ?? { kind: "absent" });
+    return emitSection({
         kind: "present",
         value: selectRegion({
             declarations: report.region.value.declarations,
@@ -595,11 +539,7 @@ export async function runContractHistoryCommand(command, coordinates) {
             writeStdout(renderRefusal({ operation: "history", contract: selected.id, refusal }, undefined, displayContext()));
         return 1;
     }
-    if (command.output === "json")
-        writeJson(history);
-    else
-        writeStdout(renderContractHistory(history, { full: command.full }));
-    return 0;
+    return emit(command.output, history, () => renderContractHistory(history, { full: command.full }), 0);
 }
 async function runReconcile(command, coordinates, execution, home) {
     const repo = requiredRepo(coordinates);

package/build/src/cli/commands/install.d.ts

@@ -1,12 +1,12 @@
 import type { ProcessInput, ProcessOutcome } from "../../runtime/proc/run.js";
-export declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
-export type HarnessName = (typeof HARNESS_NAMES)[number];
+declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
+type HarnessName = (typeof HARNESS_NAMES)[number];
 export type ParsedInstallCommand = Readonly<{
     command: "install";
     harnesses: readonly HarnessName[];
     output: "text" | "json";
 }>;
-export type HarnessInstallResult = Readonly<{
+type HarnessInstallResult = Readonly<{
     harness: HarnessName;
     status: "installed" | "failed";
     diagnostic?: string;
@@ -15,12 +15,12 @@ export type InstallInvocationResult = Readonly<{
     kind: "install";
     results: readonly HarnessInstallResult[];
 }>;
-export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
+type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
 export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
 export declare const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
 export declare function renderInstallHelp(): string;
-export declare function installAssetsRoot(): string;
 export declare function installHarnesses(harnesses: readonly HarnessName[], environment: NodeJS.ProcessEnv, runner?: InstallRunner): Promise<InstallInvocationResult>;
 export declare function renderInstallText(result: InstallInvocationResult): string;
 export declare function installExitCode(result: InstallInvocationResult): number;
+export {};

package/build/src/cli/commands/install.js

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CliUsageError, commandGuide, usageLine } from "../usage.js";
-export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
+const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
 export const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 function isHarness(value) {
@@ -47,8 +47,8 @@ export function renderInstallHelp() {
     return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits 1.`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
-const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
-const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../plugins");
+const OPENCODE_PLUGIN_ROOT = resolve(ASSET_ROOT, "opencode");
 const PI_PACKAGE_SOURCE = "npm:@astrosheep/keiyaku";
 function recipes(harness) {
     switch (harness) {
@@ -64,7 +64,7 @@ function recipes(harness) {
                 ["claude", "plugin", "update", "keiyaku@keiyaku", "--scope", "user"],
             ];
         case "opencode":
-            return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
+            return [["opencode", "plugin", OPENCODE_PLUGIN_ROOT, "--global", "--force"]];
         case "pi":
             return [["pi", "install", PI_PACKAGE_SOURCE]];
     }
@@ -83,9 +83,6 @@ function diagnostic(argv, outcome) {
     const detail = outcome.stderr.trim() || outcome.stdout.trim();
     return `${argv[0]} exited ${outcome.code}${detail.length === 0 ? "" : `: ${detail}`}`;
 }
-export function installAssetsRoot() {
-    return ASSET_ROOT;
-}
 export async function installHarnesses(harnesses, environment, runner) {
     const run = runner ?? (await import("../../runtime/proc/run.js")).runCrossPlatformProcess;
     const results = [];

package/build/src/cli/commands/task-grammar.js

@@ -1,4 +1,5 @@
-import { CliUsageError, isBlankInput, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide, } from "../usage.js";
+import { CliUsageError, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide } from "../usage.js";
+import { scanArgs } from "../scan.js";
 import { parseTaskNamespaceSelector } from "../../task/catalog.js";
 import { parseTaskId } from "../../task/identity.js";
 import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
@@ -241,73 +242,16 @@ export function taskUsageGuide(action) {
         help: `keiyaku task ${action} --help`,
     };
 }
-function setFlag(flags, name, kind, value, fail) {
-    if (flags[name] !== undefined && kind !== "repeat")
-        fail(`duplicate option: --${name}`);
-    if (kind === "boolean") {
-        flags[name] = true;
-        return;
-    }
-    if (value === undefined)
-        fail(`--${name} requires a value`);
-    if (isBlankInput(value))
-        fail(`--${name} requires a nonblank value`);
-    if (kind === "repeat") {
-        const current = flags[name];
-        flags[name] = [...(Array.isArray(current) ? current : []), value];
-    }
-    else
-        flags[name] = value;
-}
-function scanTaskOption(input, fail) {
-    const token = input.argv[input.index], name = token.slice(2), kind = input.spec.flags[name];
-    if (kind === undefined)
-        fail(`option ${token} is not valid for task ${input.action}`);
-    const next = kind === "boolean" ? undefined : input.argv[input.index + 1];
-    if (next === "-" && input.action === "update" && name === "body") {
-        if (input.stdin !== undefined)
-            fail("stdin marker '-' may appear only once");
-        input.flags[name] = "";
-        return { index: input.index + 1, stdin: name };
-    }
-    if (kind !== "boolean" && (next === undefined || next.startsWith("--") || next === "-"))
-        fail(`--${name} requires a value`);
-    setFlag(input.flags, name, kind, next, fail);
+/** One scan spec per Task action: `-` reads the document, or `--body -` replaces an update body. */
+function scanSpec(action, spec) {
     return {
-        index: input.index + (kind === "boolean" ? 0 : 1),
-        ...(input.stdin === undefined ? {} : { stdin: input.stdin }),
+        subject: `task ${action}`,
+        flags: spec.flags,
+        ...(spec.stdin === undefined ? {} : { stdin: spec.stdin }),
+        stdinRefusal: "stdin marker '-' is not valid here",
+        ...(action === "update" ? { stdinValue: "body" } : {}),
     };
 }
-function scanTaskArgv(action, argv, fail) {
-    const spec = TASK_COMMAND_SPECS[action], positionals = [], flags = {};
-    let stdin;
-    let positionalOnly = false;
-    for (let index = 1; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!positionalOnly && token === "--") {
-            positionalOnly = true;
-            continue;
-        }
-        if (!positionalOnly && token === "-") {
-            if (spec.stdin === undefined)
-                fail("stdin marker '-' is not valid here");
-            if (stdin !== undefined)
-                fail("stdin marker '-' may appear only once");
-            stdin = spec.stdin;
-            continue;
-        }
-        if (positionalOnly || !token.startsWith("--")) {
-            if (isBlankInput(token))
-                fail(`task ${action} requires a nonblank value`);
-            positionals.push(token);
-            continue;
-        }
-        const scanned = scanTaskOption({ action, spec, argv, index, flags, ...(stdin === undefined ? {} : { stdin }) }, fail);
-        index = scanned.index;
-        stdin = scanned.stdin;
-    }
-    return { positionals, flags, ...(stdin === undefined ? {} : { stdin }) };
-}
 function validateUpdate(scanned, fail) {
     const flags = scanned.flags;
     if (flags.body !== undefined && flags.append !== undefined)
@@ -419,7 +363,7 @@ export function parseTaskCommand(argv) {
     const fail = (message) => {
         throw new CliUsageError(message, taskUsageGuide(action));
     };
-    const scanned = scanTaskArgv(action, argv, fail);
+    const scanned = scanArgs(argv, scanSpec(action, TASK_COMMAND_SPECS[action]), fail);
     validateTaskScan(action, scanned, fail);
     let where;
     if (action === "query" && typeof scanned.flags.where === "string") {

package/build/src/cli/commands/task.d.ts

@@ -1,5 +1,4 @@
 import type { ParsedTaskCommand } from "./task-grammar.js";
 import type { CliRuntime } from "../runtime.js";
 import type { CliCoordinates } from "../coordinates.js";
-export { renderTaskHelp } from "./task-grammar.js";
 export declare function runTaskCommand(command: ParsedTaskCommand, coordinates: CliCoordinates, runtime: CliRuntime): Promise<number>;