@gamflaz/opencode-todolist 1.1.1 → 1.1.2

package/dist/index.d.ts

@@ -1,30 +1,10 @@
 import { Plugin } from "@opencode/plugin";
-import { type TodoReadInput, type TodoRootItem } from "./schemas/todo";
-export declare function formatReadOutput(todos: readonly TodoRootItem[], options?: {
-    visibleIds?: readonly number[];
-}): string;
+import { type TodoRootItem } from "./schemas/todo";
 export declare function formatTransitionLines(before: readonly TodoRootItem[], after: readonly TodoRootItem[]): string[];
 export declare function formatWriteOutput(todos: readonly TodoRootItem[], before?: readonly TodoRootItem[]): string;
 export declare function assertWriteIsInitialization(existing: readonly TodoRootItem[], incoming: readonly TodoRootItem[]): void;
 /** Update response: progress, next step, and transition lines without resending the list. */
 export declare function formatUpdateOutput(todos: readonly TodoRootItem[], before?: readonly TodoRootItem[]): string;
-/**
- * Narrows a list for a scoped read.
- *
- * - `scope: "root"` returns one root with every subtask, so the whole branch is
- *   visible.
- * - `scope: "children"` prints the root line as context plus the targeted
- *   subtask line, matching a "show me this subtask within its root" read.
- * - `scope: "item"` prints only the targeted row.
- *
- * Either way the root keeps every subtask in the *data*, because the root's
- * `(completed/total)` label is computed from them — dropping them would
- * silently turn `(2/2)` into `(1/1)`.
- */
-export declare function selectReadScope(todos: readonly TodoRootItem[], input: TodoReadInput): {
-    todos: TodoRootItem[];
-    visibleIds?: readonly number[];
-};
 export declare function registerTodoTools(ctx: Plugin.Context): Promise<void>;
 export declare function registerTodoPromptHook(ctx: Plugin.Context): Promise<void>;
 declare const _default: Plugin.Plugin;

package/dist/index.js

@@ -3,17 +3,9 @@ import { TodoInputToolSchema, TodoOutputToolSchema, } from "./schemas/todo.js";
 import { registerTodoSkills } from "./skills/loader.js";
 import { readTodoData, readTodos, updateTodos } from "./storage/todo-store.js";
 import { buildTodoHint, consumeTodoHint, findNextTodo, findStuckParent, flattenLeaves, isAnyTodoActive, } from "./todos/hint.js";
+import { runReadOperation } from "./todos/read.js";
 import { TodoTree } from "./todos/todo-tree.js";
 import { updateTodoById } from "./todos/update.js";
