reslop 0.1.8 → 0.2.0

package/lib/session/items.js

@@ -1,9 +1,11 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const files = require('../files.js');
 const { itemPath, TODO_FILE, isTodoItem } = files;
 const { feedbackKey } = require('../review.js');
-const { refreshIndexPatches } = require('../diff.js');
+const { refreshIndexPatches } = require('../diff/diff.js');
 
 const depChangeKey = (item) => {
   const change = item.dep && item.dep.change;
@@ -21,25 +23,125 @@ const npmBusyKind = (item) => {
   return 'npm i';
 };
 
-const itemKey = (item) => {
+const blockKey = (item) => {
   if (!item || !item.file) return '';
   const rel = itemPath(item);
   if (isTodoItem(item)) return `todo:${TODO_FILE}`;
-  const origin = item.origin ?? '';
   const depId = depChangeKey(item);
-  if (depId) return `${origin}:${rel}:dep:${depId}`;
+  if (depId) return `${rel}:dep:${depId}`;
   if (!item.hunk) {
     const block = item.blockId ?? '-';
-    return `${origin}:${rel}:file:${block}`;
+    return `${rel}:file:${block}`;
   }
   const oldStart = item.hunk.oldStart;
   const newStart = item.hunk.newStart;
   const block = item.blockId ?? '-';
-  return `${origin}:${rel}:${oldStart}:${newStart}:${block}`;
+  return `${rel}:${oldStart}:${newStart}:${block}`;
+};
+
+const itemKey = (item) => {
+  const key = blockKey(item);
+  if (!key || isTodoItem(item)) return key;
+  const origin = item.origin ?? '';
+  return `${origin}:${key}`;
+};
+
+const blockLinesKey = (item) => {
+  if (!item || !item.file || isTodoItem(item)) return '';
+  if (!item.hunk) return '';
+  const parts = [itemPath(item)];
+  for (const line of item.hunk.lines) {
+    if (line.blockId !== item.blockId) continue;
+    if (line.type === 'ctx') continue;
+    parts.push(`${line.type}:${line.text}`);
+  }
+  return parts.join('\0');
+};
+
+const pushBucket = (map, key, item) => {
+  if (!key) return;
+  const list = map.get(key) ?? [];
+  list.push(item);
+  map.set(key, list);
+};
+
+const takeBucket = (map, key, used) => {
+  if (!key) return null;
+  const list = map.get(key);
+  if (!list || !list.length) return null;
+  while (list.length) {
+    const item = list.shift();
+    if (!used.has(item)) return item;
+  }
+  return null;
+};
+
+const groupByPath = (items) => {
+  const groups = new Map();
+  for (const item of items) {
+    const rel = itemPath(item) || '';
+    const list = groups.get(rel) ?? [];
+    list.push(item);
+    groups.set(rel, list);
+  }
+  return groups;
+};
+
+const alignGroup = (prev, next) => {
+  if (!prev.length) return next;
+  if (!next.length) return [];
+  const byBlock = new Map();
+  const byLines = new Map();
+  for (const item of next) {
+    pushBucket(byBlock, blockKey(item), item);
+    pushBucket(byLines, blockLinesKey(item), item);
+  }
+  const used = new Set();
+  const ordered = [];
+  for (const item of prev) {
+    const byText = takeBucket(byLines, blockLinesKey(item), used);
+    const taken = byText ?? takeBucket(byBlock, blockKey(item), used);
+    if (!taken) continue;
+    used.add(taken);
+    ordered.push(taken);
+  }
+  for (const item of next) {
+    if (used.has(item)) continue;
+    ordered.push(item);
+  }
+  return ordered;
+};
+
+const alignLoadedItems = (prev, next) => {
+  if (!prev.length || !next.length) return next;
+  const nextGroups = groupByPath(next);
+  const seen = new Set();
+  const ordered = [];
+  for (const [rel, list] of groupByPath(prev)) {
+    seen.add(rel);
+    const aligned = alignGroup(list, nextGroups.get(rel) ?? []);
+    for (const item of aligned) ordered.push(item);
+  }
+  for (const [rel, list] of nextGroups) {
+    if (seen.has(rel)) continue;
+    for (const item of list) ordered.push(item);
+  }
+  return ordered;
 };
 
 const restoredIndex = (items, item) => {
   if (!item || !item.file) return -1;
+  const origin = item.origin ?? '';
+  const lines = blockLinesKey(item);
+  if (lines) {
+    let any = -1;
+    for (let i = 0; i < items.length; i++) {
+      if (blockLinesKey(items[i]) !== lines) continue;
+      if (any < 0) any = i;
+      if ((items[i].origin ?? '') === origin) return i;
+    }
+    if (any >= 0) return any;
+  }
   const key = itemKey(item);
   if (key) {
     const exact = items.findIndex((entry) => itemKey(entry) === key);
@@ -47,7 +149,6 @@ const restoredIndex = (items, item) => {
   }
   const rel = itemPath(item);
   if (!rel) return -1;
-  const origin = item.origin ?? '';
   const start = item.hunk ? item.hunk.newStart : 0;
   let fileMatch = -1;
   let best = -1;
@@ -106,8 +207,9 @@ const createItemCollection = () => {
   const isDismissed = (item) => state.dismissed.has(itemKey(item));
 
   const replace = (items) => {
+    const aligned = alignLoadedItems(state.items, items);
     const next = [];
-    for (const item of items) {
+    for (const item of aligned) {
       if (isDismissed(item)) continue;
       next.push(item);
     }
@@ -123,18 +225,15 @@ const createItemCollection = () => {
     state.dismissed.clear();
   };
 
-  const findIndexByKey = (key) => {
-    if (!key) return -1;
-    return state.items.findIndex((item) => itemKey(item) === key);
-  };
-
   const findRestoredIndex = (item) => restoredIndex(state.items, item);
 
   const keepOrigin = (item, origin) => {
     const next = { ...item, origin };
-    const replaced = [];
-    for (const entry of state.items) {
-      replaced.push(sameBlock(entry, item) ? next : entry);
+    const { length } = state.items;
+    const replaced = new Array(length);
+    for (let i = 0; i < length; i++) {
+      const entry = state.items[i];
+      replaced[i] = sameBlock(entry, item) ? next : entry;
     }
     if (next.dep) {
       state.items = replaced;
@@ -143,33 +242,31 @@ const createItemCollection = () => {
     state.items = refreshIndexPatches(replaced, next);
   };
 
-  return {
-    get items() {
-      return state.items;
-    },
-    set items(value) {
-      state.items = value;
+  return stateView(
+    state,
+    {
+      reset,
+      replace,
+      dismiss,
+      clearDismissed,
+      isDismissed,
+      findRestoredIndex,
+      keepOrigin,
     },
-    get dismissed() {
-      return state.dismissed;
-    },
-    reset,
-    replace,
-    dismiss,
-    clearDismissed,
-    isDismissed,
-    findIndexByKey,
-    findRestoredIndex,
-    keepOrigin,
-  };
+    ['items'],
+    ['dismissed'],
+  );
 };
 
 module.exports = {
   depChangeKey,
   needsReload,
   npmBusyKind,
+  blockKey,
   itemKey,
   itemFeedKey,
+  blockLinesKey,
+  alignLoadedItems,
   restoredIndex,
   sameBlock,
   canEditCode,

package/lib/session/lifecycle.js

@@ -4,10 +4,10 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { isAbortError } = require('./load.js');
-const { createDiskWatcher, POLL_MS } = require('./watch.js');
+const { createDiskWatcher, POLL_MS, DEBOUNCE_MS } = require('./watch.js');
 const files = require('../files.js');
-const { itemPath } = files;
-const { MANIFEST, LOCKFILE } = require('../deps/manifest.js');
+const { itemPath, relativeAge } = files;
+const { MANIFEST, LOCKFILE } = require('../deps.js');
 const review = require('../review.js');
 const { hasNotes } = review;
 
@@ -30,8 +30,6 @@ const shouldDeferExtras = (api) => {
   return audit && (waitingOutdated || waitingAudit);
 };
 
-const watchOpts = (api) => api.watch ?? {};
-
 const endReadLoop = (api) => {
   const finish = api.ui.finishReadLoop;
   if (finish) finish();
@@ -50,8 +48,6 @@ const kindFromExtra = (extra = {}) => {
   return 'reload';
 };
 
-const shouldResetNav = (kind) => kind !== 'open' && kind !== 'watch';
-
 const finishIfEmpty = (api, kind) => {
   const { collection, review: notes, ui, nav } = api;
   if (collection.items.length) return;
@@ -103,9 +99,47 @@ const itemRels = (collection) => {
   return rels;
 };
 
+const fileDatesFromDisk = (top, rels) => {
+  const dates = new Map();
+  if (!top) return dates;
+  const now = Date.now();
+  for (const rel of rels) {
+    try {
+      const st = fs.statSync(path.join(top, rel));
+      dates.set(rel, relativeAge(st.mtimeMs, now));
+    } catch {
+      continue;
+    }
+  }
+  return dates;
+};
+
+const stampItemDates = (items, dates) => {
+  for (const item of items) {
+    const date = dates.get(itemPath(item));
+    if (date) item.date = date;
+  }
+};
+
+const syncUnitEditor = (api) => {
+  const composer = api.ui.composer;
+  if (!composer || typeof composer.applyDiskText !== 'function') return;
+  if (api.nav.pane !== 'unit') return;
+  const rel = api.nav.reviewPath;
+  if (!rel) return;
+  const repo = api.ui.repo;
+  if (!repo || typeof repo.fileText !== 'function') return;
+  const text = repo.fileText(api.ui.top || api.loadConfig.cwd, rel, api.ui.rev);
+  composer.applyDiskText(text);
+};
+
 const syncItemWatches = (api) => {
   if (!api.diskWatcher) return;
-  api.diskWatcher.watchFiles(itemRels(api.collection));
+  const rels = itemRels(api.collection);
+  if (api.nav.pane === 'unit' && api.nav.reviewPath) {
+    if (!rels.includes(api.nav.reviewPath)) rels.push(api.nav.reviewPath);
+  }
+  api.diskWatcher.watchFiles(rels);
 };
 
 const applyLoaded = (api, loaded) => {
@@ -117,6 +151,10 @@ const applyLoaded = (api, loaded) => {
   const here = ui.current();
   ui.top = loaded.top ?? api.loadConfig.cwd;
   collection.replace(loaded.items);
+  stampItemDates(
+    collection.items,
+    fileDatesFromDisk(ui.top, itemRels(collection)),
+  );
   if (loaded.rev) ui.rev = loaded.rev;
   if (loaded.revShort) {
     ui.revShort = loaded.revShort;
@@ -134,6 +172,7 @@ const applyLoaded = (api, loaded) => {
   markLoaded(api);
   loader.pendingExtras = loaded.pending === true;
   syncItemWatches(api);
+  syncUnitEditor(api);
   return true;
 };
 
@@ -147,10 +186,10 @@ const load = (api) => {
   applyLoaded(api, loaded);
 };
 
-const fileStamp = (top, rel, statSync) => {
+const fileStamp = (top, rel) => {
   const full = path.join(top, rel);
   try {
-    const stat = statSync(full);
+    const stat = fs.statSync(full);
     return `${stat.mtimeMs}:${stat.size}`;
   } catch {
     return 'missing';
@@ -158,11 +197,9 @@ const fileStamp = (top, rel, statSync) => {
 };
 
 const npmStamp = (api) => {
-  const extra = watchOpts(api);
-  const statSync = extra.statSync ?? fs.statSync;
   const top = api.ui.top || api.loadConfig.cwd;
-  const pkg = fileStamp(top, MANIFEST, statSync);
-  const lock = fileStamp(top, LOCKFILE, statSync);
+  const pkg = fileStamp(top, MANIFEST);
+  const lock = fileStamp(top, LOCKFILE);
   return `${pkg}|${lock}`;
 };
 
@@ -190,8 +227,7 @@ const followExtras = async (api, loaded, gen, kind) => {
     next = await api.loader.fetchExtras(api.loadConfig.repo, loaded, extra);
   } catch (error) {
     if (!api.loader.isCurrent(gen)) return;
-    failOpen(api, error);
-    return;
+    return void failOpen(api, error);
   }
   if (!api.loader.isCurrent(gen)) return;
   if (api.ui.done) {
@@ -241,9 +277,8 @@ const resetNavAfterLoad = (api, extra = {}) => {
 };
 
 const afterSnapshot = (api, kind, extra = {}) => {
-  if (shouldResetNav(kind)) {
-    resetNavAfterLoad(api, extra);
-    return;
+  if (kind !== 'open' && kind !== 'watch') {
+    return void resetNavAfterLoad(api, extra);
   }
   if (extra.afterLoad) extra.afterLoad();
 };
@@ -270,8 +305,7 @@ const runSnapshot = async (api, gen, kind, extra = {}) => {
     );
   } catch (error) {
     if (!api.loader.isCurrent(gen)) return;
-    failOpen(api, error);
-    return;
+    return void failOpen(api, error);
   }
   if (!api.loader.isCurrent(gen)) return;
   if (api.ui.done) {
@@ -328,8 +362,7 @@ const refreshFromRepo = (api, extra = {}) => {
   afterSnapshot(api, kind, extra);
   if (loaded.pending) {
     api.ops.setBusy('checking npm');
-    followExtras(api, loaded, gen, kind);
-    return;
+    return void followExtras(api, loaded, gen, kind);
   }
   if (kind === 'keep') return;
   finishIfEmpty(api, kind);
@@ -340,17 +373,18 @@ const refreshFromRepo = (api, extra = {}) => {
 };
 
 const reloadAfterChange = (api, afterLoad) => {
-  const here = api.nav.index;
+  const hereItem = api.ui.current();
+  const hereIndex = api.nav.index;
   const restore = () => {
-    api.nav.index = here;
+    const idx = api.collection.findRestoredIndex(hereItem);
+    api.nav.index = idx >= 0 ? idx : hereIndex;
     api.ui.clampIndex();
     api.ui.syncReviewPath();
     api.ui.syncFileCursor();
     if (afterLoad) afterLoad();
   };
   if (api.ui.uiOpen && api.loadConfig.repo.loadAsync) {
-    refreshFromRepo(api, { afterLoad: restore });
-    return;
+    return void refreshFromRepo(api, { afterLoad: restore });
   }
   refreshFromRepo(api);
   restore();
@@ -364,9 +398,7 @@ const onReload = (api) => {
 
 const clearWatchRetry = (api) => {
   if (api.watchRetry === null) return;
-  const extra = watchOpts(api);
-  const clearTimeoutFn = extra.clearTimeout ?? clearTimeout;
-  clearTimeoutFn(api.watchRetry);
+  clearTimeout(api.watchRetry);
   api.watchRetry = null;
 };
 
@@ -376,35 +408,43 @@ const shouldDeferWatch = (api) => {
   if (!ui.uiOpen) return true;
   if (!api.loader.didLoad) return true;
   if (ops.gitBusy) return true;
+  if (ui.mode === 'compose') {
+    const kind = ui.composer && ui.composer.state.composeKind;
+    if (kind === 'file') return false;
+  }
   if (ui.mode !== 'review') return true;
   return false;
 };
 
+const WATCH_IGNORE_MS = 500;
+
+const ignoreWatch = (api, ms = WATCH_IGNORE_MS) => {
+  api.ignoreWatchUntil = Date.now() + ms;
+};
+
 const onDiskChange = (api) => {
+  if (Date.now() < (api.ignoreWatchUntil ?? 0)) return;
   if (shouldDeferWatch(api)) {
     if (api.watchRetry !== null) return;
-    const extra = watchOpts(api);
-    const setTimeoutFn = extra.setTimeout ?? setTimeout;
-    const delay = extra.debounceMs ?? 200;
-    api.watchRetry = setTimeoutFn(() => {
+    api.watchRetry = setTimeout(() => {
       api.watchRetry = null;
       onDiskChange(api);
-    }, delay);
+    }, DEBOUNCE_MS);
+    if (typeof api.watchRetry.unref === 'function') api.watchRetry.unref();
     return;
   }
   refreshFromRepo(api, { keepView: true, quiet: true });
 };
 
 const currentFileStamp = (api) => {
-  if (api.nav.pane !== 'diff') return '';
-  const rel = itemPath(api.ui.current());
+  const pane = api.nav.pane;
+  if (pane !== 'diff' && pane !== 'unit') return '';
+  const rel = pane === 'unit' ? api.nav.reviewPath : itemPath(api.ui.current());
   if (!rel) return '';
-  const extra = watchOpts(api);
-  const statSync = extra.statSync ?? fs.statSync;
   const full = path.join(api.ui.top || api.loadConfig.cwd, rel);
   let stat;
   try {
-    stat = statSync(full);
+    stat = fs.statSync(full);
   } catch {
     return `${rel}:missing`;
   }
@@ -440,12 +480,10 @@ const startWatch = (api) => {
   if (!isWorktree(api.ui)) return;
   const root = api.ui.top || api.loadConfig.cwd;
   if (!root) return;
-  const extra = watchOpts(api);
   api.diskWatcher = createDiskWatcher({
     root,
     paths: api.loadConfig.paths,
     onChange: () => onDiskChange(api),
-    ...extra,
   });
   syncItemWatches(api);
   if (!api.ui.term) return;
@@ -456,6 +494,7 @@ const createLifecycle = (api) => {
   api.diskWatcher = null;
   api.watchRetry = null;
   api.watchStamp = '';
+  api.ignoreWatchUntil = 0;
   api.npmExtras = null;
   return {
     applyLoaded: (loaded) => applyLoaded(api, loaded),
@@ -469,6 +508,7 @@ const createLifecycle = (api) => {
     pollCurrentFile: () => pollCurrentFile(api),
     startWatch: () => startWatch(api),
     stopWatch: () => stopWatch(api),
+    ignoreWatch: (ms) => ignoreWatch(api, ms),
     clearNpmExtras: () => clearNpmExtras(api),
   };
 };

package/lib/session/load.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const isAbortError = (error) => !!(error && error.code === 'ABORT');
 
 const createLoadCoordinator = () => {
@@ -46,40 +48,24 @@ const createLoadCoordinator = () => {
     return repo.loadExtras(loaded, extra);
   };
 
-  return {
-    get gen() {
-      return state.gen;
-    },
-    get promise() {
-      return state.promise;
-    },
-    set promise(value) {
-      state.promise = value;
-    },
-    get pendingExtras() {
-      return state.pendingExtras;
-    },
-    set pendingExtras(value) {
-      state.pendingExtras = value;
+  return stateView(
+    state,
+    {
+      get signal() {
+        return state.abort?.signal;
+      },
+      bump,
+      isCurrent,
+      accept,
+      abort,
+      reset,
+      tag,
+      fetchSnapshot,
+      fetchExtras,
     },
-    get didLoad() {
-      return state.didLoad;
-    },
-    set didLoad(value) {
-      state.didLoad = value;
-    },
-    get signal() {
-      return state.abort?.signal;
-    },
-    bump,
-    isCurrent,
-    accept,
-    abort,
-    reset,
-    tag,
-    fetchSnapshot,
-    fetchExtras,
-  };
+    ['promise', 'pendingExtras', 'didLoad'],
+    ['gen'],
+  );
 };
 
 module.exports = { isAbortError, createLoadCoordinator };

package/lib/session/navigation.js

@@ -1,16 +1,19 @@
 'use strict';
 
 const files = require('../files.js');
-const { itemPath, isTodoItem, isTodosEntry, TODO_FILE } = files;
+const { listPath, isTodoItem, isTodosEntry, TODO_FILE } = files;
 
 const initialState = (options = {}) => ({
   pane: options.startPane ?? 'files',
   index: 0,
   fileCursor: 0,
   branchCursor: 0,
+  commitCursor: 0,
   scroll: 0,
   listScroll: 0,
   reviewPath: null,
+  fileScope: 'diff',
+  unitLine: 0,
   selection: null,
   mouseAnchor: null,
   pendingClick: null,
@@ -29,12 +32,21 @@ const clampIndex = (nav, length) => {
 
 const current = (nav, items, todoItem) => {
   if (nav.todoOpen) return todoItem;
+  if (nav.pane === 'unit' && nav.reviewPath) {
+    const item = items[nav.index];
+    if (item && listPath(item) === nav.reviewPath) return item;
+    for (const entry of items) {
+      if (listPath(entry) === nav.reviewPath) return entry;
+    }
+    return null;
+  }
   return items[nav.index] ?? null;
 };
 
 const syncReviewPath = (nav, item) => {
-  if (nav.pane !== 'diff') return;
-  nav.reviewPath = item ? itemPath(item) : null;
+  if (nav.pane !== 'diff' && nav.pane !== 'unit') return;
+  if (nav.pane === 'unit' && nav.reviewPath) return;
+  nav.reviewPath = item ? listPath(item) : null;
 };
 
 const clampFileCursor = (nav, length) => {