reslop 0.1.0 → 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));
@@ -240,22 +580,31 @@ const revertItem = (top, item) => {
   }
 };
 
+const revertFile = (top, rel, items) => {
+  const paths = new Set([rel]);
+  for (const item of items) {
+    for (const file of depPaths(item)) paths.add(file);
+  }
+  for (const file of paths) {
+    const group = itemsForPath(file, items);
+    const targets = group.length ? group : items;
+    revertOnePath(top, file, targets);
+  }
+};
+
 const createGitRepo = () => ({
   load,
   resolveRev,
   add: addItem,
   unstage: unstageItem,
   revert: revertItem,
+  revertFile,
 });
 
 module.exports = {
-  runGit,
-  toplevel,
   load,
-  resolveRev,
   addItem,
   unstageItem,
   revertItem,
   createGitRepo,
-  oneLine,
 };