reslop 0.2.6 → 0.3.0

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

package/lib/render/status.json

@@ -0,0 +1,85 @@
+{
+  "busy": [
+    "pulling",
+    "pushing",
+    "loading",
+    "importing",
+    "checking npm",
+    "updating reslop",
+    "npm i",
+    "npm uninstall",
+    "npm audit fix",
+    "running",
+    "checking out",
+    "creating branch",
+    "rebasing",
+    "dropping",
+    "committing",
+    "updating",
+    "rewording",
+    "force pushing"
+  ],
+  "info": [
+    "copied",
+    "staged",
+    "unstaged",
+    "not staged",
+    "dropped",
+    "already staged",
+    "read only",
+    "transitive",
+    "nothing to review",
+    "nothing to commit",
+    "not installed",
+    "no plan",
+    "returned",
+    "stopped",
+    "started",
+    "unified",
+    "mixed",
+    "side-by-side",
+    "line numbers",
+    "no line numbers",
+    "dark",
+    "light",
+    "saved",
+    "reloaded",
+    "not a diff block",
+    "file scope",
+    "diff mode",
+    "committed",
+    "amended",
+    "reworded",
+    "fixup",
+    "updated",
+    "imported",
+    "pulled",
+    "pushed",
+    "force pushed",
+    "checked out",
+    "created",
+    "empty branch name",
+    "empty commit message",
+    "terminated",
+    "verbose",
+    "filtered",
+    "fast on",
+    "fast off",
+    "logged in",
+    "logging in",
+    "ignored",
+    "already ignored",
+    "brief",
+    "full"
+  ],
+  "infoPrefix": [
+    "checked out ",
+    "created ",
+    "rebased onto ",
+    "dropped ",
+    "exit ",
+    "model ",
+    "updated ",
+    "installed "
+  ]
+}

package/lib/render/{dash-table.js → table.js}

@@ -1,45 +1,12 @@
 'use strict';
 
-const metautil = require('metautil');
-const { bytesToSize } = metautil;
-const files = require('../files.js');
-const { relativeAge } = files;
-const ansi = require('../ansi.js');
-const { visibleWidth, graphemes, graphemeWidth } = ansi;
+const { num } = require('../common/format.js');
+const { visibleWidth, graphemes, graphemeWidth } = require('../term/ansi.js');
 const tiles = require('./tiles.js');
 const { seg, segmentsWidth, clipSegments, titleSegments } = tiles;
-const tree = require('../dashboard/tree.js');
-const { HEAT_MS } = tree;
+const { HEAT_MS } = require('../dashboard/tree.js');
 
 const MIN_FLEX = 6;
-const SECONDS_AGO = /^\d+s ago$/;
-
-const trimmed = (value) =>
-  value >= 10 ? `${Math.round(value)}` : `${Math.round(value * 10) / 10}`;
-
-const num = (value) => {
-  const n = Math.max(0, Math.round(value));
-  if (n >= 1e6) return `${trimmed(n / 1e6)}m`;
-  if (n >= 1e4) return `${trimmed(n / 1e3)}k`;
-  return `${n}`;
-};
-
-const size = (bytes) => bytesToSize(bytes > 0 ? bytes : 0);
-
-const ago = (at, now) => {
-  if (!at) return '';
-  const text = relativeAge(at, now);
-  return SECONDS_AGO.test(text) ? '<1m ago' : text;
-};
-
-const duration = (ms) => {
-  const value = Math.max(0, ms);
-  if (value < 1000) return `${Math.round(value)}ms`;
-  if (value < 60000) return `${(value / 1000).toFixed(1)}s`;
-  const minutes = Math.floor(value / 60000);
-  const seconds = Math.floor((value % 60000) / 1000);
-  return `${minutes}m${`${seconds}`.padStart(2, '0')}s`;
-};
 
 const isHot = (at, now) => at > 0 && now - at < HEAT_MS;
 
@@ -49,7 +16,15 @@ const delta = (value, now, at) => {
   return seg(`▼${num(-value)}`, 'del', true);
 };
 
-const waiting = (text) => ({ badge: [], lines: [[seg(text, 'muted')]] });
+const notice = (text, titleLine) => {
+  const rows = Array.isArray(text) ? text : [text];
+  const lines = rows.map((row) => [seg(row, 'muted')]);
+  const block = { badge: [], center: true, lines };
+  if (titleLine) block.titleLine = titleLine;
+  return block;
+};
+
+const waiting = (text) => notice(text);
 
 const cell = (text, tone = 'text', align = 'l', bold = false) => ({
   segs: [seg(text, tone, bold)],
@@ -67,13 +42,18 @@ const flexCell = (text, tone = 'muted') => ({
 
 const blankCell = { segs: [], align: 'l', flex: false };
 
+const measuredWidth = (item) => {
+  if (typeof item.measure === 'number') return item.measure;
+  return segmentsWidth(item.segs);
+};
+
 const columnWidths = (rows, count) => {
   const widths = new Array(count).fill(0);
   for (const row of rows) {
     for (let c = 0; c < count; c++) {
       const item = row[c];
       if (!item || (item.flex && !item.keep)) continue;
-      widths[c] = Math.max(widths[c], segmentsWidth(item.segs));
+      widths[c] = Math.max(widths[c], measuredWidth(item));
     }
   }
   return widths;
@@ -241,23 +221,6 @@ const titleAside = (tile, aside, width, badge = []) => {
   return [...left, seg(' '.repeat(Math.max(1, gap))), ...aside];
 };
 
-const stat = (label, value, tone = 'text', bold = false) => ({
-  label,
-  value: typeof value === 'string' ? [seg(value, tone, bold)] : value,
-});
-
-const pairRows = (items, perRow = 2) => {
-  const rows = [];
-  for (let i = 0; i < items.length; i += perRow) {
-    const row = [];
-    for (const item of items.slice(i, i + perRow)) {
-      row.push(cell(item.label, 'muted'), cellSegs(item.value));
-    }
-    rows.push(row);
-  }
-  return rows;
-};
-
 const pickGroups = (folders, exts, rows) => {
   const count = Math.max(0, rows);
   const dirs = folders.slice(0, count);
@@ -270,19 +233,14 @@ const labelOf = (key, isDir) => {
 };
 
 module.exports = {
-  num,
-  size,
-  ago,
-  duration,
   isHot,
   delta,
+  notice,
   waiting,
   cell,
   cellSegs,
   flexCell,
   tableLines,
-  stat,
-  pairRows,
   pickGroups,
   labelOf,
   titleAside,