reslop 0.2.5 → 0.2.7

package/lib/render/tiles.js

@@ -0,0 +1,355 @@
+'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,
+  bg: null,
+});
+
+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,
+  dep: THEME.pkgDepFg,
+  dev: THEME.pkgDevFg,
+  pkg: THEME.pkgFg,
+  chain: THEME.pkgChainFg,
+  heat: THEME.heatFg,
+  blink: THEME.heatBlinkFg,
+  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) {
+    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);
+};
+
+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 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 = headBg;
+  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, backs) => {
+  if (filled && index % 2 === 1) return backs.row;
+  return backs.tile;
+};
+
+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, shade.head)];
+  const bodyRoom = footer ? height - 2 : height - 1;
+  for (let i = 0; i < bodyRoom; i++) {
+    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, shade);
+    const paintRow = content.footerFlush ? paintFlushRight : paintFramed;
+    rows.push(paintRow(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 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) {
+    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,
+  equalGrid,
+  pageWindow,
+  placeEqualTiles,
+  paintSegments,
+  paintTile,
+  composeBands,
+  tileHits,
+  pageFill,
+};

package/lib/render/unit.js

@@ -1,47 +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, codeEditHits } = diff;
-const { 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);
-  const editHits = editing ? codeEditHits(source, false, width, scrollCol) : [];
-  return paneResult({
-    body,
-    cursor,
-    editHits,
+  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,
 };