reslop 0.3.0 → 0.3.2

package/lib/session/npm/npm.js

@@ -30,6 +30,8 @@ const { historyName, historyMark, countText, elapsedText } = historyPart;
 const { whenLabel, runLabel, logBase, applyExternal } = historyPart;
 const { recordedItem, sameWindow, noteTests, filteredOutput } = historyPart;
 const { size } = require('../../common/format.js');
+const { TASKS_FILE } = require('../../common/files.js');
+const { stripAnsi } = require('../../term/ansi.js');
 
 const NAME_RE = /^[\w:.-]+$/;
 
@@ -54,11 +56,30 @@ class NpmController extends RunPanel {
     this.reset();
   }
 
+  // Runs belong to the worktree they started in and go on while another
+  // one is shown
+  get runs() {
+    let list = this.byTop.get(this.ui.top);
+    if (!list) {
+      list = [];
+      this.byTop.set(this.ui.top, list);
+    }
+    return list;
+  }
+
+  set runs(list) {
+    this.byTop.set(this.ui.top, list);
+  }
+
+  everyRun() {
+    return [...this.byTop.values()].flat();
+  }
+
   reset() {
-    for (const run of this.runs ?? []) {
+    for (const run of this.byTop ? this.everyRun() : []) {
       if (run.status === 'running' && run.child) run.child.kill();
     }
-    this.runs = [];
+    this.byTop = new Map();
     this.nextId = 1;
     this.viewId = 0;
     this.focus = 'commands';
@@ -83,7 +104,28 @@ class NpmController extends RunPanel {
   }
 
   get running() {
-    return this.runs.some((run) => run.status === 'running');
+    return this.everyRun().some((run) => run.status === 'running');
+  }
+
+  // The count of runs in work by the directory they started in
+  liveByRoot() {
+    const live = new Map();
+    for (const run of this.everyRun()) {
+      if (run.status !== 'running') continue;
+      live.set(run.top, (live.get(run.top) ?? 0) + 1);
+    }
+    return live;
+  }
+
+  // Another worktree is shown: its commands and runs replace these
+  retarget() {
+    this.viewing = false;
+    this.verbose = false;
+    this.viewId = 0;
+    this.runCursor = 0;
+    this.commands = [];
+    this.dropName = '';
+    this.logBytes = 0;
   }
 
   view(active) {
@@ -103,6 +145,7 @@ class NpmController extends RunPanel {
       npmDraftName: this.draftName,
       npmDraftCommand: this.draftCommand,
       npmRunning: this.viewedRunning(),
+      npmCanSolve: this.canSolve(),
       npmLogs: active ? this.logLabel : '',
     };
   }
@@ -173,6 +216,39 @@ class NpmController extends RunPanel {
     return Boolean(run && run.status === 'running');
   }
 
+  canSolve() {
+    const run = this.viewedRun();
+    if (!this.viewing || !run || run.status !== 'exited') return false;
+    return run.exit !== 0 && run.exit !== '0' && run.exit !== '';
+  }
+
+  solve() {
+    const ui = this.ui;
+    if (!this.canSolve() || !ui.review.store) return;
+    const run = this.viewedRun();
+    this.hydrate(run);
+    this.syncOutput(run);
+    const root = run.top ?? ui.top;
+    const output = stripAnsi(
+      run.raw
+        ? filteredOutput(run.raw, root, run.exit).output
+        : reduceOutput(run.output, root, ''),
+    ).trim();
+    const limit = 6000;
+    const shortened =
+      output.length > limit
+        ? `${output.slice(0, limit)}\n… (truncated)`
+        : output;
+    const command = run.command || run.label || runLabel(run);
+    const text = `${command} failed (exit ${run.exit})\n\n${shortened}`;
+    const task = ui.review.store.addTask(TASKS_FILE, text, false, 'bugs');
+    this.closeView();
+    const tasks = ui.composer.tasks;
+    tasks.openTasksPage();
+    tasks.followRow({ task });
+    ui.flushReview(true);
+  }
+
   historyRuns() {
     const runs = this.runs.filter((run) => !launchedReslop(run));
     return foldSteps(runs).slice(0, RUN_KEEP);
@@ -239,6 +315,7 @@ class NpmController extends RunPanel {
     const run = newRun(this.nextId, {
       name: item.name,
       kind: item.kind,
+      script: item.script ?? '',
       command: item.command ?? '',
       label: item.kind === 'command' ? historyName(item) : runLabel(item),
       status: item.status,
@@ -248,6 +325,7 @@ class NpmController extends RunPanel {
       logName: item.logName,
       rawName: item.rawName,
       externalId: item.externalId || '',
+      top: this.ui.top,
       result: item.result ?? null,
       progress: item.progress ?? null,
       saved: true,
@@ -321,6 +399,25 @@ class NpmController extends RunPanel {
     this.runs = [...done, ...running];
   }
 
+  followAdded(added) {
+    const current = this.viewedRun();
+    if (!this.viewing || !current?.externalId || !current.script) return false;
+    if (current.followEnd === false) return false;
+    const next = added
+      .filter(
+        (run) =>
+          run.script === current.script &&
+          run.startedAt >= current.startedAt &&
+          sameWindow(current, run),
+      )
+      .sort((left, right) => left.startedAt - right.startedAt)
+      .at(-1);
+    if (!next) return false;
+    this.viewId = next.id;
+    this.focusRun(next);
+    return true;
+  }
+
   followExternal() {
     this.syncProgress();
     if (this.ui.nav.pane === 'npm') this.ui.paint();
@@ -337,8 +434,9 @@ class NpmController extends RunPanel {
     const added = [];
     let changed = this.absorbRecorded(recorded, this.knownLogs(), added);
     if (this.settleLost(recorded)) changed = true;
-    if (this.hydrate(this.viewedRun())) changed = true;
     this.storeAdded(added);
+    if (this.followAdded(added)) changed = true;
+    if (this.hydrate(this.viewedRun())) changed = true;
     if (changed) this.followExternal();
   }
 
@@ -487,8 +585,9 @@ class NpmController extends RunPanel {
     if (!run.stale) return false;
     run.stale = false;
     run.shownAt = Date.now();
-    noteTests(run, this.runs, run.raw);
-    run.output = filteredOutput(run.raw, this.ui.top, '').output;
+    const top = run.top ?? this.ui.top;
+    noteTests(run, this.byTop.get(top) ?? this.runs, run.raw);
+    run.output = filteredOutput(run.raw, top, '').output;
     return true;
   }
 
@@ -500,25 +599,23 @@ class NpmController extends RunPanel {
 
   async finishRun(run, entry, result) {
     const ui = this.ui;
+    const top = run.top ?? ui.top;
     const stopped = run.stopping === true;
     const raw = stopped ? withNotice(run.raw, 'terminated') : result.text;
     let slot = null;
     try {
-      slot = nextLogFile(ui.top, entry.name);
+      slot = nextLogFile(top, entry.name);
     } catch (error) {
       ui.status = error.message;
     }
     const rawFile = slot ? slot.rawName : '';
     const stoppedOutput = () => {
-      const output = withNotice(
-        reduceOutput(run.raw, ui.top, ''),
-        'terminated',
-      );
+      const output = withNotice(reduceOutput(run.raw, top, ''), 'terminated');
       return { output, log: output };
     };
     const filtered = stopped
       ? stoppedOutput()
-      : filteredOutput(result.text, ui.top, result.status, rawFile);
+      : filteredOutput(result.text, top, result.status, rawFile);
     run.raw = raw;
     run.stale = false;
     run.exit = stopped ? '' : result.status;
@@ -555,6 +652,7 @@ class NpmController extends RunPanel {
       exit: '',
       startedAt: Date.now(),
       endedAt: 0,
+      top: ui.top,
     });
     this.nextId += 1;
     this.runs.push(run);
@@ -638,7 +736,7 @@ class NpmController extends RunPanel {
   }
 
   stopAll() {
-    for (const run of this.runs) this.stop(run);
+    for (const run of this.everyRun()) this.stop(run);
   }
 
   toggleVerbose() {

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,
 };