reslop 0.2.5 → 0.2.7

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

package/lib/report-run.js

@@ -7,20 +7,16 @@ const { spawn } = childProcess;
 const utilities = require('./utilities.js');
 const { spawnBase } = utilities;
 const npmCommands = require('./npm-commands.js');
-const { writeLog } = npmCommands;
+const { nextLogFile, saveLogs } = npmCommands;
 const reportParse = require('./report-parse.js');
 const { toolHint, buildDocument } = reportParse;
 const reportRender = require('./report-render.js');
 const { renderDocument } = reportRender;
+const runs = require('./runs.js');
+const { RunRecorder, commandLabel, summarizeDocument } = runs;
 
-const OUTPUTS = new Set(['md', 'raw']);
-
-const outputMode = (env) => {
-  const value = env.RESLOP_OUTPUT;
-  if (value) return OUTPUTS.has(value) ? value : '';
-  return 'md';
-};
-
+const OUTPUTS = ['md', 'raw'];
+const PIPE = ['ignore', 'pipe', 'pipe'];
 const CMD_SAFE = /^[\w./:=@+-]+$/;
 
 const quoteCmdArg = (arg) => {
@@ -35,34 +31,18 @@ const winCommand = (program, args) => {
   return `"${parts.join(' ')}"`;
 };
 
-const spawnCommand = (program, args, options) => {
-  const { cwd, env, stdio } = options;
-  const base = { cwd, env, stdio };
+const spawnCommand = (command, options) => {
+  const { program, args } = command;
   if (process.platform !== 'win32') {
-    return spawn(program, args, spawnBase(base));
+    return spawn(program, args, spawnBase(options));
   }
-  const command = winCommand(program, args);
   const shell = process.env.comspec || 'cmd.exe';
-  return spawn(
-    shell,
-    ['/d', '/s', '/c', command],
-    spawnBase({ ...base, windowsVerbatimArguments: true }),
-  );
+  const line = winCommand(program, args);
+  const opts = spawnBase({ ...options, windowsVerbatimArguments: true });
+  return spawn(shell, ['/d', '/s', '/c', line], opts);
 };
 
-const waitStatus = (child) =>
-  new Promise((resolve) => {
-    let settled = false;
-    const finish = (status) => {
-      if (settled) return;
-      settled = true;
-      resolve(status);
-    };
-    child.on('error', () => finish(1));
-    child.on('close', (status) => finish(status === null ? 1 : status));
-  });
-
-const collect = (child) =>
+const collect = (child, onOut, onErr) =>
   new Promise((resolve) => {
     let out = '';
     let err = '';
@@ -76,89 +56,119 @@ const collect = (child) =>
       child.stdout.setEncoding('utf8');
       child.stdout.on('data', (chunk) => {
         out += chunk;
+        if (onOut) onOut(chunk);
       });
     }
     if (child.stderr) {
       child.stderr.setEncoding('utf8');
       child.stderr.on('data', (chunk) => {
         err += chunk;
+        if (onErr) onErr(chunk);
       });
     }
     child.on('error', (error) => {
       err += `${error.message}\n`;
       finish(1);
     });
-    child.on('close', (status) => finish(status === null ? 1 : status));
+    child.on('close', (status) => finish(status ?? 1));
   });
 
-const commandArgs = (argv) => {
-  if (argv[0] !== 't' || argv[1] !== '--' || !argv[2]) return null;
-  return { program: argv[2], args: argv.slice(3) };
+const beginRun = (cwd, command) =>
+  new RunRecorder(cwd, commandLabel(command.program, command.args));
+
+const documentOf = (command, result, cwd) => {
+  const hint = toolHint(command.program, command.args);
+  const { stdout, stderr, status } = result;
+  return buildDocument(stdout, stderr, cwd, status, hint);
 };
 
-const usage = (stderr) => {
-  stderr.write('reslop: missing command\n');
-  stderr.write('Usage: reslop t -- <program> [args]\n');
-  return 1;
+const rawStreams = (stdout, stderr) => {
+  if (!stderr.trim()) return stdout;
+  const lead = stdout.endsWith('\n') || !stdout ? stdout : `${stdout}\n`;
+  return `${lead}# stderr\n${stderr}`;
 };
 
-const runInherit = async (spawnFn, program, args, options) => {
-  let child;
+const runInherit = async (command, cwd, env) => {
   try {
-    child = spawnFn(program, args, { ...options, stdio: 'inherit' });
+    const child = spawnCommand(command, { cwd, env, stdio: 'inherit' });
+    return (await collect(child)).status;
   } catch {
     return 1;
   }
-  return waitStatus(child);
 };
 
-const runCapture = async (proc, deps = {}) => {
-  const env = proc.env || {};
-  const argv = proc.argv.slice(2);
-  const command = commandArgs(argv);
-  if (!command) return usage(proc.stderr);
-  const mode = outputMode(env);
-  if (!mode) {
-    proc.stderr.write(`reslop: unknown RESLOP_OUTPUT ${env.RESLOP_OUTPUT}\n`);
+const runRaw = async (proc, command, cwd, env) => {
+  const recorder = beginRun(cwd, command);
+  let child;
+  try {
+    child = spawnCommand(command, { cwd, env, stdio: PIPE });
+  } catch {
+    recorder.finish(1);
     return 1;
   }
-  const cwd = deps.cwd ? deps.cwd : proc.cwd();
-  const spawnFn = deps.spawn || spawnCommand;
-  const capture = env.RESLOP_CAPTURE === '1';
-  if (mode === 'raw' || capture) {
-    return runInherit(spawnFn, command.program, command.args, { cwd, env });
-  }
-  const childEnv = { ...env, RESLOP_CAPTURE: '1' };
+  const onOut = (chunk) => {
+    proc.stdout.write(chunk);
+    recorder.feed(chunk);
+  };
+  const onErr = (chunk) => proc.stderr.write(chunk);
+  const result = await collect(child, onOut, onErr);
+  const doc = documentOf(command, result, cwd);
+  recorder.finish(result.status, summarizeDocument(doc));
+  return result.status;
+};
+
+const runReport = async (proc, command, cwd, env) => {
+  const recorder = beginRun(cwd, command);
+  const fail = (error) => proc.stderr.write(`reslop: ${error.message}\n`);
   let child;
   try {
-    child = spawnFn(command.program, command.args, {
-      cwd,
-      env: childEnv,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const childEnv = { ...env, RESLOP_CAPTURE: '1' };
+    child = spawnCommand(command, { cwd, env: childEnv, stdio: PIPE });
   } catch (error) {
-    proc.stderr.write(`reslop: ${error.message}\n`);
+    fail(error);
+    recorder.finish(1);
     return 1;
   }
-  const result = await collect(child);
-  const hint = toolHint(command.program, command.args);
-  const doc = buildDocument(
-    result.stdout,
-    result.stderr,
-    cwd,
-    result.status,
-    hint,
-  );
-  const text = renderDocument(doc);
+  const result = await collect(child, (chunk) => recorder.feed(chunk));
+  const doc = documentOf(command, result, cwd);
+  let slot = null;
+  try {
+    slot = nextLogFile(cwd, path.basename(command.program));
+  } catch (error) {
+    fail(error);
+  }
+  const text = renderDocument(doc, slot ? slot.rawName : '');
+  recorder.finish(result.status, summarizeDocument(doc));
   proc.stdout.write(text);
+  if (!slot) return result.status;
   try {
-    writeLog(cwd, path.basename(command.program), text);
+    await saveLogs(slot, text, rawStreams(result.stdout, result.stderr));
   } catch (error) {
-    proc.stderr.write(`reslop: ${error.message}\n`);
+    fail(error);
   }
   return result.status;
 };
 
+const runCapture = async (proc, deps = {}) => {
+  const argv = proc.argv.slice(2);
+  if (argv[1] !== '--' || !argv[2]) {
+    proc.stderr.write('reslop: missing command\n');
+    proc.stderr.write('Usage: reslop t -- <program> [args]\n');
+    return 1;
+  }
+  const command = { program: argv[2], args: argv.slice(3) };
+  const env = proc.env ?? {};
+  const mode = env.RESLOP_OUTPUT || 'md';
+  if (!OUTPUTS.includes(mode)) {
+    proc.stderr.write(`reslop: unknown RESLOP_OUTPUT ${env.RESLOP_OUTPUT}\n`);
+    return 1;
+  }
+  const cwd = deps.cwd ?? proc.cwd();
+  if (env.RESLOP_CAPTURE === '1') return runInherit(command, cwd, env);
+  if (mode === 'raw') return runRaw(proc, command, cwd, env);
+  return runReport(proc, command, cwd, env);
+};
+
 module.exports = {
   winCommand,
   runCapture,