maestro-agent 0.0.1 → 0.0.2

package/src/chief/index.ts

@@ -0,0 +1,461 @@
+import type { Database } from "bun:sqlite";
+import Anthropic from "@anthropic-ai/sdk";
+import { generateId, now } from "../core/db";
+import { createWorkspaceRole } from "../roles/workspace-role";
+import { countTasksByPredicate, isBlockedTaskStatus, isInitialTaskStatus } from "../workflows";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface RecommendedRole {
+  id: string;
+  name: string;
+  rationale: string;
+  headcount: number;
+}
+
+export interface ChiefDecision {
+  tool: string;
+  args: Record<string, any>;
+}
+
+export interface ChiefHeartbeatOptions {
+  planner?: (metrics: OrganizationalMetrics) => Promise<ChiefDecision[]> | ChiefDecision[];
+}
+
+export interface OrganizationalMetrics {
+  workspaces: number;
+  projects: number;
+  open_tasks: number;
+  blocked_tasks: number;
+  working_agents: number;
+  idle_agents: number;
+  offline_agents: number;
+  agent_runtimes: number;
+  unread_inbox: number;
+}
+
+export interface ChiefConfig {
+  apiKey: string;
+  baseURL?: string;
+  model?: string;
+  maxTurns?: number;
+  /** 用于测试注入，生产环境不传 */
+  _client?: Anthropic;
+}
+
+// ─── Role Recommendation (rule-based) ────────────────────────────────────────
+
+const ROLE_RULES: Array<{ id: string; name: string; keywords: string[]; rationale: string }> = [
+  { id: "engineer", name: "Engineer", keywords: ["api", "build", "code", "ship", "implement"], rationale: "Needed for implementation and integration work." },
+  { id: "writer", name: "Writer", keywords: ["doc", "docs", "launch", "write", "content"], rationale: "Needed for documentation and launch communication." },
+  { id: "researcher", name: "Researcher", keywords: ["research", "compare", "investigate"], rationale: "Needed for discovery and option analysis." },
+  { id: "critic", name: "Critic", keywords: ["review", "qa", "test", "quality"], rationale: "Needed for review, testing, and risk checks." },
+];
+
+export function recommendRoles(goal: string): RecommendedRole[] {
+  const text = goal.toLowerCase();
+  const matches = ROLE_RULES.filter((rule) => rule.keywords.some((keyword) => text.includes(keyword)));
+  const roles = matches.length > 0 ? matches : [ROLE_RULES[0], ROLE_RULES[3]];
+  return roles.map((role) => ({
+    id: role.id,
+    name: role.name,
+    rationale: role.rationale,
+    headcount: 1,
+  }));
+}
+
+export function proposeRoster(db: Database, workspaceId: string) {
+  const workspace = db.query("SELECT * FROM workspace WHERE id = ?").get(workspaceId) as any;
+  if (!workspace) throw new Error(`Workspace not found: ${workspaceId}`);
+  const roles = recommendRoles(`${workspace.name} ${workspace.goal || ""}`);
+  const id = generateId("msg");
+  const ts = now();
+  const body = roles
+    .map((role) => `${role.id} x${role.headcount}: ${role.rationale}`)
+    .join("\n");
+  const ref = JSON.stringify({ workspace_id: workspaceId, roles });
+  db.run(
+    `INSERT INTO inbox_message (id, kind, from_actor, to_actor, subject, body, ref_json, status, created_at)
+     VALUES (?, 'proposal', 'chief', 'user', ?, ?, ?, 'unread', ?)`,
+    [id, `Roster recommendation for ${workspace.name}`, body, ref, ts],
+  );
+  return db.query("SELECT * FROM inbox_message WHERE id = ?").get(id) as any;
+}
+
+// ─── Chief Heartbeat ─────────────────────────────────────────────────────────
+
+export async function runChiefHeartbeat(db: Database, opts: ChiefHeartbeatOptions = {}) {
+  const metrics = collectOrganizationalMetrics(db);
+  const decisions = opts.planner
+    ? await opts.planner(metrics)
+    : defaultChiefPlanner(db, metrics);
+  const results = decisions.map((decision) => applyChiefDecision(db, decision));
+  return {
+    metrics,
+    decisions: decisions.length,
+    applied: results.filter((result) => result.applied).length,
+    results,
+  };
+}
+
+// ─── Claude-backed Chief Agent (agentic loop) ───────────────────────────────
+
+const CHIEF_SYSTEM = `You are MAESTRO Chief, an autonomous project manager agent.
+Your job is to review organizational health metrics and take actions to keep work flowing.
+Rules:
+- At most 5 tool calls per heartbeat.
+- Prefer proposals over direct actions (send to Inbox for human approval).
+- do_nothing if the organization is healthy.`;
+
+export function createClaudePlanner(config: ChiefConfig) {
+  const model = config.model || process.env.MAESTRO_CHIEF_MODEL || "claude-sonnet-4-20250514";
+  const maxTurns = config.maxTurns ?? 3;
+  const client = config._client ?? new Anthropic({
+    apiKey: config.apiKey,
+    baseURL: config.baseURL || undefined,
+  });
+
+  return async (metrics: OrganizationalMetrics): Promise<ChiefDecision[]> => {
+    const decisions: ChiefDecision[] = [];
+    const messages: Anthropic.MessageParam[] = [
+      { role: "user", content: `Organizational metrics:\n${JSON.stringify(metrics, null, 2)}\n\nAnalyze and take actions.` },
+    ];
+
+    for (let turn = 0; turn < maxTurns; turn++) {
+      const response = await client.messages.create({
+        model,
+        max_tokens: 1024,
+        system: CHIEF_SYSTEM,
+        messages,
+        tools: chiefTools() as Anthropic.Tool[],
+      });
+
+      // 收集本轮 tool_use blocks
+      const toolUses = response.content.filter(
+        (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
+      );
+
+      if (toolUses.length === 0) break; // 没有工具调用，结束
+
+      // 记录决策
+      for (const tu of toolUses) {
+        decisions.push({ tool: tu.name, args: (tu.input as Record<string, any>) || {} });
+      }
+
+      // 如果 stop_reason 不是 tool_use，结束
+      if (response.stop_reason !== "tool_use") break;
+
+      // 构造 tool_result 回复给模型（agentic loop）
+      messages.push({ role: "assistant", content: response.content });
+      messages.push({
+        role: "user",
+        content: toolUses.map((tu) => ({
+          type: "tool_result" as const,
+          tool_use_id: tu.id,
+          content: JSON.stringify({ ok: true, tool: tu.name }),
+        })),
+      });
+    }
+
+    return decisions;
+  };
+}
+
+// ─── Decision Executor ───────────────────────────────────────────────────────
+
+export function applyChiefDecision(db: Database, decision: ChiefDecision): { applied: boolean; message: string; ref?: any } {
+  switch (decision.tool) {
+    case "propose_project":
+      return proposeProject(db, decision.args);
+    case "archive_project":
+      return proposeArchiveProject(db, decision.args);
+    case "spawn_agent":
+      return spawnAgent(db, decision.args);
+    case "retire_agent":
+      return retireAgent(db, decision.args);
+    case "escalate_to_user":
+      return escalateToUser(db, decision.args);
+    case "recommend_roles":
+      return recommendRolesForWorkspace(db, decision.args);
+    case "update_task_flow":
+      return updateTaskFlow(db, decision.args);
+    case "create_role":
+      return createRole(db, decision.args);
+    case "do_nothing":
+      return { applied: false, message: "Chief did nothing" };
+    default:
+      return { applied: false, message: `Unknown chief tool: ${decision.tool}` };
+  }
+}
+
+// ─── Metrics ─────────────────────────────────────────────────────────────────
+
+export function collectOrganizationalMetrics(db: Database): OrganizationalMetrics {
+  return {
+    workspaces: count(db, "workspace"),
+    projects: count(db, "project"),
+    open_tasks: countTasksByPredicate(db, (task) => isInitialTaskStatus(db, task)),
+    blocked_tasks: countTasksByPredicate(db, (task) => isBlockedTaskStatus(db, task)),
+    working_agents: countWhere(db, "agent", "status = 'working'"),
+    idle_agents: countWhere(db, "agent", "status = 'idle'"),
+    offline_agents: countWhere(db, "agent", "status = 'offline'"),
+    agent_runtimes: count(db, "agent_runtime"),
+    unread_inbox: countWhere(db, "inbox_message", "status = 'unread'"),
+  };
+}
+
+// ─── Default Rule-based Planner (no LLM) ─────────────────────────────────────
+
+function defaultChiefPlanner(db: Database, metrics: OrganizationalMetrics): ChiefDecision[] {
+  const decisions: ChiefDecision[] = [];
+  if (metrics.blocked_tasks > 0) {
+    decisions.push({
+      tool: "escalate_to_user",
+      args: { kind: "escalation", body: `${metrics.blocked_tasks} task(s) are blocked.` },
+    });
+  }
+
+  const activeWorkspaces = db.query("SELECT id FROM workspace WHERE status = 'active'").all() as Array<{ id: string }>;
+  if (metrics.unread_inbox === 0) {
+    decisions.push(...activeWorkspaces.map((workspace) => ({ tool: "recommend_roles", args: { workspace_id: workspace.id } })));
+  }
+  if (decisions.length === 0) decisions.push({ tool: "do_nothing", args: {} });
+  return decisions;
+}
+
+// ─── Tool Implementations ────────────────────────────────────────────────────
+
+function proposeProject(db: Database, args: Record<string, any>) {
+  const workspace = db.query("SELECT * FROM workspace WHERE id = ?").get(args.workspace_id) as any;
+  if (!workspace) return { applied: false, message: `Workspace not found: ${args.workspace_id}` };
+  const ref = {
+    tool: "propose_project",
+    workspace_id: args.workspace_id,
+    name: args.name,
+    rationale: args.rationale,
+    charter: args.charter,
+  };
+  createInbox(db, "proposal", "chief", "user", `Project proposal for ${workspace.name}`, args.rationale || args.name || "", ref);
+  return { applied: false, message: "Project proposal sent to inbox", ref };
+}
+
+function proposeArchiveProject(db: Database, args: Record<string, any>) {
+  const project = db.query("SELECT * FROM project WHERE id = ?").get(args.project_id) as any;
+  if (!project) return { applied: false, message: `Project not found: ${args.project_id}` };
+  const ref = { tool: "archive_project", project_id: args.project_id, rationale: args.rationale };
+  createInbox(db, "proposal", "chief", "user", `Archive project: ${project.name}`, args.rationale || "", ref);
+  return { applied: false, message: "Archive proposal sent to inbox", ref };
+}
+
+function spawnAgent(db: Database, args: Record<string, any>) {
+  const role = db.query("SELECT * FROM role WHERE id = ?").get(args.role_id) as any;
+  const runtime = db.query("SELECT * FROM agent_runtime WHERE id = ?").get(args.runtime_id || args.agent_runtime) as any;
+  if (!role || !runtime) return { applied: false, message: "Role or agent runtime not found" };
+  const id = generateId("agent");
+  const ts = now();
+  db.run(
+    "INSERT INTO agent (id, role_id, runtime_id, name, status, metrics_json, created_at, last_active_at) VALUES (?, ?, ?, ?, 'idle', '{}', ?, ?)",
+    [id, role.id, runtime.id, `${role.name}-${id.slice(-4)}`, ts, ts],
+  );
+  audit(db, "chief", "chief.spawn_agent", id, args);
+  return { applied: true, message: `Spawned agent ${id}`, ref: { agent_id: id } };
+}
+
+function retireAgent(db: Database, args: Record<string, any>) {
+  const agent = db.query("SELECT * FROM agent WHERE id = ?").get(args.agent_id) as any;
+  if (!agent) return { applied: false, message: `Agent not found: ${args.agent_id}` };
+  const cooldownMs = args.cooldown_ms ?? 5 * 60_000;
+  if (cooldownMs > 0 && now() - Number(agent.last_active_at || 0) < cooldownMs) {
+    return { applied: false, message: "Retire cooldown has not elapsed" };
+  }
+  db.run("UPDATE agent SET status = 'offline' WHERE id = ?", [args.agent_id]);
+  audit(db, "chief", "chief.retire_agent", args.agent_id, args);
+  return { applied: true, message: `Retired agent ${args.agent_id}` };
+}
+
+function escalateToUser(db: Database, args: Record<string, any>) {
+  const kind = args.kind || "report";
+  const limit = Number(args.limit_per_hour ?? 10);
+  const since = now() - 60 * 60_000;
+  const c = (db.query(
+    "SELECT COUNT(*) AS count FROM inbox_message WHERE from_actor = 'chief' AND to_actor = 'user' AND kind = ? AND created_at >= ?",
+  ).get(kind, since) as any).count;
+  if (c >= limit) return { applied: false, message: "Chief escalation rate limit reached" };
+  const message = createInbox(db, kind, "chief", "user", `Chief ${kind}`, args.body || "", args.refs || null);
+  return { applied: true, message: "Escalation sent", ref: message };
+}
+
+function recommendRolesForWorkspace(db: Database, args: Record<string, any>) {
+  const workspaceId = args.workspace_id;
+  if (!workspaceId) return { applied: false, message: "recommend_roles requires workspace_id" };
+  const workspace = db.query("SELECT * FROM workspace WHERE id = ?").get(workspaceId) as any;
+  if (!workspace) return { applied: false, message: `Workspace not found: ${workspaceId}` };
+  const proposal = proposeRoster(db, workspaceId);
+  return { applied: true, message: "Role recommendation sent", ref: proposal };
+}
+
+function updateTaskFlow(db: Database, args: Record<string, any>) {
+  const mode = String(args.mode || "");
+  const ts = now();
+
+  if (mode === "add_dependency") {
+    const task = db.query("SELECT * FROM task WHERE id = ?").get(args.task_id) as any;
+    const dependsOn = Array.isArray(args.depends_on) ? args.depends_on : [];
+    if (!task || dependsOn.length === 0) return { applied: false, message: "Task or dependencies not found" };
+    for (const dependencyId of dependsOn) {
+      db.run("INSERT OR IGNORE INTO task_dependency (task_id, depends_on) VALUES (?, ?)", [task.id, dependencyId]);
+    }
+    audit(db, "chief", "chief.update_task_flow", task.id, args);
+    return { applied: true, message: `Added ${dependsOn.length} dependency(s)`, ref: { task_id: task.id, depends_on: dependsOn } };
+  }
+
+  if (mode === "reparent_task") {
+    const task = db.query("SELECT * FROM task WHERE id = ?").get(args.task_id) as any;
+    const parent = db.query("SELECT * FROM task WHERE id = ?").get(args.parent_task_id) as any;
+    if (!task || !parent) return { applied: false, message: "Task or parent not found" };
+    const lineageDepth = (parent.lineage_depth || 0) + 1;
+    db.run(
+      "UPDATE task SET parent_task_id = ?, project_id = ?, lineage_depth = ?, updated_at = ? WHERE id = ?",
+      [parent.id, parent.project_id, lineageDepth, ts, task.id],
+    );
+    audit(db, "chief", "chief.update_task_flow", task.id, args);
+    return { applied: true, message: `Reparented task ${task.id}`, ref: { task_id: task.id, parent_task_id: parent.id } };
+  }
+
+  if (mode === "spawn_followup") {
+    const parent = db.query("SELECT * FROM task WHERE id = ?").get(args.parent_task_id) as any;
+    if (!parent || !args.title) return { applied: false, message: "Parent task or title not found" };
+    const id = generateId("task");
+    const lineageDepth = (parent.lineage_depth || 0) + 1;
+    db.run(
+      `INSERT INTO task (id, project_id, parent_task_id, title, description, status, required_capabilities_json, priority, lineage_depth, created_by, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, 'chief', ?, ?)`,
+      [
+        id, parent.project_id, parent.id, args.title, args.description || "",
+        JSON.stringify(Array.isArray(args.required_capabilities) ? args.required_capabilities : []),
+        Number(args.priority || 0), lineageDepth, ts, ts,
+      ],
+    );
+    audit(db, "chief", "chief.update_task_flow", id, args);
+    return { applied: true, message: `Created follow-up task ${id}`, ref: { task_id: id, parent_task_id: parent.id } };
+  }
+
+  return { applied: false, message: `Unknown task flow mode: ${mode}` };
+}
+
+function createRole(db: Database, args: Record<string, any>) {
+  const name = String(args.name || "").trim();
+  if (!name) return { applied: false, message: "Role name is required" };
+  if (!args.workspace_id) return { applied: false, message: "workspace_id is required" };
+  const created = createWorkspaceRole(db, {
+    workspaceId: args.workspace_id,
+    projectId: args.project_id || null,
+    id: args.id,
+    name,
+    capabilities: Array.isArray(args.capabilities) ? args.capabilities : [],
+    preferredRuntimes: Array.isArray(args.preferred_runtimes) ? args.preferred_runtimes : [],
+    headcount: Number(args.headcount || 1),
+    runtimeId: args.runtime_id || null,
+  });
+  audit(db, "chief", "chief.create_role", created.role.id, args);
+  return { applied: true, message: `Created role ${created.role.id}`, ref: { role: created.role, agents: created.agents } };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function createInbox(db: Database, kind: string, fromActor: string, toActor: string, subject: string, body: string, ref: unknown) {
+  const id = generateId("msg");
+  const ts = now();
+  db.run(
+    `INSERT INTO inbox_message (id, kind, from_actor, to_actor, subject, body, ref_json, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 'unread', ?)`,
+    [id, kind, fromActor, toActor, subject, body, ref ? JSON.stringify(ref) : null, ts],
+  );
+  return db.query("SELECT * FROM inbox_message WHERE id = ?").get(id) as any;
+}
+
+function audit(db: Database, actor: string, action: string, target: string, payload: unknown) {
+  db.run(
+    "INSERT INTO audit_log (id, actor, action, target, payload_json, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+    [generateId("audit"), actor, action, target, JSON.stringify(payload), now()],
+  );
+}
+
+function count(db: Database, table: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table}`).get() as any).count;
+}
+
+function countWhere(db: Database, table: string, where: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table} WHERE ${where}`).get() as any).count;
+}
+
+// ─── Tool Definitions ────────────────────────────────────────────────────────
+
+function chiefTools(): Anthropic.Tool[] {
+  return [
+    {
+      name: "propose_project",
+      description: "Propose a new project for a workspace. This must go through Inbox approval.",
+      input_schema: { type: "object" as const, properties: { workspace_id: { type: "string" }, name: { type: "string" }, rationale: { type: "string" }, charter: { type: "string" } }, required: ["workspace_id", "name", "rationale"] },
+    },
+    {
+      name: "archive_project",
+      description: "Propose archiving a project. This must go through Inbox approval.",
+      input_schema: { type: "object" as const, properties: { project_id: { type: "string" }, rationale: { type: "string" } }, required: ["project_id", "rationale"] },
+    },
+    {
+      name: "spawn_agent",
+      description: "Spawn an agent for a role and agent runtime.",
+      input_schema: { type: "object" as const, properties: { role_id: { type: "string" }, runtime_id: { type: "string" }, rationale: { type: "string" } }, required: ["role_id", "runtime_id", "rationale"] },
+    },
+    {
+      name: "retire_agent",
+      description: "Retire an agent after cooldown.",
+      input_schema: { type: "object" as const, properties: { agent_id: { type: "string" }, rationale: { type: "string" } }, required: ["agent_id", "rationale"] },
+    },
+    {
+      name: "escalate_to_user",
+      description: "Send a rate-limited report, approval, or escalation to the user.",
+      input_schema: { type: "object" as const, properties: { kind: { type: "string" }, body: { type: "string" }, refs: { type: "object" } }, required: ["kind", "body"] },
+    },
+    {
+      name: "recommend_roles",
+      description: "Recommend workspace roles and send the proposal to Inbox.",
+      input_schema: { type: "object" as const, properties: { workspace_id: { type: "string" } }, required: ["workspace_id"] },
+    },
+    {
+      name: "update_task_flow",
+      description: "Update task flow by adding dependencies, changing parentage, or inserting a follow-up task.",
+      input_schema: {
+        type: "object" as const,
+        properties: {
+          task_id: { type: "string" }, project_id: { type: "string" }, mode: { type: "string" },
+          depends_on: { type: "array", items: { type: "string" } },
+          parent_task_id: { type: "string" }, title: { type: "string" },
+          description: { type: "string" }, required_capabilities: { type: "array", items: { type: "string" } },
+          priority: { type: "number" }, rationale: { type: "string" },
+        },
+        required: ["mode", "rationale"],
+      },
+    },
+    {
+      name: "create_role",
+      description: "Create a role directly from a chief decision.",
+      input_schema: {
+        type: "object" as const,
+        properties: {
+          id: { type: "string" }, name: { type: "string" }, workspace_id: { type: "string" },
+          project_id: { type: "string" }, capabilities: { type: "array", items: { type: "string" } },
+          preferred_runtimes: { type: "array", items: { type: "string" } },
+          headcount: { type: "number" }, rationale: { type: "string" },
+        },
+        required: ["name", "rationale"],
+      },
+    },
+    {
+      name: "do_nothing",
+      description: "No action is needed. Call this if the organization is healthy.",
+      input_schema: { type: "object" as const, properties: {} },
+    },
+  ];
+}