reslop 0.2.7 → 0.3.0

package/lib/review/store.js

@@ -0,0 +1,281 @@
+'use strict';
+
+const files = require('../common/files.js');
+const { ISSUE_FILE } = files;
+const { TASK_KINDS, taskKind } = files;
+const { upsertTemplate } = require('./templates.js');
+const { trimText } = require('../common/utilities.js');
+
+const noteCounts = (store) => {
+  const counts = { feedback: 0, tasks: 0, tasksDone: 0, code: 0 };
+  if (!store) return counts;
+  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;
+  }
+  counts.code = store.code.size;
+  return counts;
+};
+
+const reviewProgress = (store) => {
+  let done = 0;
+  let total = 0;
+  if (!store) return { done, total };
+  for (const task of store.tasks) {
+    if (!trimText(task.text)) continue;
+    total += 1;
+    if (task.done) done += 1;
+  }
+  for (const note of store.feedback.values()) {
+    total += 1;
+    if (note.done) done += 1;
+  }
+  for (const note of store.code.values()) {
+    total += 1;
+    if (note.done) done += 1;
+  }
+  return { done, total };
+};
+
+const hasNotes = (store) => {
+  const counts = noteCounts(store);
+  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 kindOrder = () => TASK_KINDS.map((kind) => kind.id);
+
+const feedbackSpots = (entries, file) => {
+  const spots = [];
+  for (let i = 0; i < entries.length; i++) {
+    const note = entries[i][1];
+    if ((note.file ?? '') !== file) continue;
+    if (!trimText(note.text)) continue;
+    spots.push(i);
+  }
+  return spots;
+};
+
+const checkLabel = (text, done) => {
+  const mark = done ? 'x' : ' ';
+  return `[${mark}] ${text}`;
+};
+
+const feedbackKey = (note) => {
+  const file = note.file ?? '';
+  const oldStart = note.oldStart ?? 0;
+  const newStart = note.newStart ?? 0;
+  const block = note.blockId ?? 0;
+  return `${file}:${oldStart}:${newStart}:${block}`;
+};
+
+const flatTaskText = (text) => trimText(text).replace(/\n/g, ' ');
+
+const knownTaskText = (store) => {
+  const known = new Set();
+  for (const task of store.tasks) known.add(flatTaskText(task.text));
+  return known;
+};
+
+class ReviewStore {
+  constructor(reviewPath, templates = []) {
+    this.reviewPath = reviewPath;
+    this.dirty = false;
+    this.nextTaskId = 1;
+    this.feedback = new Map();
+    this.code = new Map();
+    this.tasks = [];
+    this.templates = [...templates];
+    this.status = 'editing';
+    this.baseline = null;
+  }
+
+  reopen() {
+    if (this.status === 'done') this.status = 'editing';
+  }
+
+  putNote(notes, key, note, clear) {
+    const prev = notes.get(key);
+    if (clear) {
+      if (!prev) return;
+      notes.delete(key);
+      this.dirty = true;
+      return;
+    }
+    if (prev && prev.text === (note.text ?? '')) return;
+    notes.set(key, toNote(note, prev?.done));
+    this.dirty = true;
+    this.reopen();
+  }
+
+  setFeedback(key, note) {
+    const clear = !(note.text ?? '').trim();
+    this.putNote(this.feedback, key, note, clear);
+  }
+
+  setCode(key, note) {
+    this.putNote(this.code, key, note, Boolean(note.clear));
+  }
+
+  addTask(file, text = '', done = false, kind = 'features') {
+    const id = this.nextTaskId;
+    this.nextTaskId += 1;
+    const todo = { id, file, text, done, kind: taskKind({ kind }) };
+    this.tasks.push(todo);
+    this.dirty = true;
+    if (!done) this.reopen();
+    return todo;
+  }
+
+  removeTask(id) {
+    const tasks = this.tasks.filter((todo) => todo.id !== id);
+    if (tasks.length === this.tasks.length) return false;
+    this.tasks = tasks;
+    this.dirty = true;
+    return true;
+  }
+
+  setTaskText(id, text) {
+    const i = this.tasks.findIndex((todo) => todo.id === id);
+    if (i < 0) return;
+    if (!text.trim()) return void this.removeTask(id);
+    if (this.tasks[i].text === text) return;
+    this.tasks[i] = { ...this.tasks[i], text };
+    this.dirty = true;
+  }
+
+  setTaskDone(id, done) {
+    const i = this.tasks.findIndex((todo) => todo.id === id);
+    if (i < 0 || this.tasks[i].done === done) return;
+    this.tasks[i] = { ...this.tasks[i], done };
+    this.dirty = true;
+  }
+
+  setFeedbackDone(key, done) {
+    const note = this.feedback.get(key);
+    if (!note || note.done === done) return;
+    this.feedback.set(key, { ...note, done });
+    this.dirty = true;
+  }
+
+  moveTask(id, delta) {
+    if (!delta) return false;
+    const tasks = this.tasks;
+    const index = tasks.findIndex((task) => task.id === id);
+    if (index < 0) return false;
+    const task = tasks[index];
+    const kind = taskKind(task);
+    const order = kindOrder();
+    const same = [];
+    for (let i = 0; i < tasks.length; i++) {
+      if (taskKind(tasks[i]) === kind) same.push(i);
+    }
+    const at = same.indexOf(index);
+    const neighbor = same[at + delta];
+    if (neighbor !== undefined) {
+      const next = tasks.slice();
+      const swap = next[index];
+      next[index] = next[neighbor];
+      next[neighbor] = swap;
+      this.tasks = next;
+      this.dirty = true;
+      return true;
+    }
+    const dest = order[order.indexOf(kind) + delta];
+    if (!dest) return false;
+    const rest = [];
+    for (const item of tasks) {
+      if (item.id !== id) rest.push(item);
+    }
+    let insertAt = rest.length;
+    if (delta > 0) {
+      const first = rest.findIndex((item) => taskKind(item) === dest);
+      if (first >= 0) insertAt = first;
+    } else {
+      let last = -1;
+      for (let i = 0; i < rest.length; i++) {
+        if (taskKind(rest[i]) === dest) last = i;
+      }
+      insertAt = last + 1;
+    }
+    rest.splice(insertAt, 0, { ...task, kind: dest });
+    this.tasks = rest;
+    this.dirty = true;
+    return true;
+  }
+
+  moveFeedback(key, delta) {
+    if (!delta) return false;
+    const note = this.feedback.get(key);
+    if (!note) return false;
+    const entries = [...this.feedback];
+    const spots = feedbackSpots(entries, note.file ?? '');
+    const at = spots.findIndex((i) => entries[i][0] === key);
+    if (at < 0) return false;
+    const neighbor = spots[at + delta];
+    if (neighbor === undefined) return false;
+    const next = entries.slice();
+    const swap = next[spots[at]];
+    next[spots[at]] = next[neighbor];
+    next[neighbor] = swap;
+    this.feedback = new Map(next);
+    this.dirty = true;
+    return true;
+  }
+
+  applyImportedNotes(imported) {
+    if (!imported) return;
+    const feedbacks = imported.feedback ?? [];
+    for (const note of feedbacks) {
+      const key = feedbackKey(note);
+      const prev = this.feedback.get(key);
+      const text = prev ? `${prev.text}\n\n${note.text}` : note.text;
+      const done = prev ? prev.done && !!note.done : !!note.done;
+      this.setFeedback(key, { ...note, text, done });
+    }
+    const todos = imported.tasks ?? imported.todos ?? [];
+    const known = knownTaskText(this);
+    for (const todo of todos) {
+      const text = todo.text ?? '';
+      const file = todo.file || '';
+      const same = file === ISSUE_FILE && known.has(flatTaskText(text));
+      if (same) continue;
+      this.addTask(file, text, !!todo.done);
+      if (file === ISSUE_FILE) known.add(flatTaskText(text));
+    }
+  }
+
+  rememberTemplate(prevText, nextText) {
+    const trimmed = nextText.trim();
+    if (!trimmed) return;
+    const prev = (prevText ?? '').trim();
+    if (prev === trimmed) return;
+    this.templates = upsertTemplate(this.templates, trimmed);
+    this.dirty = true;
+  }
+}
+
+module.exports = {
+  ReviewStore,
+  noteCounts,
+  reviewProgress,
+  hasNotes,
+  toNote,
+  checkLabel,
+  feedbackKey,
+  flatTaskText,
+};

package/lib/review/templates.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const files = require('../common/files.js');
+const { REVIEW_DIR } = files;
+const { toInt } = require('../common/utilities.js');
+
+const TEMPLATE_SHOW = 5;
+
+const rankedTemplates = (templates) => {
+  const ranked = [...templates];
+  ranked.sort((a, b) => {
+    const byCount = b.count - a.count;
+    if (byCount) return byCount;
+    return a.text.localeCompare(b.text);
+  });
+  return ranked;
+};
+
+const prefixTemplates = (templates, prefix) => {
+  if (!prefix) return templates;
+  return templates.filter((entry) => entry.text.startsWith(prefix));
+};
+
+const upsertTemplate = (templates, text) => {
+  const trimmed = text.trim();
+  if (!trimmed) return templates;
+  const next = [...templates];
+  const i = next.findIndex((entry) => entry.text === trimmed);
+  if (i < 0) {
+    next.push({ text: trimmed, count: 1 });
+    return next;
+  }
+  const prev = next[i];
+  next[i] = { text: prev.text, count: prev.count + 1 };
+  return next;
+};
+
+const TEMPLATES_FILE = '.templates';
+
+const LEGACY_TEMPLATES = 'templates.json';
+
+const templateEntries = (data) => {
+  if (!Array.isArray(data)) return [];
+  const templates = [];
+  for (const entry of data) {
+    if (!entry || typeof entry.text !== 'string') continue;
+    const count = toInt(entry.count);
+    templates.push({
+      text: entry.text,
+      count: Number.isFinite(count) ? count : 1,
+    });
+  }
+  return templates;
+};
+
+const readTemplateFile = (file) => {
+  try {
+    return templateEntries(JSON.parse(fs.readFileSync(file, 'utf8')));
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return null;
+    return [];
+  }
+};
+
+const loadTemplates = (dir) => {
+  const folder = path.join(dir, REVIEW_DIR);
+  const current = readTemplateFile(path.join(folder, TEMPLATES_FILE));
+  if (current) return current;
+  const legacy = readTemplateFile(path.join(folder, LEGACY_TEMPLATES));
+  return legacy ?? [];
+};
+
+module.exports = {
+  TEMPLATE_SHOW,
+  rankedTemplates,
+  prefixTemplates,
+  upsertTemplate,
+  TEMPLATES_FILE,
+  LEGACY_TEMPLATES,
+  loadTemplates,
+};

package/lib/runs/commands.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { npmBin, npmOpts } = require('../common/process.js');
+const { commandEnv, PipeProcess } = require('./process.js');
+
+const startNpm = (cwd, entry, onData, onClose) => {
+  const isBin = entry.kind === 'bin';
+  const args = isBin ? ['exec', '--', entry.name] : ['run', entry.name];
+  const detached = process.platform !== 'win32';
+  const options = npmOpts({ cwd, env: commandEnv(), detached });
+  return new PipeProcess(onData, onClose).start(npmBin(), args, options);
+};
+
+module.exports = { startNpm };

package/lib/runs/logs.js

@@ -0,0 +1,299 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { stripAnsi } = require('../term/ansi.js');
+const utilities = require('../common/utilities.js');
+const { pad2 } = utilities;
+const { readJson } = utilities;
+const { dateStamp, readText } = utilities;
+const { isHashObject } = require('metautil');
+const { LOG_DIR } = require('../common/files.js');
+
+const safeName = (name) => `${name}`.replace(/[^A-Za-z0-9._-]+/g, '-');
+
+const logFileName = (command, date, index) => {
+  const safe = safeName(command);
+  const n = pad2(index);
+  return `${date}-${safe}-${n}.log`;
+};
+
+const LOG_STALE_DAYS = 5;
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const LOG_DATE = /^(\d{4})-(\d{2})-(\d{2})-/;
+
+const logDay = (name) => {
+  const match = LOG_DATE.exec(name);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  return Date.UTC(year, month - 1, day) / DAY_MS;
+};
+
+const todayIndex = (now) =>
+  Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()) / DAY_MS;
+
+const isStaleLog = (name, now) => {
+  const day = logDay(name);
+  if (day === null) return false;
+  return todayIndex(now) - day > LOG_STALE_DAYS;
+};
+
+const readLogNames = (dir) => {
+  try {
+    return fs.readdirSync(dir);
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+};
+
+const staleLogFiles = (root, now = new Date()) => {
+  const dir = path.join(root, LOG_DIR);
+  const files = [];
+  let bytes = 0;
+  for (const name of readLogNames(dir)) {
+    if (!/\.(?:log|raw|json)$/.test(name) || !isStaleLog(name, now)) continue;
+    const full = path.join(dir, name);
+    let stat = null;
+    try {
+      stat = fs.statSync(full);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+    if (!stat || !stat.isFile()) continue;
+    bytes += stat.size;
+    files.push(full);
+  }
+  return { bytes, files };
+};
+
+const removeStaleLogs = (root, now = new Date()) => {
+  const found = staleLogFiles(root, now);
+  for (const full of found.files) fs.rmSync(full, { force: true });
+  return found.bytes;
+};
+
+const logSlot = (dir, name) => {
+  const stem = name.replace(/\.log$/, '');
+  const rawName = `${stem}.raw`;
+  const jsonName = `${stem}.json`;
+  const full = path.join(dir, name);
+  const rawFull = path.join(dir, rawName);
+  const jsonFull = path.join(dir, jsonName);
+  const legacy = path.join(dir, `${stem}.raw.log`);
+  return { name, full, dir, rawName, rawFull, jsonName, jsonFull, legacy };
+};
+
+const slotTaken = (slot) => {
+  const log = fs.existsSync(slot.full);
+  const raw = fs.existsSync(slot.rawFull);
+  const json = fs.existsSync(slot.jsonFull);
+  const legacy = fs.existsSync(slot.legacy);
+  return log || raw || json || legacy;
+};
+
+const nextLogFile = (root, command, now = new Date()) => {
+  const date = dateStamp(now);
+  const dir = path.join(root, LOG_DIR);
+  let slot = null;
+  for (let index = 1; index <= 100; index++) {
+    slot = logSlot(dir, logFileName(command, date, index));
+    if (!slotTaken(slot)) break;
+  }
+  return slot;
+};
+
+const logText = (text) =>
+  stripAnsi(text)
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n');
+
+const RUN_MARK = 'npm-run';
+
+const LOG_FILE = /^(\d{4}-\d{2}-\d{2})-(.+)-(\d{2})\.log$/;
+
+const AGENT_LOG = /-agent-\d{2}\.log$/;
+
+const fileName = (name) => {
+  const file = `${name ?? ''}`;
+  if (!file || file.includes('/') || file.includes('\\')) return '';
+  return file;
+};
+
+const runMeta = (run, slot) => ({
+  reslop: RUN_MARK,
+  name: run.name,
+  kind: run.kind === 'bin' ? 'bin' : 'script',
+  command: `${run.command ?? ''}`,
+  status: run.status === 'stopped' ? 'stopped' : 'exited',
+  exit: run.status === 'stopped' ? '' : run.exit,
+  startedAt: Number(run.startedAt) || 0,
+  endedAt: Number(run.endedAt) || 0,
+  log: slot.name,
+  raw: slot.rawName,
+  result: run.result ?? null,
+  progress: run.progress ?? null,
+});
+
+const saveLogs = async (slot, reduced, raw, run) => {
+  await fs.promises.mkdir(slot.dir, { recursive: true });
+  const writes = [
+    fs.promises.writeFile(slot.full, logText(reduced)),
+    fs.promises.writeFile(slot.rawFull, logText(raw)),
+  ];
+  if (run) {
+    const body = `${JSON.stringify(runMeta(run, slot), null, 2)}\n`;
+    writes.push(fs.promises.writeFile(slot.jsonFull, body));
+  }
+  await Promise.all(writes);
+};
+
+const readObject = (file) => {
+  const data = readJson(file);
+  return isHashObject(data) ? data : null;
+};
+
+const storedExit = (data) => {
+  if (data.status === 'stopped') return '';
+  if (typeof data.exit === 'number' && Number.isInteger(data.exit)) {
+    return data.exit;
+  }
+  if (typeof data.exit === 'string' && /^-?\d+$/.test(data.exit)) {
+    return Number(data.exit);
+  }
+  return '';
+};
+
+const savedFromRecord = (data) => {
+  if (!data || data.reslop !== RUN_MARK) return null;
+  const name = `${data.name ?? ''}`;
+  const logName = fileName(data.log);
+  if (!name || !logName) return null;
+  const startedAt = Number(data.startedAt) || 0;
+  const endedAt = Number(data.endedAt) || startedAt;
+  return {
+    name,
+    kind: data.kind === 'bin' ? 'bin' : 'script',
+    command: `${data.command ?? ''}`,
+    status: data.status === 'stopped' ? 'stopped' : 'exited',
+    exit: storedExit(data),
+    startedAt,
+    endedAt,
+    logName,
+    rawName: fileName(data.raw),
+    result: data.result ?? null,
+    progress: data.progress ?? null,
+  };
+};
+
+const exitOf = (text) => {
+  const lines = `${text ?? ''}`.split('\n');
+  while (lines.length && lines.at(-1) === '') lines.pop();
+  const last = lines.at(-1) ?? '';
+  if (last === 'terminated') return { status: 'stopped', exit: '' };
+  const match = /^exit (.+)$/.exec(last);
+  if (!match) return { status: 'exited', exit: '' };
+  if (match[1] === 'null') return { status: 'stopped', exit: '' };
+  const code = Number(match[1]);
+  if (!Number.isInteger(code)) return { status: 'exited', exit: '' };
+  return { status: 'exited', exit: code };
+};
+
+const commandFor = (commands, safe) => {
+  const hits = [];
+  for (const entry of commands) {
+    if (safeName(entry.name) === safe) hits.push(entry);
+  }
+  for (const entry of hits) {
+    if (entry.name === safe && entry.kind === 'script') return entry;
+  }
+  for (const entry of hits) {
+    if (entry.kind === 'script') return entry;
+  }
+  return hits[0] || null;
+};
+
+const legacyRun = (dir, name, names, commands) => {
+  const match = LOG_FILE.exec(name);
+  if (!match) return null;
+  const stem = name.replace(/\.log$/, '');
+  const linked = commandFor(commands, match[2]);
+  const text = readText(path.join(dir, name));
+  const outcome = exitOf(text);
+  let endedAt = 0;
+  try {
+    endedAt = fs.statSync(path.join(dir, name)).mtimeMs;
+  } catch {
+    // missing log
+  }
+  const rawFile = `${stem}.raw`;
+  return {
+    name: linked ? linked.name : match[2],
+    kind: linked ? linked.kind : 'script',
+    command: linked ? `${linked.command ?? ''}` : '',
+    status: outcome.status,
+    exit: outcome.exit,
+    startedAt: endedAt,
+    endedAt,
+    logName: name,
+    rawName: names.includes(rawFile) ? rawFile : '',
+  };
+};
+
+const readSavedRuns = (root, commands = []) => {
+  const dir = path.join(root, LOG_DIR);
+  const names = readLogNames(dir);
+  const runs = [];
+  const seen = new Set();
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const saved = savedFromRecord(readObject(path.join(dir, name)));
+    if (!saved || seen.has(saved.logName)) continue;
+    seen.add(saved.logName);
+    runs.push(saved);
+  }
+  for (const name of names) {
+    if (!LOG_FILE.test(name) || AGENT_LOG.test(name) || seen.has(name)) {
+      continue;
+    }
+    const stem = name.replace(/\.log$/, '');
+    if (names.includes(`${stem}.json`)) continue;
+    const saved = legacyRun(dir, name, names, commands);
+    if (!saved) continue;
+    seen.add(saved.logName);
+    runs.push(saved);
+  }
+  runs.sort((left, right) => {
+    const at = left.startedAt - right.startedAt;
+    if (at) return at;
+    return left.logName.localeCompare(right.logName);
+  });
+  return runs;
+};
+
+const readLogPair = (root, logName, rawName) => {
+  const dir = path.join(root, LOG_DIR);
+  const log = fileName(logName);
+  const raw = fileName(rawName);
+  return {
+    output: log ? readText(path.join(dir, log)) : '',
+    raw: raw ? readText(path.join(dir, raw)) : '',
+  };
+};
+
+module.exports = {
+  logFileName,
+  staleLogFiles,
+  removeStaleLogs,
+  nextLogFile,
+  logText,
+  saveLogs,
+  readSavedRuns,
+  readLogPair,
+};