reslop 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased][unreleased]
 
+## [0.1.8][] - 2026-09-17
+
+- Simplify session controllers, input dispatch, and loading orchestration
+- Enforce structural limits and session dependency direction on library files
+- Show staged/unstaged +/- and staged/remaining totals in status line
+- Jump by word with Ctrl+Left/Right in all text editors
+- Support PgUp, PgDn, Home, and End in lists and multiline editors
+- Support mouse click in submenu and confirmation choices on the hint line
+- Fix TODO wrapped text; keep up/down navigation inside a multiline todos
+- Fix identifier diffs as whole words compare, not just letters
+- Keep reslop open when a local repo has no unstaged changes
+- Fix invisible cursor movement in scrolling diffs
+- Auto-reload worktree on disk changes, keeping the current UI state
+- Fix disk watch paths on Windows
+- Set git push upstream to `origin <branch>` when missing
+- Save in-place diff edits to the reviewed file
+
 ## [0.1.7][] - 2026-09-16
 
 - Make TODOs repo-wide, not per-file todos
@@ -66,7 +83,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.7...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.1.8...HEAD
+[0.1.8]: https://github.com/tshemsedinov/reslop/compare/v0.1.7...v0.1.8
 [0.1.7]: https://github.com/tshemsedinov/reslop/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/tshemsedinov/reslop/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/tshemsedinov/reslop/compare/v0.1.4...v0.1.5

package/README.md

@@ -19,6 +19,7 @@ Review → Plan → Repair → Verify
 - Leave feedback, issues/todos, and in-place code proposals as a repair plan.
 - Review uncommitted git diffs, a given commit, a GitHub PR, or a GitLab MR.
 - Stage, unstage, or revert each contiguous block of diff lines.
+- Auto-reload local diffs when files change, keeping the current screen.
 - Import GitHub PR and GitLab MR review comments into the local plan for AI.
 - Commit, amend, or fixup staged changes from the file list.
 - Branches: checkout, create, rebase, drop, pull and push.
@@ -59,7 +60,6 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 | `b`                 | List branches; `n` new; `r` rebase; `d` drop  |
 | `p` / `s`           | git pull/push                                 |
 | `f` / `t` / `e`     | Feedback / repo todo / edit added lines       |
-| `r`                 | Reload diffs from disk                        |
 | `m`                 | Mode: unified / mixed / side-by-side          |
 | `⏎`                 | Open the selected file                        |
 | `→` / `j`           | Next remaining diff / file                    |

package/bin/reslop.js

@@ -7,7 +7,9 @@ const { LEAVE_TERM } = require('../lib/session.js');
 const fail = (reason) => {
   try {
     process.stdout.write(LEAVE_TERM);
-  } catch {}
+  } catch {
+    // ignore
+  }
   process.stderr.write(failLine(reason));
   process.exit(1);
 };

