reslop 0.3.0 → 0.3.2

package/lib/git/dir.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const GITDIR_PREFIX = 'gitdir:';
+
+const statOf = (file) => {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+};
+
+const readFirstLine = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n')[0] ?? '';
+  } catch {
+    return '';
+  }
+};
+
+// A linked worktree keeps `.git` as a file that points into the main one
+const gitDirOf = (dot) => {
+  const line = readFirstLine(dot).trim();
+  if (!line.startsWith(GITDIR_PREFIX)) return '';
+  const raw = line.slice(GITDIR_PREFIX.length).trim();
+  if (!raw) return '';
+  return path.resolve(path.dirname(dot), raw);
+};
+
+const commonGitDir = (gitDir) => {
+  const raw = readFirstLine(path.join(gitDir, 'commondir')).trim();
+  if (!raw) return gitDir;
+  return path.resolve(gitDir, raw);
+};
+
+// The directory with HEAD and the index, and the one with refs and objects
+const resolveGitDirs = (root) => {
+  const dot = path.join(path.resolve(root), '.git');
+  const stat = statOf(dot);
+  if (!stat) return null;
+  if (stat.isDirectory()) return { gitDir: dot, commonDir: dot, linked: false };
+  const gitDir = stat.isFile() ? gitDirOf(dot) : '';
+  if (!gitDir) return null;
+  return { gitDir, commonDir: commonGitDir(gitDir), linked: true };
+};
+
+module.exports = { resolveGitDirs };

package/lib/git/git.js

