reslop 0.2.6 → 0.3.0

package/lib/session/agents/options.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const { isHashObject } = require('metautil');
+const { trimText } = require('../../common/utilities.js');
+
+const models = require('../../agents/models.js');
+const { catalogOf, fitEffort, withoutFast, contextMenu } = models;
+
+const RESTORED_FIELDS = ['model', 'effort', 'context'];
+
+const concrete = (name) => {
+  const text = trimText(name);
+  return text === 'default' ? '' : text;
+};
+
+const menuNames = (catalog) => {
+  const names = catalog.entries.map((entry) => concrete(entry.model));
+  const known = new Set(names);
+  const shown = names.filter((name) => {
+    const base = withoutFast(name);
+    return name && (name === base || !known.has(base));
+  });
+  return [...new Set(shown)];
+};
+
+class AgentOptions {
+  constructor(row) {
+    this.row = row;
+    this.catalog = catalogOf(row.models);
+    this.names = menuNames(this.catalog);
+  }
+
+  shown(model) {
+    const saved = concrete(model);
+    const base = withoutFast(saved);
+    if (this.names.includes(base)) return base;
+    if (this.names.includes(saved)) return saved;
+    return this.names[0] || '';
+  }
+
+  // What the cli lists wins over the levels the spec falls back to
+  levels(model) {
+    const resolved = this.catalog.resolve({ model, effort: 'default' });
+    if (resolved.encoded) return resolved.levels;
+    const { modelEfforts, listedEfforts, spec } = this.row;
+    const own = modelEfforts ? modelEfforts.get(resolved.model) : null;
+    const listed = own ?? listedEfforts;
+    return listed ? ['default', ...listed] : spec.efforts;
+  }
+
+  efforts(model) {
+    return this.levels(model).filter((level) => concrete(level));
+  }
+
+  contexts(model) {
+    return contextMenu(
+      model,
+      this.row.wide,
+      this.catalog,
+      this.row.spec.contexts,
+    );
+  }
+
+  hasFast(model) {
+    const base = withoutFast(concrete(model));
+    return Boolean(base) && this.catalog.find(`${base}-fast`) !== null;
+  }
+
+  firstModel(accept) {
+    return this.names.find(accept) ?? '';
+  }
+
+  fitContext(model, context) {
+    const want = concrete(context);
+    if (!want) return '';
+    const sizes = this.contexts(model);
+    return sizes.includes(want) ? want : sizes[0] || '';
+  }
+
+  align(picked, model = '') {
+    const shown = model || this.shown(picked.model);
+    const basis = concrete(picked.model) || shown;
+    picked.effort = fitEffort(this.levels(basis), picked.effort);
+    picked.context = this.fitContext(shown, picked.context);
+    const lost = this.catalog.hasFast() && !this.hasFast(shown);
+    if (picked.fast && lost) picked.fast = false;
+    return shown;
+  }
+
+  normalize(picked, model = '') {
+    picked.model = this.catalog.resolve(picked).family;
+    return this.align(picked, model || this.shown(picked.model));
+  }
+
+  preferEffort(picked, level) {
+    if (concrete(picked.effort)) return;
+    if (this.efforts(picked.model).includes(level)) picked.effort = level;
+  }
+
+  pickModel(picked, model) {
+    picked.model = model;
+    this.align(picked, model);
+  }
+
+  pickContext(picked, size) {
+    picked.context = size;
+    const offers = (model) => this.contexts(model).includes(size);
+    if (!offers(this.shown(picked.model))) {
+      picked.model = this.firstModel(offers) || picked.model;
+    }
+    const model = this.shown(picked.model);
+    this.align(picked, model);
+    if (offers(model)) picked.context = size;
+  }
+
+  toggleFast(picked) {
+    picked.fast = picked.fast !== true;
+    const shown = this.shown(picked.model);
+    const missing = this.catalog.hasFast() && !this.hasFast(shown);
+    if (picked.fast && missing) {
+      const next = this.firstModel((name) => this.hasFast(name));
+      if (next) picked.model = next;
+      else picked.fast = false;
+    }
+    this.align(picked, this.shown(picked.model));
+  }
+}
+
+const restoredFields = (spec) =>
+  spec.savesExtra ? [...RESTORED_FIELDS, 'extra'] : RESTORED_FIELDS;
+
+const restoreChoice = (picked, saved, spec) => {
+  if (!isHashObject(saved)) return;
+  for (const field of restoredFields(spec)) {
+    const value = concrete(saved[field]);
+    if (value) picked[field] = value;
+  }
+  if (saved.fast === true) picked.fast = true;
+};
+
+const storedChoice = (picked, spec) => {
+  const fields = [
+    ['model', concrete(picked.model)],
+    ['effort', concrete(picked.effort)],
+    ['extra', spec.savesExtra ? concrete(picked.extra) : ''],
+    ['fast', picked.fast === true],
+    ['context', concrete(picked.context)],
+  ];
+  const stored = Object.fromEntries(fields.filter((field) => field[1]));
+  return Object.keys(stored).length ? stored : null;
+};
+
+module.exports = { AgentOptions, concrete, restoreChoice, storedChoice };

