reslop 0.2.0 → 0.2.3

package/lib/git-branches.js

@@ -1,5 +1,9 @@
 'use strict';
 
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
 const { oneLine, requireOk, runGit, runGitAsync } = require('./git.js');
 
 const BRANCH_FORMAT = [
@@ -20,27 +24,59 @@ const PUSH_REJECTED = [
   'updates were rejected',
 ];
 
-const lastMessage = (top) => {
-  const result = runGit(['log', '-1', '--format=%B'], top);
+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 COMMIT_FORMAT = ['%H', '%h', '%an', '%ar', '%s'].join('%x1f');
+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;
 const UNIT = '\x1f';
+const RECORD = '\x1e';
+const TAG_REF = /^tag: /;
+const REMOTE_HEAD = /\/HEAD(?: -> |$)/;
+
+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 parseCommitLine = (line, index) => {
-  const parts = line.split(UNIT);
-  if (parts.length < 5) return null;
+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();
   return {
     sha,
-    shortSha: (parts[1] ?? '').trim() || sha.slice(0, 7),
-    author: (parts[2] ?? '').trim(),
-    date: (parts[3] ?? '').trim(),
-    subject: parts.slice(4).join(UNIT).trim(),
+    shortSha: read('%h') || sha.slice(0, 7),
+    author: read('%an'),
+    email: read('%ae'),
+    date: read('%ar'),
+    when: read('%ci'),
+    refs: formatCommitRefs(read('%D')),
+    subject,
+    body,
     head: index === 0,
   };
 };
@@ -48,14 +84,15 @@ const parseCommitLine = (line, index) => {
 const listCommits = (top) => {
   const args = [
     'log',
+    '-z',
     `--format=${COMMIT_FORMAT}`,
     `--max-count=${COMMIT_LIMIT}`,
   ];
   const result = requireOk(runGit(args, top), 'log failed');
   const commits = [];
-  for (const line of result.stdout.split('\n')) {
-    if (!line) continue;
-    const entry = parseCommitLine(line, commits.length);
+  for (const record of result.stdout.split('\0')) {
+    if (!record) continue;
+    const entry = parseCommitRecord(record, commits.length);
     if (entry) commits.push(entry);
   }
   return commits;
@@ -120,6 +157,179 @@ const dropCommitAsync = async (top, sha) => {
   await dropOlderCommitAsync(top, 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 applyAutosquash = (top, ontoArgs) => {
+  const result = runGit([...AUTOSQUASH_ARGS, ...ontoArgs], top);
+  const failed = rebaseFailed(result);
+  if (!failed) return;
+  runGit(['rebase', '--abort'], top);
+  throw new Error(oneLine(failed));
+};
+
+const applyAutosquashAsync = async (top, ontoArgs) => {
+  const result = await runGitAsync([...AUTOSQUASH_ARGS, ...ontoArgs], top);
+  const failed = rebaseFailed(result);
+  if (!failed) return;
+  await runGitAsync(['rebase', '--abort'], top);
+  throw new Error(oneLine(failed));
+};
+
+const applyFixupOnto = (top, original, applyRange) => {
+  const parent = runGit(['rev-parse', '--verify', `${original}^`], top);
+  if (parent.status !== 0) return applyRange(top, ['--root']);
+  return applyRange(top, [(parent.stdout ?? '').trim()]);
+};
+
+const applyFixup = (top, sha) => {
+  const spec = namedCommit(sha);
+  const commit = resolveCommit(top, spec);
+  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');
+  applyFixupOnto(top, original, applyAutosquash);
+};
+
+const applyFixupAsync = async (top, sha) => {
+  const spec = namedCommit(sha);
+  const commit = resolveCommit(top, spec);
+  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');
+  await applyFixupOnto(top, original, applyAutosquashAsync);
+};
+
+const messageBody = (message) => {
+  const text = `${message ?? ''}`;
+  return text.endsWith('\n') ? text : `${text}\n`;
+};
+
+const rewordHead = (top, message) => {
+  const args = ['commit', '--amend', '--only', '-F', '-'];
+  requireOk(runGit(args, top, messageBody(message)));
+};
+
+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);
+  return {
+    dir,
+    env: {
+      GIT_SEQUENCE_EDITOR: `${node} ${script}`,
+      RESLOP_REWORD_FILE: msgFile,
+    },
+  };
+};
+
+const rewordRange = (top, sha, env) => {
+  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
+  const onto =
+    parent.status !== 0 ? ['--root'] : [(parent.stdout ?? '').trim()];
+  return runGit(['rebase', '--interactive', ...onto], top, undefined, { env });
+};
+
+const rewordRangeAsync = async (top, sha, env) => {
+  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
+  const onto =
+    parent.status !== 0 ? ['--root'] : [(parent.stdout ?? '').trim()];
+  return runGitAsync(['rebase', '--interactive', ...onto], top, { env });
+};
+
+const finishRewordRebase = (top, result) => {
+  const failed = rebaseFailed(result);
+  if (!failed) return;
+  runGit(['rebase', '--abort'], top);
+  throw new Error(oneLine(failed));
+};
+
+const rewordOlder = (top, sha, message) => {
+  const prepared = prepareRewordEditor(message);
+  try {
+    const result = rewordRange(top, sha, prepared.env);
+    finishRewordRebase(top, result);
+  } finally {
+    fs.rmSync(prepared.dir, { recursive: true, force: true });
+  }
+};
+
+const rewordOlderAsync = async (top, sha, message) => {
+  const prepared = prepareRewordEditor(message);
+  try {
+    const result = await rewordRangeAsync(top, sha, prepared.env);
+    const failed = rebaseFailed(result);
+    if (!failed) return;
+    await runGitAsync(['rebase', '--abort'], top);
+    throw new Error(oneLine(failed));
+  } finally {
+    fs.rmSync(prepared.dir, { recursive: true, force: true });
+  }
+};
+
+const rewordCommit = (top, sha, message) => {
+  const spec = namedCommit(sha);
+  const commit = resolveCommit(top, spec);
+  const head = resolveCommit(top, 'HEAD');
+  if (commit === head) return void rewordHead(top, message);
+  rewordOlder(top, commit, message);
+};
+
+const rewordCommitAsync = async (top, sha, message) => {
+  const spec = namedCommit(sha);
+  const commit = resolveCommit(top, spec);
+  const head = resolveCommit(top, 'HEAD');
+  if (commit === head) return void rewordHead(top, message);
+  await rewordOlderAsync(top, commit, message);
+};
+
 const parseTrack = (text) => {
   const raw = `${text ?? ''}`.trim().replace(/^\[|\]$/g, '');
   if (!raw) return { ahead: 0, behind: 0, gone: false };
@@ -338,10 +548,6 @@ const hasStaged = (top) => {
 };
 
 const commitPlan = (kind, message) => {
-  if (kind === 'fixup') {
-    const target = (message ?? '').trim() || 'HEAD';
-    return { args: ['commit', `--fixup=${target}`], body: undefined };
-  }
   const args = ['commit'];
   if (kind === 'amend') args.push('--amend');
   args.push('-F', '-');
@@ -362,6 +568,7 @@ const commitChangesAsync = async (top, kind, message) => {
 
 module.exports = {
   lastMessage,
+  commitMessage,
   listCommits,
   listBranches,
   checkoutBranch,
@@ -372,6 +579,10 @@ module.exports = {
   rebaseBranchAsync,
   dropCommit,
   dropCommitAsync,
+  applyFixup,
+  applyFixupAsync,
+  rewordCommit,
+  rewordCommitAsync,
   dropBranch,
   dropBranchAsync,
   pullChanges,

package/lib/git-reword-todo.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const fs = require('node:fs');
+
+const file = process.argv[process.argv.length - 1];
+const msg = process.env.RESLOP_REWORD_FILE;
+if (!file || !msg) process.exit(1);
+const text = fs.readFileSync(file, 'utf8');
+const rows = text.split('\n');
+const out = [];
+let seen = false;
+for (const row of rows) {
+  out.push(row);
+  if (seen) continue;
+  if (!/^(pick|p)\s+/.test(row)) continue;
+  const spec = JSON.stringify(msg);
+  out.push(`exec git commit --amend --only -F ${spec}`);
+  seen = true;
+}
+fs.writeFileSync(file, out.join('\n'));

package/lib/git.js

@@ -25,7 +25,7 @@ const GIT_MAX_BUFFER = proc.DEFAULT_MAX_BUFFER;
 
 const gitProcOptions = (cwd, extra = {}) => ({
   cwd,
-  env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+  env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...extra.env },
   encoding: GIT_ENCODING,
   maxBuffer: GIT_MAX_BUFFER,
   input: extra.input,
@@ -45,8 +45,8 @@ const requireOk = (result, fallback = 'git failed') => {
   throw new Error(oneLine(msg, fallback));
 };
 
-const runGit = (args, cwd, input) => {
-  const options = gitProcOptions(cwd, { input });
+const runGit = (args, cwd, input, extra = {}) => {
+  const options = gitProcOptions(cwd, { input, env: extra.env });
   return gitResult(runProcSync('git', args, options));
 };
 
@@ -503,6 +503,11 @@ const writeFile = (top, rel, text) => {
   writeWorktree(abs, text);
 };
 
+const stagePath = (top, rel) => {
+  if (!rel) return;
+  requireOk(runGit(['add', '--', rel], top));
+};
+
 module.exports = {
   oneLine,
   requireOk,
@@ -521,6 +526,7 @@ module.exports = {
   readSnapshotAsync,
   editItem,
   writeFile,
+  stagePath,
 };
 
 const branches = require('./git-branches.js');
@@ -590,10 +596,12 @@ const createGitRepo = () =>
       revertFile: revertGitFile,
       edit: editItem,
       writeFile,
+      stagePath,
       commit: branches.commitChanges,
       commitAsync: branches.commitChangesAsync,
       hasStaged: branches.hasStaged,
       lastMessage: branches.lastMessage,
+      commitMessage: branches.commitMessage,
       listBranches: branches.listBranches,
       listCommits: branches.listCommits,
       currentBranch,
@@ -607,6 +615,10 @@ const createGitRepo = () =>
       dropAsync: branches.dropBranchAsync,
       dropCommit: branches.dropCommit,
       dropCommitAsync: branches.dropCommitAsync,
+      applyFixup: branches.applyFixup,
+      applyFixupAsync: branches.applyFixupAsync,
+      reword: branches.rewordCommit,
+      rewordAsync: branches.rewordCommitAsync,
       pull: branches.pullChanges,
       pullAsync: branches.pullChangesAsync,
       push: branches.pushChanges,
@@ -628,6 +640,7 @@ module.exports.commitChangesAsync = branches.commitChangesAsync;
 module.exports.hasStaged = branches.hasStaged;
 module.exports.currentBranch = currentBranch;
 module.exports.lastMessage = branches.lastMessage;
+module.exports.commitMessage = branches.commitMessage;
 module.exports.listBranches = branches.listBranches;
 module.exports.listCommits = branches.listCommits;
 module.exports.checkoutBranch = branches.checkoutBranch;
@@ -640,6 +653,10 @@ module.exports.dropBranch = branches.dropBranch;
 module.exports.dropBranchAsync = branches.dropBranchAsync;
 module.exports.dropCommit = branches.dropCommit;
 module.exports.dropCommitAsync = branches.dropCommitAsync;
+module.exports.applyFixup = branches.applyFixup;
+module.exports.applyFixupAsync = branches.applyFixupAsync;
+module.exports.rewordCommit = branches.rewordCommit;
+module.exports.rewordCommitAsync = branches.rewordCommitAsync;
 module.exports.pullChanges = branches.pullChanges;
 module.exports.pullChangesAsync = branches.pullChangesAsync;
 module.exports.pushChanges = branches.pushChanges;

package/lib/keys.js

@@ -6,7 +6,7 @@ const { ACTIONS, ACTION_IDS, BRANCH_ACTIONS, COMMIT_ACTIONS } = actions;
 const { DIFF_DISABLED, FILES_DISABLED, FILES_GIT_DISABLED } = actions;
 const { FILES_HIDDEN, FILES_TODO_DISABLED, TODO_DISABLED, BRANCHES_DISABLED } =
   actions;
-const { COMMITS_DISABLED, UNIT_DISABLED } = actions;
+const { COMMITS_DISABLED, UNIT_DISABLED, NPM_DISABLED } = actions;
 const { disabledActions, diffGitDisabled, branchGitDisabled } = actions;
 const { commitGitDisabled } = actions;
 const { actionFromKey, actionHot, actionLetter, buttonWord } = actions;
@@ -65,15 +65,20 @@ const parseCsiSeq = (rest) => {
   return { params: body.slice(0, i), final: body[i], eat: 2 + i + 1 };
 };
 
+const ctrlHeld = (modText) => {
+  const mod = parseInt(modText, 10);
+  return Number.isFinite(mod) && ((mod - 1) & 4) !== 0;
+};
+
 const keyFromCsi = (paramsText, final) => {
   const params = paramsText ? paramsText.split(';') : [];
   if (final === '~') return CSI_TILDE[params[0]] ?? null;
   const base = CSI_KEYS[final];
   if (!base) return null;
   if (params.length < 2) return base;
-  const mod = parseInt(params[1], 10);
-  const ctrl = Number.isFinite(mod) && ((mod - 1) & 4) !== 0;
-  if (ctrl && (base === 'left' || base === 'right')) return `ctrl-${base}`;
+  const arrow =
+    base === 'left' || base === 'right' || base === 'up' || base === 'down';
+  if (ctrlHeld(params[1]) && arrow) return `ctrl-${base}`;
   return base;
 };
 
@@ -193,6 +198,7 @@ module.exports = {
   TODO_DISABLED,
   BRANCHES_DISABLED,
   COMMITS_DISABLED,
+  NPM_DISABLED,
   UNIT_DISABLED,
   disabledActions,
   diffGitDisabled,