reslop 0.1.5 → 0.1.7

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,228 @@ 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 rebaseFailed = (result) => {
+  if (result.status === 0) return '';
+  return result.stderr || result.stdout || 'rebase failed';
+};
+
+const rebaseBranch = (top, onto) => {
+  const branch = namedBranch(onto);
+  const result = runGit(['rebase', branch], top);
+  const failed = rebaseFailed(result);
+  if (!failed) return;
+  runGit(['rebase', '--abort'], top);
+  throw new Error(oneLine(failed));
+};
+
+const rebaseBranchAsync = async (top, onto) => {
+  const branch = namedBranch(onto);
+  const result = await runGitAsync(['rebase', branch], top);
+  const failed = rebaseFailed(result);
+  if (!failed) return;
+  await runGitAsync(['rebase', '--abort'], top);
+  throw new Error(oneLine(failed));
+};
+
+const dropBranch = (top, name) => {
+  const branch = namedBranch(name);
+  requireOk(runGit(['branch', '-D', branch], top), 'drop failed');
+};
+
+const dropBranchAsync = async (top, name) => {
+  const branch = namedBranch(name);
+  requireOk(await runGitAsync(['branch', '-D', branch], top), 'drop 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 +1178,28 @@ 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,
+  rebase: rebaseBranch,
+  rebaseAsync: rebaseBranchAsync,
+  drop: dropBranch,
+  dropAsync: dropBranchAsync,
+  pull: pullChanges,
+  pullAsync: pullChangesAsync,
+  push: pushChanges,
+  pushAsync: pushChangesAsync,
 });
 
 module.exports = {
@@ -901,6 +1210,22 @@ module.exports = {
   unstageItem,
   revertItem,
   commitChanges,
+  commitChangesAsync,
+  hasStaged,
+  currentBranch,
   lastMessage,
+  listBranches,
+  checkoutBranch,
+  checkoutBranchAsync,
+  createBranch,
+  createBranchAsync,
+  rebaseBranch,
+  rebaseBranchAsync,
+  dropBranch,
+  dropBranchAsync,
+  pullChanges,
+  pullChangesAsync,
+  pushChanges,
+  pushChangesAsync,
   createGitRepo,
 };