reslop 0.2.1 → 0.2.4

package/lib/render/npm.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const ansi = require('../ansi.js');
+const chrome = require('./chrome.js');
+const primitives = require('./primitives.js');
+const npmCommands = require('../npm-commands.js');
+
+const { THEME, paint, visibleWidth, truncateVisible, seq, EL } = ansi;
+const { clipAnsi, stripAnsi, RESET, foregroundOn } = ansi;
+const { formatBusyStatus } = chrome;
+const { TABLE_KEY, TABLE_VAL } = npmCommands;
+const { fill, FILE_MARK, paneResult, paintCursorList } = primitives;
+const { paintListEdit } = primitives;
+
+const EDGE = 2;
+const TAIL = 1;
+const LOG_PAD_Y = 1;
+const LOG_PAD_X = 2;
+const NPM_NAME_MAX = 24;
+
+const logViewRows = (bodyH) => {
+  const height = Math.max(1, bodyH);
+  if (height >= LOG_PAD_Y * 2 + 1) return height - LOG_PAD_Y * 2;
+  return height;
+};
+
+const rowFg = (selected) => (selected ? THEME.chromeFg : THEME.mutedFg);
+
+const npmNameWidth = (commands) => {
+  let width = 0;
+  for (const entry of commands) {
+    width = Math.max(width, visibleWidth(`${entry.name ?? ''}`));
+  }
+  return Math.min(NPM_NAME_MAX, width);
+};
+
+const paintNpmRow = (entry, width, color, selected, nameCol = 0) => {
+  const inner = Math.max(1, width - EDGE - TAIL);
+  const mark = selected ? FILE_MARK : ' ';
+  const prefix = ` ${mark} `;
+  const prefixW = visibleWidth(prefix);
+  const rest = Math.max(1, inner - prefixW);
+  const detail = entry.kind === 'bin' ? 'bin' : entry.command;
+  const nameW = Math.min(Math.max(0, nameCol), rest);
+  const name = truncateVisible(entry.name, nameW);
+  const gap = rest > nameW + 2 ? '  ' : '';
+  const detailW = Math.max(0, rest - nameW - visibleWidth(gap));
+  const shown = truncateVisible(detail, detailW);
+  const mid = `${name}${' '.repeat(Math.max(0, nameW - visibleWidth(name)))}`;
+  const after = `${gap}${shown}`;
+  const pad = Math.max(0, rest - visibleWidth(mid + after));
+  const left = `${prefix}${mid}${after}${' '.repeat(pad)}`;
+  const fgRgb = rowFg(selected);
+  const bgRgb = selected ? THEME.buttonBg : THEME.ctxBg;
+  const tail = ' '.repeat(TAIL);
+  const edge = fill(EDGE, fgRgb, THEME.ctxBg, color);
+  if (!color) return `${left}${tail}${edge}`;
+  let out = `${seq(fgRgb, bgRgb)}${EL}`;
+  out += paint(prefix, fgRgb, bgRgb, color);
+  const bin = entry.kind === 'bin';
+  const nameFg = bin ? THEME.shaFg : THEME.buttonHotFg;
+  out += paint(mid, nameFg, bgRgb, color, !bin);
+  out += paint(`${after}${' '.repeat(pad)}${tail}`, fgRgb, bgRgb, color);
+  return out + edge;
+};
+
+const paintNpmList = (view, width, color, bodyH, headerLines) => {
+  const commands = view.npmCommands ?? [];
+  const nameW = npmNameWidth(commands);
+  const cursor = view.npmCursor ?? 0;
+  const compose = view.compose;
+  const editing = compose && compose.kind === 'npm';
+  const paintRow = (entry, rowWidth, rowColor, selected) =>
+    paintNpmRow(entry, rowWidth, rowColor, selected, nameW);
+  let extra = null;
+  if (editing) {
+    const painted = paintListEdit(compose, width, color, EDGE);
+    const at = view.npmEditName ? 'replace' : 'end';
+    extra = { row: painted.row, cursor: painted.cursor, at, index: cursor };
+  }
+  return paintCursorList(
+    commands,
+    cursor,
+    width,
+    color,
+    bodyH,
+    headerLines,
+    paintRow,
+    extra,
+    view.listScroll,
+  );
+};
+
+const logStart = (view, count, rows) => {
+  const maxStart = Math.max(0, count - rows);
+  let start = maxStart;
+  if (!view.npmFollow) start = view.npmScroll ?? 0;
+  if (start > maxStart) start = maxStart;
+  if (start < 0) start = 0;
+  return start;
+};
+
+const isTableLine = (line) => `${line ?? ''}`.startsWith(TABLE_KEY);
+
+const mixRgb = (from, to, part) => {
+  const out = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    const next = from[i] + (to[i] - from[i]) * part;
+    out[i] = Math.round(next);
+  }
+  return out;
+};
+
+const tableTone = (index) => {
+  const lift = index % 2 === 0 ? 0.035 : 0.07;
+  const valueBg = mixRgb(THEME.ctxBg, THEME.chromeFg, lift);
+  const keyBg = mixRgb(THEME.ctxBg, THEME.chromeFg, lift + 0.025);
+  const frame = mixRgb(THEME.ctxBg, THEME.chromeFg, lift * 0.4);
+  return { valueBg, keyBg, frame };
+};
+
+const tableIndex = (lines, index) => {
+  let at = index;
+  let row = 0;
+  while (at > 0 && isTableLine(lines[at - 1])) {
+    at -= 1;
+    row += 1;
+  }
+  return row;
+};
+
+const paintTableLine = (line, width, index) => {
+  const raw = line.slice(TABLE_KEY.length);
+  const at = raw.indexOf(TABLE_VAL);
+  const key = at < 0 ? raw : raw.slice(0, at);
+  const rest = at < 0 ? '' : raw.slice(at + TABLE_VAL.length);
+  const gap = rest.startsWith('  ') ? '  ' : '';
+  const value = rest.slice(gap.length);
+  const edge = 1;
+  const inner = Math.max(1, width - edge * 2);
+  const keyW = visibleWidth(key);
+  const gapW = visibleWidth(gap);
+  const valueW = Math.max(0, inner - keyW - gapW);
+  const shown = truncateVisible(value, valueW);
+  const pad = ' '.repeat(Math.max(0, valueW - visibleWidth(shown)));
+  const tone = tableTone(index);
+  const ink = THEME.ctxFg;
+  let out = fill(edge, ink, tone.frame, true);
+  out += paint(key, ink, tone.keyBg, true);
+  out += paint(gap, ink, tone.frame, true);
+  out += paint(`${shown}${pad}`, ink, tone.valueBg, true);
+  return `${out}${fill(edge, ink, tone.frame, true)}`;
+};
+
+const paintLogLine = (line, width, color, fgRgb = THEME.ctxFg) => {
+  const inner = Math.max(1, width - LOG_PAD_X * 2);
+  const source = color ? `${line ?? ''}` : stripAnsi(line);
+  const clip = (value) =>
+    color ? clipAnsi(value, inner) : truncateVisible(value, inner);
+  const body = color ? foregroundOn(clip(source), THEME.ctxBg) : clip(source);
+  const lead = ' '.repeat(LOG_PAD_X);
+  const pad = Math.max(0, width - LOG_PAD_X - visibleWidth(body));
+  const tail = ' '.repeat(pad);
+  if (!color) return `${lead}${body}${tail}`;
+  const base = seq(fgRgb, THEME.ctxBg);
+  let out = `${base}${EL}${lead}${body}`;
+  if (pad) out += `${RESET}${base}${tail}`;
+  return `${out}${RESET}`;
+};
+
+const paintRunBar = (width, color, frame) => {
+  const label = formatBusyStatus('running', frame);
+  return paintLogLine(label, width, color, THEME.chromeFg);
+};
+
+const paintNpmLog = (view, width, color, bodyH) => {
+  const text = view.npmOutput ?? '';
+  const lines = text.split('\n');
+  if (lines.length && lines.at(-1) === '') lines.pop();
+  const running = view.npmRunning === true;
+  const count = lines.length + (running ? 1 : 0);
+  const rows = logViewRows(bodyH);
+  const padY = bodyH - rows;
+  const top = padY ? 1 : 0;
+  const start = logStart(view, count, rows);
+  const blank = fill(width, THEME.ctxFg, THEME.ctxBg, color);
+  const body = [];
+  for (let i = 0; i < top; i++) body.push(blank);
+  for (let i = 0; i < rows; i++) {
+    const index = start + i;
+    if (index < lines.length) {
+      const line = lines[index];
+      if (color && isTableLine(line)) {
+        const row = tableIndex(lines, index);
+        body.push(paintTableLine(line, width, row));
+      } else {
+        body.push(paintLogLine(line, width, color));
+      }
+    } else if (running && index === lines.length) {
+      body.push(paintRunBar(width, color, view.progressFrame ?? 0));
+    } else {
+      body.push(blank);
+    }
+  }
+  for (let i = 0; i < padY - top; i++) body.push(blank);
+  return paneResult({
+    body,
+  });
+};
+
+const paintBodyNpm = (view, width, color, bodyH, headerLines) => {
+  if (view.npmView) return paintNpmLog(view, width, color, bodyH);
+  return paintNpmList(view, width, color, bodyH, headerLines);
+};
+
+module.exports = { paintBodyNpm, logViewRows };

