reslop 0.1.7 → 0.1.8

package/lib/editor.js

@@ -22,6 +22,36 @@ const offsetAt = (parts, count) => {
   return pos;
 };
 
+const WORD_RE = /[\p{L}\p{N}_]/u;
+
+const isWordChar = (ch) => WORD_RE.test(ch);
+
+const skipWhile = (parts, at, dir, pred) => {
+  if (dir > 0) {
+    while (at < parts.length && pred(parts[at])) at += 1;
+    return at;
+  }
+  while (at > 0 && pred(parts[at - 1])) at -= 1;
+  return at;
+};
+
+const wordIndex = (parts, at, dir) => {
+  const word = (ch) => isWordChar(ch);
+  const sep = (ch) => !isWordChar(ch);
+  if (dir > 0) {
+    if (at < parts.length && word(parts[at])) {
+      return skipWhile(parts, at, 1, word);
+    }
+    at = skipWhile(parts, at, 1, sep);
+    return skipWhile(parts, at, 1, word);
+  }
+  if (at > 0 && word(parts[at - 1])) {
+    return skipWhile(parts, at, -1, word);
+  }
+  at = skipWhile(parts, at, -1, sep);
+  return skipWhile(parts, at, -1, word);
+};
+
 class Editor {
   constructor(text = '') {
     this.text = text;
@@ -87,6 +117,13 @@ class Editor {
     this.cursor = offsetAt(parts, next);
   }
 
+  moveWord(delta) {
+    this.wantCol = null;
+    const dir = delta < 0 ? -1 : 1;
+    const { parts, i } = graphemeIndex(this.text, this.cursor);
+    this.cursor = offsetAt(parts, wordIndex(parts, i, dir));
+  }
+
   linePos() {
     const before = this.text.slice(0, this.cursor);
     const at = before.lastIndexOf('\n');

package/lib/files.js

@@ -4,6 +4,7 @@ const REVIEW_DIR = '.review';
 const ORIGIN_ORDER = ['staged', 'unstaged', 'untracked', 'commit', 'pr'];
 const TODO_FILE = 'TODOs';
 const REPO_TODOS_LABEL = 'Repository TODOs and Issues';
+const TOTAL_LABEL = 'total';
 
 const normalizePathSpec = (spec) =>
   `${spec ?? ''}`.replaceAll('\\', '/').replace(/\/+$/, '');
@@ -27,6 +28,8 @@ const isTodoItem = (item) => !!(item && item.origin === 'todo');
 
 const isTodosEntry = (entry) => !!(entry && entry.kind === 'todos');
 
+const isTotalEntry = (entry) => !!(entry && entry.kind === 'total');
+
 const repoTodosLabel = () => REPO_TODOS_LABEL;
 
 const makeTodoItem = () => ({
@@ -69,6 +72,45 @@ const lineDelta = ({ hunk, blockId }) => {
   return delta;
 };
 
+const addLineDelta = (group, origin, delta) => {
+  group.added += delta.added;
+  group.removed += delta.removed;
+  if (origin === 'staged') {
+    group.stagedAdded += delta.added;
+    group.stagedRemoved += delta.removed;
+    return;
+  }
+  group.unstagedAdded += delta.added;
+  group.unstagedRemoved += delta.removed;
+};
+
+const originLineDelta = (entry) => {
+  if (entry.stagedAdded !== undefined || entry.unstagedAdded !== undefined) {
+    return {
+      stagedAdded: entry.stagedAdded ?? 0,
+      stagedRemoved: entry.stagedRemoved ?? 0,
+      unstagedAdded: entry.unstagedAdded ?? 0,
+      unstagedRemoved: entry.unstagedRemoved ?? 0,
+    };
+  }
+  const added = entry.added ?? 0;
+  const removed = entry.removed ?? 0;
+  if ((entry.status ?? '') === 'staged') {
+    return {
+      stagedAdded: added,
+      stagedRemoved: removed,
+      unstagedAdded: 0,
+      unstagedRemoved: 0,
+    };
+  }
+  return {
+    stagedAdded: 0,
+    stagedRemoved: 0,
+    unstagedAdded: added,
+    unstagedRemoved: removed,
+  };
+};
+
 const fileEntries = (items) => {
   const groups = new Map();
   for (let i = 0; i < items.length; i++) {
@@ -84,6 +126,10 @@ const fileEntries = (items) => {
         remaining: 0,
         added: 0,
         removed: 0,
+        stagedAdded: 0,
+        stagedRemoved: 0,
+        unstagedAdded: 0,
+        unstagedRemoved: 0,
         staged: 0,
         unstaged: 0,
       });
@@ -92,9 +138,7 @@ const fileEntries = (items) => {
     const { origin } = item;
     group.origins.push(origin);
     group.remaining += 1;
-    const delta = lineDelta(item);
-    group.added += delta.added;
-    group.removed += delta.removed;
+    addLineDelta(group, origin, lineDelta(item));
     if (origin === 'staged') group.staged += 1;
     if (origin === 'unstaged') {
       if (group.unstaged === 0) group.openIndex = i;
@@ -108,16 +152,57 @@ const fileEntries = (items) => {
   return entries;
 };
 
+const fileTotals = (files) => {
+  const total = {
+    path: TOTAL_LABEL,
+    kind: 'total',
+    status: '',
+    remaining: 0,
+    added: 0,
+    removed: 0,
+    stagedAdded: 0,
+    stagedRemoved: 0,
+    unstagedAdded: 0,
+    unstagedRemoved: 0,
+    staged: 0,
+    unstaged: 0,
+  };
+  for (const entry of files) {
+    if (isTodosEntry(entry) || isTotalEntry(entry)) continue;
+    const remaining = entry.remaining ?? 0;
+    const staged = entry.staged ?? 0;
+    const added = entry.added ?? 0;
+    const removed = entry.removed ?? 0;
+    const lines = originLineDelta(entry);
+    const listed = entry.unstaged ?? Math.max(0, remaining - staged);
+    const untracked = (entry.status ?? '') === 'untracked';
+    const unstaged = untracked && listed === 0 ? remaining : listed;
+    total.remaining += remaining;
+    total.added += added;
+    total.removed += removed;
+    total.stagedAdded += lines.stagedAdded;
+    total.stagedRemoved += lines.stagedRemoved;
+    total.unstagedAdded += lines.unstagedAdded;
+    total.unstagedRemoved += lines.unstagedRemoved;
+    total.staged += staged;
+    total.unstaged += unstaged;
+  }
+  return total;
+};
+
 module.exports = {
   REVIEW_DIR,
   TODO_FILE,
   REPO_TODOS_LABEL,
+  TOTAL_LABEL,
   isPathInScope,
   itemPath,
   isTodoItem,
   isTodosEntry,
+  isTotalEntry,
   repoTodosLabel,
   makeTodoItem,
   fileStatus,
   fileEntries,
+  fileTotals,
 };

package/lib/git/branches.js

@@ -0,0 +1,291 @@
+'use strict';
+
+const { oneLine, requireOk, runGit, runGitAsync } = require('./run.js');
+
+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 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);
+  const listed = [];
+  for (const entry of branches) {
+    const isDefault = entry.name === primary;
+    listed.push({ ...entry, isDefault });
+  }
+  return listed;
+};
+
+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 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 hasUpstream = (top) => {
+  const args = [
+    'rev-parse',
+    '--abbrev-ref',
+    '--symbolic-full-name',
+    '@{upstream}',
+  ];
+  const result = runGit(args, top);
+  return result.status === 0;
+};
+
+const pushCmd = (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 finishPush = (result, force, branch, run) => {
+  if (result.status === 0) return;
+  const msg = result.stderr || result.stdout || 'push failed';
+  if (!noUpstream(msg)) throw pushError(msg);
+  const next = run(pushCmd(force, branch));
+  if (next.status !== 0) {
+    throw pushError(next.stderr || next.stdout || 'push failed');
+  }
+};
+
+const pushChanges = (top, force) => {
+  const useForce = force === true;
+  const branch = pushBranch(top);
+  const tracked = hasUpstream(top) ? '' : branch;
+  const result = runGit(pushCmd(useForce, tracked), top);
+  finishPush(result, useForce, branch, (args) => runGit(args, top));
+};
+
+const pushChangesAsync = async (top, force) => {
+  const useForce = force === true;
+  const branch = pushBranch(top);
+  const tracked = hasUpstream(top) ? '' : branch;
+  const result = await runGitAsync(pushCmd(useForce, tracked), top);
+  if (result.status === 0) return;
+  const msg = result.stderr || result.stdout || 'push failed';
+  if (!noUpstream(msg)) throw pushError(msg);
+  const next = await runGitAsync(pushCmd(useForce, branch), 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 }));
+};
+
+module.exports = {
+  lastMessage,
+  listBranches,
+  checkoutBranch,
+  checkoutBranchAsync,
+  createBranch,
+  createBranchAsync,
+  rebaseBranch,
+  rebaseBranchAsync,
+  dropBranch,
+  dropBranchAsync,
+  pullChanges,
+  pullChangesAsync,
+  pushChanges,
+  pushChangesAsync,
+  hasStaged,
+  commitChanges,
+  commitChangesAsync,
+};

package/lib/git/changes.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { itemPath } = require('../files.js');
+const { replaceBlockAdds } = require('../diff/edit.js');
+const { requireOk, runGit } = require('./run.js');
+
+const applyPatch = (cwd, patch, flags) => {
+  const args = ['apply', ...flags, '--whitespace=nowarn', '-'];
+  const result = runGit(args, cwd, patch);
+  requireOk(result, 'apply failed');
+};
+
+const addItem = (top, item) => {
+  if (item.origin === 'staged' || item.origin === 'commit') return;
+  if (item.origin === 'untracked' || item.file.isBinary) {
+    requireOk(runGit(['add', '--', item.file.newPath], top));
+    return;
+  }
+  applyPatch(top, item.patchAdd, ['--cached']);
+};
+
+const unstageItem = (top, item) => {
+  if (item.origin !== 'staged') return;
+  const rel = itemPath(item);
+  if (item.file.isBinary) {
+    requireOk(runGit(['restore', '--staged', '--', rel], top));
+    return;
+  }
+  applyPatch(top, item.patchAdd, ['--reverse', '--cached']);
+};
+
+const revertOnePath = (top, rel, items) => {
+  const origins = new Set();
+  let isNew = false;
+  for (const item of items) {
+    origins.add(item.origin);
+    if (item.file && item.file.isNew) isNew = true;
+  }
+  if (isNew) {
+    if (origins.has('staged')) {
+      requireOk(runGit(['rm', '-f', '--', rel], top));
+      return;
+    }
+    fs.unlinkSync(path.join(top, rel));
+    return;
+  }
+  if (origins.has('untracked') && origins.size === 1) {
+    fs.unlinkSync(path.join(top, rel));
+    return;
+  }
+  const args = ['restore', '-s', 'HEAD', '--worktree', '--staged', '--', rel];
+  requireOk(runGit(args, top));
+};
+
+const revertItem = (top, item) => {
+  if (item.origin === 'commit') return;
+  const rel = itemPath(item);
+  if (item.origin === 'untracked') {
+    fs.unlinkSync(path.join(top, rel));
+    return;
+  }
+  if (item.file.isBinary) {
+    const args = ['restore', '-s', 'HEAD', '--worktree'];
+    if (item.origin === 'staged') args.push('--staged');
+    args.push('--', rel);
+    requireOk(runGit(args, top));
+    return;
+  }
+  if (item.origin === 'unstaged') {
+    applyPatch(top, item.patchRevert, ['--reverse']);
+    return;
+  }
+  applyPatch(top, item.patchRevert, ['--reverse', '--cached']);
+  try {
+    applyPatch(top, item.patchRevert, ['--reverse']);
+  } catch (error) {
+    if (!error.message.includes('does not apply')) throw error;
+  }
+};
+
+const revertFile = (top, rel, items) => {
+  const group = [];
+  for (const item of items) {
+    if (itemPath(item) === rel) group.push(item);
+  }
+  const targets = group.length ? group : items;
+  revertOnePath(top, rel, targets);
+};
+
+const indexText = (top, rel) => {
+  const result = runGit(['show', `:${rel}`], top);
+  requireOk(result, 'show failed');
+  return result.stdout ?? '';
+};
+
+const indexMode = (top, rel) => {
+  const result = runGit(['ls-files', '--stage', '--', rel], top);
+  if (result.status !== 0) return '100644';
+  const line = (result.stdout ?? '').trim();
+  if (!line) return '100644';
+  const mode = line.split(' ')[0];
+  return mode || '100644';
+};
+
+const writeIndex = (top, rel, text) => {
+  const hashed = runGit(['hash-object', '-w', '--stdin'], top, text);
+  requireOk(hashed, 'hash-object failed');
+  const sha = (hashed.stdout ?? '').trim();
+  const mode = indexMode(top, rel);
+  const args = ['update-index', '--cacheinfo', mode, sha, rel];
+  requireOk(runGit(args, top), 'update-index failed');
+};
+
+const writeWorktree = (abs, text) => {
+  fs.writeFileSync(abs, text);
+};
+
+const editStaged = (top, rel, abs, hunk, blockId, text) => {
+  const source = indexText(top, rel);
+  const next = replaceBlockAdds(source, hunk, blockId, text);
+  writeIndex(top, rel, next);
+  let work = null;
+  try {
+    work = fs.readFileSync(abs, 'utf8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  if (work === null) {
+    writeWorktree(abs, next);
+    return;
+  }
+  if (work === source) writeWorktree(abs, next);
+};
+
+const editWorktree = (abs, hunk, blockId, text) => {
+  const source = fs.readFileSync(abs, 'utf8');
+  const next = replaceBlockAdds(source, hunk, blockId, text);
+  if (next === source) return;
+  writeWorktree(abs, next);
+};
+
+const editItem = (top, item, text) => {
+  if (item.origin === 'commit' || item.origin === 'pr') return;
+  const rel = itemPath(item);
+  if (!rel || !item.hunk) return;
+  const abs = path.join(top, rel);
+  if (item.origin === 'staged') {
+    editStaged(top, rel, abs, item.hunk, item.blockId, text);
+    return;
+  }
+  editWorktree(abs, item.hunk, item.blockId, text);
+};
+
+module.exports = {
+  addItem,
+  unstageItem,
+  revertOnePath,
+  revertItem,
+  revertFile,
+  editItem,
+};