ai-agentmanager 1.13.0 → 1.15.0

package/src/rules.js

@@ -0,0 +1,161 @@
+// Approval rules learned from your answers: when you keep saying yes to the same command in a repo
+// ("npm test", three times), the inbox offers to always allow it there. Allowed rules go to every
+// agent in that repo at launch (Claude Code's --allowedTools) and answer its live prompts, so the
+// same question isn't asked again. Kept in ~/.agentmanager/rules.json, per repo (the repo-memory key).
+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;
+// Commands whose first words name a subcommand: "npm test" is a rule, "npm" alone would allow anything npm does.
+const SUBCOMMANDS = new Set(['npm', 'pnpm', 'yarn', 'bun', 'npx', 'node', 'deno', 'git', 'gh', 'cargo', 'go', 'make', 'python', 'python3', 'uv', 'pip', 'poetry', 'pytest', 'mvn', 'gradle', './gradlew', 'dotnet', 'swift', 'xcodebuild', 'bundle', 'rake', 'rails', 'mix', 'composer', 'php', 'docker', 'kubectl', 'terraform', 'just', 'task']);
+// Never offered as a standing rule, however often approved: they delete, escalate, publish or reach out.
+const NEVER = /^(rm|sudo|su|chmod|chown|dd|mkfs|kill|killall|pkill|shutdown|reboot|curl|wget|ssh|scp|rsync|eval|exec|sh|bash|zsh|env|xargs|find|git (push|reset|clean|rebase|checkout|branch|tag)|gh (pr merge|release|repo|api|secret)|npm (publish|unpublish|login|adduser|token)|docker (rm|rmi|system|push|login)|kubectl (delete|apply)|terraform (apply|destroy))$/;
+// Anything that chains, redirects or substitutes isn't one command, so no rule covers it.
+const COMPOUND = /[;&|<>`$(){}\n\\]/;
+
+/** The words of a plain command, or null when it chains, redirects, substitutes or sets variables. */
+function words(command) {
+  const cmd = String(command ?? '').trim();
+  if (!cmd || COMPOUND.test(cmd)) return null;
+  const w = cmd.split(/\s+/);
+  return /^\w+=/.test(w[0]) ? null : w;
+}
+
+/**
+ * The rule that would allow a tool call, as Claude Code writes it, with a label for people:
+ * Bash → "Bash(npm test:*)", WebFetch → "WebFetch(domain:docs.x.com)", an MCP tool → its name.
+ * Null for calls that shouldn't become a standing rule (file edits: use Accept edits instead).
+ */
+export function ruleFor(tool) {
+  const input = tool?.input ?? {};
+  if (tool?.name === 'Bash') {
+    const w = words(input.command);
+    if (!w) return null;
+    const prefix = (SUBCOMMANDS.has(w[0]) && w[1] && !w[1].startsWith('-') ? w.slice(0, 2) : w.slice(0, 1)).join(' ');
+    if (NEVER.test(prefix) || NEVER.test(w[0])) return null;
+    return { rule: `Bash(${prefix}:*)`, label: prefix };
+  }
+  if (tool?.name === 'WebFetch') {
+    try {
+      const host = new URL(input.url).hostname;
+      return host ? { rule: `WebFetch(domain:${host})`, label: `fetch from ${host}` } : null;
+    } catch {
+      return null;
+    }
+  }
+  if (/^mcp__[\w-]+__[\w-]+$/.test(tool?.name ?? '')) return { rule: tool.name, label: tool.name.replace(/^mcp__/, '').replace('__', ': ') };
+  return null;
+}
+
+/** Whether an allowed rule covers this tool call. */
+export function covers(rule, tool) {
+  const m = /^Bash\((.+):\*\)$/.exec(rule);
+  if (m) {
+    const w = words(tool?.input?.command);
+    return tool?.name === 'Bash' && Boolean(w) && (w.join(' ') === m[1] || w.join(' ').startsWith(`${m[1]} `));
+  }
+  return ruleFor(tool)?.rule === rule;
+}
+
+/** What a pending tool call is, in a few words for an inbox card. */
+export function describeTool(tool) {
+  const input = tool?.input ?? {};
+  if (tool?.name === 'Bash') return { name: 'Bash', text: String(input.command ?? '').slice(0, 300) };
+  if (['Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'Read'].includes(tool?.name)) return { name: tool.name, text: String(input.file_path ?? input.notebook_path ?? '') };
+  if (tool?.name === 'WebFetch') return { name: 'WebFetch', text: String(input.url ?? '') };
+  return { name: String(tool?.name ?? ''), text: JSON.stringify(input).slice(0, 300) };
+}
+
+export class Rules extends EventEmitter {
+  constructor({ file = path.join(paths.home, 'rules.json'), suggestAfter = SUGGEST_AFTER } = {}) {
+    super();
+    this.file = file;
+    this.suggestAfter = suggestAfter;
+    try {
+      this.data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      this.data = {};
+    }
+    this.data.repos ??= {};
+  }
+
+  save() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    this.emit('change', this.view());
+  }
+
+  repo(key) {
+    return (this.data.repos[key] ??= { allow: [], dismissed: [], seen: {} });
+  }
+
+  /** The rules allowed in a repo, as Claude Code allow rules. */
+  allowed(key) {
+    return (this.data.repos[key]?.allow ?? []).map((r) => r.rule);
+  }
+
+  /** The allowed rule that covers this call in this repo, if any. */
+  allows(key, tool) {
+    return this.allowed(key).find((r) => covers(r, tool)) ?? null;
+  }
+
+  /** An allowed rule answered a prompt by itself: count it, so the list shows what it saves. */
+  used(key, rule) {
+    const a = this.data.repos[key]?.allow.find((x) => x.rule === rule);
+    if (!a) return;
+    a.uses = (a.uses ?? 0) + 1;
+    a.lastUsedAt = new Date().toISOString();
+    this.save();
+  }
+
+  /** You said yes to this call in this repo; count it toward a suggestion. */
+  approved(key, tool) {
+    const r = ruleFor(tool);
+    if (!r) return null;
+    const repo = this.repo(key);
+    if (repo.allow.some((x) => x.rule === r.rule)) return null;
+    const seen = (repo.seen[r.rule] ??= { label: r.label, n: 0 });
+    seen.n++;
+    seen.at = new Date().toISOString();
+    this.save();
+    return { ...r, n: seen.n };
+  }
+
+  accept(key, rule) {
+    const repo = this.data.repos[key];
+    const seen = repo?.seen[rule];
+    if (!seen && !repo?.allow.some((x) => x.rule === rule)) throw Object.assign(new Error('No such suggestion'), { status: 404 });
+    if (!repo.allow.some((x) => x.rule === rule)) repo.allow.push({ rule, label: seen.label, at: new Date().toISOString() });
+    delete repo.seen[rule];
+    this.save();
+  }
+
+  /** "Not now": stop suggesting it (it can still be allowed later from the list). */
+  dismiss(key, rule) {
+    const repo = this.data.repos[key];
+    if (!repo?.seen[rule]) throw Object.assign(new Error('No such suggestion'), { status: 404 });
+    if (!repo.dismissed.includes(rule)) repo.dismissed.push(rule);
+    this.save();
+  }
+
+  remove(key, rule) {
+    const repo = this.data.repos[key];
+    if (!repo?.allow.some((x) => x.rule === rule)) throw Object.assign(new Error('No such rule'), { status: 404 });
+    repo.allow = repo.allow.filter((x) => x.rule !== rule);
+    repo.dismissed = repo.dismissed.filter((x) => x !== rule);
+    this.save();
+  }
+
+  /** Every repo's allowed rules and the suggestions waiting for an answer. */
+  view() {
+    const allowed = [];
+    const suggestions = [];
+    for (const [repo, r] of Object.entries(this.data.repos)) {
+      for (const a of r.allow) allowed.push({ repo, ...a });
+      for (const [rule, s] of Object.entries(r.seen)) if (s.n >= this.suggestAfter && !r.dismissed.includes(rule)) suggestions.push({ repo, rule, label: s.label, n: s.n, at: s.at });
+    }
+    return { allowed, suggestions, suggestAfter: this.suggestAfter };
+  }
+}

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)}`);
       }
