@opencode-cockpit/subagents 0.7.0

package/dist/core/sample.js

@@ -0,0 +1,261 @@
+/**
+ * A run caught mid-flight, for the preview: build has launched three subagents — one searching, one
+ * held on a permission, one finished. Fixed times, so the preview draws the same thing every time.
+ */
+
+export const SAMPLE_ROOT = "ses_build";
+export const SAMPLE_NOW = 1_790_000_060_000;
+export function sample() {
+  const t = s => SAMPLE_NOW - 60_000 + s * 1000;
+  return [{
+    type: "session",
+    id: SAMPLE_ROOT,
+    agent: "build",
+    title: "Refactor auth and fix login tests",
+    at: t(0)
+  }, {
+    type: "session",
+    id: "ses_explore",
+    parentID: SAMPLE_ROOT,
+    agent: "explore",
+    title: "Map the authentication flow",
+    at: t(9)
+  }, {
+    type: "prompt",
+    id: "ses_explore",
+    key: "u1",
+    text: "Map how a session is created, read and destroyed in src/auth. List every caller of requireSession.",
+    at: t(9)
+  }, {
+    type: "status",
+    id: "ses_explore",
+    status: "busy",
+    at: t(9)
+  }, {
+    type: "thinking",
+    id: "ses_explore",
+    key: "r1",
+    text: "Start with the file tree, then session.ts — the name suggests it owns the lifecycle. The middleware probably reads it per request. I'll grep for requireSession afterwards to find the callers.",
+    done: true,
+    at: t(10)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c1",
+    name: "glob",
+    state: "completed",
+    input: {
+      pattern: "src/auth/**/*.ts"
+    },
+    output: "23 files",
+    at: t(12)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c1",
+    at: t(12)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c2",
+    name: "read",
+    state: "completed",
+    input: {
+      filePath: "/acme/src/auth/session.ts"
+    },
+    at: t(13)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c3",
+    name: "read",
+    state: "completed",
+    input: {
+      filePath: "/acme/src/auth/middleware.ts"
+    },
+    at: t(14)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c3b",
+    name: "bash",
+    state: "completed",
+    input: {
+      command: "git status --short",
+      description: "Show changed files"
+    },
+    output: ["M CHANGELOG.md", " M src/auth/session.ts", " M src/auth/middleware.ts", " M src/auth/token.ts", " M src/routes/login.ts", " M src/routes/logout.ts", " M test/auth/session.test.ts", " M test/auth/login.test.ts", " M test/routes/login.test.ts", " M package.json", "?? src/auth/refresh.ts", "?? test/auth/refresh.test.ts"].join("\n"),
+    started: t(14),
+    ended: t(15),
+    at: t(14)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c3c",
+    name: "bash",
+    state: "failed",
+    input: {
+      command: "git rev-parse --verify refs/heads/auth-refresh"
+    },
+    error: "fatal: Needed a single revision",
+    started: t(15),
+    ended: t(15),
+    at: t(15)
+  }, {
+    type: "thinking",
+    id: "ses_explore",
+    key: "r2",
+    text: "createSession and readSession are the two entry points. Need to confirm where tokens are refreshed.",
+    done: true,
+    at: t(16)
+  }, {
+    type: "tool",
+    id: "ses_explore",
+    call: "c4",
+    name: "grep",
+    state: "running",
+    input: {
+      pattern: "session",
+      include: "src/auth/**"
+    },
+    output: "src/auth/session.ts:14: export function createSession(user: User) {\nsrc/auth/session.ts:41: export function readSession(req: Request) {\nsrc/auth/middleware.ts:7: const session = readSession(req)",
+    at: t(56)
+  }, {
+    type: "reply",
+    id: "ses_explore",
+    key: "t1",
+    delta: "So far: sessions are created in session.ts:14 and read per request by the middleware, and",
+    at: t(57)
+  }, {
+    type: "usage",
+    id: "ses_explore",
+    tokens: 6100,
+    cost: 0.004,
+    at: t(57)
+  }, {
+    type: "session",
+    id: "ses_login",
+    parentID: SAMPLE_ROOT,
+    agent: "general",
+    title: "Fix the failing login test",
+    at: t(10)
+  }, {
+    type: "prompt",
+    id: "ses_login",
+    key: "u1",
+    text: "The login test fails after the session refactor. Find out why and fix it.",
+    at: t(10)
+  }, {
+    type: "status",
+    id: "ses_login",
+    status: "busy",
+    at: t(10)
+  }, {
+    type: "tool",
+    id: "ses_login",
+    call: "l1",
+    name: "read",
+    state: "completed",
+    input: {
+      filePath: "/acme/test/login.test.ts"
+    },
+    at: t(12)
+  }, {
+    type: "tool",
+    id: "ses_login",
+    call: "l2",
+    name: "edit",
+    state: "completed",
+    input: {
+      filePath: "/acme/test/login.test.ts"
+    },
+    at: t(30)
+  }, {
+    type: "tool",
+    id: "ses_login",
+    call: "l3",
+    name: "bash",
+    state: "pending",
+    input: {
+      command: "npm test -- login"
+    },
+    at: t(58)
+  }, {
+    type: "status",
+    id: "ses_login",
+    status: "waiting",
+    at: t(58)
+  }, {
+    type: "usage",
+    id: "ses_login",
+    tokens: 3900,
+    cost: 0.003,
+    at: t(58)
+  }, {
+    type: "session",
+    id: "ses_readme",
+    parentID: SAMPLE_ROOT,
+    agent: "general",
+    title: "Update README for the new auth API",
+    at: t(11)
+  }, {
+    type: "prompt",
+    id: "ses_readme",
+    key: "u1",
+    text: "Update the README's auth section for the new session API.",
+    at: t(11)
+  }, {
+    type: "status",
+    id: "ses_readme",
+    status: "busy",
+    at: t(11)
+  }, {
+    type: "tool",
+    id: "ses_readme",
+    call: "d1",
+    name: "read",
+    state: "completed",
+    input: {
+      filePath: "/acme/README.md"
+    },
+    at: t(13)
+  }, {
+    type: "tool",
+    id: "ses_readme",
+    call: "d2",
+    name: "edit",
+    state: "completed",
+    input: {
+      filePath: "/acme/README.md"
+    },
+    at: t(25)
+  }, {
+    type: "tool",
+    id: "ses_readme",
+    call: "d3",
+    name: "edit",
+    state: "completed",
+    input: {
+      filePath: "/acme/README.md"
+    },
+    at: t(33)
+  }, {
+    type: "reply",
+    id: "ses_readme",
+    key: "t1",
+    text: "Updated the README's auth section: createSession, readSession and requireSession, with an example.",
+    done: true,
+    at: t(38)
+  }, {
+    type: "status",
+    id: "ses_readme",
+    status: "idle",
+    at: t(39)
+  }, {
+    type: "usage",
+    id: "ses_readme",
+    tokens: 2200,
+    cost: 0.001,
+    at: t(39)
+  }];
+}

