reslop 0.2.6 → 0.3.0

package/lib/render/footer.js

@@ -0,0 +1,383 @@
+'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, isTaskView } = primitives;
+const { isTasksEntry } = files;
+const { ACTION_IDS, actionLetter } = actions;
+const { DASH_IDS, buttonWord } = actions;
+const { FILES_GIT_DISABLED } = actions;
+const { diffGitDisabled, branchGitDisabled, commitGitDisabled } = actions;
+const { entryHasDiff, lineHasDiff, withoutMoves } = actions;
+const { THEME, paint, visibleWidth } = ansi;
+const { selectedFile, selectedBranch, selectedCommit } = require('./header.js');
+
+const BUTTON_LEAD = ' ';
+
+const BUTTON_GAP = '  ';
+
+const HINT_ONLY = ['taskNudge'];
+
+const BUTTON_EDGE = 1;
+
+const BACK_ARROW = '🢐';
+
+const BACK_KEY = 'esc';
+
+const BUTTON_MARK = {
+  bgRgb: THEME.buttonBg,
+  fgRgb: THEME.buttonFg,
+  hotFg: THEME.buttonHotFg,
+  missFg: THEME.buttonHotFg,
+  missBold: true,
+};
+
+const QUIT_MARK = {
+  bgRgb: THEME.chromeBg,
+  fgRgb: THEME.mutedFg,
+  hotFg: THEME.warnFg,
+  missFg: THEME.mutedFg,
+  missBold: false,
+};
+
+const SAVE_HINT = 'Press **Ctrl-S** or **Enter** at EOF to save';
+
+const HINT_HOT_FG = 0xff;
+
+const buttonGap = (index) => (index ? BUTTON_GAP : BUTTON_LEAD);
+
+const hintBody = (mark) => `${mark}${BACK_KEY}`;
+
+const buttonLabel = (id, short) => (short ? actionLetter(id) : buttonWord(id));
+
+const paintBackHint = (color, mark) => {
+  const bgRgb = THEME.buttonBg;
+  const rest = hintBody(mark).slice(mark.length);
+  const arrow = paint(mark, THEME.buttonHotFg, bgRgb, color, true);
+  return arrow + paint(rest, THEME.buttonFg, bgRgb, color);
+};
+
+const paintMarkedWord = (label, letter, color, mark) => {
+  const at = label.indexOf(letter);
+  if (at < 0) {
+    return paint(label, mark.missFg, mark.bgRgb, color, mark.missBold);
+  }
+  const before = label.slice(0, at);
+  const hot = label.slice(at, at + letter.length);
+  const after = label.slice(at + letter.length);
+  let out = paint(before, mark.fgRgb, mark.bgRgb, color);
+  out += paint(hot, mark.hotFg, mark.bgRgb, color, true);
+  return out + paint(after, mark.fgRgb, mark.bgRgb, color);
+};
+
+const footerIds = (hidden, extra, backId, globals, tail, after) => {
+  const ids = backId ? [backId] : [];
+  const push = (id) => {
+    if (!ids.includes(id)) ids.push(id);
+  };
+  for (const add of extra) push(add);
+  for (const id of globals) push(id);
+  if (tail) {
+    for (const id of ACTION_IDS) {
+      if (id === 'quit' || hidden.includes(id) || ids.includes(id)) continue;
+      ids.push(id);
+    }
+  }
+  for (const id of after) push(id);
+  return ids;
+};
+
+const buttonPiece = (id, index, short, backId, mark) => {
+  const back = id === backId;
+  const letter = back ? BACK_KEY : actionLetter(id);
+  const label = back ? hintBody(mark) : buttonLabel(id, short);
+  const gap = buttonGap(index);
+  return {
+    id,
+    piece: `${gap}${label}`,
+    gap,
+    letter,
+    label,
+    back,
+    mark: back ? mark : '',
+  };
+};
+
+const packGroup = (ids, short, start, backId, mark) => {
+  const parts = [];
+  for (let i = 0; i < ids.length; i++) {
+    parts.push(buttonPiece(ids[i], start + i, short, backId, mark));
+  }
+  return parts;
+};
+
+const groupWidth = (parts) => {
+  let width = 0;
+  for (const part of parts) width += visibleWidth(part.piece);
+  return width;
+};
+
+const placeGroup = (parts, hits, disabled, x) => {
+  const placed = [];
+  let cursor = x;
+  for (const part of parts) {
+    const w = visibleWidth(part.piece);
+    const off = disabled.includes(part.id);
+    const hint = HINT_ONLY.includes(part.id);
+    if (!off && !hint) hits.push({ id: part.id, x0: cursor, x1: cursor + w });
+    placed.push({ ...part, disabled: off });
+    cursor += w;
+  }
+  return { placed, cursor };
+};
+
+const splitFooter = (ids, options, limit) => {
+  const { disabled = [], backId = '', mark = BACK_ARROW } = options;
+  const { globals = [], after = [] } = options;
+  const rightIds = [];
+  for (const id of [...globals, ...after]) {
+    if (ids.includes(id) && !rightIds.includes(id)) rightIds.push(id);
+  }
+  const leftIds = ids.filter((id) => !rightIds.includes(id));
+  const pack = (leftShort, rightShort) => {
+    const left = packGroup(leftIds, leftShort, 0, backId, mark);
+    const start = left.length ? 1 : 0;
+    const right = packGroup(rightIds, rightShort, start, backId, mark);
+    return { left, right };
+  };
+  const wide = (packed) =>
+    groupWidth(packed.left) + groupWidth(packed.right) > limit;
+  let packed = pack(false, false);
+  if (wide(packed)) packed = pack(false, true);
+  if (wide(packed)) packed = pack(true, true);
+  const left = packed.left.slice();
+  const right = packed.right.slice();
+  while (groupWidth(left) + groupWidth(right) > limit && left.length) {
+    left.pop();
+  }
+  while (groupWidth(left) + groupWidth(right) > limit && right.length) {
+    right.pop();
+  }
+  const hits = [];
+  const leftPlace = placeGroup(left, hits, disabled, 0);
+  const parts = leftPlace.placed;
+  let x = leftPlace.cursor;
+  const gap = Math.max(0, limit - x - groupWidth(right));
+  if (gap && right.length) {
+    parts.push({ spacer: true, piece: ' '.repeat(gap) });
+    x += gap;
+  }
+  const rightPlace = placeGroup(right, hits, disabled, x);
+  parts.push(...rightPlace.placed);
+  return { hits, parts };
+};
+
+const layoutButtons = (width, options = {}) => {
+  const { compact = false, hidden = [], extra = [], disabled = [] } = options;
+  const { backId = '', mark = BACK_ARROW, globals = [] } = options;
+  const { tail = true, after = [] } = options;
+  const ids = footerIds(hidden, extra, backId, globals, tail, after);
+  const limit = Math.max(0, width - BUTTON_EDGE);
+  if (globals.length) return splitFooter(ids, options, limit);
+  const build = (short) => {
+    const hits = [];
+    const parts = [];
+    let x = 0;
+    for (const id of ids) {
+      const part = buttonPiece(id, parts.length, short, backId, mark);
+      const w = visibleWidth(part.piece);
+      if (x + w > limit && parts.length) break;
+      const off = disabled.includes(id);
+      const hint = HINT_ONLY.includes(id);
+      if (!off && !hint) hits.push({ id, x0: x, x1: x + w });
+      parts.push({ ...part, disabled: off });
+      x += w;
+    }
+    return { hits, parts };
+  };
+  if (compact) return build(true);
+  const words = build(false);
+  if (words.parts.length === ids.length) return words;
+  return build(true);
+};
+
+const paintButtons = (layout, width, color) => {
+  const fgRgb = THEME.buttonFg;
+  const bgRgb = THEME.buttonBg;
+  let out = '';
+  let used = 0;
+  for (let i = 0; i < layout.parts.length; i++) {
+    const part = layout.parts[i];
+    if (part.spacer) {
+      out += paint(part.piece, fgRgb, bgRgb, color);
+      used += visibleWidth(part.piece);
+      continue;
+    }
+    const gap = part.gap ?? buttonGap(i);
+    out += paint(gap, fgRgb, bgRgb, color);
+    if (part.back) out += paintBackHint(color, part.mark);
+    else if (part.disabled) out += paint(part.label, fgRgb, bgRgb, color);
+    else out += paintMarkedWord(part.label, part.letter, color, BUTTON_MARK);
+    used += visibleWidth(part.piece);
+  }
+  return out + fill(width - used, fgRgb, bgRgb, color);
+};
+
+const commitSaveHint = (view) => {
+  const composing = view.mode === 'compose';
+  const full = view.commitView === 'full';
+  const commit = view.compose?.kind === 'commit';
+  return composing && full && commit;
+};
+
+const paintSaveHintBar = (width, color) => {
+  const bgRgb = THEME.buttonBg;
+  const plain = `${BUTTON_LEAD}${SAVE_HINT.replaceAll('**', '')}`;
+  const pad = Math.max(0, width - visibleWidth(plain));
+  if (!color) return plain + ' '.repeat(pad);
+  let out = paint(BUTTON_LEAD, THEME.buttonFg, bgRgb, color);
+  const bits = SAVE_HINT.split('**');
+  for (let i = 0; i < bits.length; i++) {
+    const hot = i % 2 === 1;
+    const tone = hot ? HINT_HOT_FG : THEME.buttonFg;
+    out += paint(bits[i], tone, bgRgb, color, hot);
+  }
+  return out + fill(pad, THEME.buttonFg, bgRgb, color);
+};
+
+const paintFooter = (view, layout, width, color) => {
+  if (commitSaveHint(view)) return paintSaveHintBar(width, color);
+  return paintButtons(layout, width, color);
+};
+
+const footerHits = (view, layout) => (commitSaveHint(view) ? [] : layout.hits);
+
+const filesDim = (view) => {
+  const entry = selectedFile(view);
+  if (isTasksEntry(entry)) return FILES_GIT_DISABLED;
+  return withoutMoves([], entryHasDiff(entry));
+};
+
+const unitDim = (view) => {
+  const off = [...diffGitDisabled(view.item)];
+  const lines = view.unitLines;
+  if (!lines || !lines.length) return off;
+  const line = lines[view.unitLine ?? 0];
+  return withoutMoves(off, lineHasDiff(line));
+};
+
+const commitsDim = (view) => {
+  const canCommit = (view.counts?.staged ?? 0) > 0;
+  const unstagedCurrent = !view.rev && !view.revShort;
+  const target = { ...selectedCommit(view), canCommit, unstagedCurrent };
+  return commitGitDisabled(target);
+};
+
+const PACKAGE_ROW_ACTIONS = ['packageDrop', 'packageWanted', 'packageLatest'];
+
+const packagesDim = (view) => {
+  const listed = view.packages && view.packages.modules;
+  const rows = listed && listed.packages ? listed.packages : [];
+  const cursor = view.packagesCursor ?? 0;
+  const onRow = rows.length > 0 && cursor < rows.length;
+  if (!onRow) return PACKAGE_ROW_ACTIONS;
+  const row = rows[cursor];
+  return row && row.transitive ? ['packageNew', 'packageDrop'] : [];
+};
+
+const agentListDim = (view) => {
+  const list = view.agents ?? [];
+  const row = list[view.agentCursor ?? 0];
+  const installed = Boolean(row && row.bin);
+  const levels = (row && row.efforts) || [];
+  const sizes = (row && row.contexts) || [];
+  const off = [];
+  if (!installed || levels.length < 2) off.push('agentEffort');
+  if (!installed) off.push('agentFast');
+  if (!installed || !sizes.length) off.push('agentContext');
+  if ((view.agentPlanCount ?? 0) < 2) off.push('agentReview');
+  return off;
+};
+
+const agentsDim = (view) => {
+  if (!view.agentView) return agentListDim(view);
+  return view.agentRunning ? ['agentRerun'] : ['agentStop'];
+};
+
+const npmDim = (view) => {
+  if (view.npmView) return view.npmRunning ? [] : ['npmStop'];
+  return view.npmLogs ? [] : ['npmLogs'];
+};
+
+const FOOTER_DIM = {
+  files: filesDim,
+  unit: unitDim,
+  diff: (view) => diffGitDisabled(view.item),
+  branches: (view) => branchGitDisabled(selectedBranch(view)),
+  commits: commitsDim,
+  packages: packagesDim,
+  agents: agentsDim,
+  npm: npmDim,
+};
+
+const dimFooterActions = (view) => {
+  const pick = FOOTER_DIM[view.pane ?? 'diff'];
+  return pick ? pick(view) : [];
+};
+
+const GIT_FOOTER = ['add', 'unstage', 'revert', 'ignore'];
+
+const FOOTER_EXTRA = {
+  repos: ['theme'],
+  dashboard: ['theme', 'pull', 'push'],
+  unit: ['add', 'unstage', 'revert', 'feedback', 'code', 'lines'],
+  files: [...GIT_FOOTER, 'code'],
+  diff: [...GIT_FOOTER, 'feedback', 'code', 'layout', 'lines'],
+  branches: ['newBranch', 'rebase', 'drop', 'pull', 'push'],
+  commits: ['newCommit', 'apply', 'reword', 'drop', 'view', 'pull', 'push'],
+  npmLog: ['npmVerbose', 'npmStop', 'npmRerun'],
+  npm: ['npmEdit', 'npmNew', 'npmDrop', 'npmLogs'],
+  packages: ['packageNew', 'packageDrop', 'packageWanted', 'packageLatest'],
+  agentLog: ['agentStop', 'agentRerun'],
+  agents: [
+    'agentModel',
+    'agentEffort',
+    'agentFast',
+    'agentContext',
+    'agentReview',
+  ],
+  tasks: ['plan', 'import', 'drop', 'check', 'taskNudge'],
+};
+
+const extraFooterActions = (view) => {
+  const { pane } = view;
+  if (pane === 'npm' && view.npmView) return FOOTER_EXTRA.npmLog;
+  if (pane === 'npm') return FOOTER_EXTRA.npm;
+  if (pane === 'agents' && view.agentView) return FOOTER_EXTRA.agentLog;
+  if (pane === 'agents') return FOOTER_EXTRA.agents;
+  const listed = FOOTER_EXTRA[pane];
+  if (listed) return listed;
+  if (isTaskView(view)) return FOOTER_EXTRA.tasks;
+  return GIT_FOOTER;
+};
+
+const footerLayout = (view, width) => {
+  const extra = extraFooterActions(view);
+  const disabled = dimFooterActions(view);
+  const backId = 'back';
+  const globals = view.pane === 'repos' ? [] : DASH_IDS;
+  const tail = false;
+  const options = { extra, disabled, backId, globals, tail };
+  return layoutButtons(width, options);
+};
+
+module.exports = {
+  QUIT_MARK,
+  paintMarkedWord,
+  layoutButtons,
+  paintFooter,
+  footerHits,
+  footerLayout,
+};

