reslop 0.2.0 → 0.2.3

package/lib/session/npm.js

@@ -0,0 +1,335 @@
+'use strict';
+
+const commands = require('../npm-commands.js');
+const { logViewRows } = require('../render/npm.js');
+
+const { listCommands, reduceOutput, writeLog, parseScriptLine } = commands;
+const { scriptLine, saveScript, removeScript, reorderScript } = commands;
+const { startNpm } = commands;
+
+const selected = (api) => {
+  const cursor = api.ui.nav.npmCursor;
+  return api.state.commands[cursor];
+};
+
+const clampCursor = (api) => {
+  const last = api.state.commands.length - 1;
+  const nav = api.ui.nav;
+  if (nav.npmCursor > last) nav.npmCursor = Math.max(0, last);
+  if (nav.npmCursor < 0) nav.npmCursor = 0;
+};
+
+const refresh = (api) => {
+  api.state.commands = listCommands(api.ui.top);
+  clampCursor(api);
+};
+
+const canEdit = (ui) => {
+  if (ui.capabilities && ui.capabilities.changes === false) return false;
+  if (ui.readOnly) return false;
+  return true;
+};
+
+const open = (api) => {
+  if (api.ui.mode === 'compose') return;
+  refresh(api);
+  api.state.viewing = false;
+  api.state.output = '';
+  api.ui.nav.pane = 'npm';
+  api.ui.status = '';
+  api.ui.nav.clearSelection();
+};
+
+const scrollLog = (api, delta) => {
+  const lines = api.state.output.split('\n');
+  let count = lines.at(-1) === '' ? lines.length - 1 : lines.length;
+  if (api.state.running) count += 1;
+  const frame = api.ui.lastFrame;
+  const bodyH = frame && frame.bodyH ? frame.bodyH : 1;
+  const max = Math.max(0, count - logViewRows(bodyH));
+  let start = api.state.followEnd ? max : api.state.logScroll;
+  start = Math.min(max, Math.max(0, start + delta));
+  api.state.followEnd = start === max;
+  api.state.logScroll = start;
+};
+
+const move = (api, delta) => {
+  if (api.state.viewing) return void scrollLog(api, delta);
+  if (!api.state.commands.length) return;
+  const nav = api.ui.nav;
+  const last = api.state.commands.length - 1;
+  const next = Math.min(last, Math.max(0, nav.npmCursor + delta));
+  if (next === nav.npmCursor) return;
+  nav.npmCursor = next;
+  api.ui.status = '';
+};
+
+const stopRun = (api) => {
+  api.state.running = false;
+  api.state.child = null;
+  if (api.ui.progress) api.ui.progress.stop('npm');
+};
+
+const showOutput = (api, text) => {
+  if (!api.state.viewing || !api.state.running) return;
+  if (api.state.stopping) return;
+  api.state.output = text;
+  api.ui.paint();
+};
+
+const withNotice = (text, notice) => {
+  const body = `${text ?? ''}`;
+  if (body.endsWith(`${notice}\n`)) return body;
+  if (!body) return `${notice}\n`;
+  if (body.endsWith('\n')) return `${body}${notice}\n`;
+  return `${body}\n${notice}\n`;
+};
+
+const finishRun = (api, entry, result) => {
+  const stopped = api.state.stopping === true;
+  const reduced = stopped
+    ? withNotice(api.state.output, 'terminated')
+    : reduceOutput(result.text, api.ui.top, result.status);
+  api.state.output = reduced;
+  api.state.stopping = false;
+  stopRun(api);
+  try {
+    writeLog(api.ui.top, entry.name, reduced);
+  } catch (error) {
+    api.ui.status = error.message;
+    api.ui.paint();
+    return;
+  }
+  if (stopped && api.state.viewing) api.ui.status = 'terminated';
+  api.ui.paint();
+};
+
+const startRun = (api, entry) => {
+  api.state.output = '';
+  api.state.viewing = true;
+  api.state.followEnd = true;
+  api.state.logScroll = 0;
+  api.state.running = true;
+  api.state.stopping = false;
+  api.ui.status = '';
+  if (api.ui.progress) api.ui.progress.start('npm');
+  const runner = api.ui.repo && api.ui.repo.runNpmCommand;
+  const start = typeof runner === 'function' ? runner : startNpm;
+  api.state.child = start(
+    api.ui.top,
+    entry,
+    (text) => showOutput(api, reduceOutput(text, api.ui.top, '')),
+    (result) => finishRun(api, entry, result),
+  );
+  api.ui.paint();
+};
+
+const runSelected = (api) => {
+  if (api.state.viewing || api.state.child) return;
+  const entry = selected(api);
+  if (!entry) return;
+  startRun(api, entry);
+};
+
+const rerun = (api) => {
+  if (!api.state.viewing || api.state.running) return;
+  const entry = selected(api);
+  if (!entry) return;
+  startRun(api, entry);
+};
+
+const closeView = (api) => {
+  if (api.state.running) {
+    api.state.stopping = true;
+    if (api.state.child) api.state.child.kill();
+    if (!api.state.running) return;
+    api.state.output = withNotice(api.state.output, 'terminated');
+    stopRun(api);
+    api.ui.status = 'terminated';
+    api.ui.paint();
+    return;
+  }
+  api.state.viewing = false;
+  api.ui.status = '';
+  api.ui.paint();
+};
+
+const editSelected = (api) => {
+  if (api.state.viewing) return;
+  if (!canEdit(api.ui)) {
+    api.ui.status = 'read only';
+    return;
+  }
+  const entry = selected(api);
+  if (!entry || entry.kind !== 'script') {
+    api.ui.status = 'not a script';
+    return;
+  }
+  api.state.editName = entry.name;
+  api.ui.composer.openCompose('npm', scriptLine(entry));
+};
+
+const newCommand = (api) => {
+  if (api.state.viewing) return;
+  if (!canEdit(api.ui)) {
+    api.ui.status = 'read only';
+    return;
+  }
+  api.state.editName = '';
+  api.ui.composer.openCompose('npm', '');
+};
+
+const finishEdit = (api) => {
+  const editor = api.ui.composer.state.editor;
+  const text = editor ? editor.text : '';
+  const parsed = parseScriptLine(text);
+  if (!parsed) {
+    api.ui.status = 'name: command';
+    return;
+  }
+  try {
+    api.ui.ignoreWatch();
+    saveScript(api.ui.top, api.state.editName, parsed);
+  } catch (error) {
+    api.ui.status = error.message;
+    return;
+  }
+  api.ui.composer.closeCompose();
+  refresh(api);
+  const at = api.state.commands.findIndex(
+    (entry) => entry.name === parsed.name,
+  );
+  if (at >= 0) api.ui.nav.npmCursor = at;
+  api.ui.status = 'saved';
+};
+
+const askDrop = (api) => {
+  if (api.state.viewing) return;
+  if (!canEdit(api.ui)) {
+    api.ui.status = 'read only';
+    return;
+  }
+  const entry = selected(api);
+  if (!entry || entry.kind !== 'script') {
+    api.ui.status = 'not a script';
+    return;
+  }
+  api.state.dropName = entry.name;
+  api.ui.mode = 'confirmDrop';
+  api.ui.status = '';
+};
+
+const confirmDrop = (api) => {
+  const name = api.state.dropName;
+  api.state.dropName = '';
+  api.ui.mode = 'review';
+  if (!name) return;
+  try {
+    api.ui.ignoreWatch();
+    removeScript(api.ui.top, name);
+  } catch (error) {
+    api.ui.status = error.message;
+    return;
+  }
+  refresh(api);
+  api.ui.status = `dropped ${name}`;
+};
+
+const cancelDrop = (api) => {
+  api.state.dropName = '';
+  api.ui.mode = 'review';
+  api.ui.status = '';
+};
+
+const reorder = (api, delta) => {
+  if (api.state.viewing) return;
+  if (!canEdit(api.ui)) {
+    api.ui.status = 'read only';
+    return;
+  }
+  const entry = selected(api);
+  if (!entry || entry.kind !== 'script') {
+    api.ui.status = 'not a script';
+    return;
+  }
+  try {
+    api.ui.ignoreWatch();
+    if (!reorderScript(api.ui.top, entry.name, delta)) return;
+  } catch (error) {
+    api.ui.status = error.message;
+    return;
+  }
+  refresh(api);
+  const at = api.state.commands.findIndex((item) => item.name === entry.name);
+  if (at >= 0) api.ui.nav.npmCursor = at;
+  api.ui.status = '';
+};
+
+const createNpmController = (ui) => {
+  const state = {
+    commands: [],
+    viewing: false,
+    output: '',
+    followEnd: true,
+    logScroll: 0,
+    editName: '',
+    dropName: '',
+    running: false,
+    stopping: false,
+    child: null,
+  };
+  const api = { ui, state };
+  return {
+    state,
+    get commands() {
+      return state.commands;
+    },
+    get viewing() {
+      return state.viewing;
+    },
+    get output() {
+      return state.output;
+    },
+    get dropName() {
+      return state.dropName;
+    },
+    get followEnd() {
+      return state.followEnd;
+    },
+    get logScroll() {
+      return state.logScroll;
+    },
+    get editName() {
+      return state.editName;
+    },
+    get running() {
+      return state.running;
+    },
+    reset() {
+      if (state.child) state.child.kill();
+      stopRun(api);
+      state.commands = [];
+      state.viewing = false;
+      state.output = '';
+      state.followEnd = true;
+      state.logScroll = 0;
+      state.editName = '';
+      state.dropName = '';
+      state.stopping = false;
+    },
+    open: () => open(api),
+    move: (delta) => move(api, delta),
+    run: () => runSelected(api),
+    rerun: () => rerun(api),
+    closeView: () => closeView(api),
+    edit: () => editSelected(api),
+    create: () => newCommand(api),
+    finishEdit: () => finishEdit(api),
+    askDrop: () => askDrop(api),
+    confirmDrop: () => confirmDrop(api),
+    cancelDrop: () => cancelDrop(api),
+    reorder: (delta) => reorder(api, delta),
+  };
+};
+
+module.exports = { createNpmController };

