reslop 0.2.5 → 0.2.7

package/lib/utilities.js

@@ -9,16 +9,12 @@ const IS_WIN = process.platform === 'win32';
 const DEFAULT_ENCODING = 'utf8';
 const DEFAULT_MAX_BUFFER = 32 * 1024 * 1024;
 
-const UNIX_CLIP = [
-  { cmd: 'wl-copy', args: [] },
-  { cmd: 'xclip', args: ['-selection', 'clipboard'] },
-  { cmd: 'xsel', args: ['--clipboard', '--input'] },
-];
-
 const parseVersion = (text) => {
   const match = /^(\d+)\.(\d+)\.(\d+)/.exec(`${text ?? ''}`);
   if (!match) return null;
-  const [, major, minor, patch] = match.map(Number);
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
   return { major, minor, patch };
 };
 
@@ -47,20 +43,13 @@ const dateStamp = (date) => {
   return `${date.getFullYear()}-${month}-${pad2(date.getDate())}`;
 };
 
-const npmBin = (platform = process.platform) =>
-  platform === 'win32' ? 'npm.cmd' : 'npm';
+const npmBin = () => (IS_WIN ? 'npm.cmd' : 'npm');
 
 const spawnBase = (extra = {}) => ({ windowsHide: true, ...extra });
 
 const npmOpts = (extra = {}, platform = process.platform) =>
   spawnBase({ shell: platform === 'win32', ...extra });
 
