@inetafrica/open-claudia 3.5.14 → 3.5.17

package/core/tasks.js

@@ -6,6 +6,11 @@
 // Tasks support a single level of hierarchy via parentId: a top-level
 // "plan" task can have child subtasks. This lets the agent break a big
 // piece of work into a plan whose progress is visible at a glance.
+//
+// Every thread of a channel shares the channel's file, so a task records the
+// conversation it was made in: `threadId` is the chat thread, null the main
+// timeline. Tasks written before that have no threadId field at all and
+// belong to no conversation in particular.
 
 const fs = require("fs");
 const path = require("path");
@@ -28,7 +33,11 @@ function load(adapter, channelId) {
 }
 
 function save(adapter, channelId, list) {
-  const f = filePathFor(adapter, channelId);
+  saveFile(filePathFor(adapter, channelId), list);
+}
+
+function saveFile(f, list) {
+  fs.mkdirSync(path.dirname(f), { recursive: true });
   const tmp = `${f}.tmp`;
   fs.writeFileSync(tmp, JSON.stringify(list, null, 2));
   fs.renameSync(tmp, f);
@@ -55,13 +64,20 @@ function add(adapter, channelId, content, opts = {}) {
     createdAt: Date.now(),
     updatedAt: Date.now(),
   };
+  // A subtask belongs to its plan's conversation; a new root to the caller's.
+  if (parentId) {
+    const parent = list.find((x) => x.id === parentId);
+    if (Object.prototype.hasOwnProperty.call(parent, "threadId")) t.threadId = parent.threadId;
+  } else if (opts.threadId !== undefined) {
+    t.threadId = opts.threadId ? String(opts.threadId) : null;
+  }
   list.push(t);
   save(adapter, channelId, list);
   return t;
 }
 
 function plan(adapter, channelId, title, subtaskContents, opts = {}) {
-  const parent = add(adapter, channelId, title, { description: opts.description || null });
+  const parent = add(adapter, channelId, title, { description: opts.description || null, threadId: opts.threadId });
   const children = [];
   for (const c of subtaskContents || []) {
     if (!String(c || "").trim()) continue;
@@ -165,7 +181,10 @@ function list(adapter, channelId, opts = {}) {
 }
 
 function tree(adapter, channelId) {
-  const all = load(adapter, channelId);
+  return treeOf(load(adapter, channelId));
+}
+
+function treeOf(all) {
   const byParent = new Map();
   const roots = [];
   for (const t of all) {
@@ -234,7 +253,11 @@ function lastActivityOf(root) {
 }
 
 function openTree(adapter, channelId) {
-  return tree(adapter, channelId)
+  return openTreeOf(load(adapter, channelId));
+}
+
+function openTreeOf(all) {
+  return treeOf(all)
     .map((r) => ({ ...r, children: (r.children || []).filter((c) => c.status !== "completed") }))
     .filter((r) => r.status !== "completed" || r.children.length > 0);
 }
@@ -254,15 +277,48 @@ function get(adapter, channelId, id) {
 // Used by the dream task-hygiene pass to surface cold work for a user
 // decision — it flags and asks, never deletes (tasks are user intent).
 function staleRoots(adapter, channelId, opts = {}) {
+  return staleRootsOf(load(adapter, channelId), opts);
+}
+
+function staleRootsOf(all, opts = {}) {
   const days = Number(opts.days) || STALE_DAYS;
   const now = opts.now || Date.now();
-  return openTree(adapter, channelId)
+  return openTreeOf(all)
     .map((r) => ({ root: r, idleDays: (now - lastActivityOf(r)) / DAY_MS }))
     .filter((x) => x.idleDays > days)
     .sort((a, b) => b.idleDays - a.idleDays)
     .map((x) => ({ id: x.root.id, content: x.root.content, status: x.root.status, idleDays: Math.round(x.idleDays) }));
 }
 
+// Every task list on this bot: one file per adapter+channel in TASKS_DIR (not
+// the archive below it). Task kinds are owner-only at the loopback, so every
+// list is the owner's, whichever channel it lives in. Files named like test
+// fixtures are skipped. `label` names the list for a report.
+function taskLists(dir = TASKS_DIR) {
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch (e) { return []; }
+  return names
+    .filter((name) => name.endsWith(".json") && !/test|fixture/i.test(name))
+    .sort()
+    .map((name) => ({ name, file: path.join(dir, name), label: listLabel(name) }));
+}
+
+function listLabel(name) {
+  const base = String(name).replace(/\.json$/, "");
+  const cut = base.indexOf("-");
+  if (cut < 0) return base;
+  const adapter = base.slice(0, cut);
+  const channel = base.slice(cut + 1);
+  return `${adapter} ${channel.length > 14 ? `${channel.slice(0, 6)}…${channel.slice(-6)}` : channel}`;
+}
+
+function loadFile(file) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, "utf-8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch (e) { return []; }
+}
+
 function renderRootFull(root, num, showIds) {
   const idTag = showIds ? `    (${root.id})` : "";
   const lines = [`${num}. ${statusMark(root)} ${root.content}${idTag}`];
@@ -309,6 +365,148 @@ function formatForInjection(adapter, channelId, opts = {}) {
   return lines.join("\n");
 }
 
+// --- Archive ---------------------------------------------------------------
+// A task can leave the live list without being lost: archive moves a root and
+// its subtasks to <TASKS_DIR>/archive/<same file name>, restore moves them back
+// with the same ids. Archiving always needs an explicit reason saying how the
+// task closed — "done: <proof>", "replaced: <by what>", "dropped: <who
+// decided>" or "handed: <to whom>" — stored as closedReason + reason text with
+// archivedAt. Nothing archives by age or on its own.
+const CLOSED_REASONS = ["done", "replaced", "dropped", "handed"];
+
+function parseCloseReason(text) {
+  const m = /^\s*(done|replaced|dropped|handed)\s*:\s*(\S[\s\S]*)$/i.exec(String(text || ""));
+  if (!m) {
+    throw new Error('archive needs a reason: "done: <proof>", "replaced: <by what>", "dropped: <who decided>" or "handed: <to whom>"');
+  }
+  return { closedReason: m[1].toLowerCase(), reason: m[2].trim() };
+}
+
+function archiveFileFor(liveFile) {
+  return path.join(path.dirname(liveFile), "archive", path.basename(liveFile));
+}
+
+function archiveInFile(liveFile, id, reasonText, opts = {}) {
+  const { closedReason, reason } = parseCloseReason(reasonText);
+  const live = loadFile(liveFile);
+  const root = live.find((t) => t.id === id);
+  if (!root) return null;
+  if (root.parentId) throw new Error(`${id} is a subtask; archive its plan (${root.parentId}) instead`);
+  const moving = live.filter((t) => t.id === id || t.parentId === id);
+  const archivedAt = opts.now || Date.now();
+  const stamped = moving.map((t) => ({ ...t, archivedAt, closedReason, reason }));
+  // Archive first: a crash in between leaves a copy in both, never in neither.
+  const archiveFile = archiveFileFor(liveFile);
+  const ids = new Set(moving.map((t) => t.id));
+  saveFile(archiveFile, [...loadFile(archiveFile).filter((t) => !ids.has(t.id)), ...stamped]);
+  saveFile(liveFile, live.filter((t) => !ids.has(t.id)));
+  return { archived: stamped.find((t) => t.id === id), alsoArchived: stamped.length - 1 };
+}
+
+function restoreInFile(liveFile, id) {
+  const archiveFile = archiveFileFor(liveFile);
+  const archived = loadFile(archiveFile);
+  const root = archived.find((t) => t.id === id);
+  if (!root) return null;
+  if (root.parentId) throw new Error(`${id} is a subtask; restore its plan (${root.parentId}) instead`);
+  const live = loadFile(liveFile);
+  if (live.some((t) => t.id === id)) throw new Error(`${id} is already in the live list`);
+  const moving = archived.filter((t) => t.id === id || t.parentId === id);
+  const ids = new Set(moving.map((t) => t.id));
+  const restored = moving.map(({ archivedAt, closedReason, reason, ...t }) => t);
+  saveFile(liveFile, [...live.filter((t) => !ids.has(t.id)), ...restored]);
+  saveFile(archiveFile, archived.filter((t) => !ids.has(t.id)));
+  return { restored: restored.find((t) => t.id === id), alsoRestored: restored.length - 1 };
+}
+
+// Archived roots (with their subtasks), most recently archived first;
+// `search` matches the title, description or reason (any case).
+function archivedInFile(liveFile, opts = {}) {
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? opts.limit : 20;
+  const needle = String(opts.search || "").trim().toLowerCase();
+  const hit = (t) => [t.content, t.description, t.reason].some((v) => String(v || "").toLowerCase().includes(needle));
+  return treeOf(loadFile(archiveFileFor(liveFile)))
+    .filter((root) => !needle || hit(root) || (root.children || []).some(hit))
+    .sort((a, b) => (b.archivedAt || 0) - (a.archivedAt || 0))
+    .slice(0, limit);
+}
+
+function archive(adapter, channelId, id, reasonText, opts = {}) {
+  return archiveInFile(filePathFor(adapter, channelId), id, reasonText, opts);
+}
+
+function restore(adapter, channelId, id) {
+  return restoreInFile(filePathFor(adapter, channelId), id);
+}
+
+function archived(adapter, channelId, opts = {}) {
+  return archivedInFile(filePathFor(adapter, channelId), opts);
+}
+
+// --- Per-conversation injection -----------------------------------------
+// The first turn of a session used to get the whole channel's tree, and every
+// thread shares one channel file (hundreds of roots, ~100k chars on a busy
+// owner chat). Now it gets this conversation's own open roots in full, one
+// line about the rest of the chat, and a pointer to `task list`.
+
+const CONVO_MAX_ROOTS = 12;
+const CONVO_MAX_CHARS = 6000;
+const SECTION_MAX_CHARS = 7500;
+const ELSEWHERE_TITLES = 5;
+const TITLE_CHARS = 80;
+
+function clip(text, max) {
+  const s = String(text || "").replace(/\s+/g, " ").trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
+// Whether a root was made in this conversation (threadId null = the main
+// timeline). A legacy root (no threadId field) belongs to none.
+function inConversation(root, threadId) {
+  if (!Object.prototype.hasOwnProperty.call(root, "threadId")) return false;
+  return (root.threadId || null) === (threadId ? String(threadId) : null);
+}
+
+function formatConversationSection(adapter, channelId, opts = {}) {
+  const showIds = opts.showIds !== false;
+  const maxRoots = Number.isFinite(opts.maxRoots) ? opts.maxRoots : CONVO_MAX_ROOTS;
+  const maxChars = Number.isFinite(opts.maxChars) ? opts.maxChars : CONVO_MAX_CHARS;
+  const cap = Number.isFinite(opts.sectionMaxChars) ? opts.sectionMaxChars : SECTION_MAX_CHARS;
+  const byRecency = openTree(adapter, channelId).sort((a, b) => lastActivityOf(b) - lastActivityOf(a));
+  if (byRecency.length === 0) return "";
+  const own = byRecency.filter((r) => inConversation(r, opts.threadId));
+  const elsewhere = byRecency.filter((r) => !inConversation(r, opts.threadId));
+
+  const lines = [
+    "## Pending tasks (this conversation)",
+    "Open tasks made in this conversation, most recently worked first. Mark a task in_progress when you actually start it and done when finished (`open-claudia task done <id>`), so the list stays honest. If something in our conversation shows a task is already finished, proactively offer to close it. Shown once per session.",
+    "",
+  ];
+  if (own.length === 0) lines.push("None of the open tasks were made in this conversation.");
+  let used = 0;
+  let shown = 0;
+  for (const root of own) {
+    if (shown >= maxRoots) break;
+    let block = renderRootFull(root, shown + 1, showIds).join("\n");
+    if (used + block.length > maxChars) {
+      if (shown > 0) break;
+      block = clip(block, maxChars); // one oversized root still shows, cut
+    }
+    lines.push(block);
+    used += block.length;
+    shown += 1;
+  }
+  if (own.length > shown) lines.push(`+${own.length - shown} more: open-claudia task list`);
+  if (elsewhere.length > 0) {
+    const inProgress = elsewhere.filter((r) => r.status === "in_progress").length;
+    const titles = elsewhere.slice(0, ELSEWHERE_TITLES).map((r) => `"${clip(r.content, TITLE_CHARS)}"`).join("; ");
+    lines.push("", `Elsewhere in this chat: ${elsewhere.length} open (${inProgress} in progress); most recent: ${titles}`);
+  }
+  lines.push("", "Run `open-claudia task list` for the full tree (`task get <id>` for one task).");
+  const text = lines.join("\n");
+  return text.length > cap ? `${text.slice(0, cap - 1)}…` : text;
+}
+
 module.exports = {
   filePathFor,
   load, save,
@@ -317,5 +515,9 @@ module.exports = {
   pendingSummary,
   format, formatTree, statusMark,
   get, staleRoots, formatForInjection, lastActivityOf,
-  STALE_DAYS, RECENCY_FULL,
+  formatConversationSection, inConversation,
+  taskLists, loadFile, staleRootsOf, treeOf, openTreeOf,
+  archive, restore, archived, archiveInFile, restoreInFile, archivedInFile, archiveFileFor,
+  parseCloseReason, CLOSED_REASONS,
+  STALE_DAYS, RECENCY_FULL, SECTION_MAX_CHARS,
 };