reslop 0.2.7 → 0.3.0

package/lib/git/worktree.js

@@ -0,0 +1,475 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { runProc, isAbort } = require('../common/process.js');
+const { oneLine } = require('../common/utilities.js');
+const diff = require('../diff/diff.js');
+const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
+const files = require('../common/files.js');
+const { groupByPath } = files;
+const { itemPath, isReadOnlyOrigin, lineDelta, REVIEW_DIR } = files;
+const { replaceBlockAdds } = require('../diff/patch.js');
+
+const GIT_CONFIG = [
+  '-c',
+  'core.quotepath=false',
+  '-c',
+  'i18n.logOutputEncoding=utf-8',
+];
+const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
+const BINARY_SIZE = 1000000;
+
+const gitOptions = (cwd, extra) => ({
+  cwd,
+  env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...extra.env },
+  input: extra.input,
+  signal: extra.signal,
+});
+
+const gitResult = (result) => {
+  if (!result.error) return result;
+  if (isAbort(result.error)) throw result.error;
+  if (result.error.code === 'ENOENT') throw new Error('git not found');
+  throw result.error;
+};
+
+const requireOk = (result, fallback = 'git failed') => {
+  if (result.status === 0) return result;
+  const msg = result.stderr || result.stdout || fallback;
+  throw new Error(oneLine(msg, fallback));
+};
+
+const runGit = (args, cwd, extra = {}) =>
+  runProc('git', args, gitOptions(cwd, extra)).then(gitResult);
+
+const command = (args, extra = {}) => ({
+  args,
+  input: extra.input,
+  env: extra.env,
+});
+
+const runSteps = async (steps, top, signal) => {
+  try {
+    let step = steps.next();
+    while (!step.done) {
+      const extra = { ...step.value, signal };
+      step = steps.next(await runGit(step.value.args, top, extra));
+    }
+    return step.value;
+  } finally {
+    steps.return();
+  }
+};
+
+const gitOp =
+  (op) =>
+  (top, ...args) =>
+    runSteps(op(...args), top);
+
+const pathArgs = (paths) => (paths.length ? ['--', ...paths] : []);
+
+const diffArgs = (revs, paths) => [
+  ...GIT_CONFIG,
+  'diff',
+  ...DIFF_OPTS,
+  ...revs,
+  ...pathArgs(paths),
+];
+
+const commitDiffArgs = (commit, parent, paths) => {
+  if (parent.status === 0) {
+    return diffArgs([parent.stdout.trim(), commit], paths);
+  }
+  return [
+    ...GIT_CONFIG,
+    'diff-tree',
+    '--no-commit-id',
+    '--root',
+    '-p',
+    ...DIFF_OPTS,
+    commit,
+    ...pathArgs(paths),
+  ];
+};
+
+const untrackedArgs = (paths) => [
+  'ls-files',
+  '-o',
+  '--exclude-standard',
+  '-z',
+  ...pathArgs(paths),
+];
+
+const isReviewFile = (rel) => rel.split(/[/\\]/)[0] === REVIEW_DIR;
+
+const isDirEntry = (rel) => rel.endsWith('/');
+
+const dropReviewItems = (items) =>
+  items.filter((item) => !isReviewFile(itemPath(item)));
+
+const isBinaryBuffer = (buf) => buf.length > BINARY_SIZE || buf.includes(0);
+
+const namesFromLs = (stdout) => stdout.split('\0').filter(Boolean);
+
+const listScopeFiles = async (top, paths = [], options = {}) => {
+  const rev = options.commit;
+  const scope = pathArgs(paths);
+  let args = ['ls-files', '-co', '--exclude-standard', '-z', ...scope];
+  if (rev) args = ['ls-tree', '-r', '--name-only', '-z', rev, ...scope];
+  const result = requireOk(await runGit(args, top), 'ls-files failed');
+  const names = namesFromLs(result.stdout).filter(
+    (rel) => !isReviewFile(rel) && !isDirEntry(rel),
+  );
+  names.sort((left, right) => left.localeCompare(right, 'en'));
+  return names;
+};
+
+const binaryNewFile = (rel) => ({
+  oldPath: rel,
+  newPath: rel,
+  isNew: true,
+  isDeleted: false,
+  isBinary: true,
+  preamble: [`diff --git a/${rel} b/${rel}`, 'new file mode 100644'],
+  hunks: [],
+});
+
+const UNTRACKED_READS = 16;
+
+const untrackedNames = (names) => {
+  const keep = (rel) => !isReviewFile(rel) && !isDirEntry(rel);
+  return names.filter(keep);
+};
+
+const untrackedFile = (rel, buf) => {
+  if (isBinaryBuffer(buf)) return binaryNewFile(rel);
+  const text = buf.toString('utf8');
+  return synthesizeNewFile(rel, text);
+};
+
+const isGone = (error) => error.code === 'ENOENT' || error.code === 'EISDIR';
+
+const untrackedItemsFrom = (top, names) => {
+  const files = [];
+  for (const rel of untrackedNames(names)) {
+    try {
+      files.push(untrackedFile(rel, fs.readFileSync(path.join(top, rel))));
+    } catch (error) {
+      if (!isGone(error)) throw error;
+    }
+  }
+  return itemsFromFiles(files, 'untracked');
+};
+
+const readUntracked = async (top, rel) => {
+  try {
+    return untrackedFile(rel, await fs.promises.readFile(path.join(top, rel)));
+  } catch (error) {
+    if (isGone(error)) return null;
+    throw error;
+  }
+};
+
+const untrackedItems = async (top, names) => {
+  const rels = untrackedNames(names);
+  const files = [];
+  for (let at = 0; at < rels.length; at += UNTRACKED_READS) {
+    const batch = rels.slice(at, at + UNTRACKED_READS);
+    const read = await Promise.all(batch.map((rel) => readUntracked(top, rel)));
+    for (const file of read) if (file) files.push(file);
+  }
+  return itemsFromFiles(files, 'untracked');
+};
+
+const countUntrackedAdded = async (top) => {
+  try {
+    const result = await runGit(untrackedArgs([]), top);
+    if (result.status !== 0) return 0;
+    const items = untrackedItemsFrom(top, namesFromLs(result.stdout));
+    let added = 0;
+    for (const item of items) added += lineDelta(item).added;
+    return added;
+  } catch {
+    return 0;
+  }
+};
+
+const gitText = async (top, spec) => {
+  const result = await runGit(['show', spec], top);
+  return result.status === 0 ? result.stdout : '';
+};
+
+const worktreeText = async (top, rel) => {
+  try {
+    return await fs.promises.readFile(path.join(top, rel), 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const indexedText = async (top, rel) => {
+  const staged = await gitText(top, `:${rel}`);
+  return staged || gitText(top, `HEAD:${rel}`);
+};
+
+const fileText = async (top, rel, rev) => {
+  if (!rel) return '';
+  if (rev) return gitText(top, `${rev}:${rel}`);
+  return worktreeText(top, rel);
+};
+
+const DEP_SIDES = {
+  untracked: (top, rel) => ['', worktreeText(top, rel)],
+  staged: (top, rel) => [gitText(top, `HEAD:${rel}`), gitText(top, `:${rel}`)],
+  unstaged: (top, rel) => [indexedText(top, rel), worktreeText(top, rel)],
+  commit: (top, rel, rev) => [
+    gitText(top, `${rev}^:${rel}`),
+    gitText(top, `${rev}:${rel}`),
+  ],
+};
+
+const readDepSides = async (top, rev, origin, rel) => {
+  const known = Object.hasOwn(DEP_SIDES, origin);
+  if (!known || (origin === 'commit' && !rev)) {
+    return { oldText: '', newText: '' };
+  }
+  const reads = DEP_SIDES[origin](top, rel, rev);
+  const [oldText, newText] = await Promise.all(reads);
+  return { oldText, newText };
+};
+
+const toplevel = async (cwd, signal) => {
+  const args = ['rev-parse', '--show-toplevel'];
+  const result = await runGit(args, cwd, { signal });
+  if (result.status !== 0) throw new Error('not a git repository');
+  return result.stdout.trim();
+};
+
+const resolveRev = async (cwd, spec) => {
+  if (!spec) return null;
+  const args = ['rev-parse', '--verify', `${spec}^{commit}`];
+  const result = await runGit(args, await toplevel(cwd));
+  return result.status === 0 ? result.stdout.trim() : null;
+};
+
+const shortRev = async (top, commit) => {
+  const result = await runGit(['rev-parse', '--short', commit], top);
+  return result.status === 0 ? result.stdout.trim() : commit.slice(0, 7);
+};
+
+const branchName = (result) => {
+  if (result.status !== 0) return '';
+  const name = result.stdout.trim();
+  return name === 'HEAD' ? '' : name;
+};
+
+const BRANCH_ARGS = ['rev-parse', '--abbrev-ref', 'HEAD'];
+
+const currentBranch = async (top) => branchName(await runGit(BRANCH_ARGS, top));
+
+const worktreeSnapshot = (top, outputs, untracked, branch) => {
+  const staged = itemsFromFiles(parseDiff(outputs[0]), 'staged');
+  const unstaged = itemsFromFiles(parseDiff(outputs[1]), 'unstaged');
+  const grouped = groupByPath([...staged, ...unstaged, ...untracked]);
+  const parsed = dropReviewItems([...grouped.values()].flat());
+  return { top, parsed, branch };
+};
+
+const snapshotCommit = async (top, commit, files) => {
+  const parsed = dropReviewItems(itemsFromFiles(files, 'commit'));
+  const names = [shortRev(top, commit), currentBranch(top)];
+  const [revShort, branch] = await Promise.all(names);
+  return { top, parsed, rev: commit, revShort, branch };
+};
+
+function* commitDiff(commit, paths) {
+  const parent = yield command(['rev-parse', '--verify', `${commit}^`]);
+  const result = yield command(commitDiffArgs(commit, parent, paths));
+  return parseDiff(requireOk(result).stdout);
+}
+
+const worktreeCommands = (paths) => [
+  diffArgs(['--cached'], paths),
+  diffArgs([], paths),
+  untrackedArgs(paths),
+];
+
+const readSnapshot = async (cwd, paths, options) => {
+  const { commit: rev, signal } = options;
+  const top = await toplevel(cwd, signal);
+  if (rev) {
+    const files = await runSteps(commitDiff(rev, paths), top, signal);
+    return snapshotCommit(top, rev, files);
+  }
+  const commands = [...worktreeCommands(paths), BRANCH_ARGS];
+  const running = commands.map((args) => runGit(args, top, { signal }));
+  const results = await Promise.all(running);
+  const branch = branchName(results.pop());
+  const outputs = results.map((result) => requireOk(result).stdout);
+  const names = namesFromLs(outputs[2]);
+  const untracked = await untrackedItems(top, names);
+  return worktreeSnapshot(top, outputs, untracked, branch);
+};
+
+const applyPatch = async (cwd, patch, flags) => {
+  const args = ['apply', ...flags, '--whitespace=nowarn', '-'];
+  const result = await runGit(args, cwd, { input: patch });
+  requireOk(result, 'apply failed');
+};
+
+const gitOk = async (args, top) => requireOk(await runGit(args, top));
+
+const addItem = async (top, item) => {
+  if (item.origin === 'staged' || item.origin === 'commit') return;
+  if (item.origin === 'untracked' || item.file.isBinary) {
+    await gitOk(['add', '--', item.file.newPath], top);
+    return;
+  }
+  await applyPatch(top, item.patchAdd, ['--cached']);
+};
+
+const unstageItem = async (top, item) => {
+  if (item.origin !== 'staged') return;
+  if (item.file.isBinary) {
+    await gitOk(['restore', '--staged', '--', itemPath(item)], top);
+    return;
+  }
+  await applyPatch(top, item.patchAdd, ['--reverse', '--cached']);
+};
+
+const revertOnePath = async (top, rel, items) => {
+  const origins = new Set(items.map((item) => item.origin));
+  const isNew = items.some((item) => item.file?.isNew);
+  if (isNew && origins.has('staged')) {
+    await gitOk(['rm', '-f', '--', rel], top);
+    return;
+  }
+  const onlyUntracked = origins.size === 1 && origins.has('untracked');
+  if (isNew || onlyUntracked) return void fs.unlinkSync(path.join(top, rel));
+  const args = ['restore', '-s', 'HEAD', '--worktree', '--staged', '--', rel];
+  await gitOk(args, top);
+};
+
+const revertItem = async (top, item) => {
+  const rel = itemPath(item);
+  if (item.origin === 'untracked') {
+    return void fs.unlinkSync(path.join(top, rel));
+  }
+  if (item.file.isBinary) {
+    const args = ['restore', '-s', 'HEAD', '--worktree'];
+    if (item.origin === 'staged') args.push('--staged');
+    await gitOk([...args, '--', rel], top);
+    return;
+  }
+  if (item.origin === 'unstaged') {
+    await applyPatch(top, item.patchRevert, ['--reverse']);
+    return;
+  }
+  await applyPatch(top, item.patchRevert, ['--reverse', '--cached']);
+  try {
+    await applyPatch(top, item.patchRevert, ['--reverse']);
+  } catch (error) {
+    if (!error.message.includes('does not apply')) throw error;
+  }
+};
+
+const isExecutable = async (abs) => {
+  try {
+    const stat = await fs.promises.stat(abs);
+    return (stat.mode & 0o111) !== 0;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    return false;
+  }
+};
+
+const indexMode = async (top, rel) => {
+  const result = await gitOk(['ls-files', '--stage', '--', rel], top);
+  const line = result.stdout.trim();
+  if (line) return line.split(' ')[0];
+  const executable = await isExecutable(path.join(top, rel));
+  return executable ? '100755' : '100644';
+};
+
+const writeIndex = async (top, rel, text) => {
+  const hashArgs = ['hash-object', '-w', `--path=${rel}`, '--stdin'];
+  const hashed = await runGit(hashArgs, top, { input: text });
+  const sha = requireOk(hashed, 'hash-object failed').stdout.trim();
+  const mode = await indexMode(top, rel);
+  const args = ['update-index', '--add', '--cacheinfo', mode, sha, rel];
+  requireOk(await runGit(args, top), 'update-index failed');
+};
+
+const readIfPresent = async (abs) => {
+  try {
+    return await fs.promises.readFile(abs, 'utf8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    return null;
+  }
+};
+
+const editStaged = async (top, rel, abs, item, text) => {
+  const shown = await runGit(['show', `:${rel}`], top);
+  const source = requireOk(shown, 'show failed').stdout;
+  const next = replaceBlockAdds(source, item.hunk, item.blockId, text);
+  await writeIndex(top, rel, next);
+  const work = await readIfPresent(abs);
+  if (work === null || work === source) await fs.promises.writeFile(abs, next);
+};
+
+const editWorktree = async (abs, item, text) => {
+  const source = await fs.promises.readFile(abs, 'utf8');
+  const next = replaceBlockAdds(source, item.hunk, item.blockId, text);
+  if (next !== source) await fs.promises.writeFile(abs, next);
+};
+
+const editItem = async (top, item, text) => {
+  if (isReadOnlyOrigin(item.origin)) return;
+  const rel = itemPath(item);
+  if (!rel || !item.hunk) return;
+  const abs = path.join(top, rel);
+  if (item.origin === 'staged') await editStaged(top, rel, abs, item, text);
+  else await editWorktree(abs, item, text);
+};
+
+const writeFile = async (top, rel, text) => {
+  if (!rel) return;
+  const abs = path.join(top, rel);
+  await fs.promises.mkdir(path.dirname(abs), { recursive: true });
+  await fs.promises.writeFile(abs, text);
+};
+
+const stagePath = async (top, rel) => {
+  if (rel) await gitOk(['add', '--', rel], top);
+};
+
+module.exports = {
+  requireOk,
+  gitOk,
+  runGit,
+  command,
+  gitOp,
+  groupByPath,
+  gitText,
+  indexedText,
+  worktreeText,
+  readDepSides,
+  revertOnePath,
+  toplevel,
+  resolveRev,
+  currentBranch,
+  fileText,
+  countUntrackedAdded,
+  listScopeFiles,
+  readSnapshot,
+  editItem,
+  writeFile,
+  writeIndex,
+  stagePath,
+  addItem,
+  unstageItem,
+  revertItem,
+};

package/lib/highlight/bash.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { words, emit, wordStyles, scanWhile, lineEnd } = core;
+const { words, emit, wordStyles, scanWhile, lineEnd } = require('./core.js');
 
 const SINGLE_QUOTES = `'\``;
 

package/lib/highlight/csv.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { emit, highlightLines } = core;
+const { emit, highlightLines } = require('./core.js');
 
 const splitCsv = (line) => {
   const cells = [];

package/lib/highlight/dot.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { emit, highlightLines } = core;
+const { emit, highlightLines } = require('./core.js');
 
 const ASSIGN_RE = /^(\s*)([A-Za-z_][A-Za-z0-9_.-]*)(\s*=\s*)(.*)$/;
 

package/lib/{highlight.js → highlight/highlight.js}

@@ -1,7 +1,8 @@
 'use strict';
 
-const core = require('./highlight/core.js');
-const { tokensText, words } = core;
+const path = require('node:path');
+const { fileExt } = require('metautil');
+const { tokensText, words } = require('./core.js');
 
 const PLUGIN_NAMES = words('bash css csv dart dot html js json log txt');
 
@@ -9,7 +10,7 @@ const HIGHLIGHTERS = Object.create(null);
 const LANG = Object.create(null);
 
 for (const name of PLUGIN_NAMES) {
-  const plugin = require(`./highlight/${name}.js`);
+  const plugin = require(`./${name}.js`);
   for (const id of plugin.langs) {
     HIGHLIGHTERS[id] = plugin.highlight;
     LANG[id] = id;
@@ -42,12 +43,11 @@ const overlayTokens = (tokens, spans) => {
     const spanText = span.text ?? '';
     const n = Math.min(tokenText.length - tokenOff, spanText.length - spanOff);
     if (n > 0) {
-      const style = typeof token.style === 'string' && token.style;
-      pieces.push({
-        text: tokenText.slice(tokenOff, tokenOff + n),
-        style: style || 'plain',
-        changed: span.changed === true,
-      });
+      const text = tokenText.slice(tokenOff, tokenOff + n);
+      const named = typeof token.style === 'string' && token.style;
+      const style = named || 'plain';
+      const changed = span.changed === true;
+      pieces.push({ text, style, changed });
     }
     tokenOff += n;
     spanOff += n;
@@ -64,11 +64,42 @@ const overlayTokens = (tokens, spans) => {
     const span = diff[spanIndex];
     const text = (span.text ?? '').slice(spanOff);
     if (text) {
-      pieces.push({ text, style: 'plain', changed: span.changed === true });
+      const style = 'plain';
+      const changed = span.changed === true;
+      pieces.push({ text, style, changed });
     }
     spanOff = 0;
   }
   return pieces;
 };
 
-module.exports = { tokensText, tokenize, overlayTokens, mapLang };
+const PROSE_BASENAMES = [
+  'license',
+  'licence',
+  'copying',
+  'authors',
+  'notice',
+  'copyright',
+];
+
+const isProse = (base) => {
+  const stem = base.replace(/\.(txt|text|md|markdown)$/, '');
+  return PROSE_BASENAMES.includes(stem);
+};
+
+const detectLang = (filePath) => {
+  const base = path.basename(filePath || '').toLowerCase();
+  if (base.endsWith('.d.ts')) return 'dts';
+  if (isProse(base)) return 'md';
+  if (base.endsWith('.log')) return 'log';
+  if (base.startsWith('.') || !base.includes('.')) return 'dot';
+  const ext = fileExt(base);
+  return ext ? mapLang(ext) : 'dot';
+};
+
+module.exports = {
+  tokensText,
+  tokenize,
+  overlayTokens,
+  detectLang,
+};

package/lib/highlight/html.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { QUOTES, emit, scanWhile, quotedEnd } = core;
+const { QUOTES, emit, scanWhile, quotedEnd } = require('./core.js');
 
 const colorHtmlTag = (tag) => {
   const out = [];
@@ -40,26 +39,29 @@ const tagEnd = (source, i) => {
   return j < n ? j + 1 : j;
 };
 
+const paintSpan = (source, i, n, out) => {
+  if (source.startsWith('<!--', i)) {
+    const close = source.indexOf('-->', i + 4);
+    const end = close < 0 ? n : close + 3;
+    emit(out, 'comment', source.slice(i, end));
+    return end;
+  }
+  if (source[i] === '<') {
+    const end = tagEnd(source, i);
+    for (const token of colorHtmlTag(source.slice(i, end))) out.push(token);
+    return end;
+  }
+  const next = source.indexOf('<', i + 1);
+  const end = next < 0 ? n : next;
+  emit(out, 'plain', source.slice(i, end));
+  return end;
+};
+
 const highlight = (source) => {
   const out = [];
   const n = source.length;
   let i = 0;
-  while (i < n) {
-    let end;
-    if (source.startsWith('<!--', i)) {
-      const close = source.indexOf('-->', i + 4);
-      end = close < 0 ? n : close + 3;
-      emit(out, 'comment', source.slice(i, end));
-    } else if (source[i] === '<') {
-      end = tagEnd(source, i);
-      for (const token of colorHtmlTag(source.slice(i, end))) out.push(token);
-    } else {
-      const next = source.indexOf('<', i + 1);
-      end = next < 0 ? n : next;
-      emit(out, 'plain', source.slice(i, end));
-    }
-    i = end;
-  }
+  while (i < n) i = paintSpan(source, i, n, out);
   return out;
 };
 

package/lib/highlight/json.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { emit, wordStyles, scanWhile, stringEnd } = core;
+const { emit, wordStyles, scanWhile, stringEnd } = require('./core.js');
 
 const JSON_LITERAL = wordStyles({ literal: ['true', 'false', 'null'] });
 

package/lib/highlight/log.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { emit, highlightLines, wordStyles } = core;
+const { emit, highlightLines, wordStyles } = require('./core.js');
 
 const LOG_DATETIME_RE = new RegExp(
   '^(\\d{4}-\\d{2}-\\d{2}[T ]\\d{2}:\\d{2}:\\d{2}' +

package/lib/highlight/txt.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const core = require('./core.js');
-const { emit, highlightLines } = core;
+const { emit, highlightLines } = require('./core.js');
 
 const URL_RE = /https?:\/\/[^\s<>"']+|www\.[^\s<>"']+/g;