reslop 0.3.1 → 0.3.3

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

package/lib/session/worktrees.js

@@ -0,0 +1,280 @@
+'use strict';
+
+const wt = require('../dashboard/worktrees.js');
+const { readWorkspace, worktreesOf, worktreeTarget } = wt;
+const linked = require('../git/linked.js');
+const { addWorktree, removeWorktree, dirKey } = linked;
+
+// Create, switch and remove the worktrees of a repository. They are tiles
+// above the branches, and on the repos screen when a folder is opened. Each
+// worktree is a repository of its own for everything else
+class WorktreeController {
+  constructor(ui) {
+    this.ui = ui;
+    this.reset();
+  }
+
+  reset() {
+    this.dropName = '';
+    this.dropRow = null;
+    this.branchName = '';
+    this.branchRow = null;
+    this.branchTarget = '';
+    this.busy = false;
+  }
+
+  // The tiles in use: the worktrees above the branches or the folder
+  panel() {
+    const { ui } = this;
+    return ui.nav.pane === 'branches' ? ui.trees : ui.workspace;
+  }
+
+  // The tiles show only when there is more than one worktree
+  hasPanels() {
+    return this.ui.trees.rows.length > 1;
+  }
+
+  // One element is selected: a tile of the worktrees or a branch
+  focused() {
+    const { ui } = this;
+    return ui.nav.pane === 'branches' && ui.nav.treeFocus && this.hasPanels();
+  }
+
+  selected() {
+    const { rows, cursor } = this.panel();
+    return rows[cursor] ?? null;
+  }
+
+  mainOf(row) {
+    const rows = this.panel().rows.filter((it) => it.group === row.group);
+    return rows.find((it) => it.main) ?? rows[0];
+  }
+
+  canWrite() {
+    const { ui } = this;
+    const inList = ui.nav.pane === 'repos' || ui.nav.pane === 'branches';
+    if (!inList || ui.mode !== 'review') return false;
+    if (!ui.capabilities.branches) {
+      ui.status = 'read only';
+      return false;
+    }
+    if (this.busy) {
+      ui.status = 'busy';
+      return false;
+    }
+    return true;
+  }
+
+  // Runs in work in a worktree keep it from being removed
+  workingIn(row) {
+    const { agents, npm } = this.ui;
+    const key = dirKey(row.dir);
+    const sources = [agents.liveByRoot(), npm.liveByRoot()];
+    return sources.some((live) => {
+      for (const [root, count] of live) {
+        if (count && dirKey(root) === key) return true;
+      }
+      return false;
+    });
+  }
+
+  // The worktrees of the repository that is shown
+  async refreshTrees() {
+    const { ui } = this;
+    const top = ui.top;
+    if (!top) return;
+    try {
+      const seed = { ...worktreesOf(top), root: top };
+      const info = await readWorkspace(seed, ui.trees.rows);
+      if (ui.top !== top) return;
+      ui.treesInfo = { ...info, root: top };
+    } catch {
+      return;
+    }
+    if (ui.trees.active) ui.trees.adopt(ui.treesInfo.repos);
+    else ui.trees.start();
+    ui.trees.refresh();
+    ui.trees.focusDir(top);
+    if (!this.hasPanels()) ui.nav.treeFocus = false;
+    ui.lifecycle.watchTrees();
+    if (ui.uiOpen && ui.nav.pane === 'branches') ui.paint();
+  }
+
+  moveTree(dx) {
+    if (this.focused()) this.ui.trees.move(dx, 0);
+  }
+
+  // A click on a tile selects it and shows that worktree
+  pickTile(name) {
+    const { ui } = this;
+    const at = ui.trees.rows.findIndex((row) => row.name === name);
+    if (at < 0 || ui.mode !== 'review') return;
+    ui.trees.cursor = at;
+    ui.nav.treeFocus = true;
+    ui.ops.hold(this.enterSelected());
+  }
+
+  // Selecting a tile shows that worktree: its branches, files, diffs, tasks
+  async enterSelected() {
+    const { ui } = this;
+    const row = this.selected();
+    if (!row || ui.mode !== 'review' || this.busy) return;
+    if (dirKey(row.dir) === dirKey(ui.top)) return;
+    ui.flushReview();
+    const home = ui.dashboardHome;
+    ui.retarget({ cwd: row.dir, repoName: row.name, pane: 'branches' });
+    ui.dashboardHome = home;
+    try {
+      await ui.ensureRepo();
+    } catch (error) {
+      ui.status = error instanceof Error ? error.message : `${error}`;
+      return;
+    }
+    const loading = ui.openLoad();
+    await ui.gitBranches.open(true);
+    await this.refreshTrees();
+    if (ui.uiOpen) {
+      ui.lifecycle.startWatch();
+      if (home) ui.dashboard.start();
+      ui.paint();
+    }
+    await loading;
+  }
+
+  onAdd() {
+    if (!this.canWrite() || !this.selected()) return;
+    this.ui.composer.openCompose('worktree', '');
+    this.ui.status = 'new worktree: branch name';
+  }
+
+  // Make a worktree for a branch that already exists in the branch list
+  onBranch() {
+    const ui = this.ui;
+    if (this.focused() || !this.canWrite()) return;
+    const branch = ui.gitBranches.selected();
+    const row = this.selected();
+    if (!branch || !row) return;
+    const main = this.mainOf(row);
+    this.branchName = branch.name;
+    this.branchRow = main;
+    this.branchTarget = worktreeTarget(main, branch.name);
+    ui.mode = 'confirmCreateWorktree';
+    ui.status = '';
+  }
+
+  cancelBranch() {
+    this.ui.mode = 'review';
+    this.branchName = '';
+    this.branchRow = null;
+    this.branchTarget = '';
+    this.ui.status = '';
+  }
+
+  confirmBranch() {
+    const row = this.branchRow;
+    const name = this.branchName;
+    this.cancelBranch();
+    if (row && name) this.ui.ops.hold(this.create(row, name));
+  }
+
+  finishAdd() {
+    const ui = this.ui;
+    const editor = ui.composer.editor;
+    const name = editor ? editor.text.trim() : '';
+    if (!name) {
+      ui.status = 'empty branch name';
+      return;
+    }
+    const row = this.selected();
+    ui.composer.closeCompose();
+    if (!row) return;
+    ui.ops.hold(this.create(row, name));
+  }
+
+  async reload() {
+    const { ui } = this;
+    if (ui.nav.pane === 'branches') {
+      await this.refreshTrees();
+      return;
+    }
+    const ws = ui.workspace;
+    const info = await readWorkspace(ui.workspaceInfo, ws.rows);
+    ui.workspaceInfo = info;
+    ws.adopt(info.repos);
+    if (ui.nav.pane === 'repos' && ui.uiOpen) ui.lifecycle.startWatch();
+  }
+
+  async create(row, name) {
+    const ui = this.ui;
+    const main = this.mainOf(row);
+    this.busy = true;
+    ui.status = 'creating worktree';
+    ui.paint();
+    try {
+      const dir = await addWorktree(main.dir, worktreeTarget(main, name), name);
+      await this.reload();
+      this.panel().focusDir(dir);
+      ui.status = `created ${name}`;
+    } catch (error) {
+      ui.status = error.message;
+    } finally {
+      this.busy = false;
+      ui.paint();
+    }
+  }
+
+  onDrop() {
+    const ui = this.ui;
+    const row = this.selected();
+    if (!this.canWrite() || !row) return;
+    if (row.main) {
+      ui.status = 'the main worktree stays';
+      return;
+    }
+    if (ui.nav.pane === 'branches' && dirKey(row.dir) === dirKey(ui.top)) {
+      ui.status = 'this worktree is shown';
+      return;
+    }
+    if (this.workingIn(row)) {
+      ui.status = 'runs are working in this worktree';
+      return;
+    }
+    this.dropRow = row;
+    this.dropName = `worktree ${row.name}`;
+    ui.mode = 'confirmWorktree';
+    ui.status = '';
+  }
+
+  cancelDrop() {
+    this.ui.mode = 'review';
+    this.reset();
+    this.ui.status = '';
+  }
+
+  confirmDrop() {
+    const row = this.dropRow;
+    this.ui.mode = 'review';
+    this.reset();
+    if (row) this.ui.ops.hold(this.remove(row));
+  }
+
+  // Git refuses a dirty or locked worktree and so does this, nothing is forced
+  async remove(row) {
+    const ui = this.ui;
+    this.busy = true;
+    ui.status = 'removing worktree';
+    ui.paint();
+    try {
+      await removeWorktree(this.mainOf(row).dir, row.dir);
+      await this.reload();
+      ui.status = `removed ${row.name}`;
+    } catch (error) {
+      ui.status = error.message;
+    } finally {
+      this.busy = false;
+      ui.paint();
+    }
+  }
+}
+
+module.exports = { WorktreeController };

