reslop 0.2.6 → 0.3.0

package/lib/session/npm/packages.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const {
+  IS_WIN,
+  npmBin,
+  runProc,
+  INSTALL_MS,
+} = require('../../common/process.js');
+const { oneLine } = require('../../common/utilities.js');
+
+class PackageController {
+  constructor(ui) {
+    this.ui = ui;
+    this.dropName = '';
+    this.addDev = false;
+    this.running = false;
+    this.job = null;
+  }
+
+  rows() {
+    const data = this.ui.dashboard.packagesView();
+    const modules = data.modules;
+    return modules && modules.packages ? modules.packages : [];
+  }
+
+  selected() {
+    return this.rows()[this.ui.nav.packagesCursor] ?? null;
+  }
+
+  canWrite() {
+    if (this.running) return false;
+    const ui = this.ui;
+    const caps = ui.capabilities;
+    if (!ui.readOnly && (!caps || caps.changes !== false)) return true;
+    ui.status = 'read only';
+    return false;
+  }
+
+  need() {
+    if (!this.canWrite()) return null;
+    const pkg = this.selected();
+    if (pkg) return pkg;
+    this.ui.status = 'not a package';
+    return null;
+  }
+
+  create() {
+    if (!this.canWrite()) return;
+    const pkg = this.selected();
+    if (pkg && pkg.transitive) {
+      this.ui.status = 'transitive';
+      return;
+    }
+    this.addDev = Boolean(pkg && pkg.dev);
+    this.ui.composer.openCompose('package', '');
+  }
+
+  finishAdd() {
+    const editor = this.ui.composer.editor;
+    if (!editor) return;
+    const name = editor.text.trim();
+    if (!name || /\s/.test(name) || name.startsWith('-')) {
+      this.ui.status = 'name';
+      return;
+    }
+    const args = ['install', name];
+    if (this.addDev) args.push('--save-dev');
+    this.ui.composer.closeCompose();
+    this.job = this.exec(args, 'npm i', `installed ${name}`);
+  }
+
+  askDrop() {
+    const pkg = this.need();
+    if (!pkg) return;
+    if (pkg.transitive) {
+      this.ui.status = 'transitive';
+      return;
+    }
+    this.dropName = pkg.name;
+    this.ui.mode = 'confirmDrop';
+    this.ui.status = '';
+  }
+
+  cancelDrop() {
+    this.dropName = '';
+    this.ui.mode = 'review';
+    this.ui.status = '';
+  }
+
+  confirmDrop() {
+    const name = this.dropName;
+    this.dropName = '';
+    this.ui.mode = 'review';
+    if (!name) return;
+    const done = `dropped ${name}`;
+    this.job = this.exec(['uninstall', name], 'npm uninstall', done);
+  }
+
+  updateWanted() {
+    const pkg = this.need();
+    if (!pkg) return;
+    const done = `updated ${pkg.name}`;
+    this.job = this.exec(['update', pkg.name], 'npm i', done);
+  }
+
+  updateLatest() {
+    const pkg = this.need();
+    if (!pkg) return;
+    const args = ['install', `${pkg.name}@latest`];
+    if (pkg.dev) args.push('--save-dev');
+    this.job = this.exec(args, 'npm i', `updated ${pkg.name}`);
+  }
+
+  async exec(args, busy, done) {
+    const ui = this.ui;
+    this.running = true;
+    ui.status = '';
+    ui.ops.setBusy(busy);
+    ui.ignoreWatch(INSTALL_MS);
+    ui.paint();
+    const run = async () => {
+      try {
+        const hook = ui.repo && ui.repo.runPackage;
+        const options = { cwd: ui.top, shell: IS_WIN };
+        const started = hook
+          ? hook(ui.top, args)
+          : runProc(npmBin(), args, options);
+        const result = await started;
+        return result;
+      } catch (error) {
+        return { error, status: 1, stderr: '' };
+      }
+    };
+    const result = await run();
+    this.running = false;
+    ui.ops.clearBusy();
+    const failed = !result || result.error || result.status;
+    if (failed) {
+      const message = result && result.error ? result.error.message : '';
+      const stderr = result ? result.stderr : '';
+      ui.status = oneLine(stderr, message || 'npm failed');
+    } else {
+      ui.status = done;
+      ui.dashboard.tasks.npm.request();
+    }
+    ui.paint();
+  }
+}
+
+module.exports = { PackageController };

