toolcraft 0.0.11 → 0.0.13

package/node_modules/@poe-code/task-list/dist/backends/yaml-file.js

@@ -1,18 +1,26 @@
 import { acquireFileLock } from "@poe-code/file-lock";
-import { parseDocument } from "yaml";
+import { isMap, parseDocument } from "yaml";
 import storeSchema from "../schema/store.schema.json" with { type: "json" };
 import taskSchema from "../schema/task.schema.json" with { type: "json" };
 import { eventsFromState, findEvent } from "../state-machine.js";
 import { resolveStateMachine } from "../state.js";
-import { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
-import { isRecord, sortStrings, sortTasks, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
+import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
+import { applyOrder, isRecord, sortStrings, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
 const STORE_KIND = "task-store";
 const STORE_SCHEMA_ID = storeSchema.$id;
 const STORE_VERSION = 1;
 const TASK_KIND = "task";
 const TASK_SCHEMA_ID = taskSchema.$id;
 const TASK_VERSION = 1;
-const RESERVED_TASK_KEYS = new Set(["$schema", "description", "kind", "name", "state", "version"]);
+const RESERVED_TASK_KEYS = new Set([
+    "$schema",
+    "created",
+    "description",
+    "kind",
+    "name",
+    "state",
+    "version"
+]);
 function malformedStore(filePath, field) {
     return new MalformedTaskError(`Malformed task store "${filePath}": invalid "${field}".`);
 }
@@ -89,6 +97,7 @@ function createTaskRecord(defaults, input, initialState) {
             taskRecord[key] = value;
         }
     }
+    taskRecord.created = new Date().toISOString();
     return taskRecord;
 }
 function assertCreateDoesNotSetState(input) {
@@ -96,6 +105,11 @@ function assertCreateDoesNotSetState(input) {
         throw new Error('Tasks.create() does not accept "state"; new tasks always start at stateMachine.initial.');
     }
 }
+function assertCreateHasId(input) {
+    if (input.id === undefined) {
+        throw new Error("id is required for yaml-file backend");
+    }
+}
 function assertUpdateDoesNotSetState(patch) {
     if (Object.prototype.hasOwnProperty.call(patch, "state")) {
         throw new Error('Tasks.update() does not accept "state"; use fire() to change task state.');
@@ -248,6 +262,50 @@ function getTaskOrThrow(store, list, id) {
     }
     return taskRecord;
 }
+function getListNode(document, list) {
+    const lists = document.get("lists");
+    if (!isMap(lists)) {
+        return undefined;
+    }
+    const listNode = lists.get(list);
+    if (!isMap(listNode)) {
+        return undefined;
+    }
+    return listNode;
+}
+function pairKey(pair) {
+    const key = pair.key;
+    if (typeof key === "string") {
+        return key;
+    }
+    if (key && typeof key === "object" && "value" in key && typeof key.value === "string") {
+        return key.value;
+    }
+    return undefined;
+}
+function findItemIndex(listNode, id) {
+    return listNode.items.findIndex((pair) => pairKey(pair) === id);
+}
+function activeItemIds(listNode, validStates) {
+    const ids = [];
+    for (const pair of listNode.items) {
+        const id = pairKey(pair);
+        if (id === undefined)
+            continue;
+        const value = pair.value;
+        let state;
+        if (value && typeof value === "object" && "get" in value && typeof value.get === "function") {
+            state = value.get("state");
+        }
+        else if (isRecord(value)) {
+            state = value.state;
+        }
+        if (typeof state === "string" && validStates.has(state) && state !== "archived") {
+            ids.push(id);
+        }
+    }
+    return ids;
+}
 async function ensureStorePath(deps) {
     if (!deps.create) {
         await deps.fs.stat(deps.path);
@@ -287,8 +345,13 @@ function createTasksView(deps, list) {
         if (!listRecord) {
             return [];
         }
-        const tasks = Object.entries(listRecord).map(([id, taskRecord]) => createTask(list, id, taskRecord));
-        return sortTasks(tasks.filter((task) => matchesFilter(task, filter)));
+        const entries = Object.entries(listRecord)
+            .map(([id, taskRecord]) => ({
+            task: createTask(list, id, taskRecord),
+            raw: taskRecord
+        }))
+            .filter(({ task }) => matchesFilter(task, filter));
+        return applyOrder(entries, filter?.order);
     }
     function assertFireableTaskEvent(task, eventName) {
         const event = findEvent(stateMachine, task.state, eventName);
@@ -315,6 +378,7 @@ function createTasksView(deps, list) {
         },
         async create(input) {
             assertCreateDoesNotSetState(input);
+            assertCreateHasId(input);
             validateTaskId(input.id);
             return withStoreLock(deps, async () => {
                 const { document, store } = await readStore(deps.fs, deps.path, validStates);
@@ -403,6 +467,73 @@ function createTasksView(deps, list) {
                 document.deleteIn(["lists", list, id]);
                 await writeAtomically(deps.fs, deps.path, serializeDocument(document));
             });
+        },
+        async move(id, anchor) {
+            validateTaskId(id);
+            return withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                const taskRecord = getTaskOrThrow(store, list, id);
+                const listNode = getListNode(document, list);
+                if (!listNode) {
+                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+                }
+                const fromIndex = findItemIndex(listNode, id);
+                if (fromIndex < 0) {
+                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+                }
+                const [movedPair] = listNode.items.splice(fromIndex, 1);
+                let insertIndex;
+                if ("position" in anchor) {
+                    insertIndex = anchor.position === "top" ? 0 : listNode.items.length;
+                }
+                else {
+                    const anchorId = "before" in anchor ? anchor.before : anchor.after;
+                    const anchorIndex = findItemIndex(listNode, anchorId);
+                    if (anchorIndex < 0) {
+                        listNode.items.splice(fromIndex, 0, movedPair);
+                        throw new AnchorNotFoundError(anchorId);
+                    }
+                    insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+                }
+                listNode.items.splice(insertIndex, 0, movedPair);
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+                return createTask(list, id, taskRecord);
+            });
+        },
+        async reorder(ids) {
+            for (const id of ids) {
+                validateTaskId(id);
+            }
+            return withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                const listNode = getListNode(document, list);
+                if (!listNode) {
+                    throw new OrderMismatchError({ missing: [...ids], extra: [] });
+                }
+                const currentActive = activeItemIds(listNode, validStates);
+                const currentSet = new Set(currentActive);
+                const inputSet = new Set(ids);
+                const missing = currentActive.filter((id) => !inputSet.has(id));
+                const extra = ids.filter((id) => !currentSet.has(id));
+                if (missing.length > 0 || extra.length > 0) {
+                    throw new OrderMismatchError({ missing, extra });
+                }
+                const archivedPairs = listNode.items.filter((pair) => {
+                    const id = pairKey(pair);
+                    return id !== undefined && !currentSet.has(id);
+                });
+                const orderedActive = ids.map((id) => {
+                    const pair = listNode.items.find((p) => pairKey(p) === id);
+                    if (!pair) {
+                        throw new OrderMismatchError({ missing: [id], extra: [] });
+                    }
+                    return pair;
+                });
+                listNode.items.splice(0, listNode.items.length, ...orderedActive, ...archivedPairs);
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+                const tasks = ids.map((id) => createTask(list, id, getTaskOrThrow(store, list, id)));
+                return tasks;
+            });
         }
     };
 }
