reslop 0.2.7 → 0.3.0

package/lib/render/primitives.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const ansi = require('../ansi.js');
-const actions = require('../session/actions.js');
+const { clamp, trimText } = require('../common/utilities.js');
+const ansi = require('../term/ansi.js');
+const { LIST_PANES } = require('../input/actions.js');
 
 const { THEME, paint, visibleWidth, graphemes, graphemeWidth } = ansi;
-const { LIST_PANES } = actions;
 
 const GUTTER_W = 2;
 const FILE_MARK = '▶';
@@ -17,12 +17,14 @@ const fill = (width, fgRgb, bgRgb, color) =>
 
 const markPrefix = (selected) => ` ${selected ? FILE_MARK : ' '} `;
 
-const isListPane = (pane) =>
-  LIST_PANES.includes(pane) || pane === 'dashboard' || pane === 'repos';
+const isListPane = (pane) => {
+  if (LIST_PANES.includes(pane)) return true;
+  return pane === 'dashboard' || pane === 'repos';
+};
 
 const isTaskView = (view) => view.item?.origin === 'task';
 
-const branchLabel = (name) => `${name ?? ''}`.trim();
+const branchLabel = (name) => trimText(name);
 
 const padVisible = (text, width, align) => {
   const gap = ' '.repeat(Math.max(0, width - visibleWidth(text)));
@@ -46,6 +48,11 @@ const paintBodyFill = (width, color, kind) => {
   return ctx(leftW) + paintSplitRule(color) + ctx(rightW);
 };
 
+const lazyRows = (length, paint) => ({ length, paint });
+
+const bodyRow = (body, index) =>
+  Array.isArray(body) ? body[index] : body.paint(index);
+
 const paneResult = (fields = {}) => ({
   body: fields.body ?? [],
   fileHits: fields.fileHits ?? [],
@@ -55,6 +62,7 @@ const paneResult = (fields = {}) => ({
   splitBody: fields.splitBody === true,
   listScroll: fields.listScroll ?? 0,
   editHits: fields.editHits ?? [],
+  scrollBar: fields.scrollBar ?? null,
 });
 
 const editSpan = (x0, textX, x1, start, text) => ({
@@ -79,7 +87,7 @@ const listWindowStart = (focus, offset, listH, count) => {
   let start = offset ?? 0;
   if (focus < start) start = focus;
   if (focus >= start + listH) start = focus - listH + 1;
-  return Math.max(0, Math.min(start, count - listH));
+  return clamp(start, 0, count - listH);
 };
 
 const rowCursor = (cursor, row) => {
@@ -90,10 +98,11 @@ const rowCursor = (cursor, row) => {
 
 const paintListWindow = (count, focus, pane, lineAt) => {
   const { width, color, bodyH, headerLines, offset } = pane;
-  const pad = bodyH >= LIST_PAD * 2 + 1 ? LIST_PAD : 0;
+  const padded = bodyH >= LIST_PAD * 2 + 1 ? LIST_PAD : 0;
+  const pad = pane.pad === 0 ? 0 : padded;
   const listH = bodyH - pad * 2;
   const start = listWindowStart(focus, offset, listH, count);
-  const blank = paintBodyFill(width, color, 'files');
+  const blank = pane.blank ?? paintBodyFill(width, color, 'files');
   const body = pad ? [blank] : [];
   const fileHits = [];
   const editHits = [];
@@ -105,7 +114,11 @@ const paintListWindow = (count, focus, pane, lineAt) => {
     if (line.cursor) cursor = rowCursor(line.cursor, row);
     for (const edit of line.edits) editHits.push({ ...edit, row });
     if (line.hit) {
-      fileHits.push({ y: headerLines + pad + i + 1, cursor: line.index });
+      const y = headerLines + pad + i + 1;
+      for (const span of line.spans ?? []) {
+        fileHits.push({ y, cursor: line.index, ...span });
+      }
+      fileHits.push({ y, cursor: line.index });
     }
   }
   if (pad) body.push(blank);
@@ -116,7 +129,15 @@ const insertedAt = (extra, count) => {
   if (extra.at === 'start') return 0;
   if (extra.at !== 'index') return count;
   const index = extra.index ?? count;
-  return Math.max(0, Math.min(index, count));
+  return clamp(index, 0, count);
+};
+
+const lineFromPaint = (painted, index) => {
+  if (typeof painted === 'string') return listLine(painted, index);
+  const line = listLine(painted.row, index);
+  if (painted.hit === false) line.hit = false;
+  if (painted.spans) line.spans = painted.spans;
+  return line;
 };
 
 const paintCursorList = (items, cursor, pane, paintRow, extra = null) => {
@@ -124,7 +145,7 @@ const paintCursorList = (items, cursor, pane, paintRow, extra = null) => {
     const entry = items[index];
     if (!entry) return null;
     const selected = !extra && index === cursor;
-    return listLine(paintRow(entry, selected, index), index);
+    return lineFromPaint(paintRow(entry, selected, index), index);
   };
   if (!extra) return paintListWindow(items.length, cursor, pane, lineAt);
   const edit = listLine(extra.row, -1, extra.cursor, extra.edits);
@@ -134,7 +155,11 @@ const paintCursorList = (items, cursor, pane, paintRow, extra = null) => {
     return paintListWindow(items.length, at, pane, replaced);
   }
   const at = insertedAt(extra, items.length);
-  const inserted = (i) => (i === at ? edit : lineAt(i < at ? i : i - 1));
+  const inserted = (i) => {
+    if (i === at) return edit;
+    const index = i < at ? i : i - 1;
+    return lineAt(index);
+  };
   return paintListWindow(items.length + 1, at, pane, inserted);
 };
 
@@ -163,7 +188,7 @@ const sliceVisible = (text, skip, width) => {
 
 const fieldWindow = (text, cursor, scroll, width) => {
   if (width <= 0) return { text: '', col: 0, scroll: 0 };
-  const at = Math.max(0, Math.min(cursor ?? 0, text.length));
+  const at = clamp(cursor ?? 0, 0, text.length);
   const col = visibleWidth(text.slice(0, at));
   let next = Math.max(0, scroll ?? 0);
   if (col < next) next = col;
@@ -213,10 +238,67 @@ const paintColumns = (parts, widths, fgRgb, bgRgb, color, tones) => {
   return text;
 };
 
+const paintPathText = (text, fg, bg, color, bold, spans) => {
+  if (!spans.length) return paint(text, fg, bg, color, bold);
+  let out = '';
+  let at = 0;
+  for (const span of spans) {
+    if (span.start > at) {
+      out += paint(text.slice(at, span.start), fg, bg, color, bold);
+    }
+    const on = span.on === true;
+    const markFg = on ? THEME.searchOnFg : THEME.searchFg;
+    const markBg = on ? THEME.searchOnBg : THEME.searchBg;
+    const slice = text.slice(span.start, span.end);
+    out += paint(slice, markFg, markBg, color, true);
+    at = span.end;
+  }
+  if (at < text.length) out += paint(text.slice(at), fg, bg, color, bold);
+  return out;
+};
+
+const scrollThumb = (count, inner, start) => {
+  if (count <= inner || inner < 1) return null;
+  let size = Math.max(1, Math.round((inner * inner) / count));
+  if (inner > 1) size = Math.min(size, inner - 1);
+  const travel = inner - size;
+  const maxStart = count - inner;
+  const at = maxStart <= 0 ? 0 : Math.round((start * travel) / maxStart);
+  return { size, travel, maxStart, at };
+};
+
+const scrollMark = (index, count, inner, start) => {
+  const thumb = scrollThumb(count, inner, start);
+  if (!thumb) return '';
+  const end = thumb.at + thumb.size;
+  if (index >= thumb.at && index < end) return 'thumb';
+  return 'track';
+};
+
+const scrollAtThumb = (top, thumb) => {
+  if (!thumb || thumb.travel <= 0) return 0;
+  const at = clamp(top, 0, thumb.travel);
+  return Math.round((at * thumb.maxStart) / thumb.travel);
+};
+
+const placeHits = (hits, origin, width, side) => {
+  const placed = [];
+  for (const hit of hits) {
+    const x0 = (hit.x0 ?? 0) + origin;
+    const x1 = (hit.x1 ?? width) + origin;
+    placed.push({ ...hit, x0, x1, side });
+  }
+  return placed;
+};
+
 module.exports = {
+  scrollThumb,
+  scrollMark,
+  scrollAtThumb,
+  placeHits,
   GUTTER_W,
-  FILE_MARK,
   MARK_W,
+  LIST_PAD,
   fill,
   markPrefix,
   isListPane,
@@ -227,8 +309,11 @@ module.exports = {
   paintSplitRule,
   paintBodyFill,
   paneResult,
+  lazyRows,
+  bodyRow,
   editSpan,
   listLine,
+  listWindowStart,
   paintListWindow,
   paintCursorList,
   sliceVisible,
@@ -237,4 +322,5 @@ module.exports = {
   padColumns,
   joinColumns,
   paintColumns,
+  paintPathText,
 };

package/lib/render/render.js

@@ -1,16 +1,11 @@
 'use strict';
 
-const chrome = require('./chrome.js');
-const notes = require('./notes.js');
-const diff = require('./diff.js');
-const present = require('./present.js');
-const frame = require('./frame.js');
-
-const { formatBusyStatus, headerText, layoutButtons } = chrome;
-const { todoBodyWidth, noteInnerWidth } = notes;
-const { paintDiffLine, codeInnerWidth } = diff;
-const { presentCursor, presentRows } = present;
-const { renderFrame } = frame;
+const { formatBusyStatus } = require('./status.js');
+const { headerText } = require('./header.js');
+const { layoutButtons } = require('./footer.js');
+const { todoBodyWidth, noteInnerWidth } = require('./notes.js');
+const { paintDiffLine, codeInnerWidth, activeDigits } = require('./diff.js');
+const { renderFrame, presentCursor, presentRows } = require('./frame.js');
 
 module.exports = {
   formatBusyStatus,
@@ -20,6 +15,7 @@ module.exports = {
   noteInnerWidth,
   paintDiffLine,
   codeInnerWidth,
+  activeDigits,
   renderFrame,
   presentCursor,
   presentRows,

package/lib/render/repos.js

@@ -1,15 +1,14 @@
 'use strict';
 
-const ansi = require('../ansi.js');
-const { THEME } = ansi;
-const primitives = require('./primitives.js');
-const { paintBodyFill, paneResult } = primitives;
+const { THEME } = require('../term/ansi.js');
+const { paintBodyFill, paneResult } = require('./primitives.js');
 const tiles = require('./tiles.js');
+const { RUN_ICON } = tiles;
 const { seg, spinner, equalGrid, pageWindow, placeEqualTiles } = tiles;
 const { paintTile, composeBands, tileHits, pageFill } = tiles;
-const { segmentsWidth, clipSegments } = tiles;
-const table = require('./dash-table.js');
-const { size, isHot } = table;
+const { segmentsWidth, clipSegments, blinkTone } = tiles;
+const { size } = require('../common/format.js');
+const { isHot } = require('./table.js');
 
 const REPO_MIN_H = 6;
 const MARGIN_MIN_H = 12;
@@ -19,29 +18,19 @@ const DIM_BACKS = {
   tile: THEME.dashDimTileBg,
   row: THEME.dashDimRowBg,
 };
-const RUN_ICON = {
-  passed: ['✔', 'add'],
-  failed: ['✖', 'error'],
-  aborted: ['⊘', 'muted'],
-};
-
 const extName = (key) => {
   const text = `${key ?? ''}`;
   if (!text || text === '(none)') return 'none';
   return text.startsWith('.') ? text.slice(1) : text;
 };
 
-const blinkTone = (frame) => (Math.abs(frame) % 2 ? 'hot' : 'warn');
-
 const spin = (frame) => seg(spinner(frame), 'warn', true);
 
-const rowPending = (row) =>
-  !row.filesReady ||
-  !row.commitsReady ||
-  !row.diffReady ||
-  !row.tasksReady ||
-  !row.runsReady ||
-  !row.npmReady;
+const rowPending = (row) => {
+  if (!row.filesReady || !row.commitsReady) return true;
+  if (!row.diffReady || !row.tasksReady) return true;
+  return !row.runsReady || !row.npmReady;
+};
 
 const fitAside = (left, right, width) => {
   const rightW = segmentsWidth(right);
@@ -214,13 +203,12 @@ const paintBodyRepos = (view, width, color, bodyH, headerLines) => {
   const page = pageWindow(model.tiles.length, model.cursor, grid.cap);
   const shown = model.tiles.slice(page.start, page.end);
   const bands = placeEqualTiles(shown, grid);
-  model.cols = grid.cols;
   const painted = paintRepos(model, bands, color);
   const rows = composeBands(bands, painted, width, height, color);
   const pad = new Array(margin).fill(pageFill(width, color));
   const body = [...pad, ...rows, ...pad];
   const fileHits = tileHits(bands, headerLines + margin);
-  return paneResult({ body, fileHits });
+  return { ...paneResult({ body, fileHits }), gridCols: grid.cols };
 };
 
-module.exports = { REPO_MIN_H, extName, paintBodyRepos };
+module.exports = { paintBodyRepos };

package/lib/render/status.js

@@ -0,0 +1,370 @@
+'use strict';
+
+const ansi = require('../term/ansi.js');
+const actions = require('../input/actions.js');
+const files = require('../common/files.js');
+const primitives = require('./primitives.js');
+const { fill, branchLabel } = primitives;
+const { npmStatus } = require('./dashboard/blocks.js');
+const { menuBoxWidth, dropBox, menuFaces } = require('./menu.js');
+const field = require('./field.js');
+const { paintPlanFace, paintImportStatus, paintFindStatus } = field;
+const { fileTotals } = files;
+const { CONFIRM, confirmPrefix, promptFromChoices } = actions;
+const { THEME, paint, visibleWidth } = ansi;
+const { truncateVisible } = ansi;
+const { paintMarkedWord, QUIT_MARK } = require('./footer.js');
+
+const WAVE = '·•●•·';
+
+const BUSY_BAR = Array.from(WAVE, (_, frame) => {
+  const start = (WAVE.length - frame) % WAVE.length;
+  return WAVE.slice(start) + WAVE.slice(0, start);
+});
+
+const {
+  busy: BUSY_PROGRESS,
+  info: INFO_STATUS,
+  infoPrefix: INFO_PREFIX,
+} = require('./status.json');
+
+const formatBusyStatus = (status, frame = 0) => {
+  const kind = `${status ?? ''}`;
+  if (!BUSY_PROGRESS.includes(kind)) return kind;
+  const i = Math.abs(frame) % BUSY_BAR.length;
+  return `${kind}  ${BUSY_BAR[i]}`;
+};
+
+const STATUS_MARK = /(\+[0-9]+(?:\/[0-9]+)?|-[0-9]+(?:\/[0-9]+)?)/g;
+
+const OLD_LOGS = /old logs \S+/;
+
+const isInfoStatus = (status) => {
+  const busy = BUSY_PROGRESS.includes(status);
+  const known = INFO_STATUS.includes(status);
+  const prefixed = INFO_PREFIX.some((prefix) => status.startsWith(prefix));
+  return busy || known || prefixed;
+};
+
+const joinStatus = (parts) => parts.filter(Boolean).join('  ');
+
+const countsKind = (sourceKind, revShort) => {
+  const remote = sourceKind === 'pr' || sourceKind === 'mr';
+  if (remote || sourceKind === 'issue') return sourceKind;
+  return revShort ? 'commit' : 'worktree';
+};
+
+const isWorktree = (view) =>
+  countsKind(view.sourceKind, view.revShort) === 'worktree';
+
+const notesLine = (counts) => {
+  const done = counts.tasksDone ?? 0;
+  const total = counts.tasks ?? 0;
+  return `tasks ${done}/${total}`;
+};
+
+const PLAN_LEAD = 'Plan file: ';
+
+const closedPlan = (view) => `${view.planName ?? ''}`;
+
+const planLabel = (view) => {
+  const closed = closedPlan(view);
+  if (!closed) return '';
+  const query = view.planOpen ? `${view.planQuery ?? ''}` : '';
+  if (!query) return closed;
+  const room = Math.max(visibleWidth(closed), visibleWidth(query));
+  const shown = truncateVisible(query, room);
+  const pad = Math.max(0, room - visibleWidth(shown));
+  return `${shown}${' '.repeat(pad)}`;
+};
+
+const reposLead = (view) => {
+  const tiles = view.repos && view.repos.tiles ? view.repos.tiles : [];
+  const count = tiles.length;
+  if (!count) return 'repos';
+  const at = (view.repos.cursor ?? 0) + 1;
+  return `${at}/${count}`;
+};
+
+const agentsLead = (view) => {
+  if (view.agentView) return view.agentStatus || 'log';
+  const list = view.agents ?? [];
+  const found = list.filter((row) => row.bin).length;
+  return `${found}/${list.length}`;
+};
+
+const statusLead = (view) => {
+  if (view.pane === 'repos') return reposLead(view);
+  if (view.pane === 'agents') return agentsLead(view);
+  const counts = view.counts ?? {};
+  const kind = countsKind(view.sourceKind, view.revShort);
+  if (kind === 'worktree') return branchLabel(view.branch);
+  if (kind === 'commit') {
+    return `commit ${view.revShort}  ${counts.commit ?? 0}`;
+  }
+  const label = view.sourceLabel || kind;
+  return `${kind} ${label}  ${counts.pr ?? 0}`;
+};
+
+const STATUS_QUIET = ['npm', 'packages', 'branches', 'agents'];
+
+const planStatus = (view) => {
+  const combo = planLabel(view);
+  if (!combo) return '';
+  return `${PLAN_LEAD}${combo}`;
+};
+
+const statusLeft = (view) => {
+  if (view.pane === 'repos') return ` ${statusLead(view)}`;
+  if (view.pane === 'tasks') {
+    const lead = joinStatus([statusLead(view), planStatus(view)]);
+    return ` ${lead}`;
+  }
+  const quiet = STATUS_QUIET.includes(view.pane);
+  const notes = quiet ? '' : notesLine(view.counts ?? {});
+  return ` ${joinStatus([statusLead(view), notes])}`;
+};
+
+const planAt = (view, text) => {
+  const combo = planLabel(view);
+  if (!combo) return -1;
+  const lead = statusLead(view);
+  const head = lead ? ` ${lead}  ${PLAN_LEAD}` : ` ${PLAN_LEAD}`;
+  const line = `${text ?? ''}`;
+  if (!line.startsWith(head)) return -1;
+  const rest = line.slice(head.length);
+  if (rest.startsWith(combo) || combo.startsWith(rest)) return head.length;
+  return -1;
+};
+
+const planFace = (view, text) => {
+  const at = planAt(view, text);
+  if (at < 0) return null;
+  const combo = planLabel(view);
+  const rest = text.slice(at);
+  const face = rest.startsWith(combo) ? combo : rest;
+  return { at, face, x: visibleWidth(text.slice(0, at)) };
+};
+
+const statusDelta = (total) => {
+  const stagedAdd = total.stagedAdded ?? 0;
+  const unstagedAdd = total.unstagedAdded ?? 0;
+  const stagedDel = total.stagedRemoved ?? 0;
+  const unstagedDel = total.unstagedRemoved ?? 0;
+  const hasDelta =
+    stagedAdd || unstagedAdd || stagedDel || unstagedDel || total.added;
+  if (!hasDelta && !total.removed) return '';
+  const plus = `+${stagedAdd}/${stagedAdd + unstagedAdd}`;
+  const minus = `-${stagedDel}/${stagedDel + unstagedDel}`;
+  return `${plus}  ${minus}`;
+};
+
+const DIFF_QUIET = ['npm', 'packages', 'tasks', 'branches', 'agents'];
+
+const statusStats = (view) => {
+  if (view.pane === 'tasks') return notesLine(view.counts ?? {});
+  const counts = view.counts ?? {};
+  const staged = counts.staged ?? 0;
+  const total = fileTotals(view.files ?? []);
+  const { remaining, staged: listed, added, removed } = total;
+  const hasGit = remaining || listed || added || removed;
+  const unstaged = counts.unstaged ?? 0;
+  const n = hasGit ? listed : staged;
+  const m = hasGit ? remaining : staged + unstaged;
+  const delta = DIFF_QUIET.includes(view.pane) ? '' : statusDelta(total);
+  const ratio = STATUS_QUIET.includes(view.pane) ? '' : `${n}/${m}`;
+  const packages = view.pane === 'packages' ? npmStatus(view.packages) : '';
+  return joinStatus([view.npmLogs, delta, ratio, packages]);
+};
+
+const statusLayout = (view, status, width) => {
+  const msg = formatBusyStatus(status, view.progressFrame ?? 0);
+  const isError = msg && !isInfoStatus(status);
+  const msgFg = isError ? THEME.errorFg : THEME.chromeFg;
+  const stats = statusStats(view);
+  const right = stats ? `${stats} ` : '';
+  const rightW = visibleWidth(right);
+  const msgW = visibleWidth(msg);
+  const side = msg ? 1 : 0;
+  const room = Math.max(0, width - rightW - msgW - side * 2);
+  const clipped = truncateVisible(statusLeft(view), room);
+  const leftW = visibleWidth(clipped);
+  const extra = Math.max(0, width - leftW - rightW - msgW);
+  const padLeft = msg ? Math.floor(extra / 2) : extra;
+  const padRight = msg ? extra - padLeft : 0;
+  return { clipped, msg, msgFg, right, padLeft, padRight };
+};
+
+const choiceHits = (choices, prefix, y) => {
+  let x = visibleWidth(prefix);
+  return choices.map((choice) => {
+    const w = visibleWidth(`${choice.lead}${choice.label}`);
+    const hit = { id: choice.letter, y, x0: x, x1: x + w };
+    x += w;
+    return hit;
+  });
+};
+
+const paintChoicePrompt = (choices, width, color, prefix) => {
+  const bgRgb = THEME.chromeBg;
+  const body = `${prefix}${promptFromChoices(choices)}`;
+  const pad = Math.max(0, width - visibleWidth(body));
+  if (!color) return body + ' '.repeat(pad);
+  let out = paint(prefix, THEME.mutedFg, bgRgb, color);
+  for (const choice of choices) {
+    const label = `${choice.lead}${choice.label}`;
+    out += paintMarkedWord(label, choice.letter, color, QUIT_MARK);
+  }
+  return out + fill(pad, THEME.mutedFg, bgRgb, color);
+};
+
+const paintStatusLeft = (text, color) => {
+  if (!color) return text;
+  const bgRgb = THEME.chromeBg;
+  const found = text.match(OLD_LOGS);
+  if (found) {
+    const token = found[0];
+    const before = text.slice(0, found.index);
+    const after = text.slice(found.index + token.length);
+    return (
+      paintStatusLeft(before, color) +
+      paint(token, THEME.shaFg, bgRgb, color) +
+      paintStatusLeft(after, color)
+    );
+  }
+  let out = '';
+  let last = 0;
+  for (const match of text.matchAll(STATUS_MARK)) {
+    const token = match[0];
+    const tokenFg = token.startsWith('+') ? THEME.addLineFg : THEME.delLineFg;
+    out += paint(text.slice(last, match.index), THEME.mutedFg, bgRgb, color);
+    out += paint(token, tokenFg, bgRgb, color);
+    last = match.index + token.length;
+  }
+  return out + paint(text.slice(last), THEME.mutedFg, bgRgb, color);
+};
+
+const paintBranchHead = (text, branch, color) => {
+  const name = branchLabel(branch);
+  if (!name || !text.startsWith(' ')) return null;
+  const shown = text.startsWith(` ${name}`) ? name : text.slice(1);
+  if (!shown || !name.startsWith(shown)) return null;
+  const rest = text.slice(1 + shown.length);
+  const bgRgb = THEME.chromeBg;
+  return (
+    paint(' ', THEME.mutedFg, bgRgb, color) +
+    paint(shown, THEME.buttonHotFg, bgRgb, color, true) +
+    paintStatusLeft(rest, color)
+  );
+};
+
+const paintTasksLeft = (view, text, color) => {
+  const place = planFace(view, text);
+  if (!place) {
+    const head = paintBranchHead(text, view.branch, color);
+    return head ?? paintStatusLeft(text, color);
+  }
+  const before = text.slice(0, place.at);
+  const after = text.slice(place.at + place.face.length);
+  const searching = Boolean(view.planOpen && view.planQuery);
+  const comboFg = searching ? THEME.searchFg : THEME.shaFg;
+  const comboBg = searching ? THEME.searchBg : THEME.chromeBg;
+  const branch = paintBranchHead(before, view.branch, color);
+  const head = branch ?? paintStatusLeft(before, color);
+  const face = paintPlanFace(view, place.face, comboFg, comboBg, color);
+  return head + face + paintStatusLeft(after, color);
+};
+
+const statusHead = (view, clipped, color) => {
+  if (view.pane === 'tasks') return paintTasksLeft(view, clipped, color);
+  if (isWorktree(view)) return paintBranchHead(clipped, view.branch, color);
+  return null;
+};
+
+const paintStatusLine = (view, status, width, color) => {
+  if (view.import) return paintImportStatus(view, width, color);
+  if (view.find) return paintFindStatus(view, width, color);
+  const confirm = CONFIRM[view.mode];
+  if (confirm) {
+    const prefix = confirmPrefix(confirm, view);
+    return paintChoicePrompt(confirm.choices, width, color, prefix);
+  }
+  const layout = statusLayout(view, status, width);
+  const leftGap = ' '.repeat(layout.padLeft);
+  const rightGap = ' '.repeat(layout.padRight);
+  if (!color) {
+    return layout.clipped + leftGap + layout.msg + rightGap + layout.right;
+  }
+  const bgRgb = THEME.chromeBg;
+  const head = statusHead(view, layout.clipped, color);
+  const left = head ?? paintStatusLeft(layout.clipped, color);
+  return (
+    left +
+    paint(leftGap, THEME.mutedFg, bgRgb, color) +
+    paint(layout.msg, layout.msgFg, bgRgb, color) +
+    paint(rightGap, THEME.mutedFg, bgRgb, color) +
+    paintStatusLeft(layout.right, color)
+  );
+};
+
+const statusChoiceHits = (view, y) => {
+  const spec = CONFIRM[view.mode];
+  if (!spec) return [];
+  return choiceHits(spec.choices, confirmPrefix(spec, view), y);
+};
+
+const statusPlanHit = (view, width, y) => {
+  if (view.pane !== 'tasks' || view.find || view.import) return null;
+  if (CONFIRM[view.mode]) return null;
+  const layout = statusLayout(view, view.status ?? '', width);
+  const place = planFace(view, layout.clipped);
+  if (!place) return null;
+  const x0 = place.x;
+  return { id: 'plan', y, x0, x1: x0 + visibleWidth(place.face) };
+};
+
+const planMenu = (view, width, color, statusY) => {
+  if (view.pane !== 'tasks' || !view.planOpen || statusY < 3) return null;
+  const names = view.planNames ?? [];
+  const layout = statusLayout(view, view.status ?? '', width);
+  const place = planFace(view, layout.clipped);
+  if (!place) return null;
+  const x = Math.max(0, place.x - 1);
+  const room = Math.max(1, statusY - 2);
+  const box = dropBox(names, view.planCursor, view.planScroll, room);
+  const boxW = menuBoxWidth(names, visibleWidth(place.face), width - x);
+  const faces = menuFaces(names, box, boxW, color);
+  const lines = [];
+  const hits = [];
+  for (let i = 0; i < faces.length; i++) {
+    const y = statusY - box.inner + i;
+    lines.push({ y, text: faces[i].face });
+    if (names[faces[i].index] === undefined) continue;
+    const id = 'plan-item';
+    const x0 = x;
+    const x1 = x + boxW;
+    const cursor = faces[i].index;
+    const hit = { id, y, x0, x1, cursor };
+    hits.push(hit);
+  }
+  return { x, lines, hits, scroll: box.start };
+};
+
+const statusBranchHit = (view, width, y) => {
+  if (view.find || view.import || CONFIRM[view.mode]) return null;
+  const name = branchLabel(view.branch);
+  if (!name || !isWorktree(view)) return null;
+  const layout = statusLayout(view, view.status ?? '', width);
+  const at = layout.clipped.indexOf(name);
+  if (at < 0) return null;
+  return { id: 'branch', y, x0: at, x1: at + visibleWidth(name) };
+};
+
+module.exports = {
+  formatBusyStatus,
+  paintStatusLine,
+  statusChoiceHits,
+  statusBranchHit,
+  statusPlanHit,
+  planMenu,
+};