reslop 0.3.0 → 0.3.2

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,8 +185,12 @@ 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 = '';
     this.status = '';
     this.layout = 'unified';
     this.lineNumbers = false;
@@ -261,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;
@@ -273,6 +282,7 @@ class Session {
     this.scheduleAutosave();
     this.dashboard.afterDraw();
     this.workspace.afterDraw();
+    this.trees.afterDraw();
   }
 
   scheduleAutosave() {
@@ -363,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();
   }
@@ -384,6 +395,7 @@ class Session {
     this.paths = [];
     this.repoName = repoName;
     this.branch = '';
+    this.repositoryUrl = '';
     this.rev = null;
     this.revShort = '';
     this.change = null;
@@ -391,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;
@@ -489,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();
@@ -518,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/tasks.js

@@ -430,7 +430,7 @@ class TaskPage {
   taskEditView() {
     const { composeKind, editor } = this.composer;
     if (composeKind !== 'tasks' || !editor) return null;
-    return { cursor: editor.cursor };
+    return { cursor: editor.cursor, anchor: editor.anchor };
   }
 
   commitTask(text) {

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

package/lib/session/workspace.js

@@ -1,20 +1,24 @@
 'use strict';
 
+const fs = require('node:fs');
 const path = require('node:path');
 const { REVIEW_DIR } = require('../common/files.js');
 const { FileIndex, HEAT_MS } = require('../dashboard/tree.js');
 const { UNKNOWN_PATH } = require('../dashboard/watch.js');
 const workspace = require('../dashboard/workspace.js');
 const { emptyDiff, countCommits, readDiffStat, taskStats, pickRun } = workspace;
+const { currentBranchName } = workspace;
 const { readNpmSummary } = require('../dashboard/npm.js');
-const { collectReport } = require('../git/deps.js');
+const { reportCounts } = require('../dashboard/reports.js');
+const { dirKey, changedFiles } = require('../git/linked.js');
+const { resolveGitDirs } = require('../git/dir.js');
 
 const TICK_ID = 'repos';
-const HEAT_TIMER = 'repos-heat';
 
 const freshBag = () => ({
   files: [],
   git: false,
+  diff: false,
   runs: false,
   tasks: false,
   npm: false,
@@ -24,6 +28,7 @@ const freshBag = () => ({
 const fullBag = () => ({
   files: [UNKNOWN_PATH],
   git: true,
+  diff: true,
   runs: true,
   tasks: true,
   npm: true,
@@ -35,6 +40,7 @@ const mergeBag = (left, right) => {
   return {
     files: [...base.files, ...right.files],
     git: base.git || right.git,
+    diff: base.diff || right.diff,
     runs: base.runs || right.runs,
     tasks: base.tasks || right.tasks,
     npm: base.npm || right.npm,
@@ -42,9 +48,37 @@ const mergeBag = (left, right) => {
   };
 };
 
-const blankRow = (repo) => ({
+// The path inside of a directory, or null for one outside of it
+const insideOf = (base, full) => {
+  const rel = path.relative(base, full);
+  const out = rel === '..' || rel.startsWith(`..${path.sep}`);
+  if (out || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join('/');
+};
+
+const gitDirKey = (dir) => {
+  const dirs = resolveGitDirs(dir);
+  return dirs ? dirKey(dirs.gitDir) : '';
+};
+
+// What a list of worktrees says of a repository
+const rowMeta = (repo) => ({
   name: repo.name,
+  group: repo.group ?? repo.name,
+  main: repo.main ?? true,
+  linked: repo.linked ?? false,
+  branch: repo.branch ?? '',
+  head: repo.head ?? '',
+  detached: repo.detached ?? false,
+  locked: repo.locked ?? false,
+});
+
+const blankRow = (repo) => ({
+  ...rowMeta(repo),
   dir: repo.dir,
+  key: dirKey(repo.dir),
+  gitDir: gitDirKey(repo.dir),
+  dirty: false,
   index: new FileIndex(repo.dir),
   bytes: 0,
   exts: [],
@@ -78,12 +112,23 @@ const readFiles = async (row, bag) => {
 };
 
 const readCommits = async (row) => {
-  row.commits = await countCommits(row.dir);
+  const [commits, branch] = await Promise.all([
+    countCommits(row.dir),
+    currentBranchName(row.dir),
+  ]);
+  row.commits = commits;
+  row.branch = branch;
+  row.detached = !branch;
   row.commitsReady = true;
 };
 
 const readDiff = async (row) => {
-  row.diff = await readDiffStat(row.dir);
+  const [diff, changed] = await Promise.all([
+    readDiffStat(row.dir),
+    changedFiles(row.dir).catch(() => []),
+  ]);
+  row.diff = diff;
+  row.dirty = changed.length > 0;
   row.diffReady = true;
 };
 
@@ -99,24 +144,26 @@ const readRuns = (row) => {
   row.runsReady = true;
 };
 
-const reportCount = async (dir, kind) => {
-  const report = await collectReport(dir, kind);
-  return report ? report.size : 0;
-};
-
 const readNpm = async (row) => {
-  const summary = await readNpmSummary(row.dir, row.npm);
-  const [audit, outdated] = await Promise.all([
-    reportCount(row.dir, 'audit'),
-    reportCount(row.dir, 'outdated'),
+  const [summary, counts] = await Promise.all([
+    readNpmSummary(row.dir, row.npm),
+    reportCounts(row.dir),
   ]);
-  row.npm = { ...summary, audit, outdated };
+  row.npm = { ...summary, ...counts };
   row.npmReady = true;
 };
 
-const toTile = (row) => ({
+const toTile = (row, live) => ({
   id: row.name,
   name: row.name,
+  group: row.group,
+  linked: row.linked,
+  branch: row.branch,
+  detached: row.detached,
+  head: row.head,
+  locked: row.locked,
+  dirty: row.dirty,
+  agents: live.get(row.key) ?? 0,
   bytes: row.bytes,
   exts: row.exts,
   tasks: row.tasks,
@@ -171,13 +218,20 @@ const classifyRest = (rest) => {
     return bag;
   }
   bag.files.push(rest);
+  bag.diff = true;
   bag.activity = true;
   return bag;
 };
 
+// The tiles of a folder on the repos screen, and the ones of the worktrees
+// of a repository above the branches
 class Workspace {
-  constructor(ui) {
+  constructor(ui, options = {}) {
     this.ui = ui;
+    this.pane = options.pane ?? 'repos';
+    this.tick = this.pane === 'repos' ? TICK_ID : `${TICK_ID}-${this.pane}`;
+    this.heat = `${this.tick}-heat`;
+    this.infoOf = options.infoOf ?? (() => this.ui.workspaceInfo);
     this.epoch = 0;
     this.reset();
   }
@@ -190,14 +244,46 @@ class Workspace {
     this.cols = 1;
   }
 
+  // Whether the tiles are on the screen
+  shown() {
+    return this.ui.uiOpen && this.ui.nav.pane === this.pane;
+  }
+
   seed() {
-    const info = this.ui.workspaceInfo;
+    const info = this.infoOf();
     const repos = info ? info.repos : [];
     this.rows = repos.map(blankRow);
     this.byName = new Map(this.rows.map((row) => [row.name, row]));
     if (this.cursor >= this.rows.length) this.cursor = 0;
   }
 
+  // The list of worktrees changed: what is known of the rest is kept
+  adopt(repos) {
+    const focus = this.rows[this.cursor] ? this.rows[this.cursor].key : '';
+    const known = new Map(this.rows.map((row) => [row.key, row]));
+    const fresh = [];
+    this.rows = repos.map((repo) => {
+      const prev = known.get(dirKey(repo.dir));
+      if (!prev) {
+        const row = blankRow(repo);
+        fresh.push(row);
+        return row;
+      }
+      return Object.assign(prev, rowMeta(repo));
+    });
+    this.byName = new Map(this.rows.map((row) => [row.name, row]));
+    const at = this.rows.findIndex((row) => row.key === focus);
+    this.cursor = at < 0 ? Math.min(this.cursor, this.rows.length - 1) : at;
+    this.cursor = Math.max(0, this.cursor);
+    for (const row of fresh) this.kick(row, fullBag());
+  }
+
+  focusDir(dir) {
+    const key = dirKey(dir);
+    const at = this.rows.findIndex((row) => row.key === key);
+    if (at >= 0) this.cursor = at;
+  }
+
   stale(epoch) {
     return epoch !== this.epoch || !this.active;
   }
@@ -205,7 +291,7 @@ class Workspace {
   publish(epoch) {
     if (this.stale(epoch)) return;
     this.afterDraw();
-    if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+    if (this.shown()) this.ui.paint();
   }
 
   async settle(epoch, read) {
@@ -219,8 +305,8 @@ class Workspace {
     if (bag.files.length) {
       jobs.push(this.settle(epoch, () => readFiles(row, bag)));
     }
-    if (bag.git) {
-      jobs.push(this.settle(epoch, () => readCommits(row)));
+    if (bag.git) jobs.push(this.settle(epoch, () => readCommits(row)));
+    if (bag.git || bag.diff) {
       jobs.push(this.settle(epoch, () => readDiff(row)));
     }
     if (bag.tasks) jobs.push(this.settle(epoch, () => readTasks(row)));
@@ -242,7 +328,7 @@ class Workspace {
       }
       if (this.stale(epoch)) break;
       this.afterDraw();
-      if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+      if (this.shown()) this.ui.paint();
     }
     row.running = false;
     if (row.pending && this.active) {
@@ -250,7 +336,7 @@ class Workspace {
       return;
     }
     this.afterDraw();
-    if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+    if (this.shown()) this.ui.paint();
   }
 
   kick(row, bag) {
@@ -265,24 +351,65 @@ class Workspace {
     for (const row of this.rows) this.kick(row, fullBag());
   }
 
+  // Everything is read again, but npm only where there is no answer yet:
+  // the lists of packages change when their files do, and the watcher says so
+  refresh() {
+    for (const row of this.rows) {
+      this.kick(row, { ...fullBag(), npm: !row.npmReady });
+    }
+  }
+
+  // The worktree that owns a path of the watcher, and the path inside it.
+  // A worktree can be anywhere, and the state of git of a linked one is
+  // in the directory of the main one
+  placeOf(rel, root) {
+    const full = path.resolve(root, rel);
+    let best = null;
+    for (const row of this.rows) {
+      for (const [base, lead] of [
+        [row.key, ''],
+        [row.gitDir, '.git/'],
+      ]) {
+        const inside = base ? insideOf(base, full) : null;
+        if (inside === null) continue;
+        if (best && base.length <= best.size) continue;
+        best = { row, rest: `${lead}${inside}`, size: base.length };
+      }
+    }
+    return best ?? this.placeByName(rel);
+  }
+
+  placeByName(rel) {
+    const slash = rel.indexOf('/');
+    const name = slash < 0 ? rel : rel.slice(0, slash);
+    const row = this.byName.get(name);
+    return row ? { row, rest: slash < 0 ? '' : rel.slice(slash + 1) } : null;
+  }
+
   notePaths(paths) {
     if (!this.active) return;
+    const missing = this.rows.some((row) => !fs.existsSync(row.dir));
+    if (missing) {
+      this.ui.ops.hold(this.ui.worktrees.reload());
+      return;
+    }
     for (const rel of paths) {
       if (rel === UNKNOWN_PATH) return void this.requestAll();
     }
     const found = new Map();
+    const info = this.infoOf();
+    const root = dirKey(info ? info.root : '.');
     for (const rel of paths) {
-      const slash = rel.indexOf('/');
-      const name = slash < 0 ? rel : rel.slice(0, slash);
-      const rest = slash < 0 ? '' : rel.slice(slash + 1);
-      const row = this.byName.get(name);
-      if (!row) continue;
+      const place = this.placeOf(rel, root);
+      if (!place) continue;
+      const { row, rest } = place;
+      const name = row.name;
       found.set(name, mergeBag(found.get(name), classifyRest(rest)));
     }
     for (const [name, bag] of found) this.kick(this.byName.get(name), bag);
     if (found.size) {
       this.afterDraw();
-      if (this.ui.uiOpen) this.ui.paint();
+      if (this.shown()) this.ui.paint();
     }
   }
 
@@ -302,8 +429,8 @@ class Workspace {
   cancelTimers() {
     const { progress, term } = this.ui;
     if (!progress || !term) return;
-    progress.stop(TICK_ID);
-    term.cancel(HEAT_TIMER);
+    progress.stop(this.tick);
+    term.cancel(this.heat);
   }
 
   hotUntil() {
@@ -316,32 +443,46 @@ class Workspace {
 
   afterDraw() {
     if (!this.active) return;
-    const visible = this.ui.uiOpen && this.ui.nav.pane === 'repos';
-    if (!visible) return void this.cancelTimers();
+    if (!this.shown()) return void this.cancelTimers();
     const now = Date.now();
     const until = this.hotUntil();
     const hot = now < until;
     const running = this.rows.some((row) => row.run?.status === 'running');
     const loading = this.rows.some((row) => rowBusy(row));
     const { progress, term } = this.ui;
-    if (running || hot || loading) progress.start(TICK_ID);
-    else progress.stop(TICK_ID);
+    if (running || hot || loading) progress.start(this.tick);
+    else progress.stop(this.tick);
     if (!hot) return;
     term.later(
-      HEAT_TIMER,
+      this.heat,
       () => {
-        if (this.ui.nav.pane === 'repos') this.ui.paint();
+        if (this.ui.nav.pane === this.pane) this.ui.paint();
       },
       until - now + 20,
     );
   }
 
+  liveAgents() {
+    const live = new Map();
+    const running = this.ui.agents ? this.ui.agents.liveByRoot() : new Map();
+    for (const [root, count] of running) live.set(dirKey(root), count);
+    return live;
+  }
+
+  // The index of the worktree that is shown, -1 for none of the tiles
+  currentIndex() {
+    const key = dirKey(this.ui.top || this.ui.cwd || '.');
+    return this.rows.findIndex((row) => row.key === key);
+  }
+
   view() {
+    const live = this.liveAgents();
     return {
       now: Date.now(),
       frame: this.ui.progressFrame,
       cursor: this.cursor,
-      tiles: this.rows.map(toTile),
+      current: this.currentIndex(),
+      tiles: this.rows.map((row) => toTile(row, live)),
     };
   }