reslop 0.2.4 → 0.2.5

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased][unreleased]
 
+## [0.2.5][] - 2026-09-30
+
+- Remove UI and filesystem polling timers, refresh on events
+- Refresh the commits list when HEAD changes outside reslop
+- Update stage/unstage immediately, git/npm in the background
+- Add editor hotkeys Ctrl+X, Ctrl+C, and Ctrl+V
+- Improve diff calculation
+- Improve npm command and test edit/run
+- Refactor internals: simplify and add classes
+- Hothey "i" add to ignore lists: .gitignore, .npmignore
+- Rename TODO to tasks and improve TUI/TUX
+
 ## [0.2.4][] - 2026-09-28
 
 - Add AI instructions to run `npm t` or `reslop t -- node --test`
@@ -141,7 +153,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.2.4...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.2.5...HEAD
+[0.2.5]: https://github.com/tshemsedinov/reslop/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/tshemsedinov/reslop/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/tshemsedinov/reslop/compare/v0.2.1...v0.2.3
 [0.2.1]: https://github.com/tshemsedinov/reslop/compare/v0.2.0...v0.2.1

package/README.md

@@ -11,8 +11,7 @@
 
 > Turn generated changes into owned changes
 
-Open a change, leave findings and a backlog, and prepare a repair plan
-for the agent.
+Open a change, leave findings and a backlog, and prepare a repair plan for the agent.
 
 ```text
 Review → Plan → Repair → Verify

package/lib/capabilities.js

@@ -97,12 +97,8 @@ const sessionCapabilities = (options) => {
 };
 
 module.exports = {
-  READ_METHODS,
-  CHANGE_METHODS,
-  BRANCH_METHODS,
   SOURCE_CAPS,
   capabilitiesFor,
-  withReadOnly,
   attachCapabilities,
   sessionCapabilities,
 };

package/lib/clipboard.js

@@ -29,8 +29,44 @@ const runClip = (cmd, args, text) => {
   return result.status === 0;
 };
 
+const UNIX_PASTE = [
+  { cmd: 'wl-paste', args: ['--no-newline'] },
+  { cmd: 'xclip', args: ['-selection', 'clipboard', '-o'] },
+  { cmd: 'xsel', args: ['--clipboard', '--output'] },
+];
+
+let copied = '';
+
+const pasteTools = (platform = process.platform) => {
+  if (platform === 'win32') {
+    const args = ['-NoProfile', '-Command', 'Get-Clipboard'];
+    return [{ cmd: 'powershell', args }];
+  }
+  if (platform === 'darwin') return [{ cmd: 'pbpaste', args: [] }];
+  return UNIX_PASTE;
+};
+
+const readPaste = (cmd, args) => {
+  const result = spawnSync(
+    cmd,
+    args,
+    spawnBase({ encoding: 'utf8', timeout: CLIP_TIMEOUT_MS }),
+  );
+  if (result.error || result.status !== 0) return '';
+  return result.stdout || '';
+};
+
+const systemPaste = () => {
+  for (const tool of pasteTools()) {
+    const text = readPaste(tool.cmd, tool.args);
+    if (text) return text;
+  }
+  return '';
+};
+
 const copyText = (text, stdout) => {
   if (!text) return false;
+  copied = text;
   let ok = false;
   if (stdout && stdout.write) {
     stdout.write(osc52(text));
@@ -42,4 +78,6 @@ const copyText = (text, stdout) => {
   return ok;
 };
 
-module.exports = { osc52, copyText };
+const pasteText = () => systemPaste() || copied;
+
+module.exports = { osc52, copyText, pasteText };

package/lib/deps-diff.js

@@ -645,14 +645,11 @@ module.exports = {
   DEP_CAPTION,
   diffSections,
   mergeResolved,
-  orderedChanges,
   summarizeGroup,
   collectGroups,
   takeManifestItems,
   foldedDepNames,
   stripFoldedDepItem,
-  buildRows,
-  makeHunk,
   makeDepItems,
   stubFileItem,
 };

package/lib/deps.js

@@ -6,6 +6,8 @@ const metautil = require('metautil');
 const { jsonParse, isHashObject } = metautil;
 const files = require('./files.js');
 const { itemPath } = files;
+const utilities = require('./utilities.js');
+const { asText } = utilities;
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
 const { listFilePath, readSections, lockEntries, lockPackageCount } = manifest;
@@ -240,7 +242,7 @@ const viaNotes = (via, pkgName) => {
   const notes = [];
   for (const item of via) {
     if (!item || typeof item !== 'object') continue;
-    const title = typeof item.title === 'string' ? item.title : '';
+    const title = asText(item.title);
     if (!title) continue;
     const hasName = typeof item.name === 'string' && item.name;
     const named = hasName ? item.name : pkgName;
@@ -271,32 +273,52 @@ const auditEntryNames = (key, entry) => {
   return names;
 };
 
-const keepHighestAudit = (audit, name, severity, fix, range, notes) => {
+const uniqueTexts = (list) => [...new Set(list.filter(Boolean))];
+
+const keepHighestAudit = (audit, found) => {
+  const { name, severity } = found;
   if (!name || !severity || severity === 'info') return;
-  const titles = [];
-  for (const note of notes) {
-    if (note && !titles.includes(note)) titles.push(note);
-  }
+  const titles = uniqueTexts(found.titles);
   const prev = audit.get(name);
   if (prev && severityRank(prev.severity) >= severityRank(severity)) {
-    const merged = [...prev.titles];
-    for (const note of titles) {
-      if (!merged.includes(note)) merged.push(note);
-    }
-    const next = {
+    audit.set(name, {
       ...prev,
-      titles: merged,
-      fix: prev.fix || fix,
-      range: prev.range || range,
-    };
-    audit.set(name, next);
+      titles: uniqueTexts([...prev.titles, ...titles]),
+      fix: prev.fix || found.fix,
+      range: prev.range || found.range,
+    });
     return;
   }
   const title = titles[0] || '';
-  const next = { name, severity, title, titles, fix, range };
-  next.fix ||= '';
-  next.range ||= '';
-  audit.set(name, next);
+  const fix = found.fix || '';
+  const range = found.range || '';
+  audit.set(name, { name, severity, title, titles, fix, range });
+};
+
+const isEntry = (value) => Boolean(value) && typeof value === 'object';
+
+const vulnFindings = (vulns) => {
+  const found = [];
+  for (const [key, entry] of Object.entries(vulns)) {
+    if (!isEntry(entry)) continue;
+    const { severity } = entry;
+    const titles = viaNotes(entry.via, entry.name || key);
+    const fix = auditFix(entry);
+    const range = asText(entry.range);
+    for (const name of auditEntryNames(key, entry)) {
+      found.push({ name, severity, fix, range, titles });
+    }
+  }
+  return found;
+};
+
+const advisoryFinding = (entry) => {
+  const name = entry.module_name || entry.name;
+  const title = namedTitle(name, asText(entry.title));
+  const titles = title ? [title] : [];
+  const fix = auditFix(entry);
+  const range = asText(entry.range);
+  return { name, severity: entry.severity, fix, range, titles };
 };
 
 const parseAuditReport = (text) => {
@@ -304,36 +326,13 @@ const parseAuditReport = (text) => {
   if (!text || !`${text}`.trim()) return audit;
   const data = jsonParse(text);
   if (!isHashObject(data)) return audit;
-  const vulns = data.vulnerabilities;
-  if (vulns && typeof vulns === 'object') {
-    for (const key of Object.keys(vulns)) {
-      const entry = vulns[key];
-      if (!entry || typeof entry !== 'object') continue;
-      const severity = entry.severity;
-      const names = auditEntryNames(key, entry);
-      const pkgName = entry.name || key;
-      const titles = viaNotes(entry.via, pkgName);
-      const fix = auditFix(entry);
-      const range = typeof entry.range === 'string' ? entry.range : '';
-      for (const name of names) {
-        keepHighestAudit(audit, name, severity, fix, range, titles);
-      }
-    }
-  }
-  const advisories = data.advisories;
-  if (advisories && typeof advisories === 'object') {
-    for (const entry of Object.values(advisories)) {
-      if (!entry || typeof entry !== 'object') continue;
-      const name = entry.module_name || entry.name;
-      const severity = entry.severity;
-      const raw = typeof entry.title === 'string' ? entry.title : '';
-      const title = namedTitle(name, raw);
-      const titles = title ? [title] : [];
-      const fix = auditFix(entry);
-      const range = typeof entry.range === 'string' ? entry.range : '';
-      keepHighestAudit(audit, name, severity, fix, range, titles);
-    }
+  const { vulnerabilities, advisories } = data;
+  const found = isEntry(vulnerabilities) ? vulnFindings(vulnerabilities) : [];
+  if (isEntry(advisories)) {
+    const listed = Object.values(advisories).filter(isEntry);
+    found.push(...listed.map(advisoryFinding));
   }
+  for (const entry of found) keepHighestAudit(audit, entry);
   return audit;
 };
 
@@ -345,11 +344,11 @@ const parseOutdatedReport = (text) => {
   for (const name of Object.keys(data)) {
     const entry = data[name];
     if (!entry || typeof entry !== 'object') continue;
-    const current = typeof entry.current === 'string' ? entry.current : '';
-    const wanted = typeof entry.wanted === 'string' ? entry.wanted : '';
-    const latest = typeof entry.latest === 'string' ? entry.latest : '';
-    const type = typeof entry.type === 'string' ? entry.type : '';
+    const wanted = asText(entry.wanted);
     if (!wanted) continue;
+    const current = asText(entry.current);
+    const latest = asText(entry.latest);
+    const type = asText(entry.type);
     outdated.set(name, { current, wanted, latest, type });
   }
   return outdated;
@@ -390,21 +389,18 @@ const unusedChangeNames = (changes, used) => {
   return names;
 };
 
-const unusedDeclaredNames = (pkg, used) => {
-  const names = [];
-  if (!pkgHasExportEntry(pkg)) return names;
-  if (!used || !used.size) return names;
+const unusedDeclared = (pkg, used) => {
+  const found = [];
+  if (!pkgHasExportEntry(pkg) || !used?.size) return found;
   const maps = readSections(pkg);
   for (const section of SECTION_KEYS) {
     if (section === 'peerDependencies') continue;
-    const keys = [...maps[section].keys()];
-    keys.sort();
-    for (const name of keys) {
-      if (used.has(name)) continue;
-      names.push(name);
+    const map = maps[section];
+    for (const name of [...map.keys()].sort()) {
+      if (!used.has(name)) found.push({ name, section, from: map.get(name) });
     }
   }
-  return names;
+  return found;
 };
 
 const markUnusedChanges = (changes, used, pkg, exportEntries) => {
@@ -418,92 +414,69 @@ const markUnusedChanges = (changes, used, pkg, exportEntries) => {
 
 const unusedDeclaredChanges = (pkg, used, exportEntries) => {
   const changes = [];
-  if (!pkgHasExportEntry(pkg)) return changes;
-  if (!used || !used.size) return changes;
-  const maps = readSections(pkg);
   const taken = new Set();
-  for (const section of SECTION_KEYS) {
-    if (section === 'peerDependencies') continue;
-    const map = maps[section];
-    const names = [...map.keys()];
-    names.sort();
-    for (const name of names) {
-      if (used.has(name)) continue;
-      if (taken.has(name)) continue;
-      if (!depExports(exportEntries, name)) continue;
-      taken.add(name);
-      const version = map.get(name);
-      changes.push({
-        name,
-        section,
-        action: 'removed',
-        from: version,
-        to: '',
-        propose: true,
-        unused: true,
-      });
-    }
+  for (const { name, section, from } of unusedDeclared(pkg, used)) {
+    if (taken.has(name) || !depExports(exportEntries, name)) continue;
+    taken.add(name);
+    const action = 'removed';
+    const to = '';
+    changes.push({
+      name,
+      section,
+      action,
+      from,
+      to,
+      propose: true,
+      unused: true,
+    });
   }
   return changes;
 };
 
+const resolvedChange = (name, vul, resolved) => {
+  const from = resolved.get(name) || '';
+  if (!vul || !from) return null;
+  const to = proposedLockVersion(from, vul);
+  const section = 'resolved';
+  const action = 'vulnerable';
+  return { name, section, action, from, to, propose: true, audit: vul };
+};
+
+const declaredChange = (name, declared, out, vul) => {
+  const wanted = proposedWanted(out, vul);
+  if (!wanted && !vul) return null;
+  const from = declared.version;
+  const to = wanted ? applyWantedRange(from, wanted) : from;
+  if (to === from && !vul) return null;
+  const action = to === from ? 'vulnerable' : 'changed';
+  const { section } = declared;
+  const change = { name, section, action, from, to, propose: true };
+  if (out) change.outdated = out;
+  if (vul) change.audit = vul;
+  return change;
+};
+
+const mapKeys = (map) => (map ? [...map.keys()] : []);
+
 const buildProposedChanges = (pkg, outdated, audit, lock, options = {}) => {
-  const used = options.used;
-  const exportEntries = options.exportEntries;
-  const names = new Set();
-  if (outdated) {
-    for (const name of outdated.keys()) names.add(name);
-  }
-  if (audit) {
-    for (const name of audit.keys()) names.add(name);
-  }
-  const listed = [...names];
+  const listed = [...new Set([...mapKeys(outdated), ...mapKeys(audit)])];
   listed.sort();
   const resolved = lockEntries(lock);
-  const unused = unusedDeclaredChanges(pkg, used, exportEntries);
-  const taken = new Set();
-  for (const change of unused) taken.add(change.name);
-  const changes = [...unused];
+  const changes = unusedDeclaredChanges(
+    pkg,
+    options.used,
+    options.exportEntries,
+  );
+  const taken = new Set(changes.map((change) => change.name));
   for (const name of listed) {
     if (taken.has(name)) continue;
     const out = outdated ? outdated.get(name) : null;
     const vul = audit ? audit.get(name) : null;
-    const type = out ? out.type : '';
-    const declared = findDeclared(pkg, name, type);
-    if (!declared) {
-      if (!vul) continue;
-      const version = resolved.get(name) || '';
-      if (!version) continue;
-      const to = proposedLockVersion(version, vul);
-      changes.push({
-        name,
-        section: 'resolved',
-        action: 'vulnerable',
-        from: version,
-        to,
-        propose: true,
-        audit: vul,
-      });
-      continue;
-    }
-    const wanted = proposedWanted(out, vul);
-    if (!wanted && !vul) continue;
-    let to = declared.version;
-    if (wanted) to = applyWantedRange(declared.version, wanted);
-    if (to === declared.version && !vul) continue;
-    let action = 'changed';
-    if (to === declared.version) action = 'vulnerable';
-    const change = {
-      name,
-      section: declared.section,
-      action,
-      from: declared.version,
-      to,
-      propose: true,
-    };
-    if (out) change.outdated = out;
-    if (vul) change.audit = vul;
-    changes.push(change);
+    const declared = findDeclared(pkg, name, out ? out.type : '');
+    const change = declared
+      ? declaredChange(name, declared, out, vul)
+      : resolvedChange(name, vul, resolved);
+    if (change) changes.push(change);
   }
   return changes;
 };
@@ -561,6 +534,30 @@ const insertAfterPath = (items, added, rel) => {
   return [...items.slice(0, at + 1), ...added, ...items.slice(at + 1)];
 };
 
+const placeFolded = (items, { folded, synthetic, leftoverNames }) => {
+  const out = [];
+  const slot = new Map();
+  for (const item of items) {
+    const meta = depFileMeta(itemPath(item));
+    const pkgRel = meta ? relOf(meta.dir, MANIFEST) : '';
+    const key = meta ? `${item.origin}\0${meta.dir}` : '';
+    if (meta && synthetic.has(key) && !slot.has(pkgRel)) {
+      slot.set(pkgRel, out.length);
+    }
+    if (folded.has(item)) continue;
+    if (!meta || meta.kind !== 'manifest') {
+      out.push(item);
+      continue;
+    }
+    const names = leftoverNames.get(key);
+    const kept = names ? stripFoldedDepItem(item, names) : item;
+    if (!kept) continue;
+    out.push(kept);
+    slot.set(pkgRel, out.length);
+  }
+  return spliceAtSlots(out, synthetic, slot);
+};
+
 const foldDepItems = (
   items,
   readSides = () => ({ oldText: '', newText: '' }),
@@ -578,51 +575,22 @@ const foldDepItems = (
     const summary = summarizeGroup(group, readSides);
     const unusedNames = unusedChangeNames(summary.changes, usedNames);
     const exportEntries = loadExportEntries(unusedNames, extra, group.dir);
-    const unused = markUnusedChanges(
-      summary.changes,
-      usedNames,
-      summary.pkg,
-      exportEntries,
-    );
-    const audited = markChanges(unused, audit, 'audit');
-    const changes = markChanges(audited, outdated, 'outdated');
+    const { pkg } = summary;
+    let changes = summary.changes;
+    changes = markUnusedChanges(changes, usedNames, pkg, exportEntries);
+    changes = markChanges(changes, audit, 'audit');
+    changes = markChanges(changes, outdated, 'outdated');
     const next = { ...summary, changes };
-    leftoverNames.set(key, foldedDepNames(next.changes));
+    leftoverNames.set(key, foldedDepNames(changes));
     const taken = takeManifestItems(next);
-    if (next.foldLock) {
-      for (const item of next.lockItems) taken.push(item);
-    }
-    if (!taken.length && !next.changes.length) continue;
+    if (next.foldLock) taken.push(...next.lockItems);
+    if (!taken.length && !changes.length) continue;
     const made = makeDepItems(group.origin, group.items, taken, next);
     if (made.length) synthetic.set(key, made);
     for (const item of taken) folded.add(item);
   }
   if (!synthetic.size && !folded.size) return items;
-  const out = [];
-  const slot = new Map();
-  for (const item of items) {
-    const rel = itemPath(item);
-    const meta = depFileMeta(rel);
-    if (meta) {
-      const pkgRel = relOf(meta.dir, MANIFEST);
-      const key = `${item.origin}\0${meta.dir}`;
-      if (synthetic.has(key) && !slot.has(pkgRel)) {
-        slot.set(pkgRel, out.length);
-      }
-    }
-    if (folded.has(item)) continue;
-    if (meta && meta.kind === 'manifest') {
-      const names = leftoverNames.get(`${item.origin}\0${meta.dir}`);
-      const kept = names ? stripFoldedDepItem(item, names) : item;
-      if (kept) {
-        out.push(kept);
-        slot.set(relOf(meta.dir, MANIFEST), out.length);
-      }
-      continue;
-    }
-    out.push(item);
-  }
-  return spliceAtSlots(out, synthetic, slot);
+  return placeFolded(items, { folded, synthetic, leftoverNames });
 };
 
 const proposeDepItems = (pkgText, outdated, audit, extra = {}) => {
@@ -630,7 +598,7 @@ const proposeDepItems = (pkgText, outdated, audit, extra = {}) => {
   if (!pkg) return [];
   const lock = jsonParse(extra.lockText ?? '');
   const used = extra.usedNames;
-  const names = unusedDeclaredNames(pkg, used);
+  const names = unusedDeclared(pkg, used).map((dep) => dep.name);
   const exportEntries = loadExportEntries(names, extra, extra.dir);
   const options = { used, exportEntries };
   const changes = buildProposedChanges(pkg, outdated, audit, lock, options);

package/lib/diff/inline.js

@@ -6,6 +6,7 @@ const { graphemes } = ansi;
 const LCS_CELL_LIMIT = 250000;
 const NOISY_TINY_SPANS = 6;
 const WORD_REFINE_MIN = 0.6;
+const WHOLE_MIN_SHARED = 0.25;
 const PIECE_RE = /[A-Za-z_$][\w$]*|\d+|\s+|./g;
 const CAMEL_RE = /[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+|./g;
 
@@ -280,6 +281,65 @@ const spansFromWordOps = (ops) => {
   };
 };
 
+const opRuns = (ops) => {
+  const runs = [];
+  for (const op of ops) {
+    const eq = op.type === 'eq';
+    let run = runs[runs.length - 1];
+    if (!run || run.eq !== eq) {
+      run = { eq, del: [], add: [] };
+      runs.push(run);
+    }
+    if (op.type !== 'add') run.del.push(op.text);
+    if (op.type !== 'del') run.add.push(op.text);
+  }
+  return runs;
+};
+
+const textSize = (parts) => parts.join('').length;
+
+const editSize = (run) => Math.max(textSize(run.del), textSize(run.add));
+
+const absorbTinyEquals = (runs) => {
+  for (let k = 1; k < runs.length - 1; k++) {
+    const [before, eq, after] = runs.slice(k - 1, k + 2);
+    if (!eq.eq) continue;
+    const size = textSize(eq.del);
+    if (size > editSize(before) || size > editSize(after)) continue;
+    const del = [...before.del, ...eq.del, ...after.del];
+    const add = [...before.add, ...eq.add, ...after.add];
+    runs.splice(k - 1, 3, { eq: false, del, add });
+    k = 0;
+  }
+  return runs;
+};
+
+const runOps = (runs) => {
+  const ops = [];
+  for (const run of runs) {
+    if (run.eq) {
+      for (const text of run.del) ops.push({ type: 'eq', text });
+      continue;
+    }
+    for (const text of run.del) ops.push({ type: 'del', text });
+    for (const text of run.add) ops.push({ type: 'add', text });
+  }
+  return ops;
+};
+
+const cleanOps = (ops) => runOps(absorbTinyEquals(opRuns(ops)));
+
+const sharedShare = (spans) => {
+  let shared = 0;
+  let total = 0;
+  for (const span of spans) {
+    const size = span.text.replace(/\s/g, '').length;
+    total += size;
+    if (!span.changed) shared += size;
+  }
+  return total === 0 ? 1 : shared / total;
+};
+
 const diffChars = (oldText, newText) => {
   const a = splitPieces(oldText);
   const b = splitPieces(newText);
@@ -296,10 +356,15 @@ const diffChars = (oldText, newText) => {
   } else if (midA.length * midB.length > LCS_CELL_LIMIT) {
     mid = wholeChanged(midA, midB);
   } else {
-    mid = spansFromWordOps(lcsOps(midA, midB));
+    mid = spansFromWordOps(cleanOps(lcsOps(midA, midB)));
   }
   const oldSpans = joinAffix(prefix, mid.oldSpans, suffix);
   const newSpans = joinAffix(prefix, mid.newSpans, suffix);
+  const oldShare = sharedShare(oldSpans);
+  const newShare = sharedShare(newSpans);
+  if (oldShare < WHOLE_MIN_SHARED && newShare < WHOLE_MIN_SHARED) {
+    return wholeChanged(a, b);
+  }
   return { oldSpans, newSpans };
 };
 

package/lib/diff/unit.js

@@ -128,43 +128,26 @@ const sameBlock = (line, item) => {
   return line.blockId === item.blockId;
 };
 
-const blockLineRange = (lines, item) => {
-  let start = 0;
+const changedLineRange = (lines, item, belongs) => {
+  let start = -1;
   let end = 0;
-  let found = false;
-  if (!item) return { start, end };
+  if (!item) return { start: 0, end };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (!sameBlock(line, item)) continue;
-    if (line.type === 'ctx') continue;
-    if (!found) {
-      start = i;
-      found = true;
-    }
+    if (line.type === 'ctx' || !belongs(line, item)) continue;
+    if (start < 0) start = i;
     end = i;
   }
-  return { start, end };
+  return { start: Math.max(start, 0), end };
 };
 
+const blockLineRange = (lines, item) =>
+  changedLineRange(lines, item, sameBlock);
+
 const blockLineIndex = (lines, item) => blockLineRange(lines, item).start;
 
-const hunkLineRange = (lines, item) => {
-  let start = 0;
-  let end = 0;
-  let found = false;
-  if (!item) return { start, end };
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!sameHunk(line.item, item)) continue;
-    if (line.type === 'ctx') continue;
-    if (!found) {
-      start = i;
-      found = true;
-    }
-    end = i;
-  }
-  return { start, end };
-};
+const hunkLineRange = (lines, item) =>
+  changedLineRange(lines, item, (line) => sameHunk(line.item, item));
 
 const fileOffset = (lines, at) => {
   let offset = 0;