reslop 0.2.6 → 0.3.0

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

@@ -4,12 +4,9 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const utilities = require('./utilities.js');
-const { oneLine } = utilities;
-const files = require('./files.js');
-const { shortAge } = files;
-const worktree = require('./git-worktree.js');
-const { requireOk, runGit, command, gitOp } = worktree;
+const { oneLine, trimText } = require('../common/utilities.js');
+const { shortAge } = require('../common/format.js');
+const { requireOk, runGit, command, gitOp } = require('./worktree.js');
 
 const BRANCH_FORMAT = [
   '%(HEAD)',
@@ -43,9 +40,7 @@ const AUTOSQUASH_ARGS = [
   '--interactive',
   '--autosquash',
 ];
-const REWORD_TODO = path.join(__dirname, 'git-reword-todo.js');
-
-const trimText = (value) => `${value ?? ''}`.trim();
+const REWORD_TODO = path.join(__dirname, 'reword-todo.js');
 
 const required = (value, message) => {
   const text = trimText(value);
@@ -60,9 +55,9 @@ const messageBody = (message) => {
   return text.endsWith('\n') ? text : `${text}\n`;
 };
 
-const commitMessage = (top, sha) => {
+const commitMessage = async (top, sha) => {
   const spec = trimText(sha) || 'HEAD';
-  const result = runGit(['log', '-1', '--format=%B', spec], top);
+  const result = await runGit(['log', '-1', '--format=%B', spec], top);
   return result.status === 0 ? result.stdout.trimEnd() : '';
 };
 
@@ -112,7 +107,7 @@ const statCount = (stat, word) => {
   return match ? parseInt(match[1], 10) : 0;
 };
 
-const listCommits = (top) => {
+const listCommits = async (top) => {
   const args = [
     'log',
     '-z',
@@ -120,7 +115,7 @@ const listCommits = (top) => {
     `--format=${COMMIT_FORMAT}`,
     `--max-count=${COMMIT_LIMIT}`,
   ];
-  const result = requireOk(runGit(args, top), 'log failed');
+  const result = requireOk(await runGit(args, top), 'log failed');
   const commits = [];
   for (const chunk of result.stdout.split('\0')) {
     const stat = STAT_LEAD.exec(chunk);
@@ -141,11 +136,10 @@ const parseTrack = (text) => {
   const raw = trimText(text).replace(/^\[|\]$/g, '');
   const ahead = /ahead (\d+)/.exec(raw);
   const behind = /behind (\d+)/.exec(raw);
-  return {
-    ahead: ahead ? Number(ahead[1]) : 0,
-    behind: behind ? Number(behind[1]) : 0,
-    gone: raw === 'gone',
-  };
+  const aheadCount = ahead ? Number(ahead[1]) : 0;
+  const behindCount = behind ? Number(behind[1]) : 0;
+  const gone = raw === 'gone';
+  return { ahead: aheadCount, behind: behindCount, gone };
 };
 
 const parseBranchLine = (line) => {
@@ -163,31 +157,33 @@ const parseBranchLine = (line) => {
   };
 };
 
-const defaultBranch = (top, names) => {
-  const result = runGit(['symbolic-ref', '--short', ORIGIN_HEAD], top);
+const defaultBranch = async (top, names) => {
+  const args = ['symbolic-ref', '--short', ORIGIN_HEAD];
+  const result = await runGit(args, top);
   const ref = result.status === 0 ? result.stdout.trim() : '';
-  const remote = ref.startsWith(ORIGIN_PREFIX)
-    ? ref.slice(ORIGIN_PREFIX.length)
-    : ref;
+  let remote = ref;
+  if (ref.startsWith(ORIGIN_PREFIX)) {
+    remote = ref.slice(ORIGIN_PREFIX.length);
+  }
   if (names.has(remote)) return remote;
   return DEFAULT_BRANCHES.find((name) => names.has(name)) ?? '';
 };
 
-const listBranches = (top) => {
+const listBranches = async (top) => {
   const args = ['for-each-ref', `--format=${BRANCH_FORMAT}`, 'refs/heads'];
-  const result = requireOk(runGit(args, top), 'branch failed');
+  const result = requireOk(await runGit(args, top), 'branch failed');
   const lines = result.stdout.split('\n').filter(Boolean);
   const branches = lines.map((line) => parseBranchLine(line)).filter(Boolean);
   const names = new Set(branches.map((entry) => entry.name));
-  const primary = defaultBranch(top, names);
+  const primary = await defaultBranch(top, names);
   return branches.map((entry) => ({
     ...entry,
     isDefault: entry.name === primary,
   }));
 };
 
-const hasStaged = (top) => {
-  const result = runGit(['diff', '--cached', '--quiet'], top);
+const hasStaged = async (top) => {
+  const result = await runGit(['diff', '--cached', '--quiet'], top);
   return result.status === 1;
 };
 
@@ -243,6 +239,24 @@ const commitOp = gitOp(function* (kind, message) {
   requireOk(result);
 });
 
+const updateOp = gitOp(function* (sha) {
+  const commit = yield* resolveCommit(required(sha, 'empty commit'));
+  const head = yield* resolveCommit('HEAD');
+  if (commit === head) {
+    const result = yield command(['commit', '--amend', '--no-edit']);
+    return void requireOk(result);
+  }
+  const fixed = yield command(['commit', '--fixup', commit]);
+  requireOk(fixed);
+  const range = yield* rebaseRange(commit);
+  try {
+    yield* rebase([...AUTOSQUASH_ARGS, ...range]);
+  } catch (error) {
+    yield command(['reset', '--soft', 'HEAD~1']);
+    throw error;
+  }
+});
+
 const dropCommitOp = gitOp(function* (sha) {
   const target = yield* resolveCommit(required(sha, 'empty commit'));
   const parent = yield command(['rev-parse', '--verify', `${target}^`]);
@@ -363,24 +377,15 @@ module.exports = {
   listCommits,
   listBranches,
   hasStaged,
-  checkoutBranch: checkoutOp.sync,
-  checkoutBranchAsync: checkoutOp.async,
-  createBranch: createOp.sync,
-  createBranchAsync: createOp.async,
-  rebaseBranch: rebaseOp.sync,
-  rebaseBranchAsync: rebaseOp.async,
-  dropBranch: dropBranchOp.sync,
-  dropBranchAsync: dropBranchOp.async,
-  dropCommit: dropCommitOp.sync,
-  dropCommitAsync: dropCommitOp.async,
-  applyFixup: fixupOp.sync,
-  applyFixupAsync: fixupOp.async,
-  rewordCommit: rewordOp.sync,
-  rewordCommitAsync: rewordOp.async,
-  pullChanges: pullOp.sync,
-  pullChangesAsync: pullOp.async,
-  pushChanges: pushOp.sync,
-  pushChangesAsync: pushOp.async,
-  commitChanges: commitOp.sync,
-  commitChangesAsync: commitOp.async,
+  checkoutBranch: checkoutOp,
+  createBranch: createOp,
+  rebaseBranch: rebaseOp,
+  dropBranch: dropBranchOp,
+  dropCommit: dropCommitOp,
+  applyFixup: fixupOp,
+  rewordCommit: rewordOp,
+  pullChanges: pullOp,
+  pushChanges: pushOp,
+  commitChanges: commitOp,
+  updateCommit: updateOp,
 };

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,104 +266,115 @@ 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 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);
+    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);
+const unstageItem = async (top, item) => {
+  if (!item.dep) {
+    await worktree.unstageItem(top, item);
+    return;
   }
-  await applyProposedUpdateAsync(top, item);
-};
-
-const unstageItem = (top, item) => {
-  if (!item.dep) return void worktree.unstageItem(top, item);
   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 = {
+  collectReport,
   finishLoad,
   loadExtras,
   captureFile,
@@ -353,7 +382,6 @@ module.exports = {
   proposedNpmPlan,
   applyProposedUpdate,
   addItem,
-  addItemAsync,
   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: worktree.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,
+};