reslop 0.2.7 → 0.3.0

package/lib/session/unit.js

@@ -1,33 +1,23 @@
 'use strict';
 
-const files = require('../files.js');
-const { listPath, isTasksEntry } = files;
+const { listPath, isTasksEntry } = require('../common/files.js');
 const diff = require('../diff/diff.js');
 const { unitLines, itemsForPath, blockLineIndex } = diff;
 const { hunkLineRange, sameHunk, hunkKey } = diff;
 const { fileOffset, splitEditor, mergeEditRows, fileLineIndex } = diff;
 
-const fileText = (ui, rel) => {
-  if (!rel) return '';
-  const repo = ui.repo;
-  if (repo && typeof repo.fileText === 'function') {
-    return repo.fileText(ui.top, rel, ui.rev);
-  }
-  return '';
-};
+const fileText = (ui, rel) => ui.reads.textOf(rel);
 
 const pathItems = (ui, rel) => itemsForPath(ui.items ?? [], rel);
 
-const linesFor = (
-  ui,
-  rel,
-  overlay = ui.composer.liveFileText(),
-  base = null,
-) => {
-  const text = overlay === null ? fileText(ui, rel) : overlay;
+const linesFor = (ui, rel, overlay, base) => {
+  const live = ui.composer.liveFileText();
+  const shown = overlay === undefined ? live : overlay;
+  const seed = base === undefined ? null : base;
+  const text = shown === null ? fileText(ui, rel) : shown;
   const group = pathItems(ui, rel);
-  if (overlay !== null && base && base.length) {
-    return mergeEditRows(base, splitEditor(text));
+  if (shown !== null && seed && seed.length) {
+    return mergeEditRows(seed, splitEditor(text));
   }
   return unitLines(text, group);
 };
@@ -149,8 +139,8 @@ const moveUnitBlock = (ui, step) => {
   nav.clearSelection();
 };
 
-const openUnitFile = (ui, entry) => {
-  if (!entry || isTasksEntry(entry)) return;
+const showFile = async (ui, entry) => {
+  await ui.reads.loadText(entry.path);
   const nav = ui.nav;
   nav.reviewPath = entry.path;
   nav.tasksOpen = false;
@@ -170,12 +160,28 @@ const openUnitFile = (ui, entry) => {
   ui.status = '';
 };
 
-const setFileScope = (ui, next) => {
-  if (ui.nav.pane !== 'files') return;
-  if (ui.nav.fileScope === next) return;
+const openUnitFile = (ui, entry) => {
+  if (!entry || isTasksEntry(entry)) return;
+  ui.ops.hold(showFile(ui, entry));
+};
+
+const applyFileScope = (ui, next, quiet) => {
   ui.nav.fileScope = next;
   ui.nav.restoreFileCursor(ui.fileList());
-  ui.status = next === 'file' ? 'file scope' : 'diff mode';
+  const label = next === 'file' ? 'file scope' : 'diff mode';
+  ui.status = quiet ? '' : label;
+};
+
+const listScope = async (ui, quiet) => {
+  await ui.reads.loadNames();
+  applyFileScope(ui, 'file', quiet);
+};
+
+const setFileScope = (ui, next, quiet = false) => {
+  if (ui.nav.pane !== 'files') return;
+  if (ui.nav.fileScope === next) return;
+  if (next === 'file') return void ui.ops.hold(listScope(ui, quiet));
+  applyFileScope(ui, next, quiet);
 };
 
 const editCursor = (ui) => {
@@ -189,11 +195,9 @@ const editCursor = (ui) => {
   const at = atBlock
     ? blockLineIndex(lines, item)
     : viewLine(ui.nav, lines.length);
-  return {
-    text,
-    cursor: fileOffset(lines, at),
-    rows: lines,
-  };
+  const cursor = fileOffset(lines, at);
+  const rows = lines;
+  return { text, cursor, rows };
 };
 
 module.exports = {
@@ -201,6 +205,7 @@ module.exports = {
   linesFor,
   moveUnitBlock,
   openUnitFile,
+  showFile,
   setFileScope,
   editCursor,
   followFileCursor,

package/lib/session/update.js

@@ -1,7 +1,184 @@
 'use strict';
 
-const update = require('../update.js');
-const { checkUpdate, installUpdate, markSkipped } = update;
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { isHashObject } = require('metautil');
+const utilities = require('../common/utilities.js');
+const {
+  INSTALL_MS,
+  npmBin,
+  npmOpts,
+  runProc,
+} = require('../common/process.js');
+const { readJson } = utilities;
+const { parseVersion, cmpVersion } = utilities;
+const { oneLine, asText } = utilities;
+
+const PKG = require('../../package.json');
+
+const PKG_NAME = PKG.name;
+const PKG_VERSION = PKG.version;
+const PKG_DIR = path.resolve(__dirname, '../..');
+const CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const FETCH_MS = 8000;
+const REGISTRY = 'https://registry.npmjs.org';
+
+const RELEASE = /^\d+\.\d+\.\d+$/;
+const NO_TARGETS = { compatible: '', major: '' };
+
+const isNpmInstall = (pkgDir) =>
+  path.basename(path.dirname(pkgDir)) === 'node_modules';
+
+const cacheFile = (env = process.env) => {
+  if (env.XDG_CACHE_HOME) {
+    return path.join(env.XDG_CACHE_HOME, 'reslop', 'update.json');
+  }
+  if (process.platform === 'win32') {
+    const local =
+      env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(local, 'reslop', 'update.json');
+  }
+  return path.join(os.homedir(), '.cache', 'reslop', 'update.json');
+};
+
+const readCache = (file) => {
+  const data = readJson(file);
+  if (!isHashObject(data)) {
+    return { checkedAt: 0, compatible: '', major: '', skipped: '' };
+  }
+  const checkedAt = parseInt(data.checkedAt, 10) || 0;
+  const compatible = asText(data.compatible);
+  const latest = asText(data.latest);
+  const major = asText(data.major) || latest;
+  const handled = asText(data.handled);
+  const skipped = asText(data.skipped) || handled;
+  return { checkedAt, compatible, major, skipped };
+};
+
+const writeCache = (file, data) => {
+  const { checkedAt, compatible, major, skipped } = data;
+  const body = JSON.stringify({ checkedAt, compatible, major, skipped });
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${body}\n`);
+  } catch {
+    // ignore cache write errors
+  }
+};
+
+const isFresh = (cache, now, interval = CHECK_INTERVAL_MS) => {
+  if (!cache.checkedAt || now < cache.checkedAt) return false;
+  return now - cache.checkedAt < interval;
+};
+
+const listVersions = (data) => {
+  if (!data || typeof data !== 'object') return [];
+  const names = [];
+  if (isHashObject(data.versions)) names.push(...Object.keys(data.versions));
+  const tags = data['dist-tags'];
+  if (tags && typeof tags.latest === 'string') names.push(tags.latest);
+  if (typeof data.version === 'string') names.push(data.version);
+  return [...new Set(names)].filter((name) => RELEASE.test(name));
+};
+
+const newer = (best, name) => {
+  if (!best) return name;
+  return cmpVersion(parseVersion(name), parseVersion(best)) > 0 ? name : best;
+};
+
+const pickTargets = (current, names) => {
+  const from = parseVersion(current);
+  if (!from) return NO_TARGETS;
+  let compatible = '';
+  let major = '';
+  for (const name of names) {
+    const ver = parseVersion(name);
+    if (cmpVersion(ver, from) <= 0) continue;
+    if (ver.major === from.major) compatible = newer(compatible, name);
+    else if (ver.major > from.major) major = newer(major, name);
+  }
+  return { compatible, major };
+};
+
+const planUpdate = (current, targets) => {
+  const from = parseVersion(current);
+  if (!from) return { action: 'none' };
+  const { compatible, major, skipped } = targets;
+  const compatVer = parseVersion(compatible);
+  if (compatVer && compatVer.major === from.major) {
+    if (cmpVersion(compatVer, from) > 0) {
+      return { action: 'install', current, latest: compatible };
+    }
+  }
+  const majorVer = parseVersion(major);
+  if (!majorVer || majorVer.major <= from.major) return { action: 'none' };
+  const skipVer = parseVersion(skipped);
+  if (skipVer && cmpVersion(majorVer, skipVer) <= 0) return { action: 'none' };
+  return { action: 'confirm', current, latest: major };
+};
+
+const isEnabled = (options) => {
+  if (typeof options.enabled === 'boolean') return options.enabled;
+  return isNpmInstall(options.pkgDir ?? PKG_DIR);
+};
+
+const fetchTargets = async (current, options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return NO_TARGETS;
+  const url = `${REGISTRY}/${encodeURIComponent(PKG_NAME)}`;
+  const headers = { accept: 'application/json' };
+  const signal = options.signal ?? AbortSignal.timeout(FETCH_MS);
+  const response = await fetchImpl(url, { headers, signal });
+  if (!response || !response.ok) return NO_TARGETS;
+  const data = await response.json();
+  return pickTargets(current, listVersions(data));
+};
+
+const installUpdate = async (version, options = {}) => {
+  if (typeof options.install === 'function') {
+    await options.install(version);
+    return;
+  }
+  const timeout = options.timeout ?? INSTALL_MS;
+  const args = ['install', '-g', `${PKG_NAME}@${version}`];
+  const result = await runProc(npmBin(), args, npmOpts({ timeout }));
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(oneLine(result.stderr, 'npm install failed'));
+  }
+};
+
+const markSkipped = (version, options = {}) => {
+  const file = options.cacheFile ?? cacheFile(options.env);
+  writeCache(file, { ...readCache(file), skipped: version });
+};
+
+const checkUpdate = async (options = {}) => {
+  if (!isEnabled(options)) return { action: 'skip' };
+  const now = Date.now();
+  const current = options.current ?? PKG_VERSION;
+  const file = options.cacheFile ?? cacheFile(options.env);
+  const cache = readCache(file);
+  if (isFresh(cache, now, options.interval)) {
+    const plan = planUpdate(current, cache);
+    return plan.action === 'install' ? { action: 'none' } : plan;
+  }
+  let targets = NO_TARGETS;
+  try {
+    targets = await fetchTargets(current, options);
+  } catch {
+    // ignore registry errors
+  }
+  if (!targets.compatible && !targets.major) {
+    writeCache(file, { ...cache, checkedAt: now });
+    return { action: 'none' };
+  }
+  const next = { ...cache, checkedAt: now, ...targets };
+  writeCache(file, next);
+  return planUpdate(current, next);
+};
 
 class UpdateCoordinator {
   constructor(ui) {
@@ -62,13 +239,13 @@ class UpdateCoordinator {
   }
 
   async check() {
-    let plan;
+    let plan = null;
     try {
       plan = await checkUpdate(this.opts);
     } catch {
-      return;
+      // update check failed
     }
-    if (this.ui.done) return;
+    if (!plan || this.ui.done) return;
     if (plan.action === 'install') {
       this.installPromise = this.install(plan.latest);
       await this.installPromise;
@@ -89,4 +266,15 @@ class UpdateCoordinator {
   }
 }
 
-module.exports = { UpdateCoordinator };
+module.exports = {
+  CHECK_INTERVAL_MS,
+  isNpmInstall,
+  cacheFile,
+  readCache,
+  writeCache,
+  isFresh,
+  planUpdate,
+  checkUpdate,
+  markSkipped,
+  UpdateCoordinator,
+};

package/lib/session/view.js

@@ -2,12 +2,9 @@
 
 const path = require('node:path');
 
-const files = require('../files.js');
-const commit = require('./commit.js');
-const { listedCommits } = commit;
-const { fileEntries, fileTotals } = files;
-const review = require('../review.js');
-const { noteCounts } = review;
+const { fileEntries, fileTotals } = require('../common/files.js');
+const { listedCommits } = require('./commit.js');
+const { noteCounts } = require('../review/review.js');
 const diff = require('../diff/diff.js');
 const { unitLines, itemsForPath, splitEditor, mergeEditRows } = diff;
 const unit = require('./unit.js');
@@ -43,18 +40,6 @@ const blankEntry = (rel) => ({
   status: '',
 });
 
-const listedNames = (ui) => {
-  const repo = ui.repo;
-  if (!repo.listFiles) return [];
-  try {
-    return repo.listFiles(ui.top || ui.cwd, ui.paths ?? [], {
-      commit: ui.rev,
-    });
-  } catch {
-    return [];
-  }
-};
-
 const mergeUnitFiles = (entries, names) => {
   const have = new Set();
   for (const entry of entries) have.add(entry.path);
@@ -74,9 +59,8 @@ const fileList = (ui) => {
   const from = sourceLabel ? 'pr' : 'commit';
   const to = sourceLabel || ui.revShort;
   const labeled = relabelStatus(entries, from, to);
-  const names = listedNames(ui);
-  if (ui.nav.fileScope === 'file') return mergeUnitFiles(labeled, names);
-  return labeled;
+  if (ui.nav.fileScope !== 'file') return labeled;
+  return mergeUnitFiles(labeled, ui.reads.names);
 };
 
 const counts = (ui, notes = noteCounts(ui.review.store)) => {
@@ -144,76 +128,92 @@ const commitRows = (ui) => {
   return rows;
 };
 
-const view = (ui) => {
-  const { composer, nav, gitBranches, commits, npm, updater } = ui;
-  const templates = composer.templates.shownTemplates();
-  const change = ui.change;
-  const sourceKind = (change && change.source) || '';
-  const notes = noteCounts(ui.review.store);
+const navView = (ui) => {
+  const { nav } = ui;
   return {
     item: ui.current(),
     index: nav.index,
     total: ui.collection.items.length,
     scroll: nav.scroll,
     listScroll: nav.listScroll,
-    status: viewStatus(ui),
-    progressFrame: ui.progressFrame,
-    layout: ui.layout,
-    counts: counts(ui, notes),
     selection: nav.selection,
     pane: nav.pane,
     fileScope: nav.fileScope,
-    files: fileList(ui),
     fileCursor: nav.fileCursor,
     find: nav.find,
+    import: nav.import,
     reviewPath: nav.reviewPath,
     unitLine: nav.unitLine,
+    branchCursor: nav.branchCursor,
+    commitCursor: nav.commitCursor,
+    packagesCursor: nav.packagesCursor,
+  };
+};
+
+const dropNameOf = (ui) => {
+  const { packages, gitBranches, commits, npm } = ui;
+  const name = packages.dropName || gitBranches.dropName;
+  return name || commits.dropName || npm.dropName;
+};
+
+const repoView = (ui) => {
+  const { change, updater } = ui;
+  return {
+    status: viewStatus(ui),
+    progressFrame: ui.progressFrame,
+    layout: ui.layout,
+    lineNumbers: ui.lineNumbers === true,
+    counts: counts(ui, noteCounts(ui.review.store)),
+    files: fileList(ui),
     unitLines: unitBodyLines(ui),
     branch: ui.branch,
-    branches: gitBranches.branches,
-    branchCursor: nav.branchCursor,
+    branches: ui.gitBranches.branches,
     commits: commitRows(ui),
-    commitCursor: nav.commitCursor,
-    commitView: commits.commitView,
-    npmCommands: npm.commands,
-    npmCursor: nav.npmCursor,
-    npmView: npm.viewing,
-    npmOutput: npm.output,
-    npmFollow: npm.followEnd,
-    npmScroll: npm.logScroll,
-    npmEditName: npm.editName,
-    npmEditField: npm.editField,
-    npmDraftName: npm.draftName,
-    npmDraftCommand: npm.draftCommand,
-    npmRunning: npm.running,
-    npmLogs: nav.pane === 'npm' ? npm.logLabel : '',
+    commitView: ui.commits.commitView,
+    quitWarning: ui.quitWarning || '',
     repoName: repoNameOf(ui),
     rev: ui.rev || '',
     revShort: ui.revShort || '',
     sourceLabel: ui.sourceLabel || '',
-    sourceKind,
+    sourceKind: (change && change.source) || '',
     mode: ui.mode,
+    updateFrom: updater.from,
+    updateTo: updater.to,
+    dropName: dropNameOf(ui),
+  };
+};
+
+const composeView = (composer) => {
+  const templates = composer.templates.shownTemplates();
+  return {
     compose: composer.composeView(),
     noteText: composer.idleNoteText(),
-    tasks: composer.tasks.taskTexts(),
-    taskSections: composer.tasks.taskSections(),
-    tasksFocus: composer.tasks.clampedTaskFocus(),
-    taskEdit: composer.tasks.taskEditView(),
     codeOverlay: composer.codeOverlayView(),
     templates,
     templateIndex: composer.templates.clampedTemplateIndex(templates),
-    updateFrom: updater.from,
-    updateTo: updater.to,
-    dropName:
-      ui.packages.dropName ||
-      gitBranches.dropName ||
-      commits.dropName ||
-      npm.dropName,
-    dashboard: nav.pane === 'dashboard' ? ui.dashboard.view() : null,
-    packages: nav.pane === 'packages' ? ui.dashboard.packagesView() : null,
-    packagesCursor: nav.packagesCursor,
-    repos: nav.pane === 'repos' ? ui.workspace.view() : null,
   };
 };
 
-module.exports = { fileList, counts, viewStatus, view };
+const screenView = (ui) => {
+  const { pane } = ui.nav;
+  return {
+    dashboard: pane === 'dashboard' ? ui.dashboard.view() : null,
+    packages: pane === 'packages' ? ui.dashboard.packagesView() : null,
+    repos: pane === 'repos' ? ui.workspace.view() : null,
+  };
+};
+
+const view = (ui) => {
+  const { pane } = ui.nav;
+  return {
+    ...navView(ui),
+    ...repoView(ui),
+    ...ui.npm.view(pane === 'npm'),
+    ...ui.agents.view(pane === 'agents'),
+    ...composeView(ui.composer),
+    ...ui.composer.tasks.view(pane === 'tasks'),
+    ...screenView(ui),
+  };
+};
+
+module.exports = { fileList, counts, unitBodyLines, view };