@astrosheep/keiyaku 4.5.7 → 4.5.8

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

@@ -70,8 +70,8 @@ function collectAliases(nodes, allocations, diagnostics) {
             diagnostics.push(diagnostic(declaration.line, "only a new task may declare an alias", declaration.token));
             continue;
         }
-        if (declaration.operator !== "=" || !/^[a-z0-9-]+$/u.test(declaration.value)) {
-            diagnostics.push(diagnostic(declaration.line, "alias must use as = [a-z0-9-]+", declaration.token));
+        if (declaration.operator !== "=" || !/^[^\s,]+$/u.test(declaration.value)) {
+            diagnostics.push(diagnostic(declaration.line, "alias must be a nonempty token without whitespace or comma", declaration.token));
             continue;
         }
         if (aliases.has(declaration.value)) {
@@ -84,6 +84,33 @@ function collectAliases(nodes, allocations, diagnostics) {
     }
     return aliases;
 }
+function isTaskState(value) {
+    return value === "open" || value === "in_progress" || value === "on_hold" || value === "done" || value === "drop";
+}
+function applyStateAssignment(node, current, assignment, scalar, diagnostics) {
+    if (node.kind !== "new") {
+        diagnostics.push(diagnostic(assignment.line, "only a new task may declare an initial state", assignment.token));
+        return current;
+    }
+    if (scalar.has(assignment.field)) {
+        diagnostics.push(diagnostic(assignment.line, "state is assigned more than once", assignment.token));
+        return current;
+    }
+    scalar.add(assignment.field);
+    if (assignment.operator !== "=" || !isTaskState(assignment.value)) {
+        diagnostics.push(diagnostic(assignment.line, "state must use = with a valid persisted state", assignment.token));
+        return current;
+    }
+    return { ...current, state: assignment.value };
+}
+function markScalarAssignment(assignment, scalar, diagnostics) {
+    if (assignment.field !== "pri" && assignment.field !== "parent")
+        return;
+    if (scalar.has(assignment.field)) {
+        diagnostics.push(diagnostic(assignment.line, `${assignment.field} is assigned more than once`, assignment.token));
+    }
+    scalar.add(assignment.field);
+}
 function resolveReference(raw, line, board, aliases, diagnostics) {
     if (raw.startsWith("^")) {
         const alias = raw.slice(1);
@@ -142,12 +169,11 @@ function applyAssignments(node, base, board, aliases, diagnostics) {
     for (const assignment of node.assignments) {
         if (assignment.field === "as")
             continue;
-        if (assignment.field === "pri" || assignment.field === "parent") {
-            if (scalar.has(assignment.field)) {
-                diagnostics.push(diagnostic(assignment.line, `${assignment.field} is assigned more than once`, assignment.token));
-            }
-            scalar.add(assignment.field);
+        if (assignment.field === "state") {
+            next = applyStateAssignment(node, next, assignment, scalar, diagnostics);
+            continue;
         }
+        markScalarAssignment(assignment, scalar, diagnostics);
         if (assignment.field === "pri") {
             if (assignment.operator !== "=" || !/^[0-3]$/u.test(assignment.value)) {
                 diagnostics.push(diagnostic(assignment.line, "pri must use = with a value from 0 through 3", assignment.token));

package/build/src/task/compose-parser.d.ts

@@ -2,7 +2,7 @@ import { type TaskId } from "./identity.js";
 import type { TaskCompositionDiagnostic } from "./operations.js";
 export type RelationField = "needs" | "supersedes" | "relates";
 export type Assignment = Readonly<{
-    field: "as" | "parent" | "pri" | RelationField;
+    field: "as" | "state" | "parent" | "pri" | RelationField;
     operator: "=" | "+=" | "-=";
     value: string;
     line: number;

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

@@ -39,7 +39,7 @@ function parseNamespace(value) {
     return parseTaskId(`task/${value}/placeholder`).namespace;
 }
 function parseAssignment(text, line) {
-    const matched = /^(as|parent|pri|needs|supersedes|relates)\s*(=|\+=|-=)\s*(.*)$/u.exec(text);
+    const matched = /^(as|state|parent|pri|needs|supersedes|relates)\s*(=|\+=|-=)\s*(.*)$/u.exec(text);
     if (matched === null)
         return null;
     return {

package/build/src/task/compose.js

@@ -32,6 +32,8 @@ function taskDraft(task, remainingAliases) {
     const lines = [task.kind === "new" ? `+ ${document.title}` : `@${document.id}`];
     if (task.kind === "new" && task.alias !== undefined)
         lines.push(`as = ${task.alias}`);
+    if (task.kind === "new")
+        lines.push(`state = ${document.state}`);
     lines.push(`pri = ${document.priority}`, `needs = ${document.needs.map((id) => reference(id, remainingAliases)).join(", ")}`, `parent = ${document.parent === null ? "" : reference(document.parent, remainingAliases)}`, `supersedes = ${document.supersedes.map((id) => reference(id, remainingAliases)).join(", ")}`, `relates = ${document.relates.map((id) => reference(id, remainingAliases)).join(", ")}`);
     if (document.body === "")
         lines.push("body =");

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

@@ -1,4 +1,5 @@
 import type { WorldRoot } from "../world.js";
+import { type ExecutionContext, type LibraryExecution } from "../akuma/requests.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 TaskCompositionAlias, type TaskCompositionBodyPreview, type TaskCompositionResult } from "./compose.js";
@@ -23,11 +24,13 @@ export type TaskDoctorReport = Readonly<{
 }>;
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
 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 type { LibraryExecution } from "../akuma/requests.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 declare class TaskHandle {
     readonly id: TaskId;
     private readonly world;
-    constructor(id: TaskId, world: WorldRoot);
+    private readonly execution;
+    constructor(id: TaskId, world: WorldRoot, execution: ExecutionContext);
     read(): Promise<TaskDetail | null>;
     tree(): Promise<TaskDecompositionTree>;
     update(input: UpdateTaskInput): Promise<TaskUpdateResult>;
@@ -56,8 +59,9 @@ declare class TaskHandle {
 export type Task = TaskHandle;
 declare class TasksHandle {
     private readonly world;
+    private readonly execution;
     readonly root: WorldRoot;
-    constructor(world: WorldRoot);
+    constructor(world: WorldRoot, execution: ExecutionContext);
     task(input: Readonly<{
         id: string;
     }>): Task;
@@ -90,7 +94,7 @@ declare class TasksHandle {
     }>): Promise<TaskQueryResult>;
     doctor(): Promise<TaskDoctorReport>;
     batch(input: Readonly<{
-        verb: "done" | "drop" | "hold";
+        verb: "start" | "done" | "drop" | "hold";
         ids: readonly string[];
         note?: string;
         signal?: AbortSignal;
@@ -104,6 +108,10 @@ declare class TasksHandle {
     }>): Promise<TaskCompositionResult>;
 }
 export type Tasks = TasksHandle;
+export declare function tasksForExecution(world: WorldRoot, execution: ExecutionContext): Tasks;
+type TasksOfInput = Readonly<{
+    execution?: LibraryExecution;
+}>;
 export declare const Tasks: Readonly<{
-    of(world: WorldRoot): Tasks;
+    of(world: WorldRoot, input?: TasksOfInput): Tasks;
 }>;

package/build/src/task/index.js

@@ -1,3 +1,5 @@
+import { executionChannel, libraryExecution, localExecutionContext, } from "../akuma/requests.js";
+import { requestForwardedTask } from "./mutation.js";
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks, } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
@@ -6,12 +8,22 @@ import { readBoard } from "./store.js";
 import { actor, addInput, closed, limit, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
 import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, DEFAULT_TASK_LIMIT, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
+function forwardTask(directory, world, request, signal) {
+    return requestForwardedTask({
+        directory,
+        world,
+        request,
+        ...(signal === undefined ? {} : { signal }),
+    });
+}
 class TaskHandle {
     id;
     world;
-    constructor(id, world) {
+    execution;
+    constructor(id, world, execution) {
         this.id = id;
         this.world = world;
+        this.execution = execution;
     }
     async read() {
         const board = (await readBoard(this.world)).board;
@@ -28,13 +40,37 @@ class TaskHandle {
             : { kind: "accepted", value: node };
     }
     update(input) {
-        return updateTask(this.world, this.id, updateInput(input));
+        const values = updateInput(input);
+        const { signal: abort, ...request } = values;
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request") {
+            return forwardTask(channel.directory, this.world, { action: "task.update", id: this.id, input: request }, abort);
+        }
+        return updateTask(this.world, this.id, values);
     }
     lifecycle(verb, input) {
         const value = record(input ?? {}, `${verb} input`);
         closed(value, verb === "drop" || verb === "done" ? ["note", "signal"] : ["signal"], `${verb} input`);
         const note = verb === "drop" || verb === "done" ? text(value.note, "note") : undefined;
-        return lifecycleTask(this.world, this.id, verb, signal(value.signal), note);
+        const abort = signal(value.signal);
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request") {
+            switch (verb) {
+                case "start":
+                    return forwardTask(channel.directory, this.world, { action: "task.start", id: this.id }, abort);
+                case "stop":
+                    return forwardTask(channel.directory, this.world, { action: "task.stop", id: this.id }, abort);
+                case "hold":
+                    return forwardTask(channel.directory, this.world, { action: "task.hold", id: this.id }, abort);
+                case "resume":
+                    return forwardTask(channel.directory, this.world, { action: "task.resume", id: this.id }, abort);
+                case "done":
+                    return forwardTask(channel.directory, this.world, { action: "task.done", id: this.id, ...(note === undefined ? {} : { note }) }, abort);
+                case "drop":
+                    return forwardTask(channel.directory, this.world, { action: "task.drop", id: this.id, ...(note === undefined ? {} : { note }) }, abort);
+            }
+        }
+        return lifecycleTask(this.world, this.id, verb, abort, note);
     }
     start(input) {
         return this.lifecycle("start", input);
@@ -57,18 +93,26 @@ class TaskHandle {
 }
 class TasksHandle {
     world;
+    execution;
     root;
-    constructor(world) {
+    constructor(world, execution) {
         this.world = world;
+        this.execution = execution;
         this.root = world;
     }
     task(input) {
         const v = record(input, "task input");
         closed(v, ["id"], "task input");
-        return new TaskHandle(id(v.id), this.world);
+        return new TaskHandle(id(v.id), this.world, this.execution);
     }
     add(input) {
-        return addTask(this.world, addInput(input));
+        const values = addInput(input);
+        const { actor: _actor, signal: abort, namespace: selected, ...request } = values;
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request") {
+            return forwardTask(channel.directory, this.world, { action: "task.add", input: { ...request, namespace: selected ?? [] } }, abort);
+        }
+        return addTask(this.world, values);
     }
     addDocument(input) {
         const v = record(input, "addDocument input");
@@ -77,12 +121,17 @@ class TasksHandle {
         if (markdown === undefined)
             throw new TypeError("markdown is required");
         const ns = namespace(v.namespace), createdBy = actor(v.actor), abort = signal(v.signal);
-        return addTaskDocument(this.world, {
+        const local = {
             markdown,
             ...(ns === undefined ? {} : { namespace: ns }),
             ...(createdBy === undefined ? {} : { actor: createdBy }),
             ...(abort === undefined ? {} : { signal: abort }),
-        });
+        };
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request") {
+            return forwardTask(channel.directory, this.world, { action: "task.addDocument", input: { markdown, namespace: ns ?? [] } }, abort);
+        }
+        return addTaskDocument(this.world, local);
     }
     async list(input = {}) {
         const v = record(input, "list input");
@@ -140,12 +189,29 @@ class TasksHandle {
         const v = record(input, "batch input");
         closed(v, ["verb", "ids", "note", "signal"], "batch input");
         const verb = v.verb;
-        if (verb !== "done" && verb !== "drop" && verb !== "hold")
+        if (verb !== "start" && verb !== "done" && verb !== "drop" && verb !== "hold")
             throw new TypeError("batch verb is invalid");
+        const ids = taskIds(v.ids, "ids");
+        if (ids === undefined || ids.length === 0)
+            throw new TypeError("ids requires at least one TaskId");
         const note = text(v.note, "note");
         if (note !== undefined && verb !== "done" && verb !== "drop")
             throw new TypeError("batch note is valid only for done or drop");
-        return batchTasks(this.world, verb, taskIds(v.ids, "ids") ?? [], signal(v.signal), note);
+        const abort = signal(v.signal);
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request") {
+            switch (verb) {
+                case "start":
+                    return forwardTask(channel.directory, this.world, { action: "task.start", ids }, abort);
+                case "hold":
+                    return forwardTask(channel.directory, this.world, { action: "task.hold", ids }, abort);
+                case "done":
+                    return forwardTask(channel.directory, this.world, { action: "task.done", ids, ...(note === undefined ? {} : { note }) }, abort);
+                case "drop":
+                    return forwardTask(channel.directory, this.world, { action: "task.drop", ids, ...(note === undefined ? {} : { note }) }, abort);
+            }
+        }
+        return batchTasks(this.world, verb, ids, abort, note);
     }
     compose(input) {
         const v = record(input, "compose input");
@@ -158,20 +224,35 @@ class TasksHandle {
         const selected = namespace(v.namespace);
         const selectedSignal = signal(v.signal);
         const selectedActor = actor(v.actor);
-        return composeTasks({
+        const local = {
             world: this.world,
             markdown,
             ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
             ...(selectedActor === undefined ? {} : { actor: selectedActor }),
             ...(selected === undefined ? {} : { defaultNamespace: selected }),
             planOnly: v.plan === true,
-        });
+        };
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request" && v.plan !== true) {
+            return forwardTask(channel.directory, this.world, { action: "task.compose", markdown, namespace: selected ?? [] }, selectedSignal);
+        }
+        return composeTasks(local);
     }
 }
+export function tasksForExecution(world, execution) {
+    if (typeof world !== "string")
+        throw new TypeError("Tasks.of world must be a WorldRoot");
+    return new TasksHandle(world, execution);
+}
+function tasksOfExecution(input) {
+    if (input === undefined)
+        return localExecutionContext();
+    const values = record(input, "Tasks.of input");
+    closed(values, ["execution"], "Tasks.of input");
+    return values.execution === undefined ? localExecutionContext() : libraryExecution(values.execution);
+}
 export const Tasks = Object.freeze({
-    of(world) {
-        if (typeof world !== "string")
-            throw new TypeError("Tasks.of world must be a WorldRoot");
-        return new TasksHandle(world);
+    of(world, input) {
+        return tasksForExecution(world, tasksOfExecution(input));
     },
 });