reslop 0.1.1 → 0.1.2

package/lib/git.js

@@ -6,16 +6,24 @@ const path = require('node:path');
 
 const diff = require('./diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
-const { itemPath } = require('./files.js');
-const { REVIEW_DIR } = require('./review.js');
+const { itemPath, isPathInScope, REVIEW_DIR } = require('./files.js');
+const deps = require('./deps.js');
+const { foldDepItems, mergeDepFile, depFileMeta } = deps;
+const { collectUsedNames, parseAuditReport, parseOutdatedReport } = deps;
+const { mergeProposedItems, MANIFEST, LOCKFILE } = deps;
 
 const GIT_CONFIG = ['-c', 'core.quotepath=false'];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
 const GIT_ENCODING = 'utf8';
 const GIT_MAX_BUFFER = 32 * 1024 * 1024;
 const BINARY_SIZE = 1000000;
+const AUDIT_MS = 15000;
+const INSTALL_MS = 120000;
 
-const oneLine = (text) => text.trim().split('\n')[0] || 'git failed';
+const oneLine = (text) => {
+  const line = text.trim().split('\n')[0];
+  return line || 'git failed';
+};
 
 const requireOk = (result, fallback = 'git failed') => {
   if (result.status === 0) return result;
@@ -40,13 +48,9 @@ const dropReviewItems = (items) => {
 
 const runGit = (args, cwd, input) => {
   const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
-  const options = {
-    cwd,
-    encoding: GIT_ENCODING,
-    input,
-    maxBuffer: GIT_MAX_BUFFER,
-    env,
-  };
+  const encoding = GIT_ENCODING;
+  const maxBuffer = GIT_MAX_BUFFER;
+  const options = { cwd, encoding, input, maxBuffer, env };
   const result = spawnSync('git', args, options);
   if (result.error) {
     if (result.error.code === 'ENOENT') throw new Error('git not found');
@@ -131,6 +135,264 @@ const mergeItems = (groups) => {
   return items;
 };
 
+const gitText = (top, spec) => {
+  const result = runGit(['show', spec], top);
+  if (result.status !== 0) return '';
+  return result.stdout ?? '';
+};
+
+const worktreeText = (top, rel) => {
+  try {
+    return fs.readFileSync(path.join(top, rel), 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const readDepSides = (top, rev, origin, rel) => {
+  if (origin === 'untracked') {
+    const newText = worktreeText(top, rel);
+    return { oldText: '', newText };
+  }
+  if (origin === 'staged') {
+    const oldText = gitText(top, `HEAD:${rel}`);
+    const newText = gitText(top, `:${rel}`);
+    return { oldText, newText };
+  }
+  if (origin === 'unstaged') {
+    const indexed = gitText(top, `:${rel}`);
+    const oldText = indexed || gitText(top, `HEAD:${rel}`);
+    const newText = worktreeText(top, rel);
+    return { oldText, newText };
+  }
+  if (origin === 'commit' && rev) {
+    const oldText = gitText(top, `${rev}^:${rel}`);
+    const newText = gitText(top, `${rev}:${rel}`);
+    return { oldText, newText };
+  }
+  return { oldText: '', newText: '' };
+};
+
+const runNpmJson = (top, args, timeout) => {
+  const result = spawnSync('npm', args, {
+    cwd: top,
+    encoding: GIT_ENCODING,
+    maxBuffer: GIT_MAX_BUFFER,
+    timeout,
+  });
+  if (result.error) return '';
+  return result.stdout || '';
+};
+
+const collectAudit = (top) => {
+  const lock = path.join(top, LOCKFILE);
+  if (!fs.existsSync(lock)) return null;
+  const args = ['audit', '--json', '--package-lock-only'];
+  const text = runNpmJson(top, args, AUDIT_MS);
+  return parseAuditReport(text);
+};
+
+const collectOutdated = (top) => {
+  const manifest = path.join(top, MANIFEST);
+  if (!fs.existsSync(manifest)) return null;
+  const args = ['outdated', '--json', '--long'];
+  const text = runNpmJson(top, args, AUDIT_MS);
+  return parseOutdatedReport(text);
+};
+
+const pickNpmMap = (override, collect, top) => {
+  if (override !== undefined) return override;
+  return collect(top);
+};
+
+const foldLoaded = (items, top, rev, extra = {}) => {
+  const readSides = (origin, rel) => readDepSides(top, rev, origin, rel);
+  let usedNames = null;
+  let audit = null;
+  let outdated = null;
+  const live = extra.audit === true && !rev;
+  let hasDepDiff = false;
+  for (const item of items) {
+    if (!depFileMeta(itemPath(item))) continue;
+    hasDepDiff = true;
+    break;
+  }
+  if (hasDepDiff || live) usedNames = collectUsedNames(top);
+  if (live) {
+    audit = pickNpmMap(extra.auditMap, collectAudit, top);
+    outdated = pickNpmMap(extra.outdatedMap, collectOutdated, top);
+  } else if (extra.audit && hasDepDiff) {
+    audit = pickNpmMap(extra.auditMap, collectAudit, top);
+  }
+  const folded = foldDepItems(items, readSides, usedNames, audit, outdated, {
+    root: top,
+  });
+  if (!live) return folded;
+  if (!isPathInScope(MANIFEST, extra.paths ?? [])) return folded;
+  const pkgText = worktreeText(top, MANIFEST);
+  const lockText = worktreeText(top, LOCKFILE);
+  return mergeProposedItems(folded, pkgText, outdated, audit, {
+    lockText,
+    usedNames,
+    root: top,
+  });
+};
+
+const depPaths = (item) => item.dep?.files ?? [];
+
+const origDepItems = (item) => item.dep?.items ?? [];
+
+const depChange = (item) => item.dep?.change ?? null;
+
+const writeWorktreeFile = (top, rel, text) => {
+  const abs = path.join(top, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, text);
+};
+
+const restoreWorktreeFile = (top, rel, saved, existed) => {
+  const abs = path.join(top, rel);
+  if (existed) {
+    fs.writeFileSync(abs, saved);
+    return;
+  }
+  try {
+    fs.unlinkSync(abs);
+  } catch {
+    // missing
+  }
+};
+
+const writeIndexFile = (top, rel, text) => {
+  const abs = path.join(top, rel);
+  const existed = fs.existsSync(abs);
+  const saved = existed ? fs.readFileSync(abs, 'utf8') : '';
+  writeWorktreeFile(top, rel, text);
+  try {
+    requireOk(runGit(['add', '--', rel], top));
+  } finally {
+    restoreWorktreeFile(top, rel, saved, existed);
+  }
+};
+
+const mergeDepLive = (top, rel, change, origin, base, side, kind) => {
+  const sides = readDepSides(top, null, origin, rel);
+  return mergeDepFile(base, sides.oldText, sides.newText, change, side, kind);
+};
+
+const applyDepIndex = (top, rel, change, origin, side) => {
+  const meta = depFileMeta(rel);
+  if (!meta) return;
+  const indexed = gitText(top, `:${rel}`) || gitText(top, `HEAD:${rel}`);
+  const text = mergeDepLive(top, rel, change, origin, indexed, side, meta.kind);
+  writeIndexFile(top, rel, text);
+};
+
+const applyDepWorktree = (top, rel, change, origin) => {
+  const meta = depFileMeta(rel);
+  if (!meta) return;
+  const worktree = worktreeText(top, rel);
+  const text = mergeDepLive(
+    top,
+    rel,
+    change,
+    origin,
+    worktree,
+    'old',
+    meta.kind,
+  );
+  writeWorktreeFile(top, rel, text);
+};
+
+const runNpm = (cwd, args) =>
+  spawnSync('npm', args, {
+    cwd,
+    encoding: GIT_ENCODING,
+    maxBuffer: GIT_MAX_BUFFER,
+    timeout: INSTALL_MS,
+  });
+
+const firstDepRel = (files, kind) => {
+  for (const rel of files) {
+    const meta = depFileMeta(rel);
+    if (meta && meta.kind === kind) return rel;
+  }
+  return '';
+};
+
+const applyProposedUpdate = (top, item) => {
+  const change = depChange(item);
+  const origin = item.origin;
+  const files = depPaths(item);
+  const lockOnly = change.section === 'resolved';
+  const removing = !!change.unused;
+  const manifest = firstDepRel(files, 'manifest');
+  const lockRel = firstDepRel(files, 'lockfile');
+  const picked = lockOnly ? lockRel : manifest;
+  const target = picked || files[0] || '';
+  const meta = depFileMeta(target);
+  if (!meta) return;
+  let saved = '';
+  if (!lockOnly && !removing && manifest) {
+    const worktree = worktreeText(top, manifest);
+    saved = worktree;
+    const text = mergeDepLive(
+      top,
+      manifest,
+      change,
+      origin,
+      worktree,
+      'new',
+      'manifest',
+    );
+    writeWorktreeFile(top, manifest, text);
+  }
+  const cwd = meta.dir === '.' ? top : path.join(top, meta.dir);
+  let npmArgs = ['i'];
+  if (removing) npmArgs = ['uninstall', change.name];
+  else if (lockOnly) npmArgs = ['audit', 'fix'];
+  const install = item.dep.install ?? ((dir) => runNpm(dir, npmArgs));
+  const result = install(cwd);
+  const fail = removing ? 'npm uninstall failed' : 'npm i failed';
+  if (result && (result.error || result.status !== 0)) {
+    if (saved && manifest) writeWorktreeFile(top, manifest, saved);
+    if (result.error) {
+      const msg = result.error.message || fail;
+      throw new Error(oneLine(msg));
+    }
+    const msg = result.stderr || result.stdout || fail;
+    throw new Error(oneLine(msg));
+  }
+  const toAdd = [];
+  if (!lockOnly && manifest) toAdd.push(manifest);
+  const dirLock = meta.dir === '.' ? LOCKFILE : `${meta.dir}/${LOCKFILE}`;
+  const lockPath = lockRel || dirLock;
+  if (fs.existsSync(path.join(top, lockPath))) toAdd.push(lockPath);
+  if (toAdd.length) requireOk(runGit(['add', '--', ...toAdd], top));
+};
+
+const applyDepChange = (top, item, mode) => {
+  const change = depChange(item);
+  if (change && change.propose) {
+    if (mode === 'add') return void applyProposedUpdate(top, item);
+    if (!change.unused) return;
+  }
+  const origin = item.origin;
+  const files = depPaths(item);
+  for (const rel of files) {
+    if (mode === 'add') {
+      applyDepIndex(top, rel, change, origin, 'new');
+      continue;
+    }
+    if (mode === 'unstage') {
+      applyDepIndex(top, rel, change, origin, 'old');
+      continue;
+    }
+    if (origin === 'staged') applyDepIndex(top, rel, change, origin, 'old');
+    applyDepWorktree(top, rel, change, origin);
+  }
+};
+
 const resolveRev = (cwd, spec) => {
   if (!spec) return null;
   const top = toplevel(cwd);
@@ -174,7 +436,9 @@ const load = (cwd, paths = [], options = {}) => {
   const rev = options.commit;
   if (rev) {
     const files = loadCommit(top, rev, extra);
-    const items = dropReviewItems(itemsFromFiles(files, 'commit'));
+    const commitItems = itemsFromFiles(files, 'commit');
+    const parsed = dropReviewItems(commitItems);
+    const items = foldLoaded(parsed, top, rev, { ...options, paths });
     const revShort = shortRev(top, rev);
     return { top, items, rev, revShort };
   }
@@ -188,15 +452,28 @@ const load = (cwd, paths = [], options = {}) => {
   const unstagedArgs = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, ...extra];
   const stagedRes = requireOk(runGit(stagedArgs, top));
   const unstagedRes = requireOk(runGit(unstagedArgs, top));
-  const staged = itemsFromFiles(parseDiff(stagedRes.stdout), 'staged');
-  const unstaged = itemsFromFiles(parseDiff(unstagedRes.stdout), 'unstaged');
+  const stagedDiff = parseDiff(stagedRes.stdout);
+  const unstagedDiff = parseDiff(unstagedRes.stdout);
+  const staged = itemsFromFiles(stagedDiff, 'staged');
+  const unstaged = itemsFromFiles(unstagedDiff, 'unstaged');
   const untracked = untrackedItems(top, paths);
-  const items = dropReviewItems(mergeItems([staged, unstaged, untracked]));
+  const combined = mergeItems([staged, unstaged, untracked]);
+  const merged = dropReviewItems(combined);
+  const items = foldLoaded(merged, top, undefined, { ...options, paths });
   return { top, items };
 };
 
 const addItem = (top, item) => {
   if (item.origin === 'staged' || item.origin === 'commit') return;
+  if (depChange(item)) {
+    applyDepChange(top, item, 'add');
+    return;
+  }
+  const files = depPaths(item);
+  if (files.length) {
+    requireOk(runGit(['add', '--', ...files], top));
+    return;
+  }
   if (item.origin === 'untracked' || item.file.isBinary) {
     requireOk(runGit(['add', '--', item.file.newPath], top));
     return;
@@ -206,6 +483,15 @@ const addItem = (top, item) => {
 
 const unstageItem = (top, item) => {
   if (item.origin !== 'staged') return;
+  if (depChange(item)) {
+    applyDepChange(top, item, 'unstage');
+    return;
+  }
+  const files = depPaths(item);
+  if (files.length) {
+    requireOk(runGit(['restore', '--staged', '--', ...files], top));
+    return;
+  }
   const rel = itemPath(item);
   if (item.file.isBinary) {
     requireOk(runGit(['restore', '--staged', '--', rel], top));
@@ -214,8 +500,62 @@ const unstageItem = (top, item) => {
   applyPatch(top, item.patchAdd, ['--reverse', '--cached']);
 };
 
+const revertOnePath = (top, rel, items) => {
+  const origins = new Set();
+  let isNew = false;
+  for (const item of items) {
+    origins.add(item.origin);
+    if (item.file && item.file.isNew) isNew = true;
+  }
+  if (isNew) {
+    if (origins.has('staged')) {
+      requireOk(runGit(['rm', '-f', '--', rel], top));
+      return;
+    }
+    fs.unlinkSync(path.join(top, rel));
+    return;
+  }
+  if (origins.has('untracked') && origins.size === 1) {
+    fs.unlinkSync(path.join(top, rel));
+    return;
+  }
+  const args = ['restore', '-s', 'HEAD', '--worktree', '--staged', '--', rel];
+  requireOk(runGit(args, top));
+};
+
+const itemsForPath = (rel, items) => {
+  const group = [];
+  for (const item of items) {
+    if (item.dep) {
+      for (const orig of origDepItems(item)) {
+        if (itemPath(orig) === rel) group.push(orig);
+      }
+      continue;
+    }
+    if (itemPath(item) === rel) group.push(item);
+  }
+  return group;
+};
+
 const revertItem = (top, item) => {
   if (item.origin === 'commit') return;
+  if (depChange(item)) {
+    applyDepChange(top, item, 'revert');
+    return;
+  }
+  if (item.dep) {
+    const byPath = new Map();
+    for (const orig of origDepItems(item)) {
+      const rel = itemPath(orig);
+      const list = byPath.get(rel);
+      if (list) list.push(orig);
+      else byPath.set(rel, [orig]);
+    }
+    for (const rel of byPath.keys()) {
+      revertOnePath(top, rel, byPath.get(rel));
+    }
+    return;
+  }
   const rel = itemPath(item);
   if (item.origin === 'untracked') {
     fs.unlinkSync(path.join(top, rel));
@@ -241,26 +581,15 @@ const revertItem = (top, item) => {
 };
 
 const revertFile = (top, rel, items) => {
-  const origins = new Set();
-  let isNew = false;
+  const paths = new Set([rel]);
   for (const item of items) {
-    origins.add(item.origin);
-    if (item.file && item.file.isNew) isNew = true;
-  }
-  if (isNew) {
-    if (origins.has('staged')) {
-      requireOk(runGit(['rm', '-f', '--', rel], top));
-      return;
-    }
-    fs.unlinkSync(path.join(top, rel));
-    return;
+    for (const file of depPaths(item)) paths.add(file);
   }
-  if (origins.has('untracked') && origins.size === 1) {
-    fs.unlinkSync(path.join(top, rel));
-    return;
+  for (const file of paths) {
+    const group = itemsForPath(file, items);
+    const targets = group.length ? group : items;
+    revertOnePath(top, file, targets);
   }
-  const args = ['restore', '-s', 'HEAD', '--worktree', '--staged', '--', rel];
-  requireOk(runGit(args, top));
 };
 
 const createGitRepo = () => ({
@@ -273,14 +602,9 @@ const createGitRepo = () => ({
 });
 
 module.exports = {
-  runGit,
-  toplevel,
   load,
-  resolveRev,
   addItem,
   unstageItem,
   revertItem,
-  revertFile,
   createGitRepo,
-  oneLine,
 };

package/lib/github.js

@@ -3,8 +3,9 @@
 const { delay } = require('metautil');
 
 const diff = require('./diff.js');
-const { parseDiff, itemsFromFiles } = diff;
-const { itemPath } = require('./files.js');
+const { parseDiff, itemsFromFiles, isCtxType } = diff;
+const { itemPath, isPathInScope } = require('./files.js');
+const { foldDepItems } = require('./deps.js');
 
 const GITHUB_API = 'https://api.github.com';
 const API_VERSION = '2022-11-28';
@@ -70,7 +71,6 @@ const parseGithubPrUrl = (text) => {
 
 const githubToken = (env) => {
   const from = env ?? process.env;
-  if (!isRecord(from)) return '';
   return from.GITHUB_TOKEN || from.GH_TOKEN || '';
 };
 
@@ -134,18 +134,15 @@ const isRetryable = (error) => {
 const retry = async (run, options) => {
   const attempts = options.attempts ?? RETRY_ATTEMPTS;
   const delayMs = options.delayMs ?? RETRY_DELAY_MS;
-  let lastError = null;
-  for (let i = 0; i < attempts; i++) {
+  for (let i = 0; ; i++) {
     try {
       return await run();
     } catch (error) {
-      lastError = error;
       const isLast = i === attempts - 1;
       if (isLast || !isRetryable(error)) throw error;
       await delay(delayMs * (i + 1));
     }
   }
-  throw lastError;
 };
 
 const githubHeaders = (token, accept) => {
@@ -164,7 +161,8 @@ const headerValue = (headers, name) => {
     return headers.get(name) || '';
   }
   const wanted = name.toLowerCase();
-  for (const [key, value] of Object.entries(headers)) {
+  for (const key of Object.keys(headers)) {
+    const value = headers[key];
     if (key.toLowerCase() === wanted) return `${value}`;
   }
   return '';
@@ -252,19 +250,6 @@ const requestGraphql = async (query, variables, options) => {
 
 const changePath = (file) => file.newPath || file.oldPath || '';
 
-const normalizePathSpec = (spec) =>
-  `${spec ?? ''}`.replaceAll('\\', '/').replace(/\/+$/, '');
-
-const isPathInScope = (rel, paths) => {
-  if (!paths.length) return true;
-  for (const spec of paths) {
-    const norm = normalizePathSpec(spec);
-    if (!norm || norm === '.') return true;
-    if (rel === norm || rel.startsWith(`${norm}/`)) return true;
-  }
-  return false;
-};
-
 const filterChangeFiles = (files, paths) => {
   if (!paths.length) return files;
   const kept = [];
@@ -314,14 +299,23 @@ const readRepoName = (data, pr) => {
   return `${pr.owner}/${pr.repo}`;
 };
 
+const pushChangeFile = (files, seen, rel) => {
+  if (!rel || seen.has(rel)) return;
+  seen.add(rel);
+  files.push(rel);
+};
+
 const changeFiles = (items) => {
   const files = [];
   const seen = new Set();
   for (const item of items) {
+    if (item.dep) {
+      const depFiles = item.dep.files ?? [];
+      for (const rel of depFiles) pushChangeFile(files, seen, rel);
+      continue;
+    }
     const rel = itemPath(item);
-    if (!rel || seen.has(rel)) continue;
-    seen.add(rel);
-    files.push(rel);
+    pushChangeFile(files, seen, rel);
   }
   return files;
 };
@@ -406,8 +400,12 @@ const locateLineInItem = (item, rel, line, side) => {
       const inBlock = entry.blockId === item.blockId;
       return { inBlock };
     }
-    if (entry.type === 'ctx' || entry.type === 'del') oldNo += 1;
-    if (entry.type === 'ctx' || entry.type === 'add') newNo += 1;
+    if (isCtxType(entry.type) || entry.type === 'del') {
+      oldNo += 1;
+    }
+    if (isCtxType(entry.type) || entry.type === 'add') {
+      newNo += 1;
+    }
   }
   return null;
 };
@@ -546,7 +544,6 @@ const loadReviewThreads = async (pr, options) => {
 const threadComments = (thread) => {
   if (!isRecord(thread)) return [];
   const comments = thread.comments;
-  if (Array.isArray(comments)) return comments;
   if (isRecord(comments) && Array.isArray(comments.nodes)) {
     return comments.nodes;
   }
@@ -581,20 +578,18 @@ const loadDiscussion = async (pr, options) => {
   return { reviewComments, reviews, issueComments, resolvedById };
 };
 
-const emptyImported = () => ({ feedback: [], todos: [] });
-
 const loadImportedNotes = async (pr, items, paths, options) => {
   try {
     const discussion = await loadDiscussion(pr, options);
     return discussionToNotes(discussion, items, paths);
   } catch {
     // ignore: discussion import is optional
-    return emptyImported();
+    return { feedback: [], todos: [] };
   }
 };
 
 const loadPullRequest = async (pr, options = {}) => {
-  const token = options.token ?? githubToken(options.env);
+  const token = options.token ?? '';
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const paths = options.paths ?? [];
   const retryOpts = options.retry ?? {};
@@ -611,7 +606,8 @@ const loadPullRequest = async (pr, options = {}) => {
   });
   const parsed = parseDiff(diffPage.body);
   const files = filterChangeFiles(parsed, paths);
-  const items = itemsFromFiles(files, 'pr');
+  const parsedItems = itemsFromFiles(files, 'pr');
+  const items = foldDepItems(parsedItems);
   const change = toChange(pr, data, items);
   const sourceLabel = `#${change.number}`;
   const imported = await loadImportedNotes(pr, items, paths, request);
@@ -619,8 +615,6 @@ const loadPullRequest = async (pr, options = {}) => {
 };
 
 module.exports = {
-  GITHUB_API,
-  PR_TODO_FILE,
   parseGithubPrUrl,
   githubToken,
   filterChangeFiles,