@@ -420,25 +551,49 @@ export async function yamlFileBackend(deps) {
     };
     const allTasks = async (filter) => {
         const { store } = await readStore(deps.fs, deps.path, validStates);
-        const tasks = [];
-        for (const [listName, listRecord] of Object.entries(getListsRecord(store))) {
-            for (const [id, taskRecord] of Object.entries(listRecord)) {
-                const task = createTask(listName, id, taskRecord);
-                if (matchesFilter(task, filter)) {
-                    tasks.push(task);
-                }
-            }
+        const result = [];
+        const listNames = sortStrings(Object.keys(getListsRecord(store)));
+        for (const listName of listNames) {
+            const listRecord = getListsRecord(store)[listName];
+            if (!isRecord(listRecord))
+                continue;
+            const entries = Object.entries(listRecord)
+                .map(([id, taskRecord]) => ({
+                task: createTask(listName, id, taskRecord),
+                raw: taskRecord
+            }))
+                .filter(({ task }) => matchesFilter(task, filter));
+            result.push(...applyOrder(entries, filter?.order));
         }
-        return sortTasks(tasks);
+        return result;
     };
     const get = async (qualifiedId) => {
         const { list: listName, id } = parseQualifiedId(qualifiedId);
         return list(listName).get(id);
     };
+    const moveBetweenLists = async (qualifiedId, targetList) => {
+        const { list: sourceListName, id } = parseQualifiedId(qualifiedId);
+        const targetListName = validateListName(targetList);
+        return withStoreLock(deps, async () => {
+            const { document, store } = await readStore(deps.fs, deps.path, validStates);
+            const taskRecord = getTaskOrThrow(store, sourceListName, id);
+            if (sourceListName === targetListName) {
+                return createTask(targetListName, id, taskRecord);
+            }
+            if (getTaskRecord(store, targetListName, id)) {
+                throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
+            }
+            document.deleteIn(["lists", sourceListName, id]);
+            document.setIn(["lists", targetListName, id], taskRecord);
+            await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+            return createTask(targetListName, id, taskRecord);
+        });
+    };
     return {
         list,
         lists,
         allTasks,
-        get
+        get,
+        moveBetweenLists
     };
 }

