reslop 0.2.6 → 0.3.0

package/lib/session/prefs.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { isHashObject } = require('metautil');
+const { THEME_NAMES } = require('../term/ansi.js');
+const { REVIEW_DIR } = require('../common/files.js');
+const { readJson, writeJson } = require('../common/utilities.js');
+
+const PREFS = '.reslop';
+
+const LAYOUT_LABEL = {
+  unified: 'unified',
+  mixed: 'mixed',
+  side: 'side-by-side',
+};
+
+const LAYOUT_VALUE = {
+  unified: 'unified',
+  mixed: 'mixed',
+  'side-by-side': 'side',
+};
+
+const prefsFile = (root) => path.join(root, PREFS);
+
+const planPath = (root, name) => path.join(root, REVIEW_DIR, name);
+
+const readPrefs = (root) => {
+  const data = readJson(prefsFile(root));
+  if (!isHashObject(data)) return { agents: {} };
+  const agents = isHashObject(data.agents) ? data.agents : {};
+  return { ...data, agents };
+};
+
+const writePrefs = (root, data) => {
+  const stored = { ...data };
+  delete stored.runs;
+  try {
+    fs.writeFileSync(prefsFile(root), `${JSON.stringify(stored, null, 2)}\n`);
+  } catch {
+    // The repo root can be read-only.
+  }
+};
+
+const section = (data, name) => {
+  const value = data[name];
+  if (!isHashObject(value)) return {};
+  return { ...value };
+};
+
+const readUiPrefs = (root) => {
+  const data = readPrefs(root);
+  const editor = section(data, 'editor');
+  const general = section(data, 'general');
+  const commits = section(data, 'commits');
+  let lineNumbers = false;
+  if (typeof editor.lineNumbers === 'boolean') {
+    lineNumbers = editor.lineNumbers;
+  } else if (typeof data.lineNumbers === 'boolean') {
+    lineNumbers = data.lineNumbers;
+  }
+  const layout = LAYOUT_VALUE[editor.mode] || 'unified';
+  const theme = THEME_NAMES.includes(general.theme) ? general.theme : 'dark';
+  const commitView = commits.view === 'full' ? 'full' : 'brief';
+  return { lineNumbers, layout, theme, commitView };
+};
+
+const saveUiPrefs = (root, patch) => {
+  if (!root) return;
+  const data = readPrefs(root);
+  const editor = section(data, 'editor');
+  const legacy = typeof data.lineNumbers === 'boolean';
+  if (legacy && editor.lineNumbers === undefined) {
+    editor.lineNumbers = data.lineNumbers;
+  }
+  delete data.lineNumbers;
+  if (patch.lineNumbers !== undefined) {
+    editor.lineNumbers = patch.lineNumbers === true;
+  }
+  if (patch.layout) editor.mode = LAYOUT_LABEL[patch.layout] || 'unified';
+  const next = { ...data, editor };
+  if (patch.theme) {
+    const general = section(data, 'general');
+    general.theme = patch.theme;
+    next.general = general;
+  }
+  if (patch.commitView) {
+    const commits = section(data, 'commits');
+    const full = patch.commitView === 'full';
+    commits.view = full ? 'full' : 'brief';
+    next.commits = commits;
+  }
+  writePrefs(root, next);
+};
+
+const writeStored = (file, data) => {
+  try {
+    writeJson(file, data);
+  } catch {
+    // The plan directory can be read-only.
+  }
+};
+
+module.exports = {
+  LAYOUT_LABEL,
+  planPath,
+  readPrefs,
+  writePrefs,
+  readUiPrefs,
+  saveUiPrefs,
+  writeStored,
+};

package/lib/session/reads.js

