reslop 0.2.4 → 0.2.6

package/lib/session/compose.js

@@ -11,7 +11,7 @@ const { listedCommits } = commit;
 const editor = require('../editor.js');
 const { Editor } = editor;
 const files = require('../files.js');
-const { itemPath, isTodoItem, listPath, isReadOnlyOrigin } = files;
+const { itemPath, isTaskItem, listPath, isReadOnlyOrigin } = files;
 const diff = require('../diff/diff.js');
 const { blockAddText } = diff;
 const items = require('./items.js');
@@ -19,163 +19,28 @@ const { itemFeedKey, canEditCode } = items;
 const review = require('../review.js');
 const { setFeedback, setCode, checkLabel, rememberTemplate } = review;
 const templates = require('./templates.js');
-const { createTemplatePick } = templates;
-const todos = require('./todos.js');
-const { createTodoCompose } = todos;
+const { TemplatePick } = templates;
+const tasks = require('./tasks.js');
+const { TaskPage } = tasks;
 const unit = require('./unit.js');
+const clipboard = require('../clipboard.js');
 
 const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
-const COMPOSE_LEAVE = ['next', 'prev', 'todo'];
+const COMPOSE_CLIP = ['ctrl-x', 'ctrl-v'];
+const COMPOSE_LEAVE = ['next', 'prev', 'tasks'];
 
 const KIND = {
-  feedback: {
-    enter: 'save',
-    tab: 'template',
-    escape: 'save',
-    move: 'note',
-    command: null,
-    view: 'note',
-  },
-  code: {
-    enter: 'newline',
-    tab: 'insert-tab',
-    escape: 'save',
-    move: 'code',
-    command: null,
-    view: 'code',
-  },
-  file: {
-    enter: 'newline',
-    tab: 'insert-tab',
-    escape: 'save',
-    move: 'code',
-    command: null,
-    view: 'code',
-  },
-  todo: {
-    enter: 'edit-next',
-    tab: 'template',
-    escape: 'save',
-    move: 'todo',
-    command: null,
-    view: 'todo',
-  },
-  commit: {
-    enter: 'save',
-    tab: 'template',
-    escape: 'cancel',
-    move: 'note',
-    command: 'commit',
-    view: 'note',
-  },
-  branch: {
-    enter: 'save',
-    tab: 'template',
-    escape: 'cancel',
-    move: 'note',
-    command: 'branch',
-    view: 'note',
-  },
-  npm: {
-    enter: 'save',
-    tab: 'insert-tab',
-    escape: 'cancel',
-    move: 'note',
-    command: 'npm',
-    view: 'note',
-  },
+  feedback: { enter: 'save', tab: 'template', escape: 'save', move: 'note' },
+  code: { enter: 'newline', tab: 'insert-tab', escape: 'save', move: 'code' },
+  file: { enter: 'newline', tab: 'insert-tab', escape: 'save', move: 'code' },
+  tasks: { enter: 'edit-next', tab: 'template', escape: 'save', move: 'tasks' },
+  commit: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
+  branch: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
+  npm: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
 };
 
-const initialState = () => ({
-  editor: null,
-  composeKind: null,
-  commitKind: null,
-  commitBody: '',
-  composeTodoId: null,
-  composeBaseline: '',
-  templateIndex: -1,
-  templateFocus: false,
-  blinkOn: true,
-  fileDirty: false,
-  fileEditRows: null,
-  fileOpened: '',
-});
-
-const reset = (state) => {
-  Object.assign(state, initialState());
-};
-
-const resetBlink = (api) => {
-  api.state.blinkOn = true;
-  api.restartBlink();
-};
-
-const tickBlink = (api) => {
-  if (!api.state.composeKind) return;
-  api.state.blinkOn = !api.state.blinkOn;
-  api.ui.draw();
-};
-
-const viewSize = (api) => api.ui.lastSize ?? api.ui.getSize();
-
-const syncCodeScroll = (api) => {
-  const kind = api.state.composeKind;
-  if (kind !== 'code' && kind !== 'file') return;
-  const ed = api.state.editor;
-  if (!ed) return;
-  const size = viewSize(api);
-  const inner = codeInnerWidth(size.width, api.ui.layout);
-  ed.reveal(inner);
-};
-
-const followFileEdit = (api) => {
-  if (api.state.composeKind !== 'file') return;
-  const text = api.state.editor ? api.state.editor.text : null;
-  const rows = unit.linesFor(
-    api.ui,
-    api.nav.reviewPath,
-    text,
-    api.state.fileEditRows,
-  );
-  unit.followFileCursor(api.nav, api.state.editor, api.ui.lastFrame, rows);
-};
-
-const afterClose = (api) => {
-  api.ui.clampIndex();
-  api.ui.syncReviewPath();
-  api.ui.syncFileCursor();
-};
-
-const openCompose = (api, kind, text, todoId) => {
-  const { state, ui, nav } = api;
-  ui.mode = 'compose';
-  state.composeKind = kind;
-  state.composeTodoId = todoId ?? null;
-  state.composeBaseline = text;
-  state.fileOpened = kind === 'file' ? text : '';
-  state.editor = new Editor(text);
-  state.templateIndex = -1;
-  state.templateFocus = false;
-  ui.status = '';
-  nav.clearSelection();
-  resetBlink(api);
-};
-
-const closeCompose = (api) => {
-  const { state, ui } = api;
-  ui.mode = 'review';
-  state.editor = null;
-  state.composeKind = null;
-  state.commitKind = null;
-  state.commitBody = '';
-  state.composeTodoId = null;
-  state.composeBaseline = '';
-  state.fileOpened = '';
-  state.templateIndex = -1;
-  state.templateFocus = false;
-  state.fileEditRows = null;
-  afterClose(api);
-};
+const COMMAND_KINDS = ['commit', 'branch', 'npm'];
+const NOTE_VIEWS = ['feedback', 'commit', 'branch', 'npm'];
 
 const itemNote = (item, text) => {
   const hunk = item.hunk;
@@ -190,586 +55,606 @@ const itemNote = (item, text) => {
   };
 };
 