package/lib/render/frame.js

@@ -1,32 +1,38 @@
 'use strict';
 
-const ansi = require('../ansi.js');
-const select = require('../select.js');
+const { clamp } = require('../common/utilities.js');
+const { ESC, RESET, stampVisible } = require('../term/ansi.js');
+const { overlayRows, markEditorSelection } = require('../term/select.js');
 const primitives = require('./primitives.js');
-const chrome = require('./chrome.js');
+const { paintHeader } = require('./header.js');
+const { paintFooter, footerHits, footerLayout } = require('./footer.js');
+const status = require('./status.js');
 const files = require('./files.js');
 const branches = require('./branches.js');
 const commits = require('./commits.js');
-const notes = require('./notes.js');
+const { paintNotePanel, paintBodyTodo } = require('./notes.js');
 const npm = require('./npm.js');
-const diff = require('./diff.js');
+const { paintBodyDiff, viewDigits, paintNumberFill } = require('./diff.js');
 const unit = require('./unit.js');
-const dashboard = require('./dashboard.js');
+const dashboard = require('./dashboard/dashboard.js');
+const packages = require('./packages.js');
+const agents = require('./agents.js');
+const repos = require('./repos.js');
 
-const { RESET } = ansi;
-const { overlayRows, markEditorSelection } = select;
 const { isListPane, isTaskView, paintBodyFill, paneResult } = primitives;
