toolcraft 0.0.10 → 0.0.12

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -4,15 +4,18 @@ import { parseDocument, stringify } from "yaml";
 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 { hasErrorCode, isRecord, sortStrings, sortTasks, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
+import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
+import { applyOrder, hasErrorCode, isRecord, sortStrings, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
 const ARCHIVE_DIRECTORY_NAME = "archive";
 const MARKDOWN_EXTENSION = ".md";
 const TASK_KIND = "task";
 const TASK_VERSION = 1;
 const TASK_SCHEMA_ID = taskSchema.$id;
+const ORDER_LOCK_FILENAME = ".order.lock";
+const MIN_PREFIX_WIDTH = 2;
 const RESERVED_FRONTMATTER_KEYS = new Set([
     "$schema",
+    "created",
     "description",
     "kind",
     "name",
@@ -48,8 +51,8 @@ function listPath(rootPath, list) {
 function archiveDirectoryPath(rootPath, list) {
     return path.join(listPath(rootPath, list), ARCHIVE_DIRECTORY_NAME);
 }
-function activeTaskPath(rootPath, list, id) {
-    return path.join(listPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
+function activeTaskFilename(id, order, width) {
+    return `${String(order).padStart(width, "0")}-${id}${MARKDOWN_EXTENSION}`;
 }
 function archivedTaskPath(rootPath, list, id) {
     return path.join(archiveDirectoryPath(rootPath, list), `${id}${MARKDOWN_EXTENSION}`);
@@ -63,6 +66,28 @@ function isHiddenEntry(entryName) {
 function isLockFile(entryName) {
     return entryName.endsWith(".lock");
 }
+function isValidTaskIdShape(id) {
+    return id.length > 0 && !id.startsWith(".") && !id.includes("/") && !id.includes("\\") && !id.includes("..");
+}
+function parseActiveFilename(entryName) {
+    if (!isMarkdownFile(entryName))
+        return undefined;
+    const stem = entryName.slice(0, -MARKDOWN_EXTENSION.length);
+    const match = /^(\d+)-(.+)$/.exec(stem);
+    if (match) {
+        const id = match[2];
+        if (isValidTaskIdShape(id)) {
+            return { id, order: Number.parseInt(match[1], 10) };
+        }
+    }
+    if (isValidTaskIdShape(stem)) {
+        return { id: stem, order: null };
+    }
+    return undefined;
+}
+function padWidthForCount(count) {
+    return Math.max(MIN_PREFIX_WIDTH, String(Math.max(count, 1)).length);
+}
 function malformedTask(filePath, field) {
     return new MalformedTaskError(`Malformed task "${filePath}": invalid "${field}".`);
 }
@@ -180,22 +205,32 @@ async function readTaskFile(fs, list, id, filePath, validStates) {
         task: createTask(list, id, frontmatter, document.body)
     };
 }
+async function findActiveTaskFilename(fs, listDirectoryPath, id) {
+    const entries = await readDirectoryNames(fs, listDirectoryPath);
+    for (const entryName of entries) {
+        if (isHiddenEntry(entryName) || isLockFile(entryName))
+            continue;
+        const parsed = parseActiveFilename(entryName);
+        if (parsed?.id === id) {
+            return entryName;
+        }
+    }
+    return undefined;
+}
 async function findTaskLocation(fs, rootPath, list, id) {
-    const activePath = activeTaskPath(rootPath, list, id);
-    const activeStat = await statIfExists(fs, activePath);
-    if (activeStat?.isFile()) {
-        return {
-            archived: false,
-            path: activePath
-        };
+    const listDirectoryPath = listPath(rootPath, list);
+    const activeName = await findActiveTaskFilename(fs, listDirectoryPath, id);
+    if (activeName) {
+        const activePath = path.join(listDirectoryPath, activeName);
+        const activeStat = await statIfExists(fs, activePath);
+        if (activeStat?.isFile()) {
+            return { archived: false, path: activePath };
+        }
     }
     const archivedPath = archivedTaskPath(rootPath, list, id);
     const archivedStat = await statIfExists(fs, archivedPath);
     if (archivedStat?.isFile()) {
-        return {
-            archived: true,
-            path: archivedPath
-        };
+        return { archived: true, path: archivedPath };
     }
     return undefined;
 }
@@ -224,6 +259,7 @@ function createdFrontmatter(defaults, input, initialState) {
             frontmatter[key] = value;
         }
     }
+    frontmatter.created = new Date().toISOString();
     return frontmatter;
 }
 function updatedFrontmatter(existingFrontmatter, task, patch) {
@@ -266,6 +302,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 markdown-dir 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.');
@@ -275,26 +316,86 @@ function createTasksView(deps, list) {
     const listDirectoryPath = listPath(deps.path, list);
     const stateMachine = resolveStateMachine(deps.stateMachine);
     const validStates = new Set(stateMachine.states);
-    async function listFiles(directoryPath) {
-        const entries = await readDirectoryNames(deps.fs, directoryPath);
-        const tasks = [];
+    async function readActiveEntries() {
+        const entries = await readDirectoryNames(deps.fs, listDirectoryPath);
+        const result = [];
         for (const entryName of entries) {
-            if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile(entryName)) {
+            if (isHiddenEntry(entryName) || isLockFile(entryName))
                 continue;
-            }
-            const entryPath = path.join(directoryPath, entryName);
+            const parsed = parseActiveFilename(entryName);
+            if (!parsed)
+                continue;
+            const entryPath = path.join(listDirectoryPath, entryName);
             const entryStat = await statIfExists(deps.fs, entryPath);
-            if (!entryStat?.isFile()) {
+            if (!entryStat?.isFile())
+                continue;
+            result.push({ id: parsed.id, order: parsed.order, filename: entryName });
+        }
+        result.sort((left, right) => {
+            const leftOrder = left.order ?? Number.POSITIVE_INFINITY;
+            const rightOrder = right.order ?? Number.POSITIVE_INFINITY;
+            if (leftOrder !== rightOrder)
+                return leftOrder - rightOrder;
+            return left.filename.localeCompare(right.filename);
+        });
+        return result;
+    }
+    async function readActiveTasks() {
+        const entries = await readActiveEntries();
+        const tasks = new Map();
+        for (const entry of entries) {
+            const filePath = path.join(listDirectoryPath, entry.filename);
+            const file = await readTaskFile(deps.fs, list, entry.id, filePath, validStates);
+            tasks.set(entry.id, { task: file.task, raw: file.frontmatter });
+        }
+        return { entries, tasks };
+    }
+    async function readArchivedTasks() {
+        const archivePath = archiveDirectoryPath(deps.path, list);
+        const entries = await readDirectoryNames(deps.fs, archivePath);
+        const result = [];
+        for (const entryName of entries) {
+            if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile(entryName))
+                continue;
+            const entryPath = path.join(archivePath, entryName);
+            const entryStat = await statIfExists(deps.fs, entryPath);
+            if (!entryStat?.isFile())
                 continue;
-            }
             const id = entryName.slice(0, -MARKDOWN_EXTENSION.length);
-            tasks.push((await readTaskFile(deps.fs, list, id, entryPath, validStates)).task);
+            const file = await readTaskFile(deps.fs, list, id, entryPath, validStates);
+            result.push({ task: file.task, raw: file.frontmatter });
         }
-        return sortTasks(tasks);
+        return result.sort((left, right) => left.task.qualifiedId.localeCompare(right.task.qualifiedId));
     }
-    async function withTaskLock(id, action) {
-        validateTaskId(id);
-        const release = await acquireFileLock(activeTaskPath(deps.path, list, id), {
+    async function rewriteListPrefixes(orderedIds) {
+        const entries = await readActiveEntries();
+        const byId = new Map(entries.map((entry) => [entry.id, entry]));
+        const width = padWidthForCount(orderedIds.length);
+        for (let index = 0; index < orderedIds.length; index += 1) {
+            const id = orderedIds[index];
+            const entry = byId.get(id);
+            if (!entry)
+                continue;
+            const desiredFilename = activeTaskFilename(id, index + 1, width);
+            if (entry.filename !== desiredFilename) {
+                const fromPath = path.join(listDirectoryPath, entry.filename);
+                const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
+                await deps.fs.rename(fromPath, stagingPath);
+                entry.filename = path.basename(stagingPath);
+            }
+        }
+        const refreshed = await readDirectoryNames(deps.fs, listDirectoryPath);
+        for (const entryName of refreshed) {
+            const stagingMatch = /\.staging-\d+-\d+$/.exec(entryName);
+            if (!stagingMatch)
+                continue;
+            const desiredName = entryName.slice(0, stagingMatch.index);
+            await deps.fs.rename(path.join(listDirectoryPath, entryName), path.join(listDirectoryPath, desiredName));
+        }
+    }
+    async function withListLock(action) {
+        await deps.fs.mkdir(listDirectoryPath, { recursive: true });
+        const release = await acquireFileLock(path.join(listDirectoryPath, ORDER_LOCK_FILENAME), {
             fs: deps.fs,
             staleMs: deps.lockStaleMs,
             retries: deps.lockRetries
@@ -306,6 +407,10 @@ function createTasksView(deps, list) {
             await release();
         }
     }
+    async function withTaskLock(id, action) {
+        validateTaskId(id);
+        return withListLock(action);
+    }
     async function getTaskFile(id) {
         validateTaskId(id);
         return readTaskAtLocation(deps.fs, deps.path, list, id, validStates);
@@ -326,29 +431,42 @@ function createTasksView(deps, list) {
         name: list,
         stateMachine,
         async all(filter) {
-            const activeTasks = await listFiles(listDirectoryPath);
-            const archivedTasks = filter?.includeArchived
-                ? await listFiles(archiveDirectoryPath(deps.path, list))
-                : [];
-            const combinedTasks = [...activeTasks, ...archivedTasks];
-            if (filter?.state) {
-                return combinedTasks.filter((task) => task.state === filter.state);
-            }
-            return combinedTasks;
+            const { entries: activeEntries, tasks: activeTasks } = await readActiveTasks();
+            const archivedEntries = filter?.includeArchived ? await readArchivedTasks() : [];
+            const orderedActive = activeEntries
+                .map((entry) => activeTasks.get(entry.id))
+                .filter((entry) => {
+                if (filter?.state && entry.task.state !== filter.state)
+                    return false;
+                return true;
+            });
+            const filteredArchived = archivedEntries.filter((entry) => {
+                if (filter?.state && entry.task.state !== filter.state)
+                    return false;
+                return true;
+            });
+            const orderedActiveTasks = applyOrder(orderedActive, filter?.order);
+            return [...orderedActiveTasks, ...filteredArchived.map((entry) => entry.task)];
         },
         async get(id) {
             return (await getTaskFile(id)).task;
         },
         async create(input) {
             assertCreateDoesNotSetState(input);
+            assertCreateHasId(input);
             validateTaskId(input.id);
             await deps.fs.mkdir(listDirectoryPath, { recursive: true });
-            return withTaskLock(input.id, async () => {
+            return withListLock(async () => {
                 const existing = await findTaskLocation(deps.fs, deps.path, list, input.id);
                 if (existing) {
                     throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
                 }
-                const targetPath = activeTaskPath(deps.path, list, input.id);
+                const activeEntries = await readActiveEntries();
+                const maxOrder = activeEntries.reduce((max, entry) => (entry.order !== null && entry.order > max ? entry.order : max), 0);
+                const nextOrder = maxOrder + 1;
+                const width = padWidthForCount(activeEntries.length + 1);
+                const filename = activeTaskFilename(input.id, nextOrder, width);
+                const targetPath = path.join(listDirectoryPath, filename);
                 const frontmatter = createdFrontmatter(deps.defaults, input, stateMachine.initial);
                 const description = input.description ?? "";
                 await writeAtomically(deps.fs, targetPath, serializeTaskDocument(frontmatter, description));
@@ -419,11 +537,58 @@ function createTasksView(deps, list) {
                 }
                 await deps.fs.unlink(location.path);
             });
+        },
+        async move(id, anchor) {
+            validateTaskId(id);
+            return withListLock(async () => {
+                const { entries, tasks } = await readActiveTasks();
+                const fromIndex = entries.findIndex((entry) => entry.id === id);
+                if (fromIndex < 0) {
+                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+                }
+                const ordered = entries.map((entry) => entry.id);
+                ordered.splice(fromIndex, 1);
+                let insertIndex;
+                if ("position" in anchor) {
+                    insertIndex = anchor.position === "top" ? 0 : ordered.length;
+                }
+                else {
+                    const anchorId = "before" in anchor ? anchor.before : anchor.after;
+                    const anchorIndex = ordered.indexOf(anchorId);
+                    if (anchorIndex < 0) {
+                        throw new AnchorNotFoundError(anchorId);
+                    }
+                    insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+                }
+                ordered.splice(insertIndex, 0, id);
+                await rewriteListPrefixes(ordered);
+                return tasks.get(id).task;
+            });
+        },
+        async reorder(ids) {
+            for (const id of ids) {
+                validateTaskId(id);
+            }
+            return withListLock(async () => {
+                const { entries, tasks } = await readActiveTasks();
+                const currentIds = entries.map((entry) => entry.id);
+                const currentSet = new Set(currentIds);
+                const inputSet = new Set(ids);
+                const missing = currentIds.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 });
+                }
+                await rewriteListPrefixes(ids);
+                return ids.map((id) => tasks.get(id).task);
+            });
         }
     };
 }
 export async function markdownDirBackend(deps) {
     await ensureRootPath(deps);
+    const stateMachine = resolveStateMachine(deps.stateMachine);
+    const validStates = new Set(stateMachine.states);
     const list = (name) => {
         const listName = validateListName(name);
         return createTasksView(deps, listName);
@@ -451,16 +616,63 @@ export async function markdownDirBackend(deps) {
         for (const taskListName of allLists) {
             tasks.push(...(await list(taskListName).all(filter)));
         }
-        return sortTasks(tasks);
+        return tasks;
     };
     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);
+        if (sourceListName === targetListName) {
+            const file = await readTaskAtLocation(deps.fs, deps.path, sourceListName, id, validStates);
+            return file.task;
+        }
+        const targetExisting = await findTaskLocation(deps.fs, deps.path, targetListName, id);
+        if (targetExisting) {
+            throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
+        }
+        const sourceLocation = await findTaskLocation(deps.fs, deps.path, sourceListName, id);
+        if (!sourceLocation) {
+            throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
+        }
+        const targetListDir = listPath(deps.path, targetListName);
+        await deps.fs.mkdir(targetListDir, { recursive: true });
+        const targetEntries = await (async () => {
+            const out = [];
+            const names = await readDirectoryNames(deps.fs, targetListDir);
+            for (const entryName of names) {
+                if (isHiddenEntry(entryName) || isLockFile(entryName))
+                    continue;
+                const parsed = parseActiveFilename(entryName);
+                if (!parsed)
+                    continue;
+                out.push({ id: parsed.id, order: parsed.order, filename: entryName });
+            }
+            return out;
+        })();
+        if (sourceLocation.archived) {
+            const archivedTargetDir = archiveDirectoryPath(deps.path, targetListName);
+            await deps.fs.mkdir(archivedTargetDir, { recursive: true });
+            const archivedTargetPath = archivedTaskPath(deps.path, targetListName, id);
+            await deps.fs.rename(sourceLocation.path, archivedTargetPath);
+            const file = await readTaskFile(deps.fs, targetListName, id, archivedTargetPath, validStates);
+            return file.task;
+        }
+        const maxOrder = targetEntries.reduce((max, entry) => (entry.order !== null && entry.order > max ? entry.order : max), 0);
+        const width = padWidthForCount(targetEntries.length + 1);
+        const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
+        const targetPath = path.join(targetListDir, targetFilename);
+        await deps.fs.rename(sourceLocation.path, targetPath);
+        const file = await readTaskFile(deps.fs, targetListName, id, targetPath, validStates);
+        return file.task;
+    };
     return {
         list,
         lists,
         allTasks,
-        get
+        get,
+        moveBetweenLists
     };
 }

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

@@ -1,4 +1,10 @@
-import type { Task, TaskListFs } from "../types.js";
+import type { ListFilter, Task, TaskListFs } from "../types.js";
+export interface OrderedEntry {
+    task: Task;
+    raw: Record<string, unknown>;
+}
+export declare function compareCreated(left: OrderedEntry, right: OrderedEntry): number;
+export declare function applyOrder(entries: OrderedEntry[], order: ListFilter["order"]): Task[];
 export declare function hasErrorCode(error: unknown, code: string): boolean;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function sortStrings(values: string[]): string[];

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

@@ -1,4 +1,25 @@
 import path from "node:path";
+export function compareCreated(left, right) {
+    const leftCreated = typeof left.raw.created === "string" ? left.raw.created : "";
+    const rightCreated = typeof right.raw.created === "string" ? right.raw.created : "";
+    if (leftCreated === "" && rightCreated === "") {
+        return left.task.qualifiedId.localeCompare(right.task.qualifiedId);
+    }
+    if (leftCreated === "")
+        return 1;
+    if (rightCreated === "")
+        return -1;
+    return leftCreated.localeCompare(rightCreated);
+}
+export function applyOrder(entries, order) {
+    if (order === "alphabetical") {
+        return sortTasks(entries.map((entry) => entry.task));
+    }
+    if (order === "created") {
+        return [...entries].sort(compareCreated).map((entry) => entry.task);
+    }
+    return entries.map((entry) => entry.task);
+}
 let tmpFileCounter = 0;
 export function hasErrorCode(error, code) {
     return (!!error &&