@@ -443,11 +457,23 @@ 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.
   api.get('/inbox', wrap(() => manager.inbox()));
+  // Approval rules learned from your answers (src/rules.js): allowed per repo, and suggestions.
+  const ruleArgs = (req) => {
+    const { repo, rule } = req.body ?? {};
+    if (typeof repo !== 'string' || typeof rule !== 'string') throw Object.assign(new Error('repo and rule are required'), { status: 400 });
+    return [repo, rule];
+  };
+  api.get('/rules', wrap(() => manager.rules.view()));
+  api.post('/rules/accept', wrap((req) => (manager.rules.accept(...ruleArgs(req)), manager.applyRules(), manager.rules.view())));
+  api.post('/rules/dismiss', wrap((req) => (manager.rules.dismiss(...ruleArgs(req)), manager.rules.view())));
+  api.post('/rules/remove', wrap((req) => (manager.rules.remove(...ruleArgs(req)), manager.rules.view())));
   api.post('/agents/:id/tell', wrap((req) => manager.tell(req.params.id, req.body?.text)));
   api.post('/agents/:id/answer', wrap((req) => manager.answerQuestion(req.params.id, req.body?.question, req.body?.text)));
   api.post('/agents/:id/prompt-key', wrap((req) => manager.answerPrompt(req.params.id, String(req.body?.key ?? ''))));
