reslop 0.2.6 → 0.3.0

package/lib/cli.js

@@ -2,50 +2,27 @@
 
 const path = require('node:path');
 
-const metautil = require('metautil');
-const { exists } = metautil;
-
-const git = require('./git.js');
-const { createGitRepo } = git;
-const github = require('./github.js');
-const { githubToken, loadPullRequest } = github;
-const gitlab = require('./gitlab.js');
-const { gitlabToken, loadMergeRequest } = gitlab;
-const source = require('./source.js');
-const { selectChangeSource, createLoadedSource } = source;
-const session = require('./session.js');
-const { Session } = session;
-const capabilities = require('./capabilities.js');
-const { capabilitiesFor, attachCapabilities } = capabilities;
-const ansi = require('./ansi.js');
-const { setTheme } = ansi;
-const reportRun = require('./report-run.js');
-const { runCapture } = reportRun;
+const { exists } = require('metautil');
+
+const { errorMessage } = require('./common/utilities.js');
+const { createGitRepo } = require('./git/git.js');
+const source = require('./source/source.js');
+const { remoteKind, selectChangeSource, createLoadedSource } = source;
+const { Session } = require('./session/session.js');
+const { hasNotes } = require('./review/review.js');
+const {
+  capabilitiesFor,
+  attachCapabilities,
+} = require('./source/capabilities.js');
+const { runCapture } = require('./report/run.js');
+const { workspaceFromArgs } = require('./dashboard/workspace.js');
 
 const HEX_REV = /^[0-9a-f]{4,40}$/i;
 const HEAD_REV = /^HEAD([~^].*)?$/i;
 const RANGE_REV = /[~^]/;
 
 const USAGE =
