reslop 0.2.0 → 0.2.3

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

package/lib/report-render.js

@@ -0,0 +1,87 @@
+'use strict';
+
+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 addRow = (rows, key, value) => {
+  if (value === null || value === undefined || value === '') return;
+  rows.push([key, `${value}`]);
+};
+
+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 problemRows = (item) => {
+  const rows = [];
+  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);
+  addRow(rows, 'message', item.message);
+  for (const extra of item.extra) addRow(rows, extra[0], extra[1]);
+  if (item.count > 1) addRow(rows, 'count', item.count);
+  if (item.omitted > 0) addRow(rows, 'omitted', item.omitted);
+  return rows;
+};
+
+const markdownValue = (value) => {
+  const text = `${value}`;
+  if (!text.includes('\n')) return text;
+  return `\n${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])}`);
+  }
+  for (const trace of item.traces) {
+    if (!trace) continue;
+    lines.push(`- trace:\n${trace}`);
+  }
+  return lines;
+};
+
+const markdownReport = (item) => {
+  const lines = ['', `# ${item.tool}`, '', `ok: ${item.ok}`];
+  for (const row of summaryRows(item.summary)) {
+    lines.push(`${row[0]}: ${row[1]}`);
+  }
+  for (const problem of item.problems) {
+    lines.push(...markdownProblem(problem));
+  }
+  return lines;
+};
+
+const renderMarkdown = (doc) => {
+  const lines = [NOTICE, '', `exit: ${doc.exit}`];
+  for (const item of doc.reports) lines.push(...markdownReport(item));
+  if (doc.stderr) lines.push('', '# stderr', '', doc.stderr);
+  return `${lines.join('\n').replace(/\n+$/, '')}\n`;
+};
+
+const renderDocument = (doc) => renderMarkdown(doc);
+
+module.exports = {
+  NOTICE,
+  renderMarkdown,
+  renderDocument,
+};

package/lib/report-run.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const { spawnBase } = require('./utilities.js');
+const { writeLog } = require('./npm-commands.js');
+const { toolHint, buildDocument } = require('./report-parse.js');
+const { renderDocument } = require('./report-render.js');
+
+const OUTPUTS = new Set(['md', 'raw']);
+
+const outputMode = (env) => {
+  const value = env.RESLOP_OUTPUT;
+  if (value) return OUTPUTS.has(value) ? value : '';
+  return 'md';
+};
+
+const CMD_SAFE = /^[\w./:=@+-]+$/;
+
+const quoteCmdArg = (arg) => {
+  const text = `${arg}`;
+  if (text && CMD_SAFE.test(text)) return text;
+  const escaped = text.replaceAll('"', '""').replaceAll('%', '"%"');
+  return `"${escaped}"`;
+};
+
+const winCommand = (program, args) => {
+  const parts = [program, ...args].map(quoteCmdArg);
+  return `"${parts.join(' ')}"`;
+};
+
+const spawnCommand = (program, args, options) => {
+  const base = {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: options.stdio,
+  };
+  if (process.platform !== 'win32') {
+    return spawn(program, args, spawnBase(base));
+  }
+  const command = winCommand(program, args);
+  const shell = process.env.comspec || 'cmd.exe';
+  return spawn(
+    shell,
+    ['/d', '/s', '/c', command],
+    spawnBase({ ...base, windowsVerbatimArguments: true }),
+  );
+};
+
+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) =>
+  new Promise((resolve) => {
+    let out = '';
+    let err = '';
+    let settled = false;
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      resolve({ status, stdout: out, stderr: err });
+    };
+    if (child.stdout) {
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => {
+        out += chunk;
+      });
+    }
+    if (child.stderr) {
+      child.stderr.setEncoding('utf8');
+      child.stderr.on('data', (chunk) => {
+        err += chunk;
+      });
+    }
+    child.on('error', (error) => {
+      err += `${error.message}\n`;
+      finish(1);
+    });
+    child.on('close', (status) => finish(status === null ? 1 : status));
+  });
+
+const commandArgs = (argv) => {
+  if (argv[0] !== 't' || argv[1] !== '--' || !argv[2]) return null;
+  return { program: argv[2], args: argv.slice(3) };
+};
+
+const usage = (stderr) => {
+  stderr.write('reslop: missing command\n');
+  stderr.write('Usage: reslop t -- <program> [args]\n');
+  return 1;
+};
+
+const runInherit = async (spawnFn, program, args, options) => {
+  let child;
+  try {
+    child = spawnFn(program, args, { ...options, stdio: 'inherit' });
+  } 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`);
+    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' };
+  let child;
+  try {
+    child = spawnFn(command.program, command.args, {
+      cwd,
+      env: childEnv,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (error) {
+    proc.stderr.write(`reslop: ${error.message}\n`);
+    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);
+  proc.stdout.write(text);
+  try {
+    writeLog(cwd, path.basename(command.program), text);
+  } catch (error) {
+    proc.stderr.write(`reslop: ${error.message}\n`);
+  }
+  return result.status;
+};
+
+module.exports = {
+  outputMode,
+  winCommand,
+  runCapture,
+};