reslop 0.2.0 → 0.2.3

package/lib/report-tools.js

@@ -0,0 +1,311 @@
+'use strict';
+
+const { parseAuditReport, parseOutdatedReport } = require('./deps.js');
+const model = require('./report-model.js');
+
+const { summary, problem, report, userTrace } = model;
+
+const place = (file, line, column, root) =>
+  userTrace(`${file}:${line}:${column}`, root);
+
+const parseEslintJson = (data, root) => {
+  const rows = Array.isArray(data) ? data : data && data.results;
+  if (!Array.isArray(rows) || !rows.length) return null;
+  if (!rows[0] || !Array.isArray(rows[0].messages)) return null;
+  const stats = summary();
+  let errors = 0;
+  let warnings = 0;
+  const problems = [];
+  for (const file of rows) {
+    const messages = file.messages || [];
+    for (const item of messages) {
+      const severity = item.severity === 1 ? 'warning' : 'error';
+      if (severity === 'warning') warnings += 1;
+      else errors += 1;
+      problems.push(
+        problem({
+          severity,
+          message: item.message || '',
+          code: item.ruleId || '',
+          trace: place(
+            file.filePath || '',
+            item.line || 0,
+            item.column || 0,
+            root,
+          ),
+        }),
+      );
+    }
+  }
+  stats.errors = errors;
+  stats.warnings = warnings;
+  return report('eslint', { summary: stats, problems });
+};
+
+const eslintLine = (line) => {
+  const match = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.*)$/.exec(line);
+  if (!match) return null;
+  const rest = match[4];
+  const ruleAt = rest.lastIndexOf('  ');
+  const message = 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 isPathLine = (line) => {
+  const text = line.trim();
+  if (!text || text.startsWith('✖')) return false;
+  if (eslintLine(text)) return false;
+  return text.includes('/') || text.includes('\\') || /\.\w+$/.test(text);
+};
+
+const parseEslintStylish = (text, root) => {
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  let file = '';
+  let errors = 0;
+  let warnings = 0;
+  let seen = false;
+  for (const line of lines) {
+    const item = eslintLine(line);
+    if (item) {
+      seen = true;
+      if (item.severity === 'warning') warnings += 1;
+      else errors += 1;
+      problems.push(
+        problem({
+          severity: item.severity,
+          message: item.message,
+          code: item.code,
+          trace: place(file, item.line, item.column, root),
+        }),
+      );
+      continue;
+    }
+    if (/✖\s+\d+\s+problems?\b/.test(line)) seen = true;
+    if (isPathLine(line)) file = line.trim();
+  }
+  if (!seen) return null;
+  const stats = summary();
+  stats.errors = errors;
+  stats.warnings = warnings;
+  return report('eslint', { summary: stats, problems });
+};
+
+const tscLine = (line) => {
+  const match = /^(.*)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.*)$/.exec(
+    line.trim(),
+  );
+  if (!match) return null;
+  return {
+    file: match[1],
+    line: match[2],
+    column: match[3],
+    code: match[4],
+    message: match[5],
+  };
+};
+
+const parseTsc = (text, root) => {
+  const problems = [];
+  for (const line of `${text ?? ''}`.split(/\r?\n/)) {
+    const item = tscLine(line);
+    if (!item) continue;
+    problems.push(
+      problem({
+        message: item.message,
+        code: item.code,
+        trace: place(item.file, item.line, item.column, root),
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('tsc', { summary: stats, problems });
+};
+
+const prettierFile = (line) => {
+  const warn = /^\[(?:warn|error)\]\s+(\S+)$/.exec(line.trim());
+  if (warn && !warn[1].startsWith('Code')) return warn[1];
+  return '';
+};
+
+const parsePrettier = (text, root) => {
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  let seen = false;
+  for (const line of lines) {
+    if (line.includes('Code style issues')) seen = true;
+    if (line.includes('All matched files use Prettier')) seen = true;
+    const file = prettierFile(line);
+    if (!file) continue;
+    seen = true;
+    problems.push(
+      problem({
+        message: 'format',
+        trace: userTrace(file, root),
+      }),
+    );
+  }
+  if (!seen) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('prettier', { summary: stats, problems });
+};
+
+const auditProblems = (text) => {
+  const audit = parseAuditReport(text);
+  const problems = [];
+  for (const item of audit.values()) {
+    const extra = [];
+    if (item.range) extra.push(['range', item.range]);
+    if (item.fix) extra.push(['fix', item.fix]);
+    problems.push(
+      problem({
+        severity: item.severity || 'error',
+        name: item.name,
+        message: item.title || '',
+        extra,
+      }),
+    );
+  }
+  return problems;
+};
+
+const parseAudit = (text) => {
+  const problems = auditProblems(text);
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('audit', { summary: stats, problems });
+};
+
+const behind = (item) => {
+  if (!item.current) return true;
+  if (item.wanted && item.wanted !== item.current) return true;
+  if (item.latest && item.latest !== item.current) return true;
+  return false;
+};
+
+const parseOutdated = (text) => {
+  const outdated = parseOutdatedReport(text);
+  const problems = [];
+  for (const [name, item] of outdated) {
+    if (!behind(item)) continue;
+    problems.push(
+      problem({
+        severity: 'warning',
+        name,
+        message: `${item.current} ${item.wanted} ${item.latest}`.trim(),
+        extra: [
+          ['current', item.current],
+          ['wanted', item.wanted],
+          ['latest', item.latest],
+        ],
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.warnings = problems.length;
+  return report('outdated', { summary: stats, problems });
+};
+
+const pushLs = (problems, text) => {
+  const message = `${text ?? ''}`.trim();
+  if (!message) return;
+  problems.push(problem({ message }));
+};
+
+const walkLs = (node, problems) => {
+  if (!node || typeof node !== 'object') return;
+  if (Array.isArray(node.problems)) {
+    for (const item of node.problems) pushLs(problems, item);
+  }
+  if (node.missing) {
+    pushLs(problems, `missing ${node.required || node.version || ''}`);
+  }
+  if (node.invalid) pushLs(problems, `invalid ${node.version || ''}`);
+  if (node.extraneous) pushLs(problems, `extraneous ${node.version || ''}`);
+  const deps = node.dependencies;
+  if (!deps || typeof deps !== 'object') return;
+  for (const name of Object.keys(deps)) walkLs(deps[name], problems);
+};
+
+const parseLs = (data) => {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+  if (!data.dependencies && !Array.isArray(data.problems)) return null;
+  const problems = [];
+  walkLs(data, problems);
+  if (!problems.length && !Array.isArray(data.problems)) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('ls', { summary: stats, problems });
+};
+
+const parseToolJson = (data, root) => {
+  const eslint = parseEslintJson(data, root);
+  if (eslint) return [eslint];
+  const vulns = data && (data.vulnerabilities || data.advisories);
+  const audit = vulns ? parseAudit(JSON.stringify(data)) : null;
+  if (audit) return [audit];
+  const ls = parseLs(data);
+  if (ls) return [ls];
+  const outdated = parseOutdated(JSON.stringify(data));
+  if (outdated) return [outdated];
+  return null;
+};
+
+const parseAuditText = (text) => {
+  if (`${text ?? ''}`.trim().startsWith('{')) return null;
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  for (let index = 0; index < lines.length; index++) {
+    const match = /^Severity:\s+(\w+)\s*$/.exec(lines[index].trim());
+    if (!match) continue;
+    const name = (lines[index - 1] || '').trim();
+    problems.push(
+      problem({
+        severity: match[1].toLowerCase(),
+        name,
+        message: name,
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('audit', { summary: stats, problems });
+};
+
+const parseToolText = (text, root) => {
+  const reports = [];
+  const eslint = parseEslintStylish(text, root);
+  if (eslint) reports.push(eslint);
+  const tsc = parseTsc(text, root);
+  if (tsc) reports.push(tsc);
+  const prettier = parsePrettier(text, root);
+  if (prettier) reports.push(prettier);
+  const audit = parseAuditText(text);
+  if (audit) reports.push(audit);
+  return reports;
+};
+
+module.exports = {
+  parseEslintJson,
+  parseEslintStylish,
+  parseTsc,
+  parsePrettier,
+  parseAudit,
+  parseOutdated,
+  parseLs,
+  parseToolJson,
+  parseToolText,
+};

package/lib/review-merge.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const { TODO_FILE } = require('./files.js');
+
+const flatText = (text) => `${text ?? ''}`.trim().replace(/\n/g, ' ');
+
+const snapTodo = (todo) => ({
+  file: todo.file ?? '',
+  text: flatText(todo.text),
+  done: todo.done === true,
+});
+
+const snapList = (todos) => {
+  const list = [];
+  for (const todo of todos ?? []) {
+    const snap = snapTodo(todo);
+    if (!snap.text) continue;
+    list.push(snap);
+  }
+  return list;
+};
+
+const copyMap = (map) => {
+  const next = new Map();
+  if (!map) return next;
+  for (const [key, note] of map) next.set(key, { ...note });
+  return next;
+};
+
+const snapshotSide = (store) => ({
+  status: store.status,
+  todos: snapList(store.todos),
+  feedback: copyMap(store.feedback),
+  code: copyMap(store.code),
+});
+
+const captureBaseline = (store) => {
+  store.baseline = snapshotSide(store);
+};
+
+const claim = (list, used, text, read) => {
+  for (let i = 0; i < list.length; i++) {
+    if (used[i]) continue;
+    if (read(list[i]) !== text) continue;
+    used[i] = true;
+    return i;
+  }
+  return -1;
+};
+
+const pickDone = (baseDone, ourDone, theirDone) => {
+  if (ourDone === theirDone) return ourDone;
+  if (theirDone === baseDone) return ourDone;
+  if (ourDone === baseDone) return theirDone;
+  return ourDone;
+};
+
+const withDone = (todo, done) => {
+  if (todo.done === done) return todo;
+  return { id: todo.id, file: todo.file, text: todo.text, done };
+};
+
+const liveText = (todo) => flatText(todo.text);
+
+const snapText = (snap) => snap.text;
+
+const flags = (n) => new Array(n).fill(false);
+
+const adoptTodo = (store, snap) => {
+  const id = store.nextTodoId;
+  store.nextTodoId += 1;
+  const file = snap.file || TODO_FILE;
+  return { id, file, text: snap.text, done: snap.done };
+};
+
+const findMerged = (merged, alias, text) => {
+  const linked = alias.get(text);
+  if (linked) {
+    const at = merged.indexOf(linked);
+    if (at >= 0) return at;
+  }
+  for (let i = 0; i < merged.length; i++) {
+    if (liveText(merged[i]) === text) return i;
+  }
+  return -1;
+};
+
+const insertTheir = (store, merged, theirs, theirKeep, alias) => {
+  for (let i = 0; i < theirs.length; i++) {
+    if (!theirKeep[i]) continue;
+    let at = merged.length;
+    let placed = false;
+    for (let j = i - 1; j >= 0 && !placed; j--) {
+      const prev = findMerged(merged, alias, theirs[j].text);
+      if (prev < 0) continue;
+      at = prev + 1;
+      placed = true;
+    }
+    for (let j = i + 1; j < theirs.length && !placed; j++) {
+      const next = findMerged(merged, alias, theirs[j].text);
+      if (next < 0) continue;
+      at = next;
+      placed = true;
+    }
+    const item = adoptTodo(store, theirs[i]);
+    merged.splice(at, 0, item);
+    alias.set(theirs[i].text, item);
+  }
+  return merged;
+};
+
+const keepOurs = (ours, kept, alias, index, text) => {
+  kept[index] = true;
+  alias.set(text, ours[index]);
+};
+
+const mergeBaseTodo = (
+  base,
+  ours,
+  theirs,
+  used,
+  kept,
+  dropped,
+  theirKeep,
+  alias,
+) => {
+  const text = base.text;
+  const oi = claim(ours, used.ours, text, liveText);
+  const ti = claim(theirs, used.theirs, text, snapText);
+  if (oi >= 0 && ti >= 0) {
+    const done = pickDone(base.done, ours[oi].done === true, theirs[ti].done);
+    ours[oi] = withDone(ours[oi], done);
+    keepOurs(ours, kept, alias, oi, text);
+    return;
+  }
+  if (oi >= 0) {
+    if (ours[oi].done === base.done) {
+      dropped[oi] = true;
+      return;
+    }
+    keepOurs(ours, kept, alias, oi, text);
+    return;
+  }
+  if (ti >= 0 && theirs[ti].done !== base.done) theirKeep[ti] = true;
+};
+
+const replaceTodo = (todo, snap) => ({
+  id: todo.id,
+  file: todo.file,
+  text: snap.text,
+  done: snap.done,
+});
+
+const fillGaps = (merged, gaps, theirs, theirKeep, alias) => {
+  let filled = 0;
+  for (let i = 0; i < theirs.length && filled < gaps.length; i++) {
+    if (!theirKeep[i]) continue;
+    const gap = gaps[filled];
+    const item = replaceTodo(gap.todo, theirs[i]);
+    merged.splice(gap.at, 0, item);
+    alias.set(theirs[i].text, item);
+    theirKeep[i] = false;
+    filled += 1;
+  }
+};
+
+const mergeFreshTodo = (ours, theirs, used, kept, alias, index) => {
+  const text = liveText(ours[index]);
+  const ti = claim(theirs, used.theirs, text, snapText);
+  if (ti < 0) {
+    kept[index] = true;
+    return;
+  }
+  const done = ours[index].done === true || theirs[ti].done === true;
+  ours[index] = withDone(ours[index], done);
+  keepOurs(ours, kept, alias, index, text);
+};
+
+const mergeTodos = (store, base, theirs) => {
+  const ours = [];
+  for (const todo of store.todos) {
+    if (!liveText(todo)) continue;
+    ours.push(todo);
+  }
+  const used = { ours: flags(ours.length), theirs: flags(theirs.length) };
+  const kept = flags(ours.length);
+  const dropped = flags(ours.length);
+  const theirKeep = flags(theirs.length);
+  const alias = new Map();
+  for (const item of base) {
+    mergeBaseTodo(item, ours, theirs, used, kept, dropped, theirKeep, alias);
+  }
+  for (let i = 0; i < ours.length; i++) {
+    if (used.ours[i]) continue;
+    mergeFreshTodo(ours, theirs, used, kept, alias, i);
+  }
+  for (let i = 0; i < theirs.length; i++) {
+    if (!used.theirs[i]) theirKeep[i] = true;
+  }
+  const merged = [];
+  const gaps = [];
+  let cursor = 0;
+  for (let i = 0; i < ours.length; i++) {
+    if (kept[i]) {
+      merged.push(ours[i]);
+      cursor += 1;
+      continue;
+    }
+    if (!dropped[i]) continue;
+    gaps.push({ at: cursor, todo: ours[i] });
+    cursor += 1;
+  }
+  fillGaps(merged, gaps, theirs, theirKeep, alias);
+  store.todos = insertTheir(store, merged, theirs, theirKeep, alias);
+};
+
+const sameNote = (left, right) =>
+  left.text === right.text && !!left.done === !!right.done;
+
+const cloneNote = (note, done) => {
+  if (!!note.done === done) return note;
+  return { ...note, done };
+};
+
+const pickNote = (ours, base, theirs) => {
+  if (ours && theirs && ours.text === theirs.text) {
+    const baseDone = base ? base.done === true : ours.done === true;
+    const done = pickDone(baseDone, ours.done === true, theirs.done === true);
+    return cloneNote(ours, done);
+  }
+  if (!base) return ours || theirs || null;
+  if (!ours) {
+    if (!theirs || sameNote(theirs, base)) return null;
+    return theirs;
+  }
+  if (!theirs) {
+    if (sameNote(ours, base)) return null;
+    return ours;
+  }
+  if (sameNote(theirs, base)) return ours;
+  if (sameNote(ours, base)) return theirs;
+  return ours;
+};
+
+const mergeMap = (ours, base, theirs) => {
+  const keys = new Set();
+  for (const key of ours.keys()) keys.add(key);
+  for (const key of base.keys()) keys.add(key);
+  for (const key of theirs.keys()) keys.add(key);
+  for (const key of keys) {
+    const next = pickNote(ours.get(key), base.get(key), theirs.get(key));
+    if (!next) ours.delete(key);
+    else ours.set(key, next);
+  }
+};
+
+const mergeReview = (store, disk) => {
+  const base = store.baseline;
+  const baseTodos = base ? base.todos : [];
+  const baseStatus = base ? base.status : store.status;
+  mergeTodos(store, baseTodos, snapList(disk.todos));
+  const feedback = base ? base.feedback : new Map();
+  const code = base ? base.code : new Map();
+  mergeMap(store.feedback, feedback, disk.feedback);
+  mergeMap(store.code, code, disk.code);
+  if (store.status === baseStatus && disk.status) store.status = disk.status;
+  store.baseline = snapshotSide(disk);
+};
+
+module.exports = { captureBaseline, mergeReview };

package/lib/review.js

@@ -4,6 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { TODO_FILE, REVIEW_DIR } = require('./files.js');
+const { captureBaseline, mergeReview } = require('./review-merge.js');
 
 const createStore = (reviewPath, templates = []) => ({
   reviewPath,
@@ -14,6 +15,7 @@ const createStore = (reviewPath, templates = []) => ({
   todos: [],
   templates: [...templates],
   status: 'editing',
+  baseline: null,
 });
 
 const noteCounts = (store) => {
@@ -119,6 +121,15 @@ const setTodoText = (store, id, text) => {
   store.dirty = true;
 };
 
+const setTodoDone = (store, id, done) => {
+  const i = store.todos.findIndex((todo) => todo.id === id);
+  if (i < 0) return;
+  const prev = store.todos[i];
+  if (prev.done === done) return;
+  store.todos[i] = { id: prev.id, file: prev.file, text: prev.text, done };
+  store.dirty = true;
+};
+
 const checkLabel = (text, done) => {
   const mark = done ? 'x' : ' ';
   return `[${mark}] ${text}`;
@@ -222,12 +233,13 @@ const SECTION_LINE = {
 };
 
 const AGENT_INSTRUCTIONS = [
-  'Execute reviews with `status: ready` or `status: partial`.',
-  'Do not start `editing` or `done` review files.',
-  'Work through unchecked items. After finishing one, mark it `[x]`.',
-  'For `code` items, replace added lines at that location with the fence.',
-  'Set `status` to `partial` if some remain, or `done` if all are `[x]`.',
-  'Do not redo items already marked `[x]`.',
+  '- Execute reviews with `status` `ready, partial, editing`',
+  '- Do not start or change `done` review files',
+  '- Work through unchecked items. After finishing one, mark it `[x]`',
+  '- For `code` items, replace added lines at that location',
+  '- If not `editing`, set `status` to `partial` if some remain, ' +
+    'or `done` if all are `[x]`',
+  '- Do not redo items already marked `[x]`',
 ].join('\n');
 
 const toInt = (text) => parseInt(text, 10);
@@ -622,6 +634,7 @@ const parseReview = (text, reviewPath, templates = []) => {
   flushPendingCode(builder, pendingCode);
   flushPendingFeedback(builder, pending);
   builder.dirty = false;
+  captureBaseline(builder);
   return builder;
 };
 
@@ -733,8 +746,25 @@ const loadTemplates = (dir) => {
   }
 };
 
+const readReviewText = (reviewPath) => {
+  try {
+    return fs.readFileSync(reviewPath, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return '';
+    throw error;
+  }
+};
+
+const mergeDiskReview = (notes) => {
+  const text = readReviewText(notes.reviewPath);
+  if (!text.startsWith('---')) return;
+  const disk = parseReview(text, notes.reviewPath, notes.templates);
+  mergeReview(notes, disk);
+};
+
 const flushReview = (notes, force = false) => {
   if (!notes || !notes.dirty) return false;
+  mergeDiskReview(notes);
   if (!hasNotes(notes) && !force) {
     notes.dirty = false;
     return false;
@@ -746,6 +776,7 @@ const flushReview = (notes, force = false) => {
   const templatesFile = path.join(top, REVIEW_DIR, TEMPLATES_FILE);
   const body = `${JSON.stringify(notes.templates, null, 2)}\n`;
   fs.writeFileSync(templatesFile, body, 'utf8');
+  captureBaseline(notes);
   notes.dirty = false;
   return true;
 };
@@ -770,6 +801,7 @@ module.exports = {
   addTodo,
   removeTodo,
   setTodoText,
+  setTodoDone,
   checkLabel,
   feedbackKey,
   applyImportedNotes,