omnirush 0.8.6 → 0.9.1

package/src/lib.js

@@ -403,3 +403,67 @@ export function managedToolTargets({ platform = process.platform, runtimeRoot }
     { tool: "rg", source: `${runtimeRoot}/bin/rg${ext}`, dest: `bin/rg${ext}` },
   ];
 }
+
+// --- yolo mode ---------------------------------------------------------------
+//
+// `--yolo`, `/yolo on` (saved as "yolo": true in <state dir>/settings.json) or
+// OMNIRUSH_YOLO=1: the project folder is trusted for the run (the core's
+// --approve) and nothing asks for confirmation. Precedence: --yolo/--no-yolo,
+// then OMNIRUSH_YOLO, then the saved setting. Default: off.
+
+export const YOLO_BANNER = "yolo mode: no prompts, project trusted";
+
+const TRUE_WORDS = new Set(["1", "true", "on", "yes"]);
+const FALSE_WORDS = new Set(["0", "false", "off", "no"]);
+
+/** OMNIRUSH_YOLO as true/false, or undefined when unset or unrecognised. */
+export function parseYoloEnv(value) {
+  const v = String(value ?? "").trim().toLowerCase();
+  if (TRUE_WORDS.has(v)) return true;
+  if (FALSE_WORDS.has(v)) return false;
+  return undefined;
+}
+
+/**
+ * Resolve yolo mode for one launch. Strips --yolo/--no-yolo from `args`
+ * (never past `--`) and, when yolo is on for an agent run, adds the core's
+ * --approve unless the user already chose -a/--approve/-na/--no-approve.
+ * Returns { yolo, source, trusted, args }: `trusted` is false only when an
+ * explicit --no-approve wins over yolo's project trust.
+ */
+export function resolveYolo(args, { env = process.env, setting } = {}) {
+  let flag;
+  const rest = [];
+  let passthrough = false;
+  for (const arg of args) {
+    if (!passthrough && arg === "--") passthrough = true;
+    if (!passthrough && arg === "--yolo") flag = true;
+    else if (!passthrough && arg === "--no-yolo") flag = false;
+    else rest.push(arg);
+  }
+  let yolo = false;
+  let source = "default";
+  const fromEnv = parseYoloEnv(env.OMNIRUSH_YOLO);
+  if (flag !== undefined) {
+    yolo = flag;
+    source = "flag";
+  } else if (fromEnv !== undefined) {
+    yolo = fromEnv;
+    source = "env";
+  } else if (setting === true) {
+    yolo = true;
+    source = "setting";
+  }
+  const subcommand = rest.length > 0 && PI_SUBCOMMANDS.has(rest[0]);
+  if (!yolo || subcommand) return { yolo: yolo && !subcommand, source, trusted: !subcommand && yolo, args: rest };
+  const end = rest.indexOf("--");
+  const scan = end < 0 ? rest : rest.slice(0, end);
+  if (scan.some((a) => a === "--no-approve" || a === "-na")) return { yolo, source, trusted: false, args: rest };
+  if (scan.some((a) => a === "--approve" || a === "-a")) return { yolo, source, trusted: true, args: rest };
+  return { yolo, source, trusted: true, args: ["--approve", ...rest] };
+}
+
+/** The one-line banner for a resolved yolo launch. */
+export function yoloBanner({ trusted }) {
+  return trusted ? YOLO_BANNER : "yolo mode: no prompts (project not trusted: --no-approve)";
+}

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;
+}

package/scripts/patch-pi-branding.js