-const writesCodeFile = (api, item) => {
-  if (!canEditCode(item)) return false;
-  const caps = api.ui.capabilities;
-  if (!caps || caps.changes !== true) return false;
-  if (isReadOnlyOrigin(item.origin)) return false;
-  const repo = api.ui.repo;
-  return !!(repo && typeof repo.edit === 'function');
-};
-
-const commitFeedback = (api, text) => {
-  const item = api.ui.current();
-  if (!item || isTodoItem(item)) return;
-  const notes = api.review.store;
-  setFeedback(notes, itemFeedKey(item), itemNote(item, text));
+const onEmptyLastLine = (editor) => {
+  if (!editor) return false;
+  const text = editor.text;
+  const lastBreak = text.lastIndexOf('\n');
+  if (editor.cursor < lastBreak + 1) return false;
+  return text.slice(lastBreak + 1).trim() === '';
 };
 
-const dropCodeNote = (api, item, text) => {
-  const notes = api.review.store;
-  if (!notes) return;
-  const key = itemFeedKey(item);
-  if (!notes.code.has(key)) return;
-  setCode(notes, key, { ...itemNote(item, text), clear: true });
-};
+const filledLines = (text) =>
+  text.split('\n').filter((line) => line.trim() !== '').length;
 
-const saveCodeNote = (api, item, text) => {
-  const original = blockAddText(item.hunk, item.blockId);
-  const notes = api.review.store;
-  const key = itemFeedKey(item);
-  const note = itemNote(item, text);
-  if (text === original) {
-    return void setCode(notes, key, { ...note, clear: true });
+const blankTail = (text) => {
+  const lines = text.split('\n');
+  let count = 0;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].trim() !== '') break;
+    count += 1;
   }
-  setCode(notes, key, note);
+  return count;
 };
 
