rovecode 0.3.3 → 0.4.0-beta.3

package/src/sextant/draw-plan.ts

@@ -1,187 +0,0 @@
-/** Sextant plan + usage painters (port #41). Ported from the user's sextant v0.4.0 app.js:675-744
- *  (drawPlan steps/crew/next, drawUsage tokens/context bar/cost); the scenario phases are gone — the
- *  steps ARE the session's todos (tools/todo.ts loadTodos), the crew rows are TaskManager TaskInfo,
- *  usage comes from the run's real token/cost accounting. Pure: `now` only drives the crew spinner. */
-
-import { ATTR } from "./types.ts";
-import type { Rect, ScreenLike, Seg, SextantState, Theme } from "./types.ts";
-import type { TaskInfo } from "../core/tasks.ts";
-import { EMPTY } from "../core/voice.ts";
-import type { TodoItem } from "../tools/todo.ts";
-import { fmtK, planCounts } from "./model.ts";
-import { crewSummary, laneGlyph, laneStatus, laneTone } from "./draw-agents.ts";
-import { crewCardBlock, crewCardHeight, groupCrew, paintCrewCards, type CrewTask } from "./crew-cards.ts";
-import { panel } from "./layout.ts";
-import { st } from "./theme.ts";
-import { driftRow } from "./draw-context.ts";
-
-/** the crew section's row ceiling: two full cards and the separator between them (the card is 3 rows —
- *  crew-cards.ts). Beyond that the plan's own steps lose their room, and the `+N more` footer says what is
- *  not shown; the full board is `∷` (draw-agents.ts). */
-const CREW_ROWS_MAX = 7;
-export const STEP_GLYPH: Record<TodoItem["status"], string> = { completed: "◆", in_progress: "◈", pending: "◇" };
-
-const oneLine = (text: string): string => text.replace(/\s+/g, " ").trim();
-/** greedy word wrap (app.js wrap) — long words are split at the width */
-export function wrapText(text: string, width: number): string[] {
-  const out: string[] = [];
-  if (width <= 0) return out;
-  for (const para of oneLine(text).split("\n")) {
-    let line = "";
-    for (const w of para.split(" ")) {
-      if (!line) { line = w; continue; }
-      if ([...line].length + 1 + [...w].length <= width) line += " " + w; else { out.push(line); line = w; }
-    }
-    while ([...line].length > width) { const cps = [...line]; out.push(cps.slice(0, width).join("")); line = cps.slice(width).join(""); }
-    out.push(line);
-  }
-  return out;
-}
-
-/** `next` = the in_progress item, then the first pending one */
-export function nextSteps(todos: readonly TodoItem[]): TodoItem[] {
-  const out: TodoItem[] = [];
-  const cur = todos.find((t) => t.status === "in_progress"); if (cur) out.push(cur);
-  const pend = todos.find((t) => t.status === "pending"); if (pend) out.push(pend);
-  return out;
-}
-/** non-terminal tasks = "working" (queued + running) — crewSummary(crew).working agrees */
-export const crewWorking = (crew: readonly TaskInfo[]): number => crewSummary(crew).working;
-/** the crew board's glyph + tone (#46 draw-agents): ◇ queued · spinner running · ◆ done · × failed · ▪ cancelled */
-export function crewGlyph(t: TaskInfo, theme: Theme, now: number): [string, number] {
-  return [laneGlyph(t.status, now), laneTone(t.status, theme)];
-}
-/** the crew board's status word (#46 laneStatus): `working mm:ss` while running, else the status */
-export const crewStatus = (t: TaskInfo, now = 0): string => laneStatus(t, now);
-
-/** Plan panel: `plan  done/total` title, todo steps (◆ done · ◈ in_progress · ◇ pending, priority hint
- *  at the right), then — anchored to the bottom — `crew  k working` (when any) and `next`. */
-export function drawPlan(scr: ScreenLike, R: Rect, s: SextantState, theme: Theme, now = 0): void {
-  const todos = s.plan.todos, c = planCounts(s);
-  const B = panel(scr, R, "plan", false, todos.length ? [[`${c.completed}/${c.total}`, st(theme.muted)]] : [], theme);
-  const yEnd = B.y + B.h;
-  let y = B.y;
-  if (s.plan.note) for (const line of wrapText(s.plan.note, B.w).slice(0, 2)) if (y < yEnd) scr.put(B.x, y++, line, st(theme.warn), B.w);
-  const next = nextSteps(todos);
-  // the crew section is CARDS now (Berkay's pick): one card per workflow — the tasks of one run — never one row
-  // per task. The height is what the cards actually need, capped; the block itself drops spacing, then names,
-  // then whole cards behind a footer (crew-cards.ts states the order).
-  const groups = groupCrew(s.crew as readonly CrewTask[]);
-  const crewNeed = groups.length ? Math.min(CREW_ROWS_MAX, crewCardHeight(groups, B.w, now)) : 0;
-  let nextRows = next.length ? next.length + 1 : 0, crewRows = crewNeed ? crewNeed + 1 : 0;
-  let nextY = yEnd - nextRows;
-  let crewY = (nextRows ? nextY - 1 : yEnd) - crewRows;
-  const minY = y + 2; // keep the steps header + one row above the anchored blocks
-  if (crewRows && crewY < minY) { crewRows = 0; crewY = yEnd; }
-  if (nextRows && nextY < minY) { nextRows = 0; nextY = yEnd; }
-  const stepsEnd = crewRows ? crewY - 1 : nextRows ? nextY - 1 : yEnd;
-  scr.text(B.x, y++, [["steps", st(theme.muted)], [todos.length ? `  ${c.completed}/${c.total}` : "", st(theme.dim)]], B.w);
-  if (!todos.length && y < stepsEnd) { // empty plan: the hint's second line only when there is room
-    scr.put(B.x, y++, EMPTY.plan[0], st(theme.dim), B.w);
-    if (y < stepsEnd) scr.put(B.x, y++, EMPTY.plan[1], st(theme.dim), B.w);
-  }
-  // a long plan windows around the step in progress instead of always showing its head: the person
-  // wants to see what is being done now, not steps 1-8 of 30. One row above says how many are earlier.
-  const room = Math.max(0, stepsEnd - y), curIdx = todos.findIndex((t) => t.status === "in_progress");
-  let start = 0;
-  if (todos.length > room && curIdx >= room - 1) { // the current step would be hidden (or be the marker row)
-    const visible = Math.max(1, room - 2); // minus the "earlier" row and the "+N more" row
-    start = Math.max(0, Math.min(curIdx - Math.floor(visible / 2), todos.length - visible));
-  }
-  if (start > 0 && y < stepsEnd) scr.put(B.x, y++, `  …${start} earlier`, st(theme.dim), B.w);
-  let shown = start;
-  for (const t of todos.slice(start)) {
-    if (y >= stepsEnd) break;
-    const cur = t.status === "in_progress", done = t.status === "completed";
-    const pr = t.priority === "high" ? "high" : t.priority === "low" ? "low" : "";
-    scr.put(B.x, y, STEP_GLYPH[t.status], st(done ? theme.okDim : cur ? theme.accent : theme.dim));
-    scr.clip(B.x + 3, y, oneLine(t.content), st(done ? theme.fg2 : cur ? theme.fg : theme.muted, -1, cur ? ATTR.BOLD : 0), B.w - 3 - (pr ? pr.length + 1 : 0));
-    if (pr) scr.put(B.x + B.w - pr.length, y, pr, st(t.priority === "high" ? theme.warn : theme.dim));
-    y++; shown++;
-  }
-  if (shown < todos.length && shown > 0) { y--; scr.fill(B.x, y, B.w, 1, " "); scr.put(B.x, y, `  +${todos.length - shown + 1} more`, st(theme.dim), B.w); }
-  if (crewRows) {
-    let cy = crewY;
-    scr.text(B.x, cy++, [["crew", st(theme.muted)], [`  ${crewSummary(s.crew).text}`, st(theme.dim)]], B.w);
-    const block = crewCardBlock(groups, B.w, crewRows - 1, now);
-    paintCrewCards(scr, B.x, cy, B.w, block.lines, theme);
-  }
-  if (nextRows) {
-    let ny = nextY;
-    scr.put(B.x, ny++, "next", st(theme.muted));
-    for (const t of next) {
-      const cur = t.status === "in_progress";
-      scr.text(B.x, ny++, [[STEP_GLYPH[t.status] + " ", st(cur ? theme.accent : theme.dim)], [oneLine(t.content), st(cur ? theme.fg : theme.muted)]], B.w);
-    }
-  }
-}
-
-/** filled cells of a `width`-wide context bar at `pct` (0..100) */
-export const barFilled = (pct: number, width: number): number => Math.round((Math.max(0, Math.min(100, pct)) / 100) * width);
-/** the first candidate that fits `width` cells, else the last one clipped with an ellipsis */
-export function fitText(candidates: readonly string[], width: number): string {
-  for (const c of candidates) if ([...c].length <= width) return c;
-  const last = candidates[candidates.length - 1];
-  if (last === undefined || width <= 0) return "";
-  return width === 1 ? "…" : [...last].slice(0, width - 1).join("") + "…";
-}
-
-/** Usage panel (3 inner rows): `tokens 4.2k` (+ in/out split when it fits), `context ━━──── 12%`
- *  (or `context ?` when the window is unknown), `cost $0.030` (or `cost —` when unpriced) +
- *  provider/model (model alone, then clipped, when narrow). */
-/** Token counts for the context row, as short as they can be and still be read: `842`, `4.2k`, `24k`,
- *  `200k`, `1M`. fmtK keeps a decimal at every size, which is right where a number stands alone and
- *  wrong in a pair — `24.0k/200.0k` costs six characters that say nothing and eats the bar beside it. */
-function fmtCtx(n: number): string {
-  if (n < 1000) return String(Math.round(n));
-  if (n < 10_000) return `${(n / 1000).toFixed(1)}k`;
-  if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
-  const m = n / 1_000_000;
-  return m < 10 && m !== Math.round(m) ? `${m.toFixed(1)}M` : `${Math.round(m)}M`;
-}
-
-export function drawUsage(scr: ScreenLike, R: Rect, s: SextantState, theme: Theme): void {
-  const B = panel(scr, R, "usage", false, [], theme);
-  const u = s.usage;
-  const label = (t: string): Seg => [t.padEnd(10), st(theme.muted)];
-  const total = fmtK(u.tokensIn + u.tokensOut);
-  const split = fitText([`  ${fmtK(u.tokensIn)} in · ${fmtK(u.tokensOut)} out`, `  ${fmtK(u.tokensIn)}/${fmtK(u.tokensOut)}`, ""], B.w - 10 - total.length);
-  if (u.tokensIn + u.tokensOut === 0) scr.text(B.x, B.y, [label("tokens"), [EMPTY.usage, st(theme.dim)]], B.w); // nothing spent yet
-  else scr.text(B.x, B.y, [label("tokens"), [total, st(theme.fg)], [split, st(theme.dim)]], B.w);
-  scr.text(B.x, B.y + 1, [label("context")]);
-  if (u.contextPct === null) scr.put(B.x + 10, B.y + 1, "?", st(theme.dim));
-  else {
-    // A percentage alone goes blind on a large window. claude-opus-5 carries 1,000,000 tokens, so a
-    // real working session sits at 0% for hours: you need 10k tokens to move the first digit, and
-    // Berkay's report was exactly this — "context shows 0%, we cannot see how much context there is".
-    // The numbers are what a person acts on ("42k of 1M" is a decision; "0%" is not), so they get the
-    // room and the percent keeps only what is left. The bar stays: it is the at-a-glance channel, and
-    // it is the only part that reads correctly when the window is small.
-    const pct = `${Math.round(u.contextPct)}%`;
-    const nums = u.contextWindow !== undefined ? `${fmtCtx(u.contextTokens ?? 0)}/${fmtCtx(u.contextWindow)}` : "";
-    const tail = nums === "" ? pct : `${nums} ${pct}`;
-    const barW = Math.max(4, B.w - 10 - tail.length - 2);
-    const filled = barFilled(u.contextPct, barW);
-    for (let i = 0; i < barW; i++) scr.put(B.x + 10 + i, B.y + 1, i < filled ? "━" : "─", st(i < filled ? theme.accent : theme.rule2));
-    const tailX = B.x + 10 + barW + 2;
-    if (nums !== "") scr.put(tailX, B.y + 1, nums, st(theme.dim));
-    scr.put(tailX + (nums === "" ? 0 : nums.length + 1), B.y + 1, pct, st(u.contextPct > 80 ? theme.warn : theme.fg));
-  }
-  const cost = u.costUsd === null ? "—" : `$${u.costUsd.toFixed(3)}`;
-  const model = u.model ? fitText([u.provider ? `  ${u.provider}/${u.model}` : `  ${u.model}`, `  ${u.model}`], B.w - 10 - cost.length) : "";
-  scr.text(B.x, B.y + 2, [label("cost"), [cost, st(theme.fg)], [model, st(theme.dim)]], B.w);
-
-  // How far the bar above is from what the provider actually counted. It matters here rather than only
-  // inside /context because compaction fires on OUR estimate: a model whose real prompt is a fifth bigger
-  // than the bar says gets compacted late, and the bar is the thing the human is looking at when they
-  // decide whether one more turn fits.
-  //
-  // Drawn only once /context has been opened, and silent otherwise. The number comes from comparing our
-  // count with a turn that reported usage, which the cockpit does not do on its own — and inventing a
-  // placeholder ("drift —") would take a row to say nothing. `driftRow` returns undefined when there is
-  // nothing honest to say, so this is one condition rather than a special case.
-  const d = s.context ? driftRow(s.context.drift, s.context.tolerance) : undefined;
-  if (d && B.h > 3) {
-    scr.text(B.x, B.y + 3, [label("drift"), [fitText([d.text, ""], B.w - 10), st(d.warn ? theme.warn : theme.dim)]], B.w);
-  }
-}

