@astrosheep/keiyaku 4.0.3 → 4.0.5

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

@@ -4,15 +4,15 @@ export const AMEND_MINIMAL_STDIN_HELP = [
     "  <complete replacement>",
 ].join("\n");
 export 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." },
+    bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "raw-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: "optional", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "raw-value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]", purpose: "Amend one Contract's document operations or structured terms." },
     deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--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>|@name|<aku/...>] [--json]", purpose: "Read the world status board or one Contract projection." },
     show: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "show [<contract>|@<contract>] [--json]", purpose: "Read one Contract guidance projection." },
-    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]", purpose: "List one identity directory." },
+    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task[/] [--json]\n       keiyaku ls kei[/] [--json]\n       keiyaku ls aku[/] [--json]\n       keiyaku ls aku/<akuma>[/] [--json]\n       keiyaku ls \"aku/*/*\" [--json]", purpose: "List one identity directory." },
     audit: { positional: "optional", stdin: "none", flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]", purpose: "Ask what candidate preparation, Verification, and target placement would do." },
     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." },

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

@@ -1,6 +1,6 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { runProcess } from "../../runtime/proc/run.js";
+import { runCrossPlatformProcess } from "../../runtime/proc/run.js";
 import { CliUsageError, usageLine, withJsonAutomationHelp } from "../usage.js";
 export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