@@ -27,7 +27,7 @@ const REPO_METHODS = {
   revertFile: gitDeps.revertFile,
   edit: worktree.editItem,
   writeFile: worktree.writeFile,
-  stagePath: worktree.stagePath,
+  stagePath: gitDeps.stagePath,
   commit: branches.commitChanges,
   updateCommit: branches.updateCommit,
   hasStaged: branches.hasStaged,

package/lib/git/linked.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { oneLine } = require('../common/utilities.js');
+const { REVIEW_DIR, LOG_DIR } = require('../common/files.js');
+const { runGit, requireOk } = require('./worktree.js');
+
+const HEADS = 'refs/heads/';
+
+const FIELDS = {
+  worktree: (entry, value) => ({ path: path.resolve(value) }),
+  HEAD: (entry, value) => ({ head: value }),
+  branch: (entry, value) => ({ branch: value.replace(HEADS, '') }),
+  detached: () => ({ detached: true }),
+  bare: () => ({ bare: true }),
+  prunable: () => ({ prunable: true }),
+  locked: (entry, value) => ({ locked: true, lockReason: value }),
+};
+
+const parseEntry = (block) => {
+  let entry = {
+    path: '',
+    head: '',
+    branch: '',
+    detached: false,
+    bare: false,
+    locked: false,
+    lockReason: '',
+    prunable: false,
+  };
+  for (const line of block.split('\n')) {
+    const space = line.indexOf(' ');
+    const key = space < 0 ? line : line.slice(0, space);
+    const value = space < 0 ? '' : line.slice(space + 1).trim();
+    const field = Object.hasOwn(FIELDS, key) ? FIELDS[key] : null;
+    if (field) entry = { ...entry, ...field(entry, value) };
+  }
+  return entry;
+};
+
+// The first entry is the main worktree, the others are linked to it
+const parseWorktrees = (text) =>
+  `${text ?? ''}`
+    .split(/\r?\n\r?\n/)
+    .filter((block) => block.trim())
+    .map(parseEntry)
+    .filter((entry) => entry.path)
+    .map((entry, index) => ({ ...entry, main: index === 0 }));
+
+const listWorktrees = async (dir) => {
+  const args = ['worktree', 'list', '--porcelain'];
+  const result = await runGit(args, dir);
+  if (result.status !== 0) return [];
+  return parseWorktrees(result.stdout);
+};
+
+// Git reports real paths, the others can go through links
+const dirKey = (dir) => {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return path.resolve(dir);
+  }
+};
+
+const sameDir = (left, right) => dirKey(left) === dirKey(right);
+
+const findWorktree = (list, dir) => list.find((it) => sameDir(it.path, dir));
+
+const isOwnFile = (rel) => {
+  const head = rel.split(/[/\\]/)[0];
+  return head === REVIEW_DIR || head === LOG_DIR;
+};
+
+// The plan and the logs of reslop are not the work of the user
+const changedFiles = async (dir) => {
+  const args = ['status', '--porcelain', '-z', '--untracked-files=all'];
+  const result = await runGit([...args, '--no-renames'], dir);
+  requireOk(result, 'git status failed');
+  const names = result.stdout.split('\0').filter(Boolean);
+  return names.map((line) => line.slice(3)).filter((rel) => !isOwnFile(rel));
+};
+
+const isDirty = async (dir) => (await changedFiles(dir)).length > 0;
+
+const branchExists = async (top, branch) => {
+  const args = ['show-ref', '--verify', '--quiet', `${HEADS}${branch}`];
+  return (await runGit(args, top)).status === 0;
+};
+
+const branchError = (branch) => {
+  const name = `${branch ?? ''}`.trim();
+  if (!name) return 'empty branch name';
+  if (name.startsWith('-')) return `bad branch name ${name}`;
+  return '';
+};
+
+// Git tells what happened after a line of progress: the last complaint
+const requireDone = (result, fallback) => {
+  if (result.status === 0) return result;
+  const text = `${result.stderr}\n${result.stdout}`;
+  const lines = text.split(/\r?\n/).map((line) => line.trim());
+  const filled = lines.filter(Boolean);
+  const named = filled.filter((line) => /^(fatal|error):/.test(line));
+  const line = named.at(-1) ?? filled.at(-1) ?? fallback;
+  throw new Error(oneLine(line.replace(/^(fatal|error):\s*/, ''), fallback));
+};
+
+// Git itself refuses a branch that is checked out in another worktree
+const addWorktree = async (top, target, branch) => {
+  const failed = branchError(branch);
+  if (failed) throw new Error(failed);
+  const name = branch.trim();
+  const dir = path.resolve(top, target);
+  const exists = await branchExists(top, name);
+  const args = exists
+    ? ['worktree', 'add', '--', dir, name]
+    : ['worktree', 'add', '-b', name, '--', dir];
+  requireDone(await runGit(args, top), 'git worktree add failed');
+  return dir;
+};
+
+// Never forced: uncommitted work or a lock keeps the worktree
+const removeWorktree = async (top, target) => {
+  const list = await listWorktrees(top);
+  const found = findWorktree(list, target);
+  if (!found) throw new Error('not a worktree of this repository');
+  if (found.main) throw new Error('the main worktree cannot be removed');
+  if (found.locked) {
+    const why = found.lockReason ? `: ${found.lockReason}` : '';
+    throw new Error(oneLine(`worktree is locked${why}`, 'worktree is locked'));
+  }
+  if (await isDirty(found.path)) {
+    throw new Error('worktree has uncommitted changes');
+  }
+  const args = ['worktree', 'remove', '--', found.path];
+  requireDone(await runGit(args, top), 'git worktree remove failed');
+};
+
+module.exports = {
+  parseWorktrees,
+  listWorktrees,
+  findWorktree,
+  dirKey,
+  sameDir,
+  changedFiles,
+  isDirty,
+  addWorktree,
+  removeWorktree,
+};