package/lib/term/themes/dark.json

@@ -24,6 +24,10 @@
     "chromeFg": "#d0d0e0",
     "chromeBg": "#181824",
     "noteBg": "#242436",
+    "popupBg": "#34445c",
+    "popupFg": "#f2f4ff",
+    "popupHotBg": "#566d90",
+    "popupDisabledFg": "#66748a",
     "buttonFg": "#6a6a7e",
     "buttonBg": "#2a2a40",
     "buttonHotFg": "#ffffff",

package/lib/term/themes/light.json

@@ -24,6 +24,10 @@
     "chromeFg": "#24292f",
     "chromeBg": "#f2f4f8",
     "noteBg": "#f8fbff",
+    "popupBg": "#d0daea",
+    "popupFg": "#202c40",
+    "popupHotBg": "#9fb6da",
+    "popupDisabledFg": "#94a0b2",
     "buttonFg": "#57606a",
     "buttonBg": "#f7f9fc",
     "buttonHotFg": "#0f1419",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reslop",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Interactive code review and repair planning for AI-assisted changes",
   "keywords": [
     "code-review",
@@ -49,7 +49,7 @@
     "node": ">=18.15.0"
   },
   "scripts": {
-    "test": "reslop t -- npm run -s lint && reslop t -- node --test",
+    "test": "reslop t -- npm run -s lint && reslop t -- node scripts/run-tests.js",
     "lint": "reslop t -- eslint . && reslop t -- prettier -c \"**/*.js\" \"**/*.json\" \"**/*.md\"",
     "fix": "reslop t -- eslint . --fix && reslop t -- prettier --write \"**/*.js\" \"**/*.json\" \"**/*.md\"",
     "enable": "node scripts/enable.js",