reslop 0.3.0 → 0.3.2

package/lib/session/branches.js

@@ -47,7 +47,7 @@ class BranchController {
     ui.refreshFromRepo({ keepEmpty: true, ...extra });
   }
 
-  async open() {
+  async open(focusTrees = false) {
     const ui = this.ui;
     const loaded = await this.loadBranches();
     if (!loaded) return;
@@ -55,9 +55,11 @@ class BranchController {
     const nav = ui.nav;
     nav.branchCursor = current < 0 ? 0 : current;
     nav.pane = 'branches';
+    nav.treeFocus = focusTrees;
     nav.resetListScroll('branches');
     ui.status = '';
     nav.clearSelection();
+    void ui.worktrees.refreshTrees();
   }
 
   runWrite(name, args, kind, done) {
@@ -76,8 +78,23 @@ class BranchController {
     ui.ops.hold(this.open());
   }
 
+  // The worktrees above the branches share the cursor keys with them: one
+  // element is selected, up from the first branch reaches the worktrees
+  moveBetweenTrees(delta) {
+    const nav = this.ui.nav;
+    if (!this.ui.worktrees.hasPanels()) return false;
+    if (nav.treeFocus) {
+      if (delta > 0) nav.treeFocus = false;
+      return true;
+    }
+    if (delta >= 0 || nav.branchCursor > 0) return false;
+    nav.treeFocus = true;
+    return true;
+  }
+
   onBranchMove(delta) {
     const nav = this.ui.nav;
+    if (this.moveBetweenTrees(delta)) return void (this.ui.status = '');
     if (!this.branches.length) {
       this.ui.status = 'nothing to review';
       return;
@@ -111,7 +128,6 @@ class BranchController {
     const after = (extra) => this.refreshAfterWrite(extra);
     const leave = () => {
       ui.composer.closeCompose();
-      ui.showFiles();
     };
     const done = `created ${name}`;
     ui.ops.runWrite(

package/lib/session/compose.js

@@ -6,7 +6,7 @@ const { noteInnerWidth, codeInnerWidth, todoBodyWidth, activeDigits } = render;
 const { commitMessageWidth } = require('../render/commits.js');
 const { listedCommits } = require('./commit.js');
 const { Editor } = require('../input/editor.js');
-const { isTextKey } = require('../input/keys.js');
+const { isTextKey, isNewlineKey } = require('../input/keys.js');
 const files = require('../common/files.js');
 const { itemPath, isTaskItem, isTasksEntry, listPath } = files;
 const { isReadOnlyOrigin } = files;
@@ -20,7 +20,13 @@ const unit = require('./unit.js');
 const clipboard = require('../term/clipboard.js');
 const { EDIT_OP, copyLine, cutLine } = require('../input/line-edit.js');
 
-const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
+const COMPOSE_EDITS = [
+  'backspace',
+  'ctrl-backspace',
+  'delete',
+  'ctrl-z',
+  'ctrl-y',
+];
 const COMPOSE_CLIP = ['ctrl-x', 'ctrl-v'];
 const COMPOSE_LEAVE = ['next', 'prev', 'tasks'];
 
@@ -33,10 +39,18 @@ const KIND = {
   branch: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
   npm: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
   package: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
+  worktree: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
 };
 
-const COMMAND_KINDS = ['commit', 'branch', 'npm', 'package'];
-const NOTE_VIEWS = ['feedback', 'commit', 'branch', 'npm', 'package'];
+const COMMAND_KINDS = ['commit', 'branch', 'npm', 'package', 'worktree'];
+const NOTE_VIEWS = [
+  'feedback',
+  'commit',
+  'branch',
+  'npm',
+  'package',
+  'worktree',
+];
 
 const itemNote = (item, text) => {
   const hunk = item.hunk;
@@ -668,8 +682,8 @@ class Composer {
   }
 
   handleKey(key) {
-    if (key === 'enter') {
-      const result = this.enter();
+    if (key === 'enter' || isNewlineKey(key)) {
+      const result = isNewlineKey(key) ? this.insertNewline() : this.enter();
       this.syncCodeScroll();
       return result;
     }

package/lib/session/dispatch.js

@@ -8,7 +8,7 @@ const { REPOS_ALLOWED } = actions;
 const { disabledActions, actionFromKey, confirmKey, lineHasDiff } = actions;
 const { onCommand } = require('./change-actions.js');
 const filesPane = require('./files-pane.js');
-const { handlePointer } = require('./pointer.js');
+const { handlePointer, handleContextKey } = require('./pointer.js');
 const { FIND_PANES, startFind, onFindKey } = require('./find.js');
 const { startImport, stopImport, onImportKey } = require('./import.js');
 const { unitBodyLines } = require('./view.js');
@@ -109,6 +109,7 @@ const HANDLERS = {
   packageLatest: (ui) => ui.packages.updateLatest(),
   npmLogs: (ui) => ui.npm.askLogs(),
   npmStop: (ui) => ui.npm.stop(),
+  npmSolve: (ui) => ui.npm.solve(),
   npmVerbose: (ui) => ui.npm.toggleVerbose(),
   npmRerun: (ui) => ui.npm.rerun(),
   agentModel: (ui) => ui.agents.openPick('model'),
@@ -116,9 +117,16 @@ const HANDLERS = {
   agentFast: (ui) => ui.agents.toggleFast(),
   agentContext: (ui) => ui.agents.openPick('context'),
   agentReview: (ui) => ui.agents.openPick('plan'),
+  agentInstall: (ui) => ui.agents.proposeInstall(),
+  agentStart: (ui) => ui.agents.startSelected(),
   agentStop: (ui) => ui.agents.stop(),
   agentRerun: (ui) => ui.agents.rerun(),
   quit: (ui) => ui.onQuit(),
+  treeLeft: (ui) => ui.worktrees.moveTree(-1),
+  treeRight: (ui) => ui.worktrees.moveTree(1),
+  worktreeNew: (ui) => ui.worktrees.onAdd(),
+  worktreeDrop: (ui) => ui.worktrees.onDrop(),
+  worktreeBranch: (ui) => ui.worktrees.onBranch(),
   repoLeft: (ui) => ui.workspace.move(-1, 0),
   repoRight: (ui) => ui.workspace.move(1, 0),
   repoUp: (ui) => ui.workspace.move(0, -1),
@@ -126,7 +134,22 @@ const HANDLERS = {
   ...DASH_HANDLERS,
 };
 
-const dispatchAction = (ui, action) => {
+// The keys of a branch do the same to the selected tile of the worktrees
+const TREE_ACTIONS = {
+  newBranch: 'worktreeNew',
+  drop: 'worktreeDrop',
+};
+const TREE_OFF = ['rebase', 'commit'];
+
+const forSelection = (ui, action) => {
+  if (!ui.worktrees.focused()) return action;
+  if (TREE_OFF.includes(action)) return null;
+  return TREE_ACTIONS[action] ?? action;
+};
+
+const dispatchAction = (ui, picked) => {
+  const action = forSelection(ui, picked);
+  if (!action) return;
   if (CONFIRM_MODE.includes(ui.mode)) return;
   if (ui.mode === 'import') stopImport(ui);
   if (action === 'lines' && (ui.pane === 'diff' || ui.pane === 'unit')) {
@@ -158,6 +181,10 @@ const CONFIRMATIONS = {
     accept: (ui) => ui.updater.accept(),
     decline: (ui) => ui.updater.decline(),
   },
+  confirmAgentInstall: {
+    confirm: (ui) => ui.agents.confirmInstall(),
+    cancel: (ui) => ui.agents.cancelInstall(),
+  },
   confirmDrop: {
     confirm: (ui) => {
       if (ui.packages.dropName) return void ui.packages.confirmDrop();
@@ -172,6 +199,14 @@ const CONFIRMATIONS = {
       ui.gitBranches.cancelDropBranch();
     },
   },
+  confirmWorktree: {
+    confirm: (ui) => ui.worktrees.confirmDrop(),
+    cancel: (ui) => ui.worktrees.cancelDrop(),
+  },
+  confirmCreateWorktree: {
+    confirm: (ui) => ui.worktrees.confirmBranch(),
+    cancel: (ui) => ui.worktrees.cancelBranch(),
+  },
   confirmPush: {
     force: (ui) => ui.gitBranches.onForcePush(),
     cancel: (ui) => ui.gitBranches.cancelPush(),
@@ -193,7 +228,10 @@ const confirmChoice = (ui, key) => {
 
 const NPM_VIEW_KEYS = {
   escape: (ui) => ui.npm.closeView(),
-  s: (ui) => ui.npm.stop(),
+  s: (ui) => {
+    if (ui.npm.viewedRunning()) ui.npm.stop();
+    else ui.npm.solve();
+  },
   r: (ui) => ui.npm.rerun(),
   v: (ui) => ui.npm.toggleVerbose(),
   e: () => {},
@@ -253,7 +291,9 @@ const planMenuKey = (ui, key) => {
 };
 
 const handleKey = (ui, key) => {
+  ui.nav.editDrag = null;
   if (CONFIRM_MODE.includes(ui.mode)) return void confirmChoice(ui, key);
+  if (handleContextKey(ui, key)) return;
   if (planMenuKey(ui, key)) return;
   if (ui.pane === 'tasks' && (key === 'ctrl-up' || key === 'ctrl-down')) {
     if (ui.mode === 'import') stopImport(ui);

package/lib/session/editor-pointer.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { indexAtRow } = require('../term/wrap.js');
+
+const hitAt = (hits, cell) =>
+  hits.find((hit) => {
+    if (hit.y !== cell.y) return false;
+    const x0 = hit.x0 ?? hit.textX;
+    return cell.x >= x0 && (hit.x1 === undefined || cell.x < hit.x1);
+  });
+
+const offsetOf = (hit, cellX) => {
+  const col = Math.max(0, cellX - hit.textX) + (hit.scroll || 0);
+  const at = indexAtRow(hit.start || 0, hit.text, col);
+  return Math.min(at, hit.limit ?? Infinity);
+};
+
+const focusField = (ui, hit) => {
+  if (ui.composeKind !== 'npm' || !hit.field) return true;
+  if (hit.field === ui.npm.editField) return true;
+  return ui.npm.focusField(hit.field);
+};
+
+const activeEditor = (ui) => {
+  if (ui.pane === 'agents' && ui.agents.pick) return ui.agents.pick.editor;
+  if (ui.pane === 'tasks' && ui.composer.tasks.planOpen) {
+    return ui.composer.tasks.planPick.editor;
+  }
+  if (ui.mode === 'find') return ui.nav.find?.editor;
+  if (ui.mode === 'import') return ui.nav.import?.editor;
+  return ui.mode === 'compose' ? ui.editor : null;
+};
+
+const editorHits = (ui, editor) =>
+  (ui.lastFrame?.editHits ?? []).filter(
+    (hit) => (hit.editor ?? ui.editor) === editor,
+  );
+
+const revealEditor = (ui) => {
+  if (ui.mode === 'compose') ui.composer.afterEdit();
+  ui.paint();
+};
+
+const beginEditDrag = (ui, cell, extend = false) => {
+  const editor = activeEditor(ui);
+  if (!editor) return false;
+  const hit = hitAt(editorHits(ui, editor), cell);
+  if (!hit) return false;
+  if (!focusField(ui, hit)) {
+    ui.paint();
+    return true;
+  }
+  const previous = editor.anchor ?? editor.cursor;
+  const anchor = extend ? previous : offsetOf(hit, cell.x);
+  editor.place(offsetOf(hit, cell.x));
+  if (extend && anchor !== editor.cursor) editor.anchor = anchor;
+  ui.nav.clearSelection();
+  ui.nav.editDrag = { editor, anchor, field: hit.field, cell };
+  revealEditor(ui);
+  return true;
+};
+
+const moveEditDrag = (ui, cell, release = false) => {
+  const drag = ui.nav.editDrag;
+  if (!drag) return false;
+  if (release && drag.cell.x === cell.x && drag.cell.y === cell.y) {
+    ui.nav.editDrag = null;
+    return true;
+  }
+  if (activeEditor(ui) === drag.editor) {
+    const hits = editorHits(ui, drag.editor).filter(
+      (hit) => hit.field === drag.field,
+    );
+    const hit = hits.reduce((nearest, candidate) => {
+      if (!nearest) return candidate;
+      return Math.abs(candidate.y - cell.y) < Math.abs(nearest.y - cell.y)
+        ? candidate
+        : nearest;
+    }, null);
+    if (hit) {
+      const x = Math.min(cell.x, (hit.x1 ?? cell.x + 1) - 1);
+      drag.editor.place(offsetOf(hit, x));
+      if (drag.anchor !== drag.editor.cursor) drag.editor.anchor = drag.anchor;
+      drag.cell = cell;
+      revealEditor(ui);
+    }
+  }
+  if (release) ui.nav.editDrag = null;
+  return true;
+};
+
+module.exports = {
+  hitAt,
+  offsetOf,
+  focusField,
+  beginEditDrag,
+  moveEditDrag,
+};

package/lib/session/files-pane.js

@@ -107,6 +107,9 @@ const onFiles = (ui) => {
 
 const onOpenFile = (ui) => {
   if (ui.nav.pane === 'packages') return;
+  if (ui.nav.pane === 'branches' && ui.worktrees.focused()) {
+    return void ui.ops.hold(ui.worktrees.enterSelected());
+  }
   if (ui.nav.pane === 'branches') {
     return void ui.gitBranches.onCheckoutBranch();
   }

package/lib/session/import.js

@@ -3,11 +3,22 @@
 const { remoteKind, selectChangeSource } = require('../source/source.js');
 const { lineKey, lineField } = require('../input/line-edit.js');
 
+const changeRepositoryUrl = (change) => {
+  if (!change?.url || !change.repository) return '';
+  try {
+    const url = new URL(change.url);
+    return `${url.origin}/${change.repository}`;
+  } catch {
+    return '';
+  }
+};
+
 const startImport = (ui) => {
   if (ui.mode !== 'review' || ui.pane !== 'tasks') return;
   ui.composer.tasks.closePlanMenu();
   ui.mode = 'import';
-  ui.nav.import = lineField('url');
+  const defaultUrl = ui.repositoryUrl || changeRepositoryUrl(ui.change);
+  ui.nav.import = lineField('url', defaultUrl);
   ui.status = '';
 };
 

package/lib/session/lifecycle.js

@@ -6,6 +6,9 @@ const path = require('node:path');
 const { isAbort } = require('../common/process.js');
 const { tagLoaded, fetchSnapshot, fetchExtras } = require('./load.js');
 const { DiskWatcher, DEBOUNCE_MS } = require('../dashboard/watch.js');
+const { watchedBy } = require('../dashboard/worktrees.js');
+const { dirKey } = require('../git/linked.js');
+const { resolveGitDirs } = require('../git/dir.js');
 const { itemPath, REVIEW_DIR } = require('../common/files.js');
 const { relativeAge } = require('../common/format.js');
 const { MANIFEST, LOCKFILE, depFileMeta } = require('../deps/deps.js');
@@ -73,16 +76,28 @@ class Lifecycle {
   constructor(ui) {
     this.ui = ui;
     this.diskWatcher = null;
+    this.treeWatcher = null;
     this.watchRetry = null;
     this.reviewStamp = '';
     this.ignoreWatchUntil = 0;
-    this.cachedExtras = null;
+    this.extras = new Map();
   }
 
   get root() {
     return this.ui.top || this.ui.cwd;
   }
 
+  // The reports of npm are kept for each worktree: showing another one does
+  // not ask npm again, and the reports of one are never taken for another
+  get cachedExtras() {
+    return this.extras.get(this.root) ?? null;
+  }
+
+  set cachedExtras(entry) {
+    if (entry) this.extras.set(this.root, entry);
+    else this.extras.delete(this.root);
+  }
+
   loadOptions(extra = {}) {
     const ui = this.ui;
     return {
@@ -169,6 +184,9 @@ class Lifecycle {
 
   applySource(loaded) {
     const ui = this.ui;
+    if (loaded.repositoryUrl !== undefined) {
+      ui.repositoryUrl = loaded.repositoryUrl || '';
+    }
     if (loaded.rev) ui.rev = loaded.rev;
     if (loaded.revShort) ui.revShort = loaded.revShort;
     else if (ui.rev && !ui.revShort) ui.revShort = ui.rev.slice(0, 7);
@@ -191,7 +209,9 @@ class Lifecycle {
     const here = ui.current();
     ui.top = loaded.top ?? ui.cwd;
     this.applyPrefs();
-    collection.replace(loaded.items);
+    const seen = loaded.seenEpoch;
+    const fresh = seen === undefined || seen === ui.ops.writeEpoch;
+    if (fresh) collection.replace(loaded.items);
     stampItemDates(ui.top, collection.items);
     this.applySource(loaded);
     if (!ui.review.store) ui.initReview();
@@ -239,7 +259,7 @@ class Lifecycle {
   }
 
   clearNpmExtras() {
-    this.cachedExtras = null;
+    this.extras.clear();
   }
 
   npmExtras() {
@@ -276,7 +296,8 @@ class Lifecycle {
     const next = outcome.value;
     if (!this.isWanted(gen)) return;
     if (next) {
-      this.applyLoaded(tagLoaded(next, gen));
+      const seenEpoch = loaded.seenEpoch;
+      this.applyLoaded(tagLoaded({ ...next, seenEpoch }, gen));
       this.cacheNpmExtras(next);
     } else {
       ui.loader.pendingExtras = false;
@@ -313,6 +334,17 @@ class Lifecycle {
     if (extra.afterLoad) extra.afterLoad();
   }
 
+  // Remember the write epoch so a snapshot that started before stage or
+  // unstage does not paint that older index over the optimistic items.
+  async fetchSettled() {
+    const ui = this.ui;
+    const seenEpoch = ui.ops.writeEpoch;
+    const opts = this.snapshotOpts({ signal: ui.loader.signal });
+    const loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
+    if (!loaded) return loaded;
+    return { ...loaded, seenEpoch };
+  }
+
   async runSnapshot(gen, kind, extra = {}) {
     const ui = this.ui;
     if (extra.quiet !== true) {
@@ -323,8 +355,7 @@ class Lifecycle {
     let loaded = null;
     const side = ui.reads.read();
     try {
-      const opts = this.snapshotOpts({ signal: ui.loader.signal });
-      loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
+      loaded = await this.fetchSettled();
     } catch (error) {
       if (ui.loader.isCurrent(gen)) this.failOpen(error);
     }
@@ -474,21 +505,46 @@ class Lifecycle {
   stopWatch() {
     this.clearWatchRetry();
     this.reviewStamp = '';
+    this.stopTreeWatch();
     if (!this.diskWatcher) return;
     this.diskWatcher.close();
     this.diskWatcher = null;
   }
 
+  stopTreeWatch() {
+    if (!this.treeWatcher) return;
+    this.treeWatcher.close();
+    this.treeWatcher = null;
+  }
+
+  // The other worktrees of the repository are watched for their tiles; the
+  // one that is shown is watched with everything else
+  watchTrees() {
+    this.stopTreeWatch();
+    const ui = this.ui;
+    const info = ui.treesInfo;
+    if (!info || ui.trees.rows.length < 2 || !ui.top) return;
+    const root = dirKey(info.root);
+    const paths = [];
+    for (const row of ui.trees.rows) {
+      const dirs = resolveGitDirs(row.key);
+      if (dirs) paths.push(dirKey(dirs.gitDir));
+      if (row.key !== dirKey(root)) paths.push(row.key);
+    }
+    const onPaths = (rels) => ui.trees.notePaths(rels);
+    this.treeWatcher = new DiskWatcher({ root, paths, onPaths });
+  }
+
   startWatch() {
     this.stopWatch();
     const ui = this.ui;
     if (ui.nav.pane === 'repos') {
-      const root = ui.workspaceRoot;
-      if (!root) return;
+      if (!ui.workspaceRoot) return;
+      const root = dirKey(ui.workspaceRoot);
       const info = ui.workspaceInfo;
       const repos = info ? info.repos : [];
       const paths = ['.'];
-      for (const repo of repos) paths.push(path.join(repo.name, '.git'));
+      for (const repo of repos) paths.push(...watchedBy(root, repo));
       const matchReview = (rel) => rel.includes(`/${REVIEW_DIR}/`);
       const onPaths = (rels) => ui.workspace.notePaths(rels);
       const options = { root, paths, matchReview, onPaths };
@@ -502,10 +558,14 @@ class Lifecycle {
       paths: this.ui.paths,
       onChange: () => this.onDiskChange(),
       onReview: () => this.applyReviewChange(),
-      onPaths: (paths) => this.ui.dashboard.noteDisk(paths),
+      onPaths: (paths) => {
+        this.ui.dashboard.noteDisk(paths);
+        this.ui.trees.notePaths(paths);
+      },
     });
     this.syncItemWatches();
     this.noteReviewStamp();
+    this.watchTrees();
   }
 }
 

package/lib/session/navigation.js

@@ -17,6 +17,7 @@ class Navigation {
     this.index = 0;
     this.fileCursor = 0;
     this.branchCursor = 0;
+    this.treeFocus = false;
     this.commitCursor = 0;
     this.npmCursor = 0;
     this.packagesCursor = 0;
@@ -28,9 +29,11 @@ class Navigation {
     this.unitLine = 0;
     this.selection = null;
     this.mouseAnchor = null;
+    this.editDrag = null;
     this.pendingClick = null;
     this.scrollDrag = null;
     this.lastClick = null;
+    this.contextMenu = null;
     this.tasksOpen = false;
     this.tasksFocus = 0;
     this.find = null;
@@ -99,8 +102,10 @@ class Navigation {
   clearSelection() {
     this.selection = null;
     this.mouseAnchor = null;
+    this.editDrag = null;
     this.pendingClick = null;
     this.scrollDrag = null;
+    this.contextMenu = null;
   }
 
   get listScroll() {

package/lib/session/npm/history.js

@@ -189,6 +189,7 @@ const recordedItem = (record) => {
   return {
     name,
     kind: script ? 'script' : 'command',
+    script,
     command,
     status: externalStatus(record),
     exit: externalExit(record),
@@ -220,7 +221,8 @@ const whenLabel = (ms) => {
 };
 
 const elapsedText = (run, now) => {
-  const end = run.endedAt || now;
+  const end =
+    run.status === 'running' ? now : run.endedAt || run.startedAt || 0;
   const ms = Math.max(0, end - (run.startedAt || end));
   const sec = Math.round(ms / 1000);
   if (sec < 60) return `${sec}s`;