reslop 0.3.1 → 0.3.2

package/lib/git/linked.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { oneLine } = require('../common/utilities.js');
+const { REVIEW_DIR, LOG_DIR } = require('../common/files.js');
+const { runGit, requireOk } = require('./worktree.js');
+
+const HEADS = 'refs/heads/';
+
+const FIELDS = {
+  worktree: (entry, value) => ({ path: path.resolve(value) }),
+  HEAD: (entry, value) => ({ head: value }),
+  branch: (entry, value) => ({ branch: value.replace(HEADS, '') }),
+  detached: () => ({ detached: true }),
+  bare: () => ({ bare: true }),
+  prunable: () => ({ prunable: true }),
+  locked: (entry, value) => ({ locked: true, lockReason: value }),
+};
+
+const parseEntry = (block) => {
+  let entry = {
+    path: '',
+    head: '',
+    branch: '',
+    detached: false,
+    bare: false,
+    locked: false,
+    lockReason: '',
+    prunable: false,
+  };
+  for (const line of block.split('\n')) {
+    const space = line.indexOf(' ');
+    const key = space < 0 ? line : line.slice(0, space);
+    const value = space < 0 ? '' : line.slice(space + 1).trim();
+    const field = Object.hasOwn(FIELDS, key) ? FIELDS[key] : null;
+    if (field) entry = { ...entry, ...field(entry, value) };
+  }
+  return entry;
+};
+
+// The first entry is the main worktree, the others are linked to it
+const parseWorktrees = (text) =>
+  `${text ?? ''}`
+    .split(/\r?\n\r?\n/)
+    .filter((block) => block.trim())
+    .map(parseEntry)
+    .filter((entry) => entry.path)
+    .map((entry, index) => ({ ...entry, main: index === 0 }));
+
+const listWorktrees = async (dir) => {
+  const args = ['worktree', 'list', '--porcelain'];
+  const result = await runGit(args, dir);
+  if (result.status !== 0) return [];
+  return parseWorktrees(result.stdout);
+};
+
+// Git reports real paths, the others can go through links
+const dirKey = (dir) => {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return path.resolve(dir);
+  }
+};
+
+const sameDir = (left, right) => dirKey(left) === dirKey(right);
+
+const findWorktree = (list, dir) => list.find((it) => sameDir(it.path, dir));
+
+const isOwnFile = (rel) => {
+  const head = rel.split(/[/\\]/)[0];
+  return head === REVIEW_DIR || head === LOG_DIR;
+};
+
+// The plan and the logs of reslop are not the work of the user
+const changedFiles = async (dir) => {
+  const args = ['status', '--porcelain', '-z', '--untracked-files=all'];
+  const result = await runGit([...args, '--no-renames'], dir);
+  requireOk(result, 'git status failed');
+  const names = result.stdout.split('\0').filter(Boolean);
+  return names.map((line) => line.slice(3)).filter((rel) => !isOwnFile(rel));
+};
+
+const isDirty = async (dir) => (await changedFiles(dir)).length > 0;
+
+const branchExists = async (top, branch) => {
+  const args = ['show-ref', '--verify', '--quiet', `${HEADS}${branch}`];
+  return (await runGit(args, top)).status === 0;
+};
+
+const branchError = (branch) => {
+  const name = `${branch ?? ''}`.trim();
+  if (!name) return 'empty branch name';
+  if (name.startsWith('-')) return `bad branch name ${name}`;
+  return '';
+};
+
+// Git tells what happened after a line of progress: the last complaint
+const requireDone = (result, fallback) => {
+  if (result.status === 0) return result;
+  const text = `${result.stderr}\n${result.stdout}`;
+  const lines = text.split(/\r?\n/).map((line) => line.trim());
+  const filled = lines.filter(Boolean);
+  const named = filled.filter((line) => /^(fatal|error):/.test(line));
+  const line = named.at(-1) ?? filled.at(-1) ?? fallback;
+  throw new Error(oneLine(line.replace(/^(fatal|error):\s*/, ''), fallback));
+};
+
+// Git itself refuses a branch that is checked out in another worktree
+const addWorktree = async (top, target, branch) => {
+  const failed = branchError(branch);
+  if (failed) throw new Error(failed);
+  const name = branch.trim();
+  const dir = path.resolve(top, target);
+  const exists = await branchExists(top, name);
+  const args = exists
+    ? ['worktree', 'add', '--', dir, name]
+    : ['worktree', 'add', '-b', name, '--', dir];
+  requireDone(await runGit(args, top), 'git worktree add failed');
+  return dir;
+};
+
+// Never forced: uncommitted work or a lock keeps the worktree
+const removeWorktree = async (top, target) => {
+  const list = await listWorktrees(top);
+  const found = findWorktree(list, target);
+  if (!found) throw new Error('not a worktree of this repository');
+  if (found.main) throw new Error('the main worktree cannot be removed');
+  if (found.locked) {
+    const why = found.lockReason ? `: ${found.lockReason}` : '';
+    throw new Error(oneLine(`worktree is locked${why}`, 'worktree is locked'));
+  }
+  if (await isDirty(found.path)) {
+    throw new Error('worktree has uncommitted changes');
+  }
+  const args = ['worktree', 'remove', '--', found.path];
+  requireDone(await runGit(args, top), 'git worktree remove failed');
+};
+
+module.exports = {
+  parseWorktrees,
+  listWorktrees,
+  findWorktree,
+  dirKey,
+  sameDir,
+  changedFiles,
+  isDirty,
+  addWorktree,
+  removeWorktree,
+};