package/lib/session/ops.js

@@ -1,16 +1,17 @@
 'use strict';
 
-const ASYNC_WITHOUT_UI = ['pull', 'push'];
-const QUIET_KIND = new Set(['staged', 'unstaged']);
+const { errorMessage } = require('../common/utilities.js');
+const { npmBusyKind } = require('./items.js');
 
-const pickRepoWrite = (repo, name, uiOpen) => {
-  const asyncFn = repo[`${name}Async`];
-  const allowAsync = uiOpen === true || ASYNC_WITHOUT_UI.includes(name);
-  const isAsync = allowAsync && typeof asyncFn === 'function';
-  return { async: isAsync, write: isAsync ? asyncFn : repo[name] };
-};
+const QUIET_KIND = ['staged', 'unstaged'];
+const POLL_MS = 5;
 
-const showsBusy = (kind) => Boolean(kind) && !QUIET_KIND.has(kind);
+const pause = (ms) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+const showsBusy = (kind) => Boolean(kind) && !QUIET_KIND.includes(kind);
 
 class ChangeQueue {
   constructor(ui, runner) {
@@ -22,6 +23,7 @@ class ChangeQueue {
     this.draining = false;
     this.pumpQueued = false;
     this.holding = false;
+    this.long = false;
     this.resume = null;
     this.reloading = false;
   }
@@ -43,6 +45,7 @@ class ChangeQueue {
     this.draining = false;
     this.pumpQueued = false;
     this.holding = false;
+    this.long = false;
     this.reloading = false;
     this.noteFree();
   }
@@ -87,6 +90,7 @@ class ChangeQueue {
   async takeJob(stamp) {
     const job = this.jobs[this.head];
     this.head += 1;
+    this.long = showsBusy(job.kind);
     this.armBusy(job.kind);
     try {
       await job.write(this.ui.top);
@@ -101,12 +105,20 @@ class ChangeQueue {
     return job.reload ? 'reload' : 'ok';
   }
 
+  // Only writes that land in milliseconds are queued or running: none shows
+  // a spinner and none waits behind a long git operation
+  quick() {
+    const working = this.draining || this.pumpQueued;
+    if (!working || this.long || this.hasPendingBusy()) return false;
+    return this.holding || !this.runner.gitBusy;
+  }
+
   schedule() {
     if (this.draining || this.pumpQueued) return;
     this.pumpQueued = true;
     queueMicrotask(() => {
       this.pumpQueued = false;
-      void this.run();
+      this.runner.track(this.run());
     });
   }
 
@@ -158,9 +170,89 @@ class OpsRunner {
     this.ui = ui;
     this.gitBusy = false;
     this.busy = '';
+    this.pending = new Set();
+    this.writing = Promise.resolve();
+    this.writers = 0;
+    this.holds = 0;
+    this.held = [];
     this.queue = new ChangeQueue(ui, this);
   }
 
+  track(promise) {
+    const settled = () => this.pending.delete(promise);
+    this.pending.add(promise);
+    promise.then(settled, settled);
+    return promise;
+  }
+
+  exclusive(write) {
+    const start = async () => write(this.ui.top);
+    const turn = this.writers ? this.writing.then(start) : start();
+    const release = () => {
+      this.writers -= 1;
+    };
+    this.writers += 1;
+    this.writing = turn.then(release, release);
+    return turn;
+  }
+
+  // Stages one item in its turn. An install can run for minutes, so it gets
+  // the lock to take around its own file and index steps instead
+  add(item) {
+    const { repo, top } = this.ui;
+    const locked = (write) => this.exclusive(write);
+    if (npmBusyKind(item)) return repo.add(top, item, { locked });
+    return locked((root) => repo.add(root, item));
+  }
+
+  unstage(item) {
+    return this.exclusive((top) => this.ui.repo.unstage(top, item));
+  }
+
+  // Input that arrives while a read is held waits for it, so keys keep order
+  hold(reading) {
+    const fail = (error) => {
+      this.ui.status = errorMessage(error);
+    };
+    const release = (value) => {
+      this.holds -= 1;
+      if (!this.holds) this.resume();
+      return value;
+    };
+    this.holds += 1;
+    return this.track(reading.catch(fail).then(release));
+  }
+
+  defer(event) {
+    if (!this.holds) return false;
+    this.held.push(event);
+    return true;
+  }
+
+  resume() {
+    const { ui, held } = this;
+    while (held.length && !this.holds && !ui.done) ui.handleEvent(held.shift());
+    if (ui.done) return void ui.finishInput();
+    ui.paint();
+  }
+
+  unlanded() {
+    return this.writers > 0 || this.queue.quick();
+  }
+
+  // Waits for quick repo writes to land, but never longer than the limit
+  async landed(limit) {
+    const deadline = Date.now() + limit;
+    while (this.unlanded() && Date.now() < deadline) await pause(POLL_MS);
+  }
+
+  async idle() {
+    await Promise.resolve();
+    while (this.pending.size || this.queue.pumpQueued) {
+      await Promise.allSettled([...this.pending]);
+    }
+  }
+
   setBusy(kind) {
     this.busy = kind;
     this.ui.startProgress();
@@ -174,21 +266,10 @@ class OpsRunner {
   reset() {
     this.gitBusy = false;
     this.busy = '';
+    this.held.length = 0;
     this.queue.reset();
   }
 
-  runRepo(label, write) {
-    const { ui } = this;
-    try {
-      write(ui.top);
-      ui.status = label;
-      return true;
-    } catch (error) {
-      ui.status = error.message;
-      return false;
-    }
-  }
-
   finishBusy(done, after) {
     const { ui } = this;
     if (ui.done || ui.mode === 'confirmPush') return void ui.paint();
@@ -197,7 +278,11 @@ class OpsRunner {
     ui.paint();
   }
 
-  async runBusy(kind, done, write, after) {
+  runBusy(kind, done, write, after) {
+    return this.track(this.busyWrite(kind, done, write, after));
+  }
+
+  async busyWrite(kind, done, write, after) {
     const { ui } = this;
     if (this.gitBusy) return;
     this.gitBusy = true;
@@ -223,17 +308,23 @@ class OpsRunner {
 
   runWrite(name, args, kind, done, after, leave = null) {
     const { ui } = this;
-    const picked = pickRepoWrite(ui.repo, name, ui.uiOpen);
-    const write = (top) => picked.write(top, ...args);
-    if (picked.async) {
-      if (leave) leave();
-      const refresh = () => after({ doneStatus: done });
-      return void this.runBusy(kind, done, write, refresh);
-    }
-    if (!this.runRepo(done, write)) return;
+    const write = (top) => ui.repo[name](top, ...args);
     if (leave) leave();
-    after({});
-    if (!ui.status) ui.status = done;
+    const refresh = () => after({ doneStatus: done });
+    return this.runBusy(kind, done, write, refresh);
+  }
+
+  async apply(label, write, after) {
+    const { ui } = this;
+    try {
+      await this.exclusive(write);
+      ui.status = label;
+      if (after) after();
+      return true;
+    } catch (error) {
+      ui.status = error.message;
+      return false;
+    }
   }
 
   enqueueLazy(job) {
@@ -241,4 +332,4 @@ class OpsRunner {
   }
 }
 
-module.exports = { pickRepoWrite, OpsRunner };
+module.exports = { OpsRunner };

package/lib/session/pointer.js

@@ -1,13 +1,53 @@
 'use strict';
 
-const select = require('../select.js');
-const editClick = require('./edit-click.js');
+const { extractText, isRange } = require('../term/select.js');
+const { scrollAtThumb, scrollThumb } = require('../render/primitives.js');
+const { indexAtRow } = require('../term/wrap.js');
 const filesPane = require('./files-pane.js');
-const { extractText, isRange } = select;
-const keys = require('../keys.js');
-const { hitAction } = keys;
-const clipboard = require('../clipboard.js');
-const { copyText } = clipboard;
+const { hitAction } = require('../input/keys.js');
+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 mouseCell = (ui, event) => {
   const size = ui.lastSize ?? ui.getSize();
@@ -16,9 +56,68 @@ const mouseCell = (ui, event) => {
   return { x, y };
 };
 
+const onLogBar = (bar, cell) => {
+  if (!bar || cell.x !== bar.x) return false;
+  const index = cell.y - bar.y;
+  return index >= 0 && index < bar.height;
+};
+
+const logLocal = (bar, cell) => {
+  const local = cell.y - bar.y - bar.track;
+  if (local < 0) return 0;
+  const last = bar.rows - 1;
+  if (local > last) return last;
+  return local;
+};
+
+const logGrab = (local, thumb) => {
+  if (local <= thumb.at) return 0;
+  const end = thumb.at + thumb.size - 1;
+  if (local >= end) return thumb.size - 1;
+  return local - thumb.at;
+};
+
+const moveLogBar = (ui, cell) => {
+  const bar = ui.lastFrame && ui.lastFrame.scrollBar;
+  const drag = ui.nav.scrollDrag;
+  if (!bar || !drag) return;
+  const top = logLocal(bar, cell) - drag.grab;
+  const at = scrollAtThumb(top, drag.thumb);
+  const panel = ui.pane === 'npm' ? ui.npm : ui.agents;
+  if (panel.viewing) panel.placeLog(at);
+  else panel.placeRuns(at);
+};
+
+const startLogDrag = (ui, cell) => {
+  const bar = ui.lastFrame && ui.lastFrame.scrollBar;
+  if (!onLogBar(bar, cell)) return false;
+  const thumb = scrollThumb(bar.count, bar.rows, bar.start);
+  if (!thumb) return false;
+  const nav = ui.nav;
+  const local = logLocal(bar, cell);
+  nav.scrollDrag = { grab: logGrab(local, thumb), thumb };
+  nav.mouseAnchor = null;
+  nav.pendingClick = null;
+  nav.selection = null;
+  moveLogBar(ui, cell);
+  return true;
+};
+
+const dismissImport = (ui, event) => {
+  if (ui.mode !== 'import') return;
+  const frame = ui.lastFrame;
+  const cell = mouseCell(ui, event);
+  const onField = frame && cell.y === frame.height - 1;
+  if (onField) return;
+  stopImport(ui);
+};
+
 const onPress = (ui, event) => {
+  dismissImport(ui, event);
   const nav = ui.nav;
   const cell = mouseCell(ui, event);
+  if (startLogDrag(ui, cell)) return;
+  nav.scrollDrag = null;
   nav.mouseAnchor = cell;
   nav.pendingClick = null;
   nav.selection = null;
@@ -30,11 +129,13 @@ const onPress = (ui, event) => {
 
 const onDrag = (ui, event) => {
   const nav = ui.nav;
+  const cell = mouseCell(ui, event);
+  if (nav.scrollDrag) return void moveLogBar(ui, cell);
   if (!nav.mouseAnchor) return;
   nav.pendingClick = null;
   nav.selection = {
     start: nav.mouseAnchor,
-    end: mouseCell(ui, event),
+    end: cell,
   };
 };
 
@@ -89,12 +190,48 @@ 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;
+  const again = armDoubleClick(ui.nav, 'agent-runs', hit.cursor);
+  if (!again || ui.mode !== 'review') return;
+  const session = ui.agents.selectedSession();
+  if (ui.agents.openRunRow(session)) return;
+  ui.agents.start();
+};
+
+const onAgentHit = (ui, hit) => {
+  if (hit.side === 'runs') return void onAgentRunHit(ui, hit);
+  ui.agents.focusCli();
+  const changed = ui.nav.agentCursor !== hit.cursor;
+  ui.nav.agentCursor = hit.cursor;
+  if (changed) {
+    ui.agents.runCursor = 0;
+    ui.agents.runScroll = 0;
+  }
+  const combo = COMBO_FIELDS.includes(hit.field);
+  if (combo) return void ui.agents.openPick(hit.field);
+  if (hit.field === 'fast') {
+    ui.agents.toggleFast();
+    return;
+  }
+  const again = armDoubleClick(ui.nav, 'agents', hit.cursor);
+  if (again && ui.mode === 'review') ui.agents.start();
+};
+
 const RELEASE_TARGETS = [
   {
     match: () => true,
     hits: 'statusHits',
     onHit: (ui, hit) => {
       if (hit.id === 'branch') return void ui.gitBranches.onBranch();
+      if (hit.id === 'plan') return void ui.composer.tasks.togglePlanMenu();
+      if (hit.id === 'plan-item') {
+        return void ui.composer.tasks.choosePlan(hit.cursor);
+      }
+      if (ui.composer.tasks.planOpen) ui.composer.tasks.closePlanMenu();
       ui.confirmChoice(hit.id);
     },
   },
@@ -103,6 +240,13 @@ const RELEASE_TARGETS = [
     hits: 'fileHits',
     onHit: (ui, hit) => ui.dashboard.open(hit.cursor),
   },
+  {
+    match: (ui) => ui.pane === 'repos',
+    hits: 'fileHits',
+    onHit: (ui, hit) => {
+      void ui.workspace.openAt(hit.cursor);
+    },
+  },
   {
     match: (ui) => ui.pane === 'files',
     hits: 'fileHits',
@@ -131,12 +275,33 @@ const RELEASE_TARGETS = [
       if (again) filesPane.onOpenFile(ui);
     },
   },
+  {
+    match: (ui) => ui.pane === 'packages',
+    hits: 'fileHits',
+    onHit: (ui, hit) => {
+      ui.nav.packagesCursor = hit.cursor;
+    },
+  },
+  {
+    match: (ui) => ui.pane === 'agents',
+    hits: 'fileHits',
+    onHit: onAgentHit,
+  },
   {
     match: (ui) => ui.pane === 'npm',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      if (hit.side === 'runs') {
+        ui.npm.runCursor = hit.cursor;
+        ui.npm.focusRuns();
+        const again = armDoubleClick(ui.nav, 'npm-runs', hit.cursor);
+        if (again && ui.mode === 'review') ui.npm.run();
+        return;
+      }
+      ui.npm.focusCommands();
       const again = armDoubleClick(ui.nav, 'npm', hit.cursor);
       ui.nav.npmCursor = hit.cursor;
+      ui.npm.clampRuns();
       if (again && ui.mode === 'review') ui.npm.run();
     },
   },
@@ -155,9 +320,45 @@ const RELEASE_TARGETS = [
   },
 ];
 
+const frameHits = (ui, accept) => (ui.lastFrame?.fileHits ?? []).filter(accept);
+
+const switchAgentCombo = (ui, cell) => {
+  const hits = frameHits(ui, (hit) => COMBO_FIELDS.includes(hit.field));
+  return clickHit(ui, hits, cell, (ui, hit) => {
+    const same =
+      ui.agents.pick.field === hit.field && ui.nav.agentCursor === hit.cursor;
+    if (same) {
+      ui.agents.closePick();
+      return;
+    }
+    ui.agents.dismissPick();
+    ui.agents.focusCli();
+    ui.nav.agentCursor = hit.cursor;
+    ui.agents.openPick(hit.field);
+    if (!ui.agents.pick) ui.paint();
+  });
+};
+
+const releaseAgentMenu = (ui, cell) => {
+  const hits = frameHits(ui, (hit) => hit.field === 'menu');
+  const accept = (ui, hit) => ui.agents.acceptPick(hit.cursor);
+  if (clickHit(ui, hits, cell, accept)) return;
+  if (switchAgentCombo(ui, cell)) return;
+  ui.agents.closePick();
+};
+
 const onRelease = (ui, event) => {
+  dismissImport(ui, event);
   const nav = ui.nav;
   const cell = mouseCell(ui, event);
+  if (nav.scrollDrag) {
+    moveLogBar(ui, cell);
+    nav.scrollDrag = null;
+    nav.mouseAnchor = null;
+    nav.pendingClick = null;
+    nav.selection = null;
+    return;
+  }
   if (nav.mouseAnchor) {
     nav.selection = { start: nav.mouseAnchor, end: cell };
   }
@@ -165,7 +366,10 @@ const onRelease = (ui, event) => {
   nav.pendingClick = null;
   nav.mouseAnchor = null;
   if (clickButton(ui, cell, clickId)) return;
-  if (editClick.placeClick(ui, cell)) return;
+  if (placeClick(ui, cell)) return;
+  if (ui.pane === 'agents' && ui.agents.pick) {
+    return void releaseAgentMenu(ui, cell);
+  }
   const frame = ui.lastFrame;
   for (const target of RELEASE_TARGETS) {
     if (!target.match(ui)) continue;
@@ -193,4 +397,6 @@ const handlePointer = (ui, event) => {
   handler(ui, event);
 };
 
-module.exports = { handlePointer };
+module.exports = {
+  handlePointer,
+};