reslop 0.2.7 → 0.3.1

package/lib/session/compose.js

@@ -1,32 +1,32 @@
 'use strict';
 
-const wrap = require('../wrap.js');
-const { cursorInWrap, wrapDoc } = wrap;
+const { cursorInWrap, wrapDoc } = require('../term/wrap.js');
 const render = require('../render/render.js');
-const { noteInnerWidth, codeInnerWidth, todoBodyWidth } = render;
-const commits = require('../render/commits.js');
-const { commitMessageWidth } = commits;
-const commit = require('./commit.js');
-const { listedCommits } = commit;
-const editor = require('../editor.js');
-const { Editor } = editor;
-const files = require('../files.js');
+const { noteInnerWidth, codeInnerWidth, todoBodyWidth, activeDigits } = render;
+const { commitMessageWidth } = require('../render/commits.js');
+const { listedCommits } = require('./commit.js');
+const { Editor } = require('../input/editor.js');
+const { isTextKey } = require('../input/keys.js');
+const files = require('../common/files.js');
 const { itemPath, isTaskItem, isTasksEntry, listPath } = files;
 const { isReadOnlyOrigin } = files;
-const diff = require('../diff/diff.js');
-const { blockAddText } = diff;
-const items = require('./items.js');
-const { itemFeedKey, canEditCode } = items;
-const review = require('../review.js');
-const { setFeedback, setCode, checkLabel, rememberTemplate } = review;
-const templates = require('./templates.js');
-const { TemplatePick } = templates;
-const tasks = require('./tasks.js');
-const { TaskPage } = tasks;
+const { blockAddText } = require('../diff/diff.js');
+const { itemFeedKey, canEditCode } = require('./items.js');
+const review = require('../review/review.js');
+const { checkLabel } = review;
+const { TemplatePick } = require('./templates.js');
+const { TaskPage } = require('./tasks.js');
 const unit = require('./unit.js');
-const clipboard = require('../clipboard.js');
-
-const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
+const clipboard = require('../term/clipboard.js');
+const { EDIT_OP, copyLine, cutLine } = require('../input/line-edit.js');
+
+const COMPOSE_EDITS = [
+  'backspace',
+  'ctrl-backspace',
+  'delete',
+  'ctrl-z',
+  'ctrl-y',
+];
 const COMPOSE_CLIP = ['ctrl-x', 'ctrl-v'];
 const COMPOSE_LEAVE = ['next', 'prev', 'tasks'];
 
@@ -78,17 +78,13 @@ const blankTail = (text) => {
   return count;
 };
 
