reslop 0.1.4 → 0.1.6

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)) {
@@ -845,6 +929,203 @@ const revertItem = (top, item) => {
   }
 };
 
+const lastMessage = (top) => {
+  const result = runGit(['log', '-1', '--format=%B'], top);
+  if (result.status !== 0) return '';
+  return (result.stdout ?? '').replace(/\s+$/, '');
+};
+
+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';
+    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`;
+  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) => {
   const paths = new Set([rel]);
   for (const item of items) {
@@ -864,9 +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 = {
@@ -876,5 +1172,19 @@ module.exports = {
   addItem,
   unstageItem,
   revertItem,
+  commitChanges,
+  commitChangesAsync,
+  hasStaged,
+  currentBranch,
+  lastMessage,
+  listBranches,
+  checkoutBranch,
+  checkoutBranchAsync,
+  createBranch,
+  createBranchAsync,
+  pullChanges,
+  pullChangesAsync,
+  pushChanges,
+  pushChangesAsync,
   createGitRepo,
 };

package/lib/highlight/bash.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const { SQUOTE, emit, wordStyle, readUntilNl } = require('./core.js');
+
+const langs = ['bash'];
+
+const aliases = {
+  sh: 'bash',
+  shell: 'bash',
+  zsh: 'bash',
+};
+
+const BASH_QUOTE = `${SQUOTE}\``;
+
+const KEYWORDS = [
+  'if',
+  'then',
+  'else',
+  'elif',
+  'fi',
+  'for',
+  'while',
+  'until',
+  'do',
+  'done',
+  'case',
+  'esac',
+  'function',
+  'select',
+  'in',
+  'time',
+  'coproc',
+];
+
+const BUILTINS = [
+  'echo',
+  'printf',
+  'cd',
+  'pwd',
+  'exit',
+  'export',
+  'source',
+  'alias',
+  'unalias',
+  'local',
+  'declare',
+  'typeset',
+  'readonly',
+  'unset',
+  'shift',
+  'read',
+  'test',
+  'true',
+  'false',
+  'exec',
+  'eval',
+  'set',
+  'trap',
+  'wait',
+  'kill',
+  'type',
+  'command',
+  'builtin',
+  'return',
+  'break',
+  'continue',
+  'pushd',
+  'popd',
+  'dirs',
+  'getopts',
+  'mapfile',
+  'readarray',
+  'let',
+  'umask',
+  'ulimit',
+  'fg',
+  'bg',
+  'jobs',
+  'hash',
+  'help',
+  'enable',
+  'caller',
+  'bind',
+  'compgen',
+  'complete',
+];
+
+const WORD_STYLE = {
+  ...wordStyle(KEYWORDS, 'control'),
+  ...wordStyle(BUILTINS, 'function'),
+};
+
+const readBashVar = (source, i) => {
+  if (source[i + 1] === '{') {
+    let j = i + 2;
+    while (j < source.length && source[j] !== '}') j += 1;
+    if (j < source.length) j += 1;
+    return { text: source.slice(i, j), end: j };
+  }
+  if (/[0-9#?$!*@-]/.test(source[i + 1] || '')) {
+    return { text: source.slice(i, i + 2), end: i + 2 };
+  }
+  let j = i + 1;
+  while (j < source.length && /[A-Za-z0-9_]/.test(source[j])) j += 1;
+  if (j === i + 1) return { text: '$', end: i + 1 };
+  return { text: source.slice(i, j), end: j };
+};
+
+const takeQuoted = (source, i) => {
+  const q = source[i];
+  let j = i + 1;
+  const n = source.length;
+  while (j < n && source[j] !== q) j += 1;
+  if (j < n) j += 1;
+  return { text: source.slice(i, j), end: j };
+};
+
+const takeBashDouble = (source, i, out) => {
+  let j = i + 1;
+  let chunk = '"';
+  const n = source.length;
+  while (j < n && source[j] !== '"') {
+    if (source[j] === '\\' && j + 1 < n) {
+      chunk += source.slice(j, j + 2);
+      j += 2;
+      continue;
+    }
+    if (source[j] === '$') {
+      emit(out, 'string', chunk);
+      chunk = '';
+      const { text, end } = readBashVar(source, j);
+      emit(out, 'variable', text);
+      j = end;
+      continue;
+    }
+    chunk += source[j];
+    j += 1;
+  }
+  if (j < n) {
+    chunk += '"';
+    j += 1;
+  }
+  if (chunk) emit(out, 'string', chunk);
+  return j;
+};
+
+const bashWordStyle = (word, nextCh) => {
+  const known = WORD_STYLE[word];
+  if (known) return known;
+  if (nextCh === '=') return 'variable';
+  return 'plain';
+};
+
+const bashOpLen = (ch, next) => ('|&><'.includes(ch) && next === ch ? 2 : 1);
+
+const highlight = (source) => {
+  const out = [];
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    const next = source[i + 1];
+
+    if (ch === '#' && (i === 0 || /\s/.test(source[i - 1]))) {
+      const { text, end } = readUntilNl(source, i);
+      emit(out, 'comment', text);
+      i = end;
+      continue;
+    }
+
+    if (BASH_QUOTE.includes(ch)) {
+      const { text, end } = takeQuoted(source, i);
+      emit(out, 'string', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '"') {
+      i = takeBashDouble(source, i, out);
+      continue;
+    }
+
+    if (ch === '$') {
+      const { text, end } = readBashVar(source, i);
+      emit(out, 'variable', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '-' && /[A-Za-z0-9]/.test(next || '')) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_-]/.test(source[j])) j += 1;
+      emit(out, 'attr', source.slice(i, j));
+      i = j;
+      continue;
+    }
+
+    if (/[A-Za-z_]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_]/.test(source[j])) j += 1;
+      const word = source.slice(i, j);
+      emit(out, bashWordStyle(word, source[j]), word);
+      i = j;
+      continue;
+    }
+
+    if (/[0-9]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /[0-9]/.test(source[j])) j += 1;
+      emit(out, 'number', source.slice(i, j));
+      i = j;
+      continue;
+    }
+
+    if ('|&;<>(){}'.includes(ch)) {
+      const j = i + bashOpLen(ch, next);
+      emit(out, 'operator', source.slice(i, j));
+      i = j;
+      continue;
+    }
+
+    emit(out, 'plain', ch);
+    i += 1;
+  }
+  return out;
+};
+
+module.exports = { langs, aliases, highlight };