package/lib/render/present.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { ESC } = require('../ansi.js');
+const ansi = require('../ansi.js');
+const { ESC } = ansi;
 
 const presentCursor = (cursor) => {
   if (!cursor || cursor.x <= 0 || cursor.y <= 0) return `${ESC}[?25l`;

package/lib/render/primitives.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const ansi = require('../ansi.js');
+const actions = require('../session/actions.js');
+const { LIST_PANES } = actions;
 
 const { THEME, paint, visibleWidth, truncateVisible, seq, EL, RESET } = ansi;
 
@@ -8,7 +10,6 @@ const GUTTER_W = 2;
 const FILE_MARK = '▶';
 const FILE_LIST_PAD = 1;
 const CHECK_DONE = 'xX';
-const LIST_PANES = ['files', 'branches', 'commits'];
 const CHECK_TOKEN = /\[([ xX])\]/;
 const CHECK_LEAD = /^\[[ xX]\] /;
 
@@ -34,14 +35,21 @@ const splitCheck = (text) => {
   return { before, mark, token, after };
 };
 
-const paintCheckBar = (text, width, fgRgb, bgRgb, color) => {
+const paintCheckBar = (text, width, fgRgb, bgRgb, color, plain = false) => {
   const clipped = truncateVisible(text, width);
   const parts = color ? splitCheck(clipped) : null;
   if (!parts) return paintBar(text, width, fgRgb, bgRgb, color);
   const pad = Math.max(0, width - visibleWidth(clipped));
   const done = CHECK_DONE.includes(parts.mark);
-  const chipFg = done ? THEME.checkDoneFg : THEME.checkFg;
-  const chipBg = done ? THEME.checkDoneBg : THEME.checkBg;
+  let chipFg = THEME.checkFg;
+  let chipBg = THEME.checkBg;
+  if (plain) {
+    chipFg = fgRgb;
+    chipBg = bgRgb;
+  } else if (done) {
+    chipFg = THEME.checkDoneFg;
+    chipBg = THEME.checkDoneBg;
+  }
   const after = `${parts.after}${' '.repeat(pad)}`;
   let out = `${seq(fgRgb, bgRgb)}${EL}`;
   if (parts.before) out += paint(parts.before, fgRgb, bgRgb, color);
@@ -111,6 +119,16 @@ const extraIdx = (extraRow, cursor, count) => {
   return count;
 };
 
+const paneResult = (fields = {}) => ({
+  body: fields.body ?? [],
+  fileHits: fields.fileHits ?? [],
+  todoOwners: fields.todoOwners ?? [],
+  todoChecks: fields.todoChecks ?? [],
+  cursor: fields.cursor ?? null,
+  splitBody: fields.splitBody === true,
+  listScroll: fields.listScroll ?? 0,
+});
+
 const paintCursorList = (
   items,
   cursor,
@@ -153,41 +171,23 @@ const paintCursorList = (
     fileHits.push({ y, cursor: itemIdx });
   }
   if (pad) body.push(blank);
-  return { body, fileHits, cursor: textCursor, offset: start };
-};
-
-const branchLabel = (name) => {
-  const branch = `${name ?? ''}`.trim();
-  if (!branch) return '';
-  return `[${branch}]`;
-};
-
-const splitBracketName = (label) => {
-  const text = `${label ?? ''}`;
-  const open = text.startsWith('[') ? '[' : '';
-  const rest = open ? text.slice(1) : text;
-  const close = rest.endsWith(']') ? ']' : '';
-  const name = close ? rest.slice(0, -1) : rest;
-  return { open, name, close };
+  return paneResult({
+    body,
+    fileHits,
+    cursor: textCursor,
+    listScroll: start,
+  });
 };
 
-const paintBracketName = (label, nameFg, wrapFg, bgRgb, color, nameBold) => {
-  const { open, name, close } = splitBracketName(label);
-  return (
-    paint(open, wrapFg, bgRgb, color, true) +
-    paint(name, nameFg, bgRgb, color, nameBold) +
-    paint(close, wrapFg, bgRgb, color, true)
-  );
-};
+const branchLabel = (name) => `${name ?? ''}`.trim();
 
-const paintListEdit = (compose, width, color, edgeW) => {
+const paintListEdit = (compose, width, color, edgeW = 0) => {
   const inner = Math.max(1, width - edgeW);
   const prefix = ` ${FILE_MARK} `;
   const prefixW = visibleWidth(prefix);
   const rest = Math.max(1, inner - prefixW);
   const text = `${compose.text ?? ''}`.replaceAll('\n', ' ');
-  const label = `[${text}]`;
-  const clipped = truncateVisible(label, rest);
+  const clipped = truncateVisible(text, rest);
   const pad = Math.max(0, rest - visibleWidth(clipped));
   const left = `${prefix}${clipped}${' '.repeat(pad)}`;
   const fgRgb = THEME.chromeFg;
@@ -198,30 +198,14 @@ const paintListEdit = (compose, width, color, edgeW) => {
     const gap = ' '.repeat(pad);
     row = `${seq(fgRgb, bgRgb)}${EL}`;
     row += paint(prefix, fgRgb, bgRgb, color);
-    row += paintBracketName(
-      clipped,
-      THEME.buttonHotFg,
-      THEME.mutedFg,
-      bgRgb,
-      color,
-    );
+    row += paint(clipped, THEME.buttonHotFg, bgRgb, color);
     row += paint(gap, fgRgb, bgRgb, color);
     row += edge;
   }
-  const col = Math.min((compose.cursor ?? 0) + 1, visibleWidth(clipped));
+  const col = Math.min(compose.cursor ?? 0, visibleWidth(clipped));
   return { row, cursor: { x: prefixW + col + 1 } };
 };
 
-const paneResult = (fields) => ({
-  body: fields.body,
-  fileHits: fields.fileHits,
-  todoOwners: fields.todoOwners,
-  todoChecks: fields.todoChecks ?? [],
-  cursor: fields.cursor ?? null,
-  splitBody: fields.splitBody === true,
-  listScroll: fields.listScroll ?? 0,
-});
-
 const measureColumns = (entries, rowFields, align) => {
   const keys = Object.keys(align);
   const widths = Object.fromEntries(keys.map((key) => [key, 0]));
@@ -280,9 +264,9 @@ module.exports = {
   paintSplitRule,
   paintBodyFill,
   windowRows,
+  listWindowStart,
   paintCursorList,
   paintListEdit,
   branchLabel,
-  paintBracketName,
   paneResult,
 };

package/lib/render/render.js

@@ -4,7 +4,8 @@ const chrome = require('./chrome.js');
 const notes = require('./notes.js');
 const diff = require('./diff.js');
 const present = require('./present.js');
-const { renderFrame } = require('./frame.js');
+const frame = require('./frame.js');
+const { renderFrame } = frame;
 
 const { QUIT_PROMPT, PUSH_PROMPT } = chrome;
 const { updatePrompt, dropPrompt } = chrome;

package/lib/render/unit.js

@@ -1,23 +1,29 @@
 'use strict';
 
-const { detectLang } = require('../detect.js');
+const detect = require('../detect.js');
+const { detectLang } = detect;
 const primitives = require('./primitives.js');
 const diff = require('./diff.js');
 
 const { paneResult } = primitives;
-const { paintDiffLine, codeCursorInRows } = diff;
-const { sameHunk } = require('../diff/diff.js');
+const { paintDiffLine, codeCursorInRows, expandSoftRows } = diff;
+const diffLib = require('../diff/diff.js');
+const { sameHunk } = diffLib;
 
 const paintBodyUnit = (view, width, color) => {
   const lines = view.unitLines ?? [];
   const item = view.item;
   const lang = detectLang(view.reviewPath ?? '');
   const overlay = view.codeOverlay;
-  const editing = view.mode === 'compose' && overlay;
-  const { length } = lines;
+  const editing =
+    view.mode === 'compose' && overlay && typeof overlay.cursor === 'number';
+  const picked = editing ? overlay.scrollCol : 0;
+  const scrollCol = picked ?? 0;
+  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 = lines[i];
+    const line = source[i];
     const isBlock = item && sameHunk(line.item, item);
     const row = { ...line };
     if (editing) {
@@ -25,16 +31,13 @@ const paintBodyUnit = (view, width, color) => {
     } else if ((row.type === 'add' || row.type === 'del') && !isBlock) {
       row.mark = ' ';
     }
-    body[i] = paintDiffLine(row, width, color, row.origin, lang);
+    body[i] = paintDiffLine(row, width, color, row.origin, lang, scrollCol);
   }
   const edit = overlay ? overlay.cursor : null;
-  const cursor = codeCursorInRows(lines, false, width, edit);
+  const cursor = codeCursorInRows(source, false, width, edit, scrollCol);
   return paneResult({
     body,
-    fileHits: [],
-    todoOwners: [],
     cursor,
-    splitBody: false,
   });
 };
 

package/lib/report-model.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const ansi = require('./ansi.js');
+const { stripAnsi } = ansi;
+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 = 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 || '' };
+};
+
+module.exports = {
+  summary,
+  problem,
+  report,
+  userTrace,
+  groupReport,
+  reduceStderr,
+  shortTail,
+  envelope,
+};

package/lib/report-parse.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const ansi = require('./ansi.js');
+const { stripAnsi } = ansi;
+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 = ['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.includes(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 = new Array(reports.length);
+  for (let i = 0; i < reports.length; i++) {
+    grouped[i] = groupReport(reports[i]);
+  }
+  return envelope(grouped, exit, reduceStderr(stderr, root));
+};
+
+module.exports = {
+  toolHint,
+  parseReports,
+  buildDocument,
+};