reslop 0.2.5 → 0.2.6

package/lib/git-worktree.js

@@ -3,17 +3,15 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const proc = require('./utilities.js');
-const { runProc, runProcSync, isAbort } = proc;
+const utilities = require('./utilities.js');
+const { runProc, runProcSync, isAbort, oneLine } = utilities;
 const diff = require('./diff/diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
 const files = require('./files.js');
-const { itemPath, REVIEW_DIR } = files;
+const { itemPath, isReadOnlyOrigin, REVIEW_DIR } = files;
 const edit = require('./diff/edit.js');
 const { replaceBlockAdds } = edit;
 
-const oneLine = (text, fallback = 'git failed') => proc.oneLine(text, fallback);
-
 const GIT_CONFIG = [
   '-c',
   'core.quotepath=false',
@@ -21,14 +19,11 @@ const GIT_CONFIG = [
   'i18n.logOutputEncoding=utf-8',
 ];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
-const GIT_ENCODING = proc.DEFAULT_ENCODING;
-const GIT_MAX_BUFFER = proc.DEFAULT_MAX_BUFFER;
+const BINARY_SIZE = 1000000;
 
-const gitProcOptions = (cwd, extra = {}) => ({
+const gitOptions = (cwd, extra) => ({
   cwd,
   env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...extra.env },
-  encoding: GIT_ENCODING,
-  maxBuffer: GIT_MAX_BUFFER,
   input: extra.input,
   signal: extra.signal,
 });
@@ -46,37 +41,61 @@ const requireOk = (result, fallback = 'git failed') => {
   throw new Error(oneLine(msg, fallback));
 };
 
-const runGit = (args, cwd, input, extra = {}) => {
-  const options = gitProcOptions(cwd, { input, env: extra.env });
-  return gitResult(runProcSync('git', args, options));
+const runGit = (args, cwd, extra = {}) =>
+  gitResult(runProcSync('git', args, gitOptions(cwd, extra)));
+
+const runGitAsync = (args, cwd, extra = {}) =>
+  runProc('git', args, gitOptions(cwd, extra)).then(gitResult);
+
+const command = (args, extra = {}) => ({
+  args,
+  input: extra.input,
+  env: extra.env,
+});
+
+const runSteps = (steps, top) => {
+  try {
+    let step = steps.next();
+    while (!step.done) {
+      step = steps.next(runGit(step.value.args, top, step.value));
+    }
+    return step.value;
+  } finally {
+    steps.return();
+  }
 };
 
-const runGitAsync = (args, cwd, extra = {}) => {
-  const options = gitProcOptions(cwd, extra);
-  return runProc('git', args, options).then(gitResult);
+const runStepsAsync = async (steps, top, signal) => {
+  try {
+    let step = steps.next();
+    while (!step.done) {
+      const extra = { ...step.value, signal };
+      step = steps.next(await runGitAsync(step.value.args, top, extra));
+    }
+    return step.value;
+  } finally {
+    steps.return();
+  }
 };
 
-const pathArgsOf = (paths) => (paths.length ? ['--', ...paths] : []);
+const gitOp = (op) => ({
+  sync: (top, ...args) => runSteps(op(...args), top),
+  async: (top, ...args) => runStepsAsync(op(...args), top),
+});
 
-const cachedDiffArgs = (pathArgs) => [
-  ...GIT_CONFIG,
-  'diff',
-  '--cached',
-  ...DIFF_OPTS,
-  ...pathArgs,
-];
+const pathArgs = (paths) => (paths.length ? ['--', ...paths] : []);
 
-const worktreeDiffArgs = (pathArgs) => [
+const diffArgs = (revs, paths) => [
   ...GIT_CONFIG,
   'diff',
   ...DIFF_OPTS,
-  ...pathArgs,
+  ...revs,
+  ...pathArgs(paths),
 ];
 
-const commitDiffArgs = (commit, parent, pathArgs) => {
+const commitDiffArgs = (commit, parent, paths) => {
   if (parent.status === 0) {
-    const from = parent.stdout.trim();
-    return [...GIT_CONFIG, 'diff', ...DIFF_OPTS, from, commit, ...pathArgs];
+    return diffArgs([parent.stdout.trim(), commit], paths);
   }
   return [
     ...GIT_CONFIG,
@@ -86,62 +105,34 @@ const commitDiffArgs = (commit, parent, pathArgs) => {
     '-p',
     ...DIFF_OPTS,
     commit,
-    ...pathArgs,
+    ...pathArgs(paths),
   ];
 };
 
-const BINARY_SIZE = 1000000;
+const untrackedArgs = (paths) => [
+  'ls-files',
+  '-o',
+  '--exclude-standard',
+  '-z',
+  ...pathArgs(paths),
+];
 
-const isReviewFile = (rel) => {
-  if (!rel) return false;
-  const first = rel.split(/[/\\]/)[0];
-  return first === REVIEW_DIR;
-};
+const isReviewFile = (rel) => rel.split(/[/\\]/)[0] === REVIEW_DIR;
 
 const dropReviewItems = (items) =>
   items.filter((item) => !isReviewFile(itemPath(item)));
 
-const isBinaryBuffer = (buf) => {
-  if (buf.length > BINARY_SIZE) return true;
-  return buf.includes(0);
-};
+const isBinaryBuffer = (buf) => buf.length > BINARY_SIZE || buf.includes(0);
 
-const namesFromLs = (stdout) => {
-  if (!stdout) return [];
-  return stdout.split('\0').filter(Boolean);
-};
-
-const untrackedLsArgs = (paths) => {
-  const args = ['ls-files', '-o', '--exclude-standard', '-z'];
-  if (paths.length) args.push('--', ...paths);
-  return args;
-};
-
-const listUntracked = (top, paths) => {
-  const result = requireOk(runGit(untrackedLsArgs(paths), top));
-  return namesFromLs(result.stdout);
-};
-
-const filterListed = (names) =>
-  names.filter((rel) => rel && !isReviewFile(rel));
-
-const listTreeArgs = (rev, paths) => {
-  const args = ['ls-tree', '-r', '--name-only', '-z', rev];
-  if (paths.length) args.push('--', ...paths);
-  return args;
-};
-
-const listWorktreeArgs = (paths) => {
-  const args = ['ls-files', '-co', '--exclude-standard', '-z'];
-  if (paths.length) args.push('--', ...paths);
-  return args;
-};
+const namesFromLs = (stdout) => stdout.split('\0').filter(Boolean);
 
 const listScopeFiles = (top, paths = [], options = {}) => {
   const rev = options.commit;
-  const args = rev ? listTreeArgs(rev, paths) : listWorktreeArgs(paths);
+  const args = rev
+    ? ['ls-tree', '-r', '--name-only', '-z', rev, ...pathArgs(paths)]
+    : ['ls-files', '-co', '--exclude-standard', '-z', ...pathArgs(paths)];
   const result = requireOk(runGit(args, top), 'ls-files failed');
-  const names = filterListed(namesFromLs(result.stdout));
+  const names = namesFromLs(result.stdout).filter((rel) => !isReviewFile(rel));
   names.sort((left, right) => left.localeCompare(right, 'en'));
   return names;
 };
@@ -160,43 +151,33 @@ const untrackedItemsFrom = (top, names) => {
   const files = [];
   for (const rel of names) {
     if (isReviewFile(rel)) continue;
-    const full = path.join(top, rel);
     let buf;
     try {
-      buf = fs.readFileSync(full);
+      buf = fs.readFileSync(path.join(top, rel));
     } catch (error) {
       if (error.code === 'ENOENT') continue;
       throw error;
     }
-    if (isBinaryBuffer(buf)) {
-      files.push(binaryNewFile(rel));
-      continue;
-    }
-    files.push(synthesizeNewFile(rel, buf.toString('utf8')));
+    if (isBinaryBuffer(buf)) files.push(binaryNewFile(rel));
+    else files.push(synthesizeNewFile(rel, buf.toString('utf8')));
   }
   return itemsFromFiles(files, 'untracked');
 };
 
-const mergeItems = (groups) => {
+const groupByPath = (items) => {
   const byPath = new Map();
-  for (const group of groups) {
-    for (const item of group) {
-      const rel = itemPath(item);
-      const list = byPath.get(rel);
-      if (list) {
-        list.push(item);
-        continue;
-      }
-      byPath.set(rel, [item]);
-    }
+  for (const item of items) {
+    const rel = itemPath(item);
+    const list = byPath.get(rel);
+    if (list) list.push(item);
+    else byPath.set(rel, [item]);
   }
-  return [...byPath.values()].flat();
+  return byPath;
 };
 
 const gitText = (top, spec) => {
   const result = runGit(['show', spec], top);
-  if (result.status !== 0) return '';
-  return result.stdout ?? '';
+  return result.status === 0 ? result.stdout : '';
 };
 
 const worktreeText = (top, rel) => {
@@ -215,24 +196,19 @@ const fileText = (top, rel, rev) => {
 
 const readDepSides = (top, rev, origin, rel) => {
   if (origin === 'untracked') {
-    const newText = worktreeText(top, rel);
-    return { oldText: '', newText };
+    return { oldText: '', newText: worktreeText(top, rel) };
   }
   if (origin === 'staged') {
     const oldText = gitText(top, `HEAD:${rel}`);
-    const newText = gitText(top, `:${rel}`);
-    return { oldText, newText };
+    return { oldText, newText: gitText(top, `:${rel}`) };
   }
   if (origin === 'unstaged') {
-    const indexed = gitText(top, `:${rel}`);
-    const oldText = indexed || gitText(top, `HEAD:${rel}`);
-    const newText = worktreeText(top, rel);
-    return { oldText, newText };
+    const oldText = gitText(top, `:${rel}`) || gitText(top, `HEAD:${rel}`);
+    return { oldText, newText: worktreeText(top, rel) };
   }
   if (origin === 'commit' && rev) {
     const oldText = gitText(top, `${rev}^:${rel}`);
-    const newText = gitText(top, `${rev}:${rel}`);
-    return { oldText, newText };
+    return { oldText, newText: gitText(top, `${rev}:${rel}`) };
   }
   return { oldText: '', newText: '' };
 };
@@ -245,106 +221,77 @@ const toplevel = (cwd) => {
 
 const resolveRev = (cwd, spec) => {
   if (!spec) return null;
-  const top = toplevel(cwd);
   const args = ['rev-parse', '--verify', `${spec}^{commit}`];
-  const result = runGit(args, top);
-  if (result.status !== 0) return null;
-  return result.stdout.trim();
+  const result = runGit(args, toplevel(cwd));
+  return result.status === 0 ? result.stdout.trim() : null;
 };
 
 const shortRev = (top, commit) => {
   const result = runGit(['rev-parse', '--short', commit], top);
-  if (result.status !== 0) return commit.slice(0, 7);
-  return result.stdout.trim();
+  return result.status === 0 ? result.stdout.trim() : commit.slice(0, 7);
 };
 
 const currentBranch = (top) => {
-  const args = ['rev-parse', '--abbrev-ref', 'HEAD'];
-  const result = runGit(args, top);
+  const result = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], top);
   if (result.status !== 0) return '';
   const name = result.stdout.trim();
-  if (!name || name === 'HEAD') return '';
-  return name;
+  return name === 'HEAD' ? '' : name;
 };
 
-const snapshotWorktree = (top, stagedOut, unstagedOut, names) => {
-  const stagedDiff = parseDiff(stagedOut);
-  const unstagedDiff = parseDiff(unstagedOut);
-  const staged = itemsFromFiles(stagedDiff, 'staged');
-  const unstaged = itemsFromFiles(unstagedDiff, 'unstaged');
-  const untracked = untrackedItemsFrom(top, names);
-  const combined = mergeItems([staged, unstaged, untracked]);
-  const parsed = dropReviewItems(combined);
-  const branch = currentBranch(top);
-  return { top, parsed, branch };
+const snapshotWorktree = (top, results) => {
+  const outputs = results.map((result) => requireOk(result).stdout);
+  const staged = itemsFromFiles(parseDiff(outputs[0]), 'staged');
+  const unstaged = itemsFromFiles(parseDiff(outputs[1]), 'unstaged');
+  const untracked = untrackedItemsFrom(top, namesFromLs(outputs[2]));
+  const grouped = groupByPath([...staged, ...unstaged, ...untracked]);
+  const parsed = dropReviewItems([...grouped.values()].flat());
+  return { top, parsed, branch: currentBranch(top) };
 };
 
 const snapshotCommit = (top, commit, files) => {
-  const commitItems = itemsFromFiles(files, 'commit');
-  const parsed = dropReviewItems(commitItems);
+  const parsed = dropReviewItems(itemsFromFiles(files, 'commit'));
   const revShort = shortRev(top, commit);
-  const branch = currentBranch(top);
-  return { top, parsed, rev: commit, revShort, branch };
+  return { top, parsed, rev: commit, revShort, branch: currentBranch(top) };
 };
 
-const loadCommit = (top, commit, extra) => {
-  const parent = runGit(['rev-parse', '--verify', `${commit}^`], top);
-  const args = commitDiffArgs(commit, parent, extra);
-  const result = requireOk(runGit(args, top));
-  return parseDiff(result.stdout);
-};
+function* commitDiff(commit, paths) {
+  const parent = yield command(['rev-parse', '--verify', `${commit}^`]);
+  const result = yield command(commitDiffArgs(commit, parent, paths));
+  return parseDiff(requireOk(result).stdout);
+}
 
-const loadCommitAsync = async (top, commit, extra, signal) => {
-  const parent = await runGitAsync(
-    ['rev-parse', '--verify', `${commit}^`],
-    top,
-    { signal },
-  );
-  const args = commitDiffArgs(commit, parent, extra);
-  const result = requireOk(await runGitAsync(args, top, { signal }));
-  return parseDiff(result.stdout);
-};
+const worktreeCommands = (paths) => [
+  diffArgs(['--cached'], paths),
+  diffArgs([], paths),
+  untrackedArgs(paths),
+];
 
 const readSnapshot = (cwd, paths, options) => {
   const top = toplevel(cwd);
-  const extra = pathArgsOf(paths);
   const rev = options.commit;
-  if (rev) return snapshotCommit(top, rev, loadCommit(top, rev, extra));
-  const stagedRes = requireOk(runGit(cachedDiffArgs(extra), top));
-  const unstagedRes = requireOk(runGit(worktreeDiffArgs(extra), top));
-  const names = listUntracked(top, paths);
-  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+  if (rev) {
+    return snapshotCommit(top, rev, runSteps(commitDiff(rev, paths), top));
+  }
+  const results = worktreeCommands(paths).map((args) => runGit(args, top));
+  return snapshotWorktree(top, results);
 };
 
 const readSnapshotAsync = async (cwd, paths, options) => {
   const top = toplevel(cwd);
-  const extra = pathArgsOf(paths);
-  const rev = options.commit;
-  const signal = options.signal;
+  const { commit: rev, signal } = options;
   if (rev) {
-    const files = await loadCommitAsync(top, rev, extra, signal);
+    const files = await runStepsAsync(commitDiff(rev, paths), top, signal);
     return snapshotCommit(top, rev, files);
   }
-  const stagedArgs = cachedDiffArgs(extra);
-  const unstagedArgs = worktreeDiffArgs(extra);
-  const lsArgs = untrackedLsArgs(paths);
-  const stagedP = runGitAsync(stagedArgs, top, { signal });
-  const unstagedP = runGitAsync(unstagedArgs, top, { signal });
-  const lsP = runGitAsync(lsArgs, top, { signal });
-  const extras = await Promise.all([stagedP, unstagedP, lsP]);
-  const stagedRes = extras[0];
-  const unstagedRes = extras[1];
-  const lsRes = extras[2];
-  requireOk(stagedRes);
-  requireOk(unstagedRes);
-  const names = namesFromLs(requireOk(lsRes).stdout);
-  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+  const running = worktreeCommands(paths).map((args) =>
+    runGitAsync(args, top, { signal }),
+  );
+  return snapshotWorktree(top, await Promise.all(running));
 };
 
 const applyPatch = (cwd, patch, flags) => {
   const args = ['apply', ...flags, '--whitespace=nowarn', '-'];
-  const result = runGit(args, cwd, patch);
-  requireOk(result, 'apply failed');
+  requireOk(runGit(args, cwd, { input: patch }), 'apply failed');
 };
 
 const addItem = (top, item) => {
@@ -357,35 +304,26 @@ const addItem = (top, item) => {
 
 const unstageItem = (top, item) => {
   if (item.origin !== 'staged') return;
-  const rel = itemPath(item);
   if (item.file.isBinary) {
-    return void requireOk(runGit(['restore', '--staged', '--', rel], top));
+    const args = ['restore', '--staged', '--', itemPath(item)];
+    return void requireOk(runGit(args, top));
   }
   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')) {
-      return void requireOk(runGit(['rm', '-f', '--', rel], top));
-    }
-    return void fs.unlinkSync(path.join(top, rel));
-  }
-  if (origins.has('untracked') && origins.size === 1) {
-    return void fs.unlinkSync(path.join(top, rel));
+  const origins = new Set(items.map((item) => item.origin));
+  const isNew = items.some((item) => item.file?.isNew);
+  if (isNew && origins.has('staged')) {
+    return void requireOk(runGit(['rm', '-f', '--', rel], top));
   }
+  const onlyUntracked = origins.size === 1 && origins.has('untracked');
+  if (isNew || onlyUntracked) return void fs.unlinkSync(path.join(top, rel));
   const args = ['restore', '-s', 'HEAD', '--worktree', '--staged', '--', rel];
   requireOk(runGit(args, top));
 };
 
 const revertItem = (top, item) => {
-  if (item.origin === 'commit') return;
   const rel = itemPath(item);
   if (item.origin === 'untracked') {
     return void fs.unlinkSync(path.join(top, rel));
@@ -393,8 +331,7 @@ const revertItem = (top, item) => {
   if (item.file.isBinary) {
     const args = ['restore', '-s', 'HEAD', '--worktree'];
     if (item.origin === 'staged') args.push('--staged');
-    args.push('--', rel);
-    return void requireOk(runGit(args, top));
+    return void requireOk(runGit([...args, '--', rel], top));
   }
   if (item.origin === 'unstaged') {
     return void applyPatch(top, item.patchRevert, ['--reverse']);
@@ -407,12 +344,6 @@ const revertItem = (top, item) => {
   }
 };
 
-const indexText = (top, rel) => {
-  const result = runGit(['show', `:${rel}`], top);
-  requireOk(result, 'show failed');
-  return result.stdout ?? '';
-};
-
 const indexMode = (top, rel) => {
   const result = requireOk(runGit(['ls-files', '--stage', '--', rel], top));
   const line = result.stdout.trim();
@@ -428,17 +359,17 @@ const indexMode = (top, rel) => {
 
 const writeIndex = (top, rel, text) => {
   const hashArgs = ['hash-object', '-w', `--path=${rel}`, '--stdin'];
-  const hashed = runGit(hashArgs, top, text);
-  requireOk(hashed, 'hash-object failed');
-  const sha = (hashed.stdout ?? '').trim();
+  const hashed = runGit(hashArgs, top, { input: text });
+  const sha = requireOk(hashed, 'hash-object failed').stdout.trim();
   const mode = indexMode(top, rel);
   const args = ['update-index', '--add', '--cacheinfo', mode, sha, rel];
   requireOk(runGit(args, top), 'update-index failed');
 };
 
-const editStaged = (top, rel, abs, hunk, blockId, text) => {
-  const source = indexText(top, rel);
-  const next = replaceBlockAdds(source, hunk, blockId, text);
+const editStaged = (top, rel, abs, item, text) => {
+  const shown = requireOk(runGit(['show', `:${rel}`], top), 'show failed');
+  const source = shown.stdout;
+  const next = replaceBlockAdds(source, item.hunk, item.blockId, text);
   writeIndex(top, rel, next);
   let work = null;
   try {
@@ -446,28 +377,24 @@ const editStaged = (top, rel, abs, hunk, blockId, text) => {
   } catch (error) {
     if (error.code !== 'ENOENT') throw error;
   }
-  if (work === null) {
-    return void fs.writeFileSync(abs, next);
-  }
-  if (work === source) fs.writeFileSync(abs, next);
+  if (work === null || work === source) fs.writeFileSync(abs, next);
 };
 
-const editWorktree = (abs, hunk, blockId, text) => {
+const editWorktree = (abs, item, text) => {
   const source = fs.readFileSync(abs, 'utf8');
-  const next = replaceBlockAdds(source, hunk, blockId, text);
-  if (next === source) return;
-  fs.writeFileSync(abs, next);
+  const next = replaceBlockAdds(source, item.hunk, item.blockId, text);
+  if (next !== source) fs.writeFileSync(abs, next);
 };
 
 const editItem = (top, item, text) => {
-  if (item.origin === 'commit' || item.origin === 'pr') return;
+  if (isReadOnlyOrigin(item.origin)) return;
   const rel = itemPath(item);
   if (!rel || !item.hunk) return;
   const abs = path.join(top, rel);
   if (item.origin === 'staged') {
-    return void editStaged(top, rel, abs, item.hunk, item.blockId, text);
+    return void editStaged(top, rel, abs, item, text);
   }
-  editWorktree(abs, item.hunk, item.blockId, text);
+  editWorktree(abs, item, text);
 };
 
 const writeFile = (top, rel, text) => {
@@ -483,10 +410,12 @@ const stagePath = (top, rel) => {
 };
 
 module.exports = {
-  oneLine,
   requireOk,
   runGit,
   runGitAsync,
+  command,
+  gitOp,
+  groupByPath,
   gitText,
   worktreeText,
   readDepSides,

package/lib/git.js

@@ -3,47 +3,18 @@
 const capabilities = require('./capabilities.js');
 const { capabilitiesFor, attachCapabilities } = capabilities;
 const worktree = require('./git-worktree.js');
-const { readSnapshot, readSnapshotAsync, toplevel, resolveRev } = worktree;
-const { listScopeFiles, fileText, editItem, writeFile, stagePath } = worktree;
-const { addItem, unstageItem, revertItem, currentBranch } = worktree;
 const branches = require('./git-branches.js');
 const gitDeps = require('./git-deps.js');
 
 const load = (cwd, paths = [], options = {}) => {
-  const snapshot = readSnapshot(cwd, paths, options);
+  const snapshot = worktree.readSnapshot(cwd, paths, options);
   return gitDeps.finishLoad(snapshot, { ...options, paths });
 };
 
 const loadAsync = async (cwd, paths = [], options = {}) => {
-  const snapshot = await readSnapshotAsync(cwd, paths, options);
-  return gitDeps.finishLoad(snapshot, {
-    ...options,
-    paths,
-    deferExtras: options.deferExtras ?? true,
-  });
-};
-
-const addGitItem = (top, item) => {
-  if (item.dep) return gitDeps.addItem(top, item);
-  return addItem(top, item);
-};
-
-const addGitItemAsync = async (top, item) => {
-  if (item.dep) return gitDeps.addItemAsync(top, item);
-  return addItem(top, item);
-};
-
-const unstageGitItem = (top, item) => {
-  if (item.dep) return gitDeps.unstageItem(top, item);
-  return unstageItem(top, item);
-};
-
-const revertGitItem = (top, item) => {
-  if (item.origin === 'commit') return;
-  if (item.dep) {
-    return void gitDeps.revertDepItem(top, item);
-  }
-  revertItem(top, item);
+  const snapshot = await worktree.readSnapshotAsync(cwd, paths, options);
+  const deferExtras = options.deferExtras ?? true;
+  return gitDeps.finishLoad(snapshot, { ...options, paths, deferExtras });
 };
 
 const createGitRepo = () =>
@@ -52,18 +23,18 @@ const createGitRepo = () =>
       load,
       loadAsync,
       loadExtras: gitDeps.loadExtras,
-      toplevel,
-      resolveRev,
-      listFiles: listScopeFiles,
-      fileText,
-      add: addGitItem,
-      addAsync: addGitItemAsync,
-      unstage: unstageGitItem,
-      revert: revertGitItem,
+      toplevel: worktree.toplevel,
+      resolveRev: worktree.resolveRev,
+      listFiles: worktree.listScopeFiles,
+      fileText: worktree.fileText,
+      add: gitDeps.addItem,
+      addAsync: gitDeps.addItemAsync,
+      unstage: gitDeps.unstageItem,
+      revert: gitDeps.revertItem,
       revertFile: gitDeps.revertFile,
-      edit: editItem,
-      writeFile,
-      stagePath,
+      edit: worktree.editItem,
+      writeFile: worktree.writeFile,
+      stagePath: worktree.stagePath,
       commit: branches.commitChanges,
       commitAsync: branches.commitChangesAsync,
       hasStaged: branches.hasStaged,
@@ -71,7 +42,7 @@ const createGitRepo = () =>
       commitMessage: branches.commitMessage,
       listBranches: branches.listBranches,
       listCommits: branches.listCommits,
-      currentBranch,
+      currentBranch: worktree.currentBranch,
       checkout: branches.checkoutBranch,
       checkoutAsync: branches.checkoutBranchAsync,
       createBranch: branches.createBranch,
@@ -95,13 +66,14 @@ const createGitRepo = () =>
   );
 
 module.exports = {
-  ...worktree,
   ...branches,
+  currentBranch: worktree.currentBranch,
+  editItem: worktree.editItem,
   load,
   loadAsync,
   loadExtras: gitDeps.loadExtras,
-  addItem: addGitItem,
-  unstageItem: unstageGitItem,
-  revertItem: revertGitItem,
+  addItem: gitDeps.addItem,
+  unstageItem: gitDeps.unstageItem,
+  revertItem: gitDeps.revertItem,
   createGitRepo,
 };