package/src/sextant/draw-tabs.ts

@@ -1,85 +0,0 @@
-/** The tab strip: paging between panels the terminal is too narrow to show at once.
- *
- *  layout.ts hides the files panel under 140 columns and the plan/usage column under 110, and until
- *  now a hidden panel was simply gone — ⌃e answered "the files panel needs ≥ 140 columns" and that was
- *  that. Berkay asked for the panels to behave like tabs instead: on a narrow terminal the MAIN slot
- *  (the code panel's rect) shows whichever panel `s.page` names, and a strip on that slot's top border
- *  says which panels exist and which one is showing. Clicking a tab pages to it; ⌃e pages to files,
- *  ⌃o cycles.
- *
- *  Deliberately absent on a wide terminal: when every panel is on screen there is nothing to page,
- *  and a strip would be one more thing to read. tabsFor() returns [] and nothing is drawn.
- *
- *  Geometry and painting live together here so the hit zones the frame loop registers are the cells
- *  that were actually painted — the same rule card-hits.ts and panel-hits.ts follow. The strip
- *  overpaints the panel title on the top border (panel() draws the title at x+2); the active tab IS
- *  the title. */
-
-import { st } from "./draw-util.ts";
-import { strWidth } from "./screen.ts";
-import { ATTR, PAGES, type Layout, type Page, type Rect, type ScreenLike, type SextantState, type Theme } from "./types.ts";
-
-export interface Tab {
-  page: Page;
-  /** the cells the label occupies on the border row */
-  rect: Rect;
-  active: boolean;
-}
-
-const LABEL: Record<Page, string> = { code: "code", files: "files", plan: "plan" };
-const SEP = " · ";
-
-/** is this page's own panel hidden by the layout, so it needs a tab to be reachable? */
-export function hiddenByLayout(L: Layout, page: Page): boolean {
-  return page === "files" ? L.files === null : page === "plan" ? L.plan === null : false;
-}
-
-/** the page actually showing in the main slot: `s.page` if that panel is hidden by the layout (so
- *  paging is what makes it visible), else code — a page pointing at a panel that is already on
- *  screen is inert, never a duplicate */
-export function mainPage(L: Layout, s: SextantState): Page {
-  return hiddenByLayout(L, s.page) ? s.page : "code";
-}
-
-/** The tabs to show, positioned on the main slot's top border; [] on a wide terminal. */
-export function tabsFor(L: Layout, s: SextantState): Tab[] {
-  const hidden = PAGES.filter((p) => hiddenByLayout(L, p));
-  if (hidden.length === 0) return [];
-  const pages: Page[] = ["code", ...hidden];
-  const active = mainPage(L, s);
-  const y = L.code.y;
-  const right = L.code.x + L.code.w - 2; // the border's last usable cell before the corner
-  let x = L.code.x + 2;
-  const out: Tab[] = [];
-  for (const [i, page] of pages.entries()) {
-    const w = strWidth(LABEL[page]) + 2; // ` label `
-    if (x + w > right) break;           // a strip the border cannot hold stops, never wraps
-    out.push({ page, rect: { x, y, w, h: 1 }, active: page === active });
-    x += w + (i < pages.length - 1 ? strWidth(SEP) : 0);
-  }
-  return out;
-}
-
-/** Paint the strip over the main slot's top border. Pure; returns what it painted. */
-export function drawTabs(scr: ScreenLike, L: Layout, s: SextantState, theme: Theme): Tab[] {
-  const tabs = tabsFor(L, s);
-  if (tabs.length === 0) return tabs;
-  const focused = s.focus === "code" || s.focus === "files";
-  for (const [i, t] of tabs.entries()) {
-    const style = t.active
-      ? st(theme.bg, focused ? theme.accent : theme.fg2, ATTR.BOLD)
-      : st(theme.muted);
-    scr.text(t.rect.x, t.rect.y, [[` ${LABEL[t.page]} `, style]], t.rect.w);
-    const next = tabs[i + 1];
-    if (next) scr.text(t.rect.x + t.rect.w, t.rect.y, [[SEP, st(theme.frame)]], next.rect.x - (t.rect.x + t.rect.w));
-  }
-  return tabs;
-}
-
-/** the page after `page` among the tabs on screen (⌃o); `page` itself when there is nothing to cycle */
-export function nextPage(L: Layout, s: SextantState): Page {
-  const tabs = tabsFor(L, s);
-  if (tabs.length < 2) return s.page;
-  const i = tabs.findIndex((t) => t.active);
-  return tabs[(i + 1) % tabs.length]!.page;
-}