@@ -648,9 +674,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));
@@ -703,6 +737,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(() => {
@@ -912,6 +947,8 @@ 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(() => {});
@@ -948,7 +985,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() }));
+      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;
     }
@@ -1029,6 +1066,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     closing = true;
     cleanup.close();
     landing.close();
+    autopilot.close();
     triggers.close();
     budgets.close();
     playbooks.close();

package/src/stuck.js

@@ -20,12 +20,14 @@ const textOf = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((b)
 
 /**
  * Incrementally read new transcript lines into `state.events` (tool calls with their results).
- * state: { offset, events: [{ t, kind: 'cmd'|'edit'|'other', ... }], pending: Map(id -> event) }.
+ * state: { offset, events: [{ t, kind: 'cmd'|'edit'|'other', ... }], pending: Map(id -> event),
+ *   calls: Map(id -> { name, input }) for the tool calls still waiting for a result (what a prompt asks about) }.
  */
 export function scanActivity(file, state) {
   state.offset ??= 0;
   state.events ??= [];
   state.pending ??= new Map();
+  state.calls ??= new Map();
   let fd;
   try {
     fd = fs.openSync(file, 'r');
@@ -34,7 +36,7 @@ export function scanActivity(file, state) {
   }
   try {
     const { size } = fs.fstatSync(fd);
-    if (size < state.offset) Object.assign(state, { offset: 0, events: [], pending: new Map() });
+    if (size < state.offset) Object.assign(state, { offset: 0, events: [], pending: new Map(), calls: new Map() });
     if (size === state.offset) return state;
     const buf = Buffer.alloc(size - state.offset);
     fs.readSync(fd, buf, 0, buf.length, state.offset);
@@ -56,7 +58,12 @@ export function scanActivity(file, state) {
           const ev = eventFor(b, t);
           state.events.push(ev);
           state.pending.set(b.id, ev);
+          // Calls left without a result by an earlier response (interrupted) aren't what's asked now.
+          if (rec.message?.id && rec.message.id !== state.callsMsg) state.calls.clear();
+          state.callsMsg = rec.message?.id;
+          state.calls.set(b.id, { name: b.name, input: b.input ?? {} });
         } else if (rec.type === 'user' && b.type === 'tool_result') {
+          state.calls.delete(b.tool_use_id);
           const ev = state.pending.get(b.tool_use_id);
           if (!ev) continue;
           state.pending.delete(b.tool_use_id);