package/dist/core/view/markdown.js

@@ -0,0 +1,211 @@
+/**
+ * A subagent's answer as rows: the markdown it writes, drawn rather than shown as source.
+ *
+ * Only what agents actually write: headings, **bold**, `code`, lists, quotes and fenced code. Inline
+ * styles survive wrapping — a line is cut into styled words first, then the words are laid out —
+ * so a path in `code` that crosses the edge keeps its colour on both lines.
+ */
+
+import { fit, widthOf } from "./rows.js";
+/** `**bold**` and `` `code` `` in one line, as styled pieces. */
+export function inline(text, base) {
+  const out = [];
+  const pattern = /(\*\*[^*]+\*\*|`[^`]+`)/g;
+  let last = 0;
+  for (const match of text.matchAll(pattern)) {
+    const at = match.index ?? 0;
+    if (at > last) out.push({
+      ...base,
+      text: text.slice(last, at)
+    });
+    const token = match[0];
+    if (token.startsWith("**")) out.push({
+      ...base,
+      text: token.slice(2, -2),
+      bold: true
+    });else out.push({
+      ...base,
+      text: token.slice(1, -1),
+      tone: "tool"
+    });
+    last = at + token.length;
+  }
+  if (last < text.length) out.push({
+    ...base,
+    text: text.slice(last)
+  });
+  return out;
+}
+
+/**
+ * Styled pieces onto lines of `width`, word by word. `first` leads the first line and `rest` every
+ * line after it — a bullet, then the indent that lines up under the words.
+ */
+export function flow(pieces, width, first, rest) {
+  const words = [];
+  for (const piece of pieces) {
+    for (const part of piece.text.split(/(\s+)/)) if (part) words.push({
+      ...piece,
+      text: part
+    });
+  }
+  const lines = [];
+  let line = [...first];
+  let used = widthOf(first.map(run => run.text).join(""));
+  const lead = () => widthOf(rest.map(run => run.text).join(""));
+  const empty = () => line.every(run => rest.includes(run) || first.includes(run));
+  for (const word of words) {
+    const w = widthOf(word.text);
+    const space = /^\s+$/.test(word.text);
+    if (used + w > width && !empty()) {
+      lines.push(line);
+      line = [...rest];
+      used = lead();
+      if (space) continue;
+    }
+    if (space && empty()) continue;
+    if (w > width - used) {
+      // A word longer than the line: cut it where the line ends.
+      let text = word.text;
+      while (widthOf(text) > width - used) {
+        let head = "";
+        for (const char of text) {
+          if (widthOf(head) + widthOf(char) > width - used) break;
+          head += char;
+        }
+        if (!head) break;
+        line.push({
+          ...word,
+          text: head
+        });
+        lines.push(line);
+        line = [...rest];
+        used = lead();
+        text = text.slice(head.length);
+      }
+      if (text) {
+        line.push({
+          ...word,
+          text
+        });
+        used += widthOf(text);
+      }
+      continue;
+    }
+    line.push(word);
+    used += w;
+  }
+  if (line.length > 0) lines.push(line);
+  return lines;
+}
+export function markdownRows(text, width, {
+  indent
+}) {
+  const pad = {
+    text: " ".repeat(indent)
+  };
+  const room = Math.max(8, width);
+  const rows = [];
+  let fence = false;
+  let blank = false;
+  const push = row => {
+    rows.push(fit(row, width));
+    blank = false;
+  };
+  const gap = () => {
+    if (!blank && rows.length > 0) rows.push(fit([], width));
+    blank = true;
+  };
+  for (const raw of text.replace(/\r/g, "").split("\n")) {
+    const line = raw.replace(/\s+$/, "");
+    if (/^\s*```/.test(line)) {
+      fence = !fence;
+      if (fence) gap();
+      continue;
+    }
+    if (fence) {
+      push([pad, {
+        text: "│ ",
+        tone: "muted",
+        fill: "block"
+      }, {
+        text: line,
+        tone: "text",
+        fill: "block"
+      }]);
+      continue;
+    }
+    if (line.trim() === "") {
+      gap();
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (heading) {
+      gap();
+      const level = heading[1].length;
+      const base = level <= 2 ? {
+        tone: "accent",
+        bold: true
+      } : {
+        tone: "text",
+        bold: true
+      };
+      for (const row of flow(inline(heading[2], base), room, [pad], [pad])) push(row);
+      continue;
+    }
+    const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+    if (bullet) {
+      const depth = Math.min(3, Math.floor(bullet[1].length / 2));
+      const lead = " ".repeat(depth * 2);
+      const first = [pad, {
+        text: `${lead}• `,
+        tone: "muted"
+      }];
+      const rest = [pad, {
+        text: `${lead}  `
+      }];
+      for (const row of flow(inline(bullet[2], {
+        tone: "text"
+      }), room, first, rest)) push(row);
+      continue;
+    }
+    const numbered = /^(\s*)(\d+)[.)]\s+(.*)$/.exec(line);
+    if (numbered) {
+      const mark = `${numbered[2]}. `;
+      const first = [pad, {
+        text: mark,
+        tone: "muted"
+      }];
+      const rest = [pad, {
+        text: " ".repeat(mark.length)
+      }];
+      for (const row of flow(inline(numbered[3], {
+        tone: "text"
+      }), room, first, rest)) push(row);
+      continue;
+    }
+    const quote = /^>\s?(.*)$/.exec(line);
+    if (quote) {
+      const first = [pad, {
+        text: "▎ ",
+        tone: "border"
+      }];
+      for (const row of flow(inline(quote[1], {
+        tone: "muted"
+      }), room, first, first)) push(row);
+      continue;
+    }
+    if (/^\s*([-*_])\1{2,}\s*$/.test(line)) {
+      push([pad, {
+        text: "─".repeat(Math.max(0, Math.min(room - indent, 40))),
+        tone: "border"
+      }]);
+      continue;
+    }
+    for (const row of flow(inline(line, {
+      tone: "text"
+    }), room, [pad], [pad])) push(row);
+  }
+  while (rows.length > 0 && rows.at(-1)?.every(run => run.text.trim() === "")) rows.pop();
+  return rows;
+}