package/lib/git/local.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+
+const { resolveGitDirs } = require('./dir.js');
+
+const HEAD_REF = 'ref: refs/heads/';
+const SHA = /^[0-9a-f]{40}$/i;
+
+const readText = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const readFirstLine = (file) => readText(file).split('\n')[0] ?? '';
+
+const isWorktreeRoot = (dir) => {
+  const dirs = resolveGitDirs(dir);
+  if (!dirs) return false;
+  try {
+    const head = path.join(dirs.gitDir, 'HEAD');
+    const objects = path.join(dirs.commonDir, 'objects');
+    const refs = path.join(dirs.commonDir, 'refs');
+    return (
+      fs.statSync(head).isFile() &&
+      fs.statSync(objects).isDirectory() &&
+      fs.statSync(refs).isDirectory()
+    );
+  } catch {
+    return false;
+  }
+};
+
+// The worktree that contains `start`, without asking git. A linked checkout
+// is the directory whose `.git` file points at the common repository.
+const worktreeRoot = (start) => {
+  let dir = path.resolve(start);
+  let stat;
+  try {
+    stat = fs.statSync(dir);
+  } catch {
+    return '';
+  }
+  if (!stat.isDirectory()) dir = path.dirname(dir);
+  for (;;) {
+    if (isWorktreeRoot(dir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return '';
+    dir = parent;
+  }
+};
+
+const headLine = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  return readFirstLine(path.join(dirs.gitDir, 'HEAD')).trim();
+};
+
+// Empty when HEAD is detached or the checkout has no branch yet
+const branchOf = (top) => {
+  const line = headLine(top);
+  if (!line.startsWith(HEAD_REF)) return '';
+  return line.slice(HEAD_REF.length);
+};
+
+const packedSha = (commonDir, ref) => {
+  const text = readText(path.join(commonDir, 'packed-refs'));
+  for (const line of text.split('\n')) {
+    if (!line || line.startsWith('#') || line.startsWith('^')) continue;
+    const space = line.indexOf(' ');
+    if (space < 0) continue;
+    if (line.slice(space + 1).trim() === ref) return line.slice(0, space);
+  }
+  return '';
+};
+
+const refSha = (commonDir, ref) => {
+  const direct = readFirstLine(path.join(commonDir, ref)).trim();
+  if (SHA.test(direct)) return direct;
+  return packedSha(commonDir, ref);
+};
+
+const headSha = (dirs) => {
+  const line = readFirstLine(path.join(dirs.gitDir, 'HEAD')).trim();
+  if (SHA.test(line)) return line;
+  if (!line.startsWith('ref: ')) return '';
+  return refSha(dirs.commonDir, line.slice('ref: '.length).trim());
+};
+
+const looseCommit = (commonDir, sha) => {
+  if (!SHA.test(sha)) return null;
+  const file = path.join(commonDir, 'objects', sha.slice(0, 2), sha.slice(2));
+  let raw;
+  try {
+    raw = zlib.inflateSync(fs.readFileSync(file));
+  } catch {
+    return null;
+  }
+  const text = raw.toString('utf8');
+  const nul = text.indexOf('\0');
+  if (nul < 0 || !text.slice(0, nul).startsWith('commit ')) return null;
+  return text.slice(nul + 1);
+};
+
+const parentsOf = (body) => {
+  const parents = [];
+  for (const line of body.split('\n')) {
+    if (line.startsWith('parent ')) parents.push(line.slice('parent '.length));
+    else if (line === '') break;
+  }
+  return parents;
+};
+
+// Null when an object lives in a pack: the caller asks git then
+const countLoose = (commonDir, sha) => {
+  const seen = new Set();
+  const queue = [sha];
+  while (queue.length) {
+    const id = queue.pop();
+    if (!id || seen.has(id)) continue;
+    const body = looseCommit(commonDir, id);
+    if (body === null) return null;
+    seen.add(id);
+    for (const parent of parentsOf(body)) queue.push(parent);
+  }
+  return seen.size;
+};
+
+// '' when the history is not a set of loose objects
+const commitCount = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  const sha = headSha(dirs);
+  if (!sha) return '0';
+  const count = countLoose(dirs.commonDir, sha);
+  if (count === null) return '';
+  return `${count}`;
+};
+
+const originUrl = (text) => {
+  let section = '';
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      section = trimmed.slice(1, -1).trim();
+      continue;
+    }
+    if (section !== 'remote "origin"') continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    if (trimmed.slice(0, eq).trim() !== 'url') continue;
+    return trimmed.slice(eq + 1).trim();
+  }
+  return '';
+};
+
+const remoteOrigin = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  return originUrl(readText(path.join(dirs.commonDir, 'config')));
+};
+
+const gitDirPath = (top) => {
+  const dirs = resolveGitDirs(top);
+  return dirs ? dirs.gitDir : '';
+};
+
+module.exports = {
+  worktreeRoot,
+  branchOf,
+  commitCount,
+  remoteOrigin,
+  gitDirPath,
+};

