@j0hanz/todokit-mcp 1.2.0 → 1.2.2

package/README.md

@@ -66,6 +66,8 @@ npm start
 
 By default, todos are stored in `todos.json` in the current working directory. To control where data is written, set the `TODOKIT_TODO_FILE` environment variable to an absolute or relative path ending with `.json`. Relative paths resolve from the current working directory. The directory is created as needed; if the file does not exist, the server starts with an empty list.
 
+When all todos are completed, the server removes the storage file so it does not linger on disk.
+
 Examples:
 
 ```bash
@@ -231,6 +233,8 @@ Result fields:
 
 Delete all todos from the list.
 
+This also removes the configured todo storage file (defaults to `todos.json`), so the next read starts from an empty list.
+
 | Parameter | Type | Required | Default | Description |
 | :-------- | :--- | :------- | :------ | :---------- |
 | (none)    | -    | -        | -       | -           |

package/dist/storage.js

@@ -278,31 +278,89 @@ export async function readTodos() {
     return todos;
 }
 export async function withTodos(mutate) {
+    return withTodoFileUpdate((todos) => {
+        const { todos: nextTodos, result } = mutate(todos);
+        if (nextTodos === todos) {
+            return { kind: 'no_change', result };
+        }
+        if (areAllTodosCompleted(nextTodos)) {
+            return { kind: 'delete_file', result };
+        }
+        return { kind: 'save', todos: nextTodos, result };
+    });
+}
+function areAllTodosCompleted(todos) {
+    return todos.length > 0 && todos.every((todo) => todo.completed);
+}
+function normalizeTodoFileUpdate(outcome, current, hasPersistedFile) {
+    if (outcome.kind === 'save' && areAllTodosCompleted(outcome.todos)) {
+        return {
+            kind: 'proceed',
+            outcome: { kind: 'delete_file', result: outcome.result },
+        };
+    }
+    if (outcome.kind !== 'no_change') {
+        return { kind: 'proceed', outcome };
+    }
+    if (hasPersistedFile && areAllTodosCompleted(current)) {
+        return {
+            kind: 'proceed',
+            outcome: { kind: 'delete_file', result: outcome.result },
+        };
+    }
+    return { kind: 'return', result: outcome.result };
+}
+async function deleteTodoFile(path) {
+    const start = nowMs();
+    await withTimeout(rm(path, { force: true }), WRITE_TIMEOUT_MS, 'File remove timed out').catch((error) => {
+        if (isNotFoundError(error))
+            return;
+        throw error;
+    });
+    cache = { todos: [], mtimeMs: null };
+    publishStorageEvent({
+        v: 1,
+        kind: 'storage',
+        op: 'write',
+        at: new Date().toISOString(),
+        durationMs: Math.max(0, nowMs() - start),
+        todoCount: 0,
+        renameRetries: 0,
+    });
+}
+async function withTodoFileUpdate(work) {
     return enqueueWrite(async () => {
         const path = getTodoFilePath();
         for (let attempt = 0; attempt <= MAX_CONFLICT_RETRIES; attempt += 1) {
             const mtimeMs = await getFileMtime(path, IO_TIMEOUT_MS);
             const current = cache?.mtimeMs === mtimeMs ? cache.todos : await loadTodos(path);
             cache = { todos: current, mtimeMs };
-            const { todos, result } = mutate(current);
-            if (todos !== current) {
-                const release = await acquireWriteLock(path, getLockTimeoutMs());
-                try {
-                    const latestMtime = await getFileMtime(path, IO_TIMEOUT_MS);
-                    if (latestMtime !== mtimeMs) {
-                        if (attempt >= MAX_CONFLICT_RETRIES) {
-                            throw createCodedError('E_STORAGE_CONFLICT', 'Todo storage changed during update; please retry.');
-                        }
-                        await delay(25 * (attempt + 1));
-                        continue;
+            const normalized = normalizeTodoFileUpdate(work(current), current, mtimeMs !== null);
+            if (normalized.kind === 'return') {
+                return normalized.result;
+            }
+            const { outcome } = normalized;
+            const release = await acquireWriteLock(path, getLockTimeoutMs());
+            try {
+                const latestMtime = await getFileMtime(path, IO_TIMEOUT_MS);
+                if (latestMtime !== mtimeMs) {
+                    if (attempt >= MAX_CONFLICT_RETRIES) {
+                        throw createCodedError('E_STORAGE_CONFLICT', 'Todo storage changed during update; please retry.');
                     }
-                    await saveTodos(path, todos);
+                    await delay(25 * (attempt + 1));
+                    continue;
                 }
-                finally {
-                    await release();
+                if (outcome.kind === 'save') {
+                    await saveTodos(path, outcome.todos);
                 }
+                else {
+                    await deleteTodoFile(path);
+                }
+                return outcome.result;
+            }
+            finally {
+                await release();
             }
-            return result;
         }
         throw createCodedError('E_STORAGE_CONFLICT', 'Todo storage update failed due to concurrent modifications');
     });
@@ -565,8 +623,8 @@ export function deleteTodosByIds(ids) {
     });
 }
 export function deleteAllTodos() {
-    return withTodos((todos) => {
-        const deletedIds = todos.map((todo) => todo.id);
-        return { todos: [], result: deletedIds };
-    });
+    return withTodoFileUpdate((todos) => ({
+        kind: 'delete_file',
+        result: todos.map((todo) => todo.id),
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/todokit-mcp",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "mcpName": "io.github.j0hanz/todokit",
   "description": "A MCP server for Todokit, a task management and productivity tool with JSON storage.",
   "type": "module",