@astrosheep/keiyaku 4.0.3 → 4.0.4

package/build/src/task/operations.js

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
 import { documentDiff } from "../markdown/diff.js";
 import { installNamespaceContext, readNamespaceContext } from "./context.js";
-import { relationProblem, projectBlocked, projectRows, projectStatusRows } from "./board.js";
+import { createTaskRelations, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
 import { parseTaskCreationDocument, serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks, } from "./store.js";
@@ -183,9 +183,14 @@ export async function readyTasks(world, scope, parent, limit = DEFAULT_TASK_LIMI
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
         return { kind: "refused", refusal: { kind: "task-missing", taskId: parent } };
+    const relations = createTaskRelations(board);
     const ready = { kind: "predicate", predicate: { field: "ready", operator: "=", value: true } };
     const expression = parent === undefined ? ready : { kind: "and", terms: [ready, underExpression(parent)] };
-    const selectedRows = projectQuery(board, selected, expression, "priority", Math.max(1, board.tasks.size)).rows;
+    const selectedRows = projectQuery(board, relations, {
+        scope: selected,
+        expression,
+        limit: Math.max(1, board.tasks.size),
+    }).rows;
     const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, updatedAt: _updatedAt, ...row }) => row);
     return { kind: "accepted", value: projectPage(rows, limit) };
 }
@@ -196,26 +201,43 @@ export async function blockedTasks(world, scope, parent, limit = DEFAULT_TASK_LI
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
         return { kind: "refused", refusal: { kind: "task-missing", taskId: parent } };
+    const relations = createTaskRelations(board);
     const blocked = { kind: "predicate", predicate: { field: "blocked", operator: "=", value: true } };
     const expression = parent === undefined ? blocked : { kind: "and", terms: [blocked, underExpression(parent)] };
-    const selectedRows = projectQuery(board, selected, expression, "priority", Math.max(1, board.tasks.size)).rows;
+    const selectedRows = projectQuery(board, relations, {
+        scope: selected,
+        expression,
+        limit: Math.max(1, board.tasks.size),
+    }).rows;
     const ids = new Set(selectedRows.map((row) => row.id));
-    return { kind: "accepted", value: projectPage(projectBlocked(board, selected).filter((row) => ids.has(row.id)), limit) };
+    return {
+        kind: "accepted",
+        value: projectPage(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), limit),
+    };
 }
 export async function queryTasks(world, expression, scope, sort = "priority", limit = DEFAULT_TASK_LIMIT) {
     const selected = await readScope(world, scope);
     if (selected !== null && !Array.isArray(selected))
         return { kind: "refused", refusal: selected };
     const board = (await readBoard(world)).board;
+    const relations = createTaskRelations(board);
     for (const target of queryUnderTargets(expression))
         if (!board.tasks.has(target)) {
             return { kind: "refused", refusal: { kind: "task-missing", taskId: target } };
         }
-    return { kind: "accepted", value: projectQuery(board, selected, expression, sort, limit) };
+    return {
+        kind: "accepted",
+        value: projectQuery(board, relations, {
+            scope: selected,
+            expression,
+            sort,
+            limit,
+        }),
+    };
 }
 /** Internal composite observation from one complete Task board read. */