package/lib/git/status.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const STAGED_TITLE = 'Changes to be committed:\n';
+const WORK_TITLE = 'Changes not staged for commit:\n';
+const UNTRACKED_TITLE = 'Untracked files:\n';
+const PREFIX = {
+  staged: { left: 'c/', right: 'i/' },
+  work: { left: 'i/', right: 'w/' },
+};
+
+const DIFF_HEADS = [
+  'diff --git ',
+  'index ',
+  '@@ ',
+  'new file ',
+  'deleted file ',
+  'old mode ',
+  'new mode ',
+  'similarity ',
+  'rename ',
+  'Binary files ',
+];
+
+const isDiffHead = (line) => DIFF_HEADS.some((head) => line.startsWith(head));
+
+const isDiffLine = (line) => {
+  if (/^-{10,}$/.test(line)) return false;
+  if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+    return true;
+  }
+  if (line.startsWith('\\')) return true;
+  return isDiffHead(line);
+};
+
+const sectionDiff = (text, title) => {
+  const at = text.lastIndexOf(title);
+  if (at < 0) return '';
+  const rest = text.slice(at + title.length);
+  if (!rest.startsWith('diff --git ')) return '';
+  const lines = [];
+  for (const line of rest.split('\n')) {
+    if (lines.length && !isDiffLine(line)) break;
+    lines.push(line);
+  }
+  return lines.join('\n').replace(/\s+$/, '');
+};
+
+const untrackedOf = (text) => {
+  const at = text.indexOf(UNTRACKED_TITLE);
+  if (at < 0) return [];
+  const rest = text.slice(at + UNTRACKED_TITLE.length);
+  const stop = rest.indexOf('\ndiff --git ');
+  const block = stop < 0 ? rest : rest.slice(0, stop);
+  const names = [];
+  for (const line of block.split('\n')) {
+    if (line.startsWith('\t')) names.push(line.slice(1));
+  }
+  return names;
+};
+
+const rewritePath = (value, from, to) => {
+  if (value === '/dev/null') return value;
+  if (!value.startsWith(from)) return '';
+  return `${to}${value.slice(from.length)}`;
+};
+
+const rewriteGit = (line, left, right) => {
+  const rest = line.slice('diff --git '.length);
+  const mid = ` ${right}`;
+  const at = rest.indexOf(mid);
+  if (!rest.startsWith(left) || at < 0) return '';
+  const oldPath = rest.slice(left.length, at);
+  const newPath = rest.slice(at + mid.length);
+  return `diff --git a/${oldPath} b/${newPath}`;
+};
+
+const rewriteBinary = (line, left, right) => {
+  const match = /^Binary files (.+) and (.+) differ$/.exec(line);
+  if (!match) return line;
+  const oldPath = rewritePath(match[1], left, 'a/');
+  const newPath = rewritePath(match[2], right, 'b/');
+  if (!oldPath || !newPath) return '';
+  return `Binary files ${oldPath} and ${newPath} differ`;
+};
+
+const rewriteMarker = (line, mark, from, to) => {
+  if (!line.startsWith(mark)) return line;
+  const value = line.slice(mark.length);
+  if (value === '/dev/null') return line;
+  const next = rewritePath(value, from, to);
+  if (!next) return '';
+  return `${mark}${next}`;
+};
+
+const rewritten = (line, left, right) => {
+  if (line.startsWith('diff --git ')) return rewriteGit(line, left, right);
+  if (line.startsWith('Binary files ')) return rewriteBinary(line, left, right);
+  if (line.startsWith('--- ')) return rewriteMarker(line, '--- ', left, 'a/');
+  if (line.startsWith('+++ ')) return rewriteMarker(line, '+++ ', right, 'b/');
+  return line;
+};
+
+// git status -vv labels the sides c/ (HEAD), i/ (index) and w/ (worktree).
+// The diff parser wants the a/ and b/ labels of git diff.
+const rewriteDiff = (text, side) => {
+  if (!text) return '';
+  const { left, right } = PREFIX[side];
+  const lines = [];
+  for (const line of text.split('\n')) {
+    const next = rewritten(line, left, right);
+    if (!next) return null;
+    lines.push(next);
+  }
+  return `${lines.join('\n')}\n`;
+};
+
+// Null when this git prints diffs in a shape we do not rewrite
+const parseStatus = (text) => {
+  const raw = `${text ?? ''}`.replaceAll('\r\n', '\n');
+  const staged = rewriteDiff(sectionDiff(raw, STAGED_TITLE), 'staged');
+  const work = rewriteDiff(sectionDiff(raw, WORK_TITLE), 'work');
+  if (staged === null || work === null) return null;
+  return { staged, work, untracked: untrackedOf(raw) };
+};
+
+module.exports = { parseStatus };