package/lib/capabilities.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('node:fs');
+
+const READ_METHODS = [
+  'load',
+  'loadAsync',
+  'loadExtras',
+  'toplevel',
+  'resolveRev',
+];
+
+const CHANGE_METHODS = [
+  'add',
+  'addAsync',
+  'unstage',
+  'revert',
+  'revertFile',
+  'edit',
+];
+
+const BRANCH_METHODS = [
+  'commit',
+  'commitAsync',
+  'hasStaged',
+  'lastMessage',
+  'listBranches',
+  'currentBranch',
+  'checkout',
+  'checkoutAsync',
+  'createBranch',
+  'createBranchAsync',
+  'rebase',
+  'rebaseAsync',
+  'drop',
+  'dropAsync',
+  'pull',
+  'pullAsync',
+  'push',
+  'pushAsync',
+];
+
+const SOURCE_CAPS = {
+  local: { read: true, changes: true, branches: true, review: true },
+  commit: { read: true, changes: false, branches: false, review: true },
+  'github-pr': { read: true, changes: false, branches: false, review: true },
+  'gitlab-mr': { read: true, changes: false, branches: false, review: true },
+  'read-only': { read: true, changes: false, branches: false, review: true },
+};
+
+const withReadOnly = (caps, readOnly) => {
+  if (!readOnly) return { ...caps };
+  return { ...caps, changes: false, branches: false };
+};
+
+const capabilitiesFor = (kind, extra = {}) => {
+  const base = SOURCE_CAPS[kind] ?? SOURCE_CAPS.local;
+  return withReadOnly(base, extra.readOnly === true);
+};
+
+const copyMethods = (target, source, names) => {
+  for (const name of names) {
+    const method = source[name];
+    if (typeof method === 'function') target[name] = method;
+  }
+};
+
+const attachCapabilities = (impl, caps) => {
+  const source = { capabilities: { ...caps } };
+  if (caps.read) copyMethods(source, impl, READ_METHODS);
+  if (caps.changes) copyMethods(source, impl, CHANGE_METHODS);
+  if (caps.branches) copyMethods(source, impl, BRANCH_METHODS);
+  return source;
+};
+
+const sessionCapabilities = (options) => {
+  const readOnly = options.readOnly === true;
+  if (options.capabilities) return withReadOnly(options.capabilities, readOnly);
+  if (options.rev) return capabilitiesFor('commit', { readOnly });
+  const source = options.change && options.change.source;
+  if (source && SOURCE_CAPS[source]) {
+    return capabilitiesFor(source, { readOnly });
+  }
+  const repoCaps = options.repo && options.repo.capabilities;
+  if (repoCaps) return withReadOnly(repoCaps, readOnly);
+  return capabilitiesFor(readOnly ? 'read-only' : 'local');
+};
+
+const createReviewStorage = (io = {}) => ({
+  readdirSync: io.readdirSync ?? fs.readdirSync,
+  readFileSync: io.readFileSync ?? fs.readFileSync,
+  writeFileSync: io.writeFileSync ?? fs.writeFileSync,
+  mkdirSync: io.mkdirSync ?? fs.mkdirSync,
+});
+
+module.exports = {
+  READ_METHODS,
+  CHANGE_METHODS,
+  BRANCH_METHODS,
+  SOURCE_CAPS,
+  capabilitiesFor,
+  withReadOnly,
+  attachCapabilities,
+  sessionCapabilities,
+  createReviewStorage,
+};

package/lib/cli.js

@@ -8,6 +8,7 @@ const { githubToken, loadPullRequest } = require('./github.js');
 const { gitlabToken, loadMergeRequest } = require('./gitlab.js');
 const { selectChangeSource, createLoadedSource } = require('./source.js');
 const { Session } = require('./session.js');
+const { capabilitiesFor, attachCapabilities } = require('./capabilities.js');
 
 const HEX_REV = /^[0-9a-f]{4,40}$/i;
 const HEAD_REV = /^HEAD([~^].*)?$/i;
@@ -121,22 +122,20 @@ const sessionOptions = (proc, deps, args, env, extra) => ({
   ...extra,
 });
 
