dsh-tree-task-flow 0.3.12 → 0.3.14

package/lib/tools.js

@@ -1,5 +1,13 @@
 /**
- * 六个 `tree_task_*` 工具。
+ * 七个 `tree_task_*` 工具。
+ *
+ * **写树分成两个工具，不是可以合并的重复。** `tree_task_create` 与 `tree_task_done`
+ * 是折叠区间的两个边界（见 `lib/region.js`）：`create` 是"开工"那一下，`done` 是
+ * "收工"那一下。`create` 只在新建目标时调用一次，`plan` 却在任务中途反复调用——
+ * 把两者并成一个工具，折叠起点就只能靠实参里有没有 `parentId` 去猜，
+ * 模型一次写漏或多写就会把起点挪走，那段过程就再也收不走了。
+ * 代价是两个工具的实参形状有点像（都是一串 `{title, detail}`），
+ * 所以 `plan` 的说明里专门写了一句"建新目标不归它管"。
  *
  * 工具本身**只做状态读写**——不注入消息、不动 surface，也不拦任何别的工具。
  * 「完成时把这个节点的执行过程从上下文里折起来、换成一条携带它结果的汇总」
@@ -22,9 +30,13 @@ import {
   addGoal,
   complete,
   createPlan,
+  deleteNode,
   doneReply,
   dropNode,
+  findNode,
+  goalsOf,
   renderContinue,
+  renderGoal,
   renderTree,
   updateNode,
 } from "./plan.js";
@@ -65,21 +77,35 @@ export function registerTools(ctx, { store, cfg }) {
   ctx.tools.register({
     name: "tree_task_status",
     description:
-      "查看当前计划树：目标、任务、子任务各自的状态与已提交的结果，以及现在该推进哪个节点。" +
-      "任务开头、上下文被压缩之后、或者不确定下一步做什么时，调用它。",
-    parameters: { type: "object", additionalProperties: false, properties: {} },
+      "查看计划树：目标、任务、子任务各自的状态与已提交的结果，以及现在该推进哪个节点。" +
+      "任务开头、上下文被压缩之后、或者不确定下一步做什么时，调用它。" +
+      "默认只展开还没结束的目标——已经做完的目标只留目标那一行，要看它的完整树就把 id 填上。",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string",
+          description:
+            "可选。填目标 id 就返回那个目标的完整树（已完成的目标默认不展开）；" +
+            "填任务或子任务 id，就按它所在的那个目标展开。",
+        },
+      },
+    },
     output: OUTPUT,
-    async execute(_args, exec) {
+    async execute(args, exec) {
       const plan = store.readPlan(sessionOf(exec));
-      return ok(renderTree(plan));
+      return ok(renderTree(plan, args?.id ?? null));
     },
   });
 
   ctx.tools.register({
     name: "tree_task_create",
     description:
-      "新增一个目标：这个目标 + 它下面的若干任务。一个会话可以有多个目标，" +
-      "按调用顺序排在计划里——已经建过的目标和它们的历史都留着，不会被这次调用替换掉。" +
+      "新建一个目标：这个目标 + 它下面的若干任务。**它是「开工」那一下**——" +
+      "折叠上下文时，插件就认这次调用作为「这一轮从哪儿开始」。" +
+      "一个会话可以有多个目标，按调用顺序排在计划里——已经建过的目标和它们的历史都留着，" +
+      "不会被这次调用替换掉。" +
       "这里的任务是交付节点——一件能独立验收的交付内容，可以是需要完成或验证的某件事，" +
       "也可以是一个检查点，不是步骤本身。" +
       "建完记得用 tree_task_plan 给这个目标下的第一个任务拆子任务。",
@@ -124,8 +150,14 @@ export function registerTools(ctx, { store, cfg }) {
       }
       store.writePlan(sessionId, plan);
       return ok(
-        `${existing === null ? "计划已建立。" : `已新增目标「${goal.title}」。`}\n\n${renderTree(plan)}\n\n` +
-          "下一步：调用 tree_task_plan 给这个目标下的第一个任务拆子任务。",
+        [
+          existing === null ? `计划已建立，目标「${goal.title}」。` : `已新增目标「${goal.title}」。`,
+          "",
+          renderGoal(goal, plan, true),
+          "",
+          "下一步：给这个目标下的第一个任务拆子任务——用 tree_task_plan，" +
+            "parentId 填那个任务的 id。",
+        ].join("\n"),
       );
     },
   });
@@ -135,7 +167,8 @@ export function registerTools(ctx, { store, cfg }) {
     description:
       "给一个节点追加子节点：给目标追加任务，给任务追加子任务。" +
       "给任务追加的是步骤（需要一次性做完的事情）。" +
-      "子任务是最低一级，不能再往下拆。",
+      "子任务是最低一级，不能再往下拆。" +
+      "**建新目标不归它管，那是 tree_task_create**——它只往已有的节点上接子节点。",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -164,12 +197,13 @@ export function registerTools(ctx, { store, cfg }) {
       const result = addChildren(plan, args?.parentId, args?.children);
       if (!result.ok) return ok(`没有添加：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
+      const found = findNode(plan, args?.parentId);
       return ok(
         [
           `已添加 ${result.added.length} 个${childLabel(result.level)}：`,
-          ...result.added.map((node) => `  ${node.id}  ${node.title}`),
+          ...result.added.map((node) => `- \`${node.id}\` ${node.title}`),
           "",
-          renderTree(plan),
+          renderGoal(found.goal, plan, true),
         ].join("\n"),
       );
     },
@@ -230,7 +264,8 @@ export function registerTools(ctx, { store, cfg }) {
       const result = updateNode(plan, args?.id, args ?? {});
       if (!result.ok) return ok(`没有修改：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
-      return ok(`已更新 ${result.changed.join(" / ")}。\n\n${renderTree(plan)}`);
+      const found = findNode(plan, args?.id);
+      return ok(`已更新 ${result.changed.join(" / ")}。\n\n${renderGoal(found.goal, plan, true)}`);
     },
   });
 
@@ -255,13 +290,63 @@ export function registerTools(ctx, { store, cfg }) {
       const result = dropNode(plan, args?.id);
       if (!result.ok) return ok(`没有丢弃：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
+      const found = findNode(plan, args?.id);
       return ok(
-        [`已丢弃：${result.dropped.join("、")}`, "", renderTree(plan), "", renderContinue(plan)].join(
-          "\n",
-        ),
+        [
+          `已丢弃：${result.dropped.join("、")}`,
+          "",
+          renderGoal(found.goal, plan, true),
+          "",
+          renderContinue(plan),
+        ].join("\n"),
       );
     },
   });
 
+  ctx.tools.register({
+    name: "tree_task_delete",
+    description:
+      "从树里删掉一个节点——**清理**用的，不是「这件事不做了」。" +
+      "丢弃（tree_task_drop）是留个记号：这件事我不做，但树里还查得到它曾经有过；" +
+      "删除是把内容凭空摘掉，连同它下面的任务或子任务一起，" +
+      "**不看状态**（已完成、已丢弃的都删得掉）。" +
+      "内容写错了、建重了、结果记在了错的地方，就用这个。",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", description: "要删除的节点 id" },
+      },
+      required: ["id"],
+    },
+    output: OUTPUT,
+    async execute(args, exec) {
+      const plan = store.readPlan(sessionOf(exec));
+      if (!plan) return ok("还没有计划。");
+      // 删掉之后就查不到"这次动的是哪个目标"了，先记一份。
+      const touched = findNode(plan, args?.id);
+      const result = deleteNode(plan, args?.id);
+      if (!result.ok) return ok(`没有删除：${result.reason}`);
+      store.writePlan(sessionOf(exec), plan);
+
+      const lines = [`已删除：${result.removed.join("、")}`, ""];
+      if (touched !== null && touched.level !== "goal") {
+        // 删的是任务或子任务：它所在的那个目标还在，照旧只给它一个目标的树。
+        lines.push(renderGoal(touched.goal, plan, true));
+      } else {
+        // 删的是目标：那个目标已经不存在了，没有"它所在的树"可给。
+        // 剩下的目标数说一句就够——要看细节再调 tree_task_status。
+        const rest = goalsOf(plan).length;
+        lines.push(
+          rest === 0
+            ? "计划树现在空了。（要用就用 tree_task_create 建新目标。）"
+            : `这个会话还剩 ${rest} 个目标，要看细节用 tree_task_status。`,
+        );
+      }
+      lines.push("", renderContinue(plan));
+      return ok(lines.join("\n"));
+    },
+  });
+
   void cfg;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tree-task-flow",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "树形任务流：把多步任务组织成目标→任务→子任务三级树，节点完成时由 AI 提交结果，插件随即把该节点的执行过程从上下文里折叠掉，只留下结果。",
   "type": "module",
   "main": "lib/index.js",