reslop 0.2.7 → 0.3.1

package/lib/{report-render.js → report/render.js}

@@ -1,18 +1,14 @@
 'use strict';
 
-const utilities = require('./utilities.js');
-const { unquote } = utilities;
+const { unquote } = require('../common/utilities.js');
+const { formatTable } = require('../runs/output.js');
 
-const NOTICE_HEAD =
-  'reslop: reduced output; passing results are omitted ' +
-  'and similar problems are grouped';
+const NOTICE_HEAD = 'Reduced output;';
 
 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}`;
+  let target = 'under `.log/`';
+  if (rawFile) target = `\`.log/${rawFile}\``;
+  return `${NOTICE_HEAD} the raw log if needed ${target}.`;
 };
 
 const addRow = (rows, key, value) => {
@@ -38,12 +34,12 @@ const sameValue = (line, value) => {
   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 startsDiff = (line, item) => {
+  if (isComparison(line) || isDiffHeader(line)) return true;
+  if (isMarkedDiff(line)) return true;
+  if (sameValue(line, item.expected)) return true;
+  return sameValue(line, item.actual);
+};
 
 const displayMessage = (item) => {
   const values = item.expected !== '' || item.actual !== '';
@@ -135,13 +131,46 @@ const loggedText = (text, rawFile) => {
   return `${head}\n\n${body}`;
 };
 
+const reportProblem = (item) => {
+  const title = item.name || item.message || item.code || 'problem';
+  const mark = item.severity === 'warning' ? '△' : '✖';
+  const count = item.count > 1 ? `  × ${item.count}` : '';
+  const lines = ['', `${mark} ${title.split('\n')[0]}${count}`, ''];
+  lines.push(...formatTable(problemRows(item)));
+  const message = displayMessage(item);
+  if (message) lines.push('', ...quoteLines(message));
+  if (item.trace) {
+    lines.push('', 'Stack');
+    for (const row of item.trace.split(/\r?\n/)) {
+      const frame = row.trim().replace(/^at\s+/, '');
+      if (frame) lines.push(`  at ${frame}`);
+    }
+  }
+  if (item.related.length) {
+    lines.push('', 'Related failures');
+    for (const row of item.related) lines.push(`  ↳ ${row}`);
+  }
+  return lines;
+};
+
+const renderReport = (doc) => {
+  const lines = [];
+  for (const item of doc.reports) {
+    if (lines.length) lines.push('');
+    const mark = item.ok ? '✔' : '✖';
+    lines.push(`${mark} ${item.tool}  ·  exit ${doc.exit}`, '');
+    lines.push(...formatTable(summaryRows(item.summary)));
+    for (const entry of item.problems) lines.push(...reportProblem(entry));
+  }
+  if (doc.stderr) lines.push('', 'Stderr', doc.stderr);
+  return `${lines.join('\n')}\n`;
+};
+
 module.exports = {
   NOTICE_HEAD,
   notice,
-  summaryRows,
-  problemRows,
   displayMessage,
-  quoteLines,
   loggedText,
   renderDocument,
+  renderReport,
 };

package/lib/{report-run.js → report/run.js}

@@ -1,19 +1,18 @@
 'use strict';
 
 const path = require('node:path');
-const childProcess = require('node:child_process');
-const { spawn } = childProcess;
+const { spawn } = require('node:child_process');
 
-const utilities = require('./utilities.js');
-const { spawnBase } = utilities;
-const npmCommands = require('./npm-commands.js');
-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 { spawnBase } = require('../common/process.js');
+const { withNewline } = require('../common/utilities.js');
+const { nextLogFile, saveLogs } = require('../runs/logs.js');
+const { toolHint, buildDocument } = require('./parse.js');
+const { renderDocument } = require('./render.js');
+const {
+  RunRecorder,
+  commandLabel,
+  summarizeDocument,
+} = require('../runs/runs.js');
 
 const OUTPUTS = ['md', 'raw'];
 const PIPE = ['ignore', 'pipe', 'pipe'];
@@ -73,8 +72,16 @@ const collect = (child, onOut, onErr) =>
     child.on('close', (status) => finish(status ?? 1));
   });
 
-const beginRun = (cwd, command) =>
-  new RunRecorder(cwd, commandLabel(command.program, command.args));
+const beginRun = (cwd, command) => {
+  let slot = null;
+  try {
+    slot = nextLogFile(cwd, path.basename(command.program));
+  } catch {
+    // ignore errors
+  }
+  const label = commandLabel(command.program, command.args);
+  return new RunRecorder(cwd, label, { slot });
+};
 
 const documentOf = (command, result, cwd) => {
   const hint = toolHint(command.program, command.args);
@@ -84,7 +91,7 @@ const documentOf = (command, result, cwd) => {
 
 const rawStreams = (stdout, stderr) => {
   if (!stderr.trim()) return stdout;
-  const lead = stdout.endsWith('\n') || !stdout ? stdout : `${stdout}\n`;
+  const lead = withNewline(stdout);
   return `${lead}# stderr\n${stderr}`;
 };
 
@@ -99,44 +106,49 @@ const runInherit = async (command, cwd, env) => {
 
 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 onOut = (chunk) => {
     proc.stdout.write(chunk);
     recorder.feed(chunk);
   };
   const onErr = (chunk) => proc.stderr.write(chunk);
+  const childEnv = { ...env, RESLOP_CAPTURE: '1' };
+  let child = null;
+  try {
+    child = spawnCommand(command, { cwd, env: childEnv, stdio: PIPE });
+  } catch {
+    recorder.finish(1);
+  }
+  if (!child) return 1;
   const result = await collect(child, onOut, onErr);
   const doc = documentOf(command, result, cwd);
+  const slot = recorder.slot;
   recorder.finish(result.status, summarizeDocument(doc));
+  if (!slot) return result.status;
+  const text = renderDocument(doc, slot.rawName);
+  const raw = rawStreams(result.stdout, result.stderr);
+  try {
+    await saveLogs(slot, text, raw);
+  } catch {
+    // the record remains even if the log files cannot be written
+  }
   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;
+  let child = null;
   try {
     const childEnv = { ...env, RESLOP_CAPTURE: '1' };
     child = spawnCommand(command, { cwd, env: childEnv, stdio: PIPE });
   } catch (error) {
     fail(error);
     recorder.finish(1);
-    return 1;
   }
+  if (!child) return 1;
   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 slot = recorder.slot;
   const text = renderDocument(doc, slot ? slot.rawName : '');
   recorder.finish(result.status, summarizeDocument(doc));
   proc.stdout.write(text);

package/lib/{report-test.js → report/test.js}

@@ -1,10 +1,9 @@
 'use strict';
 
-const model = require('./report-model.js');
-const npmCommands = require('./npm-commands.js');
-const { isPassingTest } = npmCommands;
-const utilities = require('./utilities.js');
-const { unquote } = utilities;
+const { jsonParse } = require('metautil');
+const model = require('./model.js');
+const { isPassingTest } = require('../runs/output.js');
+const { unquote } = require('../common/utilities.js');
 
 const { summary, problem, report, userTrace, errorKey } = model;
 
@@ -75,57 +74,62 @@ const extraFrom = (fields) => {
   return extra;
 };
 
+const either = (...values) => values.find(Boolean) ?? values.at(-1);
+
+const defined = (...values) =>
+  values.find((value) => value !== null && value !== undefined);
+
+const errorParts = (map, parsed) => {
+  const raw = either(
+    map.get('error'),
+    map.get('message'),
+    parsed.get('message'),
+  );
+  const text = show(raw);
+  const header = ERROR_HEAD.exec(text);
+  const [lead, name, tag] = header ?? [];
+  return {
+    message: header ? text.slice(lead.length).trim() : text,
+    type: show(either(map.get('name'), name, parsed.get('name'))),
+    code: show(either(map.get('code'), tag, parsed.get('code'))),
+  };
+};
+
 const problemFromFields = (name, fields, root, fallback = '') => {
   const map = new Map(fields);
   const stack = show(map.get('stack'));
   const parsed = new Map(exceptionFields(stack.split(/\r?\n/)));
-  const text = show(
-    map.get('error') || map.get('message') || parsed.get('message'),
-  );
-  const header = ERROR_HEAD.exec(text);
-  const message = header ? text.slice(header[0].length).trim() : text;
-  const location = show(map.get('at') || map.get('location'));
-  const duration = show(map.get('duration_ms') || map.get('duration'));
-  const details = {
-    name,
-    message,
-    duration,
-    code: show(map.get('code') || (header && header[2]) || parsed.get('code')),
-    operator: show(map.get('operator')),
-    expected: show(
-      map.get('expected') ?? map.get('wanted') ?? map.get('expect'),
-    ),
-    actual: show(map.get('actual') ?? map.get('found') ?? map.get('got')),
-    extra: extraFrom(fields),
-  };
-  const type = show(
-    map.get('name') || (header && header[1]) || parsed.get('name'),
+  const { message, type, code } = errorParts(map, parsed);
+  const location = show(either(map.get('at'), map.get('location')));
+  const duration = show(either(map.get('duration_ms'), map.get('duration')));
+  const operator = show(map.get('operator'));
+  const wanted = defined(
+    map.get('expected'),
+    map.get('wanted'),
+    map.get('expect'),
   );
-  if (type) details.extra.unshift(['type', type]);
-  const known =
-    message ||
-    stack ||
-    location ||
-    details.operator ||
-    details.code ||
-    details.expected ||
-    details.actual;
-  if (!known) details.message = fallback;
+  const got = defined(map.get('actual'), map.get('found'), map.get('got'));
+  const expected = show(wanted);
+  const actual = show(got);
+  const extra = extraFrom(fields);
+  if (type) extra.unshift(['type', type]);
+  const details = { name, message, duration, code, operator, expected, actual };
+  const facts = [message, stack, location, operator, code, expected, actual];
+  if (!facts.some(Boolean)) details.message = fallback;
   const source = show(map.get('at')) || stack || location;
-  const key = errorKey({ ...details, type }, source, root);
+  const key = errorKey({ ...details, extra, type }, source, root);
   const trace = userTrace(parsed.get('stack') || stack || location, root);
-  return problem({ ...details, key, trace });
+  return problem({ ...details, extra, key, trace });
 };
 
 const quoted = (value) => value.startsWith('"') || value.startsWith('\x27');
 
 const scalarText = (value) => {
   if (value.startsWith('"')) {
-    try {
-      return JSON.parse(value.replace(/\r?\n/g, '\\n'));
-    } catch {
-      return unquote(value);
-    }
+    const text = value.replace(/\r?\n/g, '\\n');
+    const parsed = jsonParse(text);
+    if (typeof parsed === 'string') return parsed;
+    return unquote(value);
   }
   return unquote(value);
 };
@@ -354,11 +358,9 @@ const parseNodeJsonl = (text, root) => {
   const events = [];
   for (const line of lines) {
     if (line[0] !== '{') return null;
-    try {
-      events.push(JSON.parse(line));
-    } catch {
-      return null;
-    }
+    const event = jsonParse(line);
+    if (event === null) return null;
+    events.push(event);
   }
   return parseNodeEvents(events, root);
 };
@@ -536,13 +538,12 @@ const takeSpecFrame = (lines, index, current) => {
   return block.next - index;
 };
 
-const hasDetail = (item) =>
-  item.message ||
-  item.trace ||
-  item.code ||
-  item.operator ||
-  item.expected ||
-  item.actual;
+const hasDetail = (item) => {
+  const message = item.message || item.trace;
+  const code = item.code || item.operator;
+  const values = item.expected || item.actual;
+  return message || code || values;
+};
 
 const dropPreviews = (problems) => {
   const named = new Set();

package/lib/{report-tools.js → report/tools.js}

@@ -1,10 +1,8 @@
 'use strict';
 
-const deps = require('./deps.js');
-const { parseAuditReport, parseOutdatedReport } = deps;
-const model = require('./report-model.js');
-
-const { summary, problem, report, userTrace } = model;
+const { parseAuditReport, parseOutdatedReport } = require('../deps/deps.js');
+const { summary, problem, report, userTrace } = require('./model.js');
+const { trimText } = require('../common/utilities.js');
 
 const PRETTIER_SUMMARY = [
   'Code style issues',
@@ -41,33 +39,28 @@ const parseEslintJson = (data, root) => {
         item.column || 0,
         root,
       );
-      problems.push(
-        problem({
-          severity: item.severity === 1 ? 'warning' : 'error',
-          message: item.message || '',
-          code: item.ruleId || '',
-          trace,
-        }),
-      );
+      const severity = item.severity === 1 ? 'warning' : 'error';
+      const message = item.message || '';
+      const code = item.ruleId || '';
+      const issue = { severity, message, code, trace };
+      problems.push(problem(issue));
     }
   }
   return eslintReport(problems);
 };
 
-const eslintLine = (line) => {
-  const match = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.*)$/.exec(line);
+const eslintLine = (text) => {
+  const match = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.*)$/.exec(text);
   if (!match) return null;
   const rest = match[4];
   const ruleAt = rest.lastIndexOf('  ');
-  const message = ruleAt < 0 ? rest : rest.slice(0, ruleAt);
+  const raw = ruleAt < 0 ? rest : rest.slice(0, ruleAt);
   const code = ruleAt < 0 ? '' : rest.slice(ruleAt + 2).trim();
-  return {
-    line: match[1],
-    column: match[2],
-    severity: match[3],
-    message: message.trim(),
-    code,
-  };
+  const line = match[1];
+  const column = match[2];
+  const severity = match[3];
+  const message = raw.trim();
+  return { line, column, severity, message, code };
 };
 
 const isPathLine = (line) => {
@@ -141,14 +134,12 @@ const auditExtra = (item) => {
 const parseAudit = (text) => {
   const problems = [];
   for (const item of parseAuditReport(text).values()) {
-    problems.push(
-      problem({
-        severity: item.severity || 'error',
-        name: item.name,
-        message: item.title || '',
-        extra: auditExtra(item),
-      }),
-    );
+    const severity = item.severity || 'error';
+    const { name } = item;
+    const message = item.title || '';
+    const extra = auditExtra(item);
+    const issue = { severity, name, message, extra };
+    problems.push(problem(issue));
   }
   return problems.length ? errorReport('audit', problems) : null;
 };
@@ -183,7 +174,7 @@ const parseOutdated = (text) => {
 };
 
 const pushLs = (problems, text) => {
-  const message = `${text ?? ''}`.trim();
+  const message = trimText(text);
   if (message) problems.push(problem({ message }));
 };
 
@@ -226,7 +217,7 @@ const parseToolJson = (data, root) => {
 };
 
 const parseAuditText = (text) => {
-  if (`${text ?? ''}`.trim().startsWith('{')) return null;
+  if (trimText(text).startsWith('{')) return null;
   const lines = `${text ?? ''}`.split(/\r?\n/);
   const problems = [];
   for (let index = 0; index < lines.length; index++) {

package/lib/review/agent-instructions.md

@@ -0,0 +1,14 @@
+Work through unchecked items.
+
+- Run reviews with status `editing` or `partial`
+- Do not start or change reviews with status `done`
+- After finishing an item, mark it `[x]`
+- Mark `[x]` only after the code changes are done and tests pass
+- For `code` items, replace the added lines at the given location
+- Set `status` to `partial` if any items remain, or `done` if all are `[x]`
+- Do not redo items already marked `[x]`
+- Run the full check with `npm t`
+- Run specific test files with `reslop t -- node --test <files>`
+- An item prefixed with `F<number>:` gets its own commit in this repo
+- Leave items without that prefix unstaged, do not commit or stage them
+- Do not add `Authored-by` or `Co-authored-by` unless the issue asks for it