npm - @astrosheep/keiyaku - Versions diffs - 4.5.4 → 4.5.6 - Mend

@astrosheep/keiyaku 4.5.4 → 4.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md +15 -19
package/build/src/cli/commands/install.js +2 -1
package/build/src/cli/commands/task-invoke.js +2 -9
package/build/src/task/compose-language.js +13 -6
package/build/src/task/compose-parser.js +43 -27
package/build/src/task/compose.d.ts +9 -1
package/build/src/task/compose.js +14 -13
package/build/src/task/index.d.ts +2 -2
package/build/src/task/index.js +11 -2
package/package.json +2 -2

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md CHANGED Viewed

@@ -70,30 +70,26 @@ Relations are explicit facts: `needs` orders work, `parent` groups it,
 ## Batch Create Or Modify
 Use `task compose -` to create and modify multiple Tasks in one planning
-document:
+document. Its input grammar is documented by the Task CLI owner:
 ```bash
 keiyaku task compose - <<'EOF'
 ns=feature
-+ Parent pri=0
++ Parent
+as = parent
+pri = 0
+body <<BODY
 Parent body.
-  + Child needs=@task/existing
-@task/existing pri=1 relates+=@task/other
-Replacement body.
+BODY
++ Child
+parent = ^parent
+needs = @task/existing
 EOF
 ```