package/dist/core/view/report.js

@@ -0,0 +1,58 @@
+/**
+ * The main agent's view of its subagents: what `subagents_list` answers.
+ *
+ * Written for a model, not a person — plain lines, every id in full, and the one thing it needs to do
+ * with them said once: continue a subagent by its id rather than start a new one, so the follow-up
+ * keeps everything that subagent already read and tried. Pure, like everything in `core/`.
+ */
+
+import { elapsed } from "./rows.js";
+
+/** How much of a subagent's last answer the list repeats. */
+const ANSWER = 400;
+export function subagentReport({
+  nodes,
+  now,
+  version
+}) {
+  if (nodes.length === 0) return "This conversation has no subagents yet.";
+  const how = version === 1 ? "call the task tool with its id as task_id" : "call the subagent tool with its id as sessionID";
+  const lines = [`Subagents of this conversation, oldest first. To follow up on work one of them did, continue that same subagent — ${how} — instead of launching a new one: it keeps everything it already read and tried.`, ""];
+  for (const {
+    session,
+    depth
+  } of nodes) {
+    const calls = session.entries.filter(entry => entry.kind === "tool").length;
+    const rounds = session.entries.filter(entry => entry.kind === "prompt").length;
+    /** What it said after it was last asked something: an answer only if it ended on words. */
+    const since = session.entries.slice(lastPrompt(session.entries) + 1);
+    const tail = since.at(-1);
+    const answered = tail?.kind === "reply" && tail.text.trim() !== "";
+    const cancelled = session.status === "failed" && /abort|interrupt|cancel/i.test(session.error ?? "");
+    /** Idle before it did anything is finished, not working: nothing is coming from it. */
+    const ended = session.status === "done" || session.status === "starting" && session.ended !== undefined;
+    const ago = elapsed(now - (session.ended ?? now));
+    const state = cancelled ? `cancelled ${ago} ago — stopped before it finished${answered ? "" : ", no final answer"}` : ended ? answered ? `finished ${ago} ago` : `ended ${ago} ago without a final answer${since.length === 0 ? " (it never started on its task)" : ""}` : session.status === "failed" ? `failed${session.error ? ` (${session.error})` : ""}` : session.status === "waiting" ? "waiting for a permission" : "working now";
+    const indent = "  ".repeat(depth);
+    lines.push(`${indent}- ${session.id} · ${session.agent} · "${session.title || "subagent"}" · ${state} · ${calls} call${calls === 1 ? "" : "s"}${rounds > 1 ? ` · ${rounds} rounds` : ""}${session.background ? " · background" : ""}`);
+    if (session.task) lines.push(`${indent}  Task: ${clip(session.task, ANSWER)}`);
+    const answer = lastAnswer(session.entries);
+    if (answer) lines.push(answered ? `${indent}  Last answer: ${clip(answer, ANSWER)}` : `${indent}  Last words (a progress note, not its answer): ${clip(answer, ANSWER)}`);
+  }
+  return lines.join("\n");
+}
+function lastPrompt(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) if (entries[i]?.kind === "prompt") return i;
+  return -1;
+}
+function lastAnswer(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry?.kind === "reply" && entry.text.trim()) return entry.text;
+  }
+  return undefined;
+}
+const clip = (text, most) => {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > most ? `${flat.slice(0, most - 1)}…` : flat;
+};

