reslop 0.2.5 → 0.2.6

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,
 };

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,40 +41,64 @@ 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 = {

package/lib/report-render.js

@@ -1,78 +1,111 @@
 'use strict';
 
+const utilities = require('./utilities.js');
+const { unquote } = utilities;
+
 const NOTICE_HEAD =
   'reslop: reduced output; passing results are omitted ' +
   'and similar problems are grouped';
 
-const NOTICE = [
-  NOTICE_HEAD,
-  'If reduced output hides information needed for debugging,',
-  'rerun the same command with RESLOP_OUTPUT=raw.',
-].join('\n');
+const notice = (rawFile) => {
+  const target = rawFile
+    ? `the raw log \`.log/${rawFile}\``
+    : 'the matching raw log under `.log/`';
+  const hint = `Agent: if this report hides a needed detail, read ${target}.`;
+  return `${NOTICE_HEAD}\n${hint}`;
+};
 
-const SUMMARY_ROWS = 6;
-const PROBLEM_FIELDS = 7;
+const addRow = (rows, key, value) => {
+  if (value === null || value === undefined || value === '') return;
+  rows.push([key, `${value}`]);
+};
 
-const writeRow = (rows, index, key, value) => {
-  if (value === null || value === undefined || value === '') return index;
-  rows[index] = [key, `${value}`];
-  return index + 1;
+const isComparison = (line) => {
+  const match = /^(.*) (?:!==|===|!=|==) (\S.*)$/.exec(line.trim());
+  return !!match && match[1].trim() !== '';
 };
 
-const summaryRows = (stats) => {
-  const rows = new Array(SUMMARY_ROWS);
-  let index = 0;
-  index = writeRow(rows, index, 'passed', stats.passed);
-  index = writeRow(rows, index, 'failed', stats.failed);
-  index = writeRow(rows, index, 'skipped', stats.skipped);
-  index = writeRow(rows, index, 'errors', stats.errors);
-  index = writeRow(rows, index, 'warnings', stats.warnings);
-  index = writeRow(rows, index, 'duration', stats.duration);
-  rows.length = index;
-  return rows;
+const isDiffHeader = (line) => {
+  const text = line.trim().replace(/^[+-]\s*/, '');
+  return /^actual\s+[+-]?\s*expected$/.test(text);
 };
 
-const problemRows = (item) => {
-  const extra = item.extra;
-  let size = PROBLEM_FIELDS + extra.length;
-  if (item.count > 1) size += 1;
-  if (item.omitted > 0) size += 1;
-  const rows = new Array(size);
-  let index = 0;
-  index = writeRow(rows, index, 'severity', item.severity);
-  index = writeRow(rows, index, 'duration', item.duration);
-  index = writeRow(rows, index, 'code', item.code);
-  index = writeRow(rows, index, 'operator', item.operator);
-  index = writeRow(rows, index, 'expected', item.expected);
-  index = writeRow(rows, index, 'actual', item.actual);
-  index = writeRow(rows, index, 'message', item.message);
-  for (let i = 0; i < extra.length; i++) {
-    const pair = extra[i];
-    index = writeRow(rows, index, pair[0], pair[1]);
+const isMarkedDiff = (line) => /^[+-](?:\s|$)/.test(line.trim());
+
+const sameValue = (line, value) => {
+  if (!value) return false;
+  const text = line.trim();
+  return text === value || unquote(text) === value;
+};
+
+const startsDiff = (line, item) =>
+  isComparison(line) ||
+  isDiffHeader(line) ||
+  isMarkedDiff(line) ||
+  sameValue(line, item.expected) ||
+  sameValue(line, item.actual);
+
+const displayMessage = (item) => {
+  const values = item.expected !== '' || item.actual !== '';
+  const lines = [];
+  for (const line of `${item.message}`.split('\n')) {
+    if (line.trim() === '') continue;
+    if (values && startsDiff(line, item)) break;
+    lines.push(line);
   }
-  if (item.count > 1) index = writeRow(rows, index, 'count', item.count);
-  if (item.omitted > 0) {
-    index = writeRow(rows, index, 'omitted', item.omitted);
+  if (lines.length && lines[0].trimEnd().endsWith(':')) {
+    lines[0] = lines[0].trimEnd().slice(0, -1);
   }
-  rows.length = index;
+  if (lines.length && lines[0].trim() === '') lines.shift();
+  return lines.join('\n');
+};
+
+const summaryRows = (stats) => {
+  const rows = [];
+  addRow(rows, 'passed', stats.passed);
+  addRow(rows, 'failed', stats.failed);
+  addRow(rows, 'skipped', stats.skipped);
+  addRow(rows, 'errors', stats.errors);
+  addRow(rows, 'warnings', stats.warnings);
+  addRow(rows, 'duration', stats.duration);
   return rows;
 };
 
-const markdownValue = (value) => {
-  const text = `${value}`;
-  if (!text.includes('\n')) return text;
-  return `\n${text}`;
+const problemRows = (item) => {
+  const rows = [];
+  if (item.severity !== 'error') addRow(rows, 'severity', item.severity);
+  addRow(rows, 'duration', item.duration);
+  addRow(rows, 'code', item.code);
+  addRow(rows, 'operator', item.operator);
+  addRow(rows, 'expected', item.expected);
+  addRow(rows, 'actual', item.actual);
+  for (const pair of item.extra) addRow(rows, pair[0], pair[1]);
+  if (item.count > 1) addRow(rows, 'count', item.count);
+  if (item.omitted > 0) addRow(rows, 'omitted', item.omitted);
+  return rows;
 };
 
+const prefixLines = (prefix, text) =>
+  `${text}`
+    .replace(/\n+$/, '')
+    .split('\n')
+    .map((line) => `${prefix}${line}`);
+
+const quoteLines = (text) => prefixLines('│ ', text);
+
 const markdownProblem = (item) => {
   const title = item.name || item.message || item.code || 'problem';
   const lines = ['', `## ${title}`, ''];
   for (const row of problemRows(item)) {
-    lines.push(`- ${row[0]}: ${markdownValue(row[1])}`);
+    const value = row[1].includes('\n') ? `\n${row[1]}` : row[1];
+    lines.push(`- ${row[0]}: ${value}`);
   }
-  for (const trace of item.traces) {
-    if (!trace) continue;
-    lines.push(`- trace:\n${trace}`);
+  const message = displayMessage(item);
+  if (message) lines.push('', ...prefixLines('> ', message), '');
+  if (item.trace) lines.push(`- trace:\n${item.trace}`);
+  if (item.related.length) {
+    lines.push('- related:');
+    for (const row of item.related) lines.push(`  - ${row}`);
   }
   return lines;
 };
@@ -82,23 +115,33 @@ const markdownReport = (item) => {
   for (const row of summaryRows(item.summary)) {
     lines.push(`${row[0]}: ${row[1]}`);
   }
-  for (const problem of item.problems) {
-    lines.push(...markdownProblem(problem));
-  }
+  for (const entry of item.problems) lines.push(...markdownProblem(entry));
   return lines;
 };
 
-const renderMarkdown = (doc) => {
-  const lines = [NOTICE, '', `exit: ${doc.exit}`];
+const renderDocument = (doc, rawFile) => {
+  const lines = [notice(rawFile)];
   for (const item of doc.reports) lines.push(...markdownReport(item));
   if (doc.stderr) lines.push('', '# stderr', '', doc.stderr);
+  lines.push('', `exit: ${doc.exit}`);
   return `${lines.join('\n').replace(/\n+$/, '')}\n`;
 };
 
-const renderDocument = (doc) => renderMarkdown(doc);
+const loggedText = (text, rawFile) => {
+  const body = `${text ?? ''}`;
+  if (body.startsWith(NOTICE_HEAD)) return body;
+  const head = notice(rawFile);
+  if (!body.trim()) return `${head}\n`;
+  return `${head}\n\n${body}`;
+};
 
 module.exports = {
-  NOTICE,
-  renderMarkdown,
+  NOTICE_HEAD,
+  notice,
+  summaryRows,
+  problemRows,
+  displayMessage,
+  quoteLines,
+  loggedText,
   renderDocument,
 };