reslop 0.3.0 → 0.3.2

package/lib/git/worktree.js

@@ -3,13 +3,16 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { runProc, isAbort } = require('../common/process.js');
+const { runProc, isAbort, abortError } = 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 local = require('./local.js');
+const { worktreeRoot, branchOf, remoteOrigin } = local;
+const { parseStatus } = require('./status.js');
 const { replaceBlockAdds } = require('../diff/patch.js');
 
 const GIT_CONFIG = [
@@ -20,10 +23,30 @@ const GIT_CONFIG = [
 ];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
 const BINARY_SIZE = 1000000;
+const STATUS_ARGS = [
+  '-c',
+  'core.quotepath=false',
+  '-c',
+  'color.ui=false',
+  '-c',
+  'diff.renames=false',
+  'status',
+  '-vv',
+  '--no-renames',
+  '--no-ahead-behind',
+  '-uall',
+];
+const STATUS_ENV = { LC_MESSAGES: 'C', LANGUAGE: 'C' };
 
 const gitOptions = (cwd, extra) => ({
   cwd,
-  env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', ...extra.env },
+  env: {
+    ...process.env,
+    GIT_OPTIONAL_LOCKS: '0',
+    GIT_TERMINAL_PROMPT: '0',
+    GCM_INTERACTIVE: 'Never',
+    ...extra.env,
+  },
   input: extra.input,
   signal: extra.signal,
 });
@@ -183,17 +206,12 @@ const untrackedItems = async (top, names) => {
   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 addedOf = (names, top) => {
+  let added = 0;
+  for (const item of untrackedItemsFrom(top, names)) {
+    added += lineDelta(item).added;
   }
+  return added;
 };
 
 const gitText = async (top, spec) => {
@@ -240,13 +258,23 @@ const readDepSides = async (top, rev, origin, rel) => {
   return { oldText, newText };
 };
 
-const toplevel = async (cwd, signal) => {
+const toplevelGit = 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 toplevel = async (cwd, signal) => {
+  if (signal && signal.aborted) throw abortError();
+  if (process.env.GIT_DIR || process.env.GIT_WORK_TREE) {
+    return toplevelGit(cwd, signal);
+  }
+  const found = worktreeRoot(cwd);
+  if (found) return found;
+  return toplevelGit(cwd, signal);
+};
+
 const resolveRev = async (cwd, spec) => {
   if (!spec) return null;
   const args = ['rev-parse', '--verify', `${spec}^{commit}`];
@@ -259,29 +287,53 @@ const shortRev = async (top, commit) => {
   return result.status === 0 ? result.stdout.trim() : commit.slice(0, 7);
 };
 
-const branchName = (result) => {
+const currentBranch = async (top) => {
+  const root = worktreeRoot(top);
+  if (root) return branchOf(root);
+  const args = ['rev-parse', '--abbrev-ref', 'HEAD'];
+  const result = await runGit(args, top);
   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 repositoryUrl = (raw) => {
+  let value = `${raw ?? ''}`.trim();
+  if (!value) return '';
+  const scp = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/.exec(value);
+  if (scp && !value.includes('://')) value = `https://${scp[1]}/${scp[2]}`;
+  else if (value.startsWith('git+')) value = value.slice(4);
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return '';
+  }
+  if (!['http:', 'https:', 'git:', 'ssh:'].includes(url.protocol)) return '';
+  url.protocol = 'https:';
+  url.username = '';
+  url.password = '';
+  if (url.port === '22') url.port = '';
+  url.search = '';
+  url.hash = '';
+  url.pathname = url.pathname.replace(/\.git\/?$/i, '').replace(/\/$/, '');
+  return url.toString().replace(/\/$/, '');
+};
+
+const worktreeSnapshot = (top, outputs, untracked, branch, repoUrl) => {
   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 };
+  return { top, parsed, branch, repositoryUrl: repoUrl };
 };
 
 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 };
+  const revShort = await shortRev(top, commit);
+  const branch = await currentBranch(top);
+  const repoUrl = repositoryUrl(remoteOrigin(top));
+  return { top, parsed, rev: commit, revShort, branch, repositoryUrl: repoUrl };
 };
 
 function* commitDiff(commit, paths) {
@@ -296,6 +348,38 @@ const worktreeCommands = (paths) => [
   untrackedArgs(paths),
 ];
 
+const gitView = async (top, paths, signal) => {
+  const commands = worktreeCommands(paths);
+  const running = commands.map((args) => runGit(args, top, { signal }));
+  const results = await Promise.all(running);
+  const outputs = results.map((result) => requireOk(result).stdout);
+  return {
+    staged: outputs[0],
+    work: outputs[1],
+    untracked: namesFromLs(outputs[2]),
+  };
+};
+
+const worktreeView = async (top, paths, signal) => {
+  // status -vv prints every diff and ignores the pathspec
+  if (paths.length) return gitView(top, paths, signal);
+  const extra = { signal, env: STATUS_ENV };
+  const result = await runGit(STATUS_ARGS, top, extra);
+  if (result.status !== 0) return gitView(top, paths, signal);
+  const parsed = parseStatus(result.stdout);
+  if (!parsed) return gitView(top, paths, signal);
+  return parsed;
+};
+
+const countUntrackedAdded = async (top) => {
+  try {
+    const view = await worktreeView(top, []);
+    return addedOf(view.untracked, top);
+  } catch {
+    return 0;
+  }
+};
+
 const readSnapshot = async (cwd, paths, options) => {
   const { commit: rev, signal } = options;
   const top = await toplevel(cwd, signal);
@@ -303,14 +387,12 @@ const readSnapshot = async (cwd, paths, options) => {
     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 view = await worktreeView(top, paths, signal);
+  const untracked = await untrackedItems(top, view.untracked);
+  const branch = await currentBranch(top);
+  const repoUrl = repositoryUrl(remoteOrigin(top));
+  const outputs = [view.staged, view.work];
+  return worktreeSnapshot(top, outputs, untracked, branch, repoUrl);
 };
 
 const applyPatch = async (cwd, patch, flags) => {
@@ -446,6 +528,29 @@ const stagePath = async (top, rel) => {
   if (rel) await gitOk(['add', '--', rel], top);
 };
 
+const sumDelta = (items) => {
+  let added = 0;
+  let removed = 0;
+  for (const item of items) {
+    const delta = lineDelta(item);
+    added += delta.added;
+    removed += delta.removed;
+  }
+  return { added, removed };
+};
+
+const diffCounts = async (top) => {
+  const view = await worktreeView(top, []);
+  const staged = sumDelta(itemsFromFiles(parseDiff(view.staged), 'staged'));
+  const open = sumDelta(itemsFromFiles(parseDiff(view.work), 'unstaged'));
+  return {
+    stagedAdded: staged.added,
+    unstagedAdded: open.added + addedOf(view.untracked, top),
+    stagedRemoved: staged.removed,
+    unstagedRemoved: open.removed,
+  };
+};
+
 module.exports = {
   requireOk,
   gitOk,
@@ -463,6 +568,7 @@ module.exports = {
   currentBranch,
   fileText,
   countUntrackedAdded,
+  diffCounts,
   listScopeFiles,
   readSnapshot,
   editItem,

package/lib/input/actions.js

@@ -59,6 +59,7 @@ const NPM_ACTIONS = {
   npmDrop: ['delete'],
   npmLogs: ['l'],
   npmStop: ['s'],
+  npmSolve: ['s'],
   npmVerbose: ['v'],
   npmRerun: ['r'],
 };
@@ -69,6 +70,8 @@ const AGENT_ACTIONS = {
   agentFast: ['a'],
   agentContext: ['t'],
   agentReview: ['p'],
+  agentInstall: ['i'],
+  agentStart: ['s'],
   agentStop: ['s'],
   agentRerun: ['r'],
 };
@@ -79,6 +82,8 @@ const AGENT_LIST_ACTIONS = {
   agentFast: AGENT_ACTIONS.agentFast,
   agentContext: AGENT_ACTIONS.agentContext,
   agentReview: AGENT_ACTIONS.agentReview,
+  agentInstall: AGENT_ACTIONS.agentInstall,
+  agentStart: AGENT_ACTIONS.agentStart,
 };
 
 const DASH_TILES = [
@@ -100,6 +105,11 @@ for (const tile of DASH_TILES) {
   DASH_KEYS[tile.key] = tile.action;
 }
 const DASH_IDS = Object.keys(DASH_ACTIONS);
+const WORKTREE_ACTIONS = {
+  worktreeNew: ['insert'],
+  worktreeDrop: ['delete'],
+  worktreeBranch: ['w'],
+};
 const DASH_ALLOWED = [
   ...Object.keys(DASH_BLOCKS),
   'back',
@@ -115,17 +125,28 @@ const REPOS_ALLOWED = [
   'repoDown',
   'open',
   'back',
+  'worktreeNew',
+  'worktreeDrop',
   'quit',
   'theme',
 ];
 const DASH_HIDDEN = ACTION_IDS.filter((id) => id !== 'quit');
 
 const ACTION_HOT = {
+  textCut: 'ctrl+x',
+  textCopy: 'ctrl+c',
+  textPaste: 'ctrl+v',
+  textDelete: 'del',
+  textSelectAll: 'ctrl+a',
+  open: 'enter',
   prev: '←',
   next: '→',
   drop: 'del',
+  worktreeDrop: 'del',
+  worktreeBranch: 'w',
   newBranch: 'ins',
   newCommit: 'ins',
+  worktreeNew: 'ins',
   feedback: 'q',
   check: 'space',
   taskUp: 'ctrl+up',
@@ -143,7 +164,13 @@ const ACTION_HOT = {
 };
 
 const ACTION_LABEL = {
+  textCut: 'ctrl+x cut',
+  textCopy: 'ctrl+c copy',
+  textPaste: 'ctrl+v paste',
+  textDelete: 'delete',
+  textSelectAll: 'ctrl+a select all',
   ...DASH_BLOCKS,
+  open: 'enter open',
   revert: 'drop',
   check: 'space',
   taskUp: 'ctrl+up',
@@ -161,6 +188,9 @@ const ACTION_LABEL = {
   drop: 'delete',
   newBranch: 'insert',
   newCommit: 'insert',
+  worktreeNew: 'insert',
+  worktreeDrop: 'delete',
+  worktreeBranch: 'worktree',
   feedback: 'quote',
   npmEdit: 'edit',
   npmNew: 'insert',
@@ -171,6 +201,7 @@ const ACTION_LABEL = {
   packageWanted: 'wanted',
   packageLatest: 'latest',
   npmStop: 'stop',
+  npmSolve: 'solve',
   npmVerbose: 'verbose',
   npmRerun: 're-run',
   agentModel: 'model',
@@ -178,6 +209,8 @@ const ACTION_LABEL = {
   agentFast: 'fast',
   agentContext: 'context',
   agentReview: 'plan',
+  agentInstall: 'install',
+  agentStart: 'start',
   agentStop: 'stop',
   agentRerun: 're-run',
   quit: 'q',
@@ -384,7 +417,12 @@ const keysForActions = (actions) => {
 const PANE_ONLY = ['branch', 'file', 'diff'];
 const REVIEW_DROP = { d: 'revert' };
 const DIFF_KEYS = { ...REVIEW_DROP, q: 'feedback', 'ctrl-l': 'lines' };
-const BRANCH_KEYS = keysForActions(BRANCH_ACTIONS);
+const BRANCH_KEYS = {
+  ...keysForActions(BRANCH_ACTIONS),
+  w: 'worktreeBranch',
+  left: 'treeLeft',
+  right: 'treeRight',
+};
 const COMMIT_KEYS = { ...keysForActions(COMMIT_ACTIONS), s: 'push' };
 const NPM_KEYS = {
   e: 'npmEdit',
@@ -413,6 +451,8 @@ const PANE_KEYS = {
     j: 'repoDown',
     p: 'repoLeft',
     n: 'repoRight',
+    insert: 'worktreeNew',
+    delete: 'worktreeDrop',
   },
 };
 
@@ -427,7 +467,8 @@ const KEY_TO_ACTION = {
 };
 
 const actionFromKey = (key, pane) => {
-  if (LIST_PANES.includes(pane) && (key === 'left' || key === 'right')) {
+  const sideways = key === 'left' || key === 'right';
+  if (LIST_PANES.includes(pane) && sideways && pane !== 'branches') {
     return null;
   }
   const paneKeys = PANE_KEYS[pane];
@@ -443,6 +484,7 @@ const ACTION_KEYS = {
   ...NPM_ACTIONS,
   ...COMMIT_ACTIONS,
   ...BRANCH_ACTIONS,
+  ...WORKTREE_ACTIONS,
   ...ACTIONS,
 };
 
@@ -450,6 +492,17 @@ const actionKeys = (id) => ACTION_KEYS[id] ?? [];
 
 const actionLetter = (id) => ACTION_HOT[id] ?? actionKeys(id)[0];
 
+const ACTION_CAPTION = {
+  open: 'open',
+  check: 'check',
+  textCut: 'cut',
+  textCopy: 'copy',
+  textPaste: 'paste',
+  textSelectAll: 'select all',
+};
+
+const actionCaption = (id) => ACTION_CAPTION[id] ?? ACTION_LABEL[id] ?? id;
+
 const buttonWord = (id) => {
   const word = ACTION_LABEL[id] ?? ACTION_HOT[id] ?? id;
   const mark = actionLetter(id);
@@ -486,6 +539,15 @@ const CONFIRM = {
       escape: 'decline',
     },
   },
+  confirmAgentInstall: {
+    choices: YES_NO,
+    prefix: (view) => ` install ${view.agentInstallPackage ?? ''}?`,
+    keys: {
+      y: 'confirm',
+      n: 'cancel',
+      escape: 'cancel',
+    },
+  },
   confirmDrop: {
     choices: YES_NO,
     prefix: (view) => ` drop ${view.dropName ?? ''}?`,
@@ -495,6 +557,24 @@ const CONFIRM = {
       escape: 'cancel',
     },
   },
+  confirmWorktree: {
+    choices: YES_NO,
+    prefix: (view) => ` remove ${view.dropName ?? ''}?`,
+    keys: {
+      y: 'confirm',
+      n: 'cancel',
+      escape: 'cancel',
+    },
+  },
+  confirmCreateWorktree: {
+    choices: YES_NO,
+    prefix: (view) => ` create ${view.worktreeTarget ?? ''}?`,
+    keys: {
+      y: 'confirm',
+      n: 'cancel',
+      escape: 'cancel',
+    },
+  },
   confirmPush: {
     choices: [{ letter: 'f', label: 'force push', lead: ' ' }],
     prefix: ' Need force-push?',
@@ -571,6 +651,7 @@ module.exports = {
   isFixupCommit,
   actionFromKey,
   actionLetter,
+  actionCaption,
   buttonWord,
   CONFIRM,
   CONFIRM_MODE,

package/lib/input/editor.js

@@ -139,6 +139,15 @@ class Editor {
     this.edit(next, this.cursor - size);
   }
 
+  backspaceWord() {
+    this.wantCol = null;
+    if (this.removeSpan()) return;
+    const { parts, i } = graphemeIndex(this.text, this.cursor);
+    const start = offsetAt(parts, wordIndex(parts, i, -1));
+    if (start === this.cursor) return;
+    this.edit(this.text.slice(0, start) + this.text.slice(this.cursor), start);
+  }
+
   delete() {
     this.wantCol = null;
     if (this.removeSpan()) return;

package/lib/input/keys.js

@@ -45,6 +45,15 @@ const CSI_TILDE = {
   24: 'f12',
 };
 
+// Kitty CSI-u and xterm modifyOtherKeys. 13 is Enter, 10 is line feed.
+const CSI_U = {
+  10: 'enter',
+  13: 'enter',
+  127: 'backspace',
+};
+
+const MODIFY_OTHER = '27';
+
 const CSI_MAX = 16;
 
 const LITERAL_KEY = {
@@ -71,20 +80,40 @@ const keyAt = (key, end) => ({ event: { type: 'key', key }, end });
 const modifiedKey = (base, modText) => {
   const arrow = ARROW_KEYS.includes(base);
   const end = EDGE_KEYS.includes(base);
-  if (!arrow && !end) return base;
   const mod = parseInt(modText, 10);
   const bits = Number.isFinite(mod) ? mod - 1 : 0;
   const ctrl = (bits & 4) !== 0;
   const shift = (bits & 1) !== 0;
+  if (base === 'backspace' && ctrl) return 'ctrl-backspace';
+  if (base === 'enter') {
+    if (ctrl && shift) return 'ctrl-shift-enter';
+    if (ctrl) return 'ctrl-enter';
+    if (shift) return 'shift-enter';
+    return 'enter';
+  }
+  if (!arrow && !end) return base;
   if (ctrl && shift && arrow) return `ctrl-shift-${base}`;
   if (ctrl && arrow) return `ctrl-${base}`;
   if (shift) return `shift-${base}`;
   return base;
 };
 
+const NEWLINE_KEYS = ['ctrl-enter', 'shift-enter', 'ctrl-shift-enter'];
+
+const isNewlineKey = (key) => NEWLINE_KEYS.includes(key);
+
+const otherModified = (params) => {
+  const base = CSI_U[params[2]];
+  if (!base) return null;
+  return modifiedKey(base, params[1] ?? '1');
+};
+
 const keyFromCsi = (paramsText, final) => {
   const params = paramsText ? paramsText.split(';') : [];
-  const base = final === '~' ? CSI_TILDE[params[0]] : CSI_KEYS[final];
+  if (final === '~' && params[0] === MODIFY_OTHER) return otherModified(params);
+  let base = CSI_KEYS[final];
+  if (final === '~') base = CSI_TILDE[params[0]];
+  if (final === 'u') base = CSI_U[params[0]];
   if (!base) return null;
   if (params.length < 2) return base;
   return modifiedKey(base, params[1]);
@@ -108,6 +137,7 @@ const mouseKind = (button, press) => {
   const wheel = MOUSE_WHEEL[button];
   if (wheel) return wheel;
   if (!press) return 'release';
+  if ((button & 35) === 35) return 'move';
   return button & 32 ? 'drag' : 'press';
 };
 
@@ -190,4 +220,10 @@ const hitAction = (hits, x) => {
   return null;
 };
 
-module.exports = { ACTIONS, decodeChunk, hitAction, isTextKey };
+module.exports = {
+  ACTIONS,
+  decodeChunk,
+  hitAction,
+  isTextKey,
+  isNewlineKey,
+};

package/lib/input/line-edit.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { Editor } = require('./editor.js');
-const { isTextKey } = require('./keys.js');
+const { isTextKey, isNewlineKey } = require('./keys.js');
 const clipboard = require('../term/clipboard.js');
 
 const copyLine = (editor, ui) => {
@@ -33,6 +33,7 @@ const EDIT_OP = {
   'ctrl-shift-left': (editor) => editor.moveWord(-1, true),
   'ctrl-shift-right': (editor) => editor.moveWord(1, true),
   backspace: (editor) => editor.backspace(),
+  'ctrl-backspace': (editor) => editor.backspaceWord(),
   delete: (editor) => editor.delete(),
 };
 
@@ -56,6 +57,10 @@ const lineKey = (editor, key, ui, ends) => {
     copyLine(editor, ui);
     return 'caret';
   }
+  if (isNewlineKey(key)) {
+    editor.insert('\n');
+    return 'text';
+  }
   const op = (ends ? LINE_ENDS : LINE_OP)[key];
   if (!op && !isTextKey(key)) return null;
   const before = editor.text;
@@ -64,8 +69,8 @@ const lineKey = (editor, key, ui, ends) => {
   return editor.text === before ? 'caret' : 'text';
 };
 
-const lineField = (name) => {
-  const editor = new Editor('');
+const lineField = (name, text = '') => {
+  const editor = new Editor(text);
   return {
     editor,
     get [name]() {