reslop 0.3.1 → 0.3.3

package/lib/session/agents/away.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { saveRunFiles } = require('./jobs.js');
+
+const isRunning = (job) => job.status === 'running';
+
+// Runs that go on in a worktree which is not shown. Each list is saved in
+// the logs of its own directory and is taken back when that one is shown
+class AwayRuns {
+  constructor() {
+    this.lists = new Map();
+  }
+
+  park(root, jobs) {
+    if (root && jobs.some(isRunning)) this.lists.set(root, jobs);
+  }
+
+  take(root) {
+    const jobs = this.lists.get(root);
+    this.lists.delete(root);
+    return jobs;
+  }
+
+  jobs() {
+    return [...this.lists.values()].flat();
+  }
+
+  save() {
+    for (const [root, jobs] of this.lists) {
+      saveRunFiles(root, jobs);
+      if (!jobs.some(isRunning)) this.lists.delete(root);
+    }
+  }
+
+  // The count of runs in work by directory, with the list that is shown
+  counts(root, jobs) {
+    const lists = [...this.lists.entries()];
+    if (root) lists.push([root, jobs]);
+    const live = new Map();
+    for (const [dir, list] of lists) {
+      const count = list.filter(isRunning).length;
+      if (count) live.set(dir, count);
+    }
+    return live;
+  }
+}
+
+module.exports = { AwayRuns };

package/lib/session/agents/job.js

@@ -4,33 +4,12 @@ const path = require('node:path');
 const { isHashObject } = require('metautil');
 const { pad2, withNotice, readText } = require('../../common/utilities.js');
 const { LOG_DIR } = require('../../common/files.js');
-const { agentSpec } = require('../../agents/agents.js');
+const { choiceOf } = require('../../agents/models.js');
 
 const RUN_KEEP = 40;
 
 const OUTPUT_KEEP = 100000;
 
