reslop 0.2.6 → 0.2.7

package/lib/render/primitives.js

@@ -17,7 +17,8 @@ const fill = (width, fgRgb, bgRgb, color) =>
 
 const markPrefix = (selected) => ` ${selected ? FILE_MARK : ' '} `;
 
-const isListPane = (pane) => LIST_PANES.includes(pane) || pane === 'dashboard';
+const isListPane = (pane) =>
+  LIST_PANES.includes(pane) || pane === 'dashboard' || pane === 'repos';
 
 const isTaskView = (view) => view.item?.origin === 'task';
 
@@ -111,11 +112,19 @@ const paintListWindow = (count, focus, pane, lineAt) => {
   return paneResult({ body, fileHits, editHits, cursor, listScroll: start });
 };
 
+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));
+};
+
 const paintCursorList = (items, cursor, pane, paintRow, extra = null) => {
   const lineAt = (index) => {
     const entry = items[index];
     if (!entry) return null;
-    return listLine(paintRow(entry, !extra && index === cursor), index);
+    const selected = !extra && index === cursor;
+    return listLine(paintRow(entry, selected, index), index);
   };
   if (!extra) return paintListWindow(items.length, cursor, pane, lineAt);
   const edit = listLine(extra.row, -1, extra.cursor, extra.edits);
@@ -124,10 +133,8 @@ const paintCursorList = (items, cursor, pane, paintRow, extra = null) => {
     const replaced = (i) => (i === at ? edit : lineAt(i));
     return paintListWindow(items.length, at, pane, replaced);
   }
-  const first = extra.at === 'start';
-  const at = first ? 0 : items.length;
-  const shift = first ? 1 : 0;
-  const inserted = (i) => (i === at ? edit : lineAt(i - shift));
+  const at = insertedAt(extra, items.length);
+  const inserted = (i) => (i === at ? edit : lineAt(i < at ? i : i - 1));
   return paintListWindow(items.length + 1, at, pane, inserted);
 };
 