package/lib/git/worktree.js

@@ -3,13 +3,16 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { runProc, isAbort } = require('../common/process.js');
+const { runProc, isAbort, abortError } = require('../common/process.js');
 const { oneLine } = require('../common/utilities.js');
 const diff = require('../diff/diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
 const files = require('../common/files.js');
 const { groupByPath } = files;
 const { itemPath, isReadOnlyOrigin, lineDelta, REVIEW_DIR } = files;
+const local = require('./local.js');
+const { worktreeRoot, branchOf, remoteOrigin } = local;
+const { parseStatus } = require('./status.js');
 const { replaceBlockAdds } = require('../diff/patch.js');
 
 const GIT_CONFIG = [
@@ -20,10 +23,30 @@ const GIT_CONFIG = [
 ];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
 const BINARY_SIZE = 1000000;
+const STATUS_ARGS = [
+  '-c',
+  'core.quotepath=false',
+  '-c',
+  'color.ui=false',
+  '-c',
+  'diff.renames=false',
+  'status',
+  '-vv',
+  '--no-renames',
+  '--no-ahead-behind',
+  '-uall',
+];
+const STATUS_ENV = { LC_MESSAGES: 'C', LANGUAGE: 'C' };
 
 const gitOptions = (cwd, extra) => ({
   cwd,
-  env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...extra.env },
+  env: {
+    ...process.env,
+    GIT_OPTIONAL_LOCKS: '0',
+    GIT_TERMINAL_PROMPT: '0',
+    GCM_INTERACTIVE: 'Never',
+    ...extra.env,
+  },
   input: extra.input,
   signal: extra.signal,
 });
@@ -183,17 +206,12 @@ const untrackedItems = async (top, names) => {
   return itemsFromFiles(files, 'untracked');
 };
 
-const countUntrackedAdded = async (top) => {
-  try {
-    const result = await runGit(untrackedArgs([]), top);
-    if (result.status !== 0) return 0;
-    const items = untrackedItemsFrom(top, namesFromLs(result.stdout));
-    let added = 0;
-    for (const item of items) added += lineDelta(item).added;
-    return added;
-  } catch {
-    return 0;
+const addedOf = (names, top) => {
+  let added = 0;
+  for (const item of untrackedItemsFrom(top, names)) {
+    added += lineDelta(item).added;
   }
+  return added;
 };
 
 const gitText = async (top, spec) => {
@@ -240,13 +258,23 @@ const readDepSides = async (top, rev, origin, rel) => {
   return { oldText, newText };
 };
 
-const toplevel = async (cwd, signal) => {
+const toplevelGit = async (cwd, signal) => {
   const args = ['rev-parse', '--show-toplevel'];
   const result = await runGit(args, cwd, { signal });
   if (result.status !== 0) throw new Error('not a git repository');
   return result.stdout.trim();
 };
 
+const toplevel = async (cwd, signal) => {
+  if (signal && signal.aborted) throw abortError();
+  if (process.env.GIT_DIR || process.env.GIT_WORK_TREE) {
+    return toplevelGit(cwd, signal);
+  }
+  const found = worktreeRoot(cwd);
+  if (found) return found;
+  return toplevelGit(cwd, signal);
+};
+
 const resolveRev = async (cwd, spec) => {
   if (!spec) return null;
   const args = ['rev-parse', '--verify', `${spec}^{commit}`];
@@ -259,20 +287,19 @@ const shortRev = async (top, commit) => {
   return result.status === 0 ? result.stdout.trim() : commit.slice(0, 7);
 };
 
-const branchName = (result) => {
+const currentBranch = async (top) => {
+  const root = worktreeRoot(top);
+  if (root) return branchOf(root);
+  const args = ['rev-parse', '--abbrev-ref', 'HEAD'];
+  const result = await runGit(args, top);
   if (result.status !== 0) return '';
   const name = result.stdout.trim();
   return name === 'HEAD' ? '' : name;
 };
 
-const BRANCH_ARGS = ['rev-parse', '--abbrev-ref', 'HEAD'];
-const REMOTE_ARGS = ['config', '--get', 'remote.origin.url'];
-
-const currentBranch = async (top) => branchName(await runGit(BRANCH_ARGS, top));
-
-const repositoryUrl = (result) => {
-  if (result.status !== 0) return '';
-  let value = result.stdout.trim();
+const repositoryUrl = (raw) => {
+  let value = `${raw ?? ''}`.trim();
+  if (!value) return '';
   const scp = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/.exec(value);
   if (scp && !value.includes('://')) value = `https://${scp[1]}/${scp[2]}`;
   else if (value.startsWith('git+')) value = value.slice(4);
@@ -303,12 +330,9 @@ const worktreeSnapshot = (top, outputs, untracked, branch, repoUrl) => {
 
 const snapshotCommit = async (top, commit, files) => {
   const parsed = dropReviewItems(itemsFromFiles(files, 'commit'));
-  const names = [
-    shortRev(top, commit),
-    currentBranch(top),
-    runGit(REMOTE_ARGS, top).then(repositoryUrl),
-  ];
-  const [revShort, branch, repoUrl] = await Promise.all(names);
+  const revShort = await shortRev(top, commit);
+  const branch = await currentBranch(top);
+  const repoUrl = repositoryUrl(remoteOrigin(top));
   return { top, parsed, rev: commit, revShort, branch, repositoryUrl: repoUrl };
 };
 
@@ -324,6 +348,38 @@ const worktreeCommands = (paths) => [
   untrackedArgs(paths),
 ];
 
+const gitView = async (top, paths, signal) => {
+  const commands = worktreeCommands(paths);
+  const running = commands.map((args) => runGit(args, top, { signal }));
+  const results = await Promise.all(running);
+  const outputs = results.map((result) => requireOk(result).stdout);
+  return {
+    staged: outputs[0],
+    work: outputs[1],
+    untracked: namesFromLs(outputs[2]),
+  };
+};
+
+const worktreeView = async (top, paths, signal) => {
+  // status -vv prints every diff and ignores the pathspec
+  if (paths.length) return gitView(top, paths, signal);
+  const extra = { signal, env: STATUS_ENV };
+  const result = await runGit(STATUS_ARGS, top, extra);
+  if (result.status !== 0) return gitView(top, paths, signal);
+  const parsed = parseStatus(result.stdout);
+  if (!parsed) return gitView(top, paths, signal);
+  return parsed;
+};
+
+const countUntrackedAdded = async (top) => {
+  try {
+    const view = await worktreeView(top, []);
+    return addedOf(view.untracked, top);
+  } catch {
+    return 0;
+  }
+};
+
 const readSnapshot = async (cwd, paths, options) => {
   const { commit: rev, signal } = options;
   const top = await toplevel(cwd, signal);
@@ -331,14 +387,11 @@ const readSnapshot = async (cwd, paths, options) => {
     const files = await runSteps(commitDiff(rev, paths), top, signal);
     return snapshotCommit(top, rev, files);
   }
-  const commands = [...worktreeCommands(paths), BRANCH_ARGS, REMOTE_ARGS];
-  const running = commands.map((args) => runGit(args, top, { signal }));
-  const results = await Promise.all(running);
-  const repoUrl = repositoryUrl(results.pop());
-  const branch = branchName(results.pop());
-  const outputs = results.map((result) => requireOk(result).stdout);
-  const names = namesFromLs(outputs[2]);
-  const untracked = await untrackedItems(top, names);
+  const view = await worktreeView(top, paths, signal);
+  const untracked = await untrackedItems(top, view.untracked);
+  const branch = await currentBranch(top);
+  const repoUrl = repositoryUrl(remoteOrigin(top));
+  const outputs = [view.staged, view.work];
   return worktreeSnapshot(top, outputs, untracked, branch, repoUrl);
 };
 
@@ -475,6 +528,29 @@ const stagePath = async (top, rel) => {
   if (rel) await gitOk(['add', '--', rel], top);
 };
 
+const sumDelta = (items) => {
+  let added = 0;
+  let removed = 0;
+  for (const item of items) {
+    const delta = lineDelta(item);
+    added += delta.added;
+    removed += delta.removed;
+  }
+  return { added, removed };
+};
+
+const diffCounts = async (top) => {
+  const view = await worktreeView(top, []);
+  const staged = sumDelta(itemsFromFiles(parseDiff(view.staged), 'staged'));
+  const open = sumDelta(itemsFromFiles(parseDiff(view.work), 'unstaged'));
+  return {
+    stagedAdded: staged.added,
+    unstagedAdded: open.added + addedOf(view.untracked, top),
+    stagedRemoved: staged.removed,
+    unstagedRemoved: open.removed,
+  };
+};
+
 module.exports = {
   requireOk,
   gitOk,
@@ -492,6 +568,7 @@ module.exports = {
   currentBranch,
   fileText,
   countUntrackedAdded,
+  diffCounts,
   listScopeFiles,
   readSnapshot,
   editItem,