toolcraft 0.0.23 → 0.0.25

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

@@ -1,12 +1,11 @@
 import path from "node:path";
-import { acquireFileLock } from "@poe-code/file-lock";
 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 { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
-import { applyOrder, isRecord, sortStrings, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
+import { applyOrder, isRecord, rejectSymbolicLinkComponents, sortStrings, statIfExists, validateTaskId, withFileLock, writeAtomically } from "./utils.js";
 const STORE_KIND = "task-store";
 const STORE_SCHEMA_ID = storeSchema.$id;
 const STORE_VERSION = 1;
@@ -54,7 +53,7 @@ function descriptionFromTaskRecord(taskRecord) {
     return typeof taskRecord.description === "string" ? taskRecord.description : "";
 }
 function metadataFromTaskRecord(taskRecord) {
-    const metadata = {};
+    const metadata = Object.create(null);
     for (const [key, value] of Object.entries(taskRecord)) {
         if (!RESERVED_TASK_KEYS.has(key)) {
             metadata[key] = value;
@@ -84,11 +83,11 @@ function matchesFilter(task, filter) {
     return true;
 }
 function createTaskRecord(defaults, input, initialState) {
-    const taskRecord = {
+    const taskRecord = Object.assign(Object.create(null), {
         name: input.name,
         state: initialState,
         description: input.description ?? ""
-    };
+    });
     for (const [key, value] of Object.entries(defaults.metadata)) {
         if (!RESERVED_TASK_KEYS.has(key)) {
             taskRecord[key] = value;
@@ -118,12 +117,12 @@ function assertUpdateDoesNotSetState(patch) {
     }
 }
 function buildUpdatedTaskRecord(existing, patch) {
-    const nextTaskRecord = {
+    const nextTaskRecord = Object.assign(Object.create(null), existing, {
         ...existing,
         name: patch.name ?? existing.name,
         state: existing.state,
         description: patch.description ?? descriptionFromTaskRecord(existing)
-    };
+    });
     for (const [key, value] of Object.entries(patch.metadata ?? {})) {
         if (!RESERVED_TASK_KEYS.has(key)) {
             nextTaskRecord[key] = value;
@@ -132,11 +131,11 @@ function buildUpdatedTaskRecord(existing, patch) {
     return nextTaskRecord;
 }
 function buildTransitionedTaskRecord(existing, to) {
-    return {
+    return Object.assign(Object.create(null), existing, {
         ...existing,
         state: to,
         description: descriptionFromTaskRecord(existing)
-    };
+    });
 }
 function buildFiredTaskRecord(existing, to, metadataPatch) {
     const nextTaskRecord = buildTransitionedTaskRecord(existing, to);
@@ -170,7 +169,9 @@ function assertValidStoreRecord(store, filePath) {
     if (store.kind !== STORE_KIND) {
         throw malformedStore(filePath, "kind");
     }
-    if (typeof store.version !== "number" || !Number.isInteger(store.version) || store.version !== STORE_VERSION) {
+    if (typeof store.version !== "number" ||
+        !Number.isInteger(store.version) ||
+        store.version !== STORE_VERSION) {
         throw malformedStore(filePath, "version");
     }
     if (!isRecord(store.lists)) {
@@ -254,7 +255,9 @@ function getListRecord(store, list) {
 }
 function getTaskRecord(store, list, id) {
     const listRecord = getListRecord(store, list);
-    const taskRecord = listRecord?.[id];
+    const taskRecord = listRecord !== undefined && Object.prototype.hasOwnProperty.call(listRecord, id)
+        ? listRecord[id]
+        : undefined;
     return isRecord(taskRecord) ? taskRecord : undefined;
 }
 function getTaskOrThrow(store, list, id) {
@@ -280,7 +283,10 @@ function pairKey(pair) {
     if (typeof key === "string") {
         return key;
     }
-    if (key && typeof key === "object" && "value" in key && typeof key.value === "string") {
+    if (key &&
+        typeof key === "object" &&
+        "value" in key &&
+        typeof key.value === "string") {
         return key.value;
     }
     return undefined;
@@ -296,7 +302,10 @@ function activeItemIds(listNode, validStates) {
             continue;
         const value = pair.value;
         let state;
-        if (value && typeof value === "object" && "get" in value && typeof value.get === "function") {
+        if (value &&
+            typeof value === "object" &&
+            "get" in value &&
+            typeof value.get === "function") {
             state = value.get("state");
         }
         else if (isRecord(value)) {
@@ -309,6 +318,7 @@ function activeItemIds(listNode, validStates) {
     return ids;
 }
 async function ensureStorePath(deps) {
+    await rejectSymbolicLinkComponents(deps.fs, deps.path);
     if (!deps.create) {
         await deps.fs.stat(deps.path);
         return;
@@ -325,19 +335,6 @@ async function ensureStorePath(deps) {
         ""
     ].join("\n"))));
 }
-async function withStoreLock(deps, action) {
-    const release = await acquireFileLock(deps.path, {
-        fs: deps.fs,
-        staleMs: deps.lockStaleMs,
-        retries: deps.lockRetries
-    });
-    try {
-        return await action();
-    }
-    finally {
-        await release();
-    }
-}
 function createTasksView(deps, list) {
     const stateMachine = resolveStateMachine(deps.stateMachine);
     const validStates = new Set(stateMachine.states);
@@ -382,42 +379,38 @@ function createTasksView(deps, list) {
             assertCreateDoesNotSetState(input);
             assertCreateHasId(input);
             validateTaskId(input.id);
-            return withStoreLock(deps, async () => {
-                const { document, store } = await readStore(deps.fs, deps.path, validStates);
-                if (getTaskRecord(store, list, input.id)) {
-                    throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
-                }
-                const taskRecord = createTaskRecord(deps.defaults, input, stateMachine.initial);
-                document.setIn(["lists", list, input.id], taskRecord);
-                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
-                return createTask(list, input.id, taskRecord, deps.path);
-            });
+            const { document, store } = await readStore(deps.fs, deps.path, validStates);
+            if (getTaskRecord(store, list, input.id)) {
+                throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
+            }
+            const taskRecord = createTaskRecord(deps.defaults, input, stateMachine.initial);
+            document.setIn(["lists", list, input.id], taskRecord);
+            await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+            return createTask(list, input.id, taskRecord, deps.path);
         },
         async update(id, patch) {
             assertUpdateDoesNotSetState(patch);
             validateTaskId(id);
-            return withStoreLock(deps, async () => {
-                const { document, store } = await readStore(deps.fs, deps.path, validStates);
-                const existing = getTaskOrThrow(store, list, id);
-                const nextTaskRecord = buildUpdatedTaskRecord(existing, patch);
-                if (patch.name !== undefined) {
-                    document.setIn(["lists", list, id, "name"], patch.name);
-                }
-                if (patch.description !== undefined) {
-                    document.setIn(["lists", list, id, "description"], patch.description);
-                }
-                for (const [key, value] of Object.entries(patch.metadata ?? {})) {
-                    if (!RESERVED_TASK_KEYS.has(key)) {
-                        document.setIn(["lists", list, id, key], value);
-                    }
+            const { document, store } = await readStore(deps.fs, deps.path, validStates);
+            const existing = getTaskOrThrow(store, list, id);
+            const nextTaskRecord = buildUpdatedTaskRecord(existing, patch);
+            if (patch.name !== undefined) {
+                document.setIn(["lists", list, id, "name"], patch.name);
+            }
+            if (patch.description !== undefined) {
+                document.setIn(["lists", list, id, "description"], patch.description);
+            }
+            for (const [key, value] of Object.entries(patch.metadata ?? {})) {
+                if (!RESERVED_TASK_KEYS.has(key)) {
+                    document.setIn(["lists", list, id, key], value);
                 }
-                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
-                return createTask(list, id, nextTaskRecord, deps.path);
-            });
+            }
+            await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+            return createTask(list, id, nextTaskRecord, deps.path);
         },
         async fire(id, eventName, opts) {
             validateTaskId(id);
-            return withStoreLock(deps, async () => {
+            const { event, nextTask } = await withFileLock(deps.fs, `${deps.path}.lock`, async () => {
                 const { document, store } = await readStore(deps.fs, deps.path, validStates);
                 const existing = getTaskOrThrow(store, list, id);
                 const task = createTask(list, id, existing, deps.path);
@@ -440,10 +433,13 @@ function createTasksView(deps, list) {
                     }
                 }
                 await writeAtomically(deps.fs, deps.path, serializeDocument(document));
-                const nextTask = createTask(list, id, nextTaskRecord, deps.path);
-                await event.onEnter?.(nextTask);
-                return nextTask;
+                return {
+                    event,
+                    nextTask: createTask(list, id, nextTaskRecord, deps.path)
+                };
             });
+            await event.onEnter?.(nextTask);
+            return nextTask;
         },
         async canFire(id, eventName) {
             validateTaskId(id);
@@ -463,79 +459,73 @@ function createTasksView(deps, list) {
         },
         async delete(id) {
             validateTaskId(id);
-            await withStoreLock(deps, async () => {
-                const { document, store } = await readStore(deps.fs, deps.path, validStates);
-                getTaskOrThrow(store, list, id);
-                document.deleteIn(["lists", list, id]);
-                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
-            });
+            const { document, store } = await readStore(deps.fs, deps.path, validStates);
+            getTaskOrThrow(store, list, id);
+            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;
+            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);
                 }
-                listNode.items.splice(insertIndex, 0, movedPair);
-                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
-                return createTask(list, id, taskRecord, deps.path);
-            });
+                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, deps.path);
         },
         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 { 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 (inputSet.size !== ids.length || 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: [] });
                 }
-                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), deps.path));
-                return tasks;
+                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), deps.path));
+            return tasks;
         }
     };
 }
@@ -576,20 +566,18 @@ export async function yamlFileBackend(deps) {
     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, deps.path);
-            }
-            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));
+        const { document, store } = await readStore(deps.fs, deps.path, validStates);
+        const taskRecord = getTaskOrThrow(store, sourceListName, id);
+        if (sourceListName === targetListName) {
             return createTask(targetListName, id, taskRecord, deps.path);
-        });
+        }
+        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, deps.path);
     };
     return {
         list,

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

@@ -1,7 +1,9 @@
 export { openTaskList } from "./open.js";
+export { moveTasks } from "./move.js";
 export { assertEvent, assertTransition, defaultStateMachine, type TaskEvent } from "./state.js";
 export { eventsFromState, findEvent, validateMachine, type EventDef, type StateMachineDef } from "./state-machine.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 { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError, type ListFilter, type MoveProgressEvent, type MoveResult, type MoveTasksOptions, type MoveAnchor, type OpenGhIssuesOptions, type OpenMarkdownDirOptions, type OpenTaskListOptions, type OpenYamlFileOptions, type Task, type TaskCreate, type TaskDefaults, type TaskFireOptions, type TaskList, type TaskListOptions, type TaskListFs, type TaskOrder, type TaskState, type Tasks, type TaskUpdate } from "./types.js";
+export { resolveAuth } from "./backends/gh-issues-client.js";
 export type { GhClient, GhClientOptions, ResolveAuthOptions, ResolveEndpointOptions } from "./backends/gh-issues-client.js";
 export type { GhIssuesBackendDeps } from "./backends/gh-issues.js";
 export { GhProjectSyncError, syncGhProject, verifyGhProject, type SyncGhProjectOptions, type SyncGhProjectReport, type VerifyGhProjectOptions, type VerifyGhProjectReport } from "./backends/gh-issues-sync.js";

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

@@ -1,5 +1,7 @@
 export { openTaskList } from "./open.js";
+export { moveTasks } from "./move.js";
 export { assertEvent, assertTransition, defaultStateMachine } from "./state.js";
 export { eventsFromState, findEvent, validateMachine } from "./state-machine.js";
 export { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "./types.js";
+export { resolveAuth } from "./backends/gh-issues-client.js";
 export { GhProjectSyncError, syncGhProject, verifyGhProject } from "./backends/gh-issues-sync.js";

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

@@ -0,0 +1,2 @@
+import type { MoveResult, MoveTasksOptions } from "./types.js";
+export declare function moveTasks(options: MoveTasksOptions): Promise<MoveResult>;

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

@@ -0,0 +1,215 @@
+import * as fsPromises from "node:fs/promises";
+import path from "node:path";
+import { findEvent } from "./state-machine.js";
+import { openTaskList } from "./open.js";
+export async function moveTasks(options) {
+    const rate = options.rate ?? 15;
+    if (!Number.isFinite(rate) || rate <= 0) {
+        throw new RangeError("moveTasks rate must be a positive number.");
+    }
+    if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 0)) {
+        throw new RangeError("moveTasks limit must be a non-negative integer.");
+    }
+    const source = await openTaskList(readOnlySourceOptions(options.source));
+    const tasks = (await source.allTasks({ includeArchived: true })).slice(0, options.limit);
+    const result = { created: 0, skipped: 0, errors: [] };
+    if (tasks.length === 0) {
+        return result;
+    }
+    const target = await openTaskList(readOnlyTargetOptions(options.target, options.dryRun));
+    const targetLists = new Map();
+    const takeToken = createTokenBucket(rate);
+    for (const task of tasks) {
+        let targetTasks;
+        let targetState;
+        let createdTarget;
+        try {
+            targetTasks = await resolveTargetTasks(task, target, targetLists);
+            targetState = options.stateMap?.[task.state] ?? targetTasks.stateMachine.initial;
+            const transitionEvents = findTransitionEvents(targetTasks, targetTasks.stateMachine.initial, targetState);
+            if (targetTasks.stateMachine.initial !== targetState && transitionEvents === undefined) {
+                throw new Error(`Cannot migrate task state from "${targetTasks.stateMachine.initial}" to "${targetState}".`);
+            }
+            if (options.dryRun) {
+                result.skipped += 1;
+                emitProgress(options, {
+                    type: "skipped",
+                    id: task.id,
+                    source: task,
+                    targetList: targetTasks.name,
+                    targetState,
+                    reason: "dry-run"
+                });
+                continue;
+            }
+            await takeToken();
+            let created = await targetTasks.create({
+                id: task.id,
+                name: task.name,
+                description: task.description,
+                metadata: task.metadata
+            });
+            createdTarget = created;
+            created = await applyState(targetTasks, created, transitionEvents ?? []);
+            if (options.deleteSource === true) {
+                await source.list(task.list).delete(task.id);
+            }
+            result.created += 1;
+            emitProgress(options, {
+                type: "created",
+                id: task.id,
+                source: task,
+                target: created,
+                targetList: targetTasks.name,
+                targetState
+            });
+        }
+        catch (error) {
+            let message = errorMessage(error);
+            if (createdTarget !== undefined) {
+                try {
+                    await targetTasks.delete(createdTarget.id);
+                }
+                catch (rollbackError) {
+                    message = `${message} Rollback failed: ${errorMessage(rollbackError)}`;
+                }
+            }
+            result.errors.push({ id: task.id, error: message });
+            emitProgress(options, { type: "error", id: task.id, source: task, error: message });
+        }
+    }
+    return result;
+}
+function emitProgress(options, event) {
+    try {
+        options.onProgress?.(event);
+    }
+    catch {
+        return;
+    }
+}
+async function resolveTargetTasks(sourceTask, target, targetLists) {
+    const cached = targetLists.get(sourceTask.list);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let tasks;
+    try {
+        tasks = target.list(sourceTask.list);
+    }
+    catch (error) {
+        const lists = await target.lists();
+        if (lists.length !== 1) {
+            throw error;
+        }
+        tasks = target.list(lists[0]);
+    }
+    targetLists.set(sourceTask.list, tasks);
+    return tasks;
+}
+async function applyState(tasks, created, events) {
+    let task = created;
+    for (const event of events) {
+        task = await tasks.fire(task.id, event);
+    }
+    return task;
+}
+function readOnlySourceOptions(options) {
+    if (!("create" in options)) {
+        return options;
+    }
+    return { ...options, create: false };
+}
+function readOnlyTargetOptions(options, dryRun) {
+    if (!dryRun || options.type === "gh-issues") {
+        return options;
+    }
+    return {
+        ...options,
+        create: true,
+        fs: createDryRunFs(options.fs ?? fsPromises, options.path, options.type)
+    };
+}
+function createDryRunFs(fs, targetPath, targetType) {
+    const resolvedTargetPath = path.resolve(targetPath);
+    const unexpectedWrite = async () => {
+        throw new Error("moveTasks dryRun attempted to write to the target backend.");
+    };
+    return {
+        ...fs,
+        async mkdir(directoryPath) {
+            if (path.resolve(directoryPath) !== resolvedTargetPath) {
+                await unexpectedWrite();
+            }
+        },
+        async stat(filePath) {
+            try {
+                return await fs.stat(filePath);
+            }
+            catch (error) {
+                if (path.resolve(filePath) !== resolvedTargetPath) {
+                    throw error;
+                }
+                return {
+                    isDirectory: () => targetType === "markdown-dir",
+                    isFile: () => targetType === "yaml-file",
+                    mtimeMs: 0
+                };
+            }
+        },
+        rename: unexpectedWrite,
+        unlink: unexpectedWrite,
+        writeFile: unexpectedWrite
+    };
+}
+function findTransitionEvents(tasks, fromState, targetState) {
+    if (fromState === targetState) {
+        return [];
+    }
+    const queue = [{ state: fromState, events: [] }];
+    const visited = new Set([fromState]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined) {
+            return undefined;
+        }
+        for (const eventName of Object.keys(tasks.stateMachine.events)) {
+            const event = findEvent(tasks.stateMachine, current.state, eventName);
+            if (event === undefined) {
+                continue;
+            }
+            const events = [...current.events, eventName];
+            if (event.to === targetState) {
+                return events;
+            }
+            if (!visited.has(event.to)) {
+                visited.add(event.to);
+                queue.push({ state: event.to, events });
+            }
+        }
+    }
+    return undefined;
+}
+function createTokenBucket(rate) {
+    const intervalMs = 60_000 / rate;
+    const capacity = Math.max(1, rate);
+    let tokens = capacity;
+    let lastRefill = Date.now();
+    return async () => {
+        while (true) {
+            const now = Date.now();
+            tokens = Math.min(capacity, tokens + (now - lastRefill) / intervalMs);
+            lastRefill = now;
+            if (tokens >= 1) {
+                tokens -= 1;
+                return;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, Math.ceil((1 - tokens) * intervalMs));
+            });
+        }
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -5,8 +5,6 @@ import { markdownDirBackend } from "./backends/markdown-dir.js";
 import { yamlFileBackend } from "./backends/yaml-file.js";
 import { validateMachine } from "./state-machine.js";
 import { resolveStateMachine } from "./state.js";
-const DEFAULT_LOCK_STALE_MS = 30_000;
-const DEFAULT_LOCK_RETRIES = 20;
 export const backendFactories = {
     "markdown-dir": markdownDirBackend,
     "yaml-file": yamlFileBackend
@@ -37,8 +35,6 @@ async function openFileBackend(options) {
         },
         singleList: markdownOptions?.singleList,
         frontmatterMode: markdownOptions?.frontmatterMode ?? "strict",
-        lockStaleMs: options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS,
-        lockRetries: options.lockRetries ?? DEFAULT_LOCK_RETRIES,
         create: options.create ?? false,
         fs: options.fs ?? createDefaultFs(),
         stateMachine
@@ -51,6 +47,9 @@ async function openGhIssuesBackend(options) {
     return ghIssuesBackend({
         repo: options.repo,
         project: options.project,
+        filter: options.filter,
+        state: options.state,
+        stateMachine: options.stateMachine,
         defaults: {
             metadata: { ...(options.defaults?.metadata ?? {}) }
         },