reslop 0.2.7 → 0.3.1

package/lib/session/lifecycle.js

@@ -3,20 +3,16 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const utilities = require('../utilities.js');
-const { isAbort } = utilities;
-const sessionLoad = require('./load.js');
-const { tagLoaded, fetchSnapshot, fetchExtras } = sessionLoad;
-const watch = require('./watch.js');
-const { DiskWatcher, DEBOUNCE_MS } = watch;
-const files = require('../files.js');
-const { itemPath, relativeAge } = files;
-const deps = require('../deps.js');
-const { MANIFEST, LOCKFILE, depFileMeta } = deps;
-const review = require('../review.js');
-const { hasNotes, loadReview } = review;
-const reviewMerge = require('../review-merge.js');
-const { mergeReview } = reviewMerge;
+const { isAbort } = require('../common/process.js');
+const { tagLoaded, fetchSnapshot, fetchExtras } = require('./load.js');
+const { DiskWatcher, DEBOUNCE_MS } = require('../dashboard/watch.js');
+const { itemPath, REVIEW_DIR } = require('../common/files.js');
+const { relativeAge } = require('../common/format.js');
+const { MANIFEST, LOCKFILE, depFileMeta } = require('../deps/deps.js');
+const { hasNotes, loadReview } = require('../review/review.js');
+const { setTheme } = require('../term/ansi.js');
+const { readUiPrefs } = require('./prefs.js');
+const { mergeReview } = require('../review/merge.js');
 
 const WATCH_IGNORE_MS = 500;
 
