reslop 0.3.1 → 0.3.2

package/lib/session/ops.js

@@ -154,6 +154,7 @@ class ChangeQueue {
   }
 
   enqueue(job) {
+    this.runner.writeEpoch += 1;
     if (this.reloading) {
       this.ui.loader.bump();
       this.reloading = false;
@@ -170,6 +171,7 @@ class OpsRunner {
     this.ui = ui;
     this.gitBusy = false;
     this.busy = '';
+    this.writeEpoch = 0;
     this.pending = new Set();
     this.writing = Promise.resolve();
     this.writers = 0;
@@ -186,6 +188,7 @@ class OpsRunner {
   }
 
   exclusive(write) {
+    this.writeEpoch += 1;
     const start = async () => write(this.ui.top);
     const turn = this.writers ? this.writing.then(start) : start();
     const release = () => {

package/lib/session/pointer.js

@@ -2,52 +2,19 @@
 
 const { extractText, isRange } = require('../term/select.js');
 const { scrollAtThumb, scrollThumb } = require('../render/primitives.js');
-const { indexAtRow } = require('../term/wrap.js');
+const editorPointer = require('./editor-pointer.js');
+const { hitAt, offsetOf, focusField, beginEditDrag, moveEditDrag } =
+  editorPointer;
 const filesPane = require('./files-pane.js');
 const { hitAction } = require('../input/keys.js');
+const { actionLetter, disabledActions } = require('../input/actions.js');
+const { dimFooterActions } = require('../render/footer.js');
+const textMenu = require('./text-menu.js');
+const { TEXT_ACTIONS, textEditor, textDisabled, runTextAction } = textMenu;
 const { copyText } = require('../term/clipboard.js');
 const { stopImport } = require('./import.js');
 
-const hitAt = (hits, cell) => {
-  for (const hit of hits) {
-    if (hit.y !== cell.y) continue;
-    const x0 = hit.x0 ?? hit.textX;
-    if (cell.x < x0) continue;
-    if (hit.x1 !== undefined && cell.x >= hit.x1) continue;
-    return hit;
-  }
-  return null;
-};
-
-const offsetOf = (hit, cellX) => {
-  const shown = cellX - hit.textX;
-  const col = Math.max(0, shown) + (hit.scroll || 0);
-  const at = indexAtRow(hit.start || 0, hit.text, col);
-  if (hit.limit !== undefined && at > hit.limit) return hit.limit;
-  return at;
-};
-
-const focusField = (ui, hit) => {
-  if (!hit.field || !ui.npm) return true;
-  if (hit.field === ui.npm.editField) return true;
-  return ui.npm.focusField(hit.field);
-};
-
-const placeClick = (ui, cell) => {
-  if (ui.mode !== 'compose' || !ui.editor) return false;
-  const hits = ui.lastFrame && ui.lastFrame.editHits;
-  if (!hits || !hits.length) return false;
-  const hit = hitAt(hits, cell);
-  if (!hit) return false;
-  if (!focusField(ui, hit)) {
-    ui.paint();
-    return true;
-  }
-  ui.editor.place(offsetOf(hit, cell.x));
-  ui.composer.syncCodeScroll();
-  ui.paint();
-  return true;
-};
+const COMBO_FIELDS = ['model', 'effort', 'context', 'plan'];
 
 const mouseCell = (ui, event) => {
   const size = ui.lastSize ?? ui.getSize();
@@ -112,10 +79,278 @@ const dismissImport = (ui, event) => {
   stopImport(ui);
 };
 
+const CONTEXT_ACTIONS = {
+  repos: ['open', 'worktreeNew', 'worktreeDrop'],
+  files: ['open', 'add', 'unstage', 'revert', 'ignore', 'code'],
+  branch: [
+    'open',
+    'newBranch',
+    'worktreeBranch',
+    'rebase',
+    'drop',
+    'pull',
+    'push',
+  ],
+  tree: ['open', 'worktreeNew', 'worktreeDrop'],
+  commits: ['open', 'apply', 'reword', 'drop', 'view'],
+  packages: ['packageNew', 'packageDrop', 'packageWanted', 'packageLatest'],
+  npm: ['open', 'npmEdit', 'npmDrop', 'npmLogs'],
+  npmRuns: ['open'],
+  agents: ['open', 'agentFast', 'agentInstall', 'agentStart'],
+  agentRuns: ['open', 'agentStart'],
+  tasks: ['open', 'check', 'import', 'drop'],
+};
+
+const EMPTY_ACTIONS = {
+  repos: ['worktreeNew'],
+  files: [],
+  branches: ['newBranch', 'worktreeBranch', 'pull', 'push'],
+  commits: ['newCommit', 'view', 'pull', 'push'],
+  npm: ['npmNew', 'npmLogs'],
+  packages: ['packageNew'],
+  agents: [],
+  tasks: ['import'],
+};
+
+const rowHit = (hits, cell) => {
+  const x = cell.x - 1;
+  return (hits ?? []).find((hit) => {
+    if (hit.y !== cell.y) return false;
+    if (hit.x0 === undefined) return true;
+    return x >= hit.x0 && x < hit.x1;
+  });
+};
+
+const selectContextRow = (ui, hit) => {
+  const pane = ui.pane;
+  if (pane === 'repos') {
+    const at = ui.workspace.rows.findIndex((row) => row.name === hit.cursor);
+    if (at >= 0) ui.workspace.cursor = at;
+    return CONTEXT_ACTIONS.repos;
+  }
+  if (pane === 'files') {
+    ui.nav.fileCursor = hit.cursor;
+    return CONTEXT_ACTIONS.files;
+  }
+  if (pane === 'branches') {
+    if (hit.tree) {
+      const at = ui.trees.rows.findIndex((row) => row.name === hit.cursor);
+      if (at >= 0) ui.trees.cursor = at;
+      ui.nav.treeFocus = true;
+      return CONTEXT_ACTIONS.tree;
+    }
+    ui.nav.treeFocus = false;
+    ui.nav.branchCursor = hit.cursor;
+    return CONTEXT_ACTIONS.branch;
+  }
+  if (pane === 'commits') {
+    ui.nav.commitCursor = hit.cursor;
+    return CONTEXT_ACTIONS.commits;
+  }
+  if (pane === 'packages') {
+    ui.nav.packagesCursor = hit.cursor;
+    return CONTEXT_ACTIONS.packages;
+  }
+  if (pane === 'npm') {
+    if (hit.side === 'runs') {
+      ui.npm.runCursor = hit.cursor;
+      ui.npm.focusRuns();
+      return CONTEXT_ACTIONS.npmRuns;
+    }
+    ui.nav.npmCursor = hit.cursor;
+    ui.npm.focusCommands();
+    return CONTEXT_ACTIONS.npm;
+  }
+  if (pane === 'agents') {
+    if (hit.side === 'runs') {
+      ui.agents.runCursor = hit.cursor;
+      ui.agents.focus = 'runs';
+      return CONTEXT_ACTIONS.agentRuns;
+    }
+    ui.nav.agentCursor = hit.cursor;
+    ui.agents.focusCli();
+    return CONTEXT_ACTIONS.agents;
+  }
+  if (pane === 'tasks') {
+    ui.nav.tasksFocus = hit.cursor;
+    return CONTEXT_ACTIONS.tasks;
+  }
+  return [];
+};
+
+const contextDisabled = (ui, actions) => {
+  const pane = ui.pane;
+  let target = ui.current();
+  if (pane === 'files') target = ui.fileCursorEntry();
+  if (pane === 'branches') target = ui.gitBranches.selected();
+  if (pane === 'commits') {
+    target = {
+      ...ui.commits.selected(),
+      canCommit: ui.commits.staged,
+      unstagedCurrent: !ui.rev && !ui.revShort,
+    };
+  }
+  const off = new Set([
+    ...disabledActions(pane, target),
+    ...dimFooterActions(ui.view()),
+  ]);
+  const branchWrites = [
+    'newBranch',
+    'worktreeBranch',
+    'worktreeNew',
+    'worktreeDrop',
+    'rebase',
+    'drop',
+    'pull',
+    'push',
+    'newCommit',
+    'apply',
+    'reword',
+  ];
+  if (!ui.capabilities.branches && pane !== 'tasks') {
+    for (const id of branchWrites) off.add(id);
+    if (pane === 'branches') off.add('open');
+  }
+  if (!ui.capabilities.changes) {
+    for (const id of ['add', 'unstage', 'revert', 'ignore']) off.add(id);
+    if (pane === 'files') off.add('code');
+    for (const id of actions) {
+      if (id.startsWith('package') || id.startsWith('npm')) off.add(id);
+    }
+  }
+  if (pane === 'repos' || ui.worktrees.focused()) {
+    const row = ui.worktrees.selected();
+    const current = ui.trees.currentIndex() === ui.trees.cursor;
+    if (
+      !row ||
+      row.main ||
+      ui.worktrees.workingIn(row) ||
+      (pane === 'branches' && current)
+    ) {
+      off.add('worktreeDrop');
+    }
+    if (!row || ui.worktrees.busy) off.add('worktreeNew');
+  }
+  if (pane === 'branches' && !ui.gitBranches.selected()) {
+    off.add('open');
+    off.add('worktreeBranch');
+  }
+  if (pane === 'npm') {
+    if (ui.npm.selected()?.kind !== 'script') {
+      off.add('npmEdit');
+      off.add('npmDrop');
+    }
+  }
+  if (pane === 'tasks') {
+    const row = ui.composer.tasks.rowAt(ui.nav.tasksFocus);
+    if (!row || row.draft) {
+      off.add('drop');
+      off.add('check');
+    }
+  }
+  return [...off].filter((id) => actions.includes(id));
+};
+
+const comboAt = (ui, cell) => {
+  if (ui.agents.pick || ui.composer.tasks.planOpen) return true;
+  const status = rowHit(ui.lastFrame?.statusHits, cell);
+  if (status && ['plan', 'plan-item', 'branch'].includes(status.id)) {
+    return true;
+  }
+  const hit = rowHit(ui.lastFrame?.fileHits, cell);
+  return (
+    ui.pane === 'agents' && hit && [...COMBO_FIELDS, 'menu'].includes(hit.field)
+  );
+};
+
+const onContextPress = (ui, event) => {
+  const frame = ui.lastFrame;
+  if (!frame) return;
+  const cell = mouseCell(ui, event);
+  ui.nav.contextMenu = null;
+  if (ui.pane === 'dashboard' || comboAt(ui, cell)) return void ui.paint();
+  const editor = textEditor(ui, cell);
+  if (editor) {
+    const hit = hitAt(frame.editHits ?? [], cell);
+    if (ui.mode === 'compose' && (!hit || !focusField(ui, hit))) return;
+    if (hit && !editor.hasSelect()) editor.place(offsetOf(hit, cell.x));
+    ui.nav.clearSelection();
+    ui.nav.contextMenu = {
+      x: cell.x - 1,
+      y: cell.y,
+      actions: TEXT_ACTIONS,
+      cursor: 0,
+      editor,
+      disabled: textDisabled(editor),
+    };
+    return void ui.paint();
+  }
+  if (ui.mode !== 'review' || cell.y <= 1 || cell.y >= frame.height - 1) return;
+  const hits = ui.pane === 'tasks' ? frame.taskHits : frame.fileHits;
+  const hit = rowHit(hits, cell);
+  if (!hit && ui.pane === 'branches') ui.nav.treeFocus = false;
+  const actions = hit ? selectContextRow(ui, hit) : EMPTY_ACTIONS[ui.pane];
+  if (!actions?.length) return void ui.paint();
+  ui.nav.clearSelection();
+  ui.nav.contextMenu = {
+    x: cell.x - 1,
+    y: cell.y,
+    actions,
+    cursor: 0,
+    disabled: contextDisabled(ui, actions),
+  };
+  ui.paint();
+};
+
+const contextKey = (mark) => {
+  if (mark === 'del') return 'delete';
+  if (mark === 'ins') return 'insert';
+  if (mark === 'space') return ' ';
+  return mark?.replace('+', '-');
+};
+
+const runContextAction = (ui, action) => {
+  const menu = ui.nav.contextMenu;
+  if (!menu || (menu.disabled ?? []).includes(action)) return;
+  ui.nav.contextMenu = null;
+  if (!runTextAction(ui, menu, action)) ui.dispatch(action);
+  ui.paint();
+};
+
+const handleContextKey = (ui, key) => {
+  const menu = ui.nav.contextMenu;
+  if (!menu) return false;
+  if (key === 'escape') {
+    ui.nav.contextMenu = null;
+    ui.paint();
+    return true;
+  }
+  if (key === 'up' || key === 'down') {
+    const delta = key === 'up' ? -1 : 1;
+    const last = menu.actions.length - 1;
+    menu.cursor = Math.max(0, Math.min(last, menu.cursor + delta));
+    ui.paint();
+    return true;
+  }
+  let action = key === 'enter' ? menu.actions[menu.cursor] : null;
+  if (!action) {
+    action = menu.actions.find((id) => contextKey(actionLetter(id)) === key);
+  }
+  if (!action) return true;
+  runContextAction(ui, action);
+  return true;
+};
+
 const onPress = (ui, event) => {
-  dismissImport(ui, event);
   const nav = ui.nav;
   const cell = mouseCell(ui, event);
+  if (nav.contextMenu) {
+    const hit = rowHit(ui.lastFrame?.contextHits, cell);
+    if (hit) return;
+    nav.contextMenu = null;
+  }
+  dismissImport(ui, event);
+  if (beginEditDrag(ui, cell, Boolean(event.button & 4))) return;
   if (startLogDrag(ui, cell)) return;
   nav.scrollDrag = null;
   nav.mouseAnchor = cell;
@@ -130,6 +365,7 @@ const onPress = (ui, event) => {
 const onDrag = (ui, event) => {
   const nav = ui.nav;
   const cell = mouseCell(ui, event);
+  if (moveEditDrag(ui, cell)) return;
   if (nav.scrollDrag) return void moveLogBar(ui, cell);
   if (!nav.mouseAnchor) return;
   nav.pendingClick = null;
@@ -190,8 +426,6 @@ const copySelection = (ui) => {
   ui.status = ok ? 'copied' : 'copy failed';
 };
 
-const COMBO_FIELDS = ['model', 'effort', 'context', 'plan'];
-
 const onAgentRunHit = (ui, hit) => {
   ui.agents.focus = 'runs';
   ui.agents.runCursor = hit.cursor;
@@ -260,6 +494,8 @@ const RELEASE_TARGETS = [
     match: (ui) => ui.pane === 'branches',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      if (hit.tree) return void ui.worktrees.pickTile(hit.cursor);
+      ui.nav.treeFocus = false;
       const again = armDoubleClick(ui.nav, 'branches', hit.cursor);
       ui.nav.branchCursor = hit.cursor;
       if (again) ui.gitBranches.onCheckoutBranch();
@@ -348,9 +584,17 @@ const releaseAgentMenu = (ui, cell) => {
 };
 
 const onRelease = (ui, event) => {
-  dismissImport(ui, event);
   const nav = ui.nav;
   const cell = mouseCell(ui, event);
+  if (nav.contextMenu) {
+    const hit = rowHit(ui.lastFrame?.contextHits, cell);
+    if (hit) return void runContextAction(ui, hit.id);
+    nav.contextMenu = null;
+    ui.paint();
+    return;
+  }
+  if (moveEditDrag(ui, cell, true)) return;
+  dismissImport(ui, event);
   if (nav.scrollDrag) {
     moveLogBar(ui, cell);
     nav.scrollDrag = null;
@@ -366,7 +610,6 @@ const onRelease = (ui, event) => {
   nav.pendingClick = null;
   nav.mouseAnchor = null;
   if (clickButton(ui, cell, clickId)) return;
-  if (placeClick(ui, cell)) return;
   if (ui.pane === 'agents' && ui.agents.pick) {
     return void releaseAgentMenu(ui, cell);
   }
@@ -390,6 +633,20 @@ const POINTER_HANDLERS = {
 
 const handlePointer = (ui, event) => {
   const kind = event.kind;
+  if (ui.nav.contextMenu && ['move', 'drag'].includes(kind)) {
+    const hit = rowHit(ui.lastFrame?.contextHits, mouseCell(ui, event));
+    if (hit && !hit.disabled && hit.cursor !== ui.nav.contextMenu.cursor) {
+      ui.nav.contextMenu.cursor = hit.cursor;
+      ui.paint();
+    }
+    return;
+  }
+  if (kind === 'move') return;
+  if (kind === 'press' && event.btn === 2) {
+    onContextPress(ui, event);
+    return;
+  }
+  if (event.btn === 2) return;
   const handler = POINTER_HANDLERS[kind];
   if (!handler) return;
   const isWheel = kind === 'wheelUp' || kind === 'wheelDown';
@@ -399,4 +656,5 @@ const handlePointer = (ui, event) => {
 
 module.exports = {
   handlePointer,
+  handleContextKey,
 };

package/lib/session/session.js

@@ -27,6 +27,7 @@ const dispatch = require('./dispatch.js');
 const { dispatchAction, confirmChoice, handleEvent } = dispatch;
 const { Dashboard } = require('./dashboard.js');
 const { Workspace } = require('./workspace.js');
+const { WorktreeController } = require('./worktrees.js');
 
 const bindAccessors = (target, owner, names) => {
   for (const name of names) {
@@ -134,6 +135,9 @@ const assignParts = (session, options) => {
   session.agents = new AgentsController(session);
   session.dashboard = new Dashboard(session);
   session.workspace = new Workspace(session);
+  const infoOf = () => session.treesInfo;
+  session.trees = new Workspace(session, { pane: 'branches', infoOf });
+  session.worktrees = new WorktreeController(session);
   session.lifecycle = new Lifecycle(session);
 };
 
@@ -181,6 +185,9 @@ class Session {
     this.agents.reset();
     this.dashboard.reset();
     this.workspace.reset();
+    this.worktrees.reset();
+    this.trees.reset();
+    this.treesInfo = null;
     this.top = this.cwd;
     this.branch = '';
     this.repositoryUrl = '';
@@ -262,7 +269,8 @@ class Session {
       panel.runScroll = frame.runScroll;
     }
     if (typeof frame.gridCols === 'number') {
-      this.workspace.cols = frame.gridCols;
+      const tiles = this.nav.pane === 'branches' ? this.trees : this.workspace;
+      tiles.cols = frame.gridCols;
     }
     if (this.nav.tasksOpen) this.nav.scroll = frame.scroll;
     const editScroll = frame.cursor && frame.cursor.scroll;
@@ -274,6 +282,7 @@ class Session {
     this.scheduleAutosave();
     this.dashboard.afterDraw();
     this.workspace.afterDraw();
+    this.trees.afterDraw();
   }
 
   scheduleAutosave() {
@@ -364,6 +373,7 @@ class Session {
     if (!result) return;
     if (result.kind === 'commit') this.commits.finishGitCommit();
     if (result.kind === 'branch') this.gitBranches.finishCreateBranch();
+    if (result.kind === 'worktree') this.worktrees.finishAdd();
     if (result.kind === 'npm') this.npm.finishEdit();
     if (result.kind === 'package') this.packages.finishAdd();
   }
@@ -393,6 +403,8 @@ class Session {
     this.collection.reset();
     this.reads.reset();
     this.review.reset();
+    this.npm.retarget();
+    this.agents.retarget();
     this.nav.pane = pane;
     this.nav.tasksOpen = false;
     this.nav.scroll = 0;
@@ -491,7 +503,7 @@ class Session {
       this.openLoad();
       // Populate the agent model cache while the initial screen is loading.
       // Opening the Agents pane can then use the cache instead of being the
-      // first place that starts its CLI probes.
+      // first place that asks each agent for its models.
       void this.agents.loadModels();
       this.openUpdate();
       this.draw();
@@ -520,6 +532,7 @@ class Session {
         this.lifecycle.stopWatch();
         this.dashboard.stop();
         this.workspace.stop();
+        this.trees.stop();
         this.term.stopListening();
         this.progress.clear();
         this.term.clearTimers();

package/lib/session/terminal.js

@@ -32,9 +32,9 @@ const watchResize = (stdout, proc, onResize, signal) => {
   return stop;
 };
 
-const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
+const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1003h\x1b[?1006h';
 const LEAVE_TERM =
-  '\x1b[?1006l\x1b[?1002l\x1b[?7h\x1b[0 q\x1b[?12l\x1b[?25h\x1b[?1049l';
+  '\x1b[?1006l\x1b[?1003l\x1b[?7h\x1b[0 q\x1b[?12l\x1b[?25h\x1b[?1049l';
 
 const sameCursor = (a, b) => {
   if (!a || !b) return !a && !b;

package/lib/session/text-menu.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const TEXT_ACTIONS = [
+  'textCut',
+  'textCopy',
+  'textPaste',
+  'textDelete',
+  'textSelectAll',
+];
+
+const textEditor = (ui, cell) => {
+  if (ui.mode === 'compose') return ui.editor;
+  const statusY = ui.lastFrame?.height - 1;
+  if (cell.y !== statusY) return null;
+  if (ui.mode === 'find') return ui.nav.find?.editor;
+  if (ui.mode === 'import') return ui.nav.import?.editor;
+  return null;
+};
+
+const textDisabled = (editor) => {
+  const off = editor.hasSelect() ? [] : ['textCut', 'textCopy'];
+  if (!editor.hasSelect() && editor.cursor >= editor.text.length) {
+    off.push('textDelete');
+  }
+  if (!editor.text) off.push('textSelectAll');
+  return off;
+};
+
+const TEXT_KEYS = {
+  textCut: 'ctrl-x',
+  textCopy: 'ctrl-c',
+  textPaste: 'ctrl-v',
+  textDelete: 'delete',
+};
+
+const runTextAction = (ui, menu, action) => {
+  const editor = menu.editor;
+  if (!editor) return false;
+  if (action === 'textSelectAll') {
+    editor.anchor = 0;
+    editor.cursor = editor.text.length;
+    if (ui.mode === 'compose') ui.composer.afterEdit();
+  } else {
+    const key = TEXT_KEYS[action];
+    if (key) ui.handleEvent({ type: 'key', key });
+  }
+  return true;
+};
+
+module.exports = { TEXT_ACTIONS, textEditor, textDisabled, runTextAction };

package/lib/session/view.js

@@ -137,6 +137,7 @@ const navView = (ui) => {
     scroll: nav.scroll,
     listScroll: nav.listScroll,
     selection: nav.selection,
+    contextMenu: nav.contextMenu,
     pane: nav.pane,
     fileScope: nav.fileScope,
     fileCursor: nav.fileCursor,
@@ -151,9 +152,22 @@ const navView = (ui) => {
 };
 
 const dropNameOf = (ui) => {
-  const { packages, gitBranches, commits, npm } = ui;
+  const { packages, gitBranches, commits, npm, worktrees } = ui;
   const name = packages.dropName || gitBranches.dropName;
-  return name || commits.dropName || npm.dropName;
+  return name || commits.dropName || npm.dropName || worktrees.dropName;
+};
+
+// One tile looks selected: the one under the cursor while the worktrees have
+// the focus, else the worktree that is shown
+const treesView = (ui) => {
+  const model = ui.trees.view();
+  const picked = ui.worktrees.focused() ? model.cursor : model.current;
+  return { ...model, cursor: picked < 0 ? model.cursor : picked };
+};
+
+const paneTrees = (ui, pane) => {
+  if (pane !== 'branches' || !ui.worktrees.hasPanels()) return null;
+  return treesView(ui);
 };
 
 const repoView = (ui) => {
@@ -180,6 +194,7 @@ const repoView = (ui) => {
     updateFrom: updater.from,
     updateTo: updater.to,
     dropName: dropNameOf(ui),
+    worktreeTarget: ui.worktrees.branchTarget,
   };
 };
 
@@ -200,6 +215,8 @@ const screenView = (ui) => {
     dashboard: pane === 'dashboard' ? ui.dashboard.view() : null,
     packages: pane === 'packages' ? ui.dashboard.packagesView() : null,
     repos: pane === 'repos' ? ui.workspace.view() : null,
+    trees: paneTrees(ui, pane),
+    treeFocus: ui.worktrees.focused(),
   };
 };