reslop 0.2.7 → 0.3.1

package/lib/{git-deps.js → git/deps.js}

@@ -3,22 +3,28 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const deps = require('./deps.js');
+const deps = require('../deps/deps.js');
 const { foldDepItems, mergeProposedItems } = deps;
 const { parseAuditReport, parseOutdatedReport } = deps;
 const { collectUsedNames, collectExportMeta } = deps;
-const manifest = require('./manifest.js');
+const { collectGroups } = require('../deps/diff.js');
+const manifest = require('../deps/manifest.js');
 const { MANIFEST, LOCKFILE, depFileMeta, mergeDepFile, relOf } = manifest;
-const files = require('./files.js');
-const { itemPath, isPathInScope } = files;
-const utilities = require('./utilities.js');
-const { IS_WIN, abortError, npmBin, oneLine, runProc, runProcSync } = utilities;
-const worktree = require('./git-worktree.js');
-const { requireOk, runGit, gitText, worktreeText, readDepSides } = worktree;
+const { itemPath, isPathInScope } = require('../common/files.js');
+const utilities = require('../common/utilities.js');
+const {
+  INSTALL_MS,
+  IS_WIN,
+  abortError,
+  npmBin,
+  runProc,
+} = require('../common/process.js');
+const { oneLine } = utilities;
+const worktree = require('./worktree.js');
+const { gitOk, indexedText, worktreeText, readDepSides } = worktree;
 const { revertOnePath, groupByPath, writeFile, writeIndex } = worktree;
 
 const AUDIT_MS = 15000;
