omnirush 0.9.0 → 0.10.0

package/src/sessions.js

@@ -0,0 +1,222 @@
+// Sub-agent sessions out of the user's resume list.
+//
+// spawn_agents children are headless agent runs with session files of
+// their own. Up to 0.9.0 they were written next to the user's sessions
+// (<agentDir>/sessions/<cwd-slug>/), so the core's session picker
+// (/resume) listed every sub-agent run and --continue picked whichever
+// session file changed last — often a background sub-agent's rather than
+// the user's conversation. Children now go to <session dir>/subagents/
+// (agents-lib.ts subagentSessionDir), which the core never lists.
+//
+// moveLegacySubagentSessions puts the children older releases left in a
+// session dir into that folder too (moved, never deleted: the collector
+// still finds them there when a resumed session records its sub-agents).
+// It runs at every agent launch before the core picks a session, and
+// stays cheap on large folders: a marker per session dir records when it
+// was last sorted, and only files changed since then are opened (their
+// first lines only). Files changed in the last minute are left for the
+// next launch, in case an older release is still writing them.
+//
+// A child is recognised from the top of its session file, by the same
+// signals the collector uses (pi-engine.ts subagentTask): the marker entry
+// a sub-agent writes into its own session before its task
+// (SUBAGENT_ENTRY_TYPE), or — sessions of releases that wrote no marker —
+// a first user message "Task: <task>" (SUBAGENT_TASK_PREFIX), confirmed by
+// the role prompt every sub-agent has run with since 0.5.4 (appended to
+// the system prompt: "You are a <role> subagent ..."), which the file
+// itself carries, so no other session has to be read.
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Same name as agents-lib.ts SUBAGENT_SESSIONS_DIR. */
+export const SUBAGENT_SESSIONS_DIR = "subagents";
+/** Same values as pi-engine.ts SUBAGENT_ENTRY_TYPE / SUBAGENT_TASK_PREFIX. */
+export const SUBAGENT_ENTRY_TYPE = "omnirush-subagent";
+export const SUBAGENT_TASK_PREFIX = "Task: ";
+/** Per session dir: when it was last sorted (a .json file: the core only lists *.jsonl). */
+export const SORT_MARKER = ".subagents-sorted.json";
+/** Files changed more recently than this are left for the next launch. */
+export const SETTLE_MS = 60_000;
+/** How much of a session file is read looking for its first user message. */
+const HEAD_LIMIT = 1024 * 1024;
+const CHUNK = 64 * 1024;
+
+const ROLE_PROMPT = /\bYou are an? [\w-]+ subagent\b/;
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => (part && typeof part.text === "string" ? part.text : "")).join("");
+}
+
+/**
+ * Whether a session file is a sub-agent run: a sub-agent marker entry
+ * before its first user message, or a first user message "Task: ..."
+ * after a system prompt with a sub-agent role. Reads the file only up to
+ * that first user message.
+ */
+export function isSubagentSession(file, fsImpl = fs) {
+  let fd;
+  try {
+    fd = fsImpl.openSync(file, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const buffer = Buffer.alloc(CHUNK);
+    let pending = "";
+    let read = 0;
+    let header = null;
+    let rolePrompt = false;
+    while (read < HEAD_LIMIT) {
+      const bytes = fsImpl.readSync(fd, buffer, 0, CHUNK, read);
+      if (bytes <= 0) break;
+      read += bytes;
+      pending += buffer.toString("utf8", 0, bytes);
+      let newline;
+      while ((newline = pending.indexOf("\n")) !== -1) {
+        const line = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        if (!line.trim()) continue;
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          return false;
+        }
+        if (!header) {
+          // A fork (parentSession) is the user's own branch of a session.
+          if (entry?.type !== "session" || entry.parentSession) return false;
+          header = entry;
+          continue;
+        }
+        if (entry?.type === "custom" && entry.customType === SUBAGENT_ENTRY_TYPE) return true;
+        if (entry?.type !== "message") continue;
+        const message = entry.message;
+        if (message?.role === "system") {
+          const addendum = message.sections?.addendum;
+          if (typeof addendum === "string" && ROLE_PROMPT.test(addendum)) rolePrompt = true;
+          continue;
+        }
+        if (message?.role === "user") return rolePrompt && textOf(message.content).startsWith(SUBAGENT_TASK_PREFIX);
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fsImpl.closeSync(fd);
+    } catch {
+      /* closed */
+    }
+  }
+}
+
+function readMarker(dir, fsImpl) {
+  try {
+    const value = JSON.parse(fsImpl.readFileSync(path.join(dir, SORT_MARKER), "utf8"));
+    return Number.isFinite(value?.sortedUpTo) ? value.sortedUpTo : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Move the sub-agent sessions older releases left in `dir` into
+ * dir/subagents/. Returns how many were moved. Never throws.
+ */
+export function sortSessionDir(dir, { fsImpl = fs, now = Date.now } = {}) {
+  let moved = 0;
+  try {
+    const since = readMarker(dir, fsImpl);
+    const cutoff = now() - SETTLE_MS;
+    let names;
+    try {
+      names = fsImpl.readdirSync(dir);
+    } catch {
+      return 0;
+    }
+    let sawFiles = false;
+    for (const name of names) {
+      if (!name.endsWith(".jsonl")) continue;
+      sawFiles = true;
+      const file = path.join(dir, name);
+      let stats;
+      try {
+        stats = fsImpl.statSync(file);
+      } catch {
+        continue;
+      }
+      if (!stats.isFile()) continue;
+      // Sorted already (a user session): only changes since are looked at.
+      if (stats.mtimeMs < since) continue;
+      // Maybe still being written by an older release: next launch.
+      if (stats.mtimeMs >= cutoff) continue;
+      if (!isSubagentSession(file, fsImpl)) continue;
+      const target = path.join(dir, SUBAGENT_SESSIONS_DIR);
+      try {
+        fsImpl.mkdirSync(target, { recursive: true });
+        const dest = path.join(target, name);
+        if (fsImpl.existsSync(dest)) continue;
+        fsImpl.renameSync(file, dest);
+        moved++;
+      } catch {
+        /* left where it is; tried again next launch */
+      }
+    }
+    if (sawFiles) {
+      const tmp = path.join(dir, `${SORT_MARKER}.${process.pid}.tmp`);
+      fsImpl.writeFileSync(tmp, JSON.stringify({ version: 1, sortedUpTo: cutoff }) + "\n");
+      fsImpl.renameSync(tmp, path.join(dir, SORT_MARKER));
+    }
+  } catch {
+    /* best effort: never in the way of a launch */
+  }
+  return moved;
+}
+
+/**
+ * Sort every project's session dir under <agentDir>/sessions (the picker's
+ * "all" scope lists them all) plus any custom session dir in use.
+ */
+export function moveLegacySubagentSessions({ agentDir, extraDirs = [], fsImpl = fs, now = Date.now } = {}) {
+  const dirs = [];
+  const root = path.join(agentDir, "sessions");
+  try {
+    for (const entry of fsImpl.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory()) dirs.push(path.join(root, entry.name));
+    }
+  } catch {
+    /* no sessions yet */
+  }
+  for (const dir of extraDirs) {
+    if (typeof dir === "string" && dir && !dirs.includes(path.resolve(dir))) dirs.push(path.resolve(dir));
+  }
+  let moved = 0;
+  for (const dir of dirs) moved += sortSessionDir(dir, { fsImpl, now });
+  return moved;
+}
+
+/**
+ * The custom session dir an agent launch uses, if any: --session-dir,
+ * else OMNIRUSH_/PI_CODING_AGENT_SESSION_DIR, else the "sessionDir"
+ * setting (as the core resolves it).
+ */
+export function customSessionDir(args, env, settingsFile, home, fsImpl = fs) {
+  const expand = (value) => (value === "~" ? home : value.startsWith("~/") ? path.join(home, value.slice(2)) : value);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--session-dir" && args[i + 1]) return expand(args[i + 1]);
+    if (args[i].startsWith("--session-dir=")) return expand(args[i].slice("--session-dir=".length));
+  }
+  const fromEnv = env.OMNIRUSH_CODING_AGENT_SESSION_DIR || env.PI_CODING_AGENT_SESSION_DIR;
+  if (fromEnv) return expand(fromEnv);
+  try {
+    const value = JSON.parse(fsImpl.readFileSync(settingsFile, "utf8"))?.sessionDir;
+    if (typeof value === "string" && value.trim()) return expand(value.trim());
+  } catch {
+    /* no settings */
+  }
+  return null;
+}