reslop 0.2.4 → 0.2.6

package/lib/update.js

@@ -8,7 +8,7 @@ const metautil = require('metautil');
 const { jsonParse, isHashObject } = metautil;
 const utilities = require('./utilities.js');
 const { parseVersion, cmpVersion, npmBin } = utilities;
-const { npmOpts, runProc, oneLine } = utilities;
+const { npmOpts, runProc, oneLine, asText } = utilities;
 
 const PKG = require('../package.json');
 
@@ -21,21 +21,10 @@ const INSTALL_MS = 120000;
 const REGISTRY = 'https://registry.npmjs.org';
 
 const RELEASE = /^\d+\.\d+\.\d+$/;
-const emptyCache = () => ({
-  checkedAt: 0,
-  compatible: '',
-  major: '',
-  skipped: '',
-});
+const NO_TARGETS = { compatible: '', major: '' };
 
-const asText = (value) => (typeof value === 'string' ? value : '');
-
-const toInt = (text) => parseInt(text, 10);
-
-const isNpmInstall = (pkgDir) => {
-  const parent = path.basename(path.dirname(pkgDir));
-  return parent === 'node_modules';
-};
+const isNpmInstall = (pkgDir) =>
+  path.basename(path.dirname(pkgDir)) === 'node_modules';
 
 const cacheFile = (env = process.env) => {
   if (env.XDG_CACHE_HOME) {
@@ -51,29 +40,26 @@ const cacheFile = (env = process.env) => {
 
 const readCache = (file) => {
   try {
-    const text = fs.readFileSync(file, 'utf8');
-    const data = jsonParse(text);
-    if (!isHashObject(data)) {
-      return emptyCache();
+    const data = jsonParse(fs.readFileSync(file, 'utf8'));
+    if (isHashObject(data)) {
+      return {
+        checkedAt: parseInt(data.checkedAt, 10) || 0,
+        compatible: asText(data.compatible),
+        major: asText(data.major) || asText(data.latest),
+        skipped: asText(data.skipped) || asText(data.handled),
+      };
     }
-    const checkedAt = toInt(data.checkedAt) || 0;
-    const compatible = asText(data.compatible);
-    const major = asText(data.major) || asText(data.latest);
-    const skipped = asText(data.skipped) || asText(data.handled);
-    return { checkedAt, compatible, major, skipped };
   } catch {
-    return emptyCache();
+    // missing or unreadable cache
   }
+  return { checkedAt: 0, compatible: '', major: '', skipped: '' };
 };
 
 const writeCache = (file, data) => {
+  const { checkedAt, compatible, major, skipped } = data;
+  const body = JSON.stringify({ checkedAt, compatible, major, skipped });
   try {
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    const checkedAt = data.checkedAt ?? 0;
-    const compatible = data.compatible ?? '';
-    const major = data.major ?? '';
-    const skipped = data.skipped ?? '';
-    const body = JSON.stringify({ checkedAt, compatible, major, skipped });
     fs.writeFileSync(file, `${body}\n`);
   } catch {
     // ignore cache write errors
@@ -81,76 +67,43 @@ const writeCache = (file, data) => {
 };
 
 const isFresh = (cache, now, interval = CHECK_INTERVAL_MS) => {
-  if (!cache || !cache.checkedAt) return false;
-  if (now < cache.checkedAt) return false;
+  if (!cache.checkedAt || now < cache.checkedAt) return false;
   return now - cache.checkedAt < interval;
 };
 
 const listVersions = (data) => {
   if (!data || typeof data !== 'object') return [];
   const names = [];
-  const map = data.versions;
-  if (isHashObject(map)) {
-    for (const name of Object.keys(map)) names.push(name);
-  }
+  if (isHashObject(data.versions)) names.push(...Object.keys(data.versions));
   const tags = data['dist-tags'];
   if (tags && typeof tags.latest === 'string') names.push(tags.latest);
   if (typeof data.version === 'string') names.push(data.version);
-  const listed = [];
-  for (const name of names) {
-    if (!RELEASE.test(name)) continue;
-    if (listed.includes(name)) continue;
-    listed.push(name);
-  }
-  return listed;
+  return [...new Set(names)].filter((name) => RELEASE.test(name));
 };
 
-const pickNewerName = (best, name, ver) => {
+const newer = (best, name) => {
   if (!best) return name;
-  const prev = parseVersion(best);
-  if (!prev || cmpVersion(ver, prev) > 0) return name;
-  return best;
+  return cmpVersion(parseVersion(name), parseVersion(best)) > 0 ? name : best;
 };
 
 const pickTargets = (current, names) => {
   const from = parseVersion(current);
-  if (!from) return { compatible: '', major: '' };
+  if (!from) return NO_TARGETS;
   let compatible = '';
   let major = '';
   for (const name of names) {
     const ver = parseVersion(name);
-    if (!ver) continue;
     if (cmpVersion(ver, from) <= 0) continue;
-    if (ver.major === from.major) {
-      compatible = pickNewerName(compatible, name, ver);
-      continue;
-    }
-    if (ver.major > from.major) major = pickNewerName(major, name, ver);
+    if (ver.major === from.major) compatible = newer(compatible, name);
+    else if (ver.major > from.major) major = newer(major, name);
   }
   return { compatible, major };
 };
 
-const classifyLatest = (current, latest) => {
-  const from = parseVersion(current);
-  const to = parseVersion(latest);
-  if (!from || !to || cmpVersion(to, from) <= 0) {
-    return { compatible: '', major: '' };
-  }
-  if (to.major > from.major) return { compatible: '', major: latest };
-  return { compatible: latest, major: '' };
-};
-
-const planUpdate = (current, extra = {}) => {
+const planUpdate = (current, targets) => {
   const from = parseVersion(current);
   if (!from) return { action: 'none' };
-  let compatible = extra.compatible ?? '';
-  let major = extra.major ?? '';
-  const skipped = extra.skipped ?? extra.handled ?? '';
-  if (!compatible && !major && extra.latest) {
-    const classified = classifyLatest(current, extra.latest);
-    compatible = classified.compatible;
-    major = classified.major;
-  }
+  const { compatible, major, skipped } = targets;
   const compatVer = parseVersion(compatible);
   if (compatVer && compatVer.major === from.major) {
     if (cmpVersion(compatVer, from) > 0) {
@@ -164,53 +117,40 @@ const planUpdate = (current, extra = {}) => {
   return { action: 'confirm', current, latest: major };
 };
 
-const isEnabled = (options = {}) => {
-  if (options.enabled === false) return false;
-  if (options.enabled === true) return true;
-  const pkgDir = options.pkgDir ?? PKG_DIR;
-  return isNpmInstall(pkgDir);
+const isEnabled = (options) => {
+  if (typeof options.enabled === 'boolean') return options.enabled;
+  return isNpmInstall(options.pkgDir ?? PKG_DIR);
 };
 
-const fetchTargets = async (current, options = {}) => {
-  const empty = { compatible: '', major: '' };
+const fetchTargets = async (current, options) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== 'function') return empty;
-  const encoded = encodeURIComponent(PKG_NAME);
-  const url = `${REGISTRY}/${encoded}`;
+  if (typeof fetchImpl !== 'function') return NO_TARGETS;
+  const url = `${REGISTRY}/${encodeURIComponent(PKG_NAME)}`;
   const headers = { accept: 'application/json' };
   const signal = options.signal ?? AbortSignal.timeout(FETCH_MS);
   const response = await fetchImpl(url, { headers, signal });
-  if (!response || !response.ok) return empty;
+  if (!response || !response.ok) return NO_TARGETS;
   const data = await response.json();
   return pickTargets(current, listVersions(data));
 };
 
-const npmInstall = async (spec, extra = {}) => {
-  const timeout = extra.timeout ?? INSTALL_MS;
-  const result = await runProc(
-    npmBin(),
-    ['install', '-g', spec],
-    npmOpts({ timeout }),
-  );
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    throw new Error(oneLine(result.stderr, 'npm install failed'));
-  }
-};
-
 const installUpdate = async (version, options = {}) => {
   if (typeof options.install === 'function') {
     await options.install(version);
     return;
   }
-  const spec = `${PKG_NAME}@${version}`;
-  await npmInstall(spec, options);
+  const timeout = options.timeout ?? INSTALL_MS;
+  const args = ['install', '-g', `${PKG_NAME}@${version}`];
+  const result = await runProc(npmBin(), args, npmOpts({ timeout }));
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(oneLine(result.stderr, 'npm install failed'));
+  }
 };
 
 const markSkipped = (version, options = {}) => {
   const file = options.cacheFile ?? cacheFile(options.env);
-  const cache = readCache(file);
-  writeCache(file, { ...cache, skipped: version });
+  writeCache(file, { ...readCache(file), skipped: version });
 };
 
 const checkUpdate = async (options = {}) => {
@@ -218,39 +158,28 @@ const checkUpdate = async (options = {}) => {
   const now = Date.now();
   const current = options.current ?? PKG_VERSION;
   const file = options.cacheFile ?? cacheFile(options.env);
-  const interval = options.interval ?? CHECK_INTERVAL_MS;
   const cache = readCache(file);
-  if (isFresh(cache, now, interval)) {
+  if (isFresh(cache, now, options.interval)) {
     const plan = planUpdate(current, cache);
-    if (plan.action === 'install') return { action: 'none' };
-    return plan;
+    return plan.action === 'install' ? { action: 'none' } : plan;
   }
-  let targets = { compatible: '', major: '' };
+  let targets = NO_TARGETS;
   try {
     targets = await fetchTargets(current, options);
   } catch {
     // ignore registry errors
   }
-  const next = {
-    ...cache,
-    checkedAt: now,
-    compatible: targets.compatible,
-    major: targets.major,
-  };
   if (!targets.compatible && !targets.major) {
     writeCache(file, { ...cache, checkedAt: now });
     return { action: 'none' };
   }
+  const next = { ...cache, checkedAt: now, ...targets };
   writeCache(file, next);
   return planUpdate(current, next);
 };
 
 module.exports = {
   CHECK_INTERVAL_MS,
-  PKG_NAME,
-  PKG_VERSION,
-  parseVersion,
-  cmpVersion,
   isNpmInstall,
   cacheFile,
   readCache,

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 };
 };
 
@@ -30,20 +26,30 @@ const cmpVersion = (left, right) =>
 const oneLine = (text, fallback = '') =>
   split(`${text ?? ''}`.trim(), '\n')[0] || fallback;
 
-const npmBin = (platform = process.platform) =>
-  platform === 'win32' ? 'npm.cmd' : 'npm';
+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 });
 
 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);
@@ -74,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 = '';
@@ -146,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 = {}) =>
@@ -214,15 +190,17 @@ module.exports = {
   parseVersion,
   cmpVersion,
   oneLine,
+  asText,
+  unquote,
+  pad2,
+  dateStamp,
   npmBin,
   spawnBase,
   npmOpts,
-  clipTools,
   listen,
   watchResize,
   abortError,
   isAbort,
-  procResult,
   runProcSync,
   runProc,
 };

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,16 +64,25 @@ const cursorInWrap = (text, cursor, width) => {
   return { row, col: visibleWidth(line.text.slice(0, take)) };
 };
 
-const indexAtWrapCol = (row, col, limit) => {
+const colIndex = (text, col) => {
   let used = 0;
-  let idx = 0;
-  for (const ch of graphemes(row.text)) {
+  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;
   }
-  const pos = row.start + idx;
+  return index;
+};
+
+const indexAtRow = (start, text, col) => {
+  if (col <= 0) return start;
+  return start + colIndex(`${text ?? ''}`, col);
+};
+
+const indexAtWrapCol = (row, col, limit) => {
+  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);
@@ -100,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 = {
@@ -116,5 +104,6 @@ module.exports = {
   wrapDoc,
   wrapMultiline,
   cursorInWrap,
+  indexAtRow,
   wrapMove,
 };

package/package.json

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