rovecode 0.3.3 → 0.4.0-beta.3

package/src/sextant/draw-agents.ts

@@ -1,273 +0,0 @@
-/** Port #46 — the CREW BOARD: the `∷` agents mode of the code panel, a grid of lane cells over the
- *  runtime's background tasks (core/tasks.ts TaskManager → SextantState.crew: TaskInfo[]). Ported from
- *  the user's own sextant v0.4.0 prototype src/app.js:758-892 (laneGlyph/laneStatus, drawLane cell,
- *  drawAgents grid, the full-lane view; user-owned) + README "Crew". The mock lanes are gone (spawnLane/
- *  runLane scripts, the AGENTS roster, log tail, progress steps): a cell shows one real TaskInfo —
- *  header `label · elapsed · tokens`, the goal, `id · agent`, the result row — and the board NEVER starts
- *  a task (ADR-013: only the `task` tool spawns children; this file only reads TaskInfo). PURE painter:
- *  `now` is a parameter, no timers, no wall clock, no randomness, no process access, no state writes —
- *  the renderer replaces s.crew (model.ts setCrew) from tasks.subscribe()/list() and #44 wires the board
- *  with ONE line, `setAgentsPainter(drawAgents)` (draw-code.ts seam). Keys live in keys.ts (#43):
- *  ←→↑↓ move s.code.lane, ⏎ toggles s.code.laneOpen, Esc closes. */
-
-import type { TaskInfo } from "../core/tasks.ts";
-import { ATTR, type Rect, type ScreenLike, type Seg, type SextantState, type Theme } from "./types.ts";
-import { spinner, st, wrap } from "./draw-util.ts";
-import { fmtClock, fmtK } from "./model.ts";
-
-type LaneStatus = TaskInfo["status"];
-type Tone = "fg" | "fg2" | "muted" | "dim" | "ok" | "err" | "accent";
-type Run = { text: string; tone: Tone; bold?: boolean };
-type Row = Run[];
-
-/** columns by body width: 1 below 70 cells, 2 below 120, else 3 — never more than there are tasks */
-export const GRID_BREAKS: readonly [number, number] = [70, 120];
-/** a cell needs its two border rows + the header + one body row + the result row */
-const MIN_CELL_H = 5, MIN_CELL_W = 12;
-/** goal preview rows in a grid cell / in the full lane */
-const GOAL_ROWS = 2, GOAL_ROWS_FULL = 4;
-/** the activity sweep advances one cell per 100 ms */
-export const SWEEP_MS = 100;
-export const EMPTY_NOTE = "no background tasks — I start them with the task tool for parallel work";
-const ESC_HINT = "esc back";
-
-// ------------------------------------------------------------------ pure lane helpers
-
-/** ◇ queued · spinner while running (phase from `now`) · ◆ done · × failed · ▪ cancelled */
-export function laneGlyph(status: LaneStatus, now = 0): string {
-  switch (status) {
-    case "queued": return "◇";
-    case "running": return spinner(now);
-    case "done": return "◆";
-    case "failed": return "×";
-    default: return "▪";
-  }
-}
-export function laneTone(status: LaneStatus, theme: Theme): number {
-  switch (status) {
-    case "queued": return theme.dim;
-    case "running": return theme.accent;
-    case "done": return theme.ok;
-    case "failed": return theme.err;
-    default: return theme.muted;
-  }
-}
-/** ms the task has been (or was) active: startedAt — createdAt while still queued — to finishedAt or `now` */
-export function laneElapsed(t: TaskInfo, now: number): number {
-  return Math.max(0, (t.finishedAt ?? now) - (t.startedAt ?? t.createdAt));
-}
-/** mm:ss — lane headers drop fmtClock's tenths (app.js:848) */
-export const laneClock = (ms: number): string => fmtClock(ms).replace(/\.\d$/, "");
-/** total tokens the child used; TaskManager fills usage only when the run settles → "—" until then */
-export const laneTokens = (t: TaskInfo): string => (t.usage ? fmtK(t.usage.input + t.usage.output) : "—");
-/** short status for lists (the plan panel's `agent · status` column): a live clock while working.
- *  The prototype's `needs you` (a lane blocked on a permission) is not knowable from TaskInfo today —
- *  children run with prompt→deny rules (tasks.ts childPolicy), so no task ever waits on the user. */
-export function laneStatus(t: TaskInfo, now: number): string {
-  switch (t.status) {
-    case "queued": return "queued";
-    case "running": return `working ${laneClock(laneElapsed(t, now))}`;
-    default: return t.status;
-  }
-}
-const firstLine = (text: string | undefined): string => (text ?? "").split("\n").map((l) => l.trim()).find((l) => l !== "") ?? "";
-/** the result row — what the bottom line of a cell says (the running row is the sweep bar instead) */
-export function laneResult(t: TaskInfo): string {
-  switch (t.status) {
-    case "done": return `done: ${firstLine(t.summary) || "(no output)"}`;
-    case "failed": return `failed: ${firstLine(t.error) || "(no reason)"}`;
-    case "cancelled": return "cancelled";
-    case "queued": return "queued · waiting for a slot";
-    default: return "running";
-  }
-}
-/** `+N lines merged` for an isolated child whose patch landed; null when there is nothing to say */
-export function laneMerged(t: TaskInfo): string | null {
-  if (!t.isolated || t.patchLines === undefined) return null;
-  return t.patchLines > 0 ? `+${t.patchLines} lines merged` : "nothing merged";
-}
-
-export interface CrewSummary {
-  total: number; queued: number; running: number; done: number; failed: number; cancelled: number;
-  /** non-terminal = queued + running (draw-plan crewWorking agrees) */
-  working: number;
-  /** lanes blocked on the user — always 0 today (see laneStatus); a runtime signal would fill it */
-  needsYou: number;
-  /** `k working` · `d/n done` · `no background tasks` */
-  text: string;
-}
-export function crewSummary(crew: readonly TaskInfo[]): CrewSummary {
-  const c = { total: crew.length, queued: 0, running: 0, done: 0, failed: 0, cancelled: 0 };
-  for (const t of crew) c[t.status]++;
-  const working = c.queued + c.running;
-  const text = working ? `${working} working` : c.total ? `${c.done}/${c.total} done` : "no background tasks";
-  return { ...c, working, needsYou: 0, text };
-}
-
-export function gridFor(width: number, n: number): { cols: number; rows: number } {
-  if (n <= 0) return { cols: 0, rows: 0 };
-  const cols = Math.min(n, width < GRID_BREAKS[0] ? 1 : width < GRID_BREAKS[1] ? 2 : 3);
-  return { cols, rows: Math.ceil(n / cols) };
-}
-/** indeterminate activity bar: a block a quarter of the width (≥1) sweeps left→right one cell per
- *  SWEEP_MS, leaves at the right edge and re-enters at the left — deterministic in `now`, no randomness */
-export function sweepCells(width: number, now: number): boolean[] {
-  const w = Math.max(1, width), block = Math.max(1, Math.floor(w / 4));
-  const head = Math.floor(Math.max(0, now) / SWEEP_MS) % (w + block);
-  return Array.from({ length: w }, (_, i) => i < head && i >= head - block);
-}
-
-// ------------------------------------------------------------------ geometry
-
-const clampLane = (s: SextantState): number => Math.max(0, Math.min(s.code.lane, s.crew.length - 1));
-const innerOf = (R: Rect): Rect => ({ x: R.x + 2, y: R.y + 1, w: R.w - 4, h: R.h - 2 });
-
-export interface BoardPage {
-  /** crew index + the cell rect (border included) — the renderer's click zones */
-  cells: { index: number; rect: Rect }[];
-  page: number;
-  pages: number;
-  /** the last body row is the `p/n · k tasks` footer because not every lane fits */
-  footer: boolean;
-}
-/** Where each visible lane goes: the open lane fills the body; otherwise a gridFor() grid of equal cells,
- *  paged so the selected lane is always on screen (page = ⌊lane / perPage⌋). [] when the body is too small
- *  for cells (drawAgents then lists lanes compactly). */
-export function laneCells(body: Rect, s: SextantState): BoardPage {
-  const n = s.crew.length;
-  if (n === 0 || body.w < MIN_CELL_W || body.h < 3) return { cells: [], page: 0, pages: 0, footer: false };
-  const lane = clampLane(s);
-  if (s.code.laneOpen) return { cells: [{ index: lane, rect: body }], page: 0, pages: 1, footer: false };
-  const { cols, rows } = gridFor(body.w, n);
-  const fit = (h: number): number => cols * Math.max(1, Math.min(rows, Math.floor(h / MIN_CELL_H)));
-  const footer = fit(body.h) < n;
-  const perPage = fit(body.h - (footer ? 1 : 0)), h = body.h - (footer ? 1 : 0);
-  const pages = Math.ceil(n / perPage), page = Math.floor(lane / perPage);
-  const first = page * perPage, shown = Math.min(perPage, n - first);
-  const cw = Math.floor(body.w / cols), ch = Math.floor(h / Math.ceil(shown / cols));
-  const cells = Array.from({ length: shown }, (_, i) => ({ index: first + i, rect: { x: body.x + (i % cols) * cw, y: body.y + Math.floor(i / cols) * ch, w: cw, h: ch } }));
-  return { cells, page, pages, footer };
-}
-
-/** the full lane's text body: the child's final text (done), its failure reason, or a placeholder */
-function fullText(t: TaskInfo): string {
-  if (t.status === "done") return t.summary?.trim() || "(no output)";
-  if (t.status === "failed" || t.status === "cancelled") return t.error?.trim() || t.status;
-  return "no result yet";
-}
-/** rows under the header of a grid cell: goal preview, `id · agent[ · isolated]`, merged note. In a short
- *  cell (`avail` rows between header and result) the id/agent row wins over goal lines — `/tasks cancel <id>`
- *  needs the id, and the header already carries the label. */
-function cellRows(t: TaskInfo, width: number, avail: number): Row[] {
-  const goalRows = Math.max(0, Math.min(GOAL_ROWS, avail - 1));
-  const rows: Row[] = wrap(t.goal, width).filter((l) => l !== "").slice(0, goalRows).map((l) => [{ text: l, tone: "muted" }]);
-  rows.push([{ text: `${t.id} · ${t.agent}${t.isolated ? " · isolated" : ""}`, tone: "dim" }]);
-  const merged = laneMerged(t);
-  if (merged) rows.push([{ text: merged, tone: t.patchLines ? "ok" : "dim" }]);
-  return rows;
-}
-/** the full lane's head: goal (wrapped, room for `esc back`), meta with depth, status, usage, merged, a blank */
-function fullHead(t: TaskInfo, width: number, now: number): Row[] {
-  const rows: Row[] = wrap(t.goal, Math.max(1, width - ESC_HINT.length - 2)).filter((l) => l !== "").slice(0, GOAL_ROWS_FULL).map((l) => [{ text: l, tone: "muted" }]);
-  if (!rows.length) rows.push([{ text: "", tone: "muted" }]); // the hint row exists even without a goal
-  rows.push([{ text: `${t.id} · ${t.agent} · depth ${t.depth}${t.isolated ? " · isolated" : ""}`, tone: "dim" }]);
-  rows.push([{ text: laneGlyph(t.status, now) + " ", tone: statusTone(t.status) }, { text: laneStatus(t, now), tone: "fg2" }]);
-  if (t.usage) {
-    const cost = t.usage.costUsd !== undefined ? ` · $${t.usage.costUsd.toFixed(3)}` : "";
-    rows.push([{ text: "tokens ", tone: "muted" }, { text: `${fmtK(t.usage.input)} in · ${fmtK(t.usage.output)} out${cost}`, tone: "fg2" }]);
-  }
-  const merged = laneMerged(t);
-  if (merged) rows.push([{ text: merged, tone: t.patchLines ? "ok" : "dim" }]);
-  rows.push([]);
-  return rows;
-}
-const statusTone = (status: LaneStatus): Tone =>
-  status === "queued" ? "dim" : status === "running" ? "accent" : status === "done" ? "ok" : status === "failed" ? "err" : "muted";
-
-/** Effective first visible row of the open lane's text body — s.code.scroll clamped to the text (keys.ts
- *  opens with SCROLL_TAIL = the last rows). 0 when no lane is open. The renderer writes this back into
- *  s.code.scroll after a frame (codeScrollTop counts 0 rows for the agents mode — see the #44 notes). */
-export function agentsScrollTop(body: Rect, s: SextantState): number {
-  if (!s.code.laneOpen || !s.crew.length) return 0;
-  const t = s.crew[clampLane(s)]!, I = innerOf(body);
-  if (I.w < 4 || I.h < 3) return 0;
-  const textRows = I.h - 2 - fullHead(t, I.w, 0).length;
-  const max = Math.max(0, wrap(fullText(t), I.w).length - textRows);
-  return Math.max(0, Math.min(s.code.scroll, max));
-}
-
-// ------------------------------------------------------------------ painting
-
-const runSt = (r: Run, theme: Theme) => st(theme[r.tone], -1, r.bold ? ATTR.BOLD : 0);
-const putRow = (scr: ScreenLike, x: number, y: number, w: number, row: Row, theme: Theme): void => {
-  if (row.length) scr.text(x, y, row.map((r): Seg => [r.text, runSt(r, theme)]), w);
-};
-
-/** `<glyph> <label>` left (bold; accent when selected), `mm:ss · tokens` right (dim) */
-function drawHeader(scr: ScreenLike, I: Rect, t: TaskInfo, theme: Theme, now: number, selected: boolean): void {
-  const right = `${laneClock(laneElapsed(t, now))} · ${laneTokens(t)}`;
-  const showRight = right.length + 6 <= I.w;
-  const gx = scr.put(I.x, I.y, laneGlyph(t.status, now) + " ", st(laneTone(t.status, theme)), I.w);
-  scr.clip(gx, I.y, t.label, st(selected ? theme.accent : theme.fg, -1, ATTR.BOLD), I.x + I.w - gx - (showRight ? right.length + 1 : 0));
-  if (showRight) scr.put(I.x + I.w - right.length, I.y, right, st(theme.dim));
-}
-
-/** the bottom row: the sweep bar + `running` while the child runs, else laneResult() colored by outcome */
-function drawResult(scr: ScreenLike, x: number, y: number, w: number, t: TaskInfo, theme: Theme, now: number): void {
-  if (t.status === "running") {
-    const word = "running", bw = w - word.length - 2;
-    if (bw < 4) { scr.put(x, y, word, st(theme.muted), w); return; }
-    sweepCells(bw, now).forEach((lit, i) => scr.put(x + i, y, lit ? "━" : "─", st(lit ? theme.accent : theme.rule2)));
-    scr.put(x + bw + 2, y, word, st(theme.muted));
-    return;
-  }
-  const text = laneResult(t), colon = text.indexOf(": ");
-  const tone = laneTone(t.status, theme);
-  if (colon < 0) { scr.clip(x, y, text, st(t.status === "queued" ? theme.dim : tone), w); return; }
-  const px = scr.put(x, y, text.slice(0, colon + 2), st(tone), w);
-  scr.clip(px, y, text.slice(colon + 2), st(t.status === "failed" ? theme.err : theme.fg2), x + w - px);
-}
-
-function drawCell(scr: ScreenLike, R: Rect, t: TaskInfo, s: SextantState, theme: Theme, now: number, selected: boolean): void {
-  const focused = s.focus === "code", full = s.code.laneOpen;
-  scr.box(R.x, R.y, R.w, R.h, st(selected ? (focused ? theme.accent : theme.frame) : theme.frameDim));
-  const I = innerOf(R);
-  if (I.w < 4 || I.h < 1) return;
-  drawHeader(scr, I, t, theme, now, selected);
-  if (I.h < 2) return;
-  const fy = I.y + I.h - 1;
-  const head = full ? fullHead(t, I.w, now) : cellRows(t, I.w, I.h - 2);
-  let y = I.y + 1;
-  for (const row of head) { if (y >= fy) break; putRow(scr, I.x, y++, I.w, row, theme); }
-  if (full) {
-    if (I.w > ESC_HINT.length + 4 && I.y + 1 < fy) scr.put(I.x + I.w - ESC_HINT.length, I.y + 1, ESC_HINT, st(theme.dim));
-    const lines = wrap(fullText(t), I.w), top = agentsScrollTop(R, s);
-    const tone = t.status === "failed" ? theme.err : t.status === "done" ? theme.fg2 : theme.muted;
-    for (let i = top; i < lines.length && y < fy; i++) scr.put(I.x, y++, lines[i]!, st(tone), I.w);
-  }
-  drawResult(scr, I.x, fy, I.w, t, theme, now);
-}
-
-/** a body too small for cells: one line per lane, `<glyph> <label>` + the status word at the right */
-function drawCompact(scr: ScreenLike, B: Rect, s: SextantState, theme: Theme, now: number): void {
-  const lane = clampLane(s);
-  s.crew.slice(0, B.h).forEach((t, i) => {
-    const status = laneStatus(t, now), room = B.w - status.length - 1;
-    const gx = scr.put(B.x, B.y + i, laneGlyph(t.status, now) + " ", st(laneTone(t.status, theme)), B.w);
-    scr.clip(gx, B.y + i, t.label, st(i === lane ? theme.accent : theme.fg), Math.max(0, Math.min(B.x + B.w, B.x + room) - gx));
-    if (room > 8) scr.put(B.x + B.w - status.length, B.y + i, status, st(theme.dim));
-  });
-}
-
-/** Paint the crew board into `rect` (the code panel's body, from draw-code's setAgentsPainter seam): the
- *  lane grid, or the selected lane full-size when s.code.laneOpen, or the empty note. Pure over its inputs. */
-export function drawAgents(scr: ScreenLike, rect: Rect, s: SextantState, theme: Theme, now: number): void {
-  if (rect.w <= 0 || rect.h <= 0) return;
-  scr.fill(rect.x, rect.y, rect.w, rect.h, " ", st(-1, theme.bg)); // the board owns its body (panel() idiom)
-  if (!s.crew.length) { scr.clip(rect.x, rect.y, EMPTY_NOTE, st(theme.muted), rect.w); return; }
-  const page = laneCells(rect, s);
-  if (!page.cells.length) { drawCompact(scr, rect, s, theme, now); return; }
-  const lane = clampLane(s);
-  for (const { index, rect: R } of page.cells) drawCell(scr, R, s.crew[index]!, s, theme, now, index === lane);
-  if (page.footer) scr.clip(rect.x, rect.y + rect.h - 1, `${page.page + 1}/${page.pages} · ${s.crew.length} tasks · ←→↑↓ select`, st(theme.dim), rect.w);
-}