package/lib/session/pointer.js

@@ -99,13 +99,24 @@ const RELEASE_TARGETS = [
     match: (ui) => ui.pane === 'commits',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      if (ui.mode === 'compose') return;
       ui.nav.commitCursor = hit.cursor;
     },
   },
+  {
+    match: (ui) => ui.pane === 'npm',
+    hits: 'fileHits',
+    onHit: (ui, hit) => {
+      ui.nav.npmCursor = hit.cursor;
+    },
+  },
   {
     match: (ui) => ui.pane === 'diff',
     hits: 'todoHits',
-    onHit: (ui, hit) => ui.composer.onTodoHit(hit.cursor),
+    onHit: (ui, hit) => {
+      if (hit.check) return void ui.composer.onTodoCheck(hit.cursor);
+      ui.composer.onTodoHit(hit.cursor);
+    },
   },
   {
     match: (ui) => ui.mode === 'compose',

package/lib/session/todos.js

@@ -3,7 +3,7 @@
 const files = require('../files.js');
 const { isTodosEntry, TODO_FILE } = files;
 const review = require('../review.js');
-const { addTodo, setTodoText, removeTodo, checkLabel } = review;
+const { addTodo, setTodoText, setTodoDone, removeTodo, checkLabel } = review;
 
 const TODO_TYPE_SKIP = [
   'enter',
@@ -101,6 +101,7 @@ const closeTodoPage = (api) => {
   api.nav.todoOpen = false;
   api.ui.syncReviewPath();
   api.ui.syncFileCursor();
+  api.ui.lifecycle.catchUpWatch();
 };
 
 const focusTodoPage = (api, todoId) => {
@@ -189,6 +190,17 @@ const removeFocusedTodo = (api) => {
   api.ui.flushReview(true);
 };
 
+const toggleFocusedTodo = (api) => {
+  const nav = api.nav;
+  if (!nav.todoOpen || nav.pane !== 'diff') return false;
+  if (api.ui.mode !== 'review') return false;
+  const todo = listTodos(api)[clampedTodoFocus(api)];
+  if (!todo) return false;
+  setTodoDone(api.review.store, todo.id, !todo.done);
+  api.ui.flushReview(true);
+  return true;
+};
+
 const onTodoHit = (api, cursor) => {
   if (!api.nav.todoOpen) return;
   const todos = listTodos(api);
@@ -206,6 +218,20 @@ const onTodoHit = (api, cursor) => {
   editFocusedTodo(api);
 };
 
+const onTodoCheck = (api, cursor) => {
+  if (!api.nav.todoOpen) return;
+  const todo = listTodos(api)[cursor];
+  if (!todo) return void onTodoHit(api, cursor);
+  const { state } = api;
+  if (state.composeKind === 'todo' && state.composeTodoId !== todo.id) {
+    api.commit();
+    api.close();
+  }
+  setTodoDone(api.review.store, todo.id, !todo.done);
+  api.nav.todoFocus = cursor;
+  api.ui.flushReview(true);
+};
+
 const createTodo = (api) => {
   startDraftCompose(api);
 };
@@ -253,6 +279,8 @@ const createTodoCompose = (api) => ({
   typeIntoTodo: (key) => typeIntoTodo(api, key),
   removeFocusedTodo: () => removeFocusedTodo(api),
   onTodoHit: (cursor) => onTodoHit(api, cursor),
+  onTodoCheck: (cursor) => onTodoCheck(api, cursor),
+  toggleFocusedTodo: () => toggleFocusedTodo(api),
   onTodo: () => onTodo(api),
   todoEditView: () => todoEditView(api),
   commitTodo: (text) => commitTodo(api, text),

package/lib/session/view.js

@@ -3,6 +3,7 @@
 const path = require('node:path');
 
 const files = require('../files.js');
+const { listedCommits } = require('./commit.js');
 const { fileEntries, REPO_TODOS_LABEL } = files;
 const review = require('../review.js');
 const { noteCounts } = review;
@@ -143,7 +144,7 @@ const unitBodyLines = (api) => {
 };
 
 const view = (api) => {
-  const { composer, nav, ui, gitBranches, commits, updater } = api;
+  const { composer, nav, ui, gitBranches, commits, npm, updater } = api;
   const templates = composer.shownTemplates();
   const change = ui.change;
   const sourceKind = (change && change.source) || '';
@@ -169,9 +170,19 @@ const view = (api) => {
     branch: ui.branch,
     branches: gitBranches.branches,
     branchCursor: nav.branchCursor,
-    commits: commits.commits,
+    commits: listedCommits(commits.commits),
     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,
+    npmRunning: npm.running,
     repoName: repoNameOf(api),
+    rev: ui.rev || '',
     revShort: ui.revShort || '',
     sourceLabel: ui.sourceLabel || '',
     sourceKind,
@@ -186,7 +197,7 @@ const view = (api) => {
     templateIndex: composer.clampedTemplateIndex(templates),
     updateFrom: updater.from,
     updateTo: updater.to,
-    dropName: gitBranches.dropName || commits.dropName,
+    dropName: gitBranches.dropName || commits.dropName || npm.dropName,
   };
 };
 

package/lib/session/watch.js

@@ -72,26 +72,127 @@ const closeWatcher = (watcher) => {
   }
 };
 
-const schedule = (state) => {
-  if (state.closed) return;
-  if (state.timer !== null) clearTimeout(state.timer);
-  state.timer = setTimeout(() => {
-    state.timer = null;
+const reviewMarkdown = (rel) => {
+  const norm = `${rel}`.replaceAll('\\', '/');
+  if (!norm.startsWith('.review/')) return false;
+  const rest = norm.slice('.review/'.length);
+  if (!rest || rest.includes('/')) return false;
+  return rest.endsWith('.md');
+};
+
+const isReviewDir = (root, dir) => {
+  const rel = path.relative(root, dir).replaceAll('\\', '/');
+  return rel === '.review' || rel.startsWith('.review/');
+};
+
+const hasFile = (full) => {
+  try {
+    fs.accessSync(full);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isBareReviewName = (root, dir, rel) => {
+  if (!rel || rel.includes('/') || !rel.endsWith('.md')) return false;
+  const base = path.basename(rel);
+  if (hasFile(path.join(dir, base))) return false;
+  return hasFile(path.join(root, '.review', base));
+};
+
+const isReviewEvent = (root, dir, name) => {
+  if (isReviewDir(root, dir)) return true;
+  if (!name) return false;
+  const rel = path.relative(root, path.join(dir, name));
+  const norm = rel.replaceAll('\\', '/');
+  if (reviewMarkdown(norm)) return true;
+  return isBareReviewName(root, dir, norm);
+};
+
+const isOwnDirEvent = (dir, name) => {
+  if (!name) return false;
+  const base = path.basename(dir);
+  const slash = `${name}`.replaceAll('\\', '/');
+  const bare = slash.startsWith('./') ? slash.slice(2) : slash;
+  const trimmed = bare.endsWith('/') ? bare.slice(0, -1) : bare;
+  if (trimmed === base) {
+    try {
+      return !fs.statSync(path.join(dir, trimmed)).isFile();
+    } catch {
+      return true;
+    }
+  }
+  const full = path.resolve(dir, name);
+  if (full === path.resolve(dir)) return true;
+  if (path.basename(full) !== base) return false;
+  try {
+    return fs.realpathSync(full) === fs.realpathSync(dir);
+  } catch {
+    return false;
+  }
+};
+
+const schedule = (state, timerKey, fire) => {
+  if (state.closed || !fire) return;
+  if (state[timerKey] !== null) clearTimeout(state[timerKey]);
+  state[timerKey] = setTimeout(() => {
+    state[timerKey] = null;
     if (state.closed) return;
-    state.onChange();
+    fire();
   }, state.debounceMs);
-  if (typeof state.timer.unref === 'function') state.timer.unref();
+  const timer = state[timerKey];
+  if (timer && typeof timer.unref === 'function') timer.unref();
+};
+
+const REVIEW_HOLD_MS = 200;
+
+const reviewBurst = (state) => {
+  const seen = state.reviewSeenAt;
+  if (!seen) return false;
+  const hold = Math.max(state.debounceMs * 2, REVIEW_HOLD_MS);
+  return Date.now() - seen < hold;
+};
+
+const scheduleChange = (state) => {
+  schedule(state, 'timer', () => {
+    if (reviewBurst(state)) return;
+    if (state.onChange) state.onChange();
+  });
+};
+
+const scheduleUnnamed = (state) => {
+  if (reviewBurst(state)) return;
+  schedule(state, 'looseTimer', () => {
+    if (reviewBurst(state)) return;
+    scheduleChange(state);
+  });
+};
+
+const dropChange = (state) => {
+  if (state.timer !== null) clearTimeout(state.timer);
+  if (state.looseTimer !== null) clearTimeout(state.looseTimer);
+  state.timer = null;
+  state.looseTimer = null;
 };
 
 const handleWatchEvent = (state, dir, eventType, filename) => {
   if (state.closed) return;
   const name = filename ? `${filename}` : '';
   const rel = name ? path.relative(state.root, path.join(dir, name)) : '';
+  if (isReviewEvent(state.root, dir, name)) {
+    state.reviewSeenAt = Date.now();
+    dropChange(state);
+    return void schedule(state, 'reviewTimer', state.onReview);
+  }
   if (rel && ignoredRel(rel)) return;
+  if (reviewBurst(state)) return;
+  if (!name) return void scheduleUnnamed(state);
+  if (isOwnDirEvent(dir, name)) return;
   if (eventType === 'rename' && name) {
     state.watchNewDir(path.join(dir, name));
   }
-  schedule(state);
+  scheduleChange(state);
 };
 
 const watchOne = (state, target, extra = {}) => {
@@ -141,6 +242,7 @@ const maybeWatchNewDir = (state, full) => {
     return;
   }
   if (!stat.isDirectory()) return;
+  if (path.basename(full) === '.review') return void watchOne(state, full);
   if (skipDirName(path.basename(full))) return;
   watchTree(state, full);
 };
@@ -166,7 +268,11 @@ const watchGit = (state) => {
 const stopState = (state) => {
   state.closed = true;
   if (state.timer !== null) clearTimeout(state.timer);
+  if (state.reviewTimer !== null) clearTimeout(state.reviewTimer);
+  if (state.looseTimer !== null) clearTimeout(state.looseTimer);
   state.timer = null;
+  state.reviewTimer = null;
+  state.looseTimer = null;
   while (state.watchers.length) closeWatcher(state.watchers.pop());
   state.watched.clear();
 };
@@ -189,13 +295,18 @@ const createDiskWatcher = (options) => {
     dirWatchOpts: recursive ? { recursive: true } : {},
     watchers: [],
     watched: new Set(),
+    onReview: options.onReview,
     timer: null,
+    reviewTimer: null,
+    looseTimer: null,
+    reviewSeenAt: 0,
     closed: false,
     watchNewDir: (full) => maybeWatchNewDir(state, full),
   };
   const scopes = options.paths && options.paths.length ? options.paths : ['.'];
   for (const spec of scopes) watchScope(state, spec);
   watchGit(state);
+  watchOne(state, path.resolve(state.root, '.review'));
   return {
     close: () => stopState(state),
     watchFiles: (rels) => watchFiles(state, rels),
@@ -207,5 +318,6 @@ module.exports = {
   POLL_MS,
   canWatchRecursive,
   ignoredRel,
+  isOwnDirEvent,
   createDiskWatcher,
 };