reslop 0.2.7 → 0.3.1

package/lib/session/tasks.js

@@ -1,9 +1,19 @@
 'use strict';
 
-const files = require('../files.js');
-const { isTasksEntry, TASKS_FILE, TASK_KINDS, taskKind } = files;
-const review = require('../review.js');
-const { addTask, setTaskText, setTaskDone, removeTask, checkLabel } = review;
+const path = require('node:path');
+
+const { clamp, trimText } = require('../common/utilities.js');
+const files = require('../common/files.js');
+const { isTasksEntry, TASKS_FILE, TASK_KINDS, taskKind, taskTitle } = files;
+const { REVIEW_DIR } = files;
+const review = require('../review/review.js');
+const { checkLabel } = review;
+const { orderedPlanNames, allocateReviewPath } = review;
+const plans = require('./agents/plans.js');
+const { planKey, planPart, alignPlanLabels } = plans;
+const { MenuPick, menuRows, pickDelta } = require('../input/menu-pick.js');
+const { isTextKey } = require('../input/keys.js');
+const { lineKey } = require('../input/line-edit.js');
 
 const TASK_TYPE_SKIP = [
   'enter',
@@ -27,23 +37,45 @@ const TASK_TYPE_SKIP = [
   'f',
   'd',
   't',
+  'i',
   'b',
   'r',
   'c',
 ];
 
 const isTaskTypeKey = (key) => {
-  if (!key || key.length !== 1 || key === ' ') return false;
-  if (TASK_TYPE_SKIP.includes(key)) return false;
-  if (key.startsWith('ctrl-') || key.startsWith('alt-')) return false;
-  return key.charCodeAt(0) >= 32;
+  if (!isTextKey(key) || key === ' ') return false;
+  return !TASK_TYPE_SKIP.includes(key);
 };
 
-const clamp = (value, last) => Math.max(0, Math.min(value, last));
+const sectionTitle = (row) => {
+  if (row.quote) return row.file;
+  return taskTitle(row.kind);
+};
+
+const idlePick = () => false;
+const NEW_PLAN = '<new plan>';
+const PLAN_ROWS = 8;
+
+const planListSize = (ui) => {
+  const frame = ui.lastFrame;
+  const height = frame && frame.height ? frame.height : ui.getSize().height;
+  const room = Math.max(1, height - 3);
+  return Math.min(room, PLAN_ROWS);
+};
+
+const planOpenScroll = (cursor, extra, count, size) => {
+  const span = Math.abs(extra - cursor);
+  const end = span < size ? Math.max(cursor, extra) : cursor;
+  const start = Math.max(0, end - size + 1);
+  const maxStart = Math.max(0, count - size);
+  return Math.min(start, maxStart);
+};
 
 class TaskPage {
   constructor(composer) {
     this.composer = composer;
+    this.planPick = null;
   }
 
   get ui() {
@@ -68,14 +100,46 @@ class TaskPage {
     return rows;
   }
 
+  quoteSections() {
+    const notes = this.ui.review.store;
+    if (!notes) return [];
+    const groups = new Map();
+    for (const [key, note] of notes.feedback) {
+      if (!trimText(note.text)) continue;
+      const file = note.file || key;
+      let items = groups.get(file);
+      if (!items) {
+        items = [];
+        groups.set(file, items);
+      }
+      items.push({ key, note });
+    }
+    const sections = [];
+    for (const [file, items] of groups) sections.push({ file, items });
+    return sections;
+  }
+
   rows() {
     const rows = [];
     for (const kind of TASK_KINDS) {
       const tasks = this.list(kind.id);
       for (const task of tasks) {
-        rows.push({ kind: kind.id, task, draft: false });
+        rows.push({ quote: false, kind: kind.id, task, draft: false });
+      }
+      rows.push({ quote: false, kind: kind.id, task: null, draft: true });
+    }
+    for (const section of this.quoteSections()) {
+      for (const item of section.items) {
+        rows.push({
+          quote: true,
+          kind: section.file,
+          file: section.file,
+          key: item.key,
+          note: item.note,
+          task: null,
+          draft: false,
+        });
       }
-      rows.push({ kind: kind.id, task: null, draft: true });
     }
     return rows;
   }
@@ -89,13 +153,17 @@ class TaskPage {
     if (!dest) return 0;
     for (let i = 0; i < rows.length; i++) {
       const row = rows[i];
+      if (dest.quote) {
+        if (row.quote && row.key === dest.key) return i;
+        continue;
+      }
       if (dest.draft) {
         if (row.draft && row.kind === dest.kind) return i;
         continue;
       }
       if (row.task && dest.task && row.task.id === dest.task.id) return i;
     }
-    return clamp(0, rows.length - 1);
+    return 0;
   }
 
   editingId() {
@@ -105,7 +173,11 @@ class TaskPage {
 
   isDraftCompose() {
     const composer = this.composer;
-    return composer.composeKind === 'tasks' && composer.composeTaskId === null;
+    return (
+      composer.composeKind === 'tasks' &&
+      composer.composeTaskId === null &&
+      !composer.composeQuoteKey
+    );
   }
 
   canToggle() {
@@ -113,14 +185,10 @@ class TaskPage {
     return this.ui.mode === 'review';
   }
 
-  focused() {
-    const row = this.rowAt(this.clampedTaskFocus());
-    return row && row.task ? row.task : null;
-  }
-
   focusedKind() {
     const row = this.rowAt(this.clampedTaskFocus());
-    return row ? row.kind : TASK_KINDS[0].id;
+    if (!row || row.quote) return TASK_KINDS[0].id;
+    return row.kind;
   }
 
   closeEditor() {
@@ -128,26 +196,36 @@ class TaskPage {
     this.composer.closeCompose();
   }
 
-  taskSections() {
-    if (!this.isOpen()) return [];
+  rowText(row, at) {
     const editor = this.composer.editor;
-    const editingId = this.editingId();
-    const draft = this.isDraftCompose();
     const focus = this.clampedTaskFocus();
-    let at = 0;
+    if (row.draft) {
+      const live = this.isDraftCompose() && at === focus && editor;
+      return checkLabel(live ? editor.text : '', false);
+    }
+    if (row.quote) {
+      const live = this.composer.composeQuoteKey === row.key && editor;
+      const text = live ? editor.text : row.note.text;
+      return checkLabel(text, row.note.done);
+    }
+    const live = this.editingId() === row.task.id && editor;
+    const text = live ? editor.text : row.task.text;
+    return checkLabel(text, row.task.done);
+  }
+
+  taskSections() {
+    if (!this.isOpen()) return [];
     const sections = [];
-    for (const kind of TASK_KINDS) {
-      const tasks = this.list(kind.id);
-      const texts = [];
-      for (const task of tasks) {
-        const live = editingId === task.id && editor;
-        texts.push(checkLabel(live ? editor.text : task.text, task.done));
-        at += 1;
+    let current = null;
+    let at = 0;
+    for (const row of this.rows()) {
+      const key = row.quote ? `quote:${row.file}` : row.kind;
+      if (!current || current.key !== key) {
+        current = { key, title: sectionTitle(row), texts: [] };
+        sections.push(current);
       }
-      const drafting = draft && at === focus && editor;
-      texts.push(checkLabel(drafting ? editor.text : '', false));
+      current.texts.push(this.rowText(row, at));
       at += 1;
-      sections.push({ title: kind.title, texts });
     }
     return sections;
   }
@@ -164,13 +242,13 @@ class TaskPage {
   }
 
   clampedTaskFocus() {
-    return clamp(this.nav.tasksFocus, this.taskRowCount() - 1);
+    return clamp(this.nav.tasksFocus, 0, this.taskRowCount() - 1);
   }
 
   moveTaskFocus(delta) {
     const count = this.taskRowCount();
     if (!count) return;
-    this.nav.tasksFocus = clamp(this.clampedTaskFocus() + delta, count - 1);
+    this.nav.tasksFocus = clamp(this.clampedTaskFocus() + delta, 0, count - 1);
   }
 
   openTasksPage() {
@@ -182,13 +260,6 @@ class TaskPage {
     this.ui.syncReviewPath();
   }
 
-  closeTasksPage() {
-    this.nav.tasksOpen = false;
-    this.ui.syncReviewPath();
-    this.ui.syncFileCursor();
-    this.ui.lifecycle.catchUpWatch();
-  }
-
   startDraftCompose() {
     this.openTasksPage();
     this.nav.tasksFocus = this.list(TASK_KINDS[0].id).length;
@@ -203,6 +274,10 @@ class TaskPage {
       this.composer.openCompose('tasks', '', null);
       return;
     }
+    if (row.quote) {
+      this.composer.openQuote(row.key, row.note.text);
+      return;
+    }
     this.composer.openCompose('tasks', row.task.text, row.task.id);
   }
 
@@ -223,7 +298,7 @@ class TaskPage {
     }
     const rows = this.rows();
     const at = this.clampedTaskFocus();
-    const next = clamp(at + delta, rows.length - 1);
+    const next = clamp(at + delta, 0, rows.length - 1);
     if (next === at) return;
     const dest = rows[next];
     this.composer.commitCompose();
@@ -244,9 +319,18 @@ class TaskPage {
     const nav = this.nav;
     if (!this.isOpen()) return;
     const row = this.rowAt(this.clampedTaskFocus());
-    if (!row || !row.task) return;
+    if (!row || row.draft) return;
+    const store = this.ui.review.store;
+    if (row.quote) {
+      store.setFeedback(row.key, { ...row.note, text: '' });
+      nav.tasksFocus = Math.min(nav.tasksFocus, this.rows().length - 1);
+      nav.tasksFocus = Math.max(0, nav.tasksFocus);
+      this.ui.flushReview(true);
+      return;
+    }
+    if (!row.task) return;
     const kind = row.kind;
-    removeTask(this.ui.review.store, row.task.id);
+    store.removeTask(row.task.id);
     const rows = this.rows();
     let focus = Math.min(nav.tasksFocus, rows.length - 1);
     const at = rows[focus];
@@ -260,24 +344,51 @@ class TaskPage {
 
   toggleFocusedTask() {
     if (!this.canToggle()) return false;
-    const task = this.focused();
-    if (!task) return false;
-    setTaskDone(this.ui.review.store, task.id, !task.done);
+    const row = this.rowAt(this.clampedTaskFocus());
+    if (!row || row.draft) return false;
+    const store = this.ui.review.store;
+    if (row.quote) store.setFeedbackDone(row.key, !row.note.done);
+    else if (row.task) store.setTaskDone(row.task.id, !row.task.done);
+    else return false;
     this.ui.flushReview(true);
     return true;
   }
 
+  followRow(dest) {
+    this.nav.tasksFocus = this.rowIndex(dest);
+  }
+
+  moveIssue(delta) {
+    if (!this.isOpen() || !delta) return;
+    const row = this.rowAt(this.clampedTaskFocus());
+    if (!row || row.draft) return;
+    this.composer.commitCompose();
+    const store = this.ui.review.store;
+    const moved = row.quote
+      ? store.moveFeedback(row.key, delta)
+      : store.moveTask(row.task.id, delta);
+    if (!moved) return;
+    this.composer.closeCompose();
+    this.followRow(row.quote ? { quote: true, key: row.key } : row);
+    this.ui.flushReview(true);
+  }
+
+  sameCompose(row, cursor) {
+    const composer = this.composer;
+    if (cursor !== this.clampedTaskFocus()) return false;
+    if (row.draft) return this.isDraftCompose();
+    if (row.quote) return composer.composeQuoteKey === row.key;
+    return row.task && row.task.id === composer.composeTaskId;
+  }
+
   onTaskHit(cursor) {
     if (!this.isOpen()) return;
+    this.closePlanMenu();
     const row = this.rowAt(cursor);
     if (!row) return;
     const composer = this.composer;
     if (composer.composeKind === 'tasks') {
-      const same =
-        cursor === this.clampedTaskFocus() &&
-        ((row.draft && composer.composeTaskId === null) ||
-          (row.task && row.task.id === composer.composeTaskId));
-      if (same) return;
+      if (this.sameCompose(row, cursor)) return;
       this.closeEditor();
     }
     this.nav.tasksFocus = cursor;
@@ -287,15 +398,20 @@ class TaskPage {
   onTaskCheck(cursor) {
     if (!this.isOpen()) return;
     const row = this.rowAt(cursor);
-    if (!row || !row.task) return void this.onTaskHit(cursor);
+    if (!row || row.draft) return void this.onTaskHit(cursor);
     const composer = this.composer;
-    if (
+    const otherTask =
+      row.task &&
       composer.composeKind === 'tasks' &&
-      composer.composeTaskId !== row.task.id
-    ) {
-      this.closeEditor();
-    }
-    setTaskDone(this.ui.review.store, row.task.id, !row.task.done);
+      composer.composeTaskId !== row.task.id;
+    const otherQuote =
+      row.quote &&
+      composer.composeKind === 'tasks' &&
+      composer.composeQuoteKey !== row.key;
+    if (otherTask || otherQuote) this.closeEditor();
+    const store = this.ui.review.store;
+    if (row.quote) store.setFeedbackDone(row.key, !row.note.done);
+    else store.setTaskDone(row.task.id, !row.task.done);
     this.nav.tasksFocus = cursor;
     this.ui.flushReview(true);
   }
@@ -314,20 +430,159 @@ class TaskPage {
   taskEditView() {
     const { composeKind, editor } = this.composer;
     if (composeKind !== 'tasks' || !editor) return null;
-    return { cursor: editor.cursor };
+    return { cursor: editor.cursor, anchor: editor.anchor };
   }
 
   commitTask(text) {
     const notes = this.ui.review.store;
+    const key = this.composer.composeQuoteKey;
+    if (key) {
+      const note = notes.feedback.get(key);
+      if (!note) return;
+      notes.setFeedback(key, { ...note, text });
+      return;
+    }
     const id = this.composer.composeTaskId;
-    const prev =
-      id === null ? null : notes.tasks.find((task) => task.id === id);
-    if (prev) return void setTaskText(notes, id, text);
+    const found = notes.tasks.find((task) => task.id === id);
+    const prev = id === null ? null : found;
+    if (prev) return void notes.setTaskText(id, text);
     if (!text.trim()) return;
     const kind = this.focusedKind();
-    const todo = addTask(notes, TASKS_FILE, text, false, kind);
+    const todo = notes.addTask(TASKS_FILE, text, false, kind);
     this.composer.composeTaskId = todo.id;
   }
+
+  planName() {
+    const store = this.ui.review.store;
+    if (!store || !store.reviewPath) return '';
+    return path.basename(store.reviewPath);
+  }
+
+  planNames() {
+    const names = orderedPlanNames(this.ui.top || this.ui.cwd);
+    const current = this.planName();
+    if (current && !names.includes(current)) names.push(current);
+    return names;
+  }
+
+  planLabels() {
+    const root = this.ui.top || this.ui.cwd;
+    const dir = path.join(root, REVIEW_DIR);
+    const store = this.ui.review.store;
+    const parts = this.planNames().map((name) => planPart(dir, name, store));
+    const labels = alignPlanLabels(parts.filter(Boolean));
+    labels.push(NEW_PLAN);
+    return labels;
+  }
+
+  planMenu() {
+    const labels = this.planLabels();
+    if (!this.planPick) return labels;
+    return this.planPick.filter(labels);
+  }
+
+  planQuery() {
+    return this.planPick ? this.planPick.query : '';
+  }
+
+  planScroll() {
+    return this.planPick ? this.planPick.scroll : 0;
+  }
+
+  view(active) {
+    const pick = this.planPick;
+    return {
+      tasks: this.taskTexts(),
+      taskSections: this.taskSections(),
+      tasksFocus: this.clampedTaskFocus(),
+      taskEdit: this.taskEditView(),
+      planName: this.planName(),
+      planNames: active && pick ? this.planMenu() : [],
+      planOpen: this.planOpen,
+      planCursor: this.planCursor,
+      planScroll: this.planScroll(),
+      planQuery: this.planQuery(),
+      planEditor: pick ? pick.editor : null,
+    };
+  }
+
+  get planOpen() {
+    return this.planPick !== null;
+  }
+
+  get planCursor() {
+    return this.planPick ? this.planPick.cursor : 0;
+  }
+
+  closePlanMenu() {
+    this.planPick = null;
+  }
+
+  togglePlanMenu() {
+    if (this.planPick) return void this.closePlanMenu();
+    const labels = this.planLabels();
+    if (!labels.length) return;
+    const current = this.planName();
+    const at = labels.findIndex((item) => planKey(item) === current);
+    const cursor = at < 0 ? labels.length - 1 : at;
+    const extra = labels.length - 1;
+    const size = planListSize(this.ui);
+    this.planPick = new MenuPick('plan', cursor);
+    this.planPick.scroll = planOpenScroll(cursor, extra, labels.length, size);
+  }
+
+  movePlan(delta) {
+    const pick = this.planPick;
+    const items = this.planMenu();
+    if (!pick || !items.length) return;
+    pick.move(delta, items, idlePick);
+  }
+
+  planStep(key) {
+    const body = this.ui.lastFrame && this.ui.lastFrame.bodyH;
+    return pickDelta(key, menuRows(body), menuRows(body, 0.5));
+  }
+
+  notePlanEdit(changed) {
+    if (changed) this.planPick.touch();
+  }
+
+  onPlanKey(key) {
+    const pick = this.planPick;
+    if (!pick) return;
+    if (key === 'escape') return void this.closePlanMenu();
+    if (key === 'enter') return void this.choosePlan(pick.cursor);
+    if (key === ' ') return;
+    const handled = lineKey(pick.editor, key, this.ui, false);
+    if (handled) return void this.notePlanEdit(handled === 'text');
+    const step = this.planStep(key);
+    if (step) this.movePlan(step);
+  }
+
+  openPlan(name) {
+    if (!name || name === this.planName()) return;
+    this.composer.commitCompose();
+    this.composer.closeCompose();
+    const dir = this.ui.top || this.ui.cwd;
+    if (!this.ui.review.usePlan(dir, name)) return;
+    this.nav.tasksFocus = 0;
+    this.nav.scroll = 0;
+    this.ui.lifecycle.noteReviewStamp();
+  }
+
+  createPlan() {
+    const dir = this.ui.top || this.ui.cwd;
+    const reviewPath = allocateReviewPath(dir, new Date(), this.planNames());
+    this.openPlan(path.basename(reviewPath));
+  }
+
+  choosePlan(index) {
+    const label = this.planMenu()[index];
+    const name = label ? planKey(label) : '';
+    this.closePlanMenu();
+    if (name === NEW_PLAN) return void this.createPlan();
+    this.openPlan(name);
+  }
 }
 
 module.exports = { TaskPage };

package/lib/session/templates.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const review = require('../review.js');
+const review = require('../review/review.js');
 const { rankedTemplates, prefixTemplates, TEMPLATE_SHOW } = review;
 
 class TemplatePick {

package/lib/session/terminal.js

@@ -1,9 +1,36 @@
 'use strict';
 
-const render = require('../render/render.js');
-const { presentRows, presentCursor } = render;
-const utilities = require('../utilities.js');
-const { listen, watchResize } = utilities;
+const { presentRows, presentCursor } = require('../render/render.js');
+
+const listen = (emitter, event, handler) => {
+  if (!emitter || typeof emitter.on !== 'function') return () => {};
+  emitter.on(event, handler);
+  return () => {
+    if (typeof emitter.removeListener === 'function') {
+      return void emitter.removeListener(event, handler);
+    }
+    if (typeof emitter.off === 'function') emitter.off(event, handler);
+  };
+};
+
+const watchResize = (stdout, proc, onResize, signal) => {
+  const stopStdout = listen(stdout, 'resize', onResize);
+  let stopProc = () => {};
+  try {
+    stopProc = listen(proc, 'SIGWINCH', onResize);
+  } catch {
+    // SIGWINCH is not available on Windows
+  }
+  const stop = () => {
+    stopStdout();
+    stopProc();
+  };
+  if (signal) {
+    if (signal.aborted) stop();
+    else signal.addEventListener('abort', stop, { once: true });
+  }
+  return stop;
+};
 
 const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
 const LEAVE_TERM =
@@ -14,8 +41,12 @@ const sameCursor = (a, b) => {
   return a.x === b.x && a.y === b.y;
 };
 
-const sameSize = (a, b) =>
-  a !== null && a.width === b.width && a.height === b.height;
+const sameSize = (a, b) => {
+  if (a === null) return false;
+  const sameWidth = a.width === b.width;
+  const sameHeight = a.height === b.height;
+  return sameWidth && sameHeight;
+};
 
 class Terminal {
   constructor({ stdin = null, stdout, proc = process }) {
@@ -36,10 +67,6 @@ class Terminal {
     this.lastSize = null;
   }
 
-  hasTimer(name) {
-    return this.timers.has(name);
-  }
-
   cancel(name) {
     const id = this.timers.get(name);
     if (id === undefined) return;
@@ -87,6 +114,7 @@ class Terminal {
 
   startListening({ onData, onResize }) {
     if (this.disposed) return;
+    this.listenOpts = { onData, onResize };
     this.disposers.push(listen(this.stdin, 'data', onData));
     this.disposers.push(watchResize(this.stdout, this.proc, onResize));
   }
@@ -95,6 +123,19 @@ class Terminal {
     while (this.disposers.length) this.disposers.pop()();
   }
 
+  pause() {
+    this.stopListening();
+    this.leave();
+    if (this.stdin && this.stdin.pause) this.stdin.pause();
+    this.resetCache();
+  }
+
+  resume() {
+    if (this.disposed || this.open) return;
+    this.enter();
+    if (this.listenOpts) this.startListening(this.listenOpts);
+  }
+
   paint(frame, size, cursor) {
     if (this.disposed) return;
     const resized = !sameSize(this.lastSize, size);
@@ -107,8 +148,49 @@ class Terminal {
     }
     this.lastSize = size;
     this.lastCursor = cursor;
-    this.stdout.write(presentRows(frame.rows, { clear: resized, cursor }));
+    const prev = resized || !last ? null : last.rows;
+    this.stdout.write(
+      presentRows(frame.rows, { clear: resized, cursor, prev }),
+    );
+  }
+}
+
+class Progress {
+  constructor(term, onTick, intervalMs) {
+    this.term = term;
+    this.onTick = onTick;
+    this.intervalMs = intervalMs;
+    this.active = new Set();
+  }
+
+  tick() {
+    if (!this.active.size) return;
+    this.onTick();
+    this.schedule();
+  }
+
+  schedule() {
+    this.term.later('progress', () => this.tick(), this.intervalMs);
+  }
+
+  start(id) {
+    this.active.add(id);
+    this.schedule();
+  }
+
+  stop(id) {
+    this.active.delete(id);
+    if (!this.active.size) this.term.cancel('progress');
+  }
+
+  clear() {
+    this.active.clear();
+    this.term.cancel('progress');
+  }
+
+  size() {
+    return this.active.size;
   }
 }
 
-module.exports = { ENTER_TERM, LEAVE_TERM, Terminal };
+module.exports = { watchResize, ENTER_TERM, LEAVE_TERM, Terminal, Progress };