package/node_modules/@poe-code/task-list/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { openTaskList } from "./open.js";
 export { assertEvent, assertTransition, defaultStateMachine, type TaskEvent } from "./state.js";
 export { eventsFromState, findEvent, validateMachine, type EventDef, type StateMachineDef } from "./state-machine.js";
-export { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError, type ListFilter, type OpenTaskListOptions, type Task, type TaskCreate, type TaskDefaults, type TaskFireOptions, type TaskList, type TaskListFs, type TaskState, type Tasks, type TaskUpdate } from "./types.js";
+export { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError, type ListFilter, type MoveAnchor, type OpenGhIssuesOptions, type OpenMarkdownDirOptions, type OpenTaskListOptions, type OpenYamlFileOptions, type Task, type TaskCreate, type TaskDefaults, type TaskFireOptions, type TaskList, type TaskListFs, type TaskOrder, type TaskState, type Tasks, type TaskUpdate } from "./types.js";
+export type { GhClient, GhClientOptions, ResolveAuthOptions, ResolveEndpointOptions } from "./backends/gh-issues-client.js";
+export type { GhIssuesBackendDeps } from "./backends/gh-issues.js";

package/node_modules/@poe-code/task-list/dist/index.js

@@ -1,4 +1,4 @@
 export { openTaskList } from "./open.js";
 export { assertEvent, assertTransition, defaultStateMachine } from "./state.js";
 export { eventsFromState, findEvent, validateMachine } from "./state-machine.js";