@@ -147,8 +143,9 @@ class Lifecycle {
   syncUnitEditor() {
     const ui = this.ui;
     const rel = ui.nav.reviewPath;
-    if (ui.nav.pane !== 'unit' || !rel || !ui.repo.fileText) return;
-    ui.composer.applyDiskText(ui.repo.fileText(this.root, rel, ui.rev));
+    if (ui.nav.pane !== 'unit' || !rel) return;
+    const text = ui.reads.cached(rel);
+    if (text !== null) ui.composer.applyDiskText(text);
   }
 
   syncItemWatches() {
@@ -161,6 +158,30 @@ class Lifecycle {
     this.diskWatcher.watchFiles(rels);
   }
 
+  applyPrefs() {
+    const ui = this.ui;
+    const saved = readUiPrefs(ui.top);
+    ui.lineNumbers = saved.lineNumbers;
+    ui.layout = saved.layout;
+    ui.commits.commitView = saved.commitView;
+    setTheme(saved.theme);
+  }
+
+  applySource(loaded) {
+    const ui = this.ui;
+    if (loaded.repositoryUrl !== undefined) {
+      ui.repositoryUrl = loaded.repositoryUrl || '';
+    }
+    if (loaded.rev) ui.rev = loaded.rev;
+    if (loaded.revShort) ui.revShort = loaded.revShort;
+    else if (ui.rev && !ui.revShort) ui.revShort = ui.rev.slice(0, 7);
+    if (loaded.sourceLabel) ui.sourceLabel = loaded.sourceLabel;
+    if (loaded.change) ui.change = loaded.change;
+    if (loaded.branch !== undefined) ui.branch = loaded.branch || '';
+    const repository = ui.change ? ui.change.repository : '';
+    if (!ui.repoName && repository) ui.repoName = repository;
+  }
+
   applyLoaded(loaded) {
     const ui = this.ui;
     if (ui.nav.pane === 'repos') return false;
@@ -169,21 +190,20 @@ class Lifecycle {
       if (!loader.isCurrent(loaded.generation, ui.done)) return false;
     }
     const wasTasks = nav.tasksOpen === true;
+    const firstLoad = !loader.didLoad;
     const here = ui.current();
     ui.top = loaded.top ?? ui.cwd;
+    this.applyPrefs();
     collection.replace(loaded.items);
     stampItemDates(ui.top, collection.items);
-    if (loaded.rev) ui.rev = loaded.rev;
-    if (loaded.revShort) ui.revShort = loaded.revShort;
-    else if (ui.rev && !ui.revShort) ui.revShort = ui.rev.slice(0, 7);
-    if (loaded.sourceLabel) ui.sourceLabel = loaded.sourceLabel;
-    if (loaded.change) ui.change = loaded.change;
-    if (loaded.branch !== undefined) ui.branch = loaded.branch || '';
-    const repository = ui.change ? ui.change.repository : '';
-    if (!ui.repoName && repository) ui.repoName = repository;
+    this.applySource(loaded);
     if (!ui.review.store) ui.initReview();
     ui.review.applyImported(loaded.imported);
     this.restoreAfterLoad(here, wasTasks);
+    const issue = loaded.change && loaded.change.source === 'issue';
+    if (firstLoad && issue && !collection.items.length) {
+      ui.composer.tasks.openTasksPage();
+    }
     loader.didLoad = true;
     ui.updater.maybePrompt();
     loader.pendingExtras = loaded.pending === true;
@@ -193,10 +213,9 @@ class Lifecycle {
     return true;
   }
 
-  load() {
-    const ui = this.ui;
-    const loaded = ui.repo.load(ui.cwd, ui.paths, this.loadOptions());
-    this.applyLoaded(loaded);
+  async load() {
+    await this.openLoad();
+    if (this.ui.loadError) throw this.ui.loadError;
   }
 
   npmStamp() {
@@ -246,13 +265,18 @@ class Lifecycle {
       paths: ui.paths,
       signal: ui.loader.signal,
     });
-    let next;
-    try {
-      next = await fetchExtras(ui.repo, loaded, extra);
-    } catch (error) {
-      if (ui.loader.isCurrent(gen)) this.failOpen(error);
-      return;
-    }
+    const takeExtras = async () => {
+      try {
+        const value = await fetchExtras(ui.repo, loaded, extra);
+        return { value };
+      } catch (error) {
+        if (ui.loader.isCurrent(gen)) this.failOpen(error);
+        return null;
+      }
+    };
+    const outcome = await takeExtras();
+    if (!outcome) return;
+    const next = outcome.value;
     if (!this.isWanted(gen)) return;
     if (next) {
       this.applyLoaded(tagLoaded(next, gen));
@@ -284,7 +308,7 @@ class Lifecycle {
 
   afterSnapshot(kind, extra = {}) {
     const nav = this.ui.nav;
-    if (nav.pane === 'commits') this.ui.commits.refresh();
+    if (nav.pane === 'commits') this.ui.commits.reload();
     if (kind !== 'open' && kind !== 'watch') {
       nav.scroll = 0;
       nav.clearSelection();
@@ -299,15 +323,18 @@ class Lifecycle {
       ui.ops.setBusy('loading');
       ui.paint();
     }
-    let loaded;
+    let loaded = null;
+    const side = ui.reads.read();
     try {
       const opts = this.snapshotOpts({ signal: ui.loader.signal });
       loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
     } catch (error) {
       if (ui.loader.isCurrent(gen)) this.failOpen(error);
-      return;
     }
+    if (!loaded) return;
+    const found = await side;
     if (!this.isWanted(gen)) return;
+    ui.reads.apply(found);
     this.applyLoaded(tagLoaded(loaded, gen));
     this.afterSnapshot(kind, extra);
     if (loaded.pending === true || this.npmExtrasStale()) {
@@ -335,7 +362,8 @@ class Lifecycle {
     if (loader.didLoad && !loader.pendingExtras) {
       loader.promise = Promise.resolve();
     } else {
-      loader.promise = this.runSnapshot(loader.bump(), 'open');
+      const run = this.runSnapshot(loader.bump(), 'open');
+      loader.promise = this.ui.ops.track(run);
     }
     return loader.promise;
   }
@@ -345,32 +373,15 @@ class Lifecycle {
       this.ui.loader.didLoad = true;
       return;
     }
-    this.ui.ensureRepo();
-    await this.openLoad();
-    if (this.ui.loadError) throw this.ui.loadError;
+    await this.ui.ensureRepo();
+    await this.load();
   }
 
   refreshFromRepo(extra = {}) {
     const ui = this.ui;
     ui.loader.promise = null;
     const gen = ui.loader.bump();
-    const kind = kindFromExtra(extra);
-    if (ui.uiOpen && ui.repo.loadAsync) {
-      return void this.runSnapshot(gen, kind, extra);
-    }
-    const loaded = ui.repo.load(ui.cwd, ui.paths, this.snapshotOpts(extra));
-    this.applyLoaded(tagLoaded(loaded, gen));
-    this.afterSnapshot(kind, extra);
-    if (loaded.pending === true || this.npmExtrasStale()) {
-      ui.ops.setBusy('checking npm');
-      return void this.followExtras(loaded, gen, kind);
-    }
-    if (kind === 'keep') return;
-    this.finishIfEmpty(kind);
-    if (extra.doneStatus && !ui.done && !ui.loader.pendingExtras) {
-      ui.status = extra.doneStatus;
-    }
-    if (kind === 'watch') ui.paint();
+    ui.ops.track(this.runSnapshot(gen, kindFromExtra(extra), extra));
   }
 
   reloadAfterChange(afterLoad) {
@@ -385,11 +396,7 @@ class Lifecycle {
       ui.syncFileCursor();
       if (afterLoad) afterLoad();
     };
-    if (ui.uiOpen && ui.repo.loadAsync) {
-      return void this.refreshFromRepo({ afterLoad: restore });
-    }
-    this.refreshFromRepo();
-    restore();
+    this.refreshFromRepo({ afterLoad: restore });
   }
 
   onReload() {
@@ -455,12 +462,13 @@ class Lifecycle {
       return;
     }
     const store = this.ui.review.store;
-    let disk;
+    let disk = null;
     try {
       disk = loadReview(store.reviewPath, store.templates);
     } catch {
-      return;
+      // unreadable review
     }
+    if (!disk) return;
     mergeReview(store, disk);
     this.reviewStamp = stamp;
     this.ui.paint();
@@ -484,12 +492,10 @@ class Lifecycle {
       const repos = info ? info.repos : [];
       const paths = ['.'];
       for (const repo of repos) paths.push(path.join(repo.name, '.git'));
-      this.diskWatcher = new DiskWatcher({
-        root,
-        paths,
-        matchReview: (rel) => rel.includes('/.review/'),
-        onPaths: (rels) => ui.workspace.notePaths(rels),
-      });
+      const matchReview = (rel) => rel.includes(`/${REVIEW_DIR}/`);
+      const onPaths = (rels) => ui.workspace.notePaths(rels);
+      const options = { root, paths, matchReview, onPaths };
+      this.diskWatcher = new DiskWatcher(options);
       return;
     }
     const root = this.root;

package/lib/session/load.js

@@ -40,10 +40,8 @@ class LoadCoordinator {
 
 const tagLoaded = (loaded, gen) => ({ ...loaded, generation: gen });
 
-const fetchSnapshot = async (repo, cwd, paths, options) => {
-  if (repo.loadAsync) return repo.loadAsync(cwd, paths, options);
-  return repo.load(cwd, paths, options);
-};
+const fetchSnapshot = async (repo, cwd, paths, options) =>
+  repo.load(cwd, paths, options);
 
 const fetchExtras = async (repo, loaded, extra) => {
   if (!repo.loadExtras) return null;

package/lib/session/navigation.js

@@ -1,9 +1,8 @@
 'use strict';
 
-const files = require('../files.js');
+const files = require('../common/files.js');
 const { listPath, isTaskItem, isTasksEntry, TASKS_FILE } = files;
-const actions = require('./actions.js');
-const { LIST_PANES } = actions;
+const { LIST_PANES } = require('../input/actions.js');
 
 const freshListScroll = () =>
   Object.fromEntries(LIST_PANES.map((pane) => [pane, 0]));
@@ -21,6 +20,7 @@ class Navigation {
     this.commitCursor = 0;
     this.npmCursor = 0;
     this.packagesCursor = 0;
+    this.agentCursor = 0;
     this.scroll = 0;
     this.listScrollByPane = freshListScroll();
     this.reviewPath = null;
@@ -29,10 +29,12 @@ class Navigation {
     this.selection = null;
     this.mouseAnchor = null;
     this.pendingClick = null;
+    this.scrollDrag = null;
     this.lastClick = null;
     this.tasksOpen = false;
     this.tasksFocus = 0;
     this.find = null;
+    this.import = null;
   }
 
   clampIndex(length) {
@@ -98,6 +100,7 @@ class Navigation {
     this.selection = null;
     this.mouseAnchor = null;
     this.pendingClick = null;
+    this.scrollDrag = null;
   }
 
   get listScroll() {

package/lib/session/npm/history.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const { stripAnsi } = require('../../term/ansi.js');
+const { buildDocument } = require('../../report/parse.js');
+const report = require('../../report/render.js');
+const { renderDocument, renderReport } = report;
+const runStore = require('../../runs/runs.js');
+const { Tracker, summarizeDocument } = runStore;
+const { runName } = require('../../dashboard/model.js');
+const { reduceOutput } = require('../../runs/output.js');
+const { trimText, pad2 } = require('../../common/utilities.js');
+
+const TESTS_RE = /^(?:TAP version \d+|\s*(?:not )?ok\b|[ℹi]\s+tests\s+\d+)/m;
+
+const filteredOutput = (raw, root, status, rawFile) => {
+  const text = stripAnsi(`${raw ?? ''}`);
+  if (status === '' || !TESTS_RE.test(text)) {
+    const output = reduceOutput(raw, root, status);
+    return { output, log: output, result: null };
+  }
+  const doc = buildDocument(raw, '', root, status, 'test');
+  const result = summarizeDocument(doc);
+  const output = renderReport(doc);
+  const log = renderDocument(doc, rawFile);
+  return { output, log, result };
+};
+
+const runLabel = (entry) =>
+  entry.kind === 'bin' ? `npm exec ${entry.name}` : `npm run ${entry.name}`;
+
+const historyMark = (run) => {
+  if (run.status === 'running') return 'run';
+  if (run.status === 'stopped') return 'stop';
+  if (run.exit === 0 || run.exit === '0') return 'pass';
+  return 'fail';
+};
+
+const historyCounts = (run) => {
+  const result = run.result;
+  if (result && typeof result.tests === 'number') {
+    const fail = result.failed ?? 0;
+    const ok = result.passed ?? Math.max(0, result.tests - fail);
+    return { done: result.tests, ok, fail, total: result.tests };
+  }
+  const progress = run.progress;
+  if (!progress) return null;
+  const ok = progress.done ?? 0;
+  const fail = progress.failed ?? 0;
+  if (!ok && !fail && !(progress.expected > 0)) return null;
+  const total = progress.expected > 0 ? progress.expected : null;
+  return { done: ok + fail, ok, fail, total };
+};
+
+const countText = (value) => (typeof value === 'number' ? `${value}` : '');
+
+const historyExit = (run, counts) => {
+  if (counts || run.status !== 'exited') return '';
+  if (run.exit === '' || run.exit === null || run.exit === undefined) return '';
+  return `exit ${run.exit}`;
+};
+
+const earlierTotal = (list, run) => {
+  let best = 0;
+  let at = -1;
+  for (const item of list) {
+    if (item === run || item.name !== run.name) continue;
+    if (item.status === 'running') continue;
+    const counts = historyCounts(item);
+    if (!counts || typeof counts.total !== 'number') continue;
+    const started = item.startedAt || 0;
+    if (started < at) continue;
+    at = started;
+    best = counts.total;
+  }
+  return best;
+};
+
+const noteTests = (run, list, text) => {
+  const plain = stripAnsi(`${text ?? ''}`);
+  if (!TESTS_RE.test(plain)) return;
+  const tracker = new Tracker();
+  tracker.feed(plain);
+  if (!Object.hasOwn(run, 'expected')) run.expected = earlierTotal(list, run);
+  run.progress = {
+    done: tracker.progress.done,
+    failed: tracker.progress.failed,
+    expected: run.expected,
+  };
+};
+
+const RUN_KEEP = 50;
+
+const LOG_GAP_MS = 2000;
+
+const RESLOP_RUN = /^reslop(?:\.js)?\s+t\s+--\s+/;
+
+const RESLOP_T = /reslop(?:\.js)?\s+t\s+--/;
+
+const launchedReslop = (run) => {
+  if (run.externalId) return false;
+  const command = `${run.command ?? ''}`;
+  return RESLOP_T.test(command);
+};
+
+const historyName = (run) => {
+  const script = trimText(run.name);
+  if (script) return script;
+  return trimText(run.command).replace(RESLOP_RUN, '');
+};
+
+const sameWindow = (left, right) => {
+  const start = Number(left.startedAt) || 0;
+  const end = Number(left.endedAt) || start;
+  const at = Number(right.startedAt) || 0;
+  const done = Number(right.endedAt) || at;
+  return done >= start - LOG_GAP_MS && at <= end + LOG_GAP_MS;
+};
+
+const logBase = (name) => {
+  const file = `${name ?? ''}`;
+  if (!file || file.includes('/') || file.includes('\\')) return '';
+  return file;
+};
+
+const externalStatus = (record) => {
+  if (record.status === 'running') return 'running';
+  if (record.status === 'aborted') return 'stopped';
+  return 'exited';
+};
+
+const externalExit = (record) => {
+  if (record.status === 'running' || record.status === 'aborted') return '';
+  if (record.exit === null || record.exit === undefined) return '';
+  return record.exit;
+};
+
+const progressCount = (progress, key) => {
+  if (!progress || typeof progress[key] !== 'number') return 0;
+  return progress[key];
+};
+
+const progressSame = (left, right) => {
+  const done = progressCount(left, 'done') === progressCount(right, 'done');
+  const leftFailed = progressCount(left, 'failed');
+  const rightFailed = progressCount(right, 'failed');
+  const failed = leftFailed === rightFailed;
+  const leftExpected = progressCount(left, 'expected');
+  const rightExpected = progressCount(right, 'expected');
+  const expected = leftExpected === rightExpected;
+  return done && failed && expected;
+};
+
+const resultSame = (left, right) => {
+  if (!left && !right) return true;
+  if (!left || !right) return false;
+  return (
+    left.tests === right.tests &&
+    left.passed === right.passed &&
+    left.failed === right.failed &&
+    left.errors === right.errors
+  );
+};
+
+const applyExternal = (run, record) => {
+  const status = externalStatus(record);
+  const exit = externalExit(record);
+  const endedAt = Number(record.endedAt) || 0;
+  const progress = record.progress ?? null;
+  const result = record.result ?? null;
+  const same =
+    run.status === status &&
+    run.exit === exit &&
+    (run.endedAt || 0) === endedAt &&
+    progressSame(run.progress, progress) &&
+    resultSame(run.result, result);
+  if (same) return false;
+  run.status = status;
+  run.exit = exit;
+  run.endedAt = endedAt;
+  run.progress = progress;
+  run.result = result;
+  return true;
+};
+
+const recordedItem = (record) => {
+  const script = trimText(record.script);
+  const command = trimText(record.command);
+  const name = runName({ command, script }).replace(RESLOP_RUN, '');
+  return {
+    name,
+    kind: script ? 'script' : 'command',
+    script,
+    command,
+    status: externalStatus(record),
+    exit: externalExit(record),
+    startedAt: Number(record.startedAt) || 0,
+    endedAt: Number(record.endedAt) || 0,
+    logName: logBase(record.log),
+    rawName: logBase(record.raw),
+    externalId: `${record.id ?? ''}`,
+    result: record.result ?? null,
+    progress: record.progress ?? null,
+  };
+};
+
+const whenLabel = (ms) => {
+  if (!ms) return '';
+  const date = new Date(ms);
+  const hh = pad2(date.getHours());
+  const mm = pad2(date.getMinutes());
+  const time = `${hh}:${mm}`;
+  const today = new Date();
+  const sameDay =
+    date.getFullYear() === today.getFullYear() &&
+    date.getMonth() === today.getMonth() &&
+    date.getDate() === today.getDate();
+  if (sameDay) return time;
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  return `${month}-${day} ${time}`;
+};
+
+const elapsedText = (run, now) => {
+  const end = run.endedAt || now;
+  const ms = Math.max(0, end - (run.startedAt || end));
+  const sec = Math.round(ms / 1000);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  const rest = sec % 60;
+  return `${min}m${pad2(rest)}s`;
+};
+
+module.exports = {
+  filteredOutput,
+  runLabel,
+  historyMark,
+  historyCounts,
+  countText,
+  historyExit,
+  noteTests,
+  RUN_KEEP,
+  launchedReslop,
+  historyName,
+  sameWindow,
+  logBase,
+  applyExternal,
+  recordedItem,
+  whenLabel,
+  elapsedText,
+};