package/lib/git/local.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+
+const { resolveGitDirs } = require('./dir.js');
+
+const HEAD_REF = 'ref: refs/heads/';
+const SHA = /^[0-9a-f]{40}$/i;
+
+const readText = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const readFirstLine = (file) => readText(file).split('\n')[0] ?? '';
+
+const isWorktreeRoot = (dir) => {
+  const dirs = resolveGitDirs(dir);
+  if (!dirs) return false;
+  try {
+    const head = path.join(dirs.gitDir, 'HEAD');
+    const objects = path.join(dirs.commonDir, 'objects');
+    const refs = path.join(dirs.commonDir, 'refs');
+    return (
+      fs.statSync(head).isFile() &&
+      fs.statSync(objects).isDirectory() &&
+      fs.statSync(refs).isDirectory()
+    );
+  } catch {
+    return false;
+  }
+};
+
+// The worktree that contains `start`, without asking git. A linked checkout
+// is the directory whose `.git` file points at the common repository.
+const worktreeRoot = (start) => {
+  let dir = path.resolve(start);
+  let stat;
+  try {
+    stat = fs.statSync(dir);
+  } catch {
+    return '';
+  }
+  if (!stat.isDirectory()) dir = path.dirname(dir);
+  for (;;) {
+    if (isWorktreeRoot(dir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return '';
+    dir = parent;
+  }
+};
+
+const headLine = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  return readFirstLine(path.join(dirs.gitDir, 'HEAD')).trim();
+};
+
+// Empty when HEAD is detached or the checkout has no branch yet
+const branchOf = (top) => {
+  const line = headLine(top);
+  if (!line.startsWith(HEAD_REF)) return '';
+  return line.slice(HEAD_REF.length);
+};
+
+const packedSha = (commonDir, ref) => {
+  const text = readText(path.join(commonDir, 'packed-refs'));
+  for (const line of text.split('\n')) {
+    if (!line || line.startsWith('#') || line.startsWith('^')) continue;
+    const space = line.indexOf(' ');
+    if (space < 0) continue;
+    if (line.slice(space + 1).trim() === ref) return line.slice(0, space);
+  }
+  return '';
+};
+
+const refSha = (commonDir, ref) => {
+  const direct = readFirstLine(path.join(commonDir, ref)).trim();
+  if (SHA.test(direct)) return direct;
+  return packedSha(commonDir, ref);
+};
+
+const headSha = (dirs) => {
+  const line = readFirstLine(path.join(dirs.gitDir, 'HEAD')).trim();
+  if (SHA.test(line)) return line;
+  if (!line.startsWith('ref: ')) return '';
+  return refSha(dirs.commonDir, line.slice('ref: '.length).trim());
+};
+
+const looseCommit = (commonDir, sha) => {
+  if (!SHA.test(sha)) return null;
+  const file = path.join(commonDir, 'objects', sha.slice(0, 2), sha.slice(2));
+  let raw;
+  try {
+    raw = zlib.inflateSync(fs.readFileSync(file));
+  } catch {
+    return null;
+  }
+  const text = raw.toString('utf8');
+  const nul = text.indexOf('\0');
+  if (nul < 0 || !text.slice(0, nul).startsWith('commit ')) return null;
+  return text.slice(nul + 1);
+};
+
+const parentsOf = (body) => {
+  const parents = [];
+  for (const line of body.split('\n')) {
+    if (line.startsWith('parent ')) parents.push(line.slice('parent '.length));
+    else if (line === '') break;
+  }
+  return parents;
+};
+
+// Null when an object lives in a pack: the caller asks git then
+const countLoose = (commonDir, sha) => {
+  const seen = new Set();
+  const queue = [sha];
+  while (queue.length) {
+    const id = queue.pop();
+    if (!id || seen.has(id)) continue;
+    const body = looseCommit(commonDir, id);
+    if (body === null) return null;
+    seen.add(id);
+    for (const parent of parentsOf(body)) queue.push(parent);
+  }
+  return seen.size;
+};
+
+// '' when the history is not a set of loose objects
+const commitCount = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  const sha = headSha(dirs);
+  if (!sha) return '0';
+  const count = countLoose(dirs.commonDir, sha);
+  if (count === null) return '';
+  return `${count}`;
+};
+
+const originUrl = (text) => {
+  let section = '';
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      section = trimmed.slice(1, -1).trim();
+      continue;
+    }
+    if (section !== 'remote "origin"') continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    if (trimmed.slice(0, eq).trim() !== 'url') continue;
+    return trimmed.slice(eq + 1).trim();
+  }
+  return '';
+};
+
+const remoteOrigin = (top) => {
+  const dirs = resolveGitDirs(top);
+  if (!dirs) return '';
+  return originUrl(readText(path.join(dirs.commonDir, 'config')));
+};
+
+const gitDirPath = (top) => {
+  const dirs = resolveGitDirs(top);
+  return dirs ? dirs.gitDir : '';
+};
+
+module.exports = {
+  worktreeRoot,
+  branchOf,
+  commitCount,
+  remoteOrigin,
+  gitDirPath,
+};

