reslop 0.2.4 → 0.2.6

package/lib/render/tiles.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const ansi = require('../ansi.js');
+const { THEME, paint, visibleWidth, truncateVisible } = ansi;
+
+const GAP_X = 2;
+const GAP_Y = 1;
+const MIN_W = 34;
+const MIN_H = 6;
+const MAX_COLS = 4;
+const RULE = '─';
+const ELLIPSIS = '…';
+const BAR_ON = '█';
+const BAR_OFF = '░';
+const SPARK = '▁▂▃▄▅▆▇█';
+const SPINNER = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
+
+const seg = (text, tone = 'text', bold = false) => ({
+  text: `${text}`,
+  tone,
+  bold,
+});
+
+const toneColors = () => ({
+  text: THEME.chromeFg,
+  muted: THEME.mutedFg,
+  hot: THEME.buttonHotFg,
+  add: THEME.addLineFg,
+  del: THEME.delLineFg,
+  warn: THEME.warnFg,
+  error: THEME.errorFg,
+  sha: THEME.shaFg,
+  trend: THEME.dashTrendFg,
+  key: THEME.dashKeyFg,
+});
+
+const headColors = () => ({
+  ...toneColors(),
+  muted: THEME.dashHeadMuted,
+  del: THEME.dashDelFg,
+});
+
+const segmentsWidth = (segs) => {
+  let width = 0;
+  for (const item of segs) width += visibleWidth(item.text);
+  return width;
+};
+
+const clipSegments = (segs, width) => {
+  if (segmentsWidth(segs) <= width) {
+    return segs.map((item) => ({ ...item }));
+  }
+  const markW = visibleWidth(ELLIPSIS);
+  const budget = markW <= width ? width - markW : width;
+  const out = [];
+  let used = 0;
+  for (const item of segs) {
+    const room = budget - used;
+    if (room <= 0) break;
+    const text = truncateVisible(item.text, room);
+    if (!text) continue;
+    used += visibleWidth(text);
+    out.push({ ...item, text });
+    if (visibleWidth(text) < visibleWidth(item.text)) break;
+  }
+  if (markW > width) return out;
+  if (!out.length) return [seg(ELLIPSIS)];
+  out[out.length - 1].text += ELLIPSIS;
+  return out;
+};
+
+const paintSegments = (segs, width, bg, color, fill = ' ', colors = null) => {
+  const clipped = clipSegments(segs, width);
+  const pad = Math.max(0, width - segmentsWidth(clipped));
+  const ink = colors ?? toneColors();
+  if (!color) {
+    return clipped.map((item) => item.text).join('') + fill.repeat(pad);
+  }
+  let out = '';
+  for (const item of clipped) {
+    out += paint(item.text, ink[item.tone], bg, color, item.bold);
+  }
+  return out + paint(fill.repeat(pad), ink.muted, bg, color);
+};
+
+const barSegments = (ratio, width, tone = 'add') => {
+  const clamped = Math.min(1, Math.max(0, Number.isFinite(ratio) ? ratio : 0));
+  const on = Math.round(clamped * width);
+  return [
+    seg(BAR_ON.repeat(on), tone),
+    seg(BAR_OFF.repeat(width - on), 'muted'),
+  ];
+};
+
+const sparkline = (values, width) => {
+  const count = values.length;
+  if (!count || width < 1) return '';
+  const max = Math.max(...values);
+  const top = SPARK.length - 1;
+  let out = '';
+  for (let i = 0; i < width; i++) {
+    const span = width <= 1 ? count - 1 : (i * (count - 1)) / (width - 1);
+    const at = Math.round(span);
+    const level = max > 0 ? Math.round((values[at] / max) * top) : 0;
+    out += SPARK[level];
+  }
+  return out;
+};
+
+const spinner = (frame) => SPINNER[Math.abs(frame ?? 0) % SPINNER.length];
+
+const spread = (total, parts) => {
+  const base = Math.floor(total / parts);
+  const extra = total % parts;
+  return Array.from({ length: parts }, (_, i) => base + (i < extra ? 1 : 0));
+};
+
+const placeBand = (shown, from, size, width) => {
+  const room = Math.max(0, width - (size - 1) * GAP_X);
+  const widths = spread(room, size);
+  const tiles = [];
+  let x = 0;
+  for (let i = 0; i < size; i++) {
+    tiles.push({ id: shown[from + i].id, x, w: widths[i] });
+    x += widths[i] + GAP_X;
+  }
+  return tiles;
+};
+
+const placeTiles = (shown, cols, width, height) => {
+  const rows = Math.ceil(shown.length / cols);
+  const sizes = spread(shown.length, rows);
+  const heights = spread(height - (rows - 1) * GAP_Y, rows);
+  const bands = [];
+  let from = 0;
+  let y = 0;
+  for (let row = 0; row < rows; row++) {
+    const tiles = placeBand(shown, from, sizes[row], width);
+    bands.push({ y, h: Math.max(1, heights[row]), tiles });
+    from += sizes[row];
+    y += heights[row] + GAP_Y;
+  }
+  return bands;
+};
+
+const layoutTiles = (width, height, tiles) => {
+  const cap = Math.floor((width + GAP_X) / (MIN_W + GAP_X));
+  const maxCols = Math.max(1, Math.min(MAX_COLS, cap));
+  const ranked = [...tiles].sort((left, right) => left.rank - right.rank);
+  for (let count = tiles.length; count >= 1; count--) {
+    const keep = new Set(ranked.slice(0, count).map((tile) => tile.id));
+    const shown = tiles.filter((tile) => keep.has(tile.id));
+    const cols = Math.min(maxCols, count);
+    const rows = Math.ceil(count / cols);
+    const rowH = Math.floor((height - (rows - 1) * GAP_Y) / rows);
+    if (rowH >= MIN_H || count === 1) {
+      return placeTiles(shown, cols, width, height);
+    }
+  }
+  return [];
+};
+
+const titleSegments = (tile, badge = []) => {
+  const keyed = tile.title.startsWith(tile.key);
+  const rest = keyed ? tile.title.slice(tile.key.length) : ` ${tile.title}`;
+  const segs = [seg(tile.key, 'key', true), seg(rest)];
+  return badge.length ? [...segs, seg(' '), ...badge] : segs;
+};
+
+const paintFramed = (line, width, bg, color, fill = ' ', colors = null) => {
+  const edge = paintSegments([seg(' ')], 1, bg, color);
+  const inner = Math.max(0, width - 2);
+  return edge + paintSegments(line, inner, bg, color, fill, colors) + edge;
+};
+
+const paintHead = (tile, content, width, color) => {
+  const fill = color ? ' ' : RULE;
+  const bg = THEME.dashHeadBg;
+  const colors = headColors();
+  if (content.titleLine) {
+    return paintFramed(content.titleLine, width, bg, color, fill, colors);
+  }
+  const segs = [seg(' '), ...titleSegments(tile, content.badge)];
+  return paintSegments(segs, width, bg, color, fill, colors);
+};
+
+const rowBackground = (index, filled) => {
+  if (filled && index % 2 === 1) return THEME.dashRowBg;
+  return THEME.dashTileBg;
+};
+
+const paintTile = (tile, content, width, height, color) => {
+  const { lines, footer } = content;
+  const rows = [paintHead(tile, content, width, color)];
+  const bodyRoom = footer ? height - 2 : height - 1;
+  for (let i = 0; i < bodyRoom; i++) {
+    const bg = rowBackground(i, i < lines.length);
+    rows.push(paintFramed(lines[i] ?? [], width, bg, color));
+  }
+  if (footer && height > 1) {
+    const bg = rowBackground(bodyRoom, true);
+    rows.push(paintFramed(footer, width, bg, color));
+  }
+  return rows;
+};
+
+const pageFill = (width, color) =>
+  paint(' '.repeat(Math.max(0, width)), THEME.chromeFg, THEME.dashBg, color);
+
+const composeBands = (bands, painted, width, height, color) => {
+  const rows = [];
+  const blank = pageFill(width, color);
+  for (const band of bands) {
+    if (rows.length) {
+      for (let gap = 0; gap < GAP_Y; gap++) rows.push(blank);
+    }
+    const last = band.tiles.at(-1);
+    const rest = pageFill(width - last.x - last.w, color);
+    for (let line = 0; line < band.h; line++) {
+      let row = '';
+      for (let i = 0; i < band.tiles.length; i++) {
+        if (i) row += pageFill(GAP_X, color);
+        row += painted.get(band.tiles[i].id)[line];
+      }
+      rows.push(row + rest);
+    }
+  }
+  while (rows.length < height) rows.push(blank);
+  return rows.slice(0, height);
+};
+
+const tileHits = (bands, headerLines) => {
+  const hits = [];
+  for (const band of bands) {
+    for (const tile of band.tiles) {
+      for (let line = 0; line < band.h; line++) {
+        const y = headerLines + band.y + line + 1;
+        hits.push({ y, x0: tile.x, x1: tile.x + tile.w, cursor: tile.id });
+      }
+    }
+  }
+  return hits;
+};
+
+module.exports = {
+  GAP_X,
+  GAP_Y,
+  seg,
+  segmentsWidth,
+  clipSegments,
+  barSegments,
+  sparkline,
+  spinner,
+  titleSegments,
+  layoutTiles,
+  paintTile,
+  composeBands,
+  tileHits,
+  pageFill,
+};