-const clipTools = (platform = process.platform) => {
-  if (platform === 'win32') return [{ cmd: 'clip', args: [] }];
-  if (platform === 'darwin') return [{ cmd: 'pbcopy', args: [] }];
-  return UNIX_CLIP;
-};
-
 const listen = (emitter, event, handler) => {
   if (!emitter || typeof emitter.on !== 'function') return () => {};
   emitter.on(event, handler);
@@ -91,69 +80,36 @@ const watchResize = (stdout, proc, onResize, signal) => {
   return stop;
 };
 
-const abortError = () => {
-  const error = new Error('aborted');
-  error.code = 'ABORT';
-  return error;
-};
+const codeError = (message, code) =>
+  Object.assign(new Error(message), { code });
 
-const isAbort = (error) => !!(error && error.code === 'ABORT');
+const abortError = () => codeError('aborted', 'ABORT');
 
-const asOutput = (value) => {
-  if (value === undefined || value === null) return '';
-  if (typeof value === 'string') return value;
-  return `${value}`;
-};
+const isAbort = (error) => !!(error && error.code === 'ABORT');
 
-const procResult = (values = {}) => {
-  const status = values.status ?? null;
-  const stdout = asOutput(values.stdout);
-  const stderr = asOutput(values.stderr);
-  const error = values.error ?? null;
-  return { status, stdout, stderr, error };
-};
+const procResult = (values = {}) => ({
+  status: values.status ?? null,
+  stdout: `${values.stdout ?? ''}`,
+  stderr: `${values.stderr ?? ''}`,
+  error: values.error ?? null,
+});
 
-const spawnOptions = (options = {}) => {
-  const encoding = options.encoding ?? DEFAULT_ENCODING;
-  const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+const runProcSync = (cmd, args, options = {}) => {
   const opts = spawnBase({
     cwd: options.cwd,
     env: options.env,
-    encoding,
+    encoding: options.encoding ?? DEFAULT_ENCODING,
     input: options.input,
-    maxBuffer,
+    maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
     timeout: options.timeout,
   });
   if (options.shell) opts.shell = true;
-  return opts;
-};
-
-const runProcSync = (cmd, args, options = {}) => {
-  const result = spawnSync(cmd, args, spawnOptions(options));
-  return procResult(result);
-};
-
-const attachOutput = (stream, encoding, onChunk) => {
-  if (!stream) return;
-  stream.setEncoding(encoding);
-  stream.on('data', onChunk);
-};
-
-const writeInput = (child, input) => {
-  if (!child.stdin) return;
-  try {
-    if (input) child.stdin.end(input);
-    else child.stdin.end();
-  } catch {
-    // closed
-  }
+  return procResult(spawnSync(cmd, args, opts));
 };
 
 const listenChild = (child, options, resolve) => {
   const encoding = options.encoding ?? DEFAULT_ENCODING;
   const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
-  const timeout = options.timeout;
-  const input = options.input;
   const signal = options.signal;
   let stdout = '';
   let stderr = '';
@@ -163,46 +119,49 @@ const listenChild = (child, options, resolve) => {
   const finish = (result) => {
     if (settled) return;
     settled = true;
-    if (timer) clearTimeout(timer);
-    timer = null;
-    if (signal && onAbort) {
-      signal.removeEventListener('abort', onAbort);
-    }
-    onAbort = null;
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener('abort', onAbort);
     resolve(result);
   };
-  onAbort = () => {
+  const fail = (error) => {
     child.kill();
-    finish(procResult({ stdout, stderr, error: abortError() }));
+    finish(procResult({ stdout, stderr, error }));
   };
-  const append = (kind, chunk) => {
-    if (kind === 'out') stdout += chunk;
+  onAbort = () => fail(abortError());
+  const append = (chunk, isOut) => {
+    if (isOut) stdout += chunk;
     else stderr += chunk;
-    if (stdout.length + stderr.length <= maxBuffer) return;
-    child.kill();
-    const error = new Error('maxBuffer exceeded');
-    error.code = 'ENOBUFS';
-    finish(procResult({ stdout, stderr, error }));
+    if (stdout.length + stderr.length > maxBuffer) {
+      fail(codeError('maxBuffer exceeded', 'ENOBUFS'));
+    }
   };
   if (signal) signal.addEventListener('abort', onAbort);
-  if (timeout) {
-    timer = setTimeout(() => {
-      child.kill();
-      const error = new Error('timed out');
-      error.code = 'ETIMEDOUT';
-      finish(procResult({ stdout, stderr, error }));
-    }, timeout);
+  if (options.timeout) {
+    const onTimeout = () => fail(codeError('timed out', 'ETIMEDOUT'));
+    timer = setTimeout(onTimeout, options.timeout);
   }
   if (signal && signal.aborted) onAbort();
-  attachOutput(child.stdout, encoding, (chunk) => append('out', chunk));
-  attachOutput(child.stderr, encoding, (chunk) => append('err', chunk));
+  if (child.stdout) {
+    child.stdout.setEncoding(encoding);
+    child.stdout.on('data', (chunk) => append(chunk, true));
+  }
+  if (child.stderr) {
+    child.stderr.setEncoding(encoding);
+    child.stderr.on('data', (chunk) => append(chunk, false));
+  }
   child.on('error', (error) => {
     finish(procResult({ stdout, stderr, error }));
   });
   child.on('close', (status) => {
     finish(procResult({ status, stdout, stderr }));
   });
-  writeInput(child, input);
+  if (!child.stdin) return;
+  try {
+    if (options.input) child.stdin.end(options.input);
+    else child.stdin.end();
+  } catch {
+    // closed
+  }
 };
 
 const runProc = (cmd, args, options = {}) =>
@@ -238,7 +197,6 @@ module.exports = {
   npmBin,
   spawnBase,
   npmOpts,
-  clipTools,
   listen,
   watchResize,
   abortError,

package/lib/workspace.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const files = require('./files.js');
+const { REVIEW_DIR } = files;
+const review = require('./review.js');
+const { listReviewNames, latestReviewName, loadReview, noteCounts } = review;
+const worktree = require('./git-worktree.js');
+const { runGitAsync, countUntrackedAdded } = worktree;
+const model = require('./dashboard/model.js');
+const { runName } = model;
+const runs = require('./runs.js');
+const { readRuns } = runs;
+
+const emptyDiff = () => ({
+  stagedAdded: 0,
+  unstagedAdded: 0,
+  stagedRemoved: 0,
+  unstagedRemoved: 0,
+});
+
+const isRepoDir = (dir) => {
+  try {
+    fs.accessSync(path.join(dir, '.git'));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const listChildRepos = (dir) => {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const repos = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+    const full = path.join(dir, entry.name);
+    if (!isRepoDir(full)) continue;
+    repos.push({ name: entry.name, dir: full });
+  }
+  repos.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+  return repos;
+};
+
+const workspaceAt = (dir) => {
+  let stat;
+  try {
+    stat = fs.statSync(dir);
+  } catch {
+    return null;
+  }
+  if (!stat.isDirectory() || isRepoDir(dir)) return null;
+  const repos = listChildRepos(dir);
+  if (!repos.length) return null;
+  return { root: path.resolve(dir), repos };
+};
+
+const workspaceFromArgs = (cwd, paths) => {
+  if (paths.length > 1) return null;
+  const dir = paths.length ? path.resolve(cwd, paths[0]) : cwd;
+  if (paths.length) {
+    try {
+      if (!fs.statSync(dir).isDirectory()) return null;
+    } catch {
+      return null;
+    }
+  }
+  return workspaceAt(dir);
+};
+
+const sumNumstat = (text) => {
+  let added = 0;
+  let removed = 0;
+  for (const line of `${text ?? ''}`.split('\n')) {
+    if (!line) continue;
+    const parts = line.split('\t');
+    const add = Number(parts[0]);
+    const del = Number(parts[1]);
+    if (Number.isFinite(add)) added += add;
+    if (Number.isFinite(del)) removed += del;
+  }
+  return { added, removed };
+};
+
+const readNumstat = async (dir, cached) => {
+  const args = cached
+    ? ['diff', '--cached', '--numstat']
+    : ['diff', '--numstat'];
+  try {
+    const result = await runGitAsync(args, dir);
+    if (result.status !== 0) return { added: 0, removed: 0 };
+    return sumNumstat(result.stdout);
+  } catch {
+    return { added: 0, removed: 0 };
+  }
+};
+
+const readDiffStat = async (dir) => {
+  const staged = await readNumstat(dir, true);
+  const open = await readNumstat(dir, false);
+  const untracked = await countUntrackedAdded(dir);
+  return {
+    stagedAdded: staged.added,
+    unstagedAdded: open.added + untracked,
+    stagedRemoved: staged.removed,
+    unstagedRemoved: open.removed,
+  };
+};
+
+const countCommits = async (dir) => {
+  try {
+    const result = await runGitAsync(['rev-list', '--count', 'HEAD'], dir);
+    if (result.status !== 0) return 0;
+    const value = parseInt(result.stdout.trim(), 10);
+    return Number.isFinite(value) ? value : 0;
+  } catch {
+    return 0;
+  }
+};
+
+const taskStats = (dir) => {
+  const latest = latestReviewName(listReviewNames(dir));
+  if (!latest) return { done: 0, total: 0 };
+  try {
+    const file = path.join(dir, REVIEW_DIR, latest);
+    const counts = noteCounts(loadReview(file, []));
+    return { done: counts.tasksDone, total: counts.tasks };
+  } catch {
+    return { done: 0, total: 0 };
+  }
+};
+
+const pickRun = (dir) => {
+  const list = readRuns(dir);
+  const live = list.find((row) => row.status === 'running');
+  const record = live ?? list[0] ?? null;
+  if (!record) return null;
+  const progress = record.progress ?? {};
+  return {
+    name: runName(record),
+    status: record.status,
+    done: progress.done ?? 0,
+    failed: progress.failed ?? 0,
+    expected: progress.expected ?? 0,
+    result: record.result ?? null,
+  };
+};
+
+module.exports = {
+  emptyDiff,
+  isRepoDir,
+  listChildRepos,
+  workspaceAt,
+  workspaceFromArgs,
+  sumNumstat,
+  readDiffStat,
+  countCommits,
+  taskStats,
+  pickRun,
+};

package/lib/wrap.js

@@ -12,53 +12,37 @@ const wrapPlain = (text, width) => {
   let col = 0;
   let lastBreak = -1;
   let i = 0;
-  const slice = (from, to) => {
-    let out = '';
-    for (let k = from; k < to; k++) out += parts[k];
-    return out;
-  };
-  const flush = (end) => {
-    rows.push(slice(start, end));
-    start = end;
-    col = 0;
-    lastBreak = -1;
-  };
   while (i < parts.length) {
     const ch = parts[i];
     const w = graphemeWidth(ch, col);
     if (col + w > width && col > 0) {
-      if (lastBreak >= start) {
-        flush(lastBreak + 1);
-        i = start;
-        continue;
-      }
-      flush(i);
+      const end = lastBreak >= start ? lastBreak + 1 : i;
+      rows.push(parts.slice(start, end).join(''));
+      start = end;
+      i = end;
+      col = 0;
+      lastBreak = -1;
       continue;
     }
     col += w;
     if (ch === ' ' || ch === '\t') lastBreak = i;
     i += 1;
   }
-  rows.push(slice(start, parts.length));
+  rows.push(parts.slice(start).join(''));
   return rows;
 };
 
 const wrapDoc = (text, width) => {
   const rows = [];
-  const parts = text.split('\n');
   let offset = 0;
-  for (let p = 0; p < parts.length; p++) {
-    const part = parts[p];
-    const wrapped = wrapPlain(part, width);
-    let used = 0;
-    for (const row of wrapped) {
-      rows.push({ start: offset + used, text: row });
-      used += row.length;
+  for (const part of text.split('\n')) {
+    let start = offset;
+    for (const row of wrapPlain(part, width)) {
+      rows.push({ start, text: row });
+      start += row.length;
     }
-    offset += part.length;
-    if (p < parts.length - 1) offset += 1;
+    offset += part.length + 1;
   }
-  if (!rows.length) rows.push({ start: 0, text: '' });
   return rows;
 };
 
@@ -69,9 +53,8 @@ const cursorInWrap = (text, cursor, width) => {
   const rows = wrapDoc(text, width);
   const clamped = Math.max(0, Math.min(cursor, text.length));
   let row = rows.length - 1;
-  for (let i = 0; i < rows.length; i++) {
-    const next = i + 1 < rows.length ? rows[i + 1].start : text.length + 1;
-    if (clamped < next) {
+  for (let i = 0; i < rows.length - 1; i++) {
+    if (clamped < rows[i + 1].start) {
       row = i;
       break;
     }
@@ -81,30 +64,25 @@ const cursorInWrap = (text, cursor, width) => {
   return { row, col: visibleWidth(line.text.slice(0, take)) };
 };
 
-const indexAtRow = (start, text, col) => {
-  const raw = `${text ?? ''}`;
-  if (col <= 0) return start;
+const colIndex = (text, col) => {
   let used = 0;
-  let idx = 0;
-  for (const ch of graphemes(raw)) {
+  let index = 0;
+  for (const ch of graphemes(text)) {
     const w = graphemeWidth(ch, used);
     if (used + w > col) break;
     used += w;
-    idx += ch.length;
+    index += ch.length;
   }
-  return start + idx;
+  return index;
+};
+
+const indexAtRow = (start, text, col) => {
+  if (col <= 0) return start;
+  return start + colIndex(`${text ?? ''}`, col);
 };
 
 const indexAtWrapCol = (row, col, limit) => {
-  let used = 0;
-  let idx = 0;
-  for (const ch of graphemes(row.text)) {
-    const w = graphemeWidth(ch, used);
-    if (used + w > col) break;
-    used += w;
-    idx += ch.length;
-  }
-  const pos = row.start + idx;
+  const pos = row.start + colIndex(row.text, col);
   if (pos < limit) return pos;
   if (pos <= row.start) return row.start;
   const parts = graphemes(row.text);
@@ -114,15 +92,11 @@ const indexAtWrapCol = (row, col, limit) => {
 const wrapMove = (text, cursor, width, delta, wantCol) => {
   const rows = wrapDoc(text, width);
   const pos = cursorInWrap(text, cursor, width);
-  let next = pos.row + delta;
-  if (next < 0) next = 0;
-  if (next >= rows.length) next = rows.length - 1;
+  const next = Math.min(Math.max(pos.row + delta, 0), rows.length - 1);
   const col = wantCol ?? pos.col;
   if (next === pos.row) return { cursor, col };
-  const row = rows[next];
-  let limit = text.length + 1;
-  if (next + 1 < rows.length) limit = rows[next + 1].start;
-  return { cursor: indexAtWrapCol(row, col, limit), col };
+  const limit = next + 1 < rows.length ? rows[next + 1].start : text.length + 1;
+  return { cursor: indexAtWrapCol(rows[next], col, limit), col };
 };
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reslop",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Interactive code review and repair planning for AI-assisted changes",
   "keywords": [
     "code-review",