-const saveCodeFile = (api, item, text) => {
-  const original = blockAddText(item.hunk, item.blockId);
-  if (text === original) {
-    dropCodeNote(api, item, text);
-    return true;
+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),
+  up: (c) => c.moveLine(-1),
+  down: (c) => c.moveLine(1),
+  'shift-up': (c) => c.moveLine(-1, true),
+  'shift-down': (c) => c.moveLine(1, true),
+  home: (c) => c.home(),
+  end: (c) => c.end(),
+  'shift-home': (c) => c.home(true),
+  'shift-end': (c) => c.end(true),
+  pageUp: (c) => c.movePage(-1),
+  pageDown: (c) => c.movePage(1),
+  'ctrl-a': (c) => c.editor.home(),
+  'ctrl-e': (c) => c.editor.end(),
+  'ctrl-c': (c) => c.copy(),
+  'ctrl-x': (c) => c.cut(),
+  'ctrl-v': (c) => c.paste(),
+  'ctrl-z': (c) => c.editor.undoEdit(),
+  'ctrl-y': (c) => c.editor.redoEdit(),
+  tab: (c) => c.tab(),
+};
+
+class Composer {
+  constructor(ui) {
+    this.ui = ui;
+    this.templates = new TemplatePick(this);
+    this.tasks = new TaskPage(this);
+    this.reset();
+  }
+
+  reset() {
+    this.fileDirty = false;
+    this.clear();
+  }
+
+  clear() {
+    this.editor = null;
+    this.composeKind = null;
+    this.commitKind = null;
+    this.commitBody = '';
+    this.composeTaskId = null;
+    this.composeBaseline = '';
+    this.templateIndex = -1;
+    this.templateFocus = false;
+    this.fileEditRows = null;
+    this.fileOpened = '';
+  }
+
+  get spec() {
+    return KIND[this.composeKind] ?? null;
+  }
+
+  get notes() {
+    return this.ui.review.store;
+  }
+
+  viewSize() {
+    return this.ui.lastSize ?? this.ui.getSize();
+  }
+
+  canChange() {
+    const caps = this.ui.capabilities;
+    return Boolean(caps && caps.changes === true);
+  }
+
+  syncCodeScroll() {
+    const kind = this.composeKind;
+    if (kind !== 'code' && kind !== 'file') return;
+    if (!this.editor) return;
+    const width = this.viewSize().width;
+    this.editor.reveal(codeInnerWidth(width, this.ui.layout));
+  }
+
+  followFileEdit() {
+    if (this.composeKind !== 'file') return;
+    const ui = this.ui;
+    const text = this.editor ? this.editor.text : null;
+    const rel = ui.nav.reviewPath;
+    const rows = unit.linesFor(ui, rel, text, this.fileEditRows);
+    unit.followFileCursor(ui.nav, this.editor, ui.lastFrame, rows);
+  }
+
+  openCompose(kind, text, taskId = null) {
+    this.ui.mode = 'compose';
+    this.composeKind = kind;
+    this.composeTaskId = taskId;
+    this.composeBaseline = text;
+    this.fileOpened = kind === 'file' ? text : '';
+    this.editor = new Editor(text);
+    this.templateIndex = -1;
+    this.templateFocus = false;
+    this.ui.status = '';
+    this.ui.nav.clearSelection();
+  }
+
+  closeCompose() {
+    const ui = this.ui;
+    ui.mode = 'review';
+    this.clear();
+    ui.clampIndex();
+    ui.syncReviewPath();
+    ui.syncFileCursor();
+  }
+
+  liveFileText() {
+    if (this.composeKind !== 'file' || !this.editor) return null;
+    return this.editor.text;
   }
-  try {
-    api.ui.repo.edit(api.ui.top, item, text);
-  } catch (error) {
-    api.ui.status = error.message;
-    return false;
+
+  writesCodeFile(item) {
+    if (!canEditCode(item) || !this.canChange()) return false;
+    if (isReadOnlyOrigin(item.origin)) return false;
+    return Boolean(this.ui.repo.edit);
   }
-  dropCodeNote(api, item, text);
-  api.state.fileDirty = true;
-  return true;
-};
 
-const commitCode = (api, text) => {
-  const item = api.ui.current();
-  if (!canEditCode(item)) return true;
-  if (writesCodeFile(api, item)) return saveCodeFile(api, item, text);
-  saveCodeNote(api, item, text);
-  return true;
-};
+  commitFeedback(text) {
+    const item = this.ui.current();
+    if (!item || isTaskItem(item)) return;
+    setFeedback(this.notes, itemFeedKey(item), itemNote(item, text));
+  }
 
-const saveUnitFile = (api, text) => {
-  const rel = api.nav.reviewPath;
-  const repo = api.ui.repo;
-  if (!rel || !repo || typeof repo.writeFile !== 'function') return true;
-  const caps = api.ui.capabilities;
-  if (!caps || caps.changes !== true) {
-    api.ui.status = 'read only';
-    return false;
+  dropCodeNote(item, text) {
+    const notes = this.notes;
+    if (!notes) return;
+    const key = itemFeedKey(item);
+    if (!notes.code.has(key)) return;
+    setCode(notes, key, { ...itemNote(item, text), clear: true });
   }
-  try {
-    repo.writeFile(api.ui.top, rel, text);
-  } catch (error) {
-    api.ui.status = error.message;
-    return false;
+
+  commitCode(text) {
+    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;
+    }
+    if (text !== original) {
+      try {
+        ui.repo.edit(ui.top, item, text);
+      } catch (error) {
+        ui.status = error.message;
+        return false;
+      }
+      this.fileDirty = true;
+    }
+    this.dropCodeNote(item, text);
+    return true;
   }
-  if (typeof api.ui.ignoreWatch === 'function') api.ui.ignoreWatch();
-  api.state.composeBaseline = text;
-  api.state.fileDirty = true;
-  return true;
-};
 
-const stageEditedFile = (api, rel) => {
-  if (!rel) return false;
-  const repo = api.ui.repo;
-  if (!repo) return false;
-  const caps = api.ui.capabilities;
-  if (!caps || caps.changes !== true) return false;
-  if (typeof repo.stagePath === 'function') {
+  saveUnitFile(text) {
+    const ui = this.ui;
+    const rel = ui.nav.reviewPath;
+    if (!rel || !ui.repo.writeFile) return true;
+    if (!this.canChange()) {
+      ui.status = 'read only';
+      return false;
+    }
     try {
-      repo.stagePath(api.ui.top, rel);
+      ui.repo.writeFile(ui.top, rel, text);
     } catch (error) {
-      api.ui.status = error.message;
+      ui.status = error.message;
       return false;
     }
-    if (typeof api.ui.ignoreWatch === 'function') api.ui.ignoreWatch();
+    ui.ignoreWatch();
+    this.composeBaseline = text;
+    this.fileDirty = true;
     return true;
   }
-  if (typeof repo.add !== 'function') return false;
-  let staged = 0;
-  for (const item of api.ui.items ?? []) {
-    if (listPath(item) !== rel) continue;
-    if (isReadOnlyOrigin(item.origin)) continue;
-    if (item.origin === 'staged') continue;
-    try {
-      repo.add(api.ui.top, item);
-    } catch (error) {
-      api.ui.status = error.message;
-      return staged > 0;
+
+  stageEditedFile(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 (api.ui.collection && api.ui.collection.keepOrigin) {
-      api.ui.collection.keepOrigin(item, 'staged');
+    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;
     }
-    staged += 1;
+    if (staged) ui.ignoreWatch();
+    return staged > 0;
   }
-  if (staged && typeof api.ui.ignoreWatch === 'function') {
-    api.ui.ignoreWatch();
+
+  finishSave(reload, doneStatus) {
+    const ui = this.ui;
+    ui.flushReview();
+    this.closeCompose();
+    if (!reload) {
+      if (!ui.status) ui.status = doneStatus;
+      return;
+    }
+    ui.reloadAfterChange(() => {
+      if (!ui.status) ui.status = doneStatus;
+    });
   }
-  return staged > 0;
-};
 
-const saveFileCompose = (api) => {
-  const rel = api.nav.reviewPath;
-  const opened = api.state.fileOpened;
-  const text = api.state.editor ? api.state.editor.text : '';
-  if (api.state.editor) {
-    api.nav.unitLine = api.state.editor.linePos().line;
-  }
-  const result = saveUnitFile(api, text);
-  if (result === false) return { kind: 'error' };
-  const changed = text !== opened;
-  const reload = api.state.fileDirty === true;
-  if (changed) stageEditedFile(api, rel);
-  api.ui.flushReview();
-  closeCompose(api);
-  const doneStatus = changed ? 'staged' : 'saved';
-  if (!reload || typeof api.ui.reloadAfterChange !== 'function') {
-    if (!api.ui.status) api.ui.status = doneStatus;
+  saveFileCompose() {
+    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 changed = text !== opened;
+    const reload = this.fileDirty === true;
+    if (changed) this.stageEditedFile(rel);
+    this.finishSave(reload, changed ? 'staged' : 'saved');
     return { kind: 'saved' };
   }
-  api.ui.reloadAfterChange(() => {
-    if (!api.ui.status) api.ui.status = doneStatus;
-  });
-  return { kind: 'saved' };
-};
 
-const commitCompose = (api) => {
-  const { state } = api;
-  if (!state.composeKind || !state.editor) return true;
-  const text = state.editor.text;
-  if (state.composeKind === 'feedback') {
-    if (api.review.store) commitFeedback(api, text);
-    return true;
-  }
-  if (state.composeKind === 'todo') {
-    api.todos.commitTodo(text);
+  commitCompose() {
+    const kind = this.composeKind;
+    if (!kind || !this.editor) return true;
+    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 (state.composeKind === 'code') return commitCode(api, text);
-  if (state.composeKind === 'file') return saveUnitFile(api, text);
-  return true;
-};
 
-const saveCompose = (api, extra) => {
-  const opts = extra ?? {};
-  const spec = KIND[api.state.composeKind];
-  if (spec && spec.command) return { kind: spec.command };
-  const kind = api.state.composeKind;
-  if (kind === 'file') return saveFileCompose(api);
-  const item = api.ui.current ? api.ui.current() : null;
-  const shouldStage =
-    kind === 'code' &&
-    writesCodeFile(api, item) &&
-    item &&
-    item.origin !== 'staged';
-  const rel = itemPath(item);
-  const baseline = api.state.composeBaseline;
-  const result = commitCompose(api);
-  if (result === false) return { kind: 'error' };
-  const reload = api.state.fileDirty === true;
-  if (kind === 'feedback') {
-    const notes = api.review.store;
-    const editor = api.state.editor;
-    const next = editor ? editor.text : '';
-    if (notes) rememberTemplate(notes, baseline, next);
-  }
-  if (shouldStage && reload) stageEditedFile(api, rel);
-  api.ui.flushReview();
-  closeCompose(api);
-  const doneStatus = shouldStage && reload ? 'staged' : 'saved';
-  if (reload && typeof api.ui.reloadAfterChange === 'function') {
-    api.ui.reloadAfterChange(() => {
-      if (!api.ui.status) api.ui.status = doneStatus;
-    });
-  } else {
-    api.ui.status = doneStatus;
+  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);
+    const baseline = this.composeBaseline;
+    if (this.commitCompose() === false) return { kind: 'error' };
+    const reload = this.fileDirty === true;
+    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;
+    }
+    if (opts.editNext === true) this.tasks.editNextTask();
+    return { kind: 'saved' };
   }
-  if (opts.editNext === true) api.todos.editNextTodo();
-  return { kind: 'saved' };
-};
 
-const autosave = (api) => {
-  const { state } = api;
-  const spec = KIND[state.composeKind];
-  const text = state.editor ? state.editor.text : '';
-  if (state.composeKind === 'file' && state.editor) {
-    if (text === state.composeBaseline) return;
-    return void saveUnitFile(api, text);
-  }
-  const editingCode = state.composeKind === 'code';
-  const composing = state.composeKind !== null;
-  const reviewKind = composing && (!spec || !spec.command);
-  const liveItem = api.ui.current ? api.ui.current() : null;
-  const fileEdit = editingCode && writesCodeFile(api, liveItem);
-  if (reviewKind && !fileEdit && (editingCode || text.trim())) {
-    commitCompose(api);
-  }
-  const notes = api.review.store;
-  if (notes && notes.dirty) api.ui.flushReview();
-};
-
-const composeView = (api) => {
-  const { state } = api;
-  if (!state.composeKind || !state.editor) return null;
-  const spec = KIND[state.composeKind];
-  if (!spec || spec.view !== 'note') return null;
-  const kind = state.composeKind;
-  const text = state.editor.text;
-  const cursor = state.editor.cursor;
-  return { kind, text, cursor, commitKind: state.commitKind };
-};
-
-const liveCodeText = (api) => {
-  const { state } = api;
-  if (state.composeKind === 'file' && state.editor) return state.editor.text;
-  const item = api.ui.current();
-  if (!canEditCode(item)) return null;
-  if (state.composeKind === 'code' && state.editor) return state.editor.text;
-  if (writesCodeFile(api, item)) return null;
-  const notes = api.review.store;
-  if (!notes) return null;
-  const note = notes.code.get(itemFeedKey(item));
-  if (!note) return null;
-  return note.text;
-};
-
-const codeOverlayView = (api) => {
-  const text = liveCodeText(api);
-  if (text === null) return null;
-  const editing =
-    api.state.composeKind === 'code' || api.state.composeKind === 'file';
-  const editor = api.state.editor;
-  const cursor = editing && editor ? editor.cursor : null;
-  const picked = editing && editor ? editor.scrollCol : 0;
-  const scrollCol = picked ?? 0;
-  return { text, keepEmpty: editing, cursor, scrollCol };
-};
-
-const idleNoteText = (api) => {
-  const notes = api.review.store;
-  if (!notes) return '';
-  if (api.state.composeKind) return '';
-  const item = api.ui.current();
-  if (!item || isTodoItem(item)) return '';
-  const note = notes.feedback.get(itemFeedKey(item));
-  if (!note || !note.text.trim()) return '';
-  return checkLabel(note.text, note.done);
-};
+  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';
+    const reviewKind = kind !== null && !COMMAND_KINDS.includes(kind);
+    const fileEdit = editingCode && this.writesCodeFile(this.ui.current());
+    if (reviewKind && !fileEdit && (editingCode || text.trim())) {
+      this.commitCompose();
+    }
+    if (this.notes && this.notes.dirty) this.ui.flushReview();
+  }
+
+  composeView() {
+    const { composeKind: kind, editor } = this;
+    if (!editor || !NOTE_VIEWS.includes(kind)) return null;
+    const { text, cursor, scrollCol, anchor } = editor;
+    return {
+      kind,
+      text,
+      cursor,
+      scrollCol,
+      anchor,
+      commitKind: this.commitKind,
+    };
+  }
+
+  liveCodeText() {
+    const kind = this.composeKind;
+    if (kind === 'file' && this.editor) return this.editor.text;
+    const item = this.ui.current();
+    if (!canEditCode(item)) return null;
+    if (kind === 'code' && this.editor) return this.editor.text;
+    if (this.writesCodeFile(item) || !this.notes) return null;
+    const note = this.notes.code.get(itemFeedKey(item));
+    return note ? note.text : null;
+  }
+
+  codeOverlayView() {
+    const text = this.liveCodeText();
+    if (text === null) return null;
+    const editing = this.composeKind === 'code' || this.composeKind === 'file';
+    const editor = editing ? this.editor : null;
+    return {
+      text,
+      keepEmpty: editing,
+      cursor: editor?.cursor ?? null,
+      scrollCol: editor?.scrollCol ?? 0,
+      anchor: editor?.anchor ?? null,
+    };
+  }
+
+  idleNoteText() {
+    const notes = this.notes;
+    if (!notes || this.composeKind) return '';
+    const item = this.ui.current();
+    if (!item || isTaskItem(item)) return '';
+    const note = notes.feedback.get(itemFeedKey(item));
+    if (!note || !note.text.trim()) return '';
+    return checkLabel(note.text, note.done);
+  }
+
+  tab() {
+    if (this.spec && this.spec.tab === 'insert-tab') {
+      this.editor.insert('\t');
+      return null;
+    }
+    return this.templates.applyTemplate();
+  }
+
+  moveTemplateLine(delta, shown, width) {
+    const pick = this.templates;
+    if (this.templateFocus) {
+      const next = Math.max(
+        0,
+        Math.min(this.templateIndex + delta, shown.length - 1),
+      );
+      if (next === this.templateIndex) this.templateFocus = false;
+      else pick.focusTemplate(next, false);
+      return true;
+    }
+    const pos = cursorInWrap(this.editor.text, this.editor.cursor, width);
+    const last = wrapDoc(this.editor.text, width).length - 1;
+    if (delta < 0 && pos.row === 0) {
+      pick.focusTemplate(shown.length - 1, false);
+      return true;
+    }
+    if (delta > 0 && pos.row === last) {
+      pick.focusTemplate(0, false);
+      return true;
+    }
+    return false;
+  }
 
-const composeTab = (api) => {
-  const spec = KIND[api.state.composeKind];
-  if (spec && spec.tab === 'insert-tab') {
-    api.state.editor.insert('\t');
-    return null;
+  noteLineWidth() {
+    const width = this.viewSize().width;
+    const fullCommit =
+      this.composeKind === 'commit' && this.ui.commits.commitView === 'full';
+    if (!fullCommit) return noteInnerWidth(width);
+    const inPlace = this.commitKind === 'amend' || this.commitKind === 'reword';
+    const list = listedCommits(this.ui.commits.commits);
+    const entry = (inPlace && list[this.ui.nav.commitCursor]) || null;
+    return commitMessageWidth(entry, width);
   }
-  return api.templates.applyTemplate();
-};
 
-const moveTemplateLine = (api, delta, shown, width) => {
-  const { state } = api;
-  if (state.templateFocus) {
-    let next = state.templateIndex + delta;
-    if (next < 0) next = 0;
-    if (next >= shown.length) next = shown.length - 1;
-    if (next === state.templateIndex) {
-      state.templateFocus = false;
-      return true;
+  moveLine(delta, extend) {
+    const move = this.spec ? this.spec.move : 'note';
+    if (move === 'tasks') {
+      const inner = todoBodyWidth(this.viewSize().width);
+      return void this.tasks.moveTaskCompose(delta, inner, extend);
     }
-    api.templates.focusTemplate(next, false);
-    return true;
+    if (move === 'code') {
+      this.editor.moveLine(delta, undefined, extend);
+      return void this.syncCodeScroll();
+    }
+    const width = this.noteLineWidth();
+    const shown = this.templates.shownTemplates();
+    const feedback = this.composeKind === 'feedback';
+    if (shown.length && feedback && !extend) {
+      if (this.moveTemplateLine(delta, shown, width)) return;
+    }
+    this.editor.moveLine(delta, width, extend);
   }
-  const pos = cursorInWrap(state.editor.text, state.editor.cursor, width);
-  const last = wrapDoc(state.editor.text, width).length - 1;
-  if (delta < 0 && pos.row === 0) {
-    api.templates.focusTemplate(shown.length - 1, false);
-    return true;
+
+  movePage(dir) {
+    const frame = this.ui.lastFrame;
+    const fallback = Math.max(1, (this.viewSize().height ?? 24) - 4);
+    const step = Math.max(1, frame?.bodyH ?? fallback);
+    this.moveLine(step * dir);
   }
-  if (delta > 0 && pos.row === last) {
-    api.templates.focusTemplate(0, false);
+
+  jumpTemplates(toEnd) {
+    if (!this.templateFocus) return false;
+    const shown = this.templates.shownTemplates();
+    if (!shown.length) return false;
+    this.templates.focusTemplate(toEnd ? shown.length - 1 : 0, false);
     return true;
   }
-  return false;
-};
 
-const moveNoteLine = (api, delta) => {
-  const size = viewSize(api);
-  const width = noteInnerWidth(size.width);
-  const shown = api.templates.shownTemplates();
-  const feedback = api.state.composeKind === 'feedback';
-  if (shown.length && feedback) {
-    if (moveTemplateLine(api, delta, shown, width)) return;
+  home(extend) {
+    if (!extend && this.jumpTemplates(false)) return;
+    this.editor.home(extend);
   }
-  api.state.editor.moveLine(delta, width);
-};
-
-const fullCommitEdit = (api) =>
-  api.state.composeKind === 'commit' && api.ui.commits.commitView === 'full';
-
-const editedCommitEntry = (api) => {
-  const kind = api.state.commitKind;
-  if (kind !== 'amend' && kind !== 'reword') return null;
-  const list = listedCommits(api.ui.commits.commits);
-  return list[api.nav.commitCursor] ?? null;
-};
 
-const moveCommitLine = (api, delta) => {
-  const size = viewSize(api);
-  const width = commitMessageWidth(editedCommitEntry(api), size.width);
-  api.state.editor.moveLine(delta, width);
-};
-
-const moveComposeLine = (api, delta) => {
-  const spec = KIND[api.state.composeKind];
-  const move = spec ? spec.move : 'note';
-  if (move === 'todo') {
-    const size = viewSize(api);
-    const inner = todoBodyWidth(size.width);
-    return void api.todos.moveTodoCompose(delta, inner);
-  }
-  if (move === 'code') {
-    api.state.editor.moveLine(delta);
-    return void syncCodeScroll(api);
+  end(extend) {
+    if (!extend && this.jumpTemplates(true)) return;
+    this.editor.end(extend);
   }
-  if (fullCommitEdit(api)) return void moveCommitLine(api, delta);
-  moveNoteLine(api, delta);
-};
-
-const composePageStep = (api) => {
-  const frame = api.ui.lastFrame ?? null;
-  const size = viewSize(api);
-  const fallback = Math.max(1, (size.height ?? 24) - 4);
-  return Math.max(1, frame?.bodyH ?? fallback);
-};
-
-const jumpComposeTemplates = (api, toEnd) => {
-  if (!api.state.templateFocus) return false;
-  const shown = api.templates.shownTemplates();
-  if (!shown.length) return false;
-  const index = toEnd ? shown.length - 1 : 0;
-  api.templates.focusTemplate(index, false);
-  return true;
-};
-
-const composeHome = (api) => {
-  if (jumpComposeTemplates(api, false)) return;
-  api.state.editor.home();
-};
 
-const composeEnd = (api) => {
-  if (jumpComposeTemplates(api, true)) return;
-  api.state.editor.end();
-};
-
-const moveComposePage = (api, dir) => {
-  const step = composePageStep(api) * dir;
-  moveComposeLine(api, step);
-};
-
-const onFeedback = (api) => {
-  if (api.nav.pane === 'files') {
-    api.ui.status = 'not a diff block';
-    return;
+  onFeedback() {
+    const ui = this.ui;
+    const item = ui.current();
+    if (ui.nav.pane === 'files' || !item || isTaskItem(item)) {
+      ui.status = 'not a diff block';
+      return;
+    }
+    const prev = this.notes.feedback.get(itemFeedKey(item));
+    this.openCompose('feedback', prev ? prev.text : '');
   }
-  const item = api.ui.current();
-  if (!item || isTodoItem(item)) {
-    api.ui.status = 'not a diff block';
-    return;
+
+  onUnitEdit() {
+    const ui = this.ui;
+    if (!ui.nav.reviewPath) {
+      ui.status = 'not a diff block';
+      return;
+    }
+    if (!this.canChange()) {
+      ui.status = 'read only';
+      return;
+    }
+    const at = unit.editCursor(ui);
+    this.openCompose('file', at.text);
+    this.fileEditRows = at.rows ?? null;
+    this.editor.cursor = Math.min(at.cursor, at.text.length);
+    this.syncCodeScroll();
+    this.followFileEdit();
+  }
+
+  onCode() {
+    const ui = this.ui;
+    if (ui.nav.pane === 'unit') return void this.onUnitEdit();
+    const item = ui.current();
+    if (ui.nav.pane === 'files' || !canEditCode(item)) {
+      ui.status = 'not a diff block';
+      return;
+    }
+    const original = blockAddText(item.hunk, item.blockId);
+    const writes = this.writesCodeFile(item);
+    const prev = writes ? null : this.notes.code.get(itemFeedKey(item));
+    this.openCompose('code', prev ? prev.text : original);
+    this.syncCodeScroll();
   }
-  const notes = api.review.store;
-  const prev = notes.feedback.get(itemFeedKey(item));
-  const text = prev ? prev.text : '';
-  openCompose(api, 'feedback', text);
-};
 
-const onUnitEdit = (api) => {
-  const rel = api.nav.reviewPath;
-  if (!rel) {
-    api.ui.status = 'not a diff block';
-    return;
-  }
-  const caps = api.ui.capabilities;
-  if (!caps || caps.changes !== true) {
-    api.ui.status = 'read only';
-    return;
-  }
-  const at = unit.editCursor(api.ui);
-  openCompose(api, 'file', at.text);
-  api.state.fileEditRows = at.rows ?? null;
-  api.state.editor.cursor = Math.min(at.cursor, at.text.length);
-  syncCodeScroll(api);
-  followFileEdit(api);
-};
+  insertNewline() {
+    this.editor.insert('\n');
+    this.followFileEdit();
+    return null;
+  }
 
-const onCode = (api) => {
-  if (api.nav.pane === 'unit') return void onUnitEdit(api);
-  if (api.nav.pane === 'files') {
-    api.ui.status = 'not a diff block';
-    return;
-  }
-  const item = api.ui.current();
-  if (!canEditCode(item)) {
-    api.ui.status = 'not a diff block';
-    return;
-  }
-  const original = blockAddText(item.hunk, item.blockId);
-  const notes = api.review.store;
-  const prev = writesCodeFile(api, item)
-    ? null
-    : notes.code.get(itemFeedKey(item));
-  const text = prev ? prev.text : original;
-  openCompose(api, 'code', text);
-  syncCodeScroll(api);
-};
+  enter() {
+    const kind = this.composeKind;
+    if (this.templateFocus && kind === 'feedback') {
+      return this.templates.selectTemplate(this.templateIndex);
+    }
+    const spec = this.spec;
+    if (spec && spec.enter === 'newline') return this.insertNewline();
+    if (kind === 'commit' && this.ui.commits.commitView === 'full') {
+      const text = this.editor ? this.editor.text : '';
+      const shaped = filledLines(text) >= 2 || blankTail(text) >= 2;
+      if (onEmptyLastLine(this.editor) && shaped) return this.saveCompose();
+      return this.insertNewline();
+    }
+    if (spec && spec.enter === 'edit-next') {
+      return this.saveCompose({ editNext: true });
+    }
+    return this.saveCompose();
+  }
 
-const insertNewline = (api) => {
-  api.state.editor.insert('\n');
-  resetBlink(api);
-  followFileEdit(api);
-  return null;
-};
+  leave(key) {
+    if (this.spec && this.spec.escape === 'cancel' && key === 'escape') {
+      this.closeCompose();
+      this.ui.status = '';
+      return null;
+    }
+    return this.saveCompose();
+  }
 
-const onEmptyLastLine = (editor) => {
-  if (!editor) return false;
-  const text = editor.text;
-  const lastBreak = text.lastIndexOf('\n');
-  if (editor.cursor < lastBreak + 1) return false;
-  return text.slice(lastBreak + 1).trim() === '';
-};
+  copy() {
+    const text = this.editor.selectedText();
+    if (!text) return;
+    const ok = clipboard.copyText(text, this.ui.stdout);
+    this.ui.status = ok ? 'copied' : 'copy failed';
+  }
 
-const enterCompose = (api) => {
-  const { state } = api;
-  if (state.templateFocus && state.composeKind === 'feedback') {
-    return api.templates.selectTemplate(state.templateIndex);
+  cut() {
+    if (!this.editor.hasSelect()) return;
+    this.copy();
+    this.editor.removeSpan();
   }
-  const spec = KIND[state.composeKind];
-  if (spec && spec.enter === 'newline') return insertNewline(api);
-  if (fullCommitEdit(api)) {
-    if (onEmptyLastLine(state.editor)) return saveCompose(api);
-    return insertNewline(api);
+
+  paste() {
+    const text = clipboard.pasteText();
+    if (text) this.editor.insert(text);
   }
-  if (spec && spec.enter === 'edit-next') {
-    return saveCompose(api, { editNext: true });
+
+  afterEdit() {
+    this.followFileEdit();
+    this.syncCodeScroll();
   }
-  return saveCompose(api);
-};
 
-const leaveCompose = (api, key) => {
-  const spec = KIND[api.state.composeKind];
-  if (spec && spec.escape === 'cancel' && key === 'escape') {
-    closeCompose(api);
-    api.ui.status = '';
+  handleKey(key) {
+    if (key === 'enter') {
+      const result = this.enter();
+      this.syncCodeScroll();
+      return result;
+    }
+    if (key === 'escape' || key === 'ctrl-s') return this.leave(key);
+    const special = COMPOSE_SPECIAL[key];
+    if (special) {
+      const result = special(this);
+      const edits = COMPOSE_EDITS.includes(key) || COMPOSE_CLIP.includes(key);
+      if (edits) this.templates.clearTemplatePick();
+      this.afterEdit();
+      return result ?? null;
+    }
+    if (!key.length || key.startsWith('ctrl-') || key.startsWith('alt-')) {
+      return null;
+    }
+    if (key.charCodeAt(0) >= 32) {
+      this.templates.clearTemplatePick();
+      this.editor.insert(key);
+      this.afterEdit();
+    }
     return null;
   }
-  return saveCompose(api);
-};
 
-const COMPOSE_SPECIAL = {
-  backspace: (api) => api.state.editor.backspace(),
-  delete: (api) => api.state.editor.delete(),
-  left: (api) => api.state.editor.move(-1),
-  right: (api) => api.state.editor.move(1),
-  'ctrl-left': (api) => api.state.editor.moveWord(-1),
-  'ctrl-right': (api) => api.state.editor.moveWord(1),
-  up: (api) => moveComposeLine(api, -1),
-  down: (api) => moveComposeLine(api, 1),
-  home: (api) => composeHome(api),
-  end: (api) => composeEnd(api),
-  pageUp: (api) => moveComposePage(api, -1),
-  pageDown: (api) => moveComposePage(api, 1),
-  'ctrl-a': (api) => api.state.editor.home(),
-  'ctrl-e': (api) => api.state.editor.end(),
-  'ctrl-z': (api) => api.state.editor.undoEdit(),
-  'ctrl-y': (api) => api.state.editor.redoEdit(),
-  tab: (api) => composeTab(api),
-};
-
-const handleKey = (api, key) => {
-  if (key === 'enter') {
-    const result = enterCompose(api);
-    syncCodeScroll(api);
-    return result;
-  }
-  if (key === 'escape' || key === 'ctrl-s') return leaveCompose(api, key);
-  const special = COMPOSE_SPECIAL[key];
-  if (special) {
-    const result = special(api);
-    if (COMPOSE_EDITS.includes(key)) api.templates.clearTemplatePick();
-    resetBlink(api);
-    followFileEdit(api);
-    syncCodeScroll(api);
-    return result ?? null;
-  }
-  if (!key.length) return null;
-  if (key.startsWith('ctrl-') || key.startsWith('alt-')) return null;
-  if (key.charCodeAt(0) >= 32) {
-    api.templates.clearTemplatePick();
-    api.state.editor.insert(key);
-    resetBlink(api);
-    followFileEdit(api);
-    syncCodeScroll(api);
-  }
-  return null;
-};
-
-const applyDiskText = (api, text) => {
-  if (api.state.composeKind !== 'file' || !api.state.editor) return;
-  if (text === api.state.editor.text) return;
-  const cursor = api.state.editor.cursor;
-  api.state.editor.text = text;
-  api.state.editor.cursor = Math.min(cursor, text.length);
-  api.state.composeBaseline = text;
-  api.state.fileEditRows = unit.linesFor(api.ui, api.nav.reviewPath, null);
-  syncCodeScroll(api);
-  followFileEdit(api);
-};
-
-const composerMethods = (api) => ({
-  reset: () => reset(api.state),
-  openCompose: (kind, text, todoId) => openCompose(api, kind, text, todoId),
-  closeCompose: () => closeCompose(api),
-  commitCompose: () => commitCompose(api),
-  saveCompose: (opts) => saveCompose(api, opts),
-  autosave: () => autosave(api),
-  composeView: () => composeView(api),
-  codeOverlayView: () => codeOverlayView(api),
-  idleNoteText: () => idleNoteText(api),
-  resetBlink: () => resetBlink(api),
-  tickBlink: () => tickBlink(api),
-  onFeedback: () => onFeedback(api),
-  onCode: () => onCode(api),
-  handleKey: (key) => handleKey(api, key),
-  liveFileText: () => {
-    if (api.state.composeKind !== 'file' || !api.state.editor) return null;
-    return api.state.editor.text;
-  },
-  fileEditRows: () => api.state.fileEditRows,
-  applyDiskText: (text) => applyDiskText(api, text),
-});
-
-const createComposer = ({ nav, review, ui, restartBlink }) => {
-  const state = initialState();
-  const api = { nav, review, ui, restartBlink, state };
-  api.open = (kind, text, todoId) => openCompose(api, kind, text, todoId);
-  api.close = () => closeCompose(api);
-  api.commit = () => commitCompose(api);
-  api.save = (opts) => saveCompose(api, opts);
-  api.resetBlink = () => resetBlink(api);
-  api.templates = createTemplatePick(api);
-  api.todos = createTodoCompose(api);
-  const composer = {
-    state,
-    ...composerMethods(api),
-    ...api.todos,
-    ...api.templates,
-  };
-  return composer;
-};
+  applyDiskText(text) {
+    const editor = this.editor;
+    if (this.composeKind !== 'file' || !editor) return;
+    if (text === editor.text) return;
+    const cursor = editor.cursor;
+    editor.text = text;
+    editor.cursor = Math.min(cursor, text.length);
+    editor.anchor = null;
+    this.composeBaseline = text;
+    this.fileEditRows = unit.linesFor(this.ui, this.ui.nav.reviewPath, null);
+    this.syncCodeScroll();
+    this.followFileEdit();
+  }
+}
 
-module.exports = {
-  COMPOSE_EDITS,
-  COMPOSE_LEAVE,
-  KIND,
-  createComposer,
-};
+module.exports = { COMPOSE_LEAVE, Composer };