reslop 0.1.6 → 0.1.8

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [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
+- Improve TODO screen and files screen TUI/TUX including hotkeys
+- Implement branch rebase and drop
+- Improve branch screen TUI/TUX
+- Fix TODOs autosave bug with todo duplication
+
 ## [0.1.6][] - 2026-09-15
 
 - Auto updates for patch/minor, y/n per new major
@@ -58,7 +83,10 @@
 - 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.5...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
 [0.1.4]: https://github.com/tshemsedinov/reslop/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/tshemsedinov/reslop/compare/v0.1.2...v0.1.3

package/README.md

@@ -1,4 +1,4 @@
-# 👁️ reslop — Review diff and plan changes
+# 👁️ reslop — Review AI generated code and plan changes
 
 [![ci status](https://github.com/tshemsedinov/reslop/workflows/Testing%20CI/badge.svg)](https://github.com/tshemsedinov/reslop/actions?query=workflow%3A%22Testing+CI%22+branch%3Amain)
 [![snyk](https://snyk.io/test/github/tshemsedinov/reslop/badge.svg)](https://snyk.io/test/github/tshemsedinov/reslop)
@@ -16,12 +16,16 @@ for the agent.
 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.
-- Leave feedback, todos, and in-place code proposals that become a repair plan.
+- 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.
 - Review each npm dependency once across `package.json` and the lockfile.
 - Propose unused removals, npm audit fixes, and outdated updates as diffs.
+- Code highlighting, diff compare: unified, mixed, and side-by-side layouts.
 
 ## Install
 
@@ -49,23 +53,33 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 ## Hotkeys
 
-| Key                 | Action                                          |
-| ------------------- | ----------------------------------------------- |
-| `a` / `u` / `d`     | Stage / unstage / drop this diff                |
-| `c`                 | Commit: then `c` commit / `a` amend / `f` fixup |
-| `b`                 | List branches; `b, n` new branch                |
-| `p` / `s`           | git pull/push                                   |
-| `f` / `t` / `e`     | Add feedback / todo / edit diff text            |
-| `r`                 | Reload diffs from disk                          |
-| `m`                 | Mode: unified / mixed / side-by-side            |
-| `⏎`                 | Open the selected file                          |
-| `→` / `j`           | Next remaining diff / next file                 |
-| `←` / `k`           | Previous remaining diff / 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                        |
-| `Esc` / `q`         | Quit                                            |
+| Key                 | Action                                        |
+| ------------------- | --------------------------------------------- |
+| `a` / `u` / `d`     | Stage / unstage / drop this diff              |
+| `c`                 | File list: `c` commit / `a` amend / `f` fixup |
+| `b`                 | List branches; `n` new; `r` rebase; `d` drop  |
+| `p` / `s`           | git pull/push                                 |
+| `f` / `t` / `e`     | Feedback / repo todo / edit added lines       |
+| `m`                 | Mode: unified / mixed / side-by-side          |
+| `⏎`                 | Open the selected file                        |
+| `→` / `j`           | Next remaining diff / file                    |
+| `←` / `k`           | Previous remaining diff / 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                      |
+| `Esc` / `q`         | Quit                                          |
+
+## Future
+
+- Import issues from GitHub and GitLab.
+- Security and code-quality audit; propose a repair plan.
+- Send anonymized code blocks for expert review.
+- Send questions and the repair plan to experts for approval.
+- Ask experts.
+- Verify the codebase.
+- Apply refactoring skills.
+- Call agents, harnesses, and IDEs to execute prepared plans.
 
 ## License
 

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/ansi.js

@@ -74,6 +74,7 @@ const THEME = {
   errorFg: [0xff, 0x80, 0x80],
   warnFg: [0xe8, 0xc8, 0x4a],
   mutedFg: [0x7a, 0x7a, 0x8a],
+  shaFg: [0x56, 0x9c, 0xd6],
   stagedDelLineFg: [0xa0, 0xa0, 0xa8],
   stagedDelLineBg: [0x20, 0x20, 0x26],
   stagedDelCharFg: [0xf0, 0xf0, 0xf4],

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,
+};