package/lib/render/repos.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const ansi = require('../ansi.js');
+const { THEME } = ansi;
+const primitives = require('./primitives.js');
+const { paintBodyFill, paneResult } = primitives;
+const tiles = require('./tiles.js');
+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 REPO_MIN_H = 6;
+const MARGIN_MIN_H = 12;
+const EXT_LIMIT = 3;
+const DIM_BACKS = {
+  head: THEME.dashDimHeadBg,
+  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 fitAside = (left, right, width) => {
+  const rightW = segmentsWidth(right);
+  const room = Math.max(0, width - rightW - 1);
+  const clipped = clipSegments(left, room);
+  const gap = Math.max(1, width - segmentsWidth(clipped) - rightW);
+  return [...clipped, seg(' '.repeat(gap)), ...right];
+};
+
+const titleLine = (row, ctx, selected, width) => {
+  const hot = isHot(row.activityAt, ctx.now);
+  const tone = hot ? blinkTone(ctx.frame) : 'text';
+  const left = [seg(row.name, tone, selected || hot)];
+  if (hot) left.push(seg(' ●', tone, true));
+  const right = [];
+  if (rowPending(row)) right.push(spin(ctx.frame), seg(' '));
+  const label = row.filesReady ? size(row.bytes) : '…';
+  const sizeTone = row.filesReady ? 'text' : 'muted';
+  right.push(seg(label, sizeTone, row.filesReady));
+  return fitAside(left, right, width);
+};
+
+const extLine = (row, ctx) => {
+  if (!row.filesReady) return [spin(ctx.frame)];
+  const exts = row.exts.slice(0, EXT_LIMIT);
+  if (!exts.length) return [seg('no files', 'muted')];
+  const segs = [];
+  for (let i = 0; i < exts.length; i++) {
+    if (i) segs.push(seg('  '));
+    segs.push(seg(extName(exts[i].key), 'sha'));
+    segs.push(seg(` ${size(exts[i].bytes)}`, 'text'));
+  }
+  return segs;
+};
+
+const countValue = (ready, text, frame) =>
+  ready ? seg(text, 'text', true) : spin(frame);
+
+const countLine = (row, ctx) => [
+  seg('tasks: ', 'muted'),
+  countValue(row.tasksReady, `${row.tasksDone}/${row.tasks}`, ctx.frame),
+  seg('   commits: ', 'muted'),
+  countValue(row.commitsReady, `${row.commits}`, ctx.frame),
+];
+
+const resultNote = (run) => {
+  const result = run.result;
+  if (!result) return [];
+  if (typeof result.tests === 'number') {
+    const note = [seg(` ${result.tests}`, 'muted')];
+    if (result.failed) note.push(seg(` ${result.failed} fail`, 'error'));
+    return note;
+  }
+  if (typeof result.errors === 'number') {
+    return [seg(` ${result.errors} err`, result.errors ? 'error' : 'muted')];
+  }
+  return [];
+};
+
+const runLine = (row, ctx) => {
+  if (!row.runsReady) return [seg('run: ', 'muted'), spin(ctx.frame)];
+  const run = row.run;
+  if (!run) return [seg('run: ', 'muted'), seg('idle', 'muted')];
+  if (run.status === 'running') {
+    const seen = run.done + run.failed;
+    const total = run.expected > 0 ? `/${run.expected}` : '';
+    const fail = run.failed ? ` ${run.failed} fail` : '';
+    return [
+      seg(`${spinner(ctx.frame)} `, 'warn', true),
+      seg(run.name || 'run', 'text'),
+      seg(` ${seen}${total}${fail}`, 'warn'),
+    ];
+  }
+  const icon = RUN_ICON[run.status] ?? ['?', 'muted'];
+  return [
+    seg(`${icon[0]} `, icon[1], true),
+    seg(run.name || 'run', 'text'),
+    seg(` ${run.status}`, icon[1]),
+    ...resultNote(run),
+  ];
+};
+
+const npmLine = (row, ctx) => {
+  if (!row.npmReady) return [seg('deps: ', 'muted'), spin(ctx.frame)];
+  const npm = row.npm;
+  if (!npm || !npm.hasManifest) return [seg('no package.json', 'muted')];
+  const modules = npm.modules || { count: 0, bytes: 0 };
+  const segs = [
+    seg('deps: ', 'muted'),
+    seg(`${npm.deps}`, 'text'),
+    seg('  dev: ', 'muted'),
+    seg(`${npm.dev}`, 'text'),
+    seg('  all: ', 'muted'),
+    seg(`${modules.count}`, 'text'),
+    seg(' (', 'muted'),
+    seg(size(modules.bytes), 'text'),
+    seg(')', 'muted'),
+  ];
+  if (npm.audit) {
+    segs.push(
+      seg('  '),
+      seg('🚨 ', 'error'),
+      seg(`${npm.audit}`, 'error', true),
+    );
+  }
+  if (npm.outdated) {
+    segs.push(
+      seg('  '),
+      seg('⚠️ ', 'warn'),
+      seg(`${npm.outdated}`, 'warn', true),
+    );
+  }
+  return segs;
+};
+
+const diffLine = (row, ctx) => {
+  if (!row.diffReady) return [seg('diff: ', 'muted'), spin(ctx.frame)];
+  const diff = row.diff;
+  const added = diff.stagedAdded + diff.unstagedAdded;
+  const removed = diff.stagedRemoved + diff.unstagedRemoved;
+  return [
+    seg('diff: ', 'muted'),
+    seg(`+${diff.stagedAdded}/${added}`, 'add'),
+    seg('  '),
+    seg(`-${diff.stagedRemoved}/${removed}`, 'del'),
+  ];
+};
+
+const repoContent = (row, ctx, selected, width) => ({
+  titleLine: titleLine(row, ctx, selected, width),
+  lines: [
+    extLine(row, ctx),
+    countLine(row, ctx),
+    runLine(row, ctx),
+    diffLine(row, ctx),
+    npmLine(row, ctx),
+  ],
+});
+
+const paintRepos = (model, bands, color) => {
+  const painted = new Map();
+  const ctx = { now: model.now, frame: model.frame };
+  const selected = model.tiles[model.cursor];
+  const selectedId = selected ? selected.id : '';
+  for (const band of bands) {
+    for (const place of band.tiles) {
+      const row = model.tiles.find((tile) => tile.id === place.id);
+      if (!row) continue;
+      const tile = { id: row.id, key: '', title: row.name };
+      const inner = Math.max(0, place.w - 2);
+      const picked = row.id === selectedId;
+      const content = repoContent(row, ctx, picked, inner);
+      const backs = picked ? null : DIM_BACKS;
+      const rows = paintTile(tile, content, place.w, band.h, color, backs);
+      painted.set(place.id, rows);
+    }
+  }
+  return painted;
+};
+
+const paintBodyRepos = (view, width, color, bodyH, headerLines) => {
+  const model = view.repos;
+  if (!model || !model.tiles.length) {
+    const blank = paintBodyFill(width, color, 'files');
+    return paneResult({ body: new Array(bodyH).fill(blank) });
+  }
+  const margin = bodyH >= MARGIN_MIN_H ? 1 : 0;
+  const height = Math.max(1, bodyH - margin * 2);
+  const grid = equalGrid(width, height, model.tiles.length, 34, REPO_MIN_H);
+  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 });
+};
+
+module.exports = { REPO_MIN_H, extName, paintBodyRepos };

