dsh-tree-task-flow 0.3.4 → 0.3.6

package/lib/plan.js

@@ -81,28 +81,74 @@ function makeTask(input, now) {
  * @param now - 注入的时间戳，便于测试。
  * @returns 完整的计划树对象。
  */
-export function createPlan(input, now = Date.now()) {
+/**
+ * 建一个目标：它自己的字段 + 一批任务。
+ *
+ * 一个会话可以有**多个**目标，它们是最外层的兄弟，按创建顺序排。
+ *
+ * @param input - `{ title, detail?, tasks: [{ title, detail? }] }`。
+ * @param now - 注入的时间戳，便于测试。
+ * @returns 目标节点。
+ */
+export function createGoal(input, now = Date.now()) {
   const tasks = Array.isArray(input?.tasks) ? input.tasks : [];
   if (tasks.length === 0) {
     throw new Error("至少要有一个任务；请在 tasks 里给出");
   }
   return {
-    version: 1,
+    id: newId("g"),
+    title: normalizeTitle(input?.title, "(未命名目标)"),
+    detail: String(input?.detail ?? ""),
+    status: STATUS.PENDING,
+    createdAt: now,
+    completedAt: null,
+    result: null,
+    tasks: tasks.map((task) => makeTask(task, now)),
+  };
+}
+
+/**
+ * 建一棵全新的计划树：只含一个目标。
+ *
+ * @param input - `{ title, detail?, tasks: [{ title, detail? }] }`。
+ * @param now - 注入的时间戳，便于测试。
+ * @returns 完整的计划树对象。
+ */
+export function createPlan(input, now = Date.now()) {
+  return {
+    version: 2,
     createdAt: now,
     updatedAt: now,
-    goal: {
-      id: newId("g"),
-      title: normalizeTitle(input?.title, "(未命名目标)"),
-      detail: String(input?.detail ?? ""),
-      status: STATUS.PENDING,
-      createdAt: now,
-      completedAt: null,
-      result: null,
-      tasks: tasks.map((task) => makeTask(task, now)),
-    },
+    goals: [createGoal(input, now)],
   };
 }
 
+/**
+ * 往计划里追加一个目标——同一个会话里再立一个目标走这里，不是重建整棵树。
+ *
+ * @param plan - 计划树。
+ * @param input - 同 `createGoal`。
+ * @param now - 时间戳。
+ * @returns 新加的目标节点。
+ */
+export function addGoal(plan, input, now = Date.now()) {
+  const goal = createGoal(input, now);
+  if (!Array.isArray(plan.goals)) plan.goals = [];
+  plan.goals.push(goal);
+  plan.updatedAt = now;
+  return goal;
+}
+
+/**
+ * 计划里的全部目标。
+ *
+ * @param plan - 计划树。
+ * @returns 目标数组；没有计划时是空数组。
+ */
+export function goalsOf(plan) {
+  return Array.isArray(plan?.goals) ? plan.goals : [];
+}
+
 /**
  * 按 id 找节点，并给出它在树里的位置。
  *
@@ -111,18 +157,18 @@ export function createPlan(input, now = Date.now()) {
  * @returns `{ level, goal, task, step, node }`，找不到返回 null。
  */
 export function findNode(plan, id) {
-  const goal = plan?.goal;
-  if (!goal) return null;
-  if (goal.id === id) {
-    return { level: "goal", goal, task: null, step: null, node: goal };
-  }
-  for (const task of goal.tasks ?? []) {
-    if (task.id === id) {
-      return { level: "task", goal, task, step: null, node: task };
+  for (const goal of goalsOf(plan)) {
+    if (goal.id === id) {
+      return { level: "goal", goal, task: null, step: null, node: goal };
     }
-    for (const step of task.steps ?? []) {
-      if (step.id === id) {
-        return { level: "step", goal, task, step, node: step };
+    for (const task of goal.tasks ?? []) {
+      if (task.id === id) {
+        return { level: "task", goal, task, step: null, node: task };
+      }
+      for (const step of task.steps ?? []) {
+        if (step.id === id) {
+          return { level: "step", goal, task, step, node: step };
+        }
       }
     }
   }
@@ -138,8 +184,8 @@ export function findNode(plan, id) {
  *   `step` 为 `null` 表示当前任务还没拆子任务（需要先 `tree_task_plan`）。
  */
 export function activePath(plan) {
-  const goal = plan?.goal;
-  if (!goal || !isOpen(goal)) return null;
+  const goal = goalsOf(plan).find(isOpen);
+  if (!goal) return null;
   const task = (goal.tasks ?? []).find(isOpen);
   if (!task) return { goal, task: null, step: null };
   const step = (task.steps ?? []).find(isOpen);
@@ -156,21 +202,21 @@ export function activePath(plan) {
  * @returns `{ level, goal, task, step, node }`，没有检查点时返回 null。
  */
 export function checkpointOf(plan) {
-  const goal = plan?.goal;
-  if (!goal || !isOpen(goal)) return null;
-
-  const tasks = goal.tasks ?? [];
-  const openTask = tasks.find(isOpen);
+  const active = activePath(plan);
+  if (active === null) return null;
+  const { goal } = active;
 
-  if (openTask === undefined) {
-    // 目标下已经没有未结束的任务，但目标自己还开着。
+  if (active.task === null) {
+    // 这个目标下已经没有未结束的任务，但目标自己还开着。
+    const tasks = goal.tasks ?? [];
     return tasks.length > 0 ? { level: "goal", goal, task: null, step: null, node: goal } : null;
   }
 
-  const steps = openTask.steps ?? [];
+  if (active.step !== null) return null;
+
+  const steps = active.task.steps ?? [];
   if (steps.length === 0) return null;
-  if (steps.some(isOpen)) return null;
-  return { level: "task", goal, task: openTask, step: null, node: openTask };
+  return { level: "task", goal, task: active.task, step: null, node: active.task };
 }
 
 /**
@@ -257,9 +303,11 @@ export function complete(plan, id, result, now = Date.now()) {
 }
 
 /**
- * 丢弃一个节点。丢弃任务会连同它的子任务一起丢弃。
+ * 丢弃一个节点。丢弃目标会连同它下面的任务与子任务一起丢弃；丢弃任务会带上它的子任务。
  *
  * 改需求就用这个丢弃 + `tree_task_plan` 追加新子节点，旧节点留在树里可查。
+ * 已经结束的子节点保持原样——丢的是"还要不要做"，不是改写历史。
+ * 已经**完成**的节点不能丢（那会毁掉它交出的结果），丢过的也不能再丢一次。
  *
  * @param plan - 计划树。
  * @param id - 节点 id。
@@ -269,16 +317,29 @@ export function complete(plan, id, result, now = Date.now()) {
 export function dropNode(plan, id, now = Date.now()) {
   const found = findNode(plan, id);
   if (!found) return { ok: false, reason: `找不到节点 ${id}` };
-  if (found.level === "goal") {
-    return { ok: false, reason: "不能丢弃整个目标；请用 tree_task_create 重建计划" };
+
+  if (found.node.status === STATUS.DONE) {
+    return { ok: false, reason: `节点 ${id} 已经完成，丢弃会毁掉它的结果记录` };
+  }
+  if (found.node.status === STATUS.DROPPED) {
+    return { ok: false, reason: `节点 ${id} 已经被丢弃` };
   }
 
   const dropped = [`${levelLabel(found.level)}「${found.node.title}」`];
   found.node.status = STATUS.DROPPED;
-  for (const step of found.node.steps ?? []) {
-    if (!isClosed(step)) {
-      step.status = STATUS.DROPPED;
-      dropped.push(`子任务「${step.title}」`);
+
+  // 目标是这一层唯一的"有孩子"的节点里最外那一层：丢它就把整支带走。
+  const tasks = found.level === "goal" ? (found.node.tasks ?? []) : [found.node];
+  for (const task of tasks) {
+    if (task !== found.node && !isClosed(task)) {
+      task.status = STATUS.DROPPED;
+      dropped.push(`任务「${task.title}」`);
+    }
+    for (const step of task.steps ?? []) {
+      if (!isClosed(step)) {
+        step.status = STATUS.DROPPED;
+        dropped.push(`子任务「${step.title}」`);
+      }
     }
   }
   plan.updatedAt = now;
@@ -334,13 +395,68 @@ export function levelLabel(level) {
   return "子任务";
 }
 
-/** 检查点那句话：把判断权交还给模型，不假装替它规定了出路。 */
+/**
+ * 注入消息里的层级称呼。树渲染走 `levelLabel`（目标 / 任务 / 子任务），
+ * 注入消息里 L3 一律叫"步骤"。
+ */
+const NOTICE_WORD = { goal: "目标", task: "任务", step: "步骤" };
+
+/**
+ * 节点在注入消息里的自称：目标不带标题，其余带「标题」。
+ *
+ * @param level - `goal` / `task` / `step`。
+ * @param node - 节点。
+ * @returns 自称文本。
+ */
+function subject(level, node) {
+  return level === "goal" ? `目标${node.id}` : `${NOTICE_WORD[level]}「${node.title}」${node.id}`;
+}
+
+/**
+ * 一条完成通告：这个节点做完了、过程归档了。
+ *
+ * 末尾**不带标点**——调用方按需要在后面接"，"或"。"再拼下一步提示。
+ * 不重复提交内容：`result` 就在这次 `tree_task_done` 调用的参数里，再抄一遍是白占位置。
+ *
+ * @param level - `goal` / `task` / `step`。
+ * @param node - 节点。
+ * @returns 通告文本。
+ */
+export function doneNotice(level, node) {
+  const self = subject(level, node);
+  if (node.status !== STATUS.DONE) return `${self}已被丢弃`;
+  return `${self}已经完成，执行过程已归档`;
+}
+
+/** 注入消息与 `tree_task_done` 结果共用的抬头。 */
+export const NOTICE_PREFIX = "tree_task消息：";
+
+/**
+ * `tree_task_done` 的返回内容：下一步该干什么。
+ *
+ * 提示走工具结果本身，不再另外伪造一条用户消息；"哪个节点完成了、过程已归档"
+ * 由折叠落下的那条通告负责。两者合起来才是一条完整的话，所以这里只给后半句。
+ *
+ * @param plan - 计划树。
+ * @returns 返回文本。
+ */
+export function doneReply(plan) {
+  return `${NOTICE_PREFIX}${renderContinue(plan)}`;
+}
+
+/**
+ * 检查点那句话：这一层的下一级都结束了，是收尾还是再补几个。
+ *
+ * @param checkpoint - `checkpointOf(plan)` 的结果。
+ * @returns 检查点文本。
+ */
 function checkpointNote(checkpoint) {
-  const label = levelLabel(checkpoint.level);
+  const level = checkpoint.level;
+  const childWord = level === "goal" ? "任务" : "步骤";
+  const self = subject(level, checkpoint.node);
   return (
-    `${label}「${checkpoint.node.title}」的子节点已全部结束，转入检查点。` +
-    `此刻轮到你的判断：用 tree_task_plan 继续给 ${checkpoint.node.id} 拆子节点，` +
-    `或者用 tree_task_done(id="${checkpoint.node.id}", result="…") 提交这个${label}的结果并完成它。`
+    `检查点：${self} 的${childWord}已全部结束，请确认${self} 是否完成，` +
+    `如果完成请调用tree_task_done，如果还需继续，可使用 tree_task_plan 新增${childWord}继续。`
   );
 }
 
@@ -364,66 +480,76 @@ function firstLine(text, limit = 120) {
  * @returns 多行文本。
  */
 export function renderTree(plan) {
-  if (!plan?.goal) return "（还没有计划。先用 tree_task_create 建立目标与任务。）";
+  const goals = goalsOf(plan);
+  if (goals.length === 0) return "（还没有计划。先用 tree_task_create 建立目标与任务。）";
   const active = activePath(plan);
   const checkpoint = checkpointOf(plan);
   const lines = [];
-  const goal = plan.goal;
-
-  lines.push(`${mark(goal)} 目标  ${goal.id}  ${goal.title}`);
-  if (goal.detail) lines.push(`       ${goal.detail}`);
-  if (goal.result) lines.push(`       结果: ${firstLine(goal.result.text)}`);
-
-  for (const task of goal.tasks ?? []) {
-    const taskHere = active?.task?.id === task.id || checkpoint?.node?.id === task.id;
-    lines.push(`  ${mark(task)} 任务  ${task.id}  ${task.title}${taskHere ? " ← 当前" : ""}`);
-    if (task.result) lines.push(`        结果: ${firstLine(task.result.text)}`);
-    const steps = task.steps ?? [];
-    if (steps.length === 0 && isOpen(task)) {
-      lines.push("        （还没有子节点 → 调用 tree_task_plan）");
-    }
-    for (const step of steps) {
-      lines.push(`    ${mark(step)} 子任务  ${step.id}  ${step.title}${active?.step?.id === step.id ? " ← 当前" : ""}`);
-      if (step.result) lines.push(`          结果: ${firstLine(step.result.text)}`);
+
+  for (const goal of goals) {
+    lines.push(`${mark(goal)} 目标  ${goal.id}  ${goal.title}`);
+    if (goal.detail) lines.push(`       ${goal.detail}`);
+    if (goal.result) lines.push(`       结果: ${firstLine(goal.result.text)}`);
+
+    for (const task of goal.tasks ?? []) {
+      const taskHere = active?.task?.id === task.id || checkpoint?.node?.id === task.id;
+      lines.push(`  ${mark(task)} 任务  ${task.id}  ${task.title}${taskHere ? " ← 当前" : ""}`);
+      if (task.result) lines.push(`        结果: ${firstLine(task.result.text)}`);
+      const steps = task.steps ?? [];
+      if (steps.length === 0 && isOpen(task)) {
+        lines.push("        （还没有子节点 → 调用 tree_task_plan）");
+      }
+      for (const step of steps) {
+        lines.push(`    ${mark(step)} 子任务  ${step.id}  ${step.title}${active?.step?.id === step.id ? " ← 当前" : ""}`);
+        if (step.result) lines.push(`          结果: ${firstLine(step.result.text)}`);
+      }
     }
   }
   return lines.join("\n");
 }
 
 /**
- * 生成"接下来做什么"的指令文本，给自动续行用。
+ * 注入消息里的收尾提示。它接在完成通告后面，所以自带前置标点（`lead`）。
+ *
+ * 三种落点：还有同级就报下一个；同级到头就进检查点；整棵树完了就让汇报。
  *
  * @param plan - 计划树。
- * @returns 指令文本；整棵树已结束时说明已经做完。
+ * @returns `{ lead, text }`；`lead` 是要接在通告末尾的标点。
  */
-export function renderContinue(plan) {
+export function continueNote(plan) {
   const checkpoint = checkpointOf(plan);
-  if (checkpoint !== null) {
-    const label = levelLabel(checkpoint.level);
-    return [
-      `检查点：${label}「${checkpoint.node.title}」(${checkpoint.node.id}) 的子节点已全部结束。`,
-      `此刻轮到你的判断：用 tree_task_plan 继续给 ${checkpoint.node.id} 拆子节点，` +
-        `或者用 tree_task_done(id="${checkpoint.node.id}", result="…") 提交这个${label}的结果并完成它。`,
-    ].join("\n");
-  }
+  if (checkpoint !== null) return { lead: "。", text: checkpointNote(checkpoint) };
 
   const active = activePath(plan);
-  if (active === null) {
-    return "计划树上的所有节点都已完成。请向用户汇报最终结果，不要再调用 tree_task_* 工具。";
-  }
+  if (active === null) return { lead: "，", text: "请汇报最终结果。" };
 
-  if (active.task !== null && active.step === null) {
-    return `当前任务「${active.task.title}」(${active.task.id}) 还没有子节点。请调用 tree_task_plan 为它列出子任务，然后开始执行第一个。`;
+  if (active.step !== null) {
+    return {
+      lead: "，",
+      text: `接下来需要进行步骤：「${active.step.title}」(${active.step.id})。`,
+    };
   }
 
-  if (active.step !== null) {
-    const step = active.step;
-    return [
-      `请继续执行下一个子任务。`,
-      `当前子任务：${step.id}「${step.title}」${step.detail ? ` —— ${step.detail}` : ""}`,
-      `做完之后调用 tree_task_done(id="${step.id}", result="…")，在 result 里写清它产出了什么。`,
-    ].join("\n");
+  if (active.task !== null) {
+    return {
+      lead: "，",
+      text: `接下来需要进行任务：「${active.task.title}」(${active.task.id})。`,
+    };
   }
 
-  return `请继续推进任务「${active.task?.title ?? "(未知)"}」。`;
+  // 目标下面还没拆任务，或者刚从上一个目标轮到这一个。
+  return {
+    lead: "，",
+    text: `接下来需要进行目标：「${active.goal.title}」(${active.goal.id})。`,
+  };
+}
+
+/**
+ * 同一句话独立成句。自动续行那边没有完成通告可接，直接用 `text`。
+ *
+ * @param plan - 计划树。
+ * @returns 指令文本。
+ */
+export function renderContinue(plan) {
+  return continueNote(plan).text;
 }

package/lib/prompt.js

@@ -23,18 +23,7 @@ export const SECTION_NAME = "dsh-tree-task-flow";
 export const DEFAULT_ORDER = 1800;
 
 /** 段落正文。 */
-export const SECTION_TEXT = `## 树形任务流（tree_task_* 工具组）
-
-一件事需要多步才能做完时，用这组工具把它组织成**目标 → 任务 → 子任务**三级树，
-而不是把计划写在回复正文里，也不要再用 todo_write 另记一份。层级固定三级，
-子任务是最低一级，不能再往下拆。
-
-- **完成必须提交能独立看懂的 result。** 这个节点从开始到现在的执行过程会被整段
-  折叠掉，只留下这条结果；同级已完成的汇总不会被后来的折叠卷走。要看全貌就调
-  tree_task_status，不要凭印象猜。
-- **子任务全部结束后，父节点不会自动完成。** 那一刻轮到你的判断：继续用
-  tree_task_plan 拆子节点，还是用 tree_task_done 提交结果收尾。插件不会替你决定
-  这一层做完没有。`;
+export const SECTION_TEXT = "`tree_task_*` 工具适用长线任务，当目标和资料分析完成后，如果用户要求或判断任务较为复杂，可以将任务执行计划分为目标、任务交付节点、任务执行步骤三级写入任务树，借助工具来推进项目；完成步骤或任务时提交后续步骤需要的 result，内容可以是：产物/结论/问题/有哪些需要注意的坑。";
 
 /**
  * 注册段落。调用方必须包在 `ctx.effect()` 里，否则热更新后会重复注册而抛错。