package/lib/session/agents/plans.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { visibleWidth } = require('../../term/ansi.js');
+const { padVisible } = require('../../render/primitives.js');
+const review = require('../../review/review.js');
+const { parseReview, reviewProgress, frontmatterStatus } = review;
+const { trimText } = require('../../common/utilities.js');
+
+const planKey = (value) => {
+  const text = trimText(value);
+  if (!text) return '';
+  const gap = text.indexOf('  ');
+  return gap > 0 ? text.slice(0, gap) : path.basename(text);
+};
+
+const isLive = (store, file) => {
+  const live = store ? store.reviewPath : '';
+  return Boolean(live) && path.basename(live) === path.basename(file);
+};
+
+const planState = (file, store) => {
+  if (isLive(store, file)) {
+    const status = trimText(store.status) || 'editing';
+    return { status, ...reviewProgress(store) };
+  }
+  try {
+    const text = fs.readFileSync(file, 'utf8');
+    const parsed = parseReview(text, file);
+    const progress = reviewProgress(parsed);
+    const fallback = progress.total ? 'editing' : '';
+    const status = frontmatterStatus(text) ? parsed.status : fallback;
+    return { status, done: progress.done, total: progress.total };
+  } catch {
+    return null;
+  }
+};
+
+const planProgress = (file, root, store) => {
+  if (!file) return '';
+  const abs = path.isAbsolute(file) ? file : path.join(root, file);
+  const state = planState(abs, store);
+  return state && state.total ? `${state.done}/${state.total}` : '';
+};
+
+const planPart = (dir, name, store) => {
+  const base = planKey(name);
+  if (!base) return null;
+  const state = planState(path.join(dir, base), store);
+  if (!state || !state.status) return { name: base, status: '', progress: '' };
+  const progress = `${state.done}/${state.total}`;
+  return { name: base, status: state.status, progress };
+};
+
+const planLabel = (part) => {
+  if (!part.status) return part.name;
+  return `${part.name}  ${part.status}  ${part.progress}`;
+};
+
+const alignPlanLabels = (parts) => {
+  let nameW = 0;
+  let statusW = 0;
+  for (const part of parts) {
+    if (!part.status) continue;
+    nameW = Math.max(nameW, visibleWidth(part.name));
+    statusW = Math.max(statusW, visibleWidth(part.status));
+  }
+  return parts.map((part) => {
+    if (!part.status) return part.name;
+    const name = padVisible(part.name, nameW, 'end');
+    const status = padVisible(part.status, statusW, 'end');
+    return planLabel({ name, status, progress: part.progress });
+  });
+};
+
+module.exports = {
+  planKey,
+  planProgress,
+  planPart,
+  planLabel,
+  alignPlanLabels,
+};

package/lib/session/branches.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const ops = require('./ops.js');
-const { pickRepoWrite } = ops;
+const { clamp } = require('../common/utilities.js');
 
 class BranchController {
   constructor(ui) {
@@ -22,10 +21,10 @@ class BranchController {
     return this.ui.nav.pane === 'branches' && this.ui.commits.canCommit();
   }
 
-  loadBranches() {
+  async loadBranches() {
     const ui = this.ui;
     try {
-      this.branches = ui.repo.listBranches(ui.top);
+      this.branches = await ui.repo.listBranches(ui.top);
       return true;
     } catch (error) {
       ui.status = error.message;
@@ -33,14 +32,32 @@ class BranchController {
     }
   }
 
+  async refresh() {
+    if (!this.ui.repo.listBranches) return;
+    const loaded = await this.loadBranches();
+    if (!loaded) return;
+    const last = this.branches.length - 1;
+    const nav = this.ui.nav;
+    if (nav.branchCursor > last) nav.branchCursor = Math.max(0, last);
+  }
+
   refreshAfterWrite(extra = {}) {
-    if (this.ui.repo.listBranches && this.loadBranches()) {
-      const last = this.branches.length - 1;
-      const nav = this.ui.nav;
-      if (nav.branchCursor > last) nav.branchCursor = Math.max(0, last);
-    }
-    this.ui.commits.refresh();
-    this.ui.refreshFromRepo({ keepEmpty: true, ...extra });
+    const ui = this.ui;
+    ui.ops.hold(Promise.all([this.refresh(), ui.commits.refresh()]));
+    ui.refreshFromRepo({ keepEmpty: true, ...extra });
+  }
+
+  async open() {
+    const ui = this.ui;
+    const loaded = await this.loadBranches();
+    if (!loaded) return;
+    const current = this.branches.findIndex((entry) => entry.current);
+    const nav = ui.nav;
+    nav.branchCursor = current < 0 ? 0 : current;
+    nav.pane = 'branches';
+    nav.resetListScroll('branches');
+    ui.status = '';
+    nav.clearSelection();
   }
 
   runWrite(name, args, kind, done) {
@@ -56,14 +73,7 @@ class BranchController {
       ui.status = 'read only';
       return;
     }
-    if (!this.loadBranches()) return;
-    const current = this.branches.findIndex((entry) => entry.current);
-    const nav = ui.nav;
-    nav.branchCursor = current < 0 ? 0 : current;
-    nav.pane = 'branches';
-    nav.resetListScroll('branches');
-    ui.status = '';
-    nav.clearSelection();
+    ui.ops.hold(this.open());
   }
 
   onBranchMove(delta) {
@@ -73,7 +83,7 @@ class BranchController {
       return;
     }
     const last = this.branches.length - 1;
-    const next = Math.min(last, Math.max(0, nav.branchCursor + delta));
+    const next = clamp(nav.branchCursor + delta, 0, last);
     if (next === nav.branchCursor) return;
     nav.branchCursor = next;
     this.ui.status = '';
@@ -83,13 +93,11 @@ class BranchController {
     const ui = this.ui;
     if (!ui.commits.canCommit()) return;
     const entry = this.selected();
-    if (!entry) return;
-    if (entry.current) return void ui.showFiles();
+    if (!entry || entry.current) return;
     const name = entry.name;
-    const after = (extra) => ui.refreshFromRepo({ keepEmpty: true, ...extra });
-    const leave = () => ui.showFiles();
+    const after = (extra) => this.refreshAfterWrite(extra);
     const done = `checked out ${name}`;
-    ui.ops.runWrite('checkout', [name], 'checking out', done, after, leave);
+    ui.ops.runWrite('checkout', [name], 'checking out', done, after);
   }
 
   finishCreateBranch() {
@@ -161,25 +169,9 @@ class BranchController {
     if (!ui.commits.canCommit()) return;
     const done = force ? 'force pushed' : 'pushed';
     const kind = force ? 'force pushing' : 'pushing';
-    const picked = pickRepoWrite(ui.repo, 'push', ui.uiOpen);
-    if (picked.async) {
-      const write = (top) => picked.write(top, force);
-      const after = () => this.refreshAfterWrite();
-      return void ui.ops.runBusy(kind, done, write, after);
-    }
-    try {
-      ui.repo.push(ui.top, force);
-    } catch (error) {
-      if (error.rejected && !force) {
-        ui.mode = 'confirmPush';
-        ui.status = '';
-        return;
-      }
-      ui.status = error.message;
-      return;
-    }
-    this.refreshAfterWrite();
-    ui.status = done;
+    const write = (top) => ui.repo.push(top, force);
+    const after = () => this.refreshAfterWrite({ doneStatus: done });
+    ui.ops.runBusy(kind, done, write, after);
   }
 
   onPush() {

package/lib/session/change-actions.js

@@ -2,13 +2,12 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { withNewline } = require('../common/utilities.js');
 
-const files = require('../files.js');
+const files = require('../common/files.js');
 const { listPath, isTaskItem, isTasksEntry, isReadOnlyOrigin } = files;
-const items = require('./items.js');
-const { needsReload, npmBusyKind, sameBlock } = items;
-const diff = require('../diff/diff.js');
-const { hunkKey } = diff;
+const { needsReload, npmBusyKind, sameBlock } = require('./items.js');
+const { hunkKey } = require('../diff/diff.js');
 
 const nextUnstageOrigin = (item) =>
   item.file.isNew === true ? 'untracked' : 'unstaged';
@@ -39,7 +38,7 @@ const appendIgnoreFile = (top, name, pattern) => {
   const text = exists ? fs.readFileSync(abs, 'utf8') : '';
   const lines = text.split('\n');
   if (lines.some((line) => line.trim() === pattern)) return false;
-  const base = text && !text.endsWith('\n') ? `${text}\n` : text;
+  const base = withNewline(text);
   fs.writeFileSync(abs, `${base}${pattern}\n`);
   return true;
 };
@@ -116,26 +115,17 @@ const selectNextFileAfter = (ui, rel) => {
   nav.index = entry.firstIndex;
 };
 
-const liveItem = (ui, item) =>
-  ui.items.find((entry) => sameBlock(entry, item)) ?? item;
-
-const applyGit = (ui, label, write, after) => {
-  try {
-    write(ui.top);
-    ui.status = label;
-    after();
-  } catch (error) {
-    ui.status = error.message;
-  }
+const liveItem = (ui, item) => {
+  const match = (entry) => sameBlock(entry, item);
+  return ui.items.find(match) ?? item;
 };
 
-const applyFileGit = (ui, targets, label, write, afterItem = () => {}) => {
+const applyFileGit = async (ui, targets, label, write) => {
   let written = 0;
   try {
     for (const target of targets) {
-      const current = liveItem(ui, target);
-      write(ui.top, current);
-      afterItem(current);
+      const item = liveItem(ui, target);
+      await ui.ops.exclusive((top) => write(top, item));
       written++;
     }
     ui.status = label;
@@ -146,12 +136,6 @@ const applyFileGit = (ui, targets, label, write, afterItem = () => {}) => {
   }
 };
 
-const reconcilePartial = (ui, result) => {
-  if (result.ok) return false;
-  if (result.written) ui.reloadAfterChange();
-  return true;
-};
-
 const enqueueOrigins = (ui, targets, spec) => {
   const writes = targets.map((target) => {
     const item = liveItem(ui, target);
@@ -164,36 +148,31 @@ const enqueueOrigins = (ui, targets, spec) => {
     kind: spec.busy || spec.done,
     done: spec.done,
     reload: spec.reload === true,
-    write: async (top) => {
-      for (const item of writes) await spec.write(top, item);
+    write: async () => {
+      for (const item of writes) await spec.write(item);
     },
   });
 };
 
 const stageLazy = (ui, targets, extra = {}) => {
   const busy = extra.busy || '';
-  const repo = ui.repo;
   enqueueOrigins(ui, targets, {
     done: 'staged',
     busy,
     reload: extra.reload === true,
     originOf: () => 'staged',
     afterUi: extra.afterUi,
-    write: (top, item) => {
-      if (busy && repo.addAsync) return repo.addAsync(top, item);
-      return repo.add(top, item);
-    },
+    write: (item) => ui.ops.add(item),
   });
 };
 
 const unstageLazy = (ui, targets, extra = {}) => {
-  const repo = ui.repo;
   enqueueOrigins(ui, targets, {
     done: 'unstaged',
     busy: '',
     originOf: nextUnstageOrigin,
     afterUi: extra.afterUi,
-    write: (top, item) => repo.unstage(top, item),
+    write: (item) => ui.ops.unstage(item),
   });
 };
 
@@ -205,41 +184,18 @@ const dismissReloadable = (ui, targets) => {
 
 const onBlockAdd = (ui, item) => {
   const reload = needsReload(item);
-  if (ui.uiOpen) {
-    return void stageLazy(ui, [item], { busy: npmBusyKind(item), reload });
-  }
-  applyGit(
-    ui,
-    'staged',
-    (top) => ui.repo.add(top, item),
-    () => {
-      if (reload) ui.reloadAfterChange();
-      else keepOrigin(ui, item, 'staged');
-    },
-  );
+  stageLazy(ui, [item], { busy: npmBusyKind(item), reload });
 };
 
-const onBlockUnstage = (ui, item) => {
-  if (ui.uiOpen) return void unstageLazy(ui, [item]);
-  const origin = nextUnstageOrigin(item);
-  applyGit(
-    ui,
-    'unstaged',
-    (top) => ui.repo.unstage(top, item),
-    () => keepOrigin(ui, item, origin),
-  );
-};
+const onBlockUnstage = (ui, item) => unstageLazy(ui, [item]);
 
 const onBlockRevert = (ui, item) => {
-  applyGit(
-    ui,
-    'dropped',
-    (top) => ui.repo.revert(top, item),
-    () => {
-      dismissReloadable(ui, [item]);
-      ui.reloadAfterChange();
-    },
-  );
+  const write = (top) => ui.repo.revert(top, item);
+  const after = () => {
+    dismissReloadable(ui, [item]);
+    ui.reloadAfterChange();
+  };
+  ui.ops.track(ui.ops.apply('dropped', write, after));
 };
 
 const BLOCK = {
@@ -263,48 +219,26 @@ const onBlockCommand = (ui, name) => {
 const stageTargets = (ui, targets, after = null) => {
   const reload = targets.some(needsReload);
   const busy = targets.map(npmBusyKind).find((kind) => kind) || '';
-  if (ui.uiOpen) {
-    return void stageLazy(ui, targets, { busy, reload, afterUi: after });
-  }
-  const keepStaged = (entry) => keepOrigin(ui, entry, 'staged');
-  const result = applyFileGit(ui, targets, 'staged', ui.repo.add, keepStaged);
-  if (reconcilePartial(ui, result)) return;
-  if (reload) ui.reloadAfterChange();
-  if (after) after();
+  stageLazy(ui, targets, { busy, reload, afterUi: after });
 };
 
-const unstageTargets = (ui, targets, after = null) => {
-  if (ui.uiOpen) return void unstageLazy(ui, targets, { afterUi: after });
-  const keepUnstaged = (entry) =>
-    keepOrigin(ui, entry, nextUnstageOrigin(entry));
-  const result = applyFileGit(
-    ui,
-    targets,
-    'unstaged',
-    ui.repo.unstage,
-    keepUnstaged,
-  );
-  if (reconcilePartial(ui, result)) return;
-  if (after) after();
-};
+const unstageTargets = (ui, targets, after = null) =>
+  unstageLazy(ui, targets, { afterUi: after });
 
 const revertTargets = (ui, targets) => {
   dismissReloadable(ui, targets);
-  const result = applyFileGit(ui, targets, 'dropped', ui.repo.revert);
-  if (!result.ok && !result.written) return;
-  ui.reloadAfterChange();
+  const write = (top, item) => ui.repo.revert(top, item);
+  const done = (result) => {
+    if (result.ok || result.written) ui.reloadAfterChange();
+  };
+  ui.ops.track(applyFileGit(ui, targets, 'dropped', write).then(done));
 };
 
 const revertFile = (ui, rel, selected, after) => {
   dismissReloadable(ui, selected);
-  try {
-    ui.repo.revertFile(ui.top, rel, selected);
-    ui.status = 'dropped';
-  } catch (error) {
-    ui.status = error.message;
-    return void ui.reloadAfterChange();
-  }
-  ui.reloadAfterChange(after);
+  const write = (top) => ui.repo.revertFile(top, rel, selected);
+  const done = (ok) => ui.reloadAfterChange(ok ? after : undefined);
+  ui.ops.track(ui.ops.apply('dropped', write).then(done));
 };
 
 const TARGETS = {