reslop 0.2.5 → 0.2.7

package/lib/git-branches.js

@@ -4,10 +4,12 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
+const utilities = require('./utilities.js');
+const { oneLine } = utilities;
 const files = require('./files.js');
-const gitWorktree = require('./git-worktree.js');
 const { shortAge } = files;
-const { oneLine, requireOk, runGit, runGitAsync } = gitWorktree;
+const worktree = require('./git-worktree.js');
+const { requireOk, runGit, command, gitOp } = worktree;
 
 const BRANCH_FORMAT = [
   '%(HEAD)',
@@ -17,25 +19,14 @@ const BRANCH_FORMAT = [
   '%(upstream:track)',
   '%(subject)',
 ].join('%09');
-const TRACK_AHEAD = /ahead (\d+)/;
-const TRACK_BEHIND = /behind (\d+)/;
 const ORIGIN_HEAD = 'refs/remotes/origin/HEAD';
+const ORIGIN_PREFIX = 'origin/';
 const DEFAULT_BRANCHES = ['main', 'master'];
 const PUSH_REJECTED = [
   'non-fast-forward',
   'failed to push some refs',
   'updates were rejected',
 ];
-
-const commitMessage = (top, sha) => {
-  const spec = `${sha ?? ''}`.trim() || 'HEAD';
-  const result = runGit(['log', '-1', '--format=%B', spec], top);
-  if (result.status !== 0) return '';
-  return (result.stdout ?? '').replace(/\s+$/, '');
-};
-
-const lastMessage = (top) => commitMessage(top, 'HEAD');
-
 const COMMIT_FIELDS = ['%H', '%h', '%an', '%ae', '%ar', '%ci', '%D', '%s'];
 const COMMIT_FORMAT = `${COMMIT_FIELDS.join('%x1f')}%x1e%B`;
 const COMMIT_LIMIT = 256;
@@ -43,42 +34,72 @@ const UNIT = '\x1f';
 const RECORD = '\x1e';
 const TAG_REF = /^tag: /;
 const REMOTE_HEAD = /\/HEAD(?: -> |$)/;
+const STAT_LEAD = /^\n* *\d+ files? changed[^\n]*\n?/;
+const FIXUP_MARK = 'fixup!';
+const AUTOSQUASH_ARGS = [
+  '-c',
+  'sequence.editor=:',
+  'rebase',
+  '--interactive',
+  '--autosquash',
+];
+const REWORD_TODO = path.join(__dirname, 'git-reword-todo.js');
+
+const trimText = (value) => `${value ?? ''}`.trim();
+
+const required = (value, message) => {
+  const text = trimText(value);
+  if (!text) throw new Error(message);
+  return text;
+};
+
+const branchName = (name) => required(name, 'empty branch name');
+
+const messageBody = (message) => {
+  const text = `${message ?? ''}`;
+  return text.endsWith('\n') ? text : `${text}\n`;
+};
+
+const commitMessage = (top, sha) => {
+  const spec = trimText(sha) || 'HEAD';
+  const result = runGit(['log', '-1', '--format=%B', spec], top);
+  return result.status === 0 ? result.stdout.trimEnd() : '';
+};
+
+const lastMessage = (top) => commitMessage(top, 'HEAD');
+
+const isShownRef = (name) => {
+  if (!name || TAG_REF.test(name)) return false;
+  return name === 'HEAD' || !REMOTE_HEAD.test(name);
+};
 
 const formatCommitRefs = (raw) => {
-  const text = `${raw ?? ''}`.trim();
-  if (!text) return '';
-  const names = [];
-  for (const part of text.split(', ')) {
-    const name = part.trim();
-    if (!name || TAG_REF.test(name)) continue;
-    if (name !== 'HEAD' && REMOTE_HEAD.test(name)) continue;
-    names.push(name);
-  }
-  return names.join(', ');
+  const names = trimText(raw).split(', ');
+  return names
+    .map((name) => name.trim())
+    .filter(isShownRef)
+    .join(', ');
 };
 
 const parseCommitRecord = (record, index) => {
   const cut = record.indexOf(RECORD);
   if (cut < 0) return null;
-  const parts = record.slice(0, cut).split(UNIT);
-  if (parts.length < COMMIT_FIELDS.length) return null;
-  const sha = (parts[0] ?? '').trim();
-  if (!sha) return null;
-  const body = record.slice(cut + 1).replace(/\s+$/, '');
-  const read = (spec) => {
-    const at = COMMIT_FIELDS.indexOf(spec);
-    return (parts[at] ?? '').trim();
-  };
-  const subject = read('%s') || body.split('\n')[0].trim();
+  const parts = record
+    .slice(0, cut)
+    .split(UNIT)
+    .map((part) => part.trim());
+  if (parts.length < COMMIT_FIELDS.length || !parts[0]) return null;
+  const sha = parts[0];
+  const body = record.slice(cut + 1).trimEnd();
   return {
     sha,
-    shortSha: read('%h') || sha.slice(0, 7),
-    author: read('%an'),
-    email: read('%ae'),
-    date: shortAge(read('%ar')),
-    when: read('%ci'),
-    refs: formatCommitRefs(read('%D')),
-    subject,
+    shortSha: parts[1] || sha.slice(0, 7),
+    author: parts[2],
+    email: parts[3],
+    date: shortAge(parts[4]),
+    when: parts[5],
+    refs: formatCommitRefs(parts[6]),
+    subject: parts[7] || body.split('\n')[0].trim(),
     body,
     added: 0,
     removed: 0,
@@ -86,25 +107,11 @@ const parseCommitRecord = (record, index) => {
   };
 };
 
-const STAT_LEAD = /^\n* *\d+ files? changed[^\n]*\n?/;
-
-const takeStat = (chunk) => {
-  const match = STAT_LEAD.exec(chunk);
-  if (!match) return { stat: '', rest: chunk };
-  return { stat: match[0], rest: chunk.slice(match[0].length) };
-};
-
-const countIn = (line, word) => {
-  const match = new RegExp(`(\\d+) ${word}`).exec(line);
-  if (!match) return 0;
-  return parseInt(match[1], 10);
+const statCount = (stat, word) => {
+  const match = new RegExp(`(\\d+) ${word}`).exec(stat);
+  return match ? parseInt(match[1], 10) : 0;
 };
 
-const parseShortstat = (line) => ({
-  added: countIn(line, 'insertion'),
-  removed: countIn(line, 'deletion'),
-});
-
 const listCommits = (top) => {
   const args = [
     'log',
@@ -116,257 +123,62 @@ const listCommits = (top) => {
   const result = requireOk(runGit(args, top), 'log failed');
   const commits = [];
   for (const chunk of result.stdout.split('\0')) {
-    const taken = takeStat(chunk);
-    if (taken.stat && commits.length) {
-      const stat = parseShortstat(taken.stat);
-      const last = commits[commits.length - 1];
-      last.added = stat.added;
-      last.removed = stat.removed;
+    const stat = STAT_LEAD.exec(chunk);
+    const last = commits.at(-1);
+    if (stat && last) {
+      last.added = statCount(stat[0], 'insertion');
+      last.removed = statCount(stat[0], 'deletion');
     }
-    if (!taken.rest) continue;
-    const entry = parseCommitRecord(taken.rest, commits.length);
+    const rest = stat ? chunk.slice(stat[0].length) : chunk;
+    if (!rest) continue;
+    const entry = parseCommitRecord(rest, commits.length);
     if (entry) commits.push(entry);
   }
   return commits;
 };
 
-const namedCommit = (sha) => {
-  const commit = `${sha ?? ''}`.trim();
-  if (!commit) throw new Error('empty commit');
-  return commit;
-};
-
-const resolveCommit = (top, sha) => {
-  const result = requireOk(runGit(['rev-parse', sha], top), 'rev-parse failed');
-  return (result.stdout ?? '').trim();
-};
-
-const dropHeadCommit = (top) => {
-  requireOk(runGit(['reset', '--soft', 'HEAD~1'], top), 'drop failed');
-};
-
-const runRebase = (top, args, extra = {}) => {
-  const result = runGit(args, top, undefined, extra);
-  if (result.status === 0) return;
-  runGit(['rebase', '--abort'], top);
-  requireOk(result, 'rebase failed');
-};
-
-const runRebaseAsync = async (top, args, extra = {}) => {
-  const result = await runGitAsync(args, top, extra);
-  if (result.status === 0) return;
-  await runGitAsync(['rebase', '--abort'], top);
-  requireOk(result, 'rebase failed');
-};
-
-const dropTarget = (top, sha) => {
-  const target = resolveCommit(top, namedCommit(sha));
-  const parent = runGit(['rev-parse', '--verify', `${target}^`], top);
-  if (parent.status !== 0) throw new Error('cannot drop root commit');
-  return target;
-};
-
-const dropCommit = (top, sha) => {
-  const target = dropTarget(top, sha);
-  if (target === resolveCommit(top, 'HEAD')) return void dropHeadCommit(top);
-  runRebase(top, ['rebase', '--onto', `${target}^`, target]);
-};
-
-const dropCommitAsync = async (top, sha) => {
-  const target = dropTarget(top, sha);
-  if (target === resolveCommit(top, 'HEAD')) {
-    requireOk(await runGitAsync(['reset', '--soft', 'HEAD~1'], top));
-    return;
-  }
-  await runRebaseAsync(top, ['rebase', '--onto', `${target}^`, target]);
-};
-
-const FIXUP_MARK = 'fixup!';
-const AUTOSQUASH_ARGS = [
-  '-c',
-  'sequence.editor=:',
-  'rebase',
-  '--interactive',
-  '--autosquash',
-];
-
-const isFixupSubject = (subject) =>
-  `${subject ?? ''}`.trim().startsWith(FIXUP_MARK);
-
-const fixupRest = (subject) => {
-  let text = `${subject ?? ''}`.trim();
-  while (text.startsWith(FIXUP_MARK)) {
-    text = text.slice(FIXUP_MARK.length).trim();
-  }
-  return text;
-};
-
-const commitSubject = (top, sha) => {
-  const args = ['log', '-1', '--format=%s', sha];
-  const result = requireOk(runGit(args, top), 'log failed');
-  return (result.stdout ?? '').trim();
-};
-
-const ancestorWithSubject = (top, sha, want) => {
-  const args = ['log', '--format=%H%x1f%s', `${sha}^`];
-  const result = runGit(args, top);
-  if (result.status !== 0) return '';
-  for (const line of result.stdout.split('\n')) {
-    const cut = line.indexOf(UNIT);
-    if (cut < 0) continue;
-    const subject = line.slice(cut + 1).trim();
-    if (subject !== want) continue;
-    return line.slice(0, cut).trim();
-  }
-  return '';
-};
-
-const rebaseRange = (top, sha) => {
-  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
-  return parent.status === 0 ? [parent.stdout.trim()] : ['--root'];
-};
-
-const fixupArgs = (top, sha) => {
-  const commit = resolveCommit(top, namedCommit(sha));
-  const subject = commitSubject(top, commit);
-  if (!isFixupSubject(subject)) throw new Error('not a fixup commit');
-  const want = fixupRest(subject);
-  if (!want) throw new Error('no fixup target');
-  const original = ancestorWithSubject(top, commit, want);
-  if (!original) throw new Error('no fixup target');
-  return [...AUTOSQUASH_ARGS, ...rebaseRange(top, original)];
-};
-
-const applyFixup = (top, sha) => runRebase(top, fixupArgs(top, sha));
-
-const applyFixupAsync = async (top, sha) =>
-  runRebaseAsync(top, fixupArgs(top, sha));
-
-const messageBody = (message) => {
-  const text = `${message ?? ''}`;
-  return text.endsWith('\n') ? text : `${text}\n`;
-};
-
-const REWORD_HEAD_ARGS = ['commit', '--amend', '--only', '-F', '-'];
-
-const REWORD_TODO = path.join(__dirname, 'git-reword-todo.js');
-
-const prepareRewordEditor = (message) => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'reslop-reword-'));
-  const msgFile = path.join(dir, 'MSG');
-  fs.writeFileSync(msgFile, messageBody(message));
-  const node = JSON.stringify(process.execPath);
-  const script = JSON.stringify(REWORD_TODO);
+const parseTrack = (text) => {
+  const raw = trimText(text).replace(/^\[|\]$/g, '');
+  const ahead = /ahead (\d+)/.exec(raw);
+  const behind = /behind (\d+)/.exec(raw);
   return {
-    dir,
-    env: {
-      GIT_SEQUENCE_EDITOR: `${node} ${script}`,
-      RESLOP_REWORD_FILE: msgFile,
-    },
+    ahead: ahead ? Number(ahead[1]) : 0,
+    behind: behind ? Number(behind[1]) : 0,
+    gone: raw === 'gone',
   };
 };
 
-const rewordOlder = (top, sha, message) => {
-  const prepared = prepareRewordEditor(message);
-  try {
-    const args = ['rebase', '--interactive', ...rebaseRange(top, sha)];
-    runRebase(top, args, { env: prepared.env });
-  } finally {
-    fs.rmSync(prepared.dir, { recursive: true, force: true });
-  }
-};
-
-const rewordOlderAsync = async (top, sha, message) => {
-  const prepared = prepareRewordEditor(message);
-  try {
-    const args = ['rebase', '--interactive', ...rebaseRange(top, sha)];
-    await runRebaseAsync(top, args, { env: prepared.env });
-  } finally {
-    fs.rmSync(prepared.dir, { recursive: true, force: true });
-  }
-};
-
-const rewordCommit = (top, sha, message) => {
-  const commit = resolveCommit(top, namedCommit(sha));
-  if (commit === resolveCommit(top, 'HEAD')) {
-    requireOk(runGit(REWORD_HEAD_ARGS, top, messageBody(message)));
-    return;
-  }
-  rewordOlder(top, commit, message);
-};
-
-const rewordCommitAsync = async (top, sha, message) => {
-  const commit = resolveCommit(top, namedCommit(sha));
-  if (commit === resolveCommit(top, 'HEAD')) {
-    const input = messageBody(message);
-    requireOk(await runGitAsync(REWORD_HEAD_ARGS, top, { input }));
-    return;
-  }
-  await rewordOlderAsync(top, commit, 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();
+  const name = trimText(parts[1]);
   if (!name) return null;
-  const mark = parts[0] ?? '';
-  const sha = (parts[2] ?? '').trim();
-  const date = shortAge(parts[3] ?? '');
-  const track = parseTrack(parts[4]);
-  const subject = parts.slice(5).join('\t').trim();
   return {
     name,
-    current: mark.includes('*'),
+    current: parts[0].includes('*'),
     isDefault: false,
-    sha,
-    date,
-    subject,
-    ...track,
+    sha: trimText(parts[2]),
+    date: shortAge(parts[3]),
+    subject: parts.slice(5).join('\t').trim(),
+    ...parseTrack(parts[4]),
   };
 };
 
-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);
+  const result = runGit(['symbolic-ref', '--short', ORIGIN_HEAD], top);
+  const ref = result.status === 0 ? result.stdout.trim() : '';
+  const remote = ref.startsWith(ORIGIN_PREFIX)
+    ? ref.slice(ORIGIN_PREFIX.length)
+    : ref;
   if (names.has(remote)) return remote;
-  for (const name of DEFAULT_BRANCHES) {
-    if (names.has(name)) return name;
-  }
-  return '';
+  return DEFAULT_BRANCHES.find((name) => names.has(name)) ?? '';
 };
 
 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 lines = result.stdout.split('\n').filter(Boolean);
+  const branches = lines.map((line) => parseBranchLine(line)).filter(Boolean);
+  const names = new Set(branches.map((entry) => entry.name));
   const primary = defaultBranch(top, names);
   return branches.map((entry) => ({
     ...entry,
@@ -374,175 +186,201 @@ const listBranches = (top) => {
   }));
 };
 
-const namedBranch = (name) => {
-  const branch = `${name ?? ''}`.trim();
-  if (!branch) throw new Error('empty branch name');
-  return branch;
+const hasStaged = (top) => {
+  const result = runGit(['diff', '--cached', '--quiet'], top);
+  return result.status === 1;
 };
 
-const checkoutBranch = (top, name) => {
-  const branch = namedBranch(name);
-  requireOk(runGit(['checkout', branch], top), 'checkout failed');
-};
+function* resolveCommit(sha) {
+  const result = yield command(['rev-parse', sha]);
+  return requireOk(result, 'rev-parse failed').stdout.trim();
+}
 
-const checkoutBranchAsync = async (top, name) => {
-  const branch = namedBranch(name);
-  requireOk(await runGitAsync(['checkout', branch], top), 'checkout failed');
-};
+function* rebaseRange(sha) {
+  const parent = yield command(['rev-parse', '--verify', `${sha}^`]);
+  return parent.status === 0 ? [parent.stdout.trim()] : ['--root'];
+}
 
-const createBranch = (top, name) => {
-  const branch = namedBranch(name);
-  const args = ['checkout', '-b', branch];
-  requireOk(runGit(args, top), 'checkout failed');
-};
+function* rebase(args, extra) {
+  const result = yield command(args, extra);
+  if (result.status === 0) return;
+  yield command(['rebase', '--abort']);
+  requireOk(result, 'rebase failed');
+}
 
-const createBranchAsync = async (top, name) => {
-  const branch = namedBranch(name);
-  const args = ['checkout', '-b', branch];
-  requireOk(await runGitAsync(args, top), 'checkout failed');
-};
+const simpleOp = (toArgs, fallback) =>
+  gitOp(function* (...args) {
+    const result = yield command(toArgs(...args));
+    requireOk(result, fallback);
+  });
 
-const rebaseBranch = (top, onto) =>
-  runRebase(top, ['rebase', namedBranch(onto)]);
+const checkoutOp = simpleOp(
+  (name) => ['checkout', branchName(name)],
+  'checkout failed',
+);
 
-const rebaseBranchAsync = async (top, onto) =>
-  runRebaseAsync(top, ['rebase', namedBranch(onto)]);
+const createOp = simpleOp(
+  (name) => ['checkout', '-b', branchName(name)],
+  'checkout failed',
+);
 
-const dropBranch = (top, name) => {
-  const branch = namedBranch(name);
-  requireOk(runGit(['branch', '-D', branch], top), 'drop failed');
-};
+const dropBranchOp = simpleOp(
+  (name) => ['branch', '-D', branchName(name)],
+  'drop failed',
+);
 
-const dropBranchAsync = async (top, name) => {
-  const branch = namedBranch(name);
-  requireOk(await runGitAsync(['branch', '-D', branch], top), 'drop failed');
-};
+const pullOp = simpleOp(() => ['pull'], 'pull failed');
 
-const pullChanges = (top) => {
-  requireOk(runGit(['pull'], top), 'pull failed');
-};
+const rebaseOp = gitOp(function* (onto) {
+  yield* rebase(['rebase', branchName(onto)]);
+});
 
-const pullChangesAsync = async (top) => {
-  requireOk(await runGitAsync(['pull'], top), 'pull failed');
-};
+const commitOp = gitOp(function* (kind, message) {
+  const args = ['commit'];
+  if (kind === 'amend') args.push('--amend');
+  args.push('-F', '-');
+  const result = yield command(args, { input: messageBody(message) });
+  requireOk(result);
+});
 
-const isRejectedPush = (msg) => {
-  const text = `${msg ?? ''}`.toLowerCase();
-  for (const token of PUSH_REJECTED) {
-    if (text.includes(token)) return true;
+const dropCommitOp = gitOp(function* (sha) {
+  const target = yield* resolveCommit(required(sha, 'empty commit'));
+  const parent = yield command(['rev-parse', '--verify', `${target}^`]);
+  if (parent.status !== 0) throw new Error('cannot drop root commit');
+  if (target === (yield* resolveCommit('HEAD'))) {
+    const result = yield command(['reset', '--soft', 'HEAD~1']);
+    return void requireOk(result, 'drop failed');
   }
-  return false;
-};
+  yield* rebase(['rebase', '--onto', `${target}^`, target]);
+});
 
-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 fixupRest = (subject) => {
+  let text = subject;
+  while (text.startsWith(FIXUP_MARK)) {
+    text = text.slice(FIXUP_MARK.length).trim();
+  }
+  return text;
 };
 
-const pushBranch = (top) => {
-  const result = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], top);
-  const name = (result.stdout ?? '').trim();
-  if (!name || name === 'HEAD') return 'HEAD';
-  return name;
+const shaWithSubject = (log, subject) => {
+  for (const line of log.split('\n')) {
+    const cut = line.indexOf(UNIT);
+    if (cut < 0 || line.slice(cut + 1).trim() !== subject) continue;
+    return line.slice(0, cut).trim();
+  }
+  return '';
 };
 
-const hasUpstream = (top) => {
-  const args = [
-    'rev-parse',
-    '--abbrev-ref',
-    '--symbolic-full-name',
-    '@{upstream}',
-  ];
-  const result = runGit(args, top);
-  return result.status === 0;
+function* fixupTarget(commit) {
+  const shown = yield command(['log', '-1', '--format=%s', commit]);
+  const subject = requireOk(shown, 'log failed').stdout.trim();
+  if (!subject.startsWith(FIXUP_MARK)) throw new Error('not a fixup commit');
+  const want = fixupRest(subject);
+  if (!want) throw new Error('no fixup target');
+  const log = yield command(['log', '--format=%H%x1f%s', `${commit}^`]);
+  const original = log.status === 0 ? shaWithSubject(log.stdout, want) : '';
+  if (!original) throw new Error('no fixup target');
+  return original;
+}
+
+const fixupOp = gitOp(function* (sha) {
+  const commit = yield* resolveCommit(required(sha, 'empty commit'));
+  const original = yield* fixupTarget(commit);
+  const range = yield* rebaseRange(original);
+  yield* rebase([...AUTOSQUASH_ARGS, ...range]);
+});
+
+const rewordEnv = (msgFile) => {
+  const node = JSON.stringify(process.execPath);
+  const script = JSON.stringify(REWORD_TODO);
+  return {
+    GIT_SEQUENCE_EDITOR: `${node} ${script}`,
+    RESLOP_REWORD_FILE: msgFile,
+  };
 };
 
-const pushCmd = (force, branch) => {
+const rewordOp = gitOp(function* (sha, message) {
+  const commit = yield* resolveCommit(required(sha, 'empty commit'));
+  const input = messageBody(message);
+  if (commit === (yield* resolveCommit('HEAD'))) {
+    const args = ['commit', '--amend', '--only', '-F', '-'];
+    const result = yield command(args, { input });
+    return void requireOk(result);
+  }
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'reslop-reword-'));
+  try {
+    const msgFile = path.join(dir, 'MSG');
+    fs.writeFileSync(msgFile, input);
+    const range = yield* rebaseRange(commit);
+    const env = rewordEnv(msgFile);
+    yield* rebase(['rebase', '--interactive', ...range], { env });
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+const pushArgs = (force, branch) => {
   const args = ['push'];
   if (force) args.push('--force-with-lease');
   if (branch) args.push('--set-upstream', 'origin', branch);
   return args;
 };
 
-const noUpstream = (msg) =>
-  `${msg ?? ''}`.toLowerCase().includes('no upstream');
-
-const requirePushOk = (result) => {
-  if (result.status === 0) return;
-  throw pushError(result.stderr || result.stdout || 'push failed');
+const pushError = (text) => {
+  const lower = text.toLowerCase();
+  const rejected = PUSH_REJECTED.some((token) => lower.includes(token));
+  const message = rejected ? 'push rejected' : oneLine(text, 'git failed');
+  const error = new Error(message);
+  error.rejected = rejected;
+  return error;
 };
 
-const pushChanges = (top, force) => {
-  const useForce = force === true;
-  const branch = pushBranch(top);
-  const tracked = hasUpstream(top) ? '' : branch;
-  let result = runGit(pushCmd(useForce, tracked), top);
-  if (result.status !== 0 && noUpstream(result.stderr || result.stdout)) {
-    result = runGit(pushCmd(useForce, branch), top);
-  }
-  requirePushOk(result);
-};
+const UPSTREAM_ARGS = [
+  'rev-parse',
+  '--abbrev-ref',
+  '--symbolic-full-name',
+  '@{upstream}',
+];
 
-const pushChangesAsync = async (top, force) => {
+const pushOp = gitOp(function* (force) {
   const useForce = force === true;
-  const branch = pushBranch(top);
-  const tracked = hasUpstream(top) ? '' : branch;
-  let result = await runGitAsync(pushCmd(useForce, tracked), top);
-  if (result.status !== 0 && noUpstream(result.stderr || result.stdout)) {
-    result = await runGitAsync(pushCmd(useForce, branch), top);
+  const head = yield command(['rev-parse', '--abbrev-ref', 'HEAD']);
+  const branch = head.stdout.trim() || 'HEAD';
+  const upstream = yield command(UPSTREAM_ARGS);
+  const tracked = upstream.status === 0 ? '' : branch;
+  let result = yield command(pushArgs(useForce, tracked));
+  const output = (result.stderr || result.stdout).toLowerCase();
+  if (result.status !== 0 && output.includes('no upstream')) {
+    result = yield command(pushArgs(useForce, branch));
   }
-  requirePushOk(result);
-};
-
-const hasStaged = (top) => {
-  const result = runGit(['diff', '--cached', '--quiet'], top);
-  return result.status === 1;
-};
-
-const commitPlan = (kind, message) => {
-  const args = ['commit'];
-  if (kind === 'amend') args.push('--amend');
-  args.push('-F', '-');
-  return { args, body: messageBody(message) };
-};
-
-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 }));
-};
+  if (result.status === 0) return;
+  throw pushError(result.stderr || result.stdout || 'push failed');
+});
 
 module.exports = {
   lastMessage,
   commitMessage,
   listCommits,
   listBranches,
-  checkoutBranch,
-  checkoutBranchAsync,
-  createBranch,
-  createBranchAsync,
-  rebaseBranch,
-  rebaseBranchAsync,
-  dropCommit,
-  dropCommitAsync,
-  applyFixup,
-  applyFixupAsync,
-  rewordCommit,
-  rewordCommitAsync,
-  dropBranch,
-  dropBranchAsync,
-  pullChanges,
-  pullChangesAsync,
-  pushChanges,
-  pushChangesAsync,
   hasStaged,
-  commitChanges,
-  commitChangesAsync,
+  checkoutBranch: checkoutOp.sync,
+  checkoutBranchAsync: checkoutOp.async,
+  createBranch: createOp.sync,
+  createBranchAsync: createOp.async,
+  rebaseBranch: rebaseOp.sync,
+  rebaseBranchAsync: rebaseOp.async,
+  dropBranch: dropBranchOp.sync,
+  dropBranchAsync: dropBranchOp.async,
+  dropCommit: dropCommitOp.sync,
+  dropCommitAsync: dropCommitOp.async,
+  applyFixup: fixupOp.sync,
+  applyFixupAsync: fixupOp.async,
+  rewordCommit: rewordOp.sync,
+  rewordCommitAsync: rewordOp.async,
+  pullChanges: pullOp.sync,
+  pullChangesAsync: pullOp.async,
+  pushChanges: pushOp.sync,
+  pushChangesAsync: pushOp.async,
+  commitChanges: commitOp.sync,
+  commitChangesAsync: commitOp.async,
 };