+const EDITOR_KEYS = {};
+for (const key of Object.keys(EDIT_OP)) {
+  EDITOR_KEYS[key] = (c) => EDIT_OP[key](c.editor);
+}
+
 const COMPOSE_SPECIAL = {
-  backspace: (c) => c.editor.backspace(),
-  delete: (c) => c.editor.delete(),
-  left: (c) => c.editor.move(-1),
-  right: (c) => c.editor.move(1),
-  'shift-left': (c) => c.editor.move(-1, true),
-  'shift-right': (c) => c.editor.move(1, true),
-  'ctrl-left': (c) => c.editor.moveWord(-1),
-  'ctrl-right': (c) => c.editor.moveWord(1),
-  'ctrl-shift-left': (c) => c.editor.moveWord(-1, true),
-  'ctrl-shift-right': (c) => c.editor.moveWord(1, true),
+  ...EDITOR_KEYS,
   up: (c) => c.moveLine(-1),
   down: (c) => c.moveLine(1),
   'shift-up': (c) => c.moveLine(-1, true),
@@ -118,7 +114,9 @@ class Composer {
   }
 
   reset() {
+    this.tasks.closePlanMenu();
     this.fileDirty = false;
+    this.saving = false;
     this.clear();
   }
 
@@ -128,6 +126,7 @@ class Composer {
     this.commitKind = null;
     this.commitBody = '';
     this.composeTaskId = null;
+    this.composeQuoteKey = null;
     this.composeBaseline = '';
     this.templateIndex = -1;
     this.templateFocus = false;
@@ -157,7 +156,8 @@ class Composer {
     if (kind !== 'code' && kind !== 'file') return;
     if (!this.editor) return;
     const width = this.viewSize().width;
-    this.editor.reveal(codeInnerWidth(width, this.ui.layout));
+    const digits = activeDigits(this.ui);
+    this.editor.reveal(codeInnerWidth(width, this.ui.layout, digits));
   }
 
   followFileEdit() {
@@ -173,6 +173,7 @@ class Composer {
     this.ui.mode = 'compose';
     this.composeKind = kind;
     this.composeTaskId = taskId;
+    this.composeQuoteKey = null;
     this.composeBaseline = text;
     this.fileOpened = kind === 'file' ? text : '';
     this.editor = new Editor(text);
@@ -182,6 +183,11 @@ class Composer {
     this.ui.nav.clearSelection();
   }
 
+  openQuote(key, text) {
+    this.openCompose('tasks', text, null);
+    this.composeQuoteKey = key;
+  }
+
   closeCompose() {
     const ui = this.ui;
     ui.mode = 'review';
@@ -205,7 +211,7 @@ class Composer {
   commitFeedback(text) {
     const item = this.ui.current();
     if (!item || isTaskItem(item)) return;
-    setFeedback(this.notes, itemFeedKey(item), itemNote(item, text));
+    this.notes.setFeedback(itemFeedKey(item), itemNote(item, text));
   }
 
   dropCodeNote(item, text) {
@@ -213,34 +219,52 @@ class Composer {
     if (!notes) return;
     const key = itemFeedKey(item);
     if (!notes.code.has(key)) return;
-    setCode(notes, key, { ...itemNote(item, text), clear: true });
+    notes.setCode(key, { ...itemNote(item, text), clear: true });
+  }
+
+  // Edits that land in the worktree or index, not in the review notes
+  writesDisk() {
+    const kind = this.composeKind;
+    if (!this.editor) return false;
+    if (kind === 'file') return true;
+    return kind === 'code' && this.writesCodeFile(this.ui.current());
   }
 
   commitCode(text) {
+    const item = this.ui.current();
+    if (!canEditCode(item) || this.writesCodeFile(item)) return;
+    const note = itemNote(item, text);
+    const clear = text === blockAddText(item.hunk, item.blockId);
+    this.notes.setCode(itemFeedKey(item), clear ? { ...note, clear } : note);
+  }
+
+  async write(action) {
     const ui = this.ui;
-    const item = ui.current();
-    if (!canEditCode(item)) return true;
-    const original = blockAddText(item.hunk, item.blockId);
-    if (!this.writesCodeFile(item)) {
-      const note = itemNote(item, text);
-      const clear = text === original;
-      setCode(this.notes, itemFeedKey(item), clear ? { ...note, clear } : note);
-      return true;
+    ui.ignoreWatch();
+    try {
+      await ui.ops.exclusive(action);
+    } catch (error) {
+      ui.status = error.message;
+      return false;
     }
-    if (text !== original) {
-      try {
-        ui.repo.edit(ui.top, item, text);
-      } catch (error) {
-        ui.status = error.message;
-        return false;
-      }
+    ui.ignoreWatch();
+    return true;
+  }
+
+  async writeCode(text) {
+    const ui = this.ui;
+    const item = ui.current();
+    if (text !== blockAddText(item.hunk, item.blockId)) {
+      const edit = (top) => ui.repo.edit(top, item, text);
+      const written = await this.write(edit);
+      if (!written) return false;
       this.fileDirty = true;
     }
     this.dropCodeNote(item, text);
     return true;
   }
 
-  saveUnitFile(text) {
+  async saveUnitFile(text) {
     const ui = this.ui;
     const rel = ui.nav.reviewPath;
     if (!rel || !ui.repo.writeFile) return true;
@@ -248,48 +272,37 @@ class Composer {
       ui.status = 'read only';
       return false;
     }
-    try {
-      ui.repo.writeFile(ui.top, rel, text);
-    } catch (error) {
-      ui.status = error.message;
-      return false;
-    }
-    ui.ignoreWatch();
+    const save = (top) => ui.repo.writeFile(top, rel, text);
+    const written = await this.write(save);
+    if (!written) return false;
+    ui.reads.keepText(rel, text);
     this.composeBaseline = text;
     this.fileDirty = true;
     return true;
   }
 
-  stageEditedFile(rel) {
+  stageItems(rel) {
     const ui = this.ui;
     const repo = ui.repo;
-    if (!rel || !this.canChange()) return false;
-    if (repo.stagePath) {
-      try {
-        repo.stagePath(ui.top, rel);
-      } catch (error) {
-        ui.status = error.message;
-        return false;
-      }
-      ui.ignoreWatch();
-      return true;
-    }
-    if (!repo.add) return false;
-    let staged = 0;
-    for (const item of ui.items) {
-      if (listPath(item) !== rel) continue;
-      if (isReadOnlyOrigin(item.origin) || item.origin === 'staged') continue;
-      try {
-        repo.add(ui.top, item);
-      } catch (error) {
-        ui.status = error.message;
-        return staged > 0;
-      }
-      ui.collection.keepOrigin(item, 'staged');
-      staged += 1;
-    }
-    if (staged) ui.ignoreWatch();
-    return staged > 0;
+    if (!repo.add) return;
+    const targets = ui.items.filter((item) => {
+      if (listPath(item) !== rel || isReadOnlyOrigin(item.origin)) return false;
+      return item.origin !== 'staged';
+    });
+    if (!targets.length) return;
+    for (const item of targets) ui.collection.keepOrigin(item, 'staged');
+    ui.ignoreWatch();
+    const write = async () => {
+      for (const item of targets) await ui.ops.add(item);
+    };
+    ui.ops.enqueueLazy({ kind: 'staged', done: '', reload: false, write });
+  }
+
+  async stageEditedFile(rel) {
+    const repo = this.ui.repo;
+    if (!rel || !this.canChange()) return;
+    if (!repo.stagePath) return void this.stageItems(rel);
+    await this.write((top) => repo.stagePath(top, rel));
   }
 
   finishSave(reload, doneStatus) {
@@ -300,84 +313,112 @@ class Composer {
       if (!ui.status) ui.status = doneStatus;
       return;
     }
+    this.fileDirty = false;
     ui.reloadAfterChange(() => {
       if (!ui.status) ui.status = doneStatus;
     });
   }
 
-  saveFileCompose() {
+  // Closes the editor after a note or a block edit; reloads if a file changed
+  finishNote(doneStatus) {
+    const ui = this.ui;
+    if (this.fileDirty === true) return void this.finishSave(true, doneStatus);
+    ui.flushReview();
+    this.closeCompose();
+    ui.status = doneStatus;
+  }
+
+  async saveFile() {
     const rel = this.ui.nav.reviewPath;
     const opened = this.fileOpened;
-    const text = this.editor ? this.editor.text : '';
-    if (this.editor) this.ui.nav.unitLine = this.editor.linePos().line;
-    if (!this.saveUnitFile(text)) return { kind: 'error' };
+    const text = this.editor.text;
+    this.ui.nav.unitLine = this.editor.linePos().line;
+    const saved = await this.saveUnitFile(text);
+    if (!saved) return false;
     const changed = text !== opened;
     const reload = this.fileDirty === true;
-    if (changed) this.stageEditedFile(rel);
+    if (changed) await this.stageEditedFile(rel);
     this.finishSave(reload, changed ? 'staged' : 'saved');
-    return { kind: 'saved' };
+    return true;
+  }
+
+  async saveCode() {
+    const ui = this.ui;
+    const item = ui.current();
+    const unstaged = item.origin !== 'staged';
+    const rel = itemPath(item);
+    const saved = await this.writeCode(this.editor.text);
+    if (!saved) return false;
+    const staging = unstaged && this.fileDirty === true;
+    if (staging) await this.stageEditedFile(rel);
+    this.finishNote(staging ? 'staged' : 'saved');
+    return true;
+  }
+
+  saveEdit() {
+    return this.composeKind === 'file' ? this.saveFile() : this.saveCode();
+  }
+
+  // One save at a time; `after` runs once the edit is safely on disk
+  async saveToDisk(after) {
+    if (this.saving) return;
+    this.saving = true;
+    const settle = () => {
+      this.saving = false;
+    };
+    const saved = await this.saveEdit().finally(settle);
+    if (saved && after) after();
+  }
+
+  // Leaves the editor whether or not the edit could be written
+  async writeAndClose() {
+    const text = this.editor.text;
+    if (this.composeKind === 'file') await this.saveUnitFile(text);
+    else await this.writeCode(text);
+    this.closeCompose();
   }
 
   commitCompose() {
     const kind = this.composeKind;
-    if (!kind || !this.editor) return true;
+    if (!kind || !this.editor) return;
     const text = this.editor.text;
-    if (kind === 'feedback') {
-      if (this.notes) this.commitFeedback(text);
-      return true;
-    }
-    if (kind === 'tasks') {
-      this.tasks.commitTask(text);
-      return true;
-    }
-    if (kind === 'code') return this.commitCode(text);
-    if (kind === 'file') return this.saveUnitFile(text);
-    return true;
+    if (kind === 'feedback' && this.notes) this.commitFeedback(text);
+    if (kind === 'tasks') this.tasks.commitTask(text);
+    if (kind === 'code') this.commitCode(text);
   }
 
+  // Notes save at once. An edit to a file answers `saving` and finishes later
   saveCompose(opts = {}) {
     const ui = this.ui;
     const kind = this.composeKind;
     if (COMMAND_KINDS.includes(kind)) return { kind };
-    if (kind === 'file') return this.saveFileCompose();
-    const item = ui.current();
-    const shouldStage =
-      kind === 'code' && this.writesCodeFile(item) && item.origin !== 'staged';
-    const rel = itemPath(item);
+    if (this.writesDisk()) {
+      ui.ops.hold(this.saveToDisk(opts.after));
+      return { kind: 'saving' };
+    }
     const baseline = this.composeBaseline;
-    if (this.commitCompose() === false) return { kind: 'error' };
-    const reload = this.fileDirty === true;
+    this.commitCompose();
     if (kind === 'feedback' && this.notes) {
       const next = this.editor ? this.editor.text : '';
-      rememberTemplate(this.notes, baseline, next);
-    }
-    const staging = shouldStage && reload;
-    if (staging) this.stageEditedFile(rel);
-    const doneStatus = staging ? 'staged' : 'saved';
-    if (reload) {
-      this.finishSave(true, doneStatus);
-    } else {
-      ui.flushReview();
-      this.closeCompose();
-      ui.status = doneStatus;
+      this.notes.rememberTemplate(baseline, next);
     }
+    this.finishNote('saved');
     if (opts.editNext === true) this.tasks.editNextTask();
     return { kind: 'saved' };
   }
 
+  autosaveFile(text) {
+    if (this.saving || text === this.composeBaseline) return;
+    this.ui.ops.track(this.saveUnitFile(text));
+  }
+
   autosave() {
     const kind = this.composeKind;
     const text = this.editor ? this.editor.text : '';
-    if (kind === 'file' && this.editor) {
-      if (text === this.composeBaseline) return;
-      return void this.saveUnitFile(text);
-    }
-    const editingCode = kind === 'code';
+    if (kind === 'file' && this.editor) return void this.autosaveFile(text);
     const reviewKind = kind !== null && !COMMAND_KINDS.includes(kind);
-    const fileEdit = editingCode && this.writesCodeFile(this.ui.current());
-    if (reviewKind && !fileEdit && (editingCode || text.trim())) {
-      this.commitCompose();
-    }
+    const noted = reviewKind && !this.writesDisk();
+    if (noted && (kind === 'code' || text.trim())) this.commitCompose();
     if (this.notes && this.notes.dirty) this.ui.flushReview();
   }
 
@@ -538,6 +579,12 @@ class Composer {
       ui.status = 'read only';
       return;
     }
+    ui.ops.hold(this.editViewed());
+  }
+
+  async editViewed() {
+    const ui = this.ui;
+    await ui.reads.loadText(ui.nav.reviewPath);
     const at = unit.editCursor(ui);
     this.openCompose('file', at.text);
     this.fileEditRows = at.rows ?? null;
@@ -554,8 +601,8 @@ class Composer {
       ui.status = 'not a diff block';
       return;
     }
-    unit.openUnitFile(ui, entry);
-    this.onUnitEdit();
+    const edit = () => this.onUnitEdit();
+    ui.ops.hold(unit.showFile(ui, entry).then(edit));
   }
 
   onCode() {
@@ -563,7 +610,7 @@ class Composer {
     if (ui.nav.pane === 'files') return void this.onFileEdit();
     if (ui.nav.pane === 'unit') return void this.onUnitEdit();
     const item = ui.current();
-    if (ui.nav.pane === 'files' || !canEditCode(item)) {
+    if (!canEditCode(item)) {
       ui.status = 'not a diff block';
       return;
     }
@@ -609,16 +656,11 @@ class Composer {
   }
 
   copy() {
-    const text = this.editor.selectedText();
-    if (!text) return;
-    const ok = clipboard.copyText(text, this.ui.stdout);
-    this.ui.status = ok ? 'copied' : 'copy failed';
+    copyLine(this.editor, this.ui);
   }
 
   cut() {
-    if (!this.editor.hasSelect()) return;
-    this.copy();
-    this.editor.removeSpan();
+    cutLine(this.editor, this.ui);
   }
 
   paste() {
@@ -646,10 +688,7 @@ class Composer {
       this.afterEdit();
       return result ?? null;
     }
-    if (!key.length || key.startsWith('ctrl-') || key.startsWith('alt-')) {
-      return null;
-    }
-    if (key.length === 1 && key.charCodeAt(0) >= 32) {
+    if (isTextKey(key)) {
       this.templates.clearTemplatePick();
       this.editor.insert(key);
       this.afterEdit();
@@ -660,12 +699,15 @@ class Composer {
   applyDiskText(text) {
     const editor = this.editor;
     if (this.composeKind !== 'file' || !editor) return;
-    if (text === editor.text) return;
+    // The baseline is the last text known on disk: no news, keep the typing
+    if (text === editor.text || text === this.composeBaseline) return;
     const cursor = editor.cursor;
     editor.text = text;
     editor.cursor = Math.min(cursor, text.length);
     editor.anchor = null;
     this.composeBaseline = text;
+    // An outside change is the new starting point, not an edit made here
+    this.fileOpened = text;
     this.fileEditRows = unit.linesFor(this.ui, this.ui.nav.reviewPath, null);
     this.syncCodeScroll();
     this.followFileEdit();

package/lib/session/dashboard.js

@@ -1,22 +1,15 @@
 'use strict';
 
-const files = require('../files.js');
-const { fileEntries, fileTotals } = files;
-const review = require('../review.js');
-const { noteCounts } = review;
-const runs = require('../runs.js');
-const { readRuns, settleRecord, isRunsRel } = runs;
-const tree = require('../dashboard/tree.js');
-const { FileIndex, HEAT_MS } = tree;
-const gitInfo = require('../dashboard/git.js');
-const { readGitSummary } = gitInfo;
-const npmInfo = require('../dashboard/npm.js');
-const { readNpmSummary } = npmInfo;
+const { fileEntries, fileTotals } = require('../common/files.js');
+const { noteCounts } = require('../review/review.js');
+const { readRuns, settleRecord, isRunsRel } = require('../runs/runs.js');
+const { FileIndex, HEAT_MS } = require('../dashboard/tree.js');
+const { readGitSummary } = require('../dashboard/git.js');
+const { readNpmSummary } = require('../dashboard/npm.js');
 const model = require('../dashboard/model.js');
 const { buildModel, minuteOf, MINUTE_MS, npmModel } = model;
 const filesPane = require('./files-pane.js');
-const watch = require('./watch.js');
-const { UNKNOWN_PATH, MODULES_STAMP } = watch;
+const { UNKNOWN_PATH, MODULES_STAMP } = require('../dashboard/watch.js');
 
 const TICK_ID = 'dashboard';
 const HEAT_TIMER = 'dashboard-heat';
@@ -27,7 +20,7 @@ const BLINK_MS = 3000;
 const MINUTE_KEEP = 360;
 const SWITCHES = 4;
 const RUN_MARK = { failed: 'fail', passed: 'pass', aborted: 'abort' };
-const GIT_NAMES = new Set([
+const GIT_NAMES = [
   'HEAD',
   'packed-refs',
   'FETCH_HEAD',
@@ -36,8 +29,8 @@ const GIT_NAMES = new Set([
   'logs',
   'rebase-merge',
   'rebase-apply',
-]);
-const NPM_FILES = new Set(['package.json', 'package-lock.json', MODULES_STAMP]);
+];
+const NPM_FILES = ['package.json', 'package-lock.json', MODULES_STAMP];
 const AGE_FAST_MS = 1000;
 const AGE_MID_MS = 30000;
 const AGE_SLOW_MS = 600000;
@@ -85,11 +78,12 @@ const classify = (paths) => {
     if (rel === UNKNOWN_PATH) {
       found.all = true;
     } else if (rel.startsWith('.git/')) {
-      if (GIT_NAMES.has(rel.split('/')[1])) found.git = true;
+      const gitName = rel.split('/')[1];
+      if (GIT_NAMES.includes(gitName)) found.git = true;
     } else if (isRunsRel(rel)) {
       found.runs = true;
     } else {
-      if (NPM_FILES.has(rel)) found.npm = true;
+      if (NPM_FILES.includes(rel)) found.npm = true;
       found.files.push(rel);
     }
   }
@@ -410,8 +404,12 @@ class Dashboard {
   }
 
   noteDisk(paths) {
-    if (!this.active) return;
     const found = classify(paths);
+    const npm = this.ui.npm;
+    if ((found.runs || found.all) && npm && npm.refreshRecorded) {
+      npm.refreshRecorded();
+    }
+    if (!this.active) return;
     if (found.all) return void this.requestAll();
     const tasks = this.tasks;
     if (found.files.length) {
@@ -465,9 +463,11 @@ class Dashboard {
       npm: this.npm,
       npmExtras: ui.lifecycle.npmExtras(),
       npmRun: ui.npm.lastRun,
+      npmRuns: ui.npm.dashboardRuns(),
       runs: this.liveRuns(),
       notes: noteCounts(store),
       store,
+      agents: ui.agents.summary(),
     });
   }
 
@@ -498,8 +498,8 @@ class Dashboard {
   showFiles(scope) {
     const ui = this.ui;
     ui.showFiles();
-    if (scope === 'file') filesPane.onFileScope(ui);
-    else filesPane.onDiffScope(ui);
+    if (scope === 'file') filesPane.onFileScope(ui, true);
+    else filesPane.onDiffScope(ui, true);
     ui.status = '';
   }
 
@@ -513,6 +513,7 @@ class Dashboard {
       npm: () => this.openPackages(),
       run: () => ui.npm.open(),
       tasks: () => ui.composer.tasks.openTasksPage(),
+      agents: () => ui.agents.open(),
     };
     const opener = openers[id];
     if (!opener || ui.mode !== 'review') return;