-const startSession = (options, extra = {}) => {
-  const session = new Session(options);
-  if (extra.load) session.load();
-  return session;
-};
-
 const openLocalSession = (proc, deps, args, selected, env) => {
   const cwd = deps.cwd ?? proc.cwd();
-  const repo = deps.repo ?? createGitRepo();
+  const rawRepo = deps.repo ?? createGitRepo();
   const statSync = deps.statSync ?? fs.statSync;
-  const scope = resolveScope(cwd, selected.paths, repo, statSync);
-  const session = startSession(
+  const scope = resolveScope(cwd, selected.paths, rawRepo, statSync);
+  const kind = scope.rev ? 'commit' : 'local';
+  const capabilities = capabilitiesFor(kind, { readOnly: args.readOnly });
+  const repo = attachCapabilities(rawRepo, capabilities);
+  const session = new Session(
     sessionOptions(proc, deps, args, env, {
       repo,
       paths: scope.paths,
       rev: scope.rev,
+      capabilities,
     }),
   );
   session.ensureRepo();
@@ -148,27 +147,32 @@ const remoteRepo = (deps, selected, env, cwd) => {
   const remote = REMOTE_CHANGE[selected.kind];
   const loader = deps[remote.load] ?? remote.fallback;
   const token = remote.token(env);
-  const loadRemote = async () => {
+  const loadRemote = async (_cwd, _paths, options = {}) => {
     const loaded = await loader(remote.target(selected), {
       cwd,
       paths: selected.paths,
       token,
       fetch: deps.fetch,
+      signal: options.signal,
     });
     const items = loaded.items ?? [];
     return { ...loaded, items: [...items] };
   };
-  const repo = createLoadedSource({ items: [] });
-  repo.loadAsync = loadRemote;
-  return repo;
+  return createLoadedSource({ items: [] }, selected.kind, {
+    loadAsync: loadRemote,
+  });
 };
 
 const openRemoteSession = (proc, deps, args, selected, env) => {
   const cwd = deps.cwd ?? proc.cwd();
-  return startSession(
+  const capabilities = capabilitiesFor(selected.kind, {
+    readOnly: args.readOnly,
+  });
+  return new Session(
     sessionOptions(proc, deps, args, env, {
       repo: remoteRepo(deps, selected, env, cwd),
       paths: selected.paths,
+      capabilities,
     }),
   );
 };

package/lib/deps/changes.js

@@ -0,0 +1,331 @@
+'use strict';
+
+const { itemPath } = require('../files.js');
+
+const manifest = require('./manifest.js');
+const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
+const { parseJson, readSections, emptySectionMaps } = manifest;
+const { lockRootSections, lockEntries, lockPackageCount } = manifest;
+
+const SECTION_ORDER = [...SECTION_KEYS, 'resolved', 'field'];
+const ACTION_ORDER = ['added', 'removed', 'changed', 'vulnerable'];
+const SECTION_NAMES = SECTION_KEYS.join('|');
+const SECTION_OPEN = new RegExp(`^\\s*"(${SECTION_NAMES})"\\s*:\\s*\\{\\s*$`);
+const SECTION_END = /^\s*\},?\s*$/;
+const DEP_ENTRY = /^\s*"([^"]+)"\s*:\s*"([^"]*)"\s*,?\s*$/;
+
+const diffMaps = (oldMap, newMap, section) => {
+  const keys = [...oldMap.keys(), ...newMap.keys()];
+  const names = [...new Set(keys)];
+  names.sort();
+  const changes = [];
+  for (const name of names) {
+    const from = oldMap.has(name) ? oldMap.get(name) : '';
+    const to = newMap.has(name) ? newMap.get(name) : '';
+    if (from === to) continue;
+    let action = 'changed';
+    if (!oldMap.has(name)) action = 'added';
+    else if (!newMap.has(name)) action = 'removed';
+    changes.push({ name, section, action, from, to });
+  }
+  return changes;
+};
+
+const diffSections = (oldMaps, newMaps) => {
+  const changes = [];
+  for (const key of SECTION_KEYS) {
+    const found = diffMaps(oldMaps[key], newMaps[key], key);
+    for (const change of found) changes.push(change);
+  }
+  return changes;
+};
+
+const fieldText = (value) => {
+  if (value === undefined) return '';
+  if (typeof value === 'string') return value;
+  return JSON.stringify(value);
+};
+
+const sameJson = (left, right) =>
+  JSON.stringify(left) === JSON.stringify(right);
+
+const diffOtherFields = (oldPkg, newPkg) => {
+  if (!oldPkg && !newPkg) return [];
+  const oldObj = oldPkg ?? {};
+  const newObj = newPkg ?? {};
+  const keys = [...Object.keys(oldObj), ...Object.keys(newObj)];
+  const names = [...new Set(keys)];
+  names.sort();
+  const changes = [];
+  for (const name of names) {
+    if (SECTION_KEYS.includes(name)) continue;
+    const prev = oldObj[name];
+    const next = newObj[name];
+    if (sameJson(prev, next)) continue;
+    let action = 'changed';
+    if (!Object.hasOwn(oldObj, name)) action = 'added';
+    else if (!Object.hasOwn(newObj, name)) action = 'removed';
+    const from = fieldText(prev);
+    const to = fieldText(next);
+    const section = 'field';
+    changes.push({ name, section, action, from, to });
+  }
+  return changes;
+};
+
+const onlyDepEdits = (items) => {
+  if (!items.length) return false;
+  for (const item of items) {
+    if (!item.hunk) return false;
+    const blockId = item.blockId;
+    const scoped = typeof blockId === 'number';
+    let section = '';
+    for (const line of item.hunk.lines) {
+      const open = SECTION_OPEN.exec(line.text);
+      let nextSection = section;
+      if (open) nextSection = open[1];
+      else if (section && SECTION_END.test(line.text)) nextSection = '';
+      const inBlock = !scoped || line.blockId === blockId;
+      if (inBlock && line.type !== 'ctx') {
+        const inDep = !!(open || section);
+        if (!inDep) return false;
+        const isEntry = DEP_ENTRY.test(line.text);
+        const isClose = SECTION_END.test(line.text);
+        if (!open && !isEntry && !isClose) return false;
+      }
+      section = nextSection;
+    }
+  }
+  return true;
+};
+
+const mapsFromHunks = (items) => {
+  const oldMaps = emptySectionMaps();
+  const newMaps = emptySectionMaps();
+  let section = '';
+  for (const item of items) {
+    if (!item.hunk) continue;
+    for (const line of item.hunk.lines) {
+      const open = SECTION_OPEN.exec(line.text);
+      if (open) {
+        section = open[1];
+        continue;
+      }
+      if (section && SECTION_END.test(line.text)) {
+        section = '';
+        continue;
+      }
+      if (!section) continue;
+      const entry = DEP_ENTRY.exec(line.text);
+      if (!entry) continue;
+      const name = entry[1];
+      const version = entry[2];
+      if (line.type === 'del' || line.type === 'ctx') {
+        oldMaps[section].set(name, version);
+      }
+      if (line.type === 'add' || line.type === 'ctx') {
+        newMaps[section].set(name, version);
+      }
+    }
+  }
+  return { oldMaps, newMaps };
+};
+
+const directNames = (oldMaps, newMaps) => {
+  const names = new Set();
+  for (const key of SECTION_KEYS) {
+    for (const name of oldMaps[key].keys()) names.add(name);
+    for (const name of newMaps[key].keys()) names.add(name);
+  }
+  return names;
+};
+
+const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
+  const seen = new Set();
+  const merged = [];
+  for (const change of changes) {
+    seen.add(change.name);
+    const resolvedFrom = oldResolved.get(change.name) ?? '';
+    const resolvedTo = newResolved.get(change.name) ?? '';
+    merged.push({ ...change, resolvedFrom, resolvedTo });
+  }
+  const names = [...directNames(oldMaps, newMaps)];
+  names.sort();
+  for (const name of names) {
+    if (seen.has(name)) continue;
+    const from = oldResolved.get(name) ?? '';
+    const to = newResolved.get(name) ?? '';
+    if (from === to) continue;
+    if (!from && !to) continue;
+    let action = 'changed';
+    if (!from) action = 'added';
+    else if (!to) action = 'removed';
+    const section = 'resolved';
+    const resolvedFrom = from;
+    const resolvedTo = to;
+    merged.push({ name, section, action, from, to, resolvedFrom, resolvedTo });
+  }
+  return merged;
+};
+
+const compareChangeOrder = (left, right) => {
+  const section = SECTION_ORDER.indexOf(left.section);
+  const other = SECTION_ORDER.indexOf(right.section);
+  if (section !== other) return section - other;
+  const leftAction = ACTION_ORDER.indexOf(left.action);
+  const rightAction = ACTION_ORDER.indexOf(right.action);
+  if (leftAction !== rightAction) return leftAction - rightAction;
+  return left.name.localeCompare(right.name);
+};
+
+const orderedChanges = (changes) => [...changes].sort(compareChangeOrder);
+
+const kindItems = (items, kind) => {
+  const matched = [];
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (meta && meta.kind === kind) matched.push(item);
+  }
+  return matched;
+};
+
+const readGroupSnapshot = (group, readSides) => {
+  const origin = group.origin;
+  const dir = group.dir;
+  const groupItems = group.items;
+  const manifestItems = kindItems(groupItems, 'manifest');
+  const lockItems = kindItems(groupItems, 'lockfile');
+  const manifestRel = relOf(dir, MANIFEST);
+  const lockRel = relOf(dir, LOCKFILE);
+  const manifestSides = readSides(origin, manifestRel);
+  const lockSides = readSides(origin, lockRel);
+  const oldPkg = parseJson(manifestSides.oldText);
+  const newPkg = parseJson(manifestSides.newText);
+  const oldLock = parseJson(lockSides.oldText);
+  const newLock = parseJson(lockSides.newText);
+  const parsedManifest = !!(oldPkg || newPkg);
+  return {
+    origin,
+    dir,
+    groupItems,
+    manifestItems,
+    lockItems,
+    oldPkg,
+    newPkg,
+    oldLock,
+    newLock,
+    parsedManifest,
+  };
+};
+
+const sectionMapsOf = (snapshot) => {
+  if (snapshot.parsedManifest) {
+    const oldMaps = readSections(snapshot.oldPkg);
+    const newMaps = readSections(snapshot.newPkg);
+    return { oldMaps, newMaps };
+  }
+  if (snapshot.manifestItems.length) {
+    return mapsFromHunks(snapshot.manifestItems);
+  }
+  const oldMaps = lockRootSections(snapshot.oldLock);
+  const newMaps = lockRootSections(snapshot.newLock);
+  return { oldMaps, newMaps };
+};
+
+const comparedChanges = (snapshot) => {
+  const maps = sectionMapsOf(snapshot);
+  const oldMaps = maps.oldMaps;
+  const newMaps = maps.newMaps;
+  const manifestChanges = diffSections(oldMaps, newMaps);
+  const parsed = snapshot.parsedManifest;
+  let otherChanges = [];
+  if (parsed) {
+    otherChanges = diffOtherFields(snapshot.oldPkg, snapshot.newPkg);
+  }
+  const oldResolved = lockEntries(snapshot.oldLock);
+  const newResolved = lockEntries(snapshot.newLock);
+  const changes = mergeResolved(
+    manifestChanges,
+    oldResolved,
+    newResolved,
+    oldMaps,
+    newMaps,
+  );
+  const oldCount = lockPackageCount(snapshot.oldLock);
+  const newCount = lockPackageCount(snapshot.newLock);
+  return { changes, otherChanges, oldCount, newCount };
+};
+
+const foldingPolicy = (snapshot, compared) => {
+  const foldLock = snapshot.lockItems.length > 0;
+  const hasDepChanges = compared.changes.length > 0;
+  if (!snapshot.manifestItems.length) {
+    const foldManifest = false;
+    const takeAllManifest = false;
+    return { foldLock, foldManifest, takeAllManifest };
+  }
+  if (snapshot.parsedManifest) {
+    const foldManifest = hasDepChanges;
+    const takeAllManifest = hasDepChanges && compared.otherChanges.length === 0;
+    return { foldLock, foldManifest, takeAllManifest };
+  }
+  const foldManifest = hasDepChanges && onlyDepEdits(snapshot.manifestItems);
+  const takeAllManifest = foldManifest;
+  return { foldLock, foldManifest, takeAllManifest };
+};
+
+const summarizeGroup = (group, readSides) => {
+  const snapshot = readGroupSnapshot(group, readSides);
+  const compared = comparedChanges(snapshot);
+  const policy = foldingPolicy(snapshot, compared);
+  return {
+    changes: compared.changes,
+    oldCount: compared.oldCount,
+    newCount: compared.newCount,
+    foldLock: policy.foldLock,
+    foldManifest: policy.foldManifest,
+    takeAllManifest: policy.takeAllManifest,
+    manifestItems: snapshot.manifestItems,
+    lockItems: snapshot.lockItems,
+    pkg: snapshot.newPkg || snapshot.oldPkg,
+  };
+};
+
+const collectGroups = (items) => {
+  const groups = new Map();
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (!meta) continue;
+    const key = `${item.origin}\0${meta.dir}`;
+    let group = groups.get(key);
+    if (!group) {
+      const dir = meta.dir;
+      const origin = item.origin;
+      group = { dir, origin, items: [] };
+      groups.set(key, group);
+    }
+    group.items.push(item);
+  }
+  return groups;
+};
+
+const takeManifestItems = (summary) => {
+  if (!summary.foldManifest) return [];
+  if (summary.takeAllManifest) return [...summary.manifestItems];
+  const taken = [];
+  for (const item of summary.manifestItems) {
+    if (onlyDepEdits([item])) taken.push(item);
+  }
+  return taken;
+};
+
+module.exports = {
+  diffSections,
+  mergeResolved,
+  orderedChanges,
+  summarizeGroup,
+  collectGroups,
+  takeManifestItems,
+};

