ai-agentmanager 1.14.0 → 1.16.0

package/src/repeats.js

@@ -0,0 +1,155 @@
+// Requests you keep making: the asks you type (new agents and backlog items, not ones a playbook,
+// trigger or the assistant started) are remembered, the last 500 in ~/.agentmanager/asks.json. When
+// 3 or more read alike (the same words once numbers, quoted names, URLs, issue keys and filler are
+// set aside), the inbox offers to save them as a playbook: the words they share become the request,
+// the part that changes a {{what}} placeholder, and the projects they ran in its projects.
+import crypto from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { paths } from './config.js';
+
+export const SUGGEST_AFTER = 3;
+const KEEP = 500;
+const ALIKE = 0.5; // share of distinct words two asks must have in common
+const STOP = new Set('a an and are as at be by do does for from get have in into is it its make me my of on or our please should so that the their them then this to up use we with you your'.split(' '));
+const err = (status, message) => Object.assign(new Error(message), { status });
+
+/** The words that say what an ask is about, without the parts that change from one to the next. */
+export function words(text) {
+  const w = String(text ?? '')
+    .toLowerCase()
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/(^|\s)["'`“‘][^"'`”’\n]{1,80}["'`”’](?=[\s.,;:!?)]|$)/g, ' ')
+    .replace(/\b[a-z][a-z0-9]+-\d+\b/g, ' ')
+    .replace(/#\d+|\b\d[\w.]*/g, ' ')
+    .split(/[^a-z0-9_]+/)
+    .filter((x) => x.length > 1 && !STOP.has(x));
+  return [...new Set(w)];
+}
+
+export function alike(a, b) {
+  if (!a.length || !b.length) return 0;
+  const sb = new Set(b);
+  const both = a.filter((x) => sb.has(x)).length;
+  return both / (a.length + b.length - both);
+}
+
+/** Groups of asks that read alike, newest first; each group's seed is its newest ask. */
+export function groups(asks, { threshold = ALIKE } = {}) {
+  const out = [];
+  // Newest first; asks recorded together keep their order.
+  const order = asks.map((a, i) => [a, i]).sort(([x, i], [y, j]) => y.at.localeCompare(x.at) || j - i);
+  for (const [ask] of order) {
+    const w = words(ask.text);
+    if (w.length < 2) continue;
+    const g = out.find((x) => alike(x.words, w) >= threshold);
+    if (g) g.asks.push(ask);
+    else out.push({ words: w, asks: [ask] });
+  }
+  return out;
+}
+
+/**
+ * A playbook request from asks that read alike: the words they all start and end with, around a
+ * {{what}} for the part that differs ("Upgrade react to the latest" / "Upgrade vite to the latest" →
+ * "Upgrade {{what}} to the latest"). When they share too little, the newest ask as it was written.
+ */
+export function template(texts) {
+  const split = texts.map((t) => String(t).trim().split(/\s+/));
+  if (texts.every((t) => t.trim() === texts[0].trim())) return texts[0].trim();
+  const shortest = Math.min(...split.map((s) => s.length));
+  const same = (get) => split.every((s) => get(s) === get(split[0]));
+  let pre = 0;
+  while (pre < shortest && same((s) => s[pre].toLowerCase())) pre++;
+  let suf = 0;
+  while (suf < shortest - pre && same((s) => s[s.length - 1 - suf].toLowerCase())) suf++;
+  if (pre + suf < Math.max(2, Math.ceil(shortest / 2))) return texts[0].trim();
+  const head = split[0].slice(0, pre).join(' ');
+  const tail = split[0].slice(split[0].length - suf).join(' ');
+  return [head, '{{what}}', tail].filter(Boolean).join(' ');
+}
+
+/** A short name for the playbook, from its request. */
+export function nameFor(intent) {
+  const plain = intent.replace(/\{\{\w+\}\}/g, ' ').replace(/\s+/g, ' ').trim();
+  const w = plain.split(' ').slice(0, 6);
+  while (w.length > 1 && STOP.has(w[w.length - 1].toLowerCase())) w.pop();
+  const name = w.join(' ');
+  return (name.charAt(0).toUpperCase() + name.slice(1)).replace(/[.,:;]+$/, '').slice(0, 60) || 'Repeated request';
+}
+
+export class Repeats extends EventEmitter {
+  constructor({ file = path.join(paths.home, 'asks.json'), suggestAfter = SUGGEST_AFTER, enabled = true, playbooks = () => [], projects = () => ({}) } = {}) {
+    super();
+    Object.assign(this, { file, suggestAfter, enabled, playbooks, projects });
+    try {
+      this.data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      this.data = {};
+    }
+    this.data.asks ??= [];
+    this.data.dismissed ??= [];
+  }
+
+  save() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    this.changed();
+  }
+
+  changed() {
+    this.emit('change', this.view());
+  }
+
+  /** Asks the person typed: [{ text, projectKey }]. */
+  record(asks) {
+    const at = new Date().toISOString();
+    const list = asks.map((a) => ({ text: String(a.text ?? '').trim().slice(0, 2000), projectKey: a.projectKey ?? null, at })).filter((a) => a.text);
+    if (!list.length) return;
+    this.data.asks = [...this.data.asks, ...list].slice(-KEEP);
+    this.save();
+  }
+
+  /** Requests asked for at least suggestAfter times, not already a playbook and not dismissed. */
+  suggestions() {
+    if (!this.enabled) return [];
+    const books = this.playbooks().map((p) => words(p.intent));
+    const projects = this.projects();
+    const out = [];
+    for (const g of groups(this.data.asks)) {
+      if (g.asks.length < this.suggestAfter) continue;
+      if (books.some((b) => alike(b, g.words) >= ALIKE)) continue;
+      if (this.data.dismissed.some((d) => alike(d, g.words) >= ALIKE)) continue;
+      const intent = template(g.asks.map((a) => a.text));
+      const names = [...new Set(g.asks.map((a) => projects[a.projectKey]).filter(Boolean))];
+      out.push({
+        key: crypto.createHash('sha1').update([...g.words].sort().join(' ')).digest('hex').slice(0, 12),
+        name: nameFor(intent),
+        intent,
+        projects: names,
+        count: g.asks.length,
+        examples: [...new Set(g.asks.map((a) => a.text))].slice(0, 3),
+        lastAt: g.asks[0].at,
+      });
+    }
+    return out;
+  }
+
+  /** "Not now": stop offering this one (asks like it keep counting, but it isn't offered again). */
+  dismiss(key) {
+    const g = groups(this.data.asks).find((x) => crypto.createHash('sha1').update([...x.words].sort().join(' ')).digest('hex').slice(0, 12) === key);
+    if (!g) throw err(404, 'No such suggestion');
+    this.data.dismissed = [...this.data.dismissed, g.words].slice(-100);
+    this.save();
+    return this.view();
+  }
+
+  view() {
+    return { suggestions: this.suggestions(), suggestAfter: this.suggestAfter };
+  }
+
+  inbox() {
+    return this.suggestions().map((s) => ({ ...s, kind: 'repeat', key: `repeat:${s.key}`, title: `Save "${s.name}" as a playbook?`, priority: 3 }));
+  }
+}

package/src/review.js

@@ -9,6 +9,18 @@ import { ghBin } from './tracker.js';
 const err = (status, message) => Object.assign(new Error(message), { status });
 const MAX_COMMENTS = 100;
 
+/** A git command that writes the index, retried while another git process (the app's own status refresh) holds its lock. */
+async function locked(args, opts, tries = 5) {
+  for (let i = 1; ; i++) {
+    try {
+      return await git.run('git', args, opts);
+    } catch (e) {
+      if (i >= tries || !/index\.lock|another git process/i.test(e.message)) throw e;
+      await new Promise((r) => setTimeout(r, 300 * i));
+    }
+  }
+}
+
 /** "origin/main @ 1a2b3c4d5" -> { ref: 'origin/main', sha: '1a2b3c4d5' } */
 export function parseBaseRef(baseRef) {
   const m = /^(.*) @ ([0-9a-f]{4,40})$/.exec(baseRef ?? '');
@@ -190,8 +202,8 @@ export class Review {
     const opts = { cwd: agent.workdir, timeout: 60_000 };
     const status = await git.run('git', ['status', '--porcelain'], opts);
     if (!status.trim()) throw err(409, 'Nothing to commit');
-    await git.run('git', ['add', '-A'], opts);
-    await git.run('git', ['commit', '-m', message], opts);
+    await locked(['add', '-A'], opts);
+    await locked(['commit', '-m', message], opts);
     const sha = await git.run('git', ['rev-parse', '--short', 'HEAD'], opts);
     this.manager.plugins.emit('agent.commit', { agent: this.manager.auditView(agent), message, sha });
     this.manager.refresh(agent.id).catch(() => {});

package/src/scorecard.js

@@ -156,6 +156,29 @@ export function combine(reply, f, hunks) {
 }
 
 export const RECOMMENDATION = { ready: 'Ready to approve', look: 'Look at these first', not_ready: 'Not ready' };
+const IMPROVE_BELOW = 80; // scores under this are named in the Improve message
+
+/**
+ * Improve: the agent's own scorecard sent back to it before a person reviews the work. The scores
+ * to raise (lowest first, with why), the acceptance criteria not met or not verified, and where a
+ * reviewer would look.
+ */
+export function improveMessage(sc) {
+  const weak = DIMENSIONS.filter(([k]) => sc.scores[k] && sc.scores[k].score < IMPROVE_BELOW)
+    .sort(([a], [b]) => sc.scores[a].score - sc.scores[b].score)
+    .map(([k, label]) => `- ${label} ${sc.scores[k].score}/100: ${[sc.scores[k].why, ...sc.scores[k].notes].filter(Boolean).join('; ')}`);
+  const criteria = sc.criteria.filter((c) => c.status !== 'met').map((c) => `- ${c.status === 'not_met' ? 'Not met' : 'Not verified'}: ${c.criterion}${c.evidence ? ` (${c.evidence})` : ''}`);
+  const look = sc.look.map((l) => `- ${l.file}: ${l.reason}`);
+  return [
+    `Before this goes to review: the review scorecard rates your changes ${sc.overall ?? '?'}/100 (${RECOMMENDATION[sc.recommendation]}${sc.reasons.length ? `: ${sc.reasons.join('; ')}` : ''}). Improve them where they fall short.`,
+    weak.length ? `Scores to raise:\n${weak.join('\n')}` : '',
+    criteria.length ? `Acceptance criteria:\n${criteria.join('\n')}` : '',
+    look.length ? `Where a reviewer would look first:\n${look.join('\n')}` : '',
+    'Fix what these point at: add or fix tests and run them, meet the criteria, handle the risky spots. Stay within the task, and say in the brief what you left as it is and why. Update the brief when you are done; the changes are scored again then.',
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}
 
 /** Markdown: for Copy / Download, the pull request's description and a PR comment. */
 export function scorecardMarkdown(sc, title = '') {

package/src/server.js

@@ -9,7 +9,7 @@ import { spawn } from 'node:child_process';
 import express from 'express';
 import { WebSocketServer } from 'ws';
 import { ensureHome, HOST, loadConfig, paths, PORT, saveConfig } from './config.js';
-import { AgentManager, MACHINE, shellNumber } from './manager.js';
+import { AgentManager, MACHINE, projectOf, shellNumber } from './manager.js';
 import { Backlog } from './backlog.js';
 import { Races } from './races.js';
 import { Review } from './review.js';
@@ -17,9 +17,11 @@ import { Teams } from './teams.js';
 import { Assistant } from './assistant.js';
 import { Cleanup } from './cleanup.js';
 import { Landing } from './landing.js';
+import { Autopilot } from './autopilot.js';
 import { Budgets } from './budgets.js';
 import { stats } from './stats.js';
 import { Playbooks } from './playbooks.js';
+import { Repeats } from './repeats.js';
 import { Updates } from './update.js';
 import { identity } from './identity.js';
 import { Studio } from './studio.js';
@@ -90,6 +92,9 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const teams = new Teams({ manager, store, config });
   const cleanup = new Cleanup({ manager, store, config, teams });
   const landing = new Landing({ manager, store, config });
+  // Backlog work the scorecard calls ready goes on to a pull request (and merged) by itself.
+  const autopilot = new Autopilot({ manager, store, backlog, review, landing, config });
+  manager.inboxSources.push(() => autopilot.inbox());
   const assistant = new Assistant({ manager, store, config });
   // Alerts link to the phone address when remote access is on, else the local UI.
   const notifier = new Notifier({
@@ -104,6 +109,14 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   const triggers = new Triggers({ manager, store, config, notifier });
   const budgets = new Budgets({ manager, store, config, notifier });
   const playbooks = new Playbooks({ manager, store });
+  // Requests you keep typing, offered as a playbook.
+  const repeats = new Repeats({
+    suggestAfter: config.repeats?.suggestAfter,
+    enabled: config.repeats?.enabled !== false,
+    playbooks: () => playbooks.list(),
+    projects: () => Object.fromEntries(Object.values(store.data.projects ?? {}).map((p) => [p.key, p.shortcut || p.name])),
+  });
+  manager.inboxSources.push(() => repeats.inbox());
   const memory = new Memory({ manager, config });
   const updates = new Updates({ config });
   let remoteServer = null;
@@ -230,6 +243,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
       // Agents the assistant's own session starts: its limits apply, and they are marked as its.
       const extra = assistant.admit(req.headers['x-agentmgr-agent'], list, opts);
       const created = manager.createMany(list, { ...opts, ...extra });
+      if (!extra.startedBy) repeats.record(created.map((a) => ({ text: a.intent, projectKey: projectOf(store.get(a.id) ?? a).key })));
       if (extra.startedBy) {
         for (const a of created) notifier.send('assistant', a, `was started by the assistant: ${a.intent.replace(/\s+/g, ' ').slice(0, 160)}`);
       }
@@ -254,6 +268,15 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   );
   api.get('/agents/:id/specs/:name', wrap((req) => manager.specDoc(req.params.id, req.params.name)));
   api.post('/agents/:id/scorecard/post', wrap((req) => review.postScorecard(req.params.id)));
+  // Improve: its scorecard goes back to the agent; a backlog item in review is reopened with it.
+  api.post(
+    '/agents/:id/scorecard/improve',
+    wrap((req) => {
+      const id = manager.mustGet(req.params.id).id;
+      const it = backlog.items().find((i) => i.agentId === id && i.status === 'review');
+      return manager.improve(id, it ? { send: (note) => backlog.reopen(it.id, { note }) } : {});
+    }),
+  );
   api.post('/agents/:id/plan', wrap((req) => manager.startPlanning(req.params.id)));
   api.post('/agents/:id/plan/approve', wrap((req) => manager.approvePlan(req.params.id, req.body?.note)));
   api.post('/agents/:id/plan/changes', wrap((req) => manager.requestPlanChanges(req.params.id, req.body?.note)));
@@ -443,7 +466,9 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     '/backlog',
     wrap((req) => {
       const { items, item, ...opts } = req.body ?? {};
-      return backlog.add(Array.isArray(items) ? items : [item], opts);
+      const added = backlog.add(Array.isArray(items) ? items : [item], opts);
+      repeats.record(added.map((it) => ({ text: it.title, projectKey: it.projectKey })));
+      return added;
     }),
   );
   // Everything waiting on the user: live prompts, agents' questions, stuck agents, overlaps.
@@ -658,9 +683,17 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     };
   }));
   api.get('/playbooks', wrap(() => playbooks.list()));
-  api.post('/playbooks', wrap((req) => playbooks.create(req.body ?? {})));
-  api.put('/playbooks/:id', wrap((req) => playbooks.update(req.params.id, req.body ?? {})));
-  api.delete('/playbooks/:id', wrap((req) => playbooks.remove(req.params.id)));
+  // Saving a playbook can answer a repeated-request suggestion.
+  const withRepeats = (fn) => (req) => {
+    const out = fn(req);
+    repeats.changed();
+    return out;
+  };
+  api.post('/playbooks', wrap(withRepeats((req) => playbooks.create(req.body ?? {}))));
+  api.put('/playbooks/:id', wrap(withRepeats((req) => playbooks.update(req.params.id, req.body ?? {}))));
+  api.delete('/playbooks/:id', wrap(withRepeats((req) => playbooks.remove(req.params.id))));
+  api.get('/repeats', wrap(() => repeats.view()));
+  api.post('/repeats/dismiss', wrap((req) => repeats.dismiss(String(req.body?.key ?? ''))));
   api.post('/playbooks/:id/run', wrap((req) => playbooks.run(req.params.id, { vars: req.body?.vars ?? {} })));
   api.get('/stats', wrap((req) => {
     const days = req.query.days === undefined ? 30 : Math.max(0, Math.min(3650, Math.floor(Number(req.query.days)) || 0));
@@ -713,6 +746,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   api.post('/backlog/:id/move', wrap((req) => backlog.move(req.params.id, req.body?.where)));
   api.post('/backlog/:id/split', wrap((req) => backlog.split(req.params.id, req.body?.parts)));
   api.post('/backlog/:id/keep-whole', wrap((req) => backlog.keepWhole(req.params.id)));
+  api.post('/backlog/:id/ship', wrap((req) => autopilot.shipNow(req.params.id)));
   api.post(
     '/shutdown',
     wrap(() => {
@@ -923,6 +957,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   manager.on('change', (agent) => broadcast({ t: 'agent', agent }));
   reports.on('change', () => broadcast({ t: 'built', reports: reports.list() }));
   manager.rules.on('change', (rules) => broadcast({ t: 'rules', rules }));
+  repeats.on('change', (view) => broadcast({ t: 'repeats', repeats: view }));
   manager.on('removed', (id) => {
     broadcast({ t: 'removed', id });
     live.closeAgent(id).catch(() => {});
@@ -959,7 +994,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     const url = new URL(req.url, 'http://x');
     if (url.pathname === '/ws/events') {
       eventClients.add(ws);
-      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list(), built: reports.list(), rules: manager.rules.view() }));
+      ws.send(JSON.stringify({ t: 'snapshot', agents: manager.list(), backlog: backlog.view(), projects: manager.listProjects(), races: races.list(), teams: teams.list(), built: reports.list(), rules: manager.rules.view(), repeats: repeats.view() }));
       ws.on('close', () => eventClients.delete(ws));
       return;
     }
@@ -1040,6 +1075,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     closing = true;
     cleanup.close();
     landing.close();
+    autopilot.close();
     triggers.close();
     budgets.close();
     playbooks.close();