-export { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError } from "./types.js";
+export { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "./types.js";

package/node_modules/@poe-code/task-list/dist/open.d.ts

@@ -1,3 +1,5 @@
-import type { BackendFactory, OpenTaskListOptions, TaskList } from "./types.js";
-export declare const backendFactories: Record<OpenTaskListOptions["type"], BackendFactory>;
+import type { BackendFactory, OpenMarkdownDirOptions, OpenTaskListOptions, OpenYamlFileOptions, TaskList } from "./types.js";
+type FileBackendOptions = OpenMarkdownDirOptions | OpenYamlFileOptions;
+export declare const backendFactories: Record<FileBackendOptions["type"], BackendFactory>;
 export declare function openTaskList(options: OpenTaskListOptions): Promise<TaskList>;
+export {};

package/node_modules/@poe-code/task-list/dist/open.js

@@ -1,4 +1,6 @@
 import * as fsPromises from "node:fs/promises";
+import { ghIssuesBackend } from "./backends/gh-issues.js";
+import { resolveAuth, resolveEndpoint } from "./backends/gh-issues-client.js";
 import { markdownDirBackend } from "./backends/markdown-dir.js";
 import { yamlFileBackend } from "./backends/yaml-file.js";
 import { validateMachine } from "./state-machine.js";
@@ -13,10 +15,18 @@ function createDefaultFs() {
     return fsPromises;
 }
 export async function openTaskList(options) {
-    const factory = backendFactories[options.type];
-    if (factory === undefined) {
-        throw new Error(`Unknown task list backend type "${options.type}".`);
+    switch (options.type) {
+        case "markdown-dir":
+        case "yaml-file":
+            return openFileBackend(options);
+        case "gh-issues":
+            return openGhIssuesBackend(options);
+        default:
+            throw new Error(`Unknown task list backend type "${options.type}".`);
     }
+}
+async function openFileBackend(options) {
+    const factory = backendFactories[options.type];
     const stateMachine = resolveStateMachine(options.stateMachine);
     validateMachine(stateMachine);
     const deps = {
@@ -32,3 +42,17 @@ export async function openTaskList(options) {
     };
     return factory(deps);
 }
+async function openGhIssuesBackend(options) {
+    const token = await resolveAuth({ explicitToken: options.auth?.token });
+    const endpoint = resolveEndpoint();
+    return ghIssuesBackend({
+        repo: options.repo,
+        project: options.project,
+        defaults: {
+            metadata: { ...(options.defaults?.metadata ?? {}) }
+        },
+        token,
+        endpoint,
+        fetch: options.fetch
+    });
+}

package/node_modules/@poe-code/task-list/dist/types.d.ts

@@ -10,7 +10,7 @@ export interface Task {
     metadata: Record<string, unknown>;
 }
 export interface TaskCreate {
-    id: string;
+    id?: string;
     name: string;
     description?: string;
     metadata?: Record<string, unknown>;
@@ -24,10 +24,19 @@ export interface TaskUpdate {
 export interface TaskFireOptions {
     metadataPatch?: Record<string, unknown>;
 }
+export type TaskOrder = "priority" | "alphabetical" | "created";
 export interface ListFilter {
     state?: string;
     includeArchived?: boolean;
+    order?: TaskOrder;
 }
+export type MoveAnchor = {
+    before: string;
+} | {
+    after: string;
+} | {
+    position: "top" | "bottom";
+};
 export interface Tasks {
     readonly name: string;
     readonly stateMachine: StateMachineDef;
@@ -39,12 +48,15 @@ export interface Tasks {
     canFire(id: string, event: string): Promise<boolean>;
     events(id: string): Promise<readonly string[]>;
     delete(id: string): Promise<void>;
+    move(id: string, anchor: MoveAnchor): Promise<Task>;
+    reorder(ids: readonly string[]): Promise<readonly Task[]>;
 }
 export interface TaskList {
     list(name: string): Tasks;
     lists(): Promise<string[]>;
     allTasks(filter?: ListFilter): Promise<Task[]>;
     get(qualifiedId: string): Promise<Task>;
+    moveBetweenLists(qualifiedId: string, targetList: string): Promise<Task>;
 }
 export interface TaskDefaults {
     metadata?: Record<string, unknown>;
@@ -73,8 +85,19 @@ export interface TaskListFs {
         flag?: string;
     }): Promise<void>;
 }
-export interface OpenTaskListOptions {
-    type: "markdown-dir" | "yaml-file";
+export type OpenTaskListOptions = OpenMarkdownDirOptions | OpenYamlFileOptions | OpenGhIssuesOptions;
+export interface OpenMarkdownDirOptions {
+    type: "markdown-dir";
+    path: string;
+    defaults?: TaskDefaults;
+    create?: boolean;
+    lockStaleMs?: number;
+    lockRetries?: number;
+    fs?: TaskListFs;
+    stateMachine?: StateMachineDef;
+}
+export interface OpenYamlFileOptions {
+    type: "yaml-file";
     path: string;
     defaults?: TaskDefaults;
     create?: boolean;
@@ -83,6 +106,19 @@ export interface OpenTaskListOptions {
     fs?: TaskListFs;
     stateMachine?: StateMachineDef;
 }
+export interface OpenGhIssuesOptions {
+    type: "gh-issues";
+    repo: string;
+    project: {
+        owner: string;
+        number: number;
+    };
+    defaults?: TaskDefaults;
+    auth?: {
+        token: string;
+    };
+    fetch?: typeof fetch;
+}
 export interface BackendDeps {
     path: string;
     defaults: Required<TaskDefaults>;
@@ -114,3 +150,15 @@ export declare class InvalidTransitionError extends Error {
 export declare class MalformedTaskError extends Error {
     constructor(message?: string);
 }
+export declare class OrderMismatchError extends Error {
+    readonly missing: readonly string[];
+    readonly extra: readonly string[];
+    constructor(options: {
+        missing: readonly string[];
+        extra: readonly string[];
+    });
+}
+export declare class AnchorNotFoundError extends Error {
+    readonly anchor: string;
+    constructor(anchor: string);
+}

package/node_modules/@poe-code/task-list/dist/types.js

@@ -35,3 +35,28 @@ export class MalformedTaskError extends Error {
         this.name = "MalformedTaskError";
     }
 }
+export class OrderMismatchError extends Error {
+    missing;
+    extra;
+    constructor(options) {
+        const parts = [];
+        if (options.missing.length > 0) {
+            parts.push(`missing ${options.missing.map((id) => `"${id}"`).join(", ")}`);
+        }
+        if (options.extra.length > 0) {
+            parts.push(`extra ${options.extra.map((id) => `"${id}"`).join(", ")}`);
+        }
+        super(`reorder requires the exact set of active task ids: ${parts.join("; ")}.`);
+        this.name = "OrderMismatchError";
+        this.missing = options.missing;
+        this.extra = options.extra;
+    }
+}
+export class AnchorNotFoundError extends Error {
+    anchor;
+    constructor(anchor) {
+        super(`Anchor task "${anchor}" not found.`);
+        this.name = "AnchorNotFoundError";
+        this.anchor = anchor;
+    }
+}

package/node_modules/@poe-code/task-list/package.json

@@ -21,6 +21,7 @@
   ],
   "dependencies": {
     "@poe-code/file-lock": "*",
+    "@poe-code/process-runner": "*",
     "yaml": "*"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,8 +35,8 @@
     "test": "cd ../.. && vitest run packages/toolcraft/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft/src",
     "lint": "cd ../.. && eslint packages/toolcraft/src --ext ts && tsc -p packages/toolcraft/tsconfig.json --noEmit",
-    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations tiny-mcp-client mcp-oauth auth-store",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations tiny-mcp-client mcp-oauth auth-store"
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . @poe-code/design-system @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/file-lock @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
     "@clack/core": "^1.0.0",
@@ -44,8 +44,13 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "console-table-printer": "^2.15.0",
+    "jose": "^6.1.2",
+    "jsonc-parser": "^3.3.1",
+    "mustache": "^4.2.0",
+    "smol-toml": "^1.3.0",
     "tiny-stdio-mcp-server": "^0.1.0",
-    "toolcraft-schema": "^0.0.11"
+    "toolcraft-schema": "^0.0.13",
+    "yaml": "^2.8.2"
   },
   "files": [
     "dist"
@@ -66,6 +71,7 @@
     "@poe-code/file-lock",
     "@poe-code/agent-defs",
     "@poe-code/config-mutations",
+    "@poe-code/process-runner",
     "tiny-mcp-client",
     "mcp-oauth",
     "auth-store"
@@ -77,6 +83,7 @@
     "@poe-code/config-mutations": "*",
     "@poe-code/design-system": "^0.0.1",
     "@poe-code/file-lock": "*",
+    "@poe-code/process-runner": "*",
     "@poe-code/task-list": "*",
     "auth-store": "*",
     "mcp-oauth": "*",