-- Optional first line `ns=<segment/...>` selects the allocation namespace;
-  `ns=` selects root.
-- `+ <title>` creates a Task. `@task/<id>` modifies an existing Task.
-- Two spaces of indentation assign the preceding shallower Task as `parent`.
-- Inline assignments are `pri=`, `parent=`, `needs=`, `supersedes=`, and
-  `relates=`. Relation values are comma-separated `@task/...` references.
-- `=` replaces or clears a field. `+=` appends only to `needs`, `supersedes`,
-  or `relates`.
-- Prose after a node replaces its body; bare `body=` clears it. Prefix body
-  lines beginning with `+ `, `@task/`, or `\` with one `\`.
-Compose does not change Task lifecycle state. Each changed Task is admitted
-independently; an incomplete result returns a canonical draft for the remaining
-batch.
+Use `--plan` to inspect aliases, admission order, and body byte previews without
+writing. Compose does not change Task lifecycle state. Each changed Task is
+admitted independently; an incomplete result returns a reusable draft for the
+remaining batch.

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

@@ -47,6 +47,7 @@ export function renderInstallHelp() {
 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 PI_PACKAGE_SOURCE = "npm:@astrosheep/keiyaku";
 function recipes(harness) {
     switch (harness) {
         case "codex":
@@ -63,7 +64,7 @@ function recipes(harness) {
         case "opencode":
             return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
         case "pi":
-            return [["pi", "install", PLUGIN_ROOT]];
+            return [["pi", "install", PI_PACKAGE_SOURCE]];
     }
 }
 function diagnostic(argv, outcome) {

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

@@ -294,15 +294,8 @@ function missingWorld(command) {
     });
     if (isWorldObservation(command))
         return { kind: "absent" };
-    if (command.action === "compose" && command.flags.plan === true) {
-        return {
-            kind: "refused",
-            refusal: {
-                kind: "invalid-composition",
-                diagnostics: [{ line: 1, reason: "task world has no valid planning coordinate", token: "--plan" }],
-            },
-        };
-    }
+    if (command.action === "compose" && command.flags.plan === true)
+        return { kind: "absent" };
     if (command.action === "namespace")
         return { kind: "accepted", value: [] };
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {

package/build/src/task/compose-language.js CHANGED Viewed

@@ -31,17 +31,17 @@ function createdTask(id, title, at, actor) {
 function aliasFor(node) {
     return node.assignments.find((item) => item.field === "as");
 }
-function allocateNodes(parsed, board, namespace, at, actor, diagnostics) {
-    const ids = occupied(board, namespace);
+function allocateNodes(input, diagnostics) {
+    const ids = occupied(input.board, input.namespace);
     const allocations = new Map();
-    for (const node of parsed.nodes) {
+    for (const node of input.parsed.nodes) {
         if (node.kind !== "new")
             continue;
         try {
             const localId = allocateLocalId(deriveLocalStem(node.title), ids);
             ids.add(localId);
-            const id = formatTaskId({ namespace, localId });
-            allocations.set(node.index, createdTask(id, node.title, at, actor));
+            const id = formatTaskId({ namespace: input.namespace, localId });
+            allocations.set(node.index, createdTask(id, node.title, input.at, input.actor));
         }
         catch (error) {
             diagnostics.push(diagnostic(node.line, error instanceof Error ? error.message : String(error), node.title));
@@ -257,7 +257,14 @@ export function planTaskComposition(input) {
     const parsed = parseTaskComposition(input.markdown);
     const diagnostics = [...parsed.diagnostics];
     const namespace = parsed.namespace ?? input.namespace;
-    const allocations = allocateNodes(parsed, input.board, namespace, input.at, input.actor, diagnostics);
+    const allocationInput = {
+        parsed,
+        board: input.board,
+        namespace,
+        at: input.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    };
+    const allocations = allocateNodes(allocationInput, diagnostics);
     const aliases = collectAliases(parsed.nodes, allocations, diagnostics);
     const addressed = new Set();
     const tasks = [];

package/build/src/task/compose-parser.js CHANGED Viewed

@@ -75,6 +75,41 @@ function withBody(node, body) {
 function replaceNode(nodes, node) {
     nodes[node.index] = node;
 }
+function parseBodyAssignment(input, diagnostics) {
+    const fence = /^body\s+<<(.+)$/u.exec(input.text);
+    if (fence !== null) {
+        const token = fence[1];
+        if (!/^[A-Z][A-Z0-9_]{2,31}$/u.test(token)) {
+            diagnostics.push(diagnostic(input.line.number, "body token must match [A-Z][A-Z0-9_]* with length 3..32", token));
+            return { handled: true };
+        }
+        const close = input.lines.findIndex((candidate, candidateIndex) => candidateIndex > input.index && candidate.text === token);
+        if (close < 0) {
+            diagnostics.push(diagnostic(input.line.number, "body fence is not closed", token));
+            return { handled: true, stop: true };
+        }
+        const body = withoutFenceSeparator(input.source.slice(input.line.end, input.lines[close].start));
+        if (input.current.body !== undefined) {
+            diagnostics.push(diagnostic(input.line.number, "body is assigned more than once", input.text));
+            return { handled: true, close };
+        }
+        return {
+            handled: true,
+            node: withBody(input.current, { kind: "replace", value: body, line: input.line.number, token }),
+            close,
+        };
+    }
+    if (!/^body\s*=\s*$/u.test(input.text))
+        return { handled: false };
+    if (input.current.body !== undefined) {
+        diagnostics.push(diagnostic(input.line.number, "body is assigned more than once", input.text));
+        return { handled: true };
+    }
+    return {
+        handled: true,
+        node: withBody(input.current, { kind: "clear", value: "", line: input.line.number, token: input.text }),
+    };
+}
 export function parseTaskComposition(source) {
     const lines = sourceLines(source);
     const diagnostics = [];
@@ -119,35 +154,16 @@ export function parseTaskComposition(source) {
             diagnostics.push(diagnostic(line.number, "property must follow a task node", text));
             continue;
         }
-        const fence = /^body\s+<<(.+)$/u.exec(text);
-        if (fence !== null) {
-            const token = fence[1];
-            if (!/^[A-Z][A-Z0-9_]{2,31}$/u.test(token)) {
-                diagnostics.push(diagnostic(line.number, "body token must match [A-Z][A-Z0-9_]* with length 3..32", token));
-                continue;
-            }
-            const close = lines.findIndex((candidate, candidateIndex) => candidateIndex > index && candidate.text === token);
-            if (close < 0) {
-                diagnostics.push(diagnostic(line.number, "body fence is not closed", token));
-                break;
-            }
-            const body = withoutFenceSeparator(source.slice(line.end, lines[close].start));
-            if (current.body !== undefined)
-                diagnostics.push(diagnostic(line.number, "body is assigned more than once", text));
-            else {
-                current = withBody(current, { kind: "replace", value: body, line: line.number, token });
-                replaceNode(nodes, current);
-            }
-            index = close;
-            continue;
-        }
-        if (/^body\s*=\s*$/u.test(text)) {
-            if (current.body !== undefined)
-                diagnostics.push(diagnostic(line.number, "body is assigned more than once", text));
-            else {
-                current = withBody(current, { kind: "clear", value: "", line: line.number, token: text });
+        const body = parseBodyAssignment({ text, line, index, lines, source, current }, diagnostics);
+        if (body.handled) {
+            if (body.node !== undefined) {
+                current = body.node;
                 replaceNode(nodes, current);
             }
+            if (body.close !== undefined)
+                index = body.close;
+            if (body.stop === true)
+                break;
             continue;
         }
         const assignment = parseAssignment(text, line.number);

package/build/src/task/compose.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import type { WorldRoot } from "../world.js";
 import { type TaskCompositionAlias, type TaskCompositionBodyPreview } from "./compose-language.js";
 import type { TaskId } from "./identity.js";
 import type { TaskRefusal, TaskRetry } from "./operations.js";
+export type { TaskCompositionAlias, TaskCompositionBodyPreview } from "./compose-language.js";
 export type TaskDocumentChange = Readonly<{
     taskId: TaskId;
     kind: "created" | "updated";
@@ -33,4 +34,11 @@ export type TaskCompositionResult = Readonly<{
     }>;
     draft: string;
 }> & TaskCompositionFacts);
-export declare function composeTasks(world: WorldRoot, markdown: string, signal?: AbortSignal, actor?: string, defaultNamespace?: readonly string[], planOnly?: boolean): Promise<TaskCompositionResult>;
+export declare function composeTasks(input: Readonly<{
+    world: WorldRoot;
+    markdown: string;
+    signal?: AbortSignal;
+    actor?: string;
+    defaultNamespace?: readonly string[];
+    planOnly?: boolean;
+}>): Promise<TaskCompositionResult>;

package/build/src/task/compose.js CHANGED Viewed

@@ -107,17 +107,11 @@ async function composeUnderLocks(input) {
         return await admitPlan(input.world, fresh, replanned.plan, input.signal);
     });
 }
-function composeInput(world, markdown, namespace, at, actor, signal) {
-    return {
-        world,
-        markdown,
-        namespace,
-        at,
-        ...(actor === undefined ? {} : { actor }),
-        ...(signal === undefined ? {} : { signal }),
-    };
+function composeInput(input) {
+    return input;
 }
-export async function composeTasks(world, markdown, signal, actor, defaultNamespace = [], planOnly = false) {
+export async function composeTasks(input) {
+    const { world, markdown, signal, actor, defaultNamespace = [], planOnly = false } = input;
     const at = currentTimestamp();
     const initial = await readBoard(world);
     const initialPlan = planAgainst(markdown, initial.board, defaultNamespace, at, actor);
@@ -125,11 +119,18 @@ export async function composeTasks(world, markdown, signal, actor, defaultNamesp
         return refusal(initialPlan.diagnostics);
     if (planOnly)
         return plannedResult(initialPlan.plan);
-    const input = composeInput(world, markdown, defaultNamespace, at, actor, signal);
+    const request = composeInput({
+        world,
+        markdown,
+        namespace: defaultNamespace,
+        at,
+        ...(actor === undefined ? {} : { actor }),
+        ...(signal === undefined ? {} : { signal }),
+    });
     const allocation = initialPlan.plan.tasks.some((task) => task.kind === "new");
     const admitted = allocation
-        ? await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => await composeUnderLocks(input))
-        : await composeUnderLocks(input);
+        ? await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => await composeUnderLocks(request))
+        : await composeUnderLocks(request);
     if (admitted !== "busy")
         return admitted;
     return {

package/build/src/task/index.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 import type { WorldRoot } from "../world.js";
 export type { WorldRoot } from "../world.js";
 import { type BlockedTaskRow, type TaskDetailFacts, type TaskDoctorIssue, type TaskRef, type TaskRow, type TaskTreeNode } from "./board.js";
-import { type TaskCompositionResult } from "./compose.js";
+import { type TaskCompositionAlias, type TaskCompositionBodyPreview, type TaskCompositionResult } from "./compose.js";
 import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
 import type { TaskId } from "./identity.js";
 import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskCompositionDiagnostic, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
@@ -17,7 +17,7 @@ export type TaskDoctorReport = Readonly<{
     issues: readonly TaskDoctorIssue[];
 }>;
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
-export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionDiagnostic, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
+export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionDiagnostic, TaskCompositionAlias, TaskCompositionBodyPreview, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 declare class TaskHandle {
     readonly id: TaskId;

package/build/src/task/index.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
-import { composeTasks } from "./compose.js";
+import { composeTasks, } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
 import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readyTasks, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
@@ -156,7 +156,16 @@ class TasksHandle {
         if (v.plan !== undefined && typeof v.plan !== "boolean")
             throw new TypeError("plan must be a boolean");
         const selected = namespace(v.namespace);
-        return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor), selected, v.plan === true);
+        const selectedSignal = signal(v.signal);
+        const selectedActor = actor(v.actor);
+        return composeTasks({
+            world: this.world,
+            markdown,
+            ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
+            ...(selectedActor === undefined ? {} : { actor: selectedActor }),
+            ...(selected === undefined ? {} : { defaultNamespace: selected }),
+            planOnly: v.plan === true,
+        });
     }
 }
 export const Tasks = Object.freeze({

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.4",
+  "version": "4.5.6",
   "files": [
     "build"
   ],
@@ -64,7 +64,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/square": "0.3.24",
+    "@astrosheep/square": "0.3.28",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",