-export async function observeTaskStatusRows(world) {
-    return projectStatusRows((await readBoard(world)).board, null);
+export async function observeTaskBoard(world) {
+    return projectTaskBoardObservation((await readBoard(world)).board);
 }
 /** Internal identity catalog from one complete Task board read. */
 export async function observeTaskCatalogRows(world) {

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

@@ -1,8 +1,10 @@
 import type { TaskPriority, TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
-import type { BlockedTaskRow, TaskBoard, TaskRef, TaskRow } from "./board.js";
+import type { BlockedTaskRow, TaskBoard, TaskRef, TaskRelationProjection, TaskRow } from "./board.js";
 export declare const DEFAULT_TASK_LIMIT = 100;
 export declare const MAX_TASK_LIMIT = 1000;
+export declare const TASK_RELATION_PREDICATE_FIELDS: readonly ["under", "needs", "blocks"];
+export type TaskRelationPredicateField = (typeof TASK_RELATION_PREDICATE_FIELDS)[number];
 export type TaskQueryComparison = "=" | "!=" | "<" | "<=" | ">" | ">=" | "~";
 export type TaskQueryPredicate = Readonly<{
     field: "state";
@@ -58,7 +60,12 @@ export type TaskPage<Row> = Readonly<{
     truncated: boolean;
 }>;
 export declare function normalizeTaskQuery(value: unknown): TaskQueryExpression;
-export declare function projectQuery(board: TaskBoard, scope: readonly string[] | null, expression: TaskQueryExpression, sort?: TaskQuerySort, limit?: number): TaskPage<TaskQueryRow>;
+export declare function projectQuery(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
+    scope: readonly string[] | null;
+    expression: TaskQueryExpression;
+    sort?: TaskQuerySort;
+    limit?: number;
+}>): TaskPage<TaskQueryRow>;
 export declare function projectPage<Row>(rows: readonly Row[], limit?: number): TaskPage<Row>;
 export declare function underExpression(parent: TaskId): TaskQueryExpression;
 export declare function queryUnderTargets(expression: TaskQueryExpression): readonly TaskId[];

package/build/src/task/query.js

@@ -1,7 +1,11 @@
 import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { taskDisposition } from "./board.js";
+import { taskBlocked, taskDisposition, taskRef } from "./board.js";
 export const DEFAULT_TASK_LIMIT = 100;
 export const MAX_TASK_LIMIT = 1_000;
+export const TASK_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
+function isTaskRelationPredicateField(value) {
+    return TASK_RELATION_PREDICATE_FIELDS.includes(value);
+}
 const states = ["open", "in_progress", "on_hold", "done", "drop"];
 const comparisons = ["=", "!=", "<", "<=", ">", ">=", "~"];
 function fail(message) { throw new TypeError(message); }
@@ -97,14 +101,14 @@ function predicate(value) {
         case "title": return normalizeTextPredicate(input, "title", operator);
         case "id": return normalizeTextPredicate(input, "id", operator);
         case "parent": return normalizeParentPredicate(input, operator);
-        case "under": return normalizeRelationPredicate(input, "under", operator);
-        case "needs": return normalizeRelationPredicate(input, "needs", operator);
-        case "blocks": return normalizeRelationPredicate(input, "blocks", operator);
         case "ready": return normalizeBooleanPredicate(input, "ready", operator);
         case "blocked": return normalizeBooleanPredicate(input, "blocked", operator);
         case "created": return normalizeTimestampPredicate(input, "created", operator);
         case "updated": return normalizeTimestampPredicate(input, "updated", operator);
-        default: return fail(`unknown query field: ${field}`);
+        default:
+            if (isTaskRelationPredicateField(field))
+                return normalizeRelationPredicate(input, field, operator);
+            return fail(`unknown query field: ${field}`);
     }
 }
 export function normalizeTaskQuery(value) {
@@ -139,46 +143,24 @@ function compare(left, operator, right) {
     return left >= right;
 }
 function membership(left, operator, right) { return operator === "=" ? left === right : left !== right; }
-function indexChildren(board) {
-    const children = new Map();
-    for (const task of board.tasks.values()) {
-        if (task.parent === null)
-            continue;
-        const siblings = children.get(task.parent) ?? [];
-        siblings.push(task.id);
-        children.set(task.parent, siblings);
-    }
-    return children;
-}
-function indexReverseNeeds(board) {
-    const reverse = new Map();
-    for (const task of board.tasks.values()) {
-        for (const need of task.needs) {
-            const blockers = reverse.get(need) ?? new Set();
-            blockers.add(task.id);
-            reverse.set(need, blockers);
-        }
-    }
-    return reverse;
-}
-function descendants(children, parent) {
+function descendants(relations, parent) {
     const result = new Set(), pending = [parent];
     while (pending.length > 0) {
         const current = pending.shift();
-        for (const child of children.get(current) ?? []) {
-            if (result.has(child))
+        for (const child of relations.children(current)) {
+            if (result.has(child.id))
                 continue;
-            result.add(child);
-            pending.push(child);
+            result.add(child.id);
+            pending.push(child.id);
         }
     }
     return result;
 }
-function relation(board, reverseNeeds, id, field, target) {
+function relation(board, relations, id, field, target) {
     const task = board.tasks.get(id);
     if (task === undefined)
         return false;
-    return field === "needs" ? task.needs.includes(target) : reverseNeeds.get(target)?.has(id) === true;
+    return field === "needs" ? task.needs.includes(target) : relations.blocks(id).some((ref) => ref.id === target);
 }
 function matchText(left, operator, right) {
     return operator === "~" ? left.includes(right) : compare(left, operator, right);
@@ -186,18 +168,7 @@ function matchText(left, operator, right) {
 function matchRelation(selected, operator) {
     return operator === "=" ? selected : !selected;
 }
-function isBlocked(board, task) {
-    const active = task.state === "open" || task.state === "in_progress";
-    return active && task.needs.some((need) => {
-        const target = board.tasks.get(need);
-        return target === undefined || (target.state !== "done" && target.state !== "drop");
-    });
-}
-function taskRef(board, id) {
-    const task = board.tasks.get(id);
-    return task === undefined ? { id, title: null, state: "missing" } : { id, title: task.title, state: task.state };
-}
-function matchesPredicate(board, reverseNeeds, task, value, under) {
+function matchesPredicate(board, relations, task, value, under) {
     switch (value.field) {
         case "state": return compare(task.state, value.operator, value.value);
         case "priority": return compare(task.priority, value.operator, value.value);
@@ -205,32 +176,30 @@ function matchesPredicate(board, reverseNeeds, task, value, under) {
         case "id": return matchText(task.id, value.operator, value.value);
         case "parent": return compare(task.parent ?? "", value.operator, value.value ?? "");
         case "under": return matchRelation(under.get(value.value)?.has(task.id) === true, value.operator);
-        case "needs": return matchRelation(relation(board, reverseNeeds, task.id, "needs", value.value), value.operator);
-        case "blocks": return matchRelation(relation(board, reverseNeeds, task.id, "blocks", value.value), value.operator);
+        case "needs": return matchRelation(relation(board, relations, task.id, "needs", value.value), value.operator);
+        case "blocks": return matchRelation(relation(board, relations, task.id, "blocks", value.value), value.operator);
         case "ready": return membership(taskDisposition(board, task) === "ready", value.operator, value.value);
-        case "blocked": return membership(isBlocked(board, task), value.operator, value.value);
+        case "blocked": return membership(taskBlocked(board, task), value.operator, value.value);
         case "created": return compare(task.createdAt, value.operator, value.value);
         case "updated": return compare(task.updatedAt, value.operator, value.value);
     }
 }
-function matches(board, reverseNeeds, task, expression, under) {
+function matches(board, relations, task, expression, under) {
     if (expression.kind === "not")
-        return !matches(board, reverseNeeds, task, expression.term, under);
+        return !matches(board, relations, task, expression.term, under);
     if (expression.kind !== "predicate") {
         return expression.kind === "and"
-            ? expression.terms.every((term) => matches(board, reverseNeeds, task, term, under))
-            : expression.terms.some((term) => matches(board, reverseNeeds, task, term, under));
+            ? expression.terms.every((term) => matches(board, relations, task, term, under))
+            : expression.terms.some((term) => matches(board, relations, task, term, under));
     }
-    return matchesPredicate(board, reverseNeeds, task, expression.predicate, under);
+    return matchesPredicate(board, relations, task, expression.predicate, under);
 }
-function row(board, reverseNeeds, task) {
+function row(board, relations, task) {
     return {
         id: task.id, title: task.title, state: task.state, priority: task.priority, disposition: taskDisposition(board, task),
         parent: task.parent,
         needs: task.needs.map((need) => taskRef(board, need)),
-        blocks: [...(reverseNeeds.get(task.id) ?? [])]
-            .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)))
-            .map((id) => taskRef(board, id)),
+        blocks: relations.blocks(task.id),
         createdAt: task.createdAt, updatedAt: task.updatedAt,
     };
 }
@@ -245,13 +214,12 @@ function sortTasks(tasks, sort) {
         return (sort === "updated" ? -compared : compared) || tie;
     });
 }
-export function projectQuery(board, scope, expression, sort = "priority", limit = DEFAULT_TASK_LIMIT) {
-    const children = indexChildren(board);
-    const reverseNeeds = indexReverseNeeds(board);
-    const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(children, target)]));
+export function projectQuery(board, relations, input) {
+    const { scope, expression, sort = "priority", limit = DEFAULT_TASK_LIMIT } = input;
+    const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(relations, target)]));
     const selected = sortTasks([...board.tasks.values()].filter((task) => scope === null || sameNamespace(parseTaskId(task.id).namespace, scope))
-        .filter((task) => matches(board, reverseNeeds, task, expression, under)), sort);
-    const rows = selected.slice(0, limit).map((task) => row(board, reverseNeeds, task));
+        .filter((task) => matches(board, relations, task, expression, under)), sort);
+    const rows = selected.slice(0, limit).map((task) => row(board, relations, task));
     return { rows, total: selected.length, returned: rows.length, truncated: rows.length < selected.length };
 }
 export function projectPage(rows, limit = DEFAULT_TASK_LIMIT) {

package/build/src/verification/execution.js

@@ -1,4 +1,5 @@
-import { runHookCommands, worktreeHooksFrom } from "../git/hooks.js";
+import { runHookCommands } from "../git/hooks.js";
+import { worktreeHooksFrom } from "../library/configuration.js";
 import { runProcess } from "../runtime/proc/run.js";
 const SUMMARY_BYTES = 32 * 1024;
 function argvFor(declaration) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "files": [
     "build"
   ],
@@ -43,6 +43,7 @@
     "test:typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^25.0.0",
     "@typescript-eslint/parser": "^8.66.0",
     "eslint": "^9.39.5",
@@ -55,6 +56,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
+    "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
     "yaml": "^2.9.0"
   },