package/lib/git/status.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const STAGED_TITLE = 'Changes to be committed:\n';
+const WORK_TITLE = 'Changes not staged for commit:\n';
+const UNTRACKED_TITLE = 'Untracked files:\n';
+const PREFIX = {
+  staged: { left: 'c/', right: 'i/' },
+  work: { left: 'i/', right: 'w/' },
+};
+
+const DIFF_HEADS = [
+  'diff --git ',
+  'index ',
+  '@@ ',
+  'new file ',
+  'deleted file ',
+  'old mode ',
+  'new mode ',
+  'similarity ',
+  'rename ',
+  'Binary files ',
+];
+
+const isDiffHead = (line) => DIFF_HEADS.some((head) => line.startsWith(head));
+
+const isDiffLine = (line) => {
+  if (/^-{10,}$/.test(line)) return false;
+  if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+    return true;
+  }
+  if (line.startsWith('\\')) return true;
+  return isDiffHead(line);
+};
+
+const sectionDiff = (text, title) => {
+  const at = text.lastIndexOf(title);
+  if (at < 0) return '';
+  const rest = text.slice(at + title.length);
+  if (!rest.startsWith('diff --git ')) return '';
+  const lines = [];
+  for (const line of rest.split('\n')) {
+    if (lines.length && !isDiffLine(line)) break;
+    lines.push(line);
+  }
+  return lines.join('\n').replace(/\s+$/, '');
+};
+
+const untrackedOf = (text) => {
+  const at = text.indexOf(UNTRACKED_TITLE);
+  if (at < 0) return [];
+  const rest = text.slice(at + UNTRACKED_TITLE.length);
+  const stop = rest.indexOf('\ndiff --git ');
+  const block = stop < 0 ? rest : rest.slice(0, stop);
+  const names = [];
+  for (const line of block.split('\n')) {
+    if (line.startsWith('\t')) names.push(line.slice(1));
+  }
+  return names;
+};
+
+const rewritePath = (value, from, to) => {
+  if (value === '/dev/null') return value;
+  if (!value.startsWith(from)) return '';
+  return `${to}${value.slice(from.length)}`;
+};
+
+const rewriteGit = (line, left, right) => {
+  const rest = line.slice('diff --git '.length);
+  const mid = ` ${right}`;
+  const at = rest.indexOf(mid);
+  if (!rest.startsWith(left) || at < 0) return '';
+  const oldPath = rest.slice(left.length, at);
+  const newPath = rest.slice(at + mid.length);
+  return `diff --git a/${oldPath} b/${newPath}`;
+};
+
+const rewriteBinary = (line, left, right) => {
+  const match = /^Binary files (.+) and (.+) differ$/.exec(line);
+  if (!match) return line;
+  const oldPath = rewritePath(match[1], left, 'a/');
+  const newPath = rewritePath(match[2], right, 'b/');
+  if (!oldPath || !newPath) return '';
+  return `Binary files ${oldPath} and ${newPath} differ`;
+};
+
+const rewriteMarker = (line, mark, from, to) => {
+  if (!line.startsWith(mark)) return line;
+  const value = line.slice(mark.length);
+  if (value === '/dev/null') return line;
+  const next = rewritePath(value, from, to);
+  if (!next) return '';
+  return `${mark}${next}`;
+};
+
+const rewritten = (line, left, right) => {
+  if (line.startsWith('diff --git ')) return rewriteGit(line, left, right);
+  if (line.startsWith('Binary files ')) return rewriteBinary(line, left, right);
+  if (line.startsWith('--- ')) return rewriteMarker(line, '--- ', left, 'a/');
+  if (line.startsWith('+++ ')) return rewriteMarker(line, '+++ ', right, 'b/');
+  return line;
+};
+
+// git status -vv labels the sides c/ (HEAD), i/ (index) and w/ (worktree).
+// The diff parser wants the a/ and b/ labels of git diff.
+const rewriteDiff = (text, side) => {
+  if (!text) return '';
+  const { left, right } = PREFIX[side];
+  const lines = [];
+  for (const line of text.split('\n')) {
+    const next = rewritten(line, left, right);
+    if (!next) return null;
+    lines.push(next);
+  }
+  return `${lines.join('\n')}\n`;
+};
+
+// Null when this git prints diffs in a shape we do not rewrite
+const parseStatus = (text) => {
+  const raw = `${text ?? ''}`.replaceAll('\r\n', '\n');
+  const staged = rewriteDiff(sectionDiff(raw, STAGED_TITLE), 'staged');
+  const work = rewriteDiff(sectionDiff(raw, WORK_TITLE), 'work');
+  if (staged === null || work === null) return null;
+  return { staged, work, untracked: untrackedOf(raw) };
+};
+
+module.exports = { parseStatus };