reslop 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased][unreleased]
 
+## [0.1.6][] - 2026-09-15
+
+- Auto updates for patch/minor, y/n per new major
+- Lists branches, new branch, git pull, git push
+- Show TUI progress for long background operations
+- Fix Windows spawn EINVAL when running `npm.cmd`
+- Highlight Dart diffs; refactor syntax highlighting
+- Multiple TUI/TUX improvements and fixes
+
 ## [0.1.5][] - 2026-09-14
 
 - Added `r` to reload diffs from disk

package/README.md

@@ -51,13 +51,11 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 | Key                 | Action                                          |
 | ------------------- | ----------------------------------------------- |
-| `a`                 | Stage this diff (git add)                       |
-| `u`                 | Unstage this diff                               |
-| `d`                 | Drop this diff to the last commit               |
+| `a` / `u` / `d`     | Stage / unstage / drop this diff                |
 | `c`                 | Commit: then `c` commit / `a` amend / `f` fixup |
-| `f`                 | Feedback on this diff                           |
-| `t`                 | New todo                                        |
-| `e`                 | Edit added lines                                |
+| `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                          |

package/lib/cli.js

@@ -143,29 +143,33 @@ const openLocalSession = (proc, deps, args, selected, env) => {
   return session;
 };
 
-const openRemoteSession = async (proc, deps, args, selected, env) => {
+const remoteRepo = (deps, selected, env, cwd) => {
+  if (deps.repo) return deps.repo;
   const remote = REMOTE_CHANGE[selected.kind];
-  const cwd = deps.cwd ?? proc.cwd();
   const loader = deps[remote.load] ?? remote.fallback;
   const token = remote.token(env);
-  const loaded = await loader(remote.target(selected), {
-    cwd,
-    paths: selected.paths,
-    token,
-    fetch: deps.fetch,
-  });
-  const change = loaded.change ?? null;
-  const repository = change ? change.repository : '';
-  const repo = deps.repo ?? createLoadedSource(loaded);
+  const loadRemote = async () => {
+    const loaded = await loader(remote.target(selected), {
+      cwd,
+      paths: selected.paths,
+      token,
+      fetch: deps.fetch,
+    });
+    const items = loaded.items ?? [];
+    return { ...loaded, items: [...items] };
+  };
+  const repo = createLoadedSource({ items: [] });
+  repo.loadAsync = loadRemote;
+  return repo;
+};
+
+const openRemoteSession = (proc, deps, args, selected, env) => {
+  const cwd = deps.cwd ?? proc.cwd();
   return startSession(
     sessionOptions(proc, deps, args, env, {
-      repo,
+      repo: remoteRepo(deps, selected, env, cwd),
       paths: selected.paths,
-      repoName: repository,
-      sourceLabel: loaded.sourceLabel,
-      change,
     }),
-    { load: true },
   );
 };
 

package/lib/detect.js

@@ -2,40 +2,7 @@
 
 const path = require('node:path');
 
-const LANG = {
-  md: 'md',
-  markdown: 'md',
-  js: 'js',
-  javascript: 'js',
-  mjs: 'mjs',
-  cjs: 'js',
-  ts: 'ts',
-  typescript: 'ts',
-  jsx: 'jsx',
-  tsx: 'tsx',
-  json: 'json',
-  csv: 'csv',
-  html: 'html',
-  htm: 'html',
-  css: 'css',
-  sh: 'bash',
-  bash: 'bash',
-  shell: 'bash',
-  zsh: 'bash',
-  txt: 'txt',
-  text: 'txt',
-  plain: 'txt',
-  log: 'log',
-  env: 'dot',
-  ini: 'dot',
-  conf: 'dot',
-  cfg: 'dot',
-  yaml: 'dot',
-  yml: 'dot',
-  toml: 'dot',
-  py: 'py',
-  python: 'py',
-};
+const { mapLang } = require('./highlight.js');
 
 const PROSE_BASENAMES = [
   'license',
@@ -53,11 +20,6 @@ const fileExt = (filePath) => {
   return base.slice(dot + 1).toLowerCase();
 };
 
-const mapLang = (name) => {
-  if (!name) return 'txt';
-  return LANG[name.toLowerCase()] || 'txt';
-};
-
 const isProseBasename = (base) => {
   const name = (base || '').toLowerCase();
   if (PROSE_BASENAMES.includes(name)) return true;
@@ -79,7 +41,7 @@ const detectLang = (filePath) => {
     if (rule.test(base)) return rule.lang;
   }
   const ext = fileExt(base);
-  if (ext) return LANG[ext] || 'txt';
+  if (ext) return mapLang(ext);
   return 'dot';
 };
 

package/lib/files.js

@@ -57,6 +57,7 @@ const fileEntries = (items) => {
         path: rel,
         origins: [],
         firstIndex: i,
+        openIndex: i,
         remaining: 0,
         added: 0,
         removed: 0,
@@ -72,7 +73,10 @@ const fileEntries = (items) => {
     group.added += delta.added;
     group.removed += delta.removed;
     if (origin === 'staged') group.staged += 1;
-    if (origin === 'unstaged') group.unstaged += 1;
+    if (origin === 'unstaged') {
+      if (group.unstaged === 0) group.openIndex = i;
+      group.unstaged += 1;
+    }
   }
   const entries = [...groups.values()];
   for (const group of entries) {

package/lib/git.js

@@ -7,7 +7,7 @@ const path = require('node:path');
 const diff = require('./diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
 const { itemPath, isPathInScope, REVIEW_DIR } = require('./files.js');
-const { npmBin, spawnBase } = require('./sys.js');
+const { npmBin, spawnBase, npmOpts } = require('./sys.js');
 const deps = require('./deps.js');
 const { foldDepItems, mergeDepFile, depFileMeta } = deps;
 const { collectUsedNames, parseAuditReport, parseOutdatedReport } = deps;
@@ -25,6 +25,23 @@ const GIT_MAX_BUFFER = 32 * 1024 * 1024;
 const BINARY_SIZE = 1000000;
 const AUDIT_MS = 15000;
 const INSTALL_MS = 120000;
+const BRANCH_FORMAT = [
+  '%(HEAD)',
+  '%(refname:short)',
+  '%(objectname:short)',
+  '%(committerdate:relative)',
+  '%(upstream:track)',
+  '%(subject)',
+].join('%09');
+const TRACK_AHEAD = /ahead (\d+)/;
+const TRACK_BEHIND = /behind (\d+)/;
+const ORIGIN_HEAD = 'refs/remotes/origin/HEAD';
+const DEFAULT_BRANCHES = ['main', 'master'];
+const PUSH_REJECTED = [
+  'non-fast-forward',
+  'failed to push some refs',
+  'updates were rejected',
+];
 
 const oneLine = (text) => {
   const line = text.trim().split('\n')[0];
@@ -77,7 +94,15 @@ const runProc = (cmd, args, options = {}) =>
     let stderr = '';
     let settled = false;
     let timer = null;
-    const child = spawn(cmd, args, spawnBase({ cwd, env }));
+    const spawnOpts = { cwd, env };
+    if (options.shell) spawnOpts.shell = true;
+    let child;
+    try {
+      child = spawn(cmd, args, spawnBase(spawnOpts));
+    } catch (error) {
+      resolve({ status: null, error, stdout: '', stderr: '' });
+      return;
+    }
     const finish = (result) => {
       if (settled) return;
       settled = true;
@@ -284,7 +309,7 @@ const runNpmJson = (top, args, timeout) => {
   const result = spawnSync(
     npmBin(),
     args,
-    spawnBase({
+    npmOpts({
       cwd: top,
       encoding: GIT_ENCODING,
       maxBuffer: GIT_MAX_BUFFER,
@@ -302,6 +327,7 @@ const runNpmJsonAsync = async (top, args, timeout, signal) => {
     maxBuffer: GIT_MAX_BUFFER,
     timeout,
     signal,
+    shell: npmOpts().shell,
   });
   if (result.error) return '';
   return result.stdout || '';
@@ -456,7 +482,7 @@ const runNpm = (cwd, args) =>
   spawnSync(
     npmBin(),
     args,
-    spawnBase({
+    npmOpts({
       cwd,
       encoding: GIT_ENCODING,
       maxBuffer: GIT_MAX_BUFFER,
@@ -464,6 +490,15 @@ const runNpm = (cwd, args) =>
     }),
   );
 
+const runNpmAsync = (cwd, args) =>
+  runProc(npmBin(), args, {
+    cwd,
+    encoding: GIT_ENCODING,
+    maxBuffer: GIT_MAX_BUFFER,
+    timeout: INSTALL_MS,
+    shell: npmOpts().shell,
+  });
+
 const firstDepRel = (files, kind) => {
   for (const rel of files) {
     const meta = depFileMeta(rel);
@@ -472,7 +507,7 @@ const firstDepRel = (files, kind) => {
   return '';
 };
 
-const applyProposedUpdate = (top, item) => {
+const proposedNpmPlan = (top, item) => {
   const change = depChange(item);
   const origin = item.origin;
   const files = depPaths(item);
@@ -483,7 +518,7 @@ const applyProposedUpdate = (top, item) => {
   const picked = lockOnly ? lockRel : manifest;
   const target = picked || files[0] || '';
   const meta = depFileMeta(target);
-  if (!meta) return;
+  if (!meta) return null;
   let saved = '';
   if (!lockOnly && !removing && manifest) {
     const worktree = worktreeText(top, manifest);
@@ -503,9 +538,23 @@ const applyProposedUpdate = (top, item) => {
   let npmArgs = ['i'];
   if (removing) npmArgs = ['uninstall', change.name];
   else if (lockOnly) npmArgs = ['audit', 'fix'];
-  const install = item.dep.install ?? ((dir) => runNpm(dir, npmArgs));
-  const result = install(cwd);
   const fail = removing ? 'npm uninstall failed' : 'npm i failed';
+  const dirLock = meta.dir === '.' ? LOCKFILE : `${meta.dir}/${LOCKFILE}`;
+  const lockPath = lockRel || dirLock;
+  return {
+    cwd,
+    npmArgs,
+    saved,
+    manifest,
+    lockOnly,
+    lockPath,
+    fail,
+    runner: item.dep.install,
+  };
+};
+
+const finishProposedNpm = (top, plan, result) => {
+  const { saved, manifest, lockOnly, lockPath, fail } = plan;
   if (result && (result.error || result.status !== 0)) {
     if (saved && manifest) writeWorktreeFile(top, manifest, saved);
     if (result.error) {
@@ -517,12 +566,26 @@ const applyProposedUpdate = (top, item) => {
   }
   const toAdd = [];
   if (!lockOnly && manifest) toAdd.push(manifest);
-  const dirLock = meta.dir === '.' ? LOCKFILE : `${meta.dir}/${LOCKFILE}`;
-  const lockPath = lockRel || dirLock;
   if (fs.existsSync(path.join(top, lockPath))) toAdd.push(lockPath);
   if (toAdd.length) requireOk(runGit(['add', '--', ...toAdd], top));
 };
 
+const applyProposedUpdate = (top, item) => {
+  const plan = proposedNpmPlan(top, item);
+  if (!plan) return;
+  const install = plan.runner ?? ((dir) => runNpm(dir, plan.npmArgs));
+  finishProposedNpm(top, plan, install(plan.cwd));
+};
+
+const applyProposedUpdateAsync = async (top, item) => {
+  const plan = proposedNpmPlan(top, item);
+  if (!plan) return;
+  const run = plan.runner
+    ? (dir) => Promise.resolve(plan.runner(dir))
+    : (dir) => runNpmAsync(dir, plan.npmArgs);
+  finishProposedNpm(top, plan, await run(plan.cwd));
+};
+
 const applyDepChange = (top, item, mode) => {
   const change = depChange(item);
   if (change && change.propose) {
@@ -579,6 +642,15 @@ const commitDiffArgs = (commit, parent, pathArgs) => {
 
 const pathArgsOf = (paths) => (paths.length ? ['--', ...paths] : []);
 
+const currentBranch = (top) => {
+  const args = ['rev-parse', '--abbrev-ref', 'HEAD'];
+  const result = runGit(args, top);
+  if (result.status !== 0) return '';
+  const name = result.stdout.trim();
+  if (!name || name === 'HEAD') return '';
+  return name;
+};
+
 const snapshotWorktree = (top, stagedOut, unstagedOut, names) => {
   const stagedDiff = parseDiff(stagedOut);
   const unstagedDiff = parseDiff(unstagedOut);
@@ -587,14 +659,16 @@ const snapshotWorktree = (top, stagedOut, unstagedOut, names) => {
   const untracked = untrackedItemsFrom(top, names);
   const combined = mergeItems([staged, unstaged, untracked]);
   const parsed = dropReviewItems(combined);
-  return { top, parsed };
+  const branch = currentBranch(top);
+  return { top, parsed, branch };
 };
 
 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 branch = currentBranch(top);
+  return { top, parsed, rev: commit, revShort, branch };
 };
 
 const loadCommit = (top, commit, extra) => {
@@ -746,6 +820,16 @@ const addItem = (top, item) => {
   applyPatch(top, item.patchAdd, ['--cached']);
 };
 
+const addItemAsync = async (top, item) => {
+  if (item.origin === 'staged' || item.origin === 'commit') return;
+  const change = depChange(item);
+  if (change && change.propose) {
+    await applyProposedUpdateAsync(top, item);
+    return;
+  }
+  addItem(top, item);
+};
+
 const unstageItem = (top, item) => {
   if (item.origin !== 'staged') return;
   if (depChange(item)) {
@@ -851,20 +935,195 @@ const lastMessage = (top) => {
   return (result.stdout ?? '').replace(/\s+$/, '');
 };
 
-const commitChanges = (top, kind, message) => {
+const parseTrack = (text) => {
+  const raw = `${text ?? ''}`.trim().replace(/^\[|\]$/g, '');
+  if (!raw) return { ahead: 0, behind: 0, gone: false };
+  if (raw === 'gone') return { ahead: 0, behind: 0, gone: true };
+  const aheadMatch = TRACK_AHEAD.exec(raw);
+  const behindMatch = TRACK_BEHIND.exec(raw);
+  const ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+  const behind = behindMatch ? Number(behindMatch[1]) : 0;
+  return { ahead, behind, gone: false };
+};
+
+const parseBranchLine = (line) => {
+  const parts = line.split('\t');
+  if (parts.length < 2) return null;
+  const name = (parts[1] ?? '').trim();
+  if (!name) return null;
+  const mark = parts[0] ?? '';
+  const sha = (parts[2] ?? '').trim();
+  const date = (parts[3] ?? '').trim();
+  const track = parseTrack(parts[4]);
+  const subject = parts.slice(5).join('\t').trim();
+  return {
+    name,
+    current: mark.includes('*'),
+    isDefault: false,
+    sha,
+    date,
+    subject,
+    ...track,
+  };
+};
+
+const originHead = (top) => {
+  const args = ['symbolic-ref', '--short', ORIGIN_HEAD];
+  const result = runGit(args, top);
+  if (result.status !== 0) return '';
+  const ref = result.stdout.trim();
+  const prefix = 'origin/';
+  if (ref.startsWith(prefix)) return ref.slice(prefix.length);
+  return ref;
+};
+
+const defaultBranch = (top, names) => {
+  const remote = originHead(top);
+  if (names.has(remote)) return remote;
+  for (const name of DEFAULT_BRANCHES) {
+    if (names.has(name)) return name;
+  }
+  return '';
+};
+
+const listBranches = (top) => {
+  const args = ['for-each-ref', `--format=${BRANCH_FORMAT}`, 'refs/heads'];
+  const result = requireOk(runGit(args, top), 'branch failed');
+  const branches = [];
+  for (const line of result.stdout.split('\n')) {
+    if (!line) continue;
+    const entry = parseBranchLine(line);
+    if (entry) branches.push(entry);
+  }
+  const names = new Set();
+  for (const entry of branches) names.add(entry.name);
+  const primary = defaultBranch(top, names);
+  for (const entry of branches) {
+    entry.isDefault = entry.name === primary;
+  }
+  return branches;
+};
+
+const namedBranch = (name) => {
+  const branch = `${name ?? ''}`.trim();
+  if (!branch) throw new Error('empty branch name');
+  return branch;
+};
+
+const checkoutBranch = (top, name) => {
+  const branch = namedBranch(name);
+  requireOk(runGit(['checkout', branch], top), 'checkout failed');
+};
+
+const checkoutBranchAsync = async (top, name) => {
+  const branch = namedBranch(name);
+  requireOk(await runGitAsync(['checkout', branch], top), 'checkout failed');
+};
+
+const createBranch = (top, name) => {
+  const branch = namedBranch(name);
+  const args = ['checkout', '-b', branch];
+  requireOk(runGit(args, top), 'checkout failed');
+};
+
+const createBranchAsync = async (top, name) => {
+  const branch = namedBranch(name);
+  const args = ['checkout', '-b', branch];
+  requireOk(await runGitAsync(args, top), 'checkout failed');
+};
+
+const pullChanges = (top) => {
+  requireOk(runGit(['pull'], top), 'pull failed');
+};
+
+const pullChangesAsync = async (top) => {
+  requireOk(await runGitAsync(['pull'], top), 'pull failed');
+};
+
+const isRejectedPush = (msg) => {
+  const text = `${msg ?? ''}`.toLowerCase();
+  for (const token of PUSH_REJECTED) {
+    if (text.includes(token)) return true;
+  }
+  return false;
+};
+
+const pushError = (msg) => {
+  const text = `${msg ?? ''}`;
+  const rejected = isRejectedPush(text);
+  const error = new Error(rejected ? 'push rejected' : oneLine(text));
+  error.rejected = rejected;
+  return error;
+};
+
+const pushCmd = (force) => {
+  if (force) return ['push', '--force-with-lease'];
+  return ['push'];
+};
+
+const pushUpstreamCmd = (force) => {
+  if (force) return ['push', '--force-with-lease', '-u', 'origin', 'HEAD'];
+  return ['push', '-u', 'origin', 'HEAD'];
+};
+
+const finishPush = (result, force, run) => {
+  if (result.status === 0) return;
+  const msg = result.stderr || result.stdout || 'push failed';
+  if (!msg.toLowerCase().includes('no upstream')) {
+    throw pushError(msg);
+  }
+  const next = run(pushUpstreamCmd(force));
+  if (next.status !== 0) {
+    throw pushError(next.stderr || next.stdout || 'push failed');
+  }
+};
+
+const pushChanges = (top, force) => {
+  const useForce = force === true;
+  const result = runGit(pushCmd(useForce), top);
+  finishPush(result, useForce, (args) => runGit(args, top));
+};
+
+const pushChangesAsync = async (top, force) => {
+  const useForce = force === true;
+  const result = await runGitAsync(pushCmd(useForce), top);
+  if (result.status === 0) return;
+  const msg = result.stderr || result.stdout || 'push failed';
+  if (!msg.toLowerCase().includes('no upstream')) {
+    throw pushError(msg);
+  }
+  const next = await runGitAsync(pushUpstreamCmd(useForce), top);
+  if (next.status !== 0) {
+    throw pushError(next.stderr || next.stdout || 'push failed');
+  }
+};
+
+const hasStaged = (top) => {
+  const result = runGit(['diff', '--cached', '--quiet'], top);
+  return result.status === 1;
+};
+
+const commitPlan = (kind, message) => {
   if (kind === 'fixup') {
     const target = (message ?? '').trim() || 'HEAD';
-    const result = runGit(['commit', `--fixup=${target}`], top);
-    requireOk(result);
-    return;
+    return { args: ['commit', `--fixup=${target}`], body: undefined };
   }
   const args = ['commit'];
   if (kind === 'amend') args.push('--amend');
   args.push('-F', '-');
   const text = message ?? '';
   const body = text.endsWith('\n') ? text : `${text}\n`;
-  const result = runGit(args, top, body);
-  requireOk(result);
+  return { args, body };
+};
+
+const commitChanges = (top, kind, message) => {
+  const plan = commitPlan(kind, message);
+  requireOk(runGit(plan.args, top, plan.body));
+};
+
+const commitChangesAsync = async (top, kind, message) => {
+  const plan = commitPlan(kind, message);
+  requireOk(await runGitAsync(plan.args, top, { input: plan.body }));
 };
 
 const revertFile = (top, rel, items) => {
@@ -886,11 +1145,24 @@ const createGitRepo = () => ({
   toplevel,
   resolveRev,
   add: addItem,
+  addAsync: addItemAsync,
   unstage: unstageItem,
   revert: revertItem,
   revertFile,
   commit: commitChanges,
+  commitAsync: commitChangesAsync,
+  hasStaged,
   lastMessage,
+  listBranches,
+  currentBranch,
+  checkout: checkoutBranch,
+  checkoutAsync: checkoutBranchAsync,
+  createBranch,
+  createBranchAsync,
+  pull: pullChanges,
+  pullAsync: pullChangesAsync,
+  push: pushChanges,
+  pushAsync: pushChangesAsync,
 });
 
 module.exports = {
@@ -901,6 +1173,18 @@ module.exports = {
   unstageItem,
   revertItem,
   commitChanges,
+  commitChangesAsync,
+  hasStaged,
+  currentBranch,
   lastMessage,
+  listBranches,
+  checkoutBranch,
+  checkoutBranchAsync,
+  createBranch,
+  createBranchAsync,
+  pullChanges,
+  pullChangesAsync,
+  pushChanges,
+  pushChangesAsync,
   createGitRepo,
 };