reslop 0.2.4 → 0.2.6

package/lib/review.js

@@ -4,29 +4,31 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const files = require('./files.js');
-const { TODO_FILE, REVIEW_DIR } = files;
+const { TASKS_FILE, REVIEW_DIR, TASK_KINDS, taskKind, taskTitle } = files;
 const reviewMerge = require('./review-merge.js');
 const { captureBaseline, mergeReview } = reviewMerge;
+const utilities = require('./utilities.js');
+const { pad2, dateStamp } = utilities;
 
 const createStore = (reviewPath, templates = []) => ({
   reviewPath,
   dirty: false,
-  nextTodoId: 1,
+  nextTaskId: 1,
   feedback: new Map(),
   code: new Map(),
-  todos: [],
+  tasks: [],
   templates: [...templates],
   status: 'editing',
   baseline: null,
 });
 
 const noteCounts = (store) => {
-  const counts = { feedback: 0, todo: 0, todoDone: 0, code: 0 };
+  const counts = { feedback: 0, tasks: 0, tasksDone: 0, code: 0 };
   if (!store) return counts;
-  for (const todo of store.todos) {
-    if (!todo.text.trim()) continue;
-    counts.todo += 1;
-    if (todo.done) counts.todoDone += 1;
+  for (const task of store.tasks) {
+    if (!task.text.trim()) continue;
+    counts.tasks += 1;
+    if (task.done) counts.tasksDone += 1;
   }
   for (const note of store.feedback.values()) {
     if (note.text.trim()) counts.feedback += 1;
@@ -37,98 +39,72 @@ const noteCounts = (store) => {
 
 const hasNotes = (store) => {
   const counts = noteCounts(store);
-  return counts.feedback > 0 || counts.todo > 0 || counts.code > 0;
-};
+  return counts.feedback > 0 || counts.tasks > 0 || counts.code > 0;
+};
+
+const toNote = (note, done = false) => ({
+  file: note.file,
+  oldStart: note.oldStart ?? 0,
+  newStart: note.newStart ?? 0,
+  blockId: note.blockId ?? 0,
+  origin: note.origin ?? '',
+  header: note.header ?? '',
+  text: note.text ?? '',
+  done: note.done ?? done,
+});
 
-const setFeedback = (store, key, note) => {
-  const text = note.text ?? '';
-  const trimmed = text.trim();
-  const prev = store.feedback.get(key);
-  if (!trimmed) {
+const putNote = (store, notes, key, note, clear) => {
+  const prev = notes.get(key);
+  if (clear) {
     if (!prev) return;
-    store.feedback.delete(key);
+    notes.delete(key);
     store.dirty = true;
     return;
   }
-  if (prev && prev.text === text) return;
-  store.feedback.set(key, {
-    file: note.file,
-    oldStart: note.oldStart ?? 0,
-    newStart: note.newStart ?? 0,
-    blockId: note.blockId ?? 0,
-    origin: note.origin ?? '',
-    header: note.header ?? '',
-    text,
-    done: note.done ?? prev?.done ?? false,
-  });
+  if (prev && prev.text === (note.text ?? '')) return;
+  notes.set(key, toNote(note, prev?.done));
   store.dirty = true;
 };
 
+const setFeedback = (store, key, note) => {
+  const clear = !(note.text ?? '').trim();
+  putNote(store, store.feedback, key, note, clear);
+};
+
 const setCode = (store, key, note) => {
-  const prev = store.code.get(key);
-  if (note.clear) {
-    if (!prev) return;
-    store.code.delete(key);
-    store.dirty = true;
-    return;
-  }
-  const text = note.text ?? '';
-  if (prev && prev.text === text) return;
-  store.code.set(key, {
-    file: note.file,
-    oldStart: note.oldStart ?? 0,
-    newStart: note.newStart ?? 0,
-    blockId: note.blockId ?? 0,
-    origin: note.origin ?? '',
-    header: note.header ?? '',
-    text,
-    done: note.done ?? prev?.done ?? false,
-  });
-  store.dirty = true;
+  putNote(store, store.code, key, note, Boolean(note.clear));
 };
 
-const addTodo = (store, file, text = '') => {
-  const id = store.nextTodoId;
-  store.nextTodoId += 1;
-  const todo = { id, file, text, done: false };
-  store.todos.push(todo);
+const addTask = (store, file, text = '', done = false, kind = 'backlog') => {
+  const id = store.nextTaskId;
+  store.nextTaskId += 1;
+  const todo = { id, file, text, done, kind: taskKind({ kind }) };
+  store.tasks.push(todo);
   store.dirty = true;
   return todo;
 };
 
-const removeTodo = (store, id) => {
-  const next = [];
-  let found = false;
-  for (const todo of store.todos) {
-    if (todo.id === id) {
-      found = true;
-      continue;
-    }
-    next.push(todo);
-  }
-  if (!found) return false;
-  store.todos = next;
+const removeTask = (store, id) => {
+  const tasks = store.tasks.filter((todo) => todo.id !== id);
+  if (tasks.length === store.tasks.length) return false;
+  store.tasks = tasks;
   store.dirty = true;
   return true;
 };
 
-const setTodoText = (store, id, text) => {
-  const i = store.todos.findIndex((todo) => todo.id === id);
+const setTaskText = (store, id, text) => {
+  const i = store.tasks.findIndex((todo) => todo.id === id);
   if (i < 0) return;
-  const prev = store.todos[i];
-  const trimmed = text.trim();
-  if (!trimmed) return void removeTodo(store, id);
-  if (prev.text === text) return;
-  store.todos[i] = { id: prev.id, file: prev.file, text, done: prev.done };
+  if (!text.trim()) return void removeTask(store, id);
+  if (store.tasks[i].text === text) return;
+  store.tasks[i] = { ...store.tasks[i], 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 };
+const setTaskDone = (store, id, done) => {
+  const i = store.tasks.findIndex((todo) => todo.id === id);
+  if (i < 0 || store.tasks[i].done === done) return;
+  store.tasks[i] = { ...store.tasks[i], done };
   store.dirty = true;
 };
 
@@ -153,21 +129,11 @@ const applyImportedNotes = (store, imported) => {
     const prev = store.feedback.get(key);
     const text = prev ? `${prev.text}\n\n${note.text}` : note.text;
     const done = prev ? prev.done && !!note.done : !!note.done;
-    setFeedback(store, key, {
-      file: note.file,
-      oldStart: note.oldStart ?? 0,
-      newStart: note.newStart ?? 0,
-      blockId: note.blockId ?? 0,
-      origin: note.origin ?? '',
-      header: note.header ?? '',
-      text,
-      done,
-    });
-  }
-  const todos = imported.todos ?? [];
+    setFeedback(store, key, { ...note, text, done });
+  }
+  const todos = imported.tasks ?? imported.todos ?? [];
   for (const todo of todos) {
-    const added = addTodo(store, todo.file || '', todo.text ?? '');
-    if (todo.done) added.done = true;
+    addTask(store, todo.file || '', todo.text ?? '', !!todo.done);
   }
 };
 
@@ -233,6 +199,15 @@ const SECTION_LINE = {
   '### Todo': 'todo',
   '### Feedback': 'feedback',
 };
+const BACKLOG_HEAD = 'Backlog';
+const LEGACY_BACKLOG = 'TODOs';
+const TASK_TITLES = new Map([
+  [BACKLOG_HEAD, 'backlog'],
+  [LEGACY_BACKLOG, 'backlog'],
+  ['Issues', 'issues'],
+  ['Bug Reports', 'bugs'],
+  ['Feature Requests', 'features'],
+]);
 
 const AGENT_INSTRUCTIONS = [
   '- Execute reviews with `status` `ready, partial, editing`',
@@ -249,10 +224,8 @@ const AGENT_INSTRUCTIONS = [
 const toInt = (text) => parseInt(text, 10);
 
 const canonicalStatus = (raw) => {
-  if (!raw) return '';
   const name = raw === 'pending' ? 'ready' : raw;
-  if (REVIEW_STATUSES.includes(name)) return name;
-  return '';
+  return REVIEW_STATUSES.includes(name) ? name : '';
 };
 
 const parseFrontmatterStatus = (text) => {
@@ -272,44 +245,15 @@ const parseFrontmatterStatus = (text) => {
 
 const isDoneMark = (mark) => mark === 'x' || mark === 'X';
 
-const pushTodo = (builder, file, text, done) => {
-  const id = builder.nextTodoId;
-  builder.nextTodoId += 1;
-  builder.todos.push({ id, file, text, done });
-};
-
 const checkboxLine = (text, done) => {
   const flat = text.trim().replace(/\n/g, ' ');
   const mark = done ? 'x' : ' ';
   return `- [${mark}] ${flat}`;
 };
 
-const storeFeedback = (builder, note, key) => {
-  const next = {
-    file: note.file,
-    oldStart: note.oldStart ?? 0,
-    newStart: note.newStart ?? 0,
-    blockId: note.blockId ?? 0,
-    origin: note.origin ?? '',
-    header: note.header ?? '',
-    text: note.text,
-    done: note.done ?? false,
-  };
-  builder.feedback.set(key || feedbackKey(next), next);
-};
-
-const storeCode = (builder, note, key) => {
-  const next = {
-    file: note.file,
-    oldStart: note.oldStart ?? 0,
-    newStart: note.newStart ?? 0,
-    blockId: note.blockId ?? 0,
-    origin: note.origin ?? '',
-    header: note.header ?? '',
-    text: note.text,
-    done: note.done ?? false,
-  };
-  builder.code.set(key || feedbackKey(next), next);
+const storeNote = (notes, note, key) => {
+  const next = toNote(note);
+  notes.set(key || feedbackKey(next), next);
 };
 
 const feedbackLine = (note) => {
@@ -350,17 +294,23 @@ const parseFeedSuffix = (textItem) => {
 const fileGroup = (groups, file) => {
   let group = groups.get(file);
   if (!group) {
-    group = { todos: [], feedback: [], code: [] };
+    group = { tasks: [], feedback: [], code: [] };
     groups.set(file, group);
   }
   return group;
 };
 
+const TASK_SECTION = 'task:';
+
+const taskSection = (id) => `${TASK_SECTION}${id}`;
+
 const groupReviewNotes = (notes) => {
   const groups = new Map();
-  for (const todo of notes.todos) {
-    if (!todo.text.trim()) continue;
-    fileGroup(groups, TODO_FILE).todos.push(todo);
+  for (const kind of TASK_KINDS) {
+    for (const todo of notes.tasks) {
+      if (!todo.text.trim() || taskKind(todo) !== kind.id) continue;
+      fileGroup(groups, taskSection(kind.id)).tasks.push(todo);
+    }
   }
   for (const key of notes.feedback.keys()) {
     const note = notes.feedback.get(key);
@@ -411,12 +361,22 @@ const emitCodeItem = (lines, note) => {
   lines.push(fence);
 };
 
+const sectionTitle = (file) => {
+  if (!file.startsWith(TASK_SECTION)) return file;
+  return taskTitle(file.slice(TASK_SECTION.length));
+};
+
+const backlogFile = (name) => {
+  if (name === BACKLOG_HEAD || name === LEGACY_BACKLOG) return TASKS_FILE;
+  return name;
+};
+
 const emitReviewGroups = (lines, groups) => {
   for (const file of groups.keys()) {
     const group = groups.get(file);
-    lines.push(`## ${file}`);
+    lines.push(`## ${sectionTitle(file)}`);
     lines.push('');
-    for (const todo of group.todos) {
+    for (const todo of group.tasks) {
       lines.push(checkboxLine(todo.text, todo.done));
     }
     for (const item of group.feedback) {
@@ -456,15 +416,18 @@ const parseFeedbackHeading = (line) => {
 
 const flushPendingFeedback = (builder, pending) => {
   if (!pending || !(pending.text ?? '').trim()) return null;
-  storeFeedback(builder, pending, pending.key);
+  storeNote(builder.feedback, pending, pending.key);
   return null;
 };
 
 const headingFile = (line) => {
   const quoted = FILE_QUOTE.exec(line);
-  if (quoted) return quoted[1];
+  if (quoted) return backlogFile(quoted[1]);
   if (line.startsWith('## ') && line !== '## Agent instructions') {
-    return line.slice(3);
+    const name = line.slice(3);
+    const kind = TASK_TITLES.get(name);
+    if (kind) return taskSection(kind);
+    return name;
   }
   return null;
 };
@@ -483,33 +446,23 @@ const startFeedbackPending = (heading, file) => ({
 const applyFeedMeta = (pending, raw) => {
   const loc = parseLoc(raw);
   if (!loc) return pending;
-  pending.origin = loc.origin;
-  pending.file = loc.file;
-  pending.oldStart = loc.oldStart;
-  pending.newStart = loc.newStart;
-  pending.blockId = loc.blockId;
-  pending.key = feedbackKey(loc);
-  return pending;
+  return Object.assign(pending, loc, { key: feedbackKey(loc) });
 };
 
 const applyCheckItem = (builder, file, section, pending, textItem, done) => {
+  if (file.startsWith(TASK_SECTION)) {
+    const kind = file.slice(TASK_SECTION.length);
+    addTask(builder, TASKS_FILE, textItem, done, kind);
+    return pending;
+  }
   if (section === 'todo' && file) {
-    pushTodo(builder, file, textItem, done);
+    addTask(builder, file, textItem, done, 'backlog');
     return pending;
   }
   const parsed = parseFeedSuffix(textItem);
   if (parsed) {
     flushPendingFeedback(builder, pending);
-    storeFeedback(builder, {
-      file: parsed.file || file,
-      oldStart: parsed.oldStart,
-      newStart: parsed.newStart,
-      blockId: parsed.blockId,
-      origin: '',
-      header: '',
-      text: parsed.text,
-      done,
-    });
+    storeNote(builder.feedback, { ...parsed, file: parsed.file || file, done });
     return null;
   }
   if (pending) {
@@ -518,7 +471,7 @@ const applyCheckItem = (builder, file, section, pending, textItem, done) => {
     return flushPendingFeedback(builder, pending);
   }
   if (file && section !== 'feedback') {
-    pushTodo(builder, file, textItem, done);
+    addTask(builder, file, textItem, done, 'backlog');
   }
   return pending;
 };
@@ -557,29 +510,11 @@ const startCodePending = (line) => {
   if (!match) return null;
   const loc = parseLoc(match[2]);
   if (!loc) return null;
-  return {
-    done: isDoneMark(match[1]),
-    origin: loc.origin,
-    file: loc.file,
-    oldStart: loc.oldStart,
-    newStart: loc.newStart,
-    blockId: loc.blockId,
-    open: '',
-    lines: [],
-  };
+  return { done: isDoneMark(match[1]), ...loc, open: '', lines: [] };
 };
 
 const storeCodeNote = (builder, pending, text) => {
-  storeCode(builder, {
-    file: pending.file,
-    oldStart: pending.oldStart,
-    newStart: pending.newStart,
-    blockId: pending.blockId,
-    origin: pending.origin,
-    header: '',
-    text,
-    done: pending.done,
-  });
+  storeNote(builder.code, { ...pending, text });
 };
 
 const flushPendingCode = (builder, pending) => {
@@ -646,15 +581,6 @@ const TEMPLATES_FILE = 'templates.json';
 const AUTOSAVE_MS = 3000;
 const REVIEW_NAME = /^(\d{4}-\d{2}-\d{2})-(\d+)\.md$/;
 
-const pad2 = (n) => `${n}`.padStart(2, '0');
-
-const dateStamp = (date) => {
-  const y = date.getFullYear();
-  const month = pad2(date.getMonth() + 1);
-  const day = pad2(date.getDate());
-  return `${y}-${month}-${day}`;
-};
-
 const allocateReviewPath = (dir, date, existingNames) => {
   const stamp = dateStamp(date);
   let max = -1;
@@ -666,8 +592,7 @@ const allocateReviewPath = (dir, date, existingNames) => {
     if (n > max) max = n;
   }
   const next = max + 1;
-  const file = `${stamp}-${next < 100 ? pad2(next) : String(next)}.md`;
-  return path.join(dir, REVIEW_DIR, file);
+  return path.join(dir, REVIEW_DIR, `${stamp}-${pad2(next)}.md`);
 };
 
 const listReviewNames = (dir) => {
@@ -802,10 +727,11 @@ module.exports = {
   rememberTemplate,
   setFeedback,
   setCode,
-  addTodo,
-  removeTodo,
-  setTodoText,
-  setTodoDone,
+  addTask,
+  taskKind,
+  removeTask,
+  setTaskText,
+  setTaskDone,
   checkLabel,
   feedbackKey,
   applyImportedNotes,

package/lib/runs.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ansi = require('./ansi.js');
+const { stripAnsi } = ansi;
+const commands = require('./npm-commands.js');
+const { isPassingTest } = commands;
+
+const LOG_DIR = '.log';
+const RUNS_REL = `${LOG_DIR}/.runs`;
+const RUNS_KEEP = 24;
+const WRITE_MS = 150;
+const FAILING_TEST = /^\s*(?:not ok \d+|[✖✗×]) /;
+const LIFECYCLE_EVENT = 'npm_lifecycle_event';
+
+const runsDir = (root) => path.join(root, RUNS_REL);
+
+const isRunsRel = (rel) =>
+  rel === LOG_DIR || rel === RUNS_REL || rel.startsWith(`${RUNS_REL}/`);
+
+const commandLabel = (program, args) =>
+  [path.basename(program), ...args].join(' ').trim();
+
+const isFailingTest = (line) => FAILING_TEST.test(stripAnsi(line));
+
+class Tracker {
+  constructor() {
+    this.progress = { done: 0, failed: 0, lines: 0 };
+    this.carry = '';
+  }
+
+  feed(chunk) {
+    const parts = `${this.carry}${chunk}`.split('\n');
+    this.carry = parts.pop();
+    const progress = this.progress;
+    for (const line of parts) {
+      progress.lines += 1;
+      if (isPassingTest(line)) progress.done += 1;
+      else if (isFailingTest(line)) progress.failed += 1;
+    }
+  }
+}
+
+const pidAlive = (pid) => {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+};
+
+const readRecord = (file) => {
+  try {
+    const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!record || typeof record !== 'object' || !record.id) return null;
+    return record;
+  } catch {
+    return null;
+  }
+};
+
+const listRunNames = (root) => {
+  try {
+    return fs.readdirSync(runsDir(root)).filter((n) => n.endsWith('.json'));
+  } catch {
+    return [];
+  }
+};
+
+const settleRecord = (record, alive = pidAlive) => {
+  if (record.status !== 'running' || alive(record.pid)) return record;
+  return { ...record, status: 'aborted' };
+};
+
+const readRuns = (root) => {
+  const dir = runsDir(root);
+  const records = [];
+  for (const name of listRunNames(root)) {
+    const record = readRecord(path.join(dir, name));
+    if (record) records.push(settleRecord(record));
+  }
+  return records.sort((left, right) => right.startedAt - left.startedAt);
+};
+
+const writeRecord = (root, record) => {
+  const dir = runsDir(root);
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, `${record.id}.json`);
+  const temp = `${file}.tmp`;
+  const text = JSON.stringify(record);
+  try {
+    fs.writeFileSync(temp, text);
+    fs.renameSync(temp, file);
+  } catch {
+    fs.writeFileSync(file, text);
+  }
+};
+
+const pruneRuns = (root) => {
+  const dir = runsDir(root);
+  const names = listRunNames(root).sort();
+  const extra = names.length - RUNS_KEEP;
+  for (let i = 0; i < extra; i++) {
+    fs.rmSync(path.join(dir, names[i]), { force: true });
+  }
+};
+
+const previousTotal = (root, command) => {
+  for (const record of readRuns(root)) {
+    if (record.command !== command) continue;
+    if (record.status === 'running' || record.status === 'aborted') continue;
+    const progress = record.progress ?? {};
+    const total = (progress.done ?? 0) + (progress.failed ?? 0);
+    if (total > 0) return total;
+  }
+  return 0;
+};
+
+const sumField = (reports, key) => {
+  let total = null;
+  for (const item of reports) {
+    const value = item.summary[key];
+    if (typeof value !== 'number') continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+};
+
+const summarizeDocument = (doc) => {
+  if (!doc || !Array.isArray(doc.reports)) return null;
+  const reports = doc.reports;
+  const durations = reports.map((item) => item.summary.duration);
+  let problems = 0;
+  for (const item of reports) problems += item.problems.length;
+  return {
+    tools: reports.map((item) => item.tool),
+    tests: sumField(reports, 'tests'),
+    passed: sumField(reports, 'passed'),
+    failed: sumField(reports, 'failed'),
+    skipped: sumField(reports, 'skipped'),
+    errors: sumField(reports, 'errors'),
+    warnings: sumField(reports, 'warnings'),
+    duration: durations.find(Boolean) ?? '',
+    problems,
+  };
+};
+
+const safely = (fn) => {
+  try {
+    fn();
+  } catch {
+    // run records are best effort
+  }
+};
+
+class RunRecorder {
+  constructor(root, command, options = {}) {
+    this.root = root;
+    this.clock = options.now ?? Date.now;
+    this.tracker = new Tracker();
+    this.lastWrite = 0;
+    this.closed = false;
+    const startedAt = this.clock();
+    const env = options.env || process.env;
+    this.record = {
+      v: 1,
+      id: `${startedAt}-${process.pid}`,
+      pid: process.pid,
+      command,
+      script: `${env[LIFECYCLE_EVENT] ?? ''}`.trim(),
+      cwd: root,
+      startedAt,
+      endedAt: 0,
+      status: 'running',
+      exit: null,
+      progress: { ...this.tracker.progress, expected: 0 },
+      result: null,
+    };
+    safely(() => {
+      this.record.progress.expected = previousTotal(root, command);
+      pruneRuns(root);
+      this.write();
+    });
+  }
+
+  write() {
+    Object.assign(this.record.progress, this.tracker.progress);
+    writeRecord(this.root, this.record);
+  }
+
+  feed(chunk) {
+    if (this.closed) return;
+    this.tracker.feed(chunk);
+    const now = this.clock();
+    if (now - this.lastWrite < WRITE_MS) return;
+    this.lastWrite = now;
+    safely(() => this.write());
+  }
+
+  finish(status, result = null) {
+    if (this.closed) return;
+    this.closed = true;
+    const record = this.record;
+    record.endedAt = this.clock();
+    record.exit = status;
+    record.status = status === 0 ? 'passed' : 'failed';
+    record.result = result;
+    safely(() => this.write());
+  }
+}
+
+module.exports = {
+  runsDir,
+  isRunsRel,
+  commandLabel,
+  Tracker,
+  settleRecord,
+  readRuns,
+  summarizeDocument,
+  RunRecorder,
+};