reslop 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased][unreleased]
 
+## [0.1.3][] - 2026-09-12
+
+- Showed added/removed and staged/total counts in the file list
+- Highlighted JSX and TSX syntax, including
+- Added vim-style j/k navigation and Ctrl scrolling
+- Improved TUI/UX with background git and npm checks to avoid a freeze
+
 ## [0.1.2][] - 2026-09-11
 
 - Review each dependency once across package.json and package-lock
@@ -26,7 +33,8 @@
 - Feedback and todos that produce a repair plan for an agent
 - Intra-line highlighting in unified, mixed, and side-by-side layouts
 
-[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.1.2...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.1.3...HEAD
+[0.1.3]: https://github.com/tshemsedinov/reslop/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/tshemsedinov/reslop/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/tshemsedinov/reslop/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/tshemsedinov/reslop/releases/tag/v0.1.0

package/README.md

@@ -48,23 +48,24 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 ## Keys and buttons
 
-| Key         | Action                                  |
-| ----------- | --------------------------------------- |
-| `a`         | Stage this block (`git add`)            |
-| `u`         | Unstage this block (keep worktree)      |
-| `r`         | Restore this block to the last commit   |
-| `s`         | Skip (leave unstaged, drop from review) |
-| `←`         | Previous remaining block                |
-| `→`         | Next remaining block                    |
-| `l`         | File list (git status of this scope)    |
-| `Esc`       | Quit file list or a tool                |
-| `m`         | Cycle unified / mixed / side-by-side    |
-| `f`         | Feedback on this diff block             |
-| `t`         | New todo for this file                  |
-| `⌫` / `Del` | Remove the selected todo                |
-| `⏎`         | Open the selected file                  |
-| `q`         | Quit                                    |
-| `?`         | Help                                    |
+| Key                 | Action                                   |
+| ------------------- | ---------------------------------------- |
+| `a`                 | Stage this block (`git add`)             |
+| `u`                 | Unstage this block (keep worktree)       |
+| `r`                 | Restore this block to the last commit    |
+| `f`                 | Feedback on this diff block              |
+| `t`                 | New todo for this file                   |
+| `l`                 | File list (git status of this scope)     |
+| `m`                 | Cycle unified / mixed / side-by-side     |
+| `⏎`                 | Open the selected file                   |
+| `Esc`               | Quit file list or a tool                 |
+| `→` / `j`           | Next remaining block / next file         |
+| `←` / `k`           | Previous remaining block / previous file |
+| `Ctrl-e` / `Ctrl-y` | Scroll one line down / up                |
+| `Ctrl-f` / `Ctrl-b` | Scroll page down / up                    |
+| `Ctrl-d` / `Ctrl-u` | Scroll half-page down / up               |
+| `⌫` / `Del`         | Remove the selected todo                 |
+| `q`                 | Quit                                     |
 
 ## License
 

package/lib/cli.js

@@ -99,9 +99,9 @@ const sessionOptions = (proc, deps, args, env, extra) => ({
   ...extra,
 });
 
-const startSession = (options) => {
+const startSession = (options, extra = {}) => {
   const session = new Session(options);
-  session.load();
+  if (extra.load) session.load();
   return session;
 };
 
@@ -110,13 +110,15 @@ const openLocalSession = (proc, deps, args, selected, env) => {
   const repo = deps.repo ?? createGitRepo();
   const statSync = deps.statSync ?? fs.statSync;
   const scope = resolveScope(cwd, selected.paths, repo, statSync);
-  return startSession(
+  const session = startSession(
     sessionOptions(proc, deps, args, env, {
       repo,
       paths: scope.paths,
       rev: scope.rev,
     }),
   );
+  session.ensureRepo();
+  return session;
 };
 
 const openPullRequestSession = async (proc, deps, args, selected, env) => {
@@ -140,6 +142,7 @@ const openPullRequestSession = async (proc, deps, args, selected, env) => {
       sourceLabel: loaded.sourceLabel,
       change,
     }),
+    { load: true },
   );
 };
 
@@ -152,6 +155,13 @@ const loadSession = async (proc, deps, args) => {
   return openLocalSession(proc, deps, args, selected, env);
 };
 
+const runUi = async (session, proc) => {
+  const code = await session.startUi();
+  if (session.loadError) return fail(proc.stderr, session.loadError);
+  if (session.emptyReview) proc.stdout.write('nothing to review\n');
+  return code;
+};
+
 const run = async (proc, deps = {}) => {
   const stdout = proc.stdout;
   const stderr = proc.stderr;
@@ -167,15 +177,19 @@ const run = async (proc, deps = {}) => {
   } catch (error) {
     return fail(stderr, error);
   }
+  const tty = proc.stdin.isTTY === true && stdout.isTTY === true;
+  if (tty) return runUi(session, proc);
+  try {
+    await session.loadReady();
+  } catch (error) {
+    return fail(stderr, error);
+  }
   if (!session.items.length) {
     stdout.write('nothing to review\n');
     return 0;
   }
-  if (!proc.stdin.isTTY || !stdout.isTTY) {
-    stderr.write('reslop: interactive terminal required\n');
-    return 1;
-  }
-  return session.startUi();
+  stderr.write('reslop: interactive terminal required\n');
+  return 1;
 };
 
 module.exports = {

package/lib/detect.js

@@ -11,6 +11,8 @@ const LANG = {
   cjs: 'js',
   ts: 'ts',
   typescript: 'ts',
+  jsx: 'jsx',
+  tsx: 'tsx',
   json: 'json',
   csv: 'csv',
   html: 'html',

package/lib/files.js

@@ -33,26 +33,50 @@ const fileStatus = (origins) => {
   return key;
 };
 
+const lineDelta = ({ hunk, blockId }) => {
+  const delta = { added: 0, removed: 0 };
+  if (!hunk) return delta;
+  const { lines } = hunk;
+  if (!lines) return delta;
+  const scoped = typeof blockId === 'number';
+  for (const { type, blockId: lineBlock } of lines) {
+    if (scoped && lineBlock !== blockId) continue;
+    if (type === 'add') delta.added += 1;
+    else if (type === 'del') delta.removed += 1;
+  }
+  return delta;
+};
+
 const fileEntries = (items) => {
   const groups = new Map();
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
     const rel = itemPath(item);
-    let group = groups.get(rel);
-    if (!group) {
-      group = { path: rel, origins: [], firstIndex: i, remaining: 0 };
-      groups.set(rel, group);
+    if (!groups.has(rel)) {
+      groups.set(rel, {
+        path: rel,
+        origins: [],
+        firstIndex: i,
+        remaining: 0,
+        added: 0,
+        removed: 0,
+        staged: 0,
+        unstaged: 0,
+      });
     }
-    group.origins.push(item.origin);
+    const group = groups.get(rel);
+    const { origin } = item;
+    group.origins.push(origin);
     group.remaining += 1;
+    const delta = lineDelta(item);
+    group.added += delta.added;
+    group.removed += delta.removed;
+    if (origin === 'staged') group.staged += 1;
+    if (origin === 'unstaged') group.unstaged += 1;
   }
-  const entries = [];
-  for (const group of groups.values()) {
-    const path = group.path;
-    const status = fileStatus(group.origins);
-    const firstIndex = group.firstIndex;
-    const remaining = group.remaining;
-    entries.push({ path, status, firstIndex, remaining });
+  const entries = [...groups.values()];
+  for (const group of entries) {
+    group.status = fileStatus(group.origins);
   }
   return entries;
 };

package/lib/git.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { spawnSync } = require('node:child_process');
+const { spawn, spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -46,17 +46,114 @@ const dropReviewItems = (items) => {
   return kept;
 };
 
+const abortError = () => {
+  const error = new Error('aborted');
+  error.code = 'ABORT';
+  return error;
+};
+
+const isAbort = (error) => !!(error && error.code === 'ABORT');
+
+const runProc = (cmd, args, options = {}) =>
+  new Promise((resolve) => {
+    const cwd = options.cwd;
+    const env = options.env;
+    const encoding = options.encoding ?? GIT_ENCODING;
+    const maxBuffer = options.maxBuffer ?? GIT_MAX_BUFFER;
+    const timeout = options.timeout;
+    const input = options.input;
+    const signal = options.signal;
+    if (signal && signal.aborted) {
+      resolve({ status: null, error: abortError(), stdout: '', stderr: '' });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let timer = null;
+    const child = spawn(cmd, args, { cwd, env });
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+    const onAbort = () => {
+      child.kill();
+      finish({ status: null, error: abortError(), stdout, stderr });
+    };
+    const append = (kind, chunk) => {
+      if (kind === 'out') stdout += chunk;
+      else stderr += chunk;
+      if (stdout.length + stderr.length <= maxBuffer) return;
+      child.kill();
+      const error = new Error('maxBuffer exceeded');
+      error.code = 'ENOBUFS';
+      finish({ status: null, error, stdout, stderr });
+    };
+    if (signal) signal.addEventListener('abort', onAbort);
+    if (child.stdout) {
+      child.stdout.setEncoding(encoding);
+      child.stdout.on('data', (chunk) => append('out', chunk));
+    }
+    if (child.stderr) {
+      child.stderr.setEncoding(encoding);
+      child.stderr.on('data', (chunk) => append('err', chunk));
+    }
+    if (timeout) {
+      timer = setTimeout(() => {
+        child.kill();
+        const error = new Error('timed out');
+        error.code = 'ETIMEDOUT';
+        finish({ status: null, error, stdout, stderr });
+      }, timeout);
+    }
+    child.on('error', (error) => {
+      finish({ status: null, error, stdout, stderr });
+    });
+    child.on('close', (status) => {
+      finish({ status, stdout, stderr });
+    });
+    if (child.stdin) {
+      try {
+        if (input) child.stdin.end(input);
+        else child.stdin.end();
+      } catch {
+        // closed
+      }
+    }
+  });
+
+const gitResult = (result) => {
+  if (!result.error) return result;
+  if (isAbort(result.error)) throw result.error;
+  if (result.error.code === 'ENOENT') throw new Error('git not found');
+  throw result.error;
+};
+
 const runGit = (args, cwd, input) => {
   const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
   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');
-    throw result.error;
-  }
-  return result;
+  return gitResult(result);
+};
+
+const runGitAsync = (args, cwd, extra = {}) => {
+  const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+  const encoding = GIT_ENCODING;
+  const maxBuffer = GIT_MAX_BUFFER;
+  const input = extra.input;
+  const signal = extra.signal;
+  return runProc('git', args, {
+    cwd,
+    env,
+    encoding,
+    maxBuffer,
+    input,
+    signal,
+  }).then(gitResult);
 };
 
 const toplevel = (cwd) => {
@@ -76,12 +173,16 @@ const isBinaryBuffer = (buf) => {
   return buf.includes(0);
 };
 
+const namesFromLs = (stdout) => {
+  if (!stdout) return [];
+  return stdout.split('\0').filter(Boolean);
+};
+
 const listUntracked = (top, paths) => {
   const args = ['ls-files', '-o', '--exclude-standard', '-z'];
   if (paths.length) args.push('--', ...paths);
   const result = requireOk(runGit(args, top));
-  if (!result.stdout) return [];
-  return result.stdout.split('\0').filter(Boolean);
+  return namesFromLs(result.stdout);
 };
 
 const binaryNewFile = (rel) => ({
@@ -94,9 +195,9 @@ const binaryNewFile = (rel) => ({
   hunks: [],
 });
 
-const untrackedItems = (top, paths) => {
+const untrackedItemsFrom = (top, names) => {
   const files = [];
-  for (const rel of listUntracked(top, paths)) {
+  for (const rel of names) {
     if (isReviewFile(rel)) continue;
     const full = path.join(top, rel);
     let buf;
@@ -184,6 +285,18 @@ const runNpmJson = (top, args, timeout) => {
   return result.stdout || '';
 };
 
+const runNpmJsonAsync = async (top, args, timeout, signal) => {
+  const result = await runProc('npm', args, {
+    cwd: top,
+    encoding: GIT_ENCODING,
+    maxBuffer: GIT_MAX_BUFFER,
+    timeout,
+    signal,
+  });
+  if (result.error) return '';
+  return result.stdout || '';
+};
+
 const collectAudit = (top) => {
   const lock = path.join(top, LOCKFILE);
   if (!fs.existsSync(lock)) return null;
@@ -200,30 +313,55 @@ const collectOutdated = (top) => {
   return parseOutdatedReport(text);
 };
 
+const collectAuditAsync = async (top, extra, signal) => {
+  if (extra.auditMap !== undefined) return extra.auditMap;
+  const lock = path.join(top, LOCKFILE);
+  if (!fs.existsSync(lock)) return null;
+  const args = ['audit', '--json', '--package-lock-only'];
+  const text = await runNpmJsonAsync(top, args, AUDIT_MS, signal);
+  return parseAuditReport(text);
+};
+
+const collectOutdatedAsync = async (top, extra, signal) => {
+  if (extra.outdatedMap !== undefined) return extra.outdatedMap;
+  const manifest = path.join(top, MANIFEST);
+  if (!fs.existsSync(manifest)) return null;
+  const args = ['outdated', '--json', '--long'];
+  const text = await runNpmJsonAsync(top, args, AUDIT_MS, signal);
+  return parseOutdatedReport(text);
+};
+
 const pickNpmMap = (override, collect, top) => {
   if (override !== undefined) return override;
   return collect(top);
 };
 
+const hasDepFile = (items) => {
+  for (const item of items) {
+    if (depFileMeta(itemPath(item))) return true;
+  }
+  return false;
+};
+
 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) {
+  const hasDepDiff = hasDepFile(items);
+  const collect = extra.collect !== false;
+  let usedNames = extra.usedNames ?? null;
+  let audit = extra.auditMap;
+  let outdated = extra.outdatedMap;
+  if (collect && usedNames === null && (hasDepDiff || live)) {
+    usedNames = collectUsedNames(top);
+  }
+  if (collect && live) {
     audit = pickNpmMap(extra.auditMap, collectAudit, top);
     outdated = pickNpmMap(extra.outdatedMap, collectOutdated, top);
-  } else if (extra.audit && hasDepDiff) {
+  } else if (collect && extra.audit && hasDepDiff) {
     audit = pickNpmMap(extra.auditMap, collectAudit, top);
   }
+  if (audit === undefined) audit = null;
+  if (outdated === undefined) outdated = null;
   const folded = foldDepItems(items, readSides, usedNames, audit, outdated, {
     root: top,
   });
@@ -408,40 +546,73 @@ const shortRev = (top, commit) => {
   return result.stdout.trim();
 };
 
-const loadCommit = (top, commit, extra) => {
-  const parent = runGit(['rev-parse', '--verify', `${commit}^`], top);
-  let args;
+const commitDiffArgs = (commit, parent, pathArgs) => {
   if (parent.status === 0) {
     const from = parent.stdout.trim();
-    args = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, from, commit, ...extra];
-  } else {
-    args = [
-      ...GIT_CONFIG,
-      'diff-tree',
-      '--no-commit-id',
-      '--root',
-      '-p',
-      ...DIFF_OPTS,
-      commit,
-      ...extra,
-    ];
+    return [...GIT_CONFIG, 'diff', ...DIFF_OPTS, from, commit, ...pathArgs];
   }
+  return [
+    ...GIT_CONFIG,
+    'diff-tree',
+    '--no-commit-id',
+    '--root',
+    '-p',
+    ...DIFF_OPTS,
+    commit,
+    ...pathArgs,
+  ];
+};
+
+const pathArgsOf = (paths) => (paths.length ? ['--', ...paths] : []);
+
+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);
+  return { top, parsed };
+};
+
+const snapshotCommit = (top, commit, files) => {
+  const commitItems = itemsFromFiles(files, 'commit');
+  const parsed = dropReviewItems(commitItems);
+  const revShort = shortRev(top, commit);
+  return { top, parsed, rev: commit, revShort };
+};
+
+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);
 };
 
-const load = (cwd, paths = [], options = {}) => {
+const needsExtras = (parsed, rev, extra) => {
+  const live = extra.audit === true && !rev;
+  if (live) return true;
+  if (!extra.audit) return false;
+  return hasDepFile(parsed);
+};
+
+const finishLoad = (snapshot, extra) => {
+  const options = { ...extra, paths: extra.paths ?? [] };
+  if (extra.deferExtras) options.collect = false;
+  const parsed = snapshot.parsed;
+  const top = snapshot.top;
+  const rev = snapshot.rev;
+  const items = foldLoaded(parsed, top, rev, options);
+  const pending = extra.deferExtras && needsExtras(parsed, rev, extra);
+  return { ...snapshot, items, pending };
+};
+
+const readSnapshotSync = (cwd, paths, options) => {
   const top = toplevel(cwd);
-  const extra = paths.length ? ['--', ...paths] : [];
+  const extra = pathArgsOf(paths);
   const rev = options.commit;
-  if (rev) {
-    const files = loadCommit(top, rev, extra);
-    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 };
-  }
+  if (rev) return snapshotCommit(top, rev, loadCommit(top, rev, extra));
   const stagedArgs = [
     ...GIT_CONFIG,
     'diff',
@@ -452,15 +623,95 @@ 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 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 combined = mergeItems([staged, unstaged, untracked]);
-  const merged = dropReviewItems(combined);
-  const items = foldLoaded(merged, top, undefined, { ...options, paths });
-  return { top, items };
+  const names = listUntracked(top, paths);
+  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+};
+
+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 readSnapshotAsync = async (cwd, paths, options) => {
+  const top = toplevel(cwd);
+  const extra = pathArgsOf(paths);
+  const rev = options.commit;
+  const signal = options.signal;
+  if (rev) {
+    const files = await loadCommitAsync(top, rev, extra, signal);
+    return snapshotCommit(top, rev, files);
+  }
+  const stagedArgs = [
+    ...GIT_CONFIG,
+    'diff',
+    '--cached',
+    ...DIFF_OPTS,
+    ...extra,
+  ];
+  const unstagedArgs = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, ...extra];
+  const lsArgs = ['ls-files', '-o', '--exclude-standard', '-z'];
+  if (paths.length) lsArgs.push('--', ...paths);
+  const stagedP = runGitAsync(stagedArgs, top, { signal });
+  const unstagedP = runGitAsync(unstagedArgs, top, { signal });
+  const lsP = runGitAsync(lsArgs, top, { signal });
+  const stagedRes = requireOk(await stagedP);
+  const unstagedRes = requireOk(await unstagedP);
+  const names = namesFromLs(requireOk(await lsP).stdout);
+  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+};
+
+const load = (cwd, paths = [], options = {}) => {
+  const snapshot = readSnapshotSync(cwd, paths, options);
+  return finishLoad(snapshot, { ...options, paths });
+};
+
+const loadAsync = async (cwd, paths = [], options = {}) => {
+  const snapshot = await readSnapshotAsync(cwd, paths, options);
+  return finishLoad(snapshot, { ...options, paths, deferExtras: true });
+};
+
+const usedNamesPromise = (parsed, rev, extra, top) => {
+  const live = extra.audit === true && !rev;
+  if (!live && !hasDepFile(parsed)) return Promise.resolve(null);
+  return Promise.resolve().then(() => collectUsedNames(top));
+};
+
+const loadExtras = async (snapshot, extra = {}) => {
+  const top = snapshot.top;
+  const rev = snapshot.rev;
+  const parsed = snapshot.parsed;
+  const signal = extra.signal;
+  const live = extra.audit === true && !rev;
+  const hasDepDiff = hasDepFile(parsed);
+  const usedP = usedNamesPromise(parsed, rev, extra, top);
+  let auditP = Promise.resolve(null);
+  let outdatedP = Promise.resolve(null);
+  if (live) {
+    auditP = collectAuditAsync(top, extra, signal);
+    outdatedP = collectOutdatedAsync(top, extra, signal);
+  } else if (extra.audit && hasDepDiff) {
+    auditP = collectAuditAsync(top, extra, signal);
+  }
+  const extras = await Promise.all([usedP, auditP, outdatedP]);
+  const usedNames = extras[0];
+  const audit = extras[1];
+  const outdated = extras[2];
+  if (signal && signal.aborted) throw abortError();
+  const folded = foldLoaded(parsed, top, rev, {
+    ...extra,
+    paths: extra.paths ?? [],
+    usedNames,
+    auditMap: audit,
+    outdatedMap: outdated,
+    collect: false,
+  });
+  return { ...snapshot, items: folded, pending: false };
 };
 
 const addItem = (top, item) => {
@@ -594,6 +845,9 @@ const revertFile = (top, rel, items) => {
 
 const createGitRepo = () => ({
   load,
+  loadAsync,
+  loadExtras,
+  toplevel,
   resolveRev,
   add: addItem,
   unstage: unstageItem,
@@ -603,6 +857,8 @@ const createGitRepo = () => ({
 
 module.exports = {
   load,
+  loadAsync,
+  loadExtras,
   addItem,
   unstageItem,
   revertItem,