dsh-checklists 0.3.2 → 0.4.0

package/README.md

@@ -28,6 +28,8 @@ If the agent forgets to mark something, you say so in chat and it fixes it.
 | `checklist_edit` | Changes an item's text (not its state) |
 | `checklist_list` | Full tree with ids and states, for when the digest is truncated |
 | `checklist_delete` | Deletes a list (by id or exact title) |
+| `checklist_remove_item` | Removes one item and everything nested under it |
+| `checklist_rename` | Renames a list; titles stay unique within the session |
 | `checklist_template_save` | Saves a list as a reusable template for future sessions |
 
 Items are plain strings. **Two leading spaces per level** nest them:
@@ -48,7 +50,7 @@ From a local build or tarball:
 npm install
 npm run build
 npm pack
-dsh plugin --profile dev add ./dsh-checklists-0.3.2.tgz
+dsh plugin --profile dev add ./dsh-checklists-0.4.0.tgz
 dsh --profile dev --dump-config        # the tool-checklist row should appear
 ```
 
@@ -88,6 +90,8 @@ document degrades to an empty list instead of failing the turn.
 
 ## Sidebar tab
 
+![Checklist sidebar tab](assets/screenshot-1.png)
+
 Open the right sidebar, then the **guide** (`+`) and pick **Checklist**.
 
 | Action | How |

package/lib/model.js

@@ -147,6 +147,56 @@ export function findItemById(lists, id) {
     }
     return undefined;
 }
+/**
+ * Remove one item (and its whole subtree) by exact id.
+ *
+ * Mutates the array in place, so callers must pass a document they own — the
+ * store's `update` already hands out a clone.
+ *
+ * @param items - sibling list to search, at any depth.
+ * @param id - exact item id.
+ * @returns the removed node, or `undefined` when no item has that id.
+ */
+export function removeItemById(items, id) {
+    const index = items.findIndex((entry) => entry.id === id);
+    if (index >= 0)
+        return items.splice(index, 1)[0];
+    for (const item of items) {
+        const removed = removeItemById(item.children, id);
+        if (removed)
+            return removed;
+    }
+    return undefined;
+}
+/**
+ * Validate a checklist rename before applying it.
+ *
+ * Titles are how the user reads the sidebar and how `findList` resolves a
+ * reference, so a rename must never create a second list with the same title.
+ * Renaming a list to its own title (any case) is a no-op, not a conflict.
+ *
+ * @param lists - the session's checklists.
+ * @param ref - checklist id or exact title.
+ * @param nextTitle - the requested new title.
+ * @returns the resolved list, or the reason the rename cannot proceed.
+ */
+export function checkRename(lists, ref, nextTitle) {
+    const to = nextTitle.trim();
+    if (to.length === 0)
+        return { kind: 'empty' };
+    const list = findList(lists, ref);
+    if (!list) {
+        return { kind: 'missing', available: lists.map((entry) => `${entry.id} (${entry.title})`) };
+    }
+    const lower = to.toLowerCase();
+    if (list.title.trim().toLowerCase() === lower) {
+        return { kind: 'ok', list, from: list.title, to };
+    }
+    const clash = lists.find((entry) => entry !== list && entry.title.trim().toLowerCase() === lower);
+    if (clash)
+        return { kind: 'duplicate', existing: clash.title };
+    return { kind: 'ok', list, from: list.title, to };
+}
 /**
  * The next item to work on, in depth-first order.
  *

package/lib/tools.js

@@ -5,7 +5,7 @@
  * the single source of truth and the sidebar (phase 2) is a read-only mirror.
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { buildItems, countItems, findList, flatten, ITEM_STATES, isItemState, mintId, nextItem, resolveRef, toLines, } from './model.js';
+import { buildItems, checkRename, countItems, findList, flatten, ITEM_STATES, isItemState, mintId, nextItem, removeItemById, resolveRef, toLines, } from './model.js';
 /** Ships with the plugin so a first run has something to instantiate. */
 const DEFAULT_TEMPLATES = {
     release: [
@@ -482,6 +482,138 @@ export function registerChecklistTools(ctx, store, config = {}) {
             });
         },
     })));
+    ctx.effect(() => ctx.tools.register(defineTool({
+        name: 'checklist_rename',
+        description: 'Rename an existing checklist in the CURRENT session. Titles must be unique within the session. '
+            + 'Pass the id from checklist_list, or the exact current title.',
+        parameters: {
+            listId: {
+                type: 'string',
+                required: true,
+                description: 'Checklist id, or its exact current title.',
+            },
+            title: {
+                type: 'string',
+                required: true,
+                description: 'New title for the checklist.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    listId: { type: 'string', required: true },
+                    from: { type: 'string', required: true },
+                    to: { type: 'string', required: true },
+                },
+            },
+            render: (_args, value) => {
+                const result = value;
+                return [{ type: 'text', text: `Renamed "${result.from}" → "${result.to}".` }];
+            },
+        },
+        timeoutMs: 10_000,
+        async execute(args, exec) {
+            const input = args;
+            const sessionId = sessionOf(exec);
+            const ref = text(input.listId).trim();
+            const nextTitle = text(input.title).trim();
+            if (ref.length === 0)
+                throw new Error('checklist_rename: listId must not be empty');
+            if (nextTitle.length === 0)
+                throw new Error('checklist_rename: title must not be empty');
+            if (nextTitle.length > 120)
+                throw new Error('checklist_rename: title is longer than 120 characters');
+            return store.update(sessionId, (doc) => {
+                const check = checkRename(doc.lists, ref, nextTitle);
+                if (check.kind === 'empty')
+                    throw new Error('checklist_rename: title must not be empty');
+                if (check.kind === 'missing') {
+                    const available = check.available.join(', ');
+                    throw new Error(`checklist_rename: no checklist "${ref}" in this session. `
+                        + `Available: ${available.length > 0 ? available : 'none'}`);
+                }
+                if (check.kind === 'duplicate') {
+                    throw new Error(`checklist_rename: a checklist titled "${check.existing}" already exists in this session`);
+                }
+                check.list.title = check.to;
+                return { listId: check.list.id, from: check.from, to: check.to };
+            });
+        },
+    })));
+    ctx.effect(() => ctx.tools.register(defineTool({
+        name: 'checklist_remove_item',
+        description: 'Remove one item — and everything nested under it — from a checklist in the CURRENT session. '
+            + 'Match it by id or exact text. Use it to drop work that no longer applies; '
+            + 'to change the item instead, use checklist_edit.',
+        parameters: {
+            listId: {
+                type: 'string',
+                required: true,
+                description: 'Checklist id, or its exact title.',
+            },
+            item: {
+                type: 'string',
+                required: true,
+                description: 'Item id or exact item text.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    listId: { type: 'string', required: true },
+                    itemId: { type: 'string', required: true },
+                    text: { type: 'string', required: true },
+                    removed: { type: 'integer', required: true },
+                },
+            },
+            render: (_args, value) => {
+                const result = value;
+                const extra = result.removed > 1 ? ` (+${result.removed - 1} nested)` : '';
+                return [{ type: 'text', text: `Removed "${result.text}"${extra}.` }];
+            },
+        },
+        timeoutMs: 10_000,
+        async execute(args, exec) {
+            const input = args;
+            const sessionId = sessionOf(exec);
+            const listRef = text(input.listId).trim();
+            const itemRef = text(input.item).trim();
+            if (listRef.length === 0)
+                throw new Error('checklist_remove_item: listId must not be empty');
+            if (itemRef.length === 0)
+                throw new Error('checklist_remove_item: item must not be empty');
+            return store.update(sessionId, (doc) => {
+                const list = findList(doc.lists, listRef);
+                if (!list) {
+                    const available = doc.lists.map((entry) => `${entry.id} (${entry.title})`).join(', ');
+                    throw new Error(`checklist_remove_item: no checklist "${listRef}" in this session. `
+                        + `Available: ${available.length > 0 ? available : 'none'}`);
+                }
+                const found = resolveRef([list], itemRef);
+                if (found.kind === 'ambiguous') {
+                    const options = found.candidates.map((entry) => `${entry.item.id} (${entry.item.text})`).join(', ');
+                    throw new Error(`checklist_remove_item: "${itemRef}" is ambiguous; use an id: ${options}`);
+                }
+                if (found.kind === 'miss') {
+                    throw new Error(`checklist_remove_item: no item "${itemRef}" in "${list.title}". Call checklist_list for ids.`);
+                }
+                const removed = removeItemById(list.items, found.hit.item.id);
+                if (!removed) {
+                    throw new Error(`checklist_remove_item: item "${itemRef}" disappeared from "${list.title}"`);
+                }
+                return {
+                    listId: list.id,
+                    itemId: removed.id,
+                    text: removed.text,
+                    removed: countItems([removed]).total,
+                };
+            });
+        },
+    })));
     ctx.effect(() => ctx.tools.register(defineTool({
         name: 'checklist_delete',
         description: 'Delete one checklist from the CURRENT session. The list and its items are gone; there is no archive. '

package/lib/types/model.d.ts

@@ -97,6 +97,44 @@ export declare function findItemById(lists: readonly Checklist[], id: string): {
     list: Checklist;
     item: ChecklistItem;
 } | undefined;
+/**
+ * Remove one item (and its whole subtree) by exact id.
+ *
+ * Mutates the array in place, so callers must pass a document they own — the
+ * store's `update` already hands out a clone.
+ *
+ * @param items - sibling list to search, at any depth.
+ * @param id - exact item id.
+ * @returns the removed node, or `undefined` when no item has that id.
+ */
+export declare function removeItemById(items: ChecklistItem[], id: string): ChecklistItem | undefined;
+export type RenameCheck = {
+    kind: 'ok';
+    list: Checklist;
+    from: string;
+    to: string;
+} | {
+    kind: 'empty';
+} | {
+    kind: 'missing';
+    available: string[];
+} | {
+    kind: 'duplicate';
+    existing: string;
+};
+/**
+ * Validate a checklist rename before applying it.
+ *
+ * Titles are how the user reads the sidebar and how `findList` resolves a
+ * reference, so a rename must never create a second list with the same title.
+ * Renaming a list to its own title (any case) is a no-op, not a conflict.
+ *
+ * @param lists - the session's checklists.
+ * @param ref - checklist id or exact title.
+ * @param nextTitle - the requested new title.
+ * @returns the resolved list, or the reason the rename cannot proceed.
+ */
+export declare function checkRename(lists: readonly Checklist[], ref: string, nextTitle: string): RenameCheck;
 export interface NextItem {
     list: Checklist;
     item: ChecklistItem;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-checklists",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Session-scoped checklists for DeepSeek Harness: the agent tracks work as a tree, the model always sees a compact digest, and a read-only sidebar tab mirrors it.",
   "type": "module",
   "main": "lib/index.js",
@@ -19,6 +19,7 @@
   "files": [
     "lib",
     "client",
+    "assets",
     "cordis.patch.yml",
     "README.md"
   ],