-const { paintHeader, paintFooter, footerHits, paintStatusLine } = chrome;
-const { footerLayout, statusBranchHit, statusChoiceHits } = chrome;
-const { paintNotePanel, paintBodyTodo } = notes;
-const { paintBodyDiff } = diff;
+const { bodyRow } = primitives;
+const { paintStatusLine, statusBranchHit, statusChoiceHits } = status;
+const { statusPlanHit, planMenu } = status;
 
 const PANE_BODY = {
   dashboard: dashboard.paintBodyDashboard,
+  repos: repos.paintBodyRepos,
   files: files.paintBodyFiles,
   branches: branches.paintBodyBranches,
   commits: commits.paintBodyCommits,
   npm: npm.paintBodyNpm,
+  packages: packages.paintBodyPackages,
+  agents: agents.paintBodyAgents,
   unit: unit.paintBodyUnit,
   tasks: paintBodyTodo,
 };
@@ -49,16 +55,35 @@ const frameNotes = (view, width, height, color) => {
   return { panel, rows, cursor, bodyH };
 };
 
+const headsOnly = (owners, first) => {
+  for (let i = 0; i < first; i++) {
+    if (owners[i] !== null && owners[i] !== undefined) return false;
+  }
+  return true;
+};
+
+const tailBlank = (owners, last) => {
+  for (let i = last + 1; i < owners.length; i++) {
+    if (owners[i] !== null && owners[i] !== undefined) return last;
+  }
+  return Math.max(last, owners.length - 1);
+};
+
 const revealScroll = (owners, focus, height, prefer) => {
   const first = owners.indexOf(focus);
   if (first < 0) return prefer;
   const last = owners.lastIndexOf(focus);
   const room = Math.max(1, height);
-  let start = Math.min(prefer, first);
-  if (last >= start + room) {
-    start = last - first + 1 <= room ? last - room + 1 : first;
+  const end = tailBlank(owners, last);
+  const top = headsOnly(owners, first) ? 0 : first;
+  let start = Math.min(prefer, top);
+  if (end >= start + room) {
+    const fits = end - top + 1 <= room;
+    if (fits || end > last) start = end - room + 1;
+    else start = first;
   }
-  return Math.max(0, Math.min(start, owners.length - room));
+  const max = Math.max(0, owners.length - room);
+  return clamp(start, 0, max);
 };
 
 const windowY = (win, row) => {
@@ -85,28 +110,64 @@ const mapBodyCursor = (cursor, win) => {
   return point;
 };
 
+const numberDigits = (view) => {
+  if (!view || view.lineNumbers !== true) return 0;
+  if (view.pane !== 'diff' && view.pane !== 'unit') return 0;
+  return viewDigits(view);
+};
+
 const bodyFillKind = (listPane, splitBody) => {
   if (listPane) return 'files';
   return splitBody ? 'split' : 'plain';
 };
 
+const mapScrollBar = (bar, win) => {
+  if (!bar) return null;
+  const row = bar.row + win.shift - win.scroll;
+  if (row < 0 || row >= win.shown) return null;
+  const height = Math.min(bar.height, win.shown - row);
+  return {
+    x: bar.col,
+    y: win.headerLines + row + 1,
+    height,
+    track: bar.track,
+    rows: bar.rows,
+    count: bar.count,
+    start: bar.start,
+  };
+};
+
 const windowBody = (view, painted, frame) => {
   const { width, color, bodyH, headerLines } = frame;
   const listPane = isListPane(view.pane);
   const fillKind = bodyFillKind(listPane, painted.splitBody);
-  const filler = paintBodyFill(width, color, fillKind);
-  const shift = !listPane && painted.body.length > 0 ? 1 : 0;
+  const digits = numberDigits(view);
+  const filler = digits
+    ? paintNumberFill(width, color, digits, painted.splitBody)
+    : paintBodyFill(width, color, fillKind);
+  const count = painted.body.length;
+  const shift = !listPane && count > 0 ? 1 : 0;
   const lead = (items, first) =>
     shift && items.length ? [first, ...items] : items;
-  const body = lead(painted.body, filler);
-  const taskOwners = lead(painted.taskOwners, null);
-  const taskChecks = lead(painted.taskChecks, false);
-  const scrollMax = Math.max(0, body.length - bodyH);
+  let total = count + shift;
+  let taskOwners = lead(painted.taskOwners, null);
+  let taskChecks = lead(painted.taskChecks, false);
+  if (isTaskView(view) && total > bodyH) {
+    total += 1;
+    taskOwners = taskOwners.concat(null);
+    taskChecks = taskChecks.concat(false);
+  }
+  const scrollMax = Math.max(0, total - bodyH);
   let scroll = listPane ? 0 : Math.min(view.scroll ?? 0, scrollMax);
   if (isTaskView(view)) {
     scroll = revealScroll(taskOwners, view.tasksFocus ?? 0, bodyH, scroll);
   }
-  const slice = body.slice(scroll, scroll + bodyH);
+  const slice = [];
+  for (let at = scroll; at < Math.min(total, scroll + bodyH); at++) {
+    const index = at - shift;
+    const inBody = index >= 0 && index < count;
+    slice.push(inBody ? bodyRow(painted.body, index) : filler);
+  }
   const win = { shift, scroll, shown: slice.length, headerLines };
   const taskHits = [];
   for (let i = 0; i < slice.length; i++) {
@@ -128,6 +189,7 @@ const windowBody = (view, painted, frame) => {
     fileHits: painted.fileHits,
     editHits: mapEditHits(painted.editHits, win),
     cursor: mapBodyCursor(painted.cursor, win),
+    scrollBar: mapScrollBar(painted.scrollBar, win),
   };
 };
 
@@ -173,7 +235,21 @@ const renderFrame = (view, options = {}) => {
   const hits = notePointerHits(notes, bodyH);
   const statusY = rows.length - 1;
   const branchHit = statusBranchHit(view, width, statusY);
-  const statusHits = branchHit ? [branchHit] : statusChoiceHits(view, statusY);
+  const planHit = statusPlanHit(view, width, statusY);
+  const choices = statusChoiceHits(view, statusY);
+  const statusHits = [];
+  if (branchHit) statusHits.push(branchHit);
+  if (planHit) statusHits.push(planHit);
+  if (!statusHits.length) statusHits.push(...choices);
+  const menu = planMenu(view, width, color, statusY);
+  if (menu) {
+    for (const line of menu.lines) {
+      const index = line.y - 1;
+      if (index <= 0 || index >= rows.length) continue;
+      rows[index] = stampVisible(rows[index], menu.x, line.text);
+    }
+    statusHits.push(...menu.hits);
+  }
   const editHits = [...windowed.editHits, ...hits.editHits];
   const shown = markEditorSelection(rows, view, editHits, color);
   const text = shown.map((row) => (color ? row + RESET : row)).join('\n');
@@ -191,9 +267,35 @@ const renderFrame = (view, options = {}) => {
     scroll: windowed.scroll,
     scrollMax: windowed.scrollMax,
     listScroll: windowed.listScroll,
+    menuScroll: menu ? menu.scroll : painted.menuScroll,
+    runScroll: painted.runScroll,
+    gridCols: painted.gridCols,
     cursor: hits.cursor ?? windowed.cursor,
+    scrollBar: windowed.scrollBar,
     bodyH,
   };
 };
 
-module.exports = { renderFrame };
+const presentCursor = (cursor) => {
+  if (!cursor || cursor.x <= 0 || cursor.y <= 0) return `${ESC}[?25l`;
+  const pos = `${ESC}[${cursor.y};${cursor.x}H`;
+  return `${pos}${ESC}[1 q${ESC}[?12h${ESC}[?25h`;
+};
+
+const presentRows = (rows, options = {}) => {
+  let out = `${ESC}[?25l${ESC}[?2026h`;
+  if (options.clear === true) out += `${ESC}[H${ESC}[2J`;
+  const prev = options.prev;
+  const same = prev && prev.length === rows.length ? prev : null;
+  for (let i = 0; i < rows.length; i++) {
+    if (same && same[i] === rows[i]) continue;
+    out += `${ESC}[${i + 1};1H${rows[i]}`;
+  }
+  return `${out}${ESC}[?2026l${presentCursor(options.cursor)}`;
+};
+
+module.exports = {
+  renderFrame,
+  presentCursor,
+  presentRows,
+};