@@ -0,0 +1,109 @@
+'use strict';
+
+// Repo reads the screen needs on every frame: loaded ahead and kept here
+class FileReads {
+  constructor(ui) {
+    this.ui = ui;
+    this.reset();
+  }
+
+  reset() {
+    this.names = [];
+    this.textKey = null;
+    this.text = '';
+    this.stamp = 0;
+    this.wanted = null;
+  }
+
+  keyOf(rel) {
+    const ui = this.ui;
+    return `${ui.top}\0${ui.rev ?? ''}\0${rel}`;
+  }
+
+  async readNames() {
+    const ui = this.ui;
+    if (!ui.repo.listFiles) return [];
+    const options = { commit: ui.rev };
+    try {
+      return await ui.repo.listFiles(ui.top || ui.cwd, ui.paths ?? [], options);
+    } catch {
+      return [];
+    }
+  }
+
+  async readText(rel) {
+    const ui = this.ui;
+    const key = this.keyOf(rel);
+    const repo = ui.repo;
+    const readable = rel && repo && typeof repo.fileText === 'function';
+    if (!readable) return { key, text: '' };
+    try {
+      return { key, text: await repo.fileText(ui.top, rel, ui.rev) };
+    } catch {
+      return { key, text: '' };
+    }
+  }
+
+  // What a reload needs besides the snapshot, applied together with it
+  async read() {
+    const nav = this.ui.nav;
+    const listed = nav.fileScope === 'file';
+    const rel = nav.pane === 'unit' ? nav.reviewPath : null;
+    const reads = [
+      listed ? this.readNames() : null,
+      rel ? this.readText(rel) : null,
+    ];
+    const stamp = this.stamp;
+    const [names, viewed] = await Promise.all(reads);
+    return { names, viewed, stamp };
+  }
+
+  // Text kept since the read began is newer than what the read found
+  apply(found) {
+    if (found.names) this.names = found.names;
+    if (found.viewed && found.stamp === this.stamp) this.keep(found.viewed);
+  }
+
+  keep(viewed) {
+    this.textKey = viewed.key;
+    this.text = viewed.text;
+    this.stamp += 1;
+  }
+
+  keepText(rel, text) {
+    this.keep({ key: this.keyOf(rel), text });
+  }
+
+  async loadNames() {
+    this.names = await this.readNames();
+  }
+
+  async loadText(rel) {
+    const viewed = await this.readText(rel);
+    this.keep(viewed);
+    return viewed.text;
+  }
+
+  cached(rel) {
+    if (!rel || this.textKey !== this.keyOf(rel)) return null;
+    return this.text;
+  }
+
+  // A path nobody loaded ahead is read now and painted when it arrives
+  textOf(rel) {
+    const text = this.cached(rel);
+    if (text !== null || !rel) return text ?? '';
+    const key = this.keyOf(rel);
+    if (this.wanted === key) return '';
+    this.wanted = key;
+    const ui = this.ui;
+    const done = () => {
+      this.wanted = null;
+      ui.paint();
+    };
+    ui.ops.track(this.loadText(rel).then(done, done));
+    return '';
+  }
+}
+
+module.exports = { FileReads };

package/lib/session/review.js

@@ -1,10 +1,19 @@
 'use strict';
 
-const review = require('../review.js');
-const { createStore, applyImportedNotes, setStatus } = review;
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { REVIEW_DIR, ISSUE_FILE } = require('../common/files.js');
+const review = require('../review/review.js');
+const { ReviewStore } = review;
 const { listReviewNames, loadTemplates, resolveReviewPath } = review;
 const { loadReview, flushReview } = review;
 