package/lib/render/search.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const ansi = require('../ansi.js');
+const { THEME, paint } = ansi;
+
+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;
+};
+
+module.exports = { paintPathText };

package/lib/render/tiles.js

@@ -19,6 +19,7 @@ const seg = (text, tone = 'text', bold = false) => ({
   text: `${text}`,
   tone,
   bold,
+  bg: null,
 });
 
 const toneColors = () => ({
@@ -30,7 +31,12 @@ const toneColors = () => ({
   warn: THEME.warnFg,
   error: THEME.errorFg,
   sha: THEME.shaFg,
-  trend: THEME.dashTrendFg,
+  dep: THEME.pkgDepFg,
+  dev: THEME.pkgDevFg,
+  pkg: THEME.pkgFg,
+  chain: THEME.pkgChainFg,
+  heat: THEME.heatFg,
+  blink: THEME.heatBlinkFg,
   key: THEME.dashKeyFg,
 });
 
@@ -78,7 +84,8 @@ const paintSegments = (segs, width, bg, color, fill = ' ', colors = null) => {
   }
   let out = '';
   for (const item of clipped) {
-    out += paint(item.text, ink[item.tone], bg, color, item.bold);
+    const pieceBg = item.bg ?? bg;
+    out += paint(item.text, ink[item.tone], pieceBg, color, item.bold);
   }
   return out + paint(fill.repeat(pad), ink.muted, bg, color);
 };
@@ -173,9 +180,15 @@ const paintFramed = (line, width, bg, color, fill = ' ', colors = null) => {
   return edge + paintSegments(line, inner, bg, color, fill, colors) + edge;
 };
 
-const paintHead = (tile, content, width, color) => {
+const paintFlushRight = (line, width, bg, color) => {
+  const edge = paintSegments([seg(' ')], 1, bg, color);
+  const inner = Math.max(0, width - 1);
+  return edge + paintSegments(line, inner, bg, color);
+};
+
+const paintHead = (tile, content, width, color, headBg) => {
   const fill = color ? ' ' : RULE;
-  const bg = THEME.dashHeadBg;
+  const bg = headBg;
   const colors = headColors();
   if (content.titleLine) {
     return paintFramed(content.titleLine, width, bg, color, fill, colors);
@@ -184,22 +197,28 @@ const paintHead = (tile, content, width, color) => {
   return paintSegments(segs, width, bg, color, fill, colors);
 };
 
-const rowBackground = (index, filled) => {
-  if (filled && index % 2 === 1) return THEME.dashRowBg;
-  return THEME.dashTileBg;
+const rowBackground = (index, filled, backs) => {
+  if (filled && index % 2 === 1) return backs.row;
+  return backs.tile;
 };
 
-const paintTile = (tile, content, width, height, color) => {
+const paintTile = (tile, content, width, height, color, backs = null) => {
+  const shade = backs ?? {
+    head: THEME.dashHeadBg,
+    tile: THEME.dashTileBg,
+    row: THEME.dashRowBg,
+  };
   const { lines, footer } = content;
-  const rows = [paintHead(tile, content, width, color)];
+  const rows = [paintHead(tile, content, width, color, shade.head)];
   const bodyRoom = footer ? height - 2 : height - 1;
   for (let i = 0; i < bodyRoom; i++) {
-    const bg = rowBackground(i, i < lines.length);
+    const bg = rowBackground(i, i < lines.length, shade);
     rows.push(paintFramed(lines[i] ?? [], width, bg, color));
   }
   if (footer && height > 1) {
-    const bg = rowBackground(bodyRoom, true);
-    rows.push(paintFramed(footer, width, bg, color));
+    const bg = rowBackground(bodyRoom, true, shade);
+    const paintRow = content.footerFlush ? paintFlushRight : paintFramed;
+    rows.push(paintRow(footer, width, bg, color));
   }
   return rows;
 };
@@ -229,6 +248,78 @@ const composeBands = (bands, painted, width, height, color) => {
   return rows.slice(0, height);
 };
 
+const gridSize = (width, height, cols, rows) => ({
+  tileW: Math.floor((width - (cols - 1) * GAP_X) / cols),
+  tileH: Math.floor((height - (rows - 1) * GAP_Y) / rows),
+});
+
+const equalGrid = (width, height, count, minW = MIN_W, minH = MIN_H) => {
+  const safe = Math.max(1, count);
+  const colCap = Math.max(
+    1,
+    Math.min(safe, Math.floor((width + GAP_X) / (minW + GAP_X)) || 1),
+  );
+  const rowCap = Math.max(
+    1,
+    Math.min(safe, Math.floor((height + GAP_Y) / (minH + GAP_Y)) || 1),
+  );
+  let best = null;
+  for (let cols = 1; cols <= colCap; cols++) {
+    for (let rows = 1; rows <= rowCap; rows++) {
+      const size = gridSize(width, height, cols, rows);
+      if (size.tileW < minW || size.tileH < minH) continue;
+      const cap = cols * rows;
+      const shown = Math.min(safe, cap);
+      const score = shown * 1000000 + size.tileW * size.tileH;
+      if (!best || score > best.score) {
+        best = { cols, rows, cap, ...size, score };
+      }
+    }
+  }
+  if (best) return best;
+  return {
+    cols: 1,
+    rows: 1,
+    cap: 1,
+    tileW: Math.max(1, width),
+    tileH: Math.max(1, height),
+    score: 0,
+  };
+};
+
+const pageWindow = (count, cursor, cap) => {
+  const room = Math.max(1, cap);
+  if (count <= room) return { start: 0, end: count };
+  const at = Math.min(Math.max(0, cursor), count - 1);
+  let start = Math.floor(at / room) * room;
+  if (start + room > count) start = count - room;
+  return { start, end: start + room };
+};
+
+const placeEqualTiles = (tiles, grid) => {
+  const bands = [];
+  const cols = Math.max(1, grid.cols);
+  const rows = Math.ceil(tiles.length / cols);
+  for (let row = 0; row < rows; row++) {
+    const slice = tiles.slice(row * cols, (row + 1) * cols);
+    if (!slice.length) break;
+    const placed = [];
+    for (let i = 0; i < slice.length; i++) {
+      placed.push({
+        id: slice[i].id,
+        x: i * (grid.tileW + GAP_X),
+        w: grid.tileW,
+      });
+    }
+    bands.push({
+      y: row * (grid.tileH + GAP_Y),
+      h: grid.tileH,
+      tiles: placed,
+    });
+  }
+  return bands;
+};
+
 const tileHits = (bands, headerLines) => {
   const hits = [];
   for (const band of bands) {
@@ -253,6 +344,10 @@ module.exports = {
   spinner,
   titleSegments,
   layoutTiles,
+  equalGrid,
+  pageWindow,
+  placeEqualTiles,
+  paintSegments,
   paintTile,
   composeBands,
   tileHits,

package/lib/review.js

@@ -75,7 +75,7 @@ const setCode = (store, key, note) => {
   putNote(store, store.code, key, note, Boolean(note.clear));
 };
 
-const addTask = (store, file, text = '', done = false, kind = 'backlog') => {
+const addTask = (store, file, text = '', done = false, kind = 'features') => {
   const id = store.nextTaskId;
   store.nextTaskId += 1;
   const todo = { id, file, text, done, kind: taskKind({ kind }) };
@@ -202,11 +202,12 @@ const SECTION_LINE = {
 const BACKLOG_HEAD = 'Backlog';
 const LEGACY_BACKLOG = 'TODOs';
 const TASK_TITLES = new Map([
-  [BACKLOG_HEAD, 'backlog'],
-  [LEGACY_BACKLOG, 'backlog'],
-  ['Issues', 'issues'],
+  [BACKLOG_HEAD, 'debt'],
+  [LEGACY_BACKLOG, 'debt'],
+  ['Issues', 'debt'],
   ['Bug Reports', 'bugs'],
   ['Feature Requests', 'features'],
+  ...TASK_KINDS.map((kind) => [kind.title, kind.id]),
 ]);
 
 const AGENT_INSTRUCTIONS = [