package/src/sextant/draw-util.ts

@@ -1,65 +0,0 @@
-/** Sextant surface (port #42) — small pure drawing helpers shared by the code and messages panels.
- *  Ported from the user's own sextant v0.4.0 prototype: src/app.js:37 (st), :66-78 (wrap), :210-220
- *  (panel). Pure: no clock, no timers, no process access — `now` arrives as a parameter.
- *  #44 dedupe: `st` and `panel` are the shared theme.ts / layout.ts ones, re-exported here so the
- *  panels' imports stay put (layout.ts panel() = this file's former one: interior cleared to the
- *  theme background, extras clipped with an ellipsis before they are dropped). */
-
-import { SPIN, type Rect } from "./types.ts";
-
-export { st } from "./theme.ts";
-export { panel } from "./layout.ts";
-
-/** the four-glyph diamond spinner, phase from the frame clock (140 ms per step) */
-export const spinner = (now: number): string => SPIN[Math.floor(now / 140) % SPIN.length] ?? "◇";
-
-/** split file content into lines; a trailing newline does not produce a phantom empty line */
-export function splitLines(s: string): string[] {
-  const l = s.split("\n");
-  if (l.length && l[l.length - 1] === "") l.pop();
-  return l;
-}
-
-/** 1-slot cache: splitLines is called twice per frame (drawFileView + codeScrollTop/rowCount).
- *  File content is a stable string reference within a frame; reference equality is the cheapest guard. */
-let _splitCache: { src: string; lines: string[] } | null = null;
-export function splitLinesCached(s: string): string[] {
-  if (_splitCache && _splitCache.src === s) return _splitCache.lines;
-  const lines = splitLines(s);
-  _splitCache = { src: s, lines };
-  return lines;
-}
-
-/** Word-wrap to `width` cells — one cell per code point (types.ts), so an emoji counts once and a
- *  surrogate pair never straddles two rows — keeping explicit newlines (a blank paragraph stays a
- *  blank row); a word longer than the width is hard-split wherever it starts. Never returns []. */
-export function wrap(text: string, width: number): string[] {
-  const w = Math.max(1, width);
-  const out: string[] = [];
-  for (const para of String(text).split("\n")) {
-    let line = "", len = 0;
-    for (const word of para.split(" ")) {
-      const cps = [...word];
-      if (line && len + 1 + cps.length <= w) { line += " " + word; len += 1 + cps.length; continue; }
-      if (line) out.push(line);
-      while (cps.length > w) out.push(cps.splice(0, w).join(""));
-      line = cps.join(""); len = cps.length;
-    }
-    out.push(line);
-  }
-  return out;
-}
-
-/** hard-split a line into `width`-cell chunks (terminal-style, no word boundaries; one cell per
- *  code point — an astral glyph moves to the next row whole); "" → [""] */
-export function hardWrap(line: string, width: number): string[] {
-  const w = Math.max(1, width);
-  const cps = [...line];
-  if (cps.length <= w) return [line];
-  const out: string[] = [];
-  for (let i = 0; i < cps.length; i += w) out.push(cps.slice(i, i + w).join(""));
-  return out;
-}
-
-/** inner rect of a panel drawn at `r` (2 cells of horizontal padding, 1 row for each border) */
-export const inner = (r: Rect): Rect => ({ x: r.x + 2, y: r.y + 1, w: r.w - 4, h: r.h - 2 });