@@ -80,7 +80,7 @@ function diagnostic(argv, outcome) {
 export function installAssetsRoot() {
     return ASSET_ROOT;
 }
-export async function installHarnesses(harnesses, environment, runner = runProcess) {
+export async function installHarnesses(harnesses, environment, runner = runCrossPlatformProcess) {
     const results = [];
     for (const harness of harnesses) {
         let failure;

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

@@ -1,4 +1,6 @@
 import { Tasks, } from "../../task/index.js";
+import { injectedBodyRequests, requestBodyTask } from "../../akuma/requests.js";
+import { decodeTaskMutationRequest } from "../../task/mutation.js";
 function value(command, name) {
     const item = command.flags[name];
     return typeof item === "string" ? item : undefined;
@@ -54,6 +56,82 @@ async function invokeUpdate(tasks, command, readStdin) {
         ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
     });
 }
+async function addMutationRequest(command, input) {
+    const selectedNamespace = namespace(value(command, "namespace"));
+    if (command.stdin === "document")
+        return { action: "task.addDocument", input: {
+                markdown: await input.readStdin(),
+                ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+            } };
+    const body = value(command, "body"), note = value(command, "note");
+    const initialState = state(value(command, "state")), selectedPriority = priority(value(command, "priority"));
+    const needs = ids(values(command, "needs")), parent = value(command, "parent");
+    const supersedes = ids(values(command, "supersedes")), relates = ids(values(command, "relates"));
+    return { action: "task.add", input: {
+            title: command.positionals[0], ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+            ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }),
+            ...(initialState === undefined ? {} : { state: initialState }),
+            ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+            ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent: parent }),
+            ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
+        } };
+}
+async function updateMutationRequest(command, input) {
+    const body = command.stdin === "body" ? await input.readStdin() : value(command, "body");
+    const appendBody = command.stdin === "append" ? await input.readStdin() : value(command, "append");
+    const note = command.stdin === "note" ? await input.readStdin() : value(command, "note");
+    const title = value(command, "title"), selectedPriority = priority(value(command, "priority"));
+    const addNeeds = ids(values(command, "needs")), dropNeeds = ids(values(command, "drop-needs"));
+    const parent = value(command, "parent"), addSupersedes = ids(values(command, "supersedes"));
+    const dropSupersedes = ids(values(command, "drop-supersedes")), addRelates = ids(values(command, "relates"));
+    const dropRelates = ids(values(command, "drop-relates"));
+    return { action: "task.update", id: command.positionals[0], input: {
+            ...(title === undefined ? {} : { title }), ...(body === undefined ? {} : { body }),
+            ...(appendBody === undefined ? {} : { appendBody }), ...(note === undefined ? {} : { note }),
+            ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+            ...(addNeeds === undefined ? {} : { addNeeds }), ...(dropNeeds === undefined ? {} : { dropNeeds }),
+            ...(command.flags["no-parent"] === true ? { parent: null }
+                : parent === undefined ? {} : { parent: parent }),
+            ...(addSupersedes === undefined ? {} : { addSupersedes }),
+            ...(dropSupersedes === undefined ? {} : { dropSupersedes }),
+            ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
+        } };
+}
+function lifecycleMutationRequest(command) {
+    const id = command.positionals[0];
+    switch (command.action) {
+        case "start": return { action: "task.start", id };
+        case "stop": return { action: "task.stop", id };
+        case "resume": return { action: "task.resume", id };
+        case "hold": return { action: "task.hold", ids: command.positionals };
+        case "done": return { action: "task.done", ids: command.positionals, ...(value(command, "note") === undefined ? {} : { note: value(command, "note") }) };
+        case "drop": return { action: "task.drop", ids: command.positionals, ...(value(command, "note") === undefined ? {} : { note: value(command, "note") }) };
+        default: throw new Error(`task action cannot forward: ${command.action}`);
+    }
+}
+async function mutationRequest(command, input) {
+    if (command.action === "add")
+        return await addMutationRequest(command, input);
+    if (command.action === "compose")
+        return { action: "task.compose", markdown: await input.readStdin() };
+    if (command.action === "update")
+        return await updateMutationRequest(command, input);
+    return lifecycleMutationRequest(command);
+}
+function validatedMutationRequest(request) {
+    switch (request.action) {
+        case "task.add":
+        case "task.addDocument": return decodeTaskMutationRequest(request.action, { input: request.input });
+        case "task.compose": return decodeTaskMutationRequest(request.action, { markdown: request.markdown });
+        case "task.update": return decodeTaskMutationRequest(request.action, { id: request.id, input: request.input });
+        case "task.start":
+        case "task.stop":
+        case "task.resume": return decodeTaskMutationRequest(request.action, { id: request.id });
+        case "task.hold": return decodeTaskMutationRequest(request.action, { ids: request.ids });
+        case "task.done":
+        case "task.drop": return decodeTaskMutationRequest(request.action, { ids: request.ids, ...(request.note === undefined ? {} : { note: request.note }) });
+    }
+}
 async function invokeRead(tasks, command) {
     const id = command.positionals[0];
     switch (command.action) {
@@ -97,15 +175,7 @@ function missingWorld(command) {
     }
     return missing(command.positionals[0]);
 }
-export async function invokeTask(command, input) {
-    let world = input.world;
-    if (world === null && (command.action === "add" || command.action === "compose"
-        || (command.action === "namespace" && command.positionals.length > 0))) {
-        world = await input.establish();
-    }
-    if (world === null)
-        return missingWorld(command);
-    const tasks = Tasks.of(world);
+async function invokeLocalMutation(tasks, command, input) {
     if (isWorldObservation(command))
         return observeWorldRead(tasks, command);
     if (command.action === "show" || command.action === "tree")
@@ -138,3 +208,22 @@ export async function invokeTask(command, input) {
         default: throw new Error(`task action has no invocation: ${command.action}`);
     }
 }
+function establishesWorld(command) {
+    return command.action === "add" || command.action === "compose"
+        || (command.action === "namespace" && command.positionals.length > 0);
+}
+function forwardsMutation(command) {
+    return command.action !== "show" && command.action !== "tree"
+        && command.action !== "namespace" && !isWorldObservation(command);
+}
+export async function invokeTask(command, input) {
+    const world = input.world ?? (establishesWorld(command) ? await input.establish() : null);
+    if (world === null)
+        return missingWorld(command);
+    const requests = injectedBodyRequests();
+    if (requests !== null && forwardsMutation(command)) {
+        const request = validatedMutationRequest(await mutationRequest(command, input));
+        return await requestBodyTask({ directory: requests, world, request });
+    }
+    return await invokeLocalMutation(Tasks.of(world), command, input);
+}

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

@@ -1,4 +1,4 @@
-import type { TaskQueryExpression } from "../../task/index.js";
+import { type TaskQueryExpression } from "../../task/index.js";
 export type { TaskQueryExpression } from "../../task/index.js";
 export declare function parseTaskQueryExpression(source: string): TaskQueryExpression;
 export declare function validateTaskLimit(source: string): void;

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

@@ -1,3 +1,4 @@
+import { TASK_RELATION_PREDICATE_FIELDS, } from "../../task/index.js";
 import { MAX_TASK_LIMIT, normalizeTaskQuery } from "../../task/query.js";
 function syntax(message, offset) { throw new Error(`${message} at column ${offset + 1}`); }
 function scanString(source, offset) {
@@ -133,7 +134,15 @@ function parseTextPredicate(field, operator, value) {
     return { field, operator: selected, value: value.value };
 }
 function parseRelationPredicate(field, operator, value) {
-    return { field, operator: equalityOperator(operator, field), value: canonicalTaskId(value, field) };
+    const relationField = TASK_RELATION_PREDICATE_FIELDS.find((candidate) => candidate === field.value);
+    if (relationField === undefined) {
+        syntax(`unknown query field ${JSON.stringify(field.value)}`, field.offset);
+    }
+    return {
+        field: relationField,
+        operator: equalityOperator(operator, relationField),
+        value: canonicalTaskId(value, relationField),
+    };
 }
 function parseBooleanPredicate(field, operator, value) {
     return { field, operator: equalityOperator(operator, field), value: boolean(value) };
@@ -216,14 +225,11 @@ class Parser {
                 operator: equalityOperator(operator, "parent"),
                 value: value.value === "none" ? null : canonicalTaskId(value, "parent"),
             };
-            case "under": return parseRelationPredicate("under", operator, value);
-            case "needs": return parseRelationPredicate("needs", operator, value);
-            case "blocks": return parseRelationPredicate("blocks", operator, value);
             case "ready": return parseBooleanPredicate("ready", operator, value);
             case "blocked": return parseBooleanPredicate("blocked", operator, value);
             case "created": return parseTimestampPredicate("created", operator, value);
             case "updated": return parseTimestampPredicate("updated", operator, value);
-            default: return syntax(`unknown query field ${JSON.stringify(field.value)}`, field.offset);
+            default: return parseRelationPredicate(field, operator, value);
         }
     }
 }

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

@@ -3,6 +3,7 @@ import { type WorldRoot } from "../world.js";
 import { type ParsedCommand } from "./parse.js";
 export type CliCoordinates = Readonly<{
     cwd: string;
+    cwdSource: "input" | "process";
     repo?: Repo;
     world: WorldRoot | null;
     candidateWorld: WorldRoot | null;
@@ -12,6 +13,7 @@ export type CliCoordinateInput = Readonly<{
     processCwd?: string;
     cwd?: string;
     repo?: string;
+    gitPath?: string;
     command: ParsedCommand;
 }>;
 export declare function assertExplicitRepoUse(command: ParsedCommand, repo: string | undefined): void;

package/build/src/cli/coordinates.js

@@ -11,9 +11,12 @@ async function canonicalInvocationCwd(input) {
         throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
     }
 }
-async function discoverRepoAt(coordinate) {
+async function discoverRepoAt(coordinate, gitPath) {
     try {
-        return { kind: "present", repo: await Repo.at({ path: coordinate }) };
+        return {
+            kind: "present",
+            repo: await Repo.at({ path: coordinate, ...(gitPath === undefined ? {} : { gitPath }) }),
+        };
     }
     catch (error) {
         if (error instanceof NoGitWorldError)
@@ -38,8 +41,11 @@ function repoPolicy(command) {
             return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
         case "status":
         case "tell":
-        case "history":
             return { use: "optional", acceptsExplicit: false };
+        case "history":
+            return "contract" in command
+                ? { use: "required", acceptsExplicit: true }
+                : { use: "optional", acceptsExplicit: false };
         case "fork":
             return { use: "optional", acceptsExplicit: true };
         case "wait":
@@ -103,15 +109,16 @@ async function resolveWorld(cwd, repo) {
 export async function resolveCliCoordinates(input) {
     const processCwd = resolve(input.processCwd ?? ".");
     const cwd = await canonicalInvocationCwd(resolve(processCwd, input.cwd ?? "."));
-    const invocationRepo = await discoverRepoAt(cwd);
+    const invocationRepo = await discoverRepoAt(cwd, input.gitPath);
     const selectedRepo = input.repo === undefined
         ? invocationRepo
-        : await discoverRepoAt(resolve(cwd, input.repo));
+        : await discoverRepoAt(resolve(cwd, input.repo), input.gitPath);
     const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
     const repo = repoFor(repoPolicy(input.command).use, selectedRepo);
     const world = await resolveWorld(cwd, worldRepo);
     return {
         cwd,
+        cwdSource: input.cwd === undefined ? "process" : "input",
         ...(repo === undefined ? {} : { repo }),
         world: world.root,
         candidateWorld: world.candidate,

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

@@ -10,6 +10,7 @@ type InvokeRuntime = Readonly<{
     environment?: NodeJS.ProcessEnv;
     readStdin?: () => Promise<string>;
     actor?: ActorId;
+    onOperationStart?: () => void;
 }>;
 export type SettingsInvocationResult = Readonly<{
     kind: "settings";