-export function formatReadOutput(todos, options) {
-    if (todos.length === 0)
-        return "No todos recorded.";
-    const tree = new TodoTree(todos).render(options);
-    const check = new TodoTree(todos).validateAndNormalize();
-    if (check.valid)
-        return tree;
-    return `Warning: the stored list needs fixing — ${check.error}\n${tree}`;
-}
 export function formatTransitionLines(before, after) {
     const previous = new Map(flattenLeaves(before).map((leaf) => [leaf.id, leaf.status]));
     const leaves = flattenLeaves(after);
@@ -60,7 +52,7 @@ export function formatWriteOutput(todos, before = []) {
 export function assertWriteIsInitialization(existing, incoming) {
     if (existing.length > 0 && incoming.length > 0) {
         const messages = [
-            '[manage_todo_list] Invalid operation: "write".',
+            'Invalid operation: "write".',
             "",
             'The "write" operation is only allowed during initialization.',
             'Use "update" to modify an existing todo list.',
@@ -75,38 +67,6 @@ export function formatUpdateOutput(todos, before = []) {
     const progress = `Todos (${stats.completedSubTasks}/${stats.totalSubTasks}).`;
     return formatWriteOutput(todos, before).replace(/^Todos \(\d+\/\d+\) updated\./, progress.slice(0, -1));
 }
-/**
- * Narrows a list for a scoped read.
- *
- * - `scope: "root"` returns one root with every subtask, so the whole branch is
- *   visible.
- * - `scope: "children"` prints the root line as context plus the targeted
- *   subtask line, matching a "show me this subtask within its root" read.
- * - `scope: "item"` prints only the targeted row.
- *
- * Either way the root keeps every subtask in the *data*, because the root's
- * `(completed/total)` label is computed from them — dropping them would
- * silently turn `(2/2)` into `(1/1)`.
- */
-export function selectReadScope(todos, input) {
-    if (input.scope !== "item" && input.scope !== "children" && input.scope !== "root") {
-        return { todos: [...todos] };
-    }
-    const target = input.target;
-    const rootId = Number.isInteger(target) ? target : Math.floor(target);
-    const root = todos.find((item) => item.id === rootId);
-    const child = Number.isInteger(target)
-        ? undefined
-        : root?.children?.find((item) => item.id === target);
-    if (!root || (!Number.isInteger(target) && !child)) {
-        throw new Error(`[manage_todo_list] todo id ${target} was not found`);
-    }
-    // `root` shows the branch as-is; it needs no row filter at all.
-    if (input.scope === "root")
-        return { todos: [root] };
-    const visibleIds = input.scope === "children" ? [rootId, target] : [target];
-    return { todos: [root], visibleIds };
-}
 export async function registerTodoTools(ctx) {
     await ctx.tool.transform((tools) => {
         tools.add({
@@ -123,18 +83,16 @@ export async function registerTodoTools(ctx) {
             execute: async (input, toolContext) => {
                 const parsed = TodoInputToolSchema.safeParse(input);
                 if (!parsed.success) {
-                    throw new Error(`[manage_todo_list validation failed] ${parsed.error.issues
+                    throw new Error(`Invalid manage_todo_list input: ${parsed.error.issues
                         .map((i) => `${i.path.join(".") || "input"}: ${i.message}`)
                         .join(", ")}`);
                 }
                 if (parsed.data.operation === "read") {
                     const todos = await readTodos(toolContext.sessionID);
-                    const scoped = selectReadScope(todos, parsed.data);
+                    const result = runReadOperation(todos, parsed.data);
                     return {
-                        output: { todos: scoped.todos },
-                        content: formatReadOutput(scoped.todos, {
-                            visibleIds: scoped.visibleIds,
-                        }),
+                        output: { todos: result.todos },
+                        content: result.content,
                     };
                 }
                 if (parsed.data.operation === "update") {

package/dist/storage/migrate-json.js

@@ -54,7 +54,7 @@ export function parseLegacyTodos(raw) {
         parsed = JSON.parse(raw);
     }
     catch (error) {
-        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${error instanceof Error ? error.message : String(error)}`);
+        throw new InvalidTodoDataError(`invalid todo data: ${error instanceof Error ? error.message : String(error)}`);
     }
     const list = Array.isArray(parsed)
         ? parsed
@@ -62,11 +62,11 @@ export function parseLegacyTodos(raw) {
             ? parsed.todos
             : undefined;
     if (!Array.isArray(list)) {
-        throw new InvalidTodoDataError("[todo store read failed] invalid todo data: todo list is missing");
+        throw new InvalidTodoDataError("invalid todo data: todo list is missing");
     }
     const result = TodoListSchema.safeParse(list);
     if (!result.success) {
-        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${result.error.issues
+        throw new InvalidTodoDataError(`invalid todo data: ${result.error.issues
             .map((issue) => issue.message)
             .join(", ")}`);
     }

package/dist/storage/todo-store.js

@@ -26,7 +26,7 @@ export class TodoStore {
     static normalizeSessionID(sessionID) {
         const normalized = sessionID.trim();
         if (!TodoStore.SESSION_ID_PATTERN.test(normalized)) {
-            throw new Error("[todo store] invalid session ID");
+            throw new Error("invalid session ID");
         }
         return normalized;
     }
@@ -281,7 +281,7 @@ export class TodoStore {
             if (!result.valid) {
                 // Throwing inside the transaction rolls it back, so an invalid list
                 // never reaches disk and never bumps the revision.
-                throw new Error(`[todo store validation failed] ${result.error}`);
+                throw new Error(result.error);
             }
             return result.data;
         }).todos;

package/dist/todos/read.d.ts

@@ -0,0 +1,44 @@
+import type { TodoReadInput, TodoRootItem } from "../schemas/todo";
+/**
+ * Render a list as the tree the `read` operation answers with.
+ *
+ * A list that fails validation still renders — showing the rows is more useful
+ * than refusing — but the warning goes first so the caller fixes it before
+ * trusting the shape.
+ */
+export declare function formatReadOutput(todos: readonly TodoRootItem[], options?: {
+    visibleIds?: readonly number[];
+}): string;
+/**
+ * Narrows a list for a scoped read.
+ *
+ * - `scope: "root"` returns one root with every subtask, so the whole branch is
+ *   visible.
+ * - `scope: "children"` prints the root line as context plus the targeted
+ *   subtask line, matching a "show me this subtask within its root" read.
+ * - `scope: "item"` prints only the targeted row.
+ *
+ * Either way the root keeps every subtask in the *data*, because the root's
+ * `(completed/total)` label is computed from them — dropping them would
+ * silently turn `(2/2)` into `(1/1)`.
+ */
+export declare function selectReadScope(todos: readonly TodoRootItem[], input: TodoReadInput): {
+    todos: TodoRootItem[];
+    visibleIds?: readonly number[];
+};
+export interface ReadOperationResult {
+    /** Scope-narrowed list, also what the tool returns as structured output. */
+    todos: TodoRootItem[];
+    /** Rows to print for `children`/`item`; absent means "print everything". */
+    visibleIds?: readonly number[];
+    /** Rendered tree, ready to hand back as tool content. */
+    content: string;
+}
+/**
+ * Whole `read` operation, minus storage.
+ *
+ * Kept pure on purpose: the caller reads the session's list and passes it in,
+ * so this module never needs a session id and mirrors `updateTodoById` instead
+ * of the storage-facing wrappers.
+ */
+export declare function runReadOperation(todos: readonly TodoRootItem[], input: TodoReadInput): ReadOperationResult;

package/dist/todos/read.js

@@ -0,0 +1,67 @@
+import { TodoTree } from "./todo-tree.js";
+/**
+ * Render a list as the tree the `read` operation answers with.
+ *
+ * A list that fails validation still renders — showing the rows is more useful
+ * than refusing — but the warning goes first so the caller fixes it before
+ * trusting the shape.
+ */
+export function formatReadOutput(todos, options) {
+    if (todos.length === 0)
+        return "No todos recorded.";
+    const tree = new TodoTree(todos).render(options);
+    const check = new TodoTree(todos).validateAndNormalize();
+    if (check.valid)
+        return tree;
+    return `Warning: the stored list needs fixing — ${check.error}\n${tree}`;
+}
+/**
+ * Narrows a list for a scoped read.
+ *
+ * - `scope: "root"` returns one root with every subtask, so the whole branch is
+ *   visible.
+ * - `scope: "children"` prints the root line as context plus the targeted
+ *   subtask line, matching a "show me this subtask within its root" read.
+ * - `scope: "item"` prints only the targeted row.
+ *
+ * Either way the root keeps every subtask in the *data*, because the root's
+ * `(completed/total)` label is computed from them — dropping them would
+ * silently turn `(2/2)` into `(1/1)`.
+ */
+export function selectReadScope(todos, input) {
+    if (input.scope !== "item" &&
+        input.scope !== "children" &&
+        input.scope !== "root") {
+        return { todos: [...todos] };
+    }
+    const target = input.target;
+    const rootId = Number.isInteger(target) ? target : Math.floor(target);
+    const root = todos.find((item) => item.id === rootId);
+    const child = Number.isInteger(target)
+        ? undefined
+        : root?.children?.find((item) => item.id === target);
+    if (!root || (!Number.isInteger(target) && !child)) {
+        throw new Error(`todo id ${target} was not found`);
+    }
+    // `root` shows the branch as-is; it needs no row filter at all.
+    if (input.scope === "root")
+        return { todos: [root] };
+    const visibleIds = input.scope === "children" ? [rootId, target] : [target];
+    return { todos: [root], visibleIds };
+}
+/**
+ * Whole `read` operation, minus storage.
+ *
+ * Kept pure on purpose: the caller reads the session's list and passes it in,
+ * so this module never needs a session id and mirrors `updateTodoById` instead
+ * of the storage-facing wrappers.
+ */
+export function runReadOperation(todos, input) {
+    const scoped = selectReadScope(todos, input);
+    const content = formatReadOutput(scoped.todos, {
+        visibleIds: scoped.visibleIds,
+    });
+    return scoped.visibleIds === undefined
+        ? { todos: scoped.todos, content }
+        : { todos: scoped.todos, visibleIds: scoped.visibleIds, content };
+}

package/dist/todos/todo-tree.d.ts

@@ -54,8 +54,26 @@ export declare class TodoTree {
     /**
      * Rejects completed parents with unfinished children, and auto-completes a
      * parent whose children are all completed.
+     *
+     * The order check runs **after** the auto-complete above, never before: a
+     * parent whose children all finished is raised to `completed` here, and that
+     * promotion can itself create an out-of-order list. Checking first would let
+     * the promotion slip past the check.
      */
     private normalize;
+    /**
+     * Roots run in order, so nothing after the first unfinished root may be
+     * finished.
+     *
+     * Only `error` is allowed to follow an open root — a broken task has to be
+     * fixable even while earlier work is still open. Everything else
+     * (`completed`, `in_progress`, `cancelled`) has to wait its turn.
+     *
+     * This lives here rather than in `update.ts` because `write` and the legacy
+     * importer reach the database without passing the update rules at all. One
+     * check in the shared validator closes every path at once.
+     */
+    private static findOrderError;
     /**
      * Renders the tree.
      *

package/dist/todos/todo-tree.js

@@ -132,6 +132,11 @@ export class TodoTree {
     /**
      * Rejects completed parents with unfinished children, and auto-completes a
      * parent whose children are all completed.
+     *
+     * The order check runs **after** the auto-complete above, never before: a
+     * parent whose children all finished is raised to `completed` here, and that
+     * promotion can itself create an out-of-order list. Checking first would let
+     * the promotion slip past the check.
      */
     normalize() {
         const normalized = [];
@@ -156,8 +161,39 @@ export class TodoTree {
                 status: allChildrenCompleted ? "completed" : item.status,
             });
         }
+        const orderError = TodoTree.findOrderError(normalized);
+        if (orderError)
+            return { valid: false, error: orderError };
         return { valid: true, data: normalized };
     }
+    /**
+     * Roots run in order, so nothing after the first unfinished root may be
+     * finished.
+     *
+     * Only `error` is allowed to follow an open root — a broken task has to be
+     * fixable even while earlier work is still open. Everything else
+     * (`completed`, `in_progress`, `cancelled`) has to wait its turn.
+     *
+     * This lives here rather than in `update.ts` because `write` and the legacy
+     * importer reach the database without passing the update rules at all. One
+     * check in the shared validator closes every path at once.
+     */
+    static findOrderError(todos) {
+        const isFinal = (status) => status === "completed" || status === "cancelled";
+        let firstOpen;
+        for (const root of todos) {
+            if (!firstOpen) {
+                if (!isFinal(root.status))
+                    firstOpen = root;
+                continue;
+            }
+            // Past the first open root: a later root must still be untouched.
+            if (root.status === "pending" || root.status === "error")
+                continue;
+            return `Task '${root.id}' is '${root.status}' but earlier task '${firstOpen.id}' is still '${firstOpen.status}'. Roots run in order: finish or cancel '${firstOpen.id}' first.`;
+        }
+        return null;
+    }
     // Rendering
     /**
      * Renders the tree.

package/dist/todos/update.js

@@ -38,7 +38,7 @@ function assertForwardTransition(from, to, id) {
     if (from === to)
         return;
     if (!(FORWARD_TRANSITIONS[from] ?? []).includes(to)) {
-        throw new Error(`[manage_todo_list] todo ${id} cannot move from '${from}' to '${to}'. Progress only moves forward; use 'error' to report a failure and fix it from there.`);
+        throw new Error(`todo ${id} cannot move from '${from}' to '${to}'. Progress only moves forward; use 'error' to report a failure and fix it from there.`);
     }
 }
 /** Any root still open, an `error` root included. */
@@ -65,11 +65,11 @@ export function assertSequentialScope(todos, input) {
     const targetRoot = todos.find((root) => root.id === input.id ||
         root.children?.some((child) => child.id === input.id));
     if (!targetRoot) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     const firstOpen = todos.findIndex((root) => !isFinal(root.status));
     if (firstOpen === -1) {
-        throw new Error("[manage_todo_list] every todo is already finished; nothing can be updated.");
+        throw new Error("every todo is already finished; nothing can be updated.");
     }
     const targetRootIndex = todos.indexOf(targetRoot);
     if (targetRootIndex !== firstOpen && !hasError(targetRoot)) {
@@ -80,10 +80,10 @@ export function assertSequentialScope(todos, input) {
         ? targetRoot
         : targetRoot.children?.find((child) => child.id === input.id);
     if (!target) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     if (isFinal(target.status)) {
-        throw new Error(`[manage_todo_list] todo ${input.id} is '${target.status}' and final; it cannot be changed.`);
+        throw new Error(`todo ${input.id} is '${target.status}' and final; it cannot be changed.`);
     }
     assertForwardTransition(target.status, input.status, input.id);
     if (input.status === "in_progress") {
@@ -93,7 +93,7 @@ export function assertSequentialScope(todos, input) {
         }
         const busyChild = targetRoot.children?.find((child) => child.status === "in_progress" && child.id !== input.id);
         if (busyChild) {
-            throw new Error(`[manage_todo_list] subtask ${busyChild.id} is still in_progress. Finish it (or cancel it) before starting ${input.id}.`);
+            throw new Error(`subtask ${busyChild.id} is still in_progress. Finish it (or cancel it) before starting ${input.id}.`);
         }
     }
     return { targetRoot, target };
@@ -134,7 +134,7 @@ export function updateTodoById(todos, input) {
         return { ...root, status, children };
     });
     if (!updated) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     return { todos: nextTodos, updated };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamflaz/opencode-todolist",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Hierarchical todo list plugin for OpenCode with a real-time TUI widget.",
   "type": "module",
   "files": [