+const issueTasks = (imported) => {
+  const todos = imported.tasks ?? imported.todos ?? [];
+  return todos.filter((todo) => (todo.file || '') === ISSUE_FILE);
+};
+
 class ReviewController {
   constructor() {
     this.reset();
@@ -21,16 +30,17 @@ class ReviewController {
     const templates = loadTemplates(dir);
     const resolved = resolveReviewPath(dir, date, names, extra);
     this.didResume = resolved.resume === true;
-    this.store = this.didResume
-      ? loadReview(resolved.reviewPath, templates)
-      : createStore(resolved.reviewPath, templates);
+    const reviewPath = resolved.reviewPath;
+    if (this.didResume) this.store = loadReview(reviewPath, templates);
+    else this.store = new ReviewStore(reviewPath, templates);
     return this.store;
   }
 
   applyImported(imported) {
     if (!imported || !this.store) return false;
-    if (this.didResume || this.importedRemote) return false;
-    applyImportedNotes(this.store, imported);
+    if (this.importedRemote) return false;
+    const notes = this.didResume ? { tasks: issueTasks(imported) } : imported;
+    this.store.applyImportedNotes(notes);
     this.importedRemote = true;
     return true;
   }
@@ -45,9 +55,17 @@ class ReviewController {
     }
   }
 
-  finishQuit(status) {
-    setStatus(this.store, status);
-    return this.flush();
+  usePlan(dir, name) {
+    const store = this.store;
+    if (!store || !name) return false;
+    const next = path.join(dir, REVIEW_DIR, name);
+    if (next === store.reviewPath) return false;
+    this.flush();
+    const templates = store.templates;
+    const loaded = fs.existsSync(next);
+    if (loaded) this.store = loadReview(next, templates);
+    else this.store = new ReviewStore(next, templates);
+    return true;
   }
 }
 

package/lib/session/run-panel.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { clamp } = require('../common/utilities.js');
+const { logScrollMax } = require('../render/log.js');
+
+class RunPanel {
+  constructor(ui) {
+    this.ui = ui;
+  }
+
+  barMax() {
+    const bar = this.ui.lastFrame && this.ui.lastFrame.scrollBar;
+    return bar ? Math.max(0, bar.count - bar.rows) : -1;
+  }
+
+  setLog(start, max) {
+    const next = clamp(start, 0, max);
+    this.logScroll = next;
+    this.followEnd = next === max;
+  }
+
+  placeLog(start) {
+    const max = this.barMax();
+    if (max >= 0) this.setLog(start, max);
+  }
+
+  placeRuns(start) {
+    const max = this.barMax();
+    if (max >= 0) this.runScroll = clamp(start, 0, max);
+  }
+
+  scrollLogBy(delta, text, running) {
+    const { lastSize, lastFrame } = this.ui;
+    const max = logScrollMax(text, lastSize, lastFrame, running);
+    const from = this.followEnd ? max : this.logScroll;
+    this.setLog(from + delta, max);
+  }
+}
+
+module.exports = { RunPanel };

package/lib/{session.js → session/session.js}

@@ -1,53 +1,58 @@
 'use strict';
 
-const render = require('./render/render.js');
-const { renderFrame } = render;
-const keys = require('./keys.js');
-const { decodeChunk } = keys;
-const review = require('./review.js');
-const { AUTOSAVE_MS, hasNotes } = review;
-const files = require('./files.js');
-const { makeTaskItem } = files;
-const capabilities = require('./capabilities.js');
-const { sessionCapabilities } = capabilities;
-const actions = require('./session/actions.js');
-const { LIST_PANES } = actions;
-const terminal = require('./session/terminal.js');
-const { Terminal, LEAVE_TERM } = terminal;
-const load = require('./session/load.js');
-const { LoadCoordinator } = load;
-const items = require('./session/items.js');
-const { ItemCollection } = items;
-const navigation = require('./session/navigation.js');
-const { Navigation } = navigation;
-const sessionReview = require('./session/review.js');
-const { ReviewController } = sessionReview;
-const update = require('./session/update.js');
-const { UpdateCoordinator } = update;
-const progress = require('./session/progress.js');
-const { Progress } = progress;
-const compose = require('./session/compose.js');
-const { Composer } = compose;
-const ops = require('./session/ops.js');
-const { OpsRunner } = ops;
-const commit = require('./session/commit.js');
-const { CommitController } = commit;
-const branches = require('./session/branches.js');
-const { BranchController } = branches;
-const npm = require('./session/npm.js');
-const { NpmController } = npm;
-const accessors = require('./session/accessors.js');
-const { bindAccessors, bindGetters } = accessors;
-const view = require('./session/view.js');
-const filesPane = require('./session/files-pane.js');
-const lifecycle = require('./session/lifecycle.js');
-const { Lifecycle } = lifecycle;
-const dispatch = require('./session/dispatch.js');
+const { renderFrame } = require('../render/render.js');
+const { decodeChunk } = require('../input/keys.js');
+const { AUTOSAVE_MS, hasNotes } = require('../review/review.js');
+const { makeTaskItem } = require('../common/files.js');
+const { sessionCapabilities } = require('../source/capabilities.js');
+const { LIST_PANES } = require('../input/actions.js');
+const { Terminal, Progress, LEAVE_TERM } = require('./terminal.js');
+const { LoadCoordinator } = require('./load.js');
+const { ItemCollection } = require('./items.js');
+const { Navigation } = require('./navigation.js');
+const { ReviewController } = require('./review.js');
+const { UpdateCoordinator } = require('./update.js');
+const { Composer } = require('./compose.js');
+const { OpsRunner } = require('./ops.js');
+const { FileReads } = require('./reads.js');
+const { CommitController } = require('./commit.js');
+const { BranchController } = require('./branches.js');
+const { NpmController } = require('./npm/npm.js');
+const { PackageController } = require('./npm/packages.js');
+const { AgentsController } = require('./agents/agents.js');
+const view = require('./view.js');
+const filesPane = require('./files-pane.js');
+const { Lifecycle } = require('./lifecycle.js');
+const dispatch = require('./dispatch.js');
 const { dispatchAction, confirmChoice, handleEvent } = dispatch;
-const dashboard = require('./session/dashboard.js');
-const { Dashboard } = dashboard;
+const { Dashboard } = require('./dashboard.js');
+const { Workspace } = require('./workspace.js');
+
+const bindAccessors = (target, owner, names) => {
+  for (const name of names) {
+    Object.defineProperty(target, name, {
+      configurable: true,
+      enumerable: true,
+      get: () => owner[name],
+      set: (value) => {
+        owner[name] = value;
+      },
+    });
+  }
+};
+
+const bindGetters = (target, owner, names) => {
+  for (const name of names) {
+    Object.defineProperty(target, name, {
+      configurable: true,
+      enumerable: true,
+      get: () => owner[name],
+    });
+  }
+};
 
 const PROGRESS_MS = 160;
+const QUIT_WAIT_MS = 3000;
 
 const NAV_FIELDS = [
   'pane',
@@ -56,6 +61,8 @@ const NAV_FIELDS = [
   'branchCursor',
   'commitCursor',
   'npmCursor',
+  'packagesCursor',
+  'agentCursor',
   'scroll',
   'listScroll',
   'reviewPath',
@@ -98,6 +105,13 @@ const assignOptions = (session, options) => {
   session.auditMap = options.auditMap;
   session.updateOpts = options.update;
   session.dashboardHome = options.startPane === 'dashboard';
+  session.workspaceRoot = options.workspace ? options.workspace.root : '';
+  session.workspaceInfo = options.workspace ?? null;
+  session.loadPullRequest = options.loadPullRequest ?? null;
+  session.loadMergeRequest = options.loadMergeRequest ?? null;
+  session.loadGithubIssue = options.loadGithubIssue ?? null;
+  session.loadGitlabIssue = options.loadGitlabIssue ?? null;
+  session.fetchImpl = options.fetch ?? null;
 };
 
 const assignParts = (session, options) => {
@@ -112,10 +126,14 @@ const assignParts = (session, options) => {
   session.updater = new UpdateCoordinator(session);
   session.composer = new Composer(session);
   session.ops = new OpsRunner(session);
+  session.reads = new FileReads(session);
   session.commits = new CommitController(session);
   session.gitBranches = new BranchController(session);
   session.npm = new NpmController(session);
+  session.packages = new PackageController(session);
+  session.agents = new AgentsController(session);
   session.dashboard = new Dashboard(session);
+  session.workspace = new Workspace(session);
   session.lifecycle = new Lifecycle(session);
 };
 
@@ -156,17 +174,22 @@ class Session {
     this.review.reset();
     this.composer.reset();
     this.ops.reset();
+    this.reads.reset();
     this.gitBranches.reset();
     this.commits.reset();
     this.npm.reset();
+    this.agents.reset();
     this.dashboard.reset();
+    this.workspace.reset();
     this.top = this.cwd;
     this.branch = '';
     this.status = '';
     this.layout = 'unified';
+    this.lineNumbers = false;
     this.done = false;
     this.exitCode = 0;
     this.mode = 'review';
+    this.quitWarning = '';
     this.tasksItem = makeTaskItem();
     this.progressFrame = 0;
     this.emptyReview = false;
@@ -181,13 +204,13 @@ class Session {
     this.progress.clear();
   }
 
-  ensureRepo() {
+  async ensureRepo() {
     if (!this.repo.toplevel) return;
-    this.top = this.repo.toplevel(this.cwd);
+    this.top = await this.repo.toplevel(this.cwd);
   }
 
   load() {
-    this.lifecycle.load();
+    return this.lifecycle.load();
   }
 
   loadReady() {
@@ -225,6 +248,21 @@ class Session {
     if (LIST_PANES.includes(this.pane)) {
       this.nav.listScroll = frame.listScroll;
     }
+    const menuScroll = frame.menuScroll;
+    if (this.agents.pick && typeof menuScroll === 'number') {
+      this.agents.pick.scroll = menuScroll;
+    }
+    const planPick = this.composer.tasks.planPick;
+    if (planPick && typeof menuScroll === 'number') {
+      planPick.scroll = menuScroll;
+    }
+    if (typeof frame.runScroll === 'number') {
+      const panel = this.pane === 'npm' ? this.npm : this.agents;
+      panel.runScroll = frame.runScroll;
+    }
+    if (typeof frame.gridCols === 'number') {
+      this.workspace.cols = frame.gridCols;
+    }
     if (this.nav.tasksOpen) this.nav.scroll = frame.scroll;
     const editScroll = frame.cursor && frame.cursor.scroll;
     if (this.editor && typeof editScroll === 'number') {
@@ -234,6 +272,7 @@ class Session {
     this.term.paint(frame, size, composing ? frame.cursor : null);
     this.scheduleAutosave();
     this.dashboard.afterDraw();
+    this.workspace.afterDraw();
   }
 
   scheduleAutosave() {
@@ -284,7 +323,11 @@ class Session {
   }
 
   handleEvent(event) {
-    handleEvent(this, event);
+    if (!this.ops.defer(event)) handleEvent(this, event);
+  }
+
+  finishInput() {
+    if (this.finishReadLoop) this.finishReadLoop();
   }
 
   pushInput(text) {
@@ -321,6 +364,7 @@ class Session {
     if (result.kind === 'commit') this.commits.finishGitCommit();
     if (result.kind === 'branch') this.gitBranches.finishCreateBranch();
     if (result.kind === 'npm') this.npm.finishEdit();
+    if (result.kind === 'package') this.packages.finishAdd();
   }
 
   selectTemplate(index) {
@@ -331,28 +375,83 @@ class Session {
     this.composer.autosave();
   }
 
+  retarget({ cwd, top, repoName, pane }) {
+    this.lifecycle.stopWatch();
+    this.dashboard.stop();
+    this.loader.reset();
+    this.cwd = cwd;
+    if (top) this.top = top;
+    this.paths = [];
+    this.repoName = repoName;
+    this.branch = '';
+    this.rev = null;
+    this.revShort = '';
+    this.change = null;
+    this.dashboardHome = pane === 'dashboard';
+    this.collection.reset();
+    this.reads.reset();
+    this.review.reset();
+    this.nav.pane = pane;
+    this.nav.tasksOpen = false;
+    this.nav.scroll = 0;
+    this.nav.clearSelection();
+    this.status = '';
+  }
+
+  childWarning() {
+    const tests = this.npm && this.npm.running === true;
+    const agents = this.agents && this.agents.runningCount() > 0;
+    if (tests && agents) return ' exit will terminate tests and agents';
+    if (agents) return ' exit will terminate agents';
+    if (tests) return ' exit will terminate tests';
+    return '';
+  }
+
+  stopChildren() {
+    if (this.npm) this.npm.stopAll();
+    if (this.agents) this.agents.killAll();
+  }
+
+  // A quick repo write still running lands first, so it is not left half done
+  exitNow() {
+    if (this.done || !this.ops.unlanded()) return void this.finishExit();
+    const exit = () => this.finishExit();
+    this.ops.hold(this.ops.landed(QUIT_WAIT_MS).then(exit));
+  }
+
+  finishExit() {
+    this.flushReview();
+    this.done = true;
+    this.exitCode = 0;
+  }
+
   onQuit() {
+    const composer = this.composer;
+    if (this.mode === 'compose' && composer.writesDisk()) {
+      const quit = () => this.onQuit();
+      return void this.ops.hold(composer.writeAndClose().then(quit));
+    }
     if (this.mode === 'compose') {
-      this.composer.commitCompose();
-      this.composer.closeCompose();
+      composer.commitCompose();
+      composer.closeCompose();
     }
-    if (hasNotes(this.notes)) {
+    const warning = this.childWarning();
+    if (warning) {
+      this.quitWarning = warning;
       this.mode = 'confirmQuit';
       this.status = '';
       return;
     }
-    this.done = true;
-    this.exitCode = 0;
+    this.exitNow();
   }
 
-  finishQuit(status) {
-    const result = this.review.finishQuit(status);
-    if (!result.ok) this.status = result.error.message;
-    this.done = true;
-    this.exitCode = 0;
+  confirmQuit() {
+    this.stopChildren();
+    this.exitNow();
   }
 
   cancelQuit() {
+    this.quitWarning = '';
     this.mode = 'review';
     this.status = '';
   }
@@ -367,6 +466,7 @@ class Session {
 
   tickProgress() {
     this.progressFrame += 1;
+    if (this.npm.running) this.npm.refreshRecorded();
     this.paint();
   }
 
@@ -385,7 +485,12 @@ class Session {
     this.uiOpen = true;
     this.term.enter();
     try {
+      if (this.nav.pane === 'repos') this.workspace.start();
       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.
+      void this.agents.loadModels();
       this.openUpdate();
       this.draw();
       await this.readLoop();
@@ -412,6 +517,7 @@ class Session {
         settled = true;
         this.lifecycle.stopWatch();
         this.dashboard.stop();
+        this.workspace.stop();
         this.term.stopListening();
         this.progress.clear();
         this.term.clearTimers();
@@ -431,6 +537,7 @@ class Session {
       this.term.startListening({ onData, onResize: () => this.draw() });
       this.lifecycle.startWatch();
       if (this.dashboardHome) this.dashboard.start();
+      if (this.nav.pane === 'repos') this.workspace.start();
     });
   }
 }