package/lib/render/unit.js

@@ -1,44 +1,31 @@
 'use strict';
 
 const detect = require('../detect.js');
-const { detectLang } = detect;
+const diffLib = require('../diff/diff.js');
 const primitives = require('./primitives.js');
 const diff = require('./diff.js');
 
-const { paneResult } = primitives;
-const { paintDiffLine, codeCursorInRows, expandSoftRows } = diff;
-const diffLib = require('../diff/diff.js');
+const { detectLang } = detect;
 const { sameHunk } = diffLib;
+const { paneResult } = primitives;
+const { paintDiffLine, expandSoftRows, codeHits } = diff;
 
 const paintBodyUnit = (view, width, color) => {
-  const lines = view.unitLines ?? [];
-  const item = view.item;
+  const { item, codeOverlay: overlay } = view;
   const lang = detectLang(view.reviewPath ?? '');
-  const overlay = view.codeOverlay;
   const editing =
-    view.mode === 'compose' && overlay && typeof overlay.cursor === 'number';
-  const picked = editing ? overlay.scrollCol : 0;
-  const scrollCol = picked ?? 0;
+    view.mode === 'compose' && typeof overlay?.cursor === 'number';
+  const scrollCol = (editing ? overlay.scrollCol : 0) ?? 0;
+  const lines = view.unitLines ?? [];
   const source = editing ? lines : expandSoftRows(lines, width, false, true);
-  const { length } = source;
-  const body = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const line = source[i];
-    const isBlock = item && sameHunk(line.item, item);
-    const row = { ...line };
-    if (editing) {
-      row.mark = ' ';
-    } else if ((row.type === 'add' || row.type === 'del') && !isBlock) {
-      row.mark = ' ';
-    }
-    body[i] = paintDiffLine(row, width, color, row.origin, lang, scrollCol);
-  }
-  const edit = overlay ? overlay.cursor : null;
-  const cursor = codeCursorInRows(source, false, width, edit, scrollCol);
-  return paneResult({
-    body,
-    cursor,
+  const body = source.map((line) => {
+    const changed = line.type === 'add' || line.type === 'del';
+    const outside = changed && !(item && sameHunk(line.item, item));
+    const row = editing || outside ? { ...line, mark: ' ' } : line;
+    return paintDiffLine(row, width, color, row.origin, lang, scrollCol);
   });
+  const hits = codeHits(source, false, width, overlay, editing, scrollCol);
+  return paneResult({ body, ...hits });
 };
 
 module.exports = { paintBodyUnit };

package/lib/report-model.js

@@ -4,7 +4,7 @@ const ansi = require('./ansi.js');
 const { stripAnsi } = ansi;
 const commands = require('./npm-commands.js');
 
-const { withoutNodeFrame, indentStack, relativize } = commands;
+const { traceLine, relativize } = commands;
 
 const summary = () => ({
   tests: null,
@@ -23,8 +23,10 @@ const problem = (fields = {}) => {
     severity: fields.severity || 'error',
     name: fields.name || '',
     message: fields.message || '',
+    key: fields.key || '',
     trace,
     traces,
+    related: fields.related || [],
     duration: fields.duration || '',
     code: fields.code || '',
     operator: fields.operator || '',
@@ -44,15 +46,16 @@ const report = (tool, fields = {}) => ({
 });
 
 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());
+  for (const line of stripAnsi(`${text ?? ''}`).split(/\r?\n/)) {
+    const next = traceLine(line, root);
+    if (next !== null) kept.push(next.trimEnd());
   }
-  while (kept.length && kept[kept.length - 1] === '') kept.pop();
-  return kept.join('\n').trim();
+  let start = 0;
+  while (start < kept.length && kept[start].trim() === '') start += 1;
+  let end = kept.length;
+  while (end > start && kept[end - 1] === '') end -= 1;
+  return kept.slice(start, end).join('\n');
 };
 
 const normalizeMessage = (message) => {
@@ -60,33 +63,106 @@ const normalizeMessage = (message) => {
   return text.replace(/\s+\S+:\d+:\d+$/, '');
 };
 
-const groupKey = (item) =>
-  [
+// Build identity from raw diagnostics, before userTrace removes Node frames.
+const errorKey = (fields, stack, root) => {
+  const text = stripAnsi(fields.message || '');
+  const header = /^([\w.]*Error)(?: \[[^\]]+\])?:\s*/.exec(text);
+  const type = fields.type || (header ? header[1] : '');
+  const message = header ? text.slice(header[0].length) : text;
+  let origin = '';
+  for (const row of stripAnsi(stack).split(/\r?\n/)) {
+    const line = row.trim().replace(/^at\s+/, '');
+    if (/^[\w.]*Error(?: \[[^\]]+\])?:/.test(line)) continue;
+    if (line.includes('node:') || !/:\d+:\d+\)?$/.test(line)) continue;
+    const location = line.replace(/^.*\((.*:\d+:\d+)\)$/, '$1');
+    origin = relativize(location.replace(/file:\/\//g, ''), root).replace(
+      /\\/g,
+      '/',
+    );
+    break;
+  }
+  return JSON.stringify([
+    fields.severity || 'error',
+    type,
+    fields.code || '',
+    fields.operator || '',
+    message.replace(/\r\n/g, '\n').trim(),
+    fields.expected || '',
+    fields.actual || '',
+    origin,
+  ]);
+};
+
+const normalizeTrace = (trace) => {
+  if (!trace) return '';
+  return `${trace}`
+    .trim()
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.replace(/\\/g, '/').replace(/:\d+(?::\d+)?/g, ':X:Y'))
+    .join('\n');
+};
+
+const groupKey = (item) => {
+  if (item.key) return item.key;
+  const trace = normalizeTrace(item.trace);
+  return [
     item.severity,
     item.code,
     item.operator,
-    item.expected,
-    item.actual,
-    normalizeMessage(item.message),
+    trace || normalizeMessage(item.message),
   ].join('\0');
+};
+
+const relatedProblem = (item, group) => {
+  const frames = item.trace.split(/\r?\n/).map((line) => line.trim());
+  const sample = (group.traces[0] || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim());
+  let index = 0;
+  while (index < frames.length && frames[index] === sample[index]) index++;
+  if (index === frames.length && item.name === group.name) return '';
+  const rows = [item.name];
+  const branch = frames[index];
+  const last = frames.at(-1) || '';
+  let location = '';
+  if (/:\d+:\d+\)?$/.test(last)) {
+    const inner = last.replace(/^.*\((.*:\d+:\d+)\)$/, '$1');
+    location = inner.replace(/^at\s+/, '');
+  }
+  if (branch) {
+    let frame = branch.replace(/^at\s+/, '');
+    if (index === frames.length - 1 && location) frame = location;
+    rows.push(frame);
+  }
+  if (index < frames.length - 1 && location) rows.push(location);
+  return rows.filter(Boolean).join(' | ');
+};
 
 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 });