-const INSTALL_MS = 120000;
 
 const NPM_REPORT = {
   audit: {
@@ -41,21 +47,11 @@ const npmOptions = (cwd, timeout, signal) => ({
 });
 
 const runNpm = (cwd, args) =>
-  runProcSync(npmBin(), args, npmOptions(cwd, INSTALL_MS));
-
-const runNpmAsync = (cwd, args) =>
   runProc(npmBin(), args, npmOptions(cwd, INSTALL_MS));
 
 const npmOutput = (result) => (result.error ? '' : result.stdout);
 
-const collectReport = (top, kind) => {
-  const report = NPM_REPORT[kind];
-  if (!fs.existsSync(path.join(top, report.file))) return null;
-  const options = npmOptions(top, AUDIT_MS);
-  return report.parse(npmOutput(runProcSync(npmBin(), report.args, options)));
-};
-
-const collectReportAsync = async (top, kind, signal) => {
+const collectReport = async (top, kind, signal) => {
   const report = NPM_REPORT[kind];
   if (!fs.existsSync(path.join(top, report.file))) return null;
   const options = npmOptions(top, AUDIT_MS, signal);
@@ -67,13 +63,16 @@ const depPaths = (item) => item.dep?.files ?? [];
 
 const depChange = (item) => item.dep?.change ?? null;
 
-const hasProposed = (item) => !!depChange(item)?.propose;
-
-const isStagedOrCommit = (item) =>
-  item.origin === 'staged' || item.origin === 'commit';
+const isStagedOrCommit = (item) => {
+  const staged = item.origin === 'staged';
+  const commit = item.origin === 'commit';
+  return staged || commit;
+};
 
-const firstDepRel = (rels, kind) =>
-  rels.find((rel) => depFileMeta(rel)?.kind === kind) ?? '';
+const firstDepRel = (rels, kind) => {
+  const match = (rel) => depFileMeta(rel)?.kind === kind;
+  return rels.find(match) ?? '';
+};
 
 const proposedNpmPlan = (top, item) => {
   const change = depChange(item);
@@ -118,8 +117,25 @@ const extrasNeeds = (items, rev, extra) => {
   return { live, scan: live || hasDepDiff, audit };
 };
 
-const foldLoaded = (items, top, rev, extra) => {
-  const readSides = (origin, rel) => readDepSides(top, rev, origin, rel);
+const NO_SIDES = { oldText: '', newText: '' };
+
+const sidesReader = async (items, top, rev) => {
+  const sides = new Map();
+  const reads = [];
+  for (const group of collectGroups(items).values()) {
+    for (const name of [MANIFEST, LOCKFILE]) {
+      const rel = relOf(group.dir, name);
+      const key = `${group.origin}\0${rel}`;
+      const keep = (found) => sides.set(key, found);
+      reads.push(readDepSides(top, rev, group.origin, rel).then(keep));
+    }
+  }
+  await Promise.all(reads);
+  return (origin, rel) => sides.get(`${origin}\0${rel}`) ?? NO_SIDES;
+};
+
+const foldLoaded = async (items, top, rev, extra) => {
+  const readSides = await sidesReader(items, top, rev);
   const needs = extrasNeeds(items, rev, extra);
   const collect = extra.collect !== false;
   const scan = collect && needs.scan;
@@ -129,10 +145,10 @@ const foldLoaded = (items, top, rev, extra) => {
     exportEntries = collectExportMeta(top);
   }
   if (collect && needs.audit && audit === undefined) {
-    audit = collectReport(top, 'audit');
+    audit = await collectReport(top, 'audit', extra.signal);
   }
   if (collect && needs.live && outdated === undefined) {
-    outdated = collectReport(top, 'outdated');
+    outdated = await collectReport(top, 'outdated', extra.signal);
   }
   audit ??= null;
   outdated ??= null;
@@ -141,16 +157,16 @@ const foldLoaded = (items, top, rev, extra) => {
     exportEntries,
   });
   if (!needs.live || !isPathInScope(MANIFEST, extra.paths)) return folded;
-  const pkgText = worktreeText(top, MANIFEST);
-  const lockText = worktreeText(top, LOCKFILE);
+  const texts = [worktreeText(top, MANIFEST), worktreeText(top, LOCKFILE)];
+  const [pkgText, lockText] = await Promise.all(texts);
   const options = { lockText, usedNames, root: top, exportEntries };
   return mergeProposedItems(folded, pkgText, outdated, audit, options);
 };
 
-const finishLoad = (snapshot, extra) => {
+const finishLoad = async (snapshot, extra) => {
   const { top, rev, parsed } = snapshot;
   const options = { ...extra, collect: !extra.deferExtras };
-  const items = foldLoaded(parsed, top, rev, options);
+  const items = await foldLoaded(parsed, top, rev, options);
   const pending = extra.deferExtras && extrasNeeds(parsed, rev, extra).audit;
   return { ...snapshot, items, pending };
 };
@@ -167,21 +183,23 @@ const loadExtras = async (snapshot, extra = {}) => {
   const { signal } = extra;
   const needs = extrasNeeds(parsed, rev, extra);
   const known = extra.exportEntries;
+  let exportMeta = known;
+  if (known === undefined && needs.scan) {
+    exportMeta = later(() => collectExportMeta(top));
+  }
   const [usedNames, audit, outdated, exportEntries] = await Promise.all([
     needs.scan ? later(() => collectUsedNames(top)) : null,
     reportTask(needs.audit, extra.auditMap, () =>
-      collectReportAsync(top, 'audit', signal),
+      collectReport(top, 'audit', signal),
     ),
     reportTask(needs.live, extra.outdatedMap, () =>
-      collectReportAsync(top, 'outdated', signal),
+      collectReport(top, 'outdated', signal),
     ),
-    known === undefined && needs.scan
-      ? later(() => collectExportMeta(top))
-      : known,
+    exportMeta,
   ]);
   if (signal && signal.aborted) throw abortError();
   const found = { usedNames, auditMap: audit, outdatedMap: outdated };
-  const items = foldLoaded(parsed, top, rev, {
+  const items = await foldLoaded(parsed, top, rev, {
     ...extra,
     ...found,
     paths: extra.paths ?? [],
@@ -207,23 +225,23 @@ const restoreFile = (top, saved) => {
   else fs.rmSync(abs, { force: true });
 };
 
-const mergeLive = (top, rel, item, base, side) => {
-  const sides = readDepSides(top, null, item.origin, rel);
+const mergeLive = async (top, rel, item, base, side) => {
+  const sides = await readDepSides(top, null, item.origin, rel);
   const { kind } = depFileMeta(rel);
   const change = depChange(item);
   return mergeDepFile(base, sides.oldText, sides.newText, change, side, kind);
 };
 
-const applyDepIndex = (top, rel, item, side) => {
+const applyDepIndex = async (top, rel, item, side) => {
   if (!depFileMeta(rel)) return;
-  const indexed = gitText(top, `:${rel}`) || gitText(top, `HEAD:${rel}`);
-  writeIndex(top, rel, mergeLive(top, rel, item, indexed, side));
+  const indexed = await indexedText(top, rel);
+  await writeIndex(top, rel, await mergeLive(top, rel, item, indexed, side));
 };
 
-const applyDepWorktree = (top, rel, item, side) => {
+const applyDepWorktree = async (top, rel, item, side) => {
   if (!depFileMeta(rel)) return;
-  const text = mergeLive(top, rel, item, worktreeText(top, rel), side);
-  writeFile(top, rel, text);
+  const live = await worktreeText(top, rel);
+  await writeFile(top, rel, await mergeLive(top, rel, item, live, side));
 };
 
 const npmError = (result, fail) => {
@@ -232,12 +250,12 @@ const npmError = (result, fail) => {
   return new Error(oneLine(msg || fail, fail));
 };
 
-const stagePlan = (top, plan) => {
+const stagePlan = async (top, plan) => {
   const toAdd = [];
   if (!plan.lockOnly && plan.manifest) toAdd.push(plan.manifest);
   if (fs.existsSync(path.join(top, plan.lockPath))) toAdd.push(plan.lockPath);
   if (!toAdd.length) return;
-  requireOk(runGit(['add', '--', ...toAdd], top));
+  await gitOk(['add', '--', ...toAdd], top);
 };
 
 const startPlan = (top, item) => {
@@ -248,113 +266,151 @@ const startPlan = (top, item) => {
   return { plan, owned };
 };
 
-const finishPlan = (top, plan, result, stage = stagePlan) => {
+const finishPlan = async (top, plan, result, stage = stagePlan) => {
   const failed = result && (result.error || result.status !== 0);
   if (failed) throw npmError(result, plan.fail);
-  stage(top, plan);
+  await stage(top, plan);
+};
+
+const manifestPlan = (top, rel) => {
+  const meta = depFileMeta(rel);
+  if (!meta || meta.kind !== 'manifest') return null;
+  return {
+    cwd: meta.dir === '.' ? top : path.join(top, meta.dir),
+    npmArgs: ['i'],
+    fail: 'npm i failed',
+    lockOnly: false,
+    lockPath: relOf(meta.dir, LOCKFILE),
+    manifest: rel,
+  };
+};
+
+const syncManifest = async (top, rel, extra = {}) => {
+  const plan = manifestPlan(top, rel);
+  if (!plan) return;
+  const install = extra.run ?? runNpm;
+  const result = await install(plan.cwd, plan.npmArgs);
+  await finishPlan(top, plan, result, extra.stage);
 };
 
 const restoreOwned = (top, owned) => {
   for (const saved of owned) restoreFile(top, saved);
 };
 
-const applyProposedUpdate = (top, item, extra = {}) => {
-  const started = startPlan(top, item);
-  if (!started) return;
-  const { plan, owned } = started;
-  try {
-    if (plan.prepareManifest) applyDepWorktree(top, plan.manifest, item, 'new');
-    const install = extra.run ?? plan.runner ?? runNpm;
-    finishPlan(top, plan, install(plan.cwd, plan.npmArgs), extra.stage);
-  } catch (error) {
-    restoreOwned(top, owned);
-    throw error;
-  }
-};
+const unlocked = (write) => write();
 
-const applyProposedUpdateAsync = async (top, item) => {
+// The install can run for minutes, so only the file and index steps around
+// it go through the caller's write lock
+const applyProposedUpdate = async (top, item, extra = {}) => {
   const started = startPlan(top, item);
   if (!started) return;
   const { plan, owned } = started;
+  const locked = extra.locked ?? unlocked;
   try {
-    if (plan.prepareManifest) applyDepWorktree(top, plan.manifest, item, 'new');
-    const install = plan.runner ?? runNpmAsync;
-    finishPlan(top, plan, await install(plan.cwd, plan.npmArgs));
+    if (plan.prepareManifest) {
+      await locked(() => applyDepWorktree(top, plan.manifest, item, 'new'));
+    }
+    const install = extra.run ?? plan.runner ?? runNpm;
+    const result = await install(plan.cwd, plan.npmArgs);
+    await locked(() => finishPlan(top, plan, result, extra.stage));
   } catch (error) {
     restoreOwned(top, owned);
     throw error;
   }
 };
 
-const applyDepChange = (top, item, mode) => {
+const applyDepChange = async (top, item, mode, extra) => {
   const change = depChange(item);
   if (change.propose) {
-    if (mode === 'add') return void applyProposedUpdate(top, item);
+    if (mode === 'add') {
+      await applyProposedUpdate(top, item, extra);
+      return;
+    }
     if (!change.unused) return;
   }
   for (const rel of depPaths(item)) {
     if (mode !== 'revert') {
-      applyDepIndex(top, rel, item, mode === 'add' ? 'new' : 'old');
+      await applyDepIndex(top, rel, item, mode === 'add' ? 'new' : 'old');
       continue;
     }
-    if (item.origin === 'staged') applyDepIndex(top, rel, item, 'old');
-    applyDepWorktree(top, rel, item, 'old');
+    if (item.origin === 'staged') await applyDepIndex(top, rel, item, 'old');
+    await applyDepWorktree(top, rel, item, 'old');
   }
 };
 
-const addItem = (top, item) => {
-  if (!item.dep) return void worktree.addItem(top, item);
+const addItem = async (top, item, extra) => {
+  if (!item.dep) {
+    await worktree.addItem(top, item);
+    await syncManifest(top, itemPath(item), extra);
+    return;
+  }
   if (isStagedOrCommit(item)) return;
-  if (depChange(item)) return void applyDepChange(top, item, 'add');
+  if (depChange(item)) {
+    await applyDepChange(top, item, 'add', extra);
+    return;
+  }
   const rels = depPaths(item);
-  if (rels.length) requireOk(runGit(['add', '--', ...rels], top));
+  if (rels.length) await gitOk(['add', '--', ...rels], top);
 };
 
-const addItemAsync = async (top, item) => {
-  if (isStagedOrCommit(item) || !hasProposed(item)) {
-    return void addItem(top, item);
-  }
-  await applyProposedUpdateAsync(top, item);
+const stagePath = async (top, rel, extra) => {
+  await worktree.stagePath(top, rel);
+  await syncManifest(top, rel, extra);
 };
 
-const unstageItem = (top, item) => {
-  if (!item.dep) return void worktree.unstageItem(top, item);
+const unstageItem = async (top, item) => {
+  if (!item.dep) {
+    await worktree.unstageItem(top, item);
+    return;
+  }
   if (item.origin !== 'staged') return;
-  if (depChange(item)) return void applyDepChange(top, item, 'unstage');
+  if (depChange(item)) {
+    await applyDepChange(top, item, 'unstage');
+    return;
+  }
   const rels = depPaths(item);
   if (!rels.length) return;
-  requireOk(runGit(['restore', '--staged', '--', ...rels], top));
+  await gitOk(['restore', '--staged', '--', ...rels], top);
 };
 
-const revertItem = (top, item) => {
+const revertItem = async (top, item) => {
   if (item.origin === 'commit') return;
-  if (!item.dep) return void worktree.revertItem(top, item);
-  if (depChange(item)) return void applyDepChange(top, item, 'revert');
+  if (!item.dep) {
+    await worktree.revertItem(top, item);
+    return;
+  }
+  if (depChange(item)) {
+    await applyDepChange(top, item, 'revert');
+    return;
+  }
   const byPath = groupByPath(item.dep.items ?? []);
-  for (const rel of byPath.keys()) revertOnePath(top, rel, byPath.get(rel));
+  for (const rel of byPath.keys()) {
+    await revertOnePath(top, rel, byPath.get(rel));
+  }
 };
 
-const revertFile = (top, rel, items) => {
+const revertFile = async (top, rel, items) => {
   const rels = new Set([rel]);
   for (const item of items) {
     for (const file of depPaths(item)) rels.add(file);
   }
   for (const file of rels) {
     const group = itemsForPath(file, items);
-    revertOnePath(top, file, group.length ? group : items);
+    await revertOnePath(top, file, group.length ? group : items);
   }
 };
 
 module.exports = {
-  collectReportAsync,
+  collectReport,
   finishLoad,
   loadExtras,
   captureFile,
   restoreFile,
   proposedNpmPlan,
   applyProposedUpdate,
+  syncManifest,
   addItem,
-  addItemAsync,
+  stagePath,
   unstageItem,
   revertItem,
   revertFile,

package/lib/git/git.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const {
+  capabilitiesFor,
+  attachCapabilities,
+} = require('../source/capabilities.js');
+const worktree = require('./worktree.js');
+const branches = require('./branches.js');
+const gitDeps = require('./deps.js');
+
+const load = async (cwd, paths = [], options = {}) => {
+  const snapshot = await worktree.readSnapshot(cwd, paths, options);
+  const deferExtras = options.deferExtras ?? true;
+  return gitDeps.finishLoad(snapshot, { ...options, paths, deferExtras });
+};
+
+const REPO_METHODS = {
+  load,
+  loadExtras: gitDeps.loadExtras,
+  toplevel: worktree.toplevel,
+  resolveRev: worktree.resolveRev,
+  listFiles: worktree.listScopeFiles,
+  fileText: worktree.fileText,
+  add: gitDeps.addItem,
+  unstage: gitDeps.unstageItem,
+  revert: gitDeps.revertItem,
+  revertFile: gitDeps.revertFile,
+  edit: worktree.editItem,
+  writeFile: worktree.writeFile,
+  stagePath: gitDeps.stagePath,
+  commit: branches.commitChanges,
+  updateCommit: branches.updateCommit,
+  hasStaged: branches.hasStaged,
+  lastMessage: branches.lastMessage,
+  commitMessage: branches.commitMessage,
+  listBranches: branches.listBranches,
+  listCommits: branches.listCommits,
+  currentBranch: worktree.currentBranch,
+  checkout: branches.checkoutBranch,
+  createBranch: branches.createBranch,
+  rebase: branches.rebaseBranch,
+  drop: branches.dropBranch,
+  dropCommit: branches.dropCommit,
+  applyFixup: branches.applyFixup,
+  reword: branches.rewordCommit,
+  pull: branches.pullChanges,
+  push: branches.pushChanges,
+};
+
+const createGitRepo = () =>
+  attachCapabilities(REPO_METHODS, capabilitiesFor('local'));
+
+const listed = createGitRepo();
+const unlisted = Object.keys(REPO_METHODS).filter(
+  (name) => !Object.hasOwn(listed, name),
+);
+if (unlisted.length) {
+  throw new Error(`git methods without a capability: ${unlisted.join(', ')}`);
+}
+
+module.exports = {
+  ...branches,
+  currentBranch: worktree.currentBranch,
+  editItem: worktree.editItem,
+  load,
+  loadExtras: gitDeps.loadExtras,
+  addItem: gitDeps.addItem,
+  unstageItem: gitDeps.unstageItem,
+  revertItem: gitDeps.revertItem,
+  createGitRepo,
+};