reslop 0.2.1 → 0.2.3

package/lib/render/frame.js

@@ -8,18 +8,20 @@ const files = require('./files.js');
 const branches = require('./branches.js');
 const commits = require('./commits.js');
 const notes = require('./notes.js');
+const npm = require('./npm.js');
 const diff = require('./diff.js');
 const unit = require('./unit.js');
 
 const { RESET } = ansi;
 const { LIST_PANES, paintBodyFill, paneResult } = primitives;
-const { paintHeader, paintButtons, paintStatusLine } = chrome;
+const { paintHeader, paintFooter, footerHits, paintStatusLine } = chrome;
 const { layoutButtons, statusBranchHit, statusChoiceHits } = chrome;
 const { hiddenActions, dimFooterActions, extraFooterActions } = chrome;
 const { paintNotePanel, paintBodyTodo } = notes;
 const { paintBodyFiles } = files;
 const { paintBodyBranches } = branches;
 const { paintBodyCommits } = commits;
+const { paintBodyNpm } = npm;
 const { paintBodyDiff } = diff;
 const { paintBodyUnit } = unit;
 
@@ -28,6 +30,7 @@ const bodyKind = (view) => {
   if (pane === 'files' || pane === 'branches' || pane === 'commits') {
     return pane;
   }
+  if (pane === 'npm') return 'npm';
   if (pane === 'unit') return 'unit';
   if (!view.item) return 'empty';
   if (view.item.origin === 'todo') return 'todo';
@@ -47,6 +50,7 @@ const BODY_PAINT = {
   files: paintBodyFiles,
   branches: paintBodyBranches,
   commits: paintBodyCommits,
+  npm: paintBodyNpm,
   empty: paintBodyEmpty,
   todo: paintBodyTodo,
   diff: paintBodyDiff,
@@ -75,6 +79,33 @@ const bodyFillKind = (listPane, splitBody) => {
   return 'plain';
 };
 
+const ownerSpan = (owners, focus) => {
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < owners.length; i++) {
+    if (owners[i] !== focus) continue;
+    if (first < 0) first = i;
+    last = i;
+  }
+  return { first, last };
+};
+
+const revealScroll = (owners, focus, height, prefer) => {
+  const span = ownerSpan(owners, focus);
+  if (span.first < 0) return prefer;
+  const room = Math.max(1, height);
+  let start = prefer;
+  if (span.first < start) start = span.first;
+  if (span.last >= start + room) {
+    const fits = span.last - span.first + 1 <= room;
+    start = fits ? span.last - room + 1 : span.first;
+  }
+  const maxStart = Math.max(0, owners.length - room);
+  if (start > maxStart) start = maxStart;
+  if (start < 0) start = 0;
+  return start;
+};
+
 const mapBodyCursor = (cursor, shift, scroll, headerLines, shown) => {
   if (!cursor) return null;
   const row = cursor.row + shift;
@@ -119,7 +150,10 @@ const windowBody = (view, width, color, bodyH, headerLines, paintedBody) => {
   }
   const scrollRaw = view.scroll ?? 0;
   const scrollMax = Math.max(0, body.length - bodyH);
-  const scroll = listPane ? 0 : Math.min(scrollRaw, scrollMax);
+  let scroll = listPane ? 0 : Math.min(scrollRaw, scrollMax);
+  if (view.item && view.item.origin === 'todo') {
+    scroll = revealScroll(todoOwners, view.todoFocus ?? 0, bodyH, scroll);
+  }
   const end = Math.min(body.length, scroll + bodyH);
   const copied = Math.max(0, end - scroll);
   const slice = new Array(bodyH);
@@ -165,7 +199,7 @@ const stackFrame = (view, width, color, rows, layout, windowed, notes) => {
   for (const row of notes.noteRows) rows.push(row);
   const status = view.status ?? '';
   rows.push(paintStatusLine(view, status, width, color));
-  rows.push(paintButtons(layout, width, color));
+  rows.push(paintFooter(view, layout, width, color));
   return overlayRows(rows, view.selection);
 };
 
@@ -207,7 +241,7 @@ const renderFrame = (view, options = {}) => {
   return {
     text,
     rows: painted,
-    buttons: layout.hits,
+    buttons: footerHits(view, layout),
     fileHits,
     todoHits,
     templateHits,

package/lib/render/npm.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const ansi = require('../ansi.js');
+const chrome = require('./chrome.js');
+const primitives = require('./primitives.js');
+const npmCommands = require('../npm-commands.js');
+
+const { THEME, paint, visibleWidth, truncateVisible, seq, EL } = ansi;
+const { clipAnsi, stripAnsi, RESET, foregroundOn } = ansi;
+const { formatBusyStatus } = chrome;
+const { TABLE_KEY, TABLE_VAL } = npmCommands;
+const { fill, FILE_MARK, paneResult, paintCursorList } = primitives;
+const { paintListEdit } = primitives;
+
+const EDGE = 2;
+const TAIL = 1;
+const LOG_PAD_Y = 1;
+const LOG_PAD_X = 2;
+const NPM_NAME_MAX = 24;
+
+const logViewRows = (bodyH) => {
+  const height = Math.max(1, bodyH);
+  if (height >= LOG_PAD_Y * 2 + 1) return height - LOG_PAD_Y * 2;
+  return height;
+};
+
+const rowFg = (selected) => (selected ? THEME.chromeFg : THEME.mutedFg);
+
+const npmNameWidth = (commands) => {
+  let width = 0;
+  for (const entry of commands) {
+    width = Math.max(width, visibleWidth(`${entry.name ?? ''}`));
+  }
+  return Math.min(NPM_NAME_MAX, width);
+};
+
+const paintNpmRow = (entry, width, color, selected, nameCol = 0) => {
+  const inner = Math.max(1, width - EDGE - TAIL);
+  const mark = selected ? FILE_MARK : ' ';
+  const prefix = ` ${mark} `;
+  const prefixW = visibleWidth(prefix);
+  const rest = Math.max(1, inner - prefixW);
+  const detail = entry.kind === 'bin' ? 'bin' : entry.command;
+  const nameW = Math.min(Math.max(0, nameCol), rest);
+  const name = truncateVisible(entry.name, nameW);
+  const gap = rest > nameW + 2 ? '  ' : '';
+  const detailW = Math.max(0, rest - nameW - visibleWidth(gap));
+  const shown = truncateVisible(detail, detailW);
+  const mid = `${name}${' '.repeat(Math.max(0, nameW - visibleWidth(name)))}`;
+  const after = `${gap}${shown}`;
+  const pad = Math.max(0, rest - visibleWidth(mid + after));
+  const left = `${prefix}${mid}${after}${' '.repeat(pad)}`;
+  const fgRgb = rowFg(selected);
+  const bgRgb = selected ? THEME.buttonBg : THEME.ctxBg;
+  const tail = ' '.repeat(TAIL);
+  const edge = fill(EDGE, fgRgb, THEME.ctxBg, color);
+  if (!color) return `${left}${tail}${edge}`;
+  let out = `${seq(fgRgb, bgRgb)}${EL}`;
+  out += paint(prefix, fgRgb, bgRgb, color);
+  const bin = entry.kind === 'bin';
+  const nameFg = bin ? THEME.shaFg : THEME.buttonHotFg;
+  out += paint(mid, nameFg, bgRgb, color, !bin);
+  out += paint(`${after}${' '.repeat(pad)}${tail}`, fgRgb, bgRgb, color);
+  return out + edge;
+};
+
+const paintNpmList = (view, width, color, bodyH, headerLines) => {
+  const commands = view.npmCommands ?? [];
+  const nameW = npmNameWidth(commands);
+  const cursor = view.npmCursor ?? 0;
+  const compose = view.compose;
+  const editing = compose && compose.kind === 'npm';
+  const paintRow = (entry, rowWidth, rowColor, selected) =>
+    paintNpmRow(entry, rowWidth, rowColor, selected, nameW);
+  let extra = null;
+  if (editing) {
+    const painted = paintListEdit(compose, width, color, EDGE);
+    const at = view.npmEditName ? 'replace' : 'end';
+    extra = { row: painted.row, cursor: painted.cursor, at, index: cursor };
+  }
+  const painted = paintCursorList(
+    commands,
+    cursor,
+    width,
+    color,
+    bodyH,
+    headerLines,
+    paintRow,
+    extra,
+    view.listScroll,
+  );
+  return paneResult({
+    body: painted.body,
+    fileHits: painted.fileHits,
+    todoOwners: [],
+    cursor: painted.cursor,
+    splitBody: false,
+    listScroll: painted.offset,
+  });
+};
+
+const logStart = (view, count, rows) => {
+  const maxStart = Math.max(0, count - rows);
+  let start = maxStart;
+  if (!view.npmFollow) start = view.npmScroll ?? 0;
+  if (start > maxStart) start = maxStart;
+  if (start < 0) start = 0;
+  return start;
+};
+
+const isTableLine = (line) => `${line ?? ''}`.startsWith(TABLE_KEY);
+
+const mixRgb = (from, to, part) => {
+  const out = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    const next = from[i] + (to[i] - from[i]) * part;
+    out[i] = Math.round(next);
+  }
+  return out;
+};
+
+const tableTone = (index) => {
+  const lift = index % 2 === 0 ? 0.035 : 0.07;
+  const valueBg = mixRgb(THEME.ctxBg, THEME.chromeFg, lift);
+  const keyBg = mixRgb(THEME.ctxBg, THEME.chromeFg, lift + 0.025);
+  const frame = mixRgb(THEME.ctxBg, THEME.chromeFg, lift * 0.4);
+  return { valueBg, keyBg, frame };
+};
+
+const tableIndex = (lines, index) => {
+  let at = index;
+  let row = 0;
+  while (at > 0 && isTableLine(lines[at - 1])) {
+    at -= 1;
+    row += 1;
+  }
+  return row;
+};
+
+const paintTableLine = (line, width, index) => {
+  const raw = line.slice(TABLE_KEY.length);
+  const at = raw.indexOf(TABLE_VAL);
+  const key = at < 0 ? raw : raw.slice(0, at);
+  const rest = at < 0 ? '' : raw.slice(at + TABLE_VAL.length);
+  const gap = rest.startsWith('  ') ? '  ' : '';
+  const value = rest.slice(gap.length);
+  const edge = 1;
+  const inner = Math.max(1, width - edge * 2);
+  const keyW = visibleWidth(key);
+  const gapW = visibleWidth(gap);
+  const valueW = Math.max(0, inner - keyW - gapW);
+  const shown = truncateVisible(value, valueW);
+  const pad = ' '.repeat(Math.max(0, valueW - visibleWidth(shown)));
+  const tone = tableTone(index);
+  const ink = THEME.ctxFg;
+  let out = fill(edge, ink, tone.frame, true);
+  out += paint(key, ink, tone.keyBg, true);
+  out += paint(gap, ink, tone.frame, true);
+  out += paint(`${shown}${pad}`, ink, tone.valueBg, true);
+  return `${out}${fill(edge, ink, tone.frame, true)}`;
+};
+
+const paintLogLine = (line, width, color, fgRgb = THEME.ctxFg) => {
+  const inner = Math.max(1, width - LOG_PAD_X * 2);
+  const source = color ? `${line ?? ''}` : stripAnsi(line);
+  const clip = (value) =>
+    color ? clipAnsi(value, inner) : truncateVisible(value, inner);
+  const body = color ? foregroundOn(clip(source), THEME.ctxBg) : clip(source);
+  const lead = ' '.repeat(LOG_PAD_X);
+  const pad = Math.max(0, width - LOG_PAD_X - visibleWidth(body));
+  const tail = ' '.repeat(pad);
+  if (!color) return `${lead}${body}${tail}`;
+  const base = seq(fgRgb, THEME.ctxBg);
+  let out = `${base}${EL}${lead}${body}`;
+  if (pad) out += `${RESET}${base}${tail}`;
+  return `${out}${RESET}`;
+};
+
+const paintRunBar = (width, color, frame) => {
+  const label = formatBusyStatus('running', frame);
+  return paintLogLine(label, width, color, THEME.chromeFg);
+};
+
+const paintNpmLog = (view, width, color, bodyH) => {
+  const text = view.npmOutput ?? '';
+  const lines = text.split('\n');
+  if (lines.length && lines.at(-1) === '') lines.pop();
+  const running = view.npmRunning === true;
+  const count = lines.length + (running ? 1 : 0);
+  const rows = logViewRows(bodyH);
+  const padY = bodyH - rows;
+  const top = padY ? 1 : 0;
+  const start = logStart(view, count, rows);
+  const blank = fill(width, THEME.ctxFg, THEME.ctxBg, color);
+  const body = [];
+  for (let i = 0; i < top; i++) body.push(blank);
+  for (let i = 0; i < rows; i++) {
+    const index = start + i;
+    if (index < lines.length) {
+      const line = lines[index];
+      if (color && isTableLine(line)) {
+        const row = tableIndex(lines, index);
+        body.push(paintTableLine(line, width, row));
+      } else {
+        body.push(paintLogLine(line, width, color));
+      }
+    } else if (running && index === lines.length) {
+      body.push(paintRunBar(width, color, view.progressFrame ?? 0));
+    } else {
+      body.push(blank);
+    }
+  }
+  for (let i = 0; i < padY - top; i++) body.push(blank);
+  return paneResult({
+    body,
+    fileHits: [],
+    todoOwners: [],
+    cursor: null,
+    splitBody: false,
+  });
+};
+
+const paintBodyNpm = (view, width, color, bodyH, headerLines) => {
+  if (view.npmView) return paintNpmLog(view, width, color, bodyH);
+  return paintNpmList(view, width, color, bodyH, headerLines);
+};
+
+module.exports = { paintBodyNpm, logViewRows };

package/lib/render/primitives.js

@@ -8,7 +8,7 @@ const GUTTER_W = 2;
 const FILE_MARK = '▶';
 const FILE_LIST_PAD = 1;
 const CHECK_DONE = 'xX';
-const LIST_PANES = ['files', 'branches', 'commits'];
+const LIST_PANES = ['files', 'branches', 'commits', 'npm'];
 const CHECK_TOKEN = /\[([ xX])\]/;
 const CHECK_LEAD = /^\[[ xX]\] /;
 
@@ -156,38 +156,15 @@ const paintCursorList = (
   return { body, fileHits, cursor: textCursor, offset: start };
 };
 
-const branchLabel = (name) => {
-  const branch = `${name ?? ''}`.trim();
-  if (!branch) return '';
-  return `[${branch}]`;
-};
-
-const splitBracketName = (label) => {
-  const text = `${label ?? ''}`;
-  const open = text.startsWith('[') ? '[' : '';
-  const rest = open ? text.slice(1) : text;
-  const close = rest.endsWith(']') ? ']' : '';
-  const name = close ? rest.slice(0, -1) : rest;
-  return { open, name, close };
-};
-
-const paintBracketName = (label, nameFg, wrapFg, bgRgb, color, nameBold) => {
-  const { open, name, close } = splitBracketName(label);
-  return (
-    paint(open, wrapFg, bgRgb, color, true) +
-    paint(name, nameFg, bgRgb, color, nameBold) +
-    paint(close, wrapFg, bgRgb, color, true)
-  );
-};
+const branchLabel = (name) => `${name ?? ''}`.trim();
 
-const paintListEdit = (compose, width, color, edgeW) => {
+const paintListEdit = (compose, width, color, edgeW = 0) => {
   const inner = Math.max(1, width - edgeW);
   const prefix = ` ${FILE_MARK} `;
   const prefixW = visibleWidth(prefix);
   const rest = Math.max(1, inner - prefixW);
   const text = `${compose.text ?? ''}`.replaceAll('\n', ' ');
-  const label = `[${text}]`;
-  const clipped = truncateVisible(label, rest);
+  const clipped = truncateVisible(text, rest);
   const pad = Math.max(0, rest - visibleWidth(clipped));
   const left = `${prefix}${clipped}${' '.repeat(pad)}`;
   const fgRgb = THEME.chromeFg;
@@ -198,17 +175,11 @@ const paintListEdit = (compose, width, color, edgeW) => {
     const gap = ' '.repeat(pad);
     row = `${seq(fgRgb, bgRgb)}${EL}`;
     row += paint(prefix, fgRgb, bgRgb, color);
-    row += paintBracketName(
-      clipped,
-      THEME.buttonHotFg,
-      THEME.mutedFg,
-      bgRgb,
-      color,
-    );
+    row += paint(clipped, THEME.buttonHotFg, bgRgb, color);
     row += paint(gap, fgRgb, bgRgb, color);
     row += edge;
   }
-  const col = Math.min((compose.cursor ?? 0) + 1, visibleWidth(clipped));
+  const col = Math.min(compose.cursor ?? 0, visibleWidth(clipped));
   return { row, cursor: { x: prefixW + col + 1 } };
 };
 
@@ -280,9 +251,9 @@ module.exports = {
   paintSplitRule,
   paintBodyFill,
   windowRows,
+  listWindowStart,
   paintCursorList,
   paintListEdit,
   branchLabel,
-  paintBracketName,
   paneResult,
 };

package/lib/report-model.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const { stripAnsi } = require('./ansi.js');
+const commands = require('./npm-commands.js');
+
+const { withoutNodeFrame, indentStack, relativize } = commands;
+
+const summary = () => ({
+  tests: null,
+  passed: null,
+  failed: null,
+  skipped: null,
+  errors: null,
+  warnings: null,
+  duration: '',
+});
+
+const problem = (fields = {}) => {
+  const trace = fields.trace || '';
+  const traces = fields.traces || (trace ? [trace] : []);
+  return {
+    severity: fields.severity || 'error',
+    name: fields.name || '',
+    message: fields.message || '',
+    trace,
+    traces,
+    duration: fields.duration || '',
+    code: fields.code || '',
+    operator: fields.operator || '',
+    expected: fields.expected || '',
+    actual: fields.actual || '',
+    extra: fields.extra || [],
+    count: fields.count === undefined ? 1 : fields.count,
+    omitted: fields.omitted || 0,
+  };
+};
+
+const report = (tool, fields = {}) => ({
+  tool,
+  ok: fields.ok !== false,
+  summary: fields.summary || summary(),
+  problems: fields.problems || [],
+});
+
+const userTrace = (text, root) => {
+  const lines = stripAnsi(`${text ?? ''}`).split(/\r?\n/);
+  const kept = [];
+  for (const line of lines) {
+    const next = withoutNodeFrame(line);
+    if (next === null) continue;
+    kept.push(relativize(indentStack(next), root).trimEnd());
+  }
+  while (kept.length && kept[kept.length - 1] === '') kept.pop();
+  return kept.join('\n').trim();
+};
+
+const normalizeMessage = (message) => {
+  const text = `${message ?? ''}`.trim().replace(/\s+/g, ' ');
+  return text.replace(/\s+\S+:\d+:\d+$/, '');
+};
+
+const groupKey = (item) =>
+  [
+    item.severity,
+    item.code,
+    item.operator,
+    item.expected,
+    item.actual,
+    normalizeMessage(item.message),
+  ].join('\0');
+
+const groupProblems = (problems) => {
+  const groups = new Map();
+  const order = [];
+  for (const item of problems) {
+    const key = groupKey(item);
+    let group = groups.get(key);
+    if (!group) {
+      group = problem({ ...item, count: 0, traces: [], omitted: 0 });
+      groups.set(key, group);
+      order.push(group);
+    }
+    group.count += 1;
+    if (item.trace && group.traces.length < 3) group.traces.push(item.trace);
+  }
+  for (const group of order) {
+    group.trace = group.traces[0] || '';
+    group.omitted = Math.max(0, group.count - group.traces.length);
+  }
+  return order;
+};
+
+const groupReport = (item) =>
+  report(item.tool, {
+    ok: item.ok,
+    summary: item.summary,
+    problems: groupProblems(item.problems),
+  });
+
+const reduceStderr = (text, root) => userTrace(text, root);
+
+const shortTail = (text) => {
+  const lines = `${text ?? ''}`.trim().split(/\r?\n/);
+  if (lines.length <= 20) return lines.join('\n');
+  return lines.slice(-20).join('\n');
+};
+
+const envelope = (reports, exit, stderr) => {
+  const status = exit === null || exit === undefined ? 1 : exit;
+  const ok = status === 0;
+  const items = [];
+  for (const item of reports) {
+    items.push(report(item.tool, { ...item, ok }));
+  }
+  return { ok, exit: status, reports: items, stderr: stderr || '' };
+};
+
+module.exports = {
+  summary,
+  problem,
+  report,
+  userTrace,
+  groupReport,
+  reduceStderr,
+  shortTail,
+  envelope,
+};

package/lib/report-parse.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { stripAnsi } = require('./ansi.js');
+const model = require('./report-model.js');
+const testParse = require('./report-test.js');
+const toolParse = require('./report-tools.js');
+
+const { problem, report, groupReport } = model;
+const { reduceStderr, shortTail, envelope } = model;
+const { parseTap, parseNodeJsonl, parseTestJson, parseSpec } = testParse;
+const { parseToolJson, parseToolText } = toolParse;
+
+const KNOWN = new Set([
+  'test',
+  'tsc',
+  'eslint',
+  'prettier',
+  'audit',
+  'outdated',
+  'ls',
+]);
+
+const toolHint = (program, args) => {
+  const name = `${program ?? ''}`.split(/[/\\]/).pop();
+  const list = args || [];
+  const joined = [name, ...list].join(' ');
+  if (name === 'eslint') return 'eslint';
+  if (name === 'tsc') return 'tsc';
+  if (name === 'prettier') return 'prettier';
+  if (/\baudit\b/.test(joined)) return 'audit';
+  if (/\boutdated\b/.test(joined)) return 'outdated';
+  if (name === 'npm' || name === 'pnpm' || name === 'npm.cmd') {
+    if (/\b(ls|list)\b/.test(joined)) return 'ls';
+  }
+  if (name === 'node' && (args || []).includes('--test')) return 'test';
+  return '';
+};
+
+const parseJson = (text) => {
+  const trimmed = `${text ?? ''}`.trim();
+  if (!trimmed || (trimmed[0] !== '{' && trimmed[0] !== '[')) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+};
+
+const parseJsonReports = (text, root) => {
+  const node = parseNodeJsonl(text, root);
+  if (node) return [node];
+  const data = parseJson(text);
+  if (!data) return null;
+  const test = parseTestJson(data, root);
+  if (test) return [test];
+  const tools = parseToolJson(data, root);
+  if (tools) return tools;
+  return [];
+};
+
+const parseReports = (text, root) => {
+  const json = parseJsonReports(text, root);
+  if (json) return json;
+  const reports = [];
+  const tap = parseTap(text, root);
+  if (tap) reports.push(tap);
+  const tools = parseToolText(text, root);
+  for (const item of tools) reports.push(item);
+  if (!tap) {
+    const spec = parseSpec(text, root);
+    if (spec) reports.push(spec);
+  }
+  return reports;
+};
+
+const withHint = (reports, text, exit, hint) => {
+  if (reports.length || !`${text ?? ''}`.trim() || exit === 0) return reports;
+  const tool = KNOWN.has(hint) ? hint : 'test';
+  return [report(tool, { problems: [problem({ message: shortTail(text) })] })];
+};
+
+const buildDocument = (stdout, stderr, root, exit, hint) => {
+  const text = stripAnsi(stdout);
+  const reports = withHint(parseReports(text, root), text, exit, hint);
+  const grouped = [];
+  for (const item of reports) grouped.push(groupReport(item));
+  return envelope(grouped, exit, reduceStderr(stderr, root));
+};
+
+module.exports = {
+  toolHint,
+  parseReports,
+  buildDocument,
+};