+      group = problem({ ...item, count: 0, traces: [], related: [] });
       groups.set(key, group);
-      order.push(group);
     }
     group.count += 1;
-    if (item.trace && group.traces.length < 3) group.traces.push(item.trace);
+    if (item.trace && !group.traces.length) {
+      group.traces.push(item.trace);
+    } else if (group.count > 1 && group.related.length < 2) {
+      const related = relatedProblem(item, group);
+      if (related && !group.related.includes(related)) {
+        group.related.push(related);
+      }
+    }
   }
+  const order = [...groups.values()];
   for (const group of order) {
     group.trace = group.traces[0] || '';
-    group.omitted = Math.max(0, group.count - group.traces.length);
+    group.omitted = Math.max(0, group.count - 1 - group.related.length);
   }
   return order;
 };
@@ -98,23 +174,25 @@ const groupReport = (item) =>
     problems: groupProblems(item.problems),
   });
 
-const reduceStderr = (text, root) => userTrace(text, root);
+const toolFailed = (item) => {
+  const stats = item.summary;
+  if (stats.failed || stats.errors) return true;
+  return item.problems.some((entry) => entry.severity !== 'warning');
+};
 
-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 keepReport = (item) => {
+  const stats = item.summary;
+  if (stats.tests || stats.passed || stats.failed || stats.skipped) return true;
+  return !!(stats.errors || stats.warnings) || item.problems.length > 0;
 };
 
 const envelope = (reports, exit, stderr) => {
-  const status = exit === null || exit === undefined ? 1 : exit;
-  const ok = status === 0;
-  const items = new Array(reports.length);
-  for (let i = 0; i < reports.length; i++) {
-    const item = reports[i];
-    items[i] = report(item.tool, { ...item, ok });
-  }
-  return { ok, exit: status, reports: items, stderr: stderr || '' };
+  const status = exit ?? 1;
+  const kept = reports.filter(keepReport);
+  const items = kept.map((item) =>
+    report(item.tool, { ...item, ok: !toolFailed(item) }),
+  );
+  return { ok: status === 0, exit: status, reports: items, stderr };
 };
 
 module.exports = {
@@ -122,8 +200,7 @@ module.exports = {
   problem,
   report,
   userTrace,
+  errorKey,
   groupReport,
-  reduceStderr,
-  shortTail,
   envelope,
 };

package/lib/report-parse.js

@@ -6,31 +6,26 @@ 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 { problem, report, userTrace, groupReport, envelope } = model;
 const { parseTap, parseNodeJsonl, parseTestJson, parseSpec } = testParse;
-const { parseToolJson, parseToolText } = toolParse;
+const { parseToolJson, parseToolText, stderrRest } = toolParse;
 
-const KNOWN = ['test', 'tsc', 'eslint', 'prettier', 'audit', 'outdated', 'ls'];
+const COUNTS = ['tests', 'passed', 'failed', 'skipped', 'errors', 'warnings'];
 
 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';
+  const name = program.split(/[/\\]/).pop();
+  const joined = [name, ...args].join(' ');
+  if (name === 'eslint' || name === 'tsc' || name === 'prettier') return name;
   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';
+  const isNpm = name === 'npm' || name === 'pnpm' || name === 'npm.cmd';
+  if (isNpm && /\b(ls|list)\b/.test(joined)) return 'ls';
+  if (name === 'node' && args.includes('--test')) return 'test';
   return '';
 };
 
 const parseJson = (text) => {
-  const trimmed = `${text ?? ''}`.trim();
+  const trimmed = text.trim();
   if (!trimmed || (trimmed[0] !== '{' && trimmed[0] !== '[')) return null;
   try {
     return JSON.parse(trimmed);
@@ -46,44 +41,67 @@ const parseJsonReports = (text, root) => {
   if (!data) return null;
   const test = parseTestJson(data, root);
   if (test) return [test];
-  const tools = parseToolJson(data, root);
-  if (tools) return tools;
-  return [];
+  return parseToolJson(data, root) || [];
 };
 
 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 spec = tap ? null : parseSpec(text, root);
+  const reports = [tap, ...parseToolText(text, root), spec];
+  return reports.filter(Boolean);
 };
 
+const shortTail = (text) => text.trim().split(/\r?\n/).slice(-20).join('\n');
+
 const withHint = (reports, text, exit, hint) => {
-  if (reports.length || !`${text ?? ''}`.trim() || exit === 0) return reports;
-  const tool = KNOWN.includes(hint) ? hint : 'test';
-  return [report(tool, { problems: [problem({ message: shortTail(text) })] })];
+  if (reports.length || !text.trim() || exit === 0) return reports;
+  const fallback = problem({ message: shortTail(text) });
+  return [report(hint || 'test', { problems: [fallback] })];
 };
 
-const buildDocument = (stdout, stderr, root, exit, hint) => {
-  const text = stripAnsi(stdout);
-  const reports = withHint(parseReports(text, root), text, exit, hint);
-  const grouped = new Array(reports.length);
-  for (let i = 0; i < reports.length; i++) {
-    grouped[i] = groupReport(reports[i]);
+const mergeSummary = (left, right) => {
+  const stats = { ...left };
+  for (const key of COUNTS) {
+    if (right[key] === null) continue;
+    stats[key] = (stats[key] ?? 0) + right[key];
+  }
+  if (!stats.duration && right.duration) stats.duration = right.duration;
+  return stats;
+};
+
+const mergeReports = (left, right) => {
+  const merged = left.slice();
+  for (const item of right) {
+    const at = merged.findIndex((entry) => entry.tool === item.tool);
+    if (at < 0) {
+      merged.push(item);
+      continue;
+    }
+    const prev = merged[at];
+    merged[at] = report(item.tool, {
+      summary: mergeSummary(prev.summary, item.summary),
+      problems: prev.problems.concat(item.problems),
+    });
   }
-  return envelope(grouped, exit, reduceStderr(stderr, root));
+  return merged;
+};
+
+const buildDocument = (stdout, stderr, root, exit, hint) => {
+  const out = stripAnsi(stdout);
+  const err = stripAnsi(stderr);
+  const reports = mergeReports(
+    parseReports(out, root),
+    parseReports(err, root),
+  );
+  const text = out.trim() ? out : err;
+  const grouped = withHint(reports, text, exit, hint).map(groupReport);
+  const rest = stderrRest(err, grouped);
+  return envelope(grouped, exit, userTrace(rest, root));
 };
 
 module.exports = {
   toolHint,
-  parseReports,
   buildDocument,
 };