package/dist/core/view/rows.js

@@ -0,0 +1,146 @@
+/**
+ * Rows of styled runs — the one drawing of every Subagents surface, pure so a test can measure it.
+ *
+ * Tones name a meaning, never a colour; `tui/render.ts` is the only place that knows what a tone
+ * looks like, so the preview CLI and OpenCode draw the same rows (docs/building/terminal-ui.md).
+ */
+
+/**
+ * What sits behind a run: the header band, a block (code, the input), a card (the task, your
+ * messages), or the item under the cursor.
+ */
+
+export const rowText = row => row.map(run => run.text).join("");
+
+/** Columns a string takes. Wide characters (CJK, most emoji) take two. */
+export function widthOf(text, limit = Number.POSITIVE_INFINITY) {
+  let width = 0;
+  for (const char of text) {
+    /** Past the limit the answer is "too wide" — a 100 kB line need not be measured to the end. */
+    if (width > limit) return width;
+    const code = char.codePointAt(0) ?? 0;
+    width += code >= 0x1100 && (code <= 0x115f || code >= 0x2e80 && code <= 0xa4cf || code >= 0xac00 && code <= 0xd7a3 || code >= 0xf900 && code <= 0xfaff || code >= 0xfe30 && code <= 0xfe4f || code >= 0xff00 && code <= 0xff60 || code >= 0xffe0 && code <= 0xffe6 || code >= 0x1f300 && code <= 0x1faff || code >= 0x20000 && code <= 0x3fffd) ? 2 : 1;
+  }
+  return width;
+}
+
+/** `text` in at most `width` columns, ending in `…` when cut. */
+export function cut(text, width) {
+  if (width <= 0) return "";
+  if (widthOf(text, width) <= width) return text;
+  let out = "";
+  let used = 0;
+  for (const char of text) {
+    const w = widthOf(char);
+    if (used + w > width - 1) break;
+    out += char;
+    used += w;
+  }
+  return `${out}…`;
+}
+
+/**
+ * A row exactly `width` columns wide: runs cut where they overflow, and padded — in the last run's
+ * fill — where they fall short, so a band reaches both edges. Every row every surface draws goes
+ * through here; the grid test holds it to it.
+ */
+export function fit(row, width) {
+  const out = [];
+  let used = 0;
+  for (const run of row) {
+    if (used >= width) break;
+    const room = width - used;
+    const w = widthOf(run.text, room);
+    if (w <= room) {
+      out.push(run);
+      used += w;
+    } else {
+      const text = cut(run.text, room);
+      out.push({
+        ...run,
+        text
+      });
+      used += widthOf(text);
+      break;
+    }
+  }
+  if (used < width) {
+    const last = out.at(-1);
+    out.push({
+      text: " ".repeat(width - used),
+      ...(last?.fill ? {
+        fill: last.fill
+      } : {})
+    });
+  }
+  return out;
+}
+
+/** Left and right parts on one row, the right part flush against the edge; the left gives way. */
+export function spread(left, right, width) {
+  const rightWidth = widthOf(rowText(right));
+  if (rightWidth >= width) return fit(right, width);
+  const leftRoom = width - rightWidth - 1;
+  const shown = fit(left, leftRoom);
+  const fill = right[0]?.fill ?? left.at(-1)?.fill;
+  return [...shown, {
+    text: " ",
+    ...(fill ? {
+      fill
+    } : {})
+  }, ...right];
+}
+
+/** Words onto lines of at most `width` columns; newlines in the text are kept; a long word breaks. */
+export function wrap(text, width) {
+  const room = Math.max(1, width);
+  const lines = [];
+  for (const paragraph of text.replace(/\r/g, "").split("\n")) {
+    if (paragraph.trim() === "") {
+      lines.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of paragraph.split(/(\s+)/)) {
+      if (word === "") continue;
+      if (widthOf(line) + widthOf(word) <= room) {
+        line += word;
+        continue;
+      }
+      if (line.trim() !== "") lines.push(line.trimEnd());
+      line = /^\s+$/.test(word) ? "" : word;
+      while (widthOf(line) > room) {
+        let head = "";
+        for (const char of line) {
+          if (widthOf(head) + widthOf(char) > room) break;
+          head += char;
+        }
+        lines.push(head);
+        line = line.slice(head.length);
+      }
+    }
+    lines.push(line.trimEnd());
+  }
+  return lines;
+}
+
+/** A duration in the fewest characters that still reads: `4s`, `51s`, `2m04s`, `1h12m`. */
+export function elapsed(ms) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, "0")}m`;
+}
+
+/** `1.2k`, `24k`, `1.1M` — tokens in a narrow column. */
+export function compact(n) {
+  if (n < 1000) return `${n}`;
+  if (n < 10_000) return `${(n / 1000).toFixed(1).replace(/\.0$/, "")}k`;
+  if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
+  return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+}
+
+/** A spinner frame, from a clock that ticks on every paint. */
+export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export const spin = frame => SPINNER[Math.abs(frame) % SPINNER.length];