-  'Usage: reslop [-n] [-r] [-light] [path | commit | pr-url | mr-url]';
-
-const REMOTE_CHANGE = {
-  pr: {
-    load: 'loadPullRequest',
-    fallback: loadPullRequest,
-    token: githubToken,
-    target: (selected) => selected.pr,
-  },
-  mr: {
-    load: 'loadMergeRequest',
-    fallback: loadMergeRequest,
-    token: gitlabToken,
-    target: (selected) => selected.mr,
-  },
-};
-
-const errorMessage = (reason) =>
-  reason instanceof Error ? reason.message : `${reason ?? ''}`;
+  'Usage: reslop [-r] [path | commit | pr-url | mr-url | issue-url]';
 
 const fail = (stderr, reason) => {
   stderr.write(`reslop: ${errorMessage(reason)}\n`);
@@ -54,27 +31,27 @@ const fail = (stderr, reason) => {
 
 const parseArgv = (argv) => {
   const paths = [];
-  let newReview = false;
   let readOnly = false;
-  let theme = 'dark';
   for (const arg of argv) {
-    if (arg === '-n') newReview = true;
-    else if (arg === '-r') readOnly = true;
-    else if (arg === '-light') theme = 'light';
+    if (arg === '-r') readOnly = true;
     else if (arg.startsWith('-')) throw new Error(`unknown option ${arg}`);
     else paths.push(arg);
   }
-  return { paths, newReview, readOnly, theme };
+  return { paths, readOnly };
 };
 
-const looksLikeRev = (spec) =>
-  HEX_REV.test(spec) || HEAD_REV.test(spec) || RANGE_REV.test(spec);
+const looksLikeRev = (spec) => {
+  const hex = HEX_REV.test(spec);
+  const head = HEAD_REV.test(spec);
+  const range = RANGE_REV.test(spec);
+  return hex || head || range;
+};
 
 const resolveScope = async (cwd, paths, repo) => {
   if (!paths.length) return { rev: null, paths };
   const first = paths[0];
   if (await exists(path.resolve(cwd, first))) return { rev: null, paths };
-  const resolved = repo.resolveRev(cwd, first);
+  const resolved = await repo.resolveRev(cwd, first);
   if (resolved) {
     if (paths.length > 1) throw new Error('use a commit or a path, not both');
     return { rev: resolved, paths: [] };
@@ -85,6 +62,20 @@ const resolveScope = async (cwd, paths, repo) => {
 
 const localOptions = async (deps, args, selected, cwd) => {
   const rawRepo = deps.repo ?? createGitRepo();
+  const found = workspaceFromArgs(cwd, selected.paths);
+  if (found) {
+    const capabilities = capabilitiesFor('local', { readOnly: args.readOnly });
+    return {
+      cwd: found.root,
+      repo: attachCapabilities(rawRepo, capabilities),
+      paths: [],
+      rev: null,
+      capabilities,
+      startPane: 'repos',
+      workspace: found,
+      repoName: path.basename(found.root),
+    };
+  }
   const scope = await resolveScope(cwd, selected.paths, rawRepo);
   const kind = scope.rev ? 'commit' : 'local';
   const capabilities = capabilitiesFor(kind, { readOnly: args.readOnly });
@@ -100,22 +91,21 @@ const localOptions = async (deps, args, selected, cwd) => {
 
 const remoteRepo = (deps, selected, env, cwd) => {
   if (deps.repo) return deps.repo;
-  const remote = REMOTE_CHANGE[selected.kind];
-  const loader = deps[remote.load] ?? remote.fallback;
+  const remote = remoteKind(selected);
+  const loader = deps[remote.option] ?? remote.load;
   const token = remote.token(env);
   const loadRemote = async (_cwd, _paths, options = {}) => {
-    const loaded = await loader(remote.target(selected), {
-      cwd,
-      paths: selected.paths,
-      token,
-      fetch: deps.fetch,
-      signal: options.signal,
-    });
+    const target = remote.target(selected);
+    const paths = selected.paths;
+    const fetch = deps.fetch;
+    const signal = options.signal;
+    const request = { cwd, paths, token, fetch, signal };
+    const loaded = await loader(target, request);
     const items = loaded.items ?? [];
     return { ...loaded, items: [...items] };
   };
   return createLoadedSource({ items: [] }, selected.kind, {
-    loadAsync: loadRemote,
+    load: loadRemote,
   });
 };
 
@@ -129,7 +119,8 @@ const loadSession = async (proc, deps, args) => {
   const env = proc.env ?? {};
   const cwd = deps.cwd ?? proc.cwd();
   const selected = selectChangeSource(args.paths);
-  const extra = REMOTE_CHANGE[selected.kind]
+  const kind = remoteKind(selected);
+  const extra = kind
     ? remoteOptions(deps, args, selected, cwd, env)
     : await localOptions(deps, args, selected, cwd);
   const session = new Session({
@@ -138,12 +129,11 @@ const loadSession = async (proc, deps, args) => {
     stdout: proc.stdout,
     color: proc.stdout.isTTY === true && !env.NO_COLOR,
     startPane: 'files',
-    newReview: args.newReview,
     readOnly: args.readOnly,
     audit: true,
     ...extra,
   });
-  session.ensureRepo();
+  if (session.pane !== 'repos') await session.ensureRepo();
   return session;
 };
 
@@ -159,29 +149,34 @@ const run = async (proc, deps = {}) => {
   if (argv[0] === 't') return runCapture(proc, deps);
   const stdout = proc.stdout;
   const stderr = proc.stderr;
-  let args;
+  let args = null;
   try {
     args = parseArgv(argv);
   } catch (error) {
     fail(stderr, error);
     stderr.write(`${USAGE}\n`);
-    return 1;
   }
-  setTheme(args.theme);
-  let session;
+  if (!args) return 1;
+  let session = null;
   try {
     session = await loadSession(proc, deps, args);
   } catch (error) {
-    return fail(stderr, error);
+    fail(stderr, error);
   }
+  if (!session) return 1;
   const tty = proc.stdin.isTTY === true && stdout.isTTY === true;
   if (tty) return runUi(session, proc);
+  if (session.pane === 'repos') {
+    stderr.write('reslop: interactive terminal required\n');
+    return 1;
+  }
   try {
     await session.loadReady();
   } catch (error) {
     return fail(stderr, error);
   }
-  if (!session.items.length) {
+  const noted = session.notes ? hasNotes(session.notes) : false;
+  if (!session.items.length && !noted) {
     stdout.write('nothing to review\n');
     return 0;
   }

package/lib/{files.js → common/files.js}

@@ -1,24 +1,21 @@
 'use strict';
 
-const manifest = require('./manifest.js');
-const { listFilePath } = manifest;
+const path = require('node:path');
 
-const REVIEW_DIR = '.review';
+const REVIEW_DIR = '.plan';
+const LOG_DIR = '.log';
+const ISSUE_FILE = 'issue';
 const ORIGIN_ORDER = ['staged', 'unstaged', 'untracked', 'commit', 'pr'];
 const TASKS_FILE = 'TODOs';
-const REPO_TASKS_LABEL =
-  'Project Tasks: Backlog, Issues, Bug Reports, Feature Requests';
-const TASK_KINDS = [
-  { id: 'backlog', title: 'Backlog' },
-  { id: 'issues', title: 'Issues' },
-  { id: 'bugs', title: 'Bug Reports' },
-  { id: 'features', title: 'Feature Requests' },
-];
-const TASK_KIND_IDS = new Set(TASK_KINDS.map((kind) => kind.id));
+const { label: REPO_TASKS_LABEL, kinds: TASK_KINDS } = require('./tasks.json');
+
+const TASK_KIND_IDS = TASK_KINDS.map((kind) => kind.id);
+const TASK_KIND_ALIAS = { backlog: 'debt', issues: 'debt' };
 
 const taskKind = (todo) => {
   const kind = todo && todo.kind;
-  return TASK_KIND_IDS.has(kind) ? kind : 'backlog';
+  if (TASK_KIND_IDS.includes(kind)) return kind;
+  return TASK_KIND_ALIAS[kind] ?? 'debt';
 };
 
 const taskTitle = (id) => {
@@ -28,17 +25,9 @@ const taskTitle = (id) => {
   return TASK_KINDS[0].title;
 };
 const TOTAL_LABEL = 'total';
-const AGE_UNIT = {
-  second: 's',
-  minute: 'm',
-  hour: 'h',
-  day: 'd',
-  week: 'w',
-  month: 'mo',
-  year: 'y',
-};
-const AGE_AGO = /^(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago$/i;
-const AGE_SHORT = /^(\d+)(mo|[smhdwy])(?: ago)?$/i;
+const MANIFEST = 'package.json';
+const LOCKFILE = 'package-lock.json';
+const DEP_KIND = { [MANIFEST]: 'manifest', [LOCKFILE]: 'lockfile' };
 
 const isPathInScope = (rel, paths) => {
   if (!paths.length) return true;
@@ -52,6 +41,34 @@ const isPathInScope = (rel, paths) => {
 
 const itemPath = (item) => item?.file?.newPath || item?.file?.oldPath || '';
 
+const posixRel = (rel) => `${rel ?? ''}`.replaceAll('\\', '/');
+
+const depFileMeta = (rel) => {
+  const normalized = posixRel(rel);
+  const kind = DEP_KIND[path.posix.basename(normalized)];
+  if (!normalized || !kind) return null;
+  return { kind, dir: path.posix.dirname(normalized) };
+};
+
+const relOf = (dir, name) => (dir === '.' ? name : `${dir}/${name}`);
+
+const listFilePath = (rel) => {
+  const meta = depFileMeta(rel);
+  if (meta && meta.kind === 'lockfile') return relOf(meta.dir, MANIFEST);
+  return posixRel(rel);
+};
+
+const groupByPath = (items) => {
+  const byPath = new Map();
+  for (const item of items) {
+    const rel = itemPath(item);
+    const list = byPath.get(rel);
+    if (list) list.push(item);
+    else byPath.set(rel, [item]);
+  }
+  return byPath;
+};
+
 const listPath = (item) => listFilePath(itemPath(item));
 
 const isTaskItem = (item) => item?.origin === 'task';
@@ -97,32 +114,6 @@ const lineDelta = ({ hunk, blockId }) => {
   return delta;
 };
 
-const shortUnit = (n, unit) => `${n}${AGE_UNIT[unit]} ago`;
-
-const shortAge = (text) => {
-  const raw = `${text ?? ''}`.trim();
-  if (/^yesterday$/i.test(raw)) return '1d ago';
-  const match = AGE_AGO.exec(raw);
-  if (match) return shortUnit(match[1], match[2].toLowerCase());
-  const brief = AGE_SHORT.exec(raw);
-  if (brief) return `${brief[1]}${brief[2].toLowerCase()} ago`;
-  return raw;
-};
-
-const relativeAge = (thenMs, nowMs = Date.now()) => {
-  const diff = Math.max(0, Math.round((nowMs - thenMs) / 1000));
-  if (diff < 90) return shortUnit(diff, 'second');
-  const minutes = Math.round(diff / 60);
-  if (minutes < 90) return shortUnit(minutes, 'minute');
-  const hours = Math.round(minutes / 60);
-  if (hours < 36) return shortUnit(hours, 'hour');
-  const days = Math.round(hours / 24);
-  if (days < 14) return shortUnit(days, 'day');
-  if (days < 70) return shortUnit(Math.round(days / 7), 'week');
-  if (days < 365) return shortUnit(Math.round(days / 30), 'month');
-  return shortUnit(Math.round(days / 365), 'year');
-};
-
 const emptyCounts = () => ({
   remaining: 0,
   added: 0,
@@ -221,12 +212,21 @@ const fileTotals = (files) => {
 
 module.exports = {
   REVIEW_DIR,
+  LOG_DIR,
+  ISSUE_FILE,
+  posixRel,
+  groupByPath,
   TASKS_FILE,
   REPO_TASKS_LABEL,
   TASK_KINDS,
   taskKind,
   taskTitle,
   TOTAL_LABEL,
+  MANIFEST,
+  LOCKFILE,
+  depFileMeta,
+  relOf,
+  listFilePath,
   isPathInScope,
   itemPath,
   listPath,
@@ -236,8 +236,7 @@ module.exports = {
   isTotalEntry,
   makeTaskItem,
   fileStatus,
+  lineDelta,
   fileEntries,
   fileTotals,
-  relativeAge,
-  shortAge,
 };

package/lib/common/find.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const matchesIn = (text, query) => {
+  const spans = [];
+  if (!query || !text) return spans;
+  const hay = text.toLowerCase();
+  const needle = query.toLowerCase();
+  const step = needle.length;
+  let from = 0;
+  while (from <= hay.length - step) {
+    const at = hay.indexOf(needle, from);
+    if (at < 0) break;
+    spans.push({ start: at, end: at + step });
+    from = at + step;
+  }
+  return spans;
+};
+
+const fileMatches = (entries, query) => {
+  const hits = [];
+  if (!query) return hits;
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const path = entry && entry.path ? entry.path : '';
+    if (!path) continue;
+    for (const span of matchesIn(path, query)) {
+      hits.push({ index, path, start: span.start, end: span.end });
+    }
+  }
+  return hits;
+};
+
+const activeHit = (entries, find) => {
+  if (!find || !find.query) return null;
+  const hits = fileMatches(entries, find.query);
+  if (!hits.length) return null;
+  const count = hits.length;
+  let at = find.at % count;
+  if (at < 0) at += count;
+  return hits[at];
+};
+
+const keptPrefix = (shown, full) => {
+  const mark = shown.endsWith('…') && shown !== full ? 1 : 0;
+  const keep = shown.length - mark;
+  if (!full.startsWith(shown.slice(0, keep))) return -1;
+  return keep;
+};
+
+const spansFor = (shown, full, query, hit) => {
+  const spans = matchesIn(shown, query);
+  if (!hit || hit.path !== full) return spans;
+  const keep = keptPrefix(shown, full);
+  if (keep < 0 || hit.start >= keep) return spans;
+  return spans.map((span) => ({
+    ...span,
+    on: span.start === hit.start,
+  }));
+};
+
+module.exports = { fileMatches, activeHit, spansFor };

package/lib/common/format.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { bytesToSize } = require('metautil');
+const { trimText, pad2 } = require('./utilities.js');
+
+const AGE_UNIT = {
+  second: 's',
+  minute: 'm',
+  hour: 'h',
+  day: 'd',
+  week: 'w',
+  month: 'mo',
+  year: 'y',
+};
+const AGE_AGO = /^(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago$/i;
+const AGE_SHORT = /^(\d+)(mo|[smhdwy])(?: ago)?$/i;
+const SECONDS_AGO = /^\d+s ago$/;
+
+const shortUnit = (n, unit) => `${n}${AGE_UNIT[unit]} ago`;
+
+const AGE_SEC = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+  w: 604800,
+  mo: 2592000,
+  y: 31536000,
+};
+
+const ageParts = (text) => {
+  const raw = trimText(text);
+  if (/^yesterday$/i.test(raw)) return { count: 1, unit: 'd' };
+  const long = AGE_AGO.exec(raw);
+  if (long) return { count: long[1], unit: AGE_UNIT[long[2].toLowerCase()] };
+  const brief = AGE_SHORT.exec(raw);
+  if (brief) return { count: brief[1], unit: brief[2].toLowerCase() };
+  return null;
+};
+
+const shortAge = (text) => {
+  const age = ageParts(text);
+  return age ? `${age.count}${age.unit} ago` : trimText(text);
+};
+
+const ageSeconds = (text) => {
+  const age = ageParts(text);
+  if (!age) return Number.POSITIVE_INFINITY;
+  return Number(age.count) * AGE_SEC[age.unit];
+};
+
+const relativeAge = (thenMs, nowMs = Date.now()) => {
+  const diff = Math.max(0, Math.round((nowMs - thenMs) / 1000));
+  if (diff < 90) return shortUnit(diff, 'second');
+  const minutes = Math.round(diff / 60);
+  if (minutes < 90) return shortUnit(minutes, 'minute');
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return shortUnit(hours, 'hour');
+  const days = Math.round(hours / 24);
+  if (days < 14) return shortUnit(days, 'day');
+  if (days < 70) return shortUnit(Math.round(days / 7), 'week');
+  if (days < 365) return shortUnit(Math.round(days / 30), 'month');
+  return shortUnit(Math.round(days / 365), 'year');
+};
+
+const trimmed = (value) =>
+  value >= 10 ? `${Math.round(value)}` : `${Math.round(value * 10) / 10}`;
+
+const num = (value) => {
+  const n = Math.max(0, Math.round(value));
+  if (n >= 1e6) return `${trimmed(n / 1e6)}m`;
+  if (n >= 1e4) return `${trimmed(n / 1e3)}k`;
+  return `${n}`;
+};
+
+const size = (bytes) => bytesToSize(bytes > 0 ? bytes : 0);
+
+const ago = (at, now) => {
+  if (!at) return '';
+  const text = relativeAge(at, now);
+  return SECONDS_AGO.test(text) ? '<1m ago' : text;
+};
+
+const duration = (ms) => {
+  const value = Math.max(0, ms);
+  if (value < 1000) return `${Math.round(value)}ms`;
+  if (value < 60000) return `${(value / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(value / 60000);
+  const seconds = Math.floor((value % 60000) / 1000);
+  return `${minutes}m${pad2(seconds)}s`;
+};
+
+module.exports = {
+  shortAge,
+  ageSeconds,
+  relativeAge,
+  num,
+  size,
+  ago,
+  duration,
+};

package/lib/{utilities.js → common/process.js}

@@ -1,48 +1,12 @@
 'use strict';
 
-const childProcess = require('node:child_process');
-const { spawn, spawnSync } = childProcess;
-const metautil = require('metautil');
-const { split } = metautil;
+const { spawn } = require('node:child_process');
 
 const IS_WIN = process.platform === 'win32';
+const INSTALL_MS = 120000;
 const DEFAULT_ENCODING = 'utf8';
 const DEFAULT_MAX_BUFFER = 32 * 1024 * 1024;
 
-const parseVersion = (text) => {
-  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(`${text ?? ''}`);
-  if (!match) return null;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  const patch = Number(match[3]);
-  return { major, minor, patch };
-};
-
-const cmpVersion = (left, right) =>
-  left.major - right.major ||
-  left.minor - right.minor ||
-  left.patch - right.patch;
-
-const oneLine = (text, fallback = '') =>
-  split(`${text ?? ''}`.trim(), '\n')[0] || fallback;
-
-const asText = (value) => (typeof value === 'string' ? value : '');
-
-const unquote = (value) => {
-  const text = `${value ?? ''}`;
-  if (text.length < 2) return text;
-  const open = text[0];
-  const quoted = open === text.at(-1) && (open === '"' || open === '\x27');
-  return quoted ? text.slice(1, -1) : text;
-};
-
-const pad2 = (n) => `${n}`.padStart(2, '0');
-
-const dateStamp = (date) => {
-  const month = pad2(date.getMonth() + 1);
-  return `${date.getFullYear()}-${month}-${pad2(date.getDate())}`;
-};
-
 const npmBin = () => (IS_WIN ? 'npm.cmd' : 'npm');
 
 const spawnBase = (extra = {}) => ({ windowsHide: true, ...extra });
@@ -50,36 +14,6 @@ const spawnBase = (extra = {}) => ({ windowsHide: true, ...extra });
 const npmOpts = (extra = {}, platform = process.platform) =>
   spawnBase({ shell: platform === 'win32', ...extra });
 
-const listen = (emitter, event, handler) => {
-  if (!emitter || typeof emitter.on !== 'function') return () => {};
-  emitter.on(event, handler);
-  return () => {
-    if (typeof emitter.removeListener === 'function') {
-      return void emitter.removeListener(event, handler);
-    }
-    if (typeof emitter.off === 'function') emitter.off(event, handler);
-  };
-};
-
-const watchResize = (stdout, proc, onResize, signal) => {
-  const stopStdout = listen(stdout, 'resize', onResize);
-  let stopProc = () => {};
-  try {
-    stopProc = listen(proc, 'SIGWINCH', onResize);
-  } catch {
-    // SIGWINCH is not available on Windows
-  }
-  const stop = () => {
-    stopStdout();
-    stopProc();
-  };
-  if (signal) {
-    if (signal.aborted) stop();
-    else signal.addEventListener('abort', stop, { once: true });
-  }
-  return stop;
-};
-
 const codeError = (message, code) =>
   Object.assign(new Error(message), { code });
 
@@ -94,19 +28,6 @@ const procResult = (values = {}) => ({
   error: values.error ?? null,
 });
 
-const runProcSync = (cmd, args, options = {}) => {
-  const opts = spawnBase({
-    cwd: options.cwd,
-    env: options.env,
-    encoding: options.encoding ?? DEFAULT_ENCODING,
-    input: options.input,
-    maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
-    timeout: options.timeout,
-  });
-  if (options.shell) opts.shell = true;
-  return procResult(spawnSync(cmd, args, opts));
-};
-
 const listenChild = (child, options, resolve) => {
   const encoding = options.encoding ?? DEFAULT_ENCODING;
   const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
@@ -156,6 +77,8 @@ const listenChild = (child, options, resolve) => {
     finish(procResult({ status, stdout, stderr }));
   });
   if (!child.stdin) return;
+  // A child that exits before reading its input reports that by its status
+  child.stdin.on('error', () => {});
   try {
     if (options.input) child.stdin.end(options.input);
     else child.stdin.end();
@@ -173,34 +96,23 @@ const runProc = (cmd, args, options = {}) =>
     }
     const spawnOpts = { cwd: options.cwd, env: options.env };
     if (options.shell) spawnOpts.shell = true;
-    let child;
+    let child = null;
     try {
       child = spawn(cmd, args, spawnBase(spawnOpts));
     } catch (error) {
       resolve(procResult({ error }));
-      return;
     }
+    if (!child) return;
     listenChild(child, options, resolve);
   });
 
 module.exports = {
   IS_WIN,
-  DEFAULT_ENCODING,
-  DEFAULT_MAX_BUFFER,
-  parseVersion,
-  cmpVersion,
-  oneLine,
-  asText,
-  unquote,
-  pad2,
-  dateStamp,
+  INSTALL_MS,
   npmBin,
   spawnBase,
   npmOpts,
-  listen,
-  watchResize,
   abortError,
   isAbort,
-  runProcSync,
   runProc,
 };