@@ -1,251 +0,0 @@
-#!/usr/bin/env node
-// Rebrand the vendored agent core (@earendil-works/pi-coding-agent) so
-// users see "omnirush", never "pi"/"Pi". Runs on postinstall (before the
-// bun download) and is safe to re-run (idempotent).
-//
-// Two mechanisms:
-//   1. package.json `piConfig.name = "omnirush"` — pi's supported rebrand
-//      hook. APP_NAME/APP_TITLE (banner logo "omnirush v0.86.1", terminal
-//      title, --help usage lines, auth hints, debug-log name, the
-//      <APP>_CODING_AGENT_DIR env var) all derive from it, in dist and in
-//      the runtime bundle. It also disables pi's official-distribution
-//      first-time-setup wizard (upstream treats forks/rebrands that way).
-//   2. Literal string replacements across the installed dist/*.js (the
-//      standalone files and the runtime bundle chunks) for the handful of
-//      user-visible strings that do not go through APP_NAME.
-//
-// Never renamed: file paths, config/session directory names, function or
-// variable identifiers, env-var names (PI_OFFLINE, PI_TELEMETRY, ... are
-// the core's real env contract), or the `pi` admin-subcommand aliases —
-// only display strings.
-//
-// Fail-soft: a core update that moved a string logs a warning; it never
-// breaks `npm install`.
-
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PKG = "@earendil-works/pi-coding-agent";
-const BRAND = "omnirush";
-
-// Display strings that do not flow through APP_NAME. `from` must match the
-// installed dist exactly; applied with replaceAll to every dist/**/*.js.
-export const REPLACEMENTS = [
-  {
-    label: "TUI banner onboarding line",
-    from: "Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.",
-    to: "Omnirush can explain its own features and look up its docs. Ask it how to use or extend Omnirush.",
-  },
-  {
-    label: "system prompt persona",
-    from: "operating inside pi, a coding agent harness",
-    to: "operating inside omnirush, a coding agent harness",
-  },
-  {
-    label: "system prompt docs section header",
-    from:
-      "Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):",
-    to: "Omnirush documentation (read only when the user asks about the agent itself, its SDK, extensions, themes, skills, or TUI):",
-  },
-  {
-    label: "system prompt docs reading rule",
-    from: "When reading pi docs or examples",
-    to: "When reading the bundled docs or examples",
-  },
-  {
-    label: "system prompt packages doc reference",
-    from: "pi packages (docs/packages.md)",
-    to: "agent packages (docs/packages.md)",
-  },
-  {
-    label: "system prompt topics rule",
-    from: "When working on pi topics, read the docs and examples",
-    to: "When working on agent topics, read the docs and examples",
-  },
-  {
-    label: "system prompt read-fully rule",
-    from: "Always read pi .md files completely",
-    to: "Always read the agent .md files completely",
-  },
-  {
-    label: "bug report persona",
-    from: "about pi, the coding agent they are talking to",
-    to: "about omnirush, the coding agent they are talking to",
-  },
-  {
-    label: "bug report recipient",
-    from: "Write a report for the pi developers",
-    to: "Write a report for the omnirush developers",
-  },
-  {
-    label: "--help update line",
-    from: "Update pi, extensions, or model catalogs",
-    to: "Update the agent, extensions, or model catalogs",
-  },
-  {
-    label: "--help update alias token",
-    from: "[source|self|pi]",
-    to: "[source|self]",
-  },
-  {
-    label: "update subcommand description",
-    from: "Update pi only (self works as alias to pi)",
-    to: "Update the agent only (self works as an alias)",
-  },
-  // Belt-and-braces against the pi.dev update banner (Foxtran's 0.73.1
-  // report: a stale core showed "Update Available — pi.dev/changelog"
-  // even though PI_OFFLINE should suppress the check). PI_OFFLINE=1 in
-  // the spawn env stops the check; these rewrites make the banner
-  // UNRENDERABLE even where PI_OFFLINE is absent (direct pi spawns,
-  // older cores): showNewVersionNotification returns before its body
-  // (the parameter is renamed so the replacement stays idempotent and
-  // never re-matches), and the pi.dev changelog URL is blanked. The
-  // parameter spelling differs between the standalone dist (readable)
-  // and the minified runtime bundle chunk, hence the two variants; a
-  // future core that renames the parameter just reports "missing"
-  // (fail-soft) and we would re-derive the target.
-  {
-    label: "TUI update banner (standalone dist)",
-    from: "showNewVersionNotification(release) {",
-    to: "showNewVersionNotification(_release) { return;",
-  },
-  {
-    label: "TUI update banner (runtime bundle chunk)",
-    from: "showNewVersionNotification(release2){",
-    to: "showNewVersionNotification(_r){return;",
-  },
-  {
-    label: "pi.dev changelog URL",
-    from: '"https://pi.dev/changelog"',
-    to: '""',
-  },
-];
-
-function findPiRoot(startDir) {
-  let dir = startDir;
-  for (let i = 0; i < 8; i++) {
-    const candidate = path.join(dir, "node_modules", PKG);
-    if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-  return null;
-}
-
-function listDistFiles(root) {
-  const out = [];
-  const stack = [root];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) stack.push(full);
-      else if (entry.isFile() && entry.name.endsWith(".js")) out.push(full);
-    }
-  }
-  return out;
-}
-
-/**
- * Apply the rebrand to the installed core. Returns a report:
- *   { piRoot, packageJsonPatched, applied: [{label, files}], missing: [{label, reason}] }
- */
-export function applyBrandingPatches(startDir) {
-  const piRoot = findPiRoot(startDir);
-  if (!piRoot) {
-    return { piRoot: null, packageJsonPatched: false, applied: [], missing: [{ label: "core", reason: `${PKG} not installed` }] };
-  }
-
-  // 1. The supported rebrand hook.
-  let packageJsonPatched = false;
-  const pkgPath = path.join(piRoot, "package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  if (pkg.piConfig?.name !== BRAND) {
-    pkg.piConfig = { ...(pkg.piConfig || {}), name: BRAND };
-    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-    packageJsonPatched = true;
-  }
-
-  // 2. Literal display strings, everywhere under dist/.
-  const applied = [];
-  const missing = [];
-  const files = listDistFiles(path.join(piRoot, "dist"));
-  for (const replacement of REPLACEMENTS) {
-    let hits = 0;
-    for (const file of files) {
-      let content;
-      try {
-        content = fs.readFileSync(file, "utf8");
-      } catch {
-        continue;
-      }
-      if (!content.includes(replacement.from)) continue;
-      fs.writeFileSync(file, content.replaceAll(replacement.from, replacement.to));
-      hits++;
-    }
-    if (hits > 0) applied.push({ label: replacement.label, files: hits });
-    else missing.push({ label: replacement.label, reason: "target string not found (already applied or core updated)" });
-  }
-  return { piRoot, packageJsonPatched, applied, missing };
-}
-
-function main() {
-  const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-  const report = applyBrandingPatches(repoRoot);
-  if (!report.piRoot) {
-    console.log("omnirush: agent core not installed; skipped branding patch");
-    return;
-  // Version alignment: pi's self-reported version (banner/help) reads its
-  // own package.json — rewrite it to the omnirush release version so the
-  // product version, not upstream's, is what users and support see.
-  try {
-    const piPkgPath = path.join(report.piRoot, "package.json");
-    const piPkg = JSON.parse(fs.readFileSync(piPkgPath, "utf8"));
-    const ourVersion = JSON.parse(
-      fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"),
-    ).version;
-    if (piPkg.version !== ourVersion) {
-      piPkg.version = ourVersion;
-      fs.writeFileSync(piPkgPath, JSON.stringify(piPkg, null, 2) + "\n");
-      report.versionAligned = ourVersion;
-    }
-  } catch {
-    /* cosmetic — never fail the patch over version alignment */
-  }
-  }
-  // Version alignment: pi's self-reported version (banner/help) reads its
-  // own package.json — rewrite it to the omnirush release version so the
-  // product version, not upstream's, is what users and support see.
-  try {
-    const piPkgPath = path.join(report.piRoot, "package.json");
-    const piPkg = JSON.parse(fs.readFileSync(piPkgPath, "utf8"));
-    const ourVersion = JSON.parse(
-      fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"),
-    ).version;
-    if (piPkg.version !== ourVersion) {
-      piPkg.version = ourVersion;
-      fs.writeFileSync(piPkgPath, JSON.stringify(piPkg, null, 2) + "\n");
-      report.versionAligned = ourVersion;
-    }
-  } catch {
-    /* cosmetic — never fail the patch over version alignment */
-  }
-  const patched = report.packageJsonPatched ? "package.json + " : "";
-  const ver = report.versionAligned ? `; version aligned to ${report.versionAligned}` : "";
-  console.log(
-    `omnirush: branding applied (${patched}${report.applied.length} display strings)${ver}` +
-      (report.missing.length > 0 ? `; ${report.missing.length} already-applied/absent` : ""),
-  );
-}
-
-// CLI entry (postinstall). Imported as a module by tests — never exit there.
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  try {
-    main();
-  } catch (error) {
-    // Fail-soft: a cosmetic patch must never break `npm install`.
-    console.warn("omnirush: branding patch skipped:", error?.message ?? error);
-  }
-}