package/lib/deps/items.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { itemPath } = require('../files.js');
+
+const { depFileMeta } = require('./manifest.js');
+const { orderedChanges } = require('./changes.js');
+const { buildRows, makeHunk } = require('./rows.js');
+
+const uniquePaths = (items) => {
+  const files = [];
+  const seen = new Set();
+  for (const item of items) {
+    const rel = itemPath(item);
+    if (!rel || seen.has(rel)) continue;
+    seen.add(rel);
+    files.push(rel);
+  }
+  return files;
+};
+
+const filesForChange = (change, files) => {
+  const manifest = [];
+  const lockfile = [];
+  for (const rel of files) {
+    const meta = depFileMeta(rel);
+    if (!meta) continue;
+    if (meta.kind === 'manifest') manifest.push(rel);
+    else lockfile.push(rel);
+  }
+  if (change.section === 'field') {
+    if (manifest.length) return manifest;
+    return files;
+  }
+  if (change.section === 'resolved') {
+    if (lockfile.length) return lockfile;
+    return files;
+  }
+  if (change.propose) {
+    if (manifest.length) return manifest;
+    return files;
+  }
+  const both = [...manifest, ...lockfile];
+  if (both.length) return both;
+  return files;
+};
+
+const pickPrimary = (items) => {
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (meta && meta.kind === 'manifest') return item;
+  }
+  return items[0];
+};
+
+const makeDepItem = (origin, fileItems, hidden, change, extra, blockId) => {
+  const allFiles = uniquePaths(fileItems);
+  const files = change ? filesForChange(change, allFiles) : allFiles;
+  const primary = pickPrimary(fileItems);
+  const oldPath = itemPath(primary);
+  const newPath = oldPath;
+  const isNew = fileItems.some((item) => item.file && item.file.isNew);
+  const isDeleted = fileItems.every((item) => item.file && item.file.isDeleted);
+  let oldCount = 0;
+  let newCount = 0;
+  if (!change) {
+    oldCount = extra.oldCount ?? 0;
+    newCount = extra.newCount ?? 0;
+  }
+  const rows = buildRows(change, oldCount, newCount);
+  const hunk = makeHunk(rows, blockId);
+  const isBinary = false;
+  const preamble = [];
+  const hunks = [hunk];
+  const file = {
+    oldPath,
+    newPath,
+    isNew,
+    isDeleted,
+    isBinary,
+    preamble,
+    hunks,
+  };
+  const patchAdd = '';
+  const patchRevert = '';
+  const items = hidden;
+  const dep = { files, items, change };
+  const reload = !!(change && change.propose);
+  return { origin, file, hunk, blockId, patchAdd, patchRevert, dep, reload };
+};
+
+const makeDepItems = (origin, fileItems, hidden, summary) => {
+  const ordered = orderedChanges(summary.changes);
+  if (!ordered.length) {
+    return [makeDepItem(origin, fileItems, hidden, null, summary, 0)];
+  }
+  const items = [];
+  let blockId = 0;
+  for (const change of ordered) {
+    const made = makeDepItem(
+      origin,
+      fileItems,
+      hidden,
+      change,
+      summary,
+      blockId,
+    );
+    items.push(made);
+    blockId += 1;
+  }
+  return items;
+};
+
+const stubFileItem = (rel, origin) => {
+  const file = {
+    oldPath: rel,
+    newPath: rel,
+    isNew: false,
+    isDeleted: false,
+    isBinary: false,
+    preamble: [],
+    hunks: [],
+  };
+  const hunk = null;
+  const blockId = 0;
+  const patchAdd = '';
+  const patchRevert = '';
+  return { origin, file, hunk, blockId, patchAdd, patchRevert };
+};
+
+module.exports = { makeDepItems, stubFileItem };