-const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
-
-const SESSION_FLAG = '--(?:resume|conversation)';
-
-const SESSION_MARK = new RegExp(`${SESSION_FLAG}[= ](${UUID})`, 'gi');
-
-const FILES_MARK = /(\d[\d,]*)\s+files?\s+(?:edited|changed|modified)/gi;
-
-const tokenPattern = (name) => {
-  const word = `${name}[_ -]?tokens?`;
-  const json = `"${name}_tokens"`;
-  const body = `(?:${word}|${json})\\s*[:=]\\s*"?(\\d[\\d,]*)`;
-  return new RegExp(body, 'gi');
-};
-
-const TOTAL_TOKEN = tokenPattern('total');
-
-const INPUT_TOKEN = tokenPattern('input');
-
-const OUTPUT_TOKEN = tokenPattern('output');
-
 const exitLabel = (status) => {
   if (status === null || status === undefined || status === '') {
     return 'stopped';
@@ -70,43 +49,6 @@ const countField = (value) => {
   return countOf(value);
 };
 
-const lastCount = (text, re) => {
-  re.lastIndex = 0;
-  let found = null;
-  for (const match of `${text ?? ''}`.matchAll(re)) {
-    const count = countOf(match[1]);
-    if (count !== null) found = count;
-  }
-  return found;
-};
-
-const sessionOf = (text) => {
-  SESSION_MARK.lastIndex = 0;
-  let found = '';
-  for (const match of `${text ?? ''}`.matchAll(SESSION_MARK)) found = match[1];
-  return found;
-};
-
-const tokensOf = (text) => {
-  const total = lastCount(text, TOTAL_TOKEN);
-  if (total !== null) return total;
-  const input = lastCount(text, INPUT_TOKEN);
-  const output = lastCount(text, OUTPUT_TOKEN);
-  if (input === null && output === null) return null;
-  return (input ?? 0) + (output ?? 0);
-};
-
-const runStats = (text) => {
-  const stats = {};
-  const session = sessionOf(text);
-  const files = lastCount(text, FILES_MARK);
-  const tokens = tokensOf(text);
-  if (session) stats.session = session;
-  if (files !== null) stats.files = files;
-  if (tokens !== null) stats.tokens = tokens;
-  return stats;
-};
-
 const restoredState = (item) => {
   if (item.running === true || item.status === 'running') {
     return { status: 'running', exit: null };
@@ -139,24 +81,17 @@ const applyElapsed = (job, item) => {
 const readLog = (root, name) =>
   root && name ? readText(path.join(root, LOG_DIR, name)) : '';
 
-// An agent with a denial mark exits 0 having done nothing: silent or refused
-const fruitless = (job, text) => {
-  if (job.action !== 'run') return false;
-  const spec = agentSpec(job.cliId);
-  if (!spec || !spec.denied) return false;
-  return !text.trim() || spec.denied.test(text);
-};
-
 class AgentJob {
   constructor(fields) {
     this.id = fields.id;
     this.cliId = fields.cliId;
     this.name = fields.name;
     this.model = fields.model;
-    this.cmd = fields.cmd;
-    this.args = fields.args;
+    this.choice = choiceOf(fields.choice ?? { model: fields.model });
+    this.resume = textOf(fields.resume);
     this.command = fields.command;
     this.plan = fields.plan;
+    this.title = textOf(fields.title);
     this.action = fields.action;
     this.status = fields.status;
     this.exit = fields.exit;
@@ -182,10 +117,11 @@ class AgentJob {
       cliId: launch.id,
       name: launch.name,
       model,
-      cmd: launch.cmd,
-      args: launch.args,
+      choice: launch.choice,
+      resume: launch.session,
       command: launch.command,
       plan: launch.plan,
+      title: textOf(launch.title),
       action: launch.kind,
       status: 'running',
       exit: null,
@@ -205,10 +141,11 @@ class AgentJob {
       cliId: textOf(item.cliId),
       name: textOf(item.name),
       model: textOf(item.model),
-      cmd: textOf(item.cmd),
-      args: Array.isArray(item.args) ? item.args : [],
+      choice: item.choice,
+      resume: item.resume,
       command: textOf(item.command),
       plan: textOf(item.plan),
+      title: textOf(item.title),
       action: textOf(item.action, 'run'),
       status: state.status,
       exit: state.exit,
@@ -235,8 +172,12 @@ class AgentJob {
     return elapsedLabel(this, now);
   }
 
-  captureStats() {
-    const stats = runStats(this.output);
+  // The session is known as soon as it opens, long before the run ends
+  captureStats(given) {
+    const { child } = this;
+    const live = child && typeof child.stats === 'function';
+    const stats = given ?? (live ? child.stats() : null);
+    if (!stats) return;
     if (stats.session) this.session = stats.session;
     if (typeof stats.files === 'number') this.files = stats.files;
     if (typeof stats.tokens === 'number') this.tokens = stats.tokens;
@@ -254,8 +195,7 @@ class AgentJob {
       cliId: this.cliId,
       name: this.name,
       model: this.model,
-      cmd: this.cmd,
-      args: this.args,
+      choice: this.choice,
       command: this.command,
       plan: this.plan,
       action: this.action,
@@ -263,8 +203,10 @@ class AgentJob {
       elapsed: elapsedSeconds(this),
       startedAt: this.startedAt,
     };
+    if (this.title) saved.title = this.title;
     if (this.logName) saved.log = this.logName;
     if (this.rawName) saved.raw = this.rawName;
+    if (this.resume) saved.resume = this.resume;
     if (this.session) saved.session = this.session;
     if (typeof this.files === 'number') saved.files = this.files;
     return saved;
@@ -284,13 +226,8 @@ class AgentJob {
   }
 
   finish(result) {
-    let text = result.text ?? '';
-    let { status } = result;
-    if (status === 0 && fruitless(this, text)) {
-      status = 1;
-      if (!text.trim()) text = withNotice(text, 'Agent exited without output');
-    }
-    this.close(exitLabel(status), status, text);
+    this.captureStats(result.stats);
+    this.close(exitLabel(result.status), result.status, result.text ?? '');
   }
 }
 
@@ -300,7 +237,8 @@ const restoreJobs = (saved) => {
   const jobs = [];
   let nextId = 1;
   for (const item of Array.isArray(saved) ? saved : []) {
-    if (!isHashObject(item)) continue;
+    // Signing in was a run of its own before agents were reached over ACP
+    if (!isHashObject(item) || item.action === 'login') continue;
     const job = AgentJob.restore(item, nextId);
     nextId = Math.max(nextId, job.id + 1);
     jobs.push(job);
@@ -313,7 +251,6 @@ module.exports = {
   OUTPUT_KEEP,
   elapsedLabel,
   textOf,
-  runStats,
   readLog,
   launchJob,
   restoreJobs,

package/lib/session/agents/jobs.js

@@ -8,7 +8,6 @@ const { logText, nextLogFile } = require('../../runs/logs.js');
 const jobPart = require('./job.js');
 const { OUTPUT_KEEP, readLog, textOf } = jobPart;
 const { elapsedLabel, RUN_KEEP, restoreJobs, launchJob } = jobPart;
-const { runStats } = jobPart;
 const prefsPart = require('../prefs.js');
 const { planPath, readPrefs, writePrefs } = prefsPart;
 const { writeStored } = prefsPart;
@@ -104,19 +103,6 @@ const runBlock = (root, job) => {
   return `${stem}\n${body}`;
 };
 
-const replayLaunch = (job) => ({
-  ok: true,
-  cmd: job.cmd,
-  args: job.args.slice(),
-  prompt: '',
-  plan: job.plan,
-  id: job.cliId,
-  name: job.name,
-  kind: job.action || 'run',
-  command: job.command,
-  session: job.session,
-});
-
 const pruneAgent = (root, jobs) => {
   const keep = new Set();
   for (const job of jobs) {
@@ -174,10 +160,12 @@ const sessionEntry = (prev, job) => {
   const prior = isHashObject(prev) ? prev : {};
   const entry = { cli: job.cliId || prior.cli || '' };
   const name = stemOf(job.logName) || prior.name || '';
+  const title = textOf(job.title) || textOf(prior.title);
   const startedAt = Number(job.startedAt) || Number(prior.startedAt) || 0;
   const files = typeof job.files === 'number' ? job.files : prior.files;
   const tokens = typeof job.tokens === 'number' ? job.tokens : prior.tokens;
   if (name) entry.name = name;
+  if (title) entry.title = title;
   if (startedAt) entry.startedAt = startedAt;
   if (typeof files === 'number') entry.files = files;
   if (typeof tokens === 'number') entry.tokens = tokens;
@@ -194,15 +182,17 @@ const replacedStems = (jobs) => {
   return stems;
 };
 
-const rememberSession = (rows, id, stem, at) => {
-  const blank = { id, name: '', startedAt: 0 };
+const rememberSession = (rows, id, stem, at, title) => {
+  const blank = { id, name: '', title: '', startedAt: 0 };
   const prev = rows.get(id) || blank;
   if (at >= prev.startedAt) {
     prev.startedAt = at;
     if (stem) prev.name = stem;
+    if (title) prev.title = title;
   } else if (!prev.name && stem) {
     prev.name = stem;
   }
+  if (!prev.title && title) prev.title = title;
   rows.set(id, prev);
 };
 
@@ -214,16 +204,17 @@ const listSessions = (root, jobs, cliId) => {
     if (hidden.has(id)) continue;
     if (!isHashObject(entry) || entry.cli !== cliId) continue;
     const name = textOf(entry.name);
+    const title = textOf(entry.title);
     const startedAt = Number(entry.startedAt) || 0;
-    rows.set(id, { id, name, startedAt });
+    rows.set(id, { id, name, title, startedAt });
   }
   for (const job of jobs) {
-    if (job.cliId !== cliId || job.action === 'login') continue;
+    if (job.cliId !== cliId) continue;
     const id = sessionKey(job);
     if (!id) continue;
     const stem = stemOf(job.logName);
     const at = Number(job.startedAt) || 0;
-    rememberSession(rows, id, stem, at);
+    rememberSession(rows, id, stem, at, textOf(job.title));
   }
   const list = [...rows.values()];
   list.sort((left, right) => {
@@ -240,7 +231,7 @@ const panelSessions = (root, jobs, cliId) => {
   for (const session of found) {
     rows.push({
       id: session.id,
-      name: session.name || session.id,
+      name: session.title || session.name || session.id,
       session: true,
     });
   }
@@ -251,7 +242,6 @@ const runningJobs = (jobs, cliId) => {
   const runs = [];
   for (const job of jobs) {
     if (job.cliId !== cliId || job.status !== 'running') continue;
-    if (job.action === 'login') continue;
     runs.push(job);
   }
   return runs;
@@ -260,15 +250,15 @@ const runningJobs = (jobs, cliId) => {
 const liveRun = (job, progress) => {
   const stem = stemOf(job.logName);
   const id = sessionKey(job);
-  const command = stem || job.command || job.name;
+  const caption = job.title || stem || job.command || job.name;
   return {
     id,
     jobId: job.id,
-    name: command,
+    name: caption,
     status: job.status,
     elapsed: elapsedLabel(job),
     progress,
-    command,
+    command: caption,
   };
 };
 
@@ -295,7 +285,6 @@ const withLiveRuns = (saved, running, progressOf) => {
 const mergeSessions = (saved, jobs) => {
   const sessions = { ...saved };
   for (const job of jobs) {
-    if (job.action === 'login') continue;
     const stem = stemOf(job.logName);
     const id = textOf(job.session);
     const done = job.status !== 'running';
@@ -341,12 +330,10 @@ module.exports = {
   elapsedLabel,
   launchJob,
   restoreJobs,
-  runStats,
   assignLog,
   stemOf,
   orderedSessions,
   runBlock,
-  replayLaunch,
   panelSessions,
   runningJobs,
   withLiveRuns,

package/lib/session/agents/options.js

@@ -4,92 +4,57 @@ const { isHashObject } = require('metautil');
 const { trimText } = require('../../common/utilities.js');
 
 const models = require('../../agents/models.js');
-const { catalogOf, fitEffort, withoutFast, contextMenu } = models;
+const { catalogOf, fitEffort, concrete } = 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)];
-};
+const STORED_FIELDS = ['model', 'effort', 'context'];
 
+// The choices one agent row offers, from what its session lists
 class AgentOptions {
   constructor(row) {
     this.row = row;
-    this.catalog = catalogOf(row.models);
-    this.names = menuNames(this.catalog);
+    this.catalog = catalogOf(row.catalog);
+    this.names = this.catalog.names;
   }
 
+  // A saved model stays as it is until the agent has listed its own
   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;
+    const saved = trimText(model);
+    if (!this.catalog.loaded || this.catalog.find(saved)) return saved;
+    return this.catalog.current || this.names[0] || '';
   }
 
   efforts(model) {
-    return this.levels(model).filter((level) => concrete(level));
+    return this.catalog.efforts(this.shown(model));
   }
 
   contexts(model) {
-    return contextMenu(
-      model,
-      this.row.wide,
-      this.catalog,
-      this.row.spec.contexts,
-    );
+    return this.catalog.contexts(this.shown(model));
   }
 
-  hasFast(model) {
-    const base = withoutFast(concrete(model));
-    return Boolean(base) && this.catalog.find(`${base}-fast`) !== null;
+  fasts(model) {
+    return this.catalog.fasts(this.shown(model));
   }
 
-  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] || '';
+  // Before the agent has listed anything the saved choice is all there is
+  settings(picked) {
+    if (this.catalog.loaded) {
+      return this.catalog.resolve(this.shown(picked.model), picked);
+    }
+    return {
+      effort: concrete(picked.effort),
+      context: trimText(picked.context),
+      fast: picked.fast === true ? 'on' : 'off',
+    };
   }
 
-  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;
+  align(picked) {
+    if (!this.catalog.loaded) return;
+    picked.effort = fitEffort(this.efforts(picked.model), picked.effort);
   }
 
-  normalize(picked, model = '') {
-    picked.model = this.catalog.resolve(picked).family;
-    return this.align(picked, model || this.shown(picked.model));
+  normalize(picked) {
+    this.align(picked);
+    return this.shown(picked.model);
   }
 
   preferEffort(picked, level) {
@@ -99,55 +64,34 @@ class AgentOptions {
 
   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;
+    this.align(picked);
   }
 
   toggleFast(picked) {
+    if (this.fasts(picked.model).length < 2) return false;
     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));
+    return true;
   }
 }
 
-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 storedChoice = (picked) => {
   const fields = [
-    ['model', concrete(picked.model)],
+    ['model', trimText(picked.model)],
     ['effort', concrete(picked.effort)],
-    ['extra', spec.savesExtra ? concrete(picked.extra) : ''],
     ['fast', picked.fast === true],
-    ['context', concrete(picked.context)],
+    ['context', trimText(picked.context)],
   ];
   const stored = Object.fromEntries(fields.filter((field) => field[1]));
   return Object.keys(stored).length ? stored : null;
 };
 
-module.exports = { AgentOptions, concrete, restoreChoice, storedChoice };
+const restoreChoice = (picked, saved) => {
+  if (!isHashObject(saved)) return;
+  const stored = storedChoice(saved) ?? {};
+  for (const field of STORED_FIELDS) {
+    if (stored[field]) picked[field] = stored[field];
+  }
+  if (stored.fast) picked.fast = true;
+};
+
+module.exports = { AgentOptions, restoreChoice, storedChoice };

package/lib/session/agents/plans.js

@@ -8,6 +8,57 @@ const review = require('../../review/review.js');
 const { parseReview, reviewProgress, frontmatterStatus } = review;
 const { trimText } = require('../../common/utilities.js');
 
+const FRONTMATTER = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/;
+
+const HEADING = /^#{1,3}\s+(.+)$/;
+
+const TASK = /^- \[[ xX]\]\s+(.+)$/;
+
+const DATE_TOKEN = /\d{4}-\d{2}-\d{2}(?:-\d+)?/;
+
+const ITEM_PREFIX = /^F\d+:\s*/;
+
+const CAPTION_MAX = 72;
+
+const clipCaption = (text) => {
+  const line = text.replace(/\s+/g, ' ').trim();
+  if (line.length <= CAPTION_MAX) return line;
+  return `${line.slice(0, CAPTION_MAX - 1)}…`;
+};
+
+const captionFromPlan = (text) => {
+  const body = `${text ?? ''}`.replace(FRONTMATTER, '');
+  let heading = '';
+  let task = '';
+  for (const raw of body.split('\n')) {
+    const line = raw.trim();
+    if (!heading) {
+      const head = HEADING.exec(line);
+      if (head) heading = head[1].trim();
+    }
+    if (!task) {
+      const item = TASK.exec(line);
+      if (item) task = item[1].replace(ITEM_PREFIX, '').trim();
+    }
+    if (heading && task) break;
+  }
+  if (heading && !DATE_TOKEN.test(heading)) return clipCaption(heading);
+  if (task) return clipCaption(task);
+  return '';
+};
+
+const planCaption = (root, plan) => {
+  const rel = `${plan ?? ''}`.trim();
+  if (!rel || !root) return '';
+  const file = path.isAbsolute(rel) ? rel : path.join(root, rel);
+  try {
+    return captionFromPlan(fs.readFileSync(file, 'utf8'));
+  } catch {
+    // missing plan
+    return '';
+  }
+};
+
 const planKey = (value) => {
   const text = trimText(value);
   if (!text) return '';
@@ -75,6 +126,8 @@ const alignPlanLabels = (parts) => {
 };
 
 module.exports = {
+  captionFromPlan,
+  planCaption,
   planKey,
   planProgress,
   planPart,

package/lib/session/agents/view.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const NO_PICK = {
+  agentPick: '',
+  agentMenu: null,
+  agentQuery: '',
+  agentEditor: null,
+  agentMenuOff: [],
+  agentPickCursor: 0,
+  agentMenuScroll: 0,
+};
+
+const NO_LIST = {
+  agents: null,
+  agentInstallPackage: '',
+  agentRuns: [],
+  agentRunCursor: 0,
+  agentRunScroll: 0,
+  agentFocus: 'cli',
+  agentCanStart: false,
+  agentPlanCount: 0,
+  agentView: false,
+};
+
+const NO_JOB = {
+  agentOutput: '',
+  agentCommand: '',
+  agentElapsed: '',
+  agentProgress: '',
+  agentRunning: false,
+  agentStatus: '',
+};
+
+module.exports = { NO_PICK, NO_LIST, NO_JOB };