macro-agent 0.1.2 → 0.1.3

package/references/openteams/src/services/template-service.test.ts

@@ -1,306 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import type Database from "better-sqlite3";
-import { createInMemoryDatabase } from "../db/database";
-import { TemplateService } from "./template-service";
-import { CommunicationService } from "./communication-service";
-import { TeamService } from "./team-service";
-import type { TeamManifest } from "../template/types";
-
-describe("TemplateService", () => {
-  let db: Database.Database;
-  let templateService: TemplateService;
-  let commService: CommunicationService;
-  let teamService: TeamService;
-
-  const selfDrivingManifest: TeamManifest = {
-    name: "self-driving",
-    description: "Autonomous codebase development",
-    version: 1,
-    roles: ["planner", "grinder", "judge"],
-    topology: {
-      root: { role: "planner", config: { model: "sonnet" } },
-      companions: [{ role: "judge", config: { model: "haiku" } }],
-      spawn_rules: {
-        planner: ["grinder", "planner"],
-        judge: [],
-        grinder: [],
-      },
-    },
-    communication: {
-      channels: {
-        task_updates: {
-          description: "Task events",
-          signals: ["TASK_CREATED", "TASK_COMPLETED", "TASK_FAILED"],
-        },
-        work_coordination: {
-          signals: ["WORK_ASSIGNED", "WORKER_DONE"],
-        },
-      },
-      subscriptions: {
-        planner: [
-          { channel: "task_updates" },
-          { channel: "work_coordination", signals: ["WORKER_DONE"] },
-        ],
-        judge: [{ channel: "task_updates", signals: ["TASK_FAILED"] }],
-        grinder: [
-          { channel: "work_coordination", signals: ["WORK_ASSIGNED"] },
-        ],
-      },
-      emissions: {
-        planner: ["TASK_CREATED", "WORK_ASSIGNED"],
-        grinder: ["WORKER_DONE"],
-      },
-      routing: {
-        peers: [
-          {
-            from: "judge",
-            to: "planner",
-            via: "direct",
-            signals: ["FIXUP_CREATED"],
-          },
-        ],
-      },
-    },
-  };
-
-  beforeEach(() => {
-    db = createInMemoryDatabase();
-    templateService = new TemplateService(db);
-    commService = new CommunicationService(db);
-    teamService = new TeamService(db);
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  describe("bootstrapFromManifest", () => {
-    it("creates a team with template metadata", () => {
-      const result = templateService.bootstrapFromManifest(
-        selfDrivingManifest
-      );
-
-      expect(result.team.name).toBe("self-driving");
-      expect(result.team.description).toBe(
-        "Autonomous codebase development"
-      );
-      expect(result.team.template_name).toBe("self-driving");
-      expect(result.roles).toEqual(["planner", "grinder", "judge"]);
-    });
-
-    it("auto-registers root and companion roles as members", () => {
-      const result = templateService.bootstrapFromManifest(
-        selfDrivingManifest
-      );
-
-      expect(result.members).toContain("planner");
-      expect(result.members).toContain("judge");
-      expect(result.members).toHaveLength(2); // root + 1 companion
-
-      const plannerMember = teamService.getMember("self-driving", "planner");
-      expect(plannerMember).not.toBeNull();
-      expect(plannerMember!.role).toBe("planner");
-      expect(plannerMember!.model).toBe("sonnet");
-
-      const judgeMember = teamService.getMember("self-driving", "judge");
-      expect(judgeMember).not.toBeNull();
-      expect(judgeMember!.role).toBe("judge");
-      expect(judgeMember!.model).toBe("haiku");
-    });
-
-    it("allows overriding the team name", () => {
-      const result = templateService.bootstrapFromManifest(
-        selfDrivingManifest,
-        "my-project"
-      );
-
-      expect(result.team.name).toBe("my-project");
-      expect(result.team.template_name).toBe("self-driving");
-    });
-
-    it("sets up channels", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      const channels = commService.listChannels("self-driving");
-      expect(channels).toHaveLength(2);
-      expect(channels.map((c) => c.name).sort()).toEqual([
-        "task_updates",
-        "work_coordination",
-      ]);
-    });
-
-    it("sets up subscriptions", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      const subs = commService.listSubscriptions("self-driving");
-      expect(subs.length).toBeGreaterThan(0);
-
-      const plannerSubs = commService.getSubscriptionsForRole(
-        "self-driving",
-        "planner"
-      );
-      expect(plannerSubs).toHaveLength(2);
-    });
-
-    it("sets up spawn rules", () => {
-      const result = templateService.bootstrapFromManifest(
-        selfDrivingManifest
-      );
-
-      expect(result.spawnRules).toHaveLength(3);
-
-      const plannerRule = result.spawnRules.find(
-        (r) => r.from === "planner"
-      )!;
-      expect(plannerRule.canSpawn).toEqual(["grinder", "planner"]);
-
-      // Judge and grinder can't spawn
-      expect(
-        result.spawnRules.find((r) => r.from === "judge")!.canSpawn
-      ).toEqual([]);
-    });
-
-    it("sets up peer routes", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      const routes = commService.listPeerRoutes("self-driving");
-      expect(routes).toHaveLength(1);
-      expect(routes[0].from_role).toBe("judge");
-      expect(routes[0].to_role).toBe("planner");
-    });
-  });
-
-  describe("canSpawn", () => {
-    it("respects spawn rules", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      expect(
-        templateService.canSpawn("self-driving", "planner", "grinder")
-      ).toBe(true);
-      expect(
-        templateService.canSpawn("self-driving", "planner", "planner")
-      ).toBe(true);
-      expect(
-        templateService.canSpawn("self-driving", "judge", "grinder")
-      ).toBe(false);
-      expect(
-        templateService.canSpawn("self-driving", "grinder", "grinder")
-      ).toBe(false);
-    });
-
-    it("allows all when no spawn rules exist", () => {
-      teamService.create({ name: "no-rules" });
-
-      expect(
-        templateService.canSpawn("no-rules", "anyone", "anything")
-      ).toBe(true);
-    });
-  });
-
-  describe("getSpawnRules", () => {
-    it("returns roles that a role can spawn", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      expect(
-        templateService.getSpawnRules("self-driving", "planner")
-      ).toEqual(["grinder", "planner"]);
-      expect(
-        templateService.getSpawnRules("self-driving", "judge")
-      ).toEqual([]);
-    });
-  });
-
-  describe("listSpawnRules", () => {
-    it("returns all spawn rules for a team", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      const rules = templateService.listSpawnRules("self-driving");
-      // Only planner has non-empty spawn targets stored in the DB
-      expect(rules).toHaveLength(1);
-      expect(rules[0].from).toBe("planner");
-      expect(rules[0].canSpawn).toEqual(["grinder", "planner"]);
-    });
-  });
-
-  describe("getTemplateInfo", () => {
-    it("returns template info for a templated team", () => {
-      templateService.bootstrapFromManifest(selfDrivingManifest);
-
-      const info = templateService.getTemplateInfo("self-driving");
-      expect(info!.templateName).toBe("self-driving");
-    });
-
-    it("returns null template info for non-templated team", () => {
-      teamService.create({ name: "manual" });
-
-      const info = templateService.getTemplateInfo("manual");
-      expect(info!.templateName).toBeNull();
-    });
-
-    it("returns null for nonexistent team", () => {
-      expect(templateService.getTemplateInfo("nope")).toBeNull();
-    });
-  });
-
-  describe("structured team template (backward compat)", () => {
-    it("bootstraps a traditional coordinator/worker structure", () => {
-      const structured: TeamManifest = {
-        name: "structured",
-        description: "Traditional structured development",
-        version: 1,
-        roles: ["coordinator", "integrator", "worker", "monitor"],
-        topology: {
-          root: { role: "coordinator" },
-          spawn_rules: {
-            coordinator: ["worker", "integrator", "monitor"],
-            integrator: ["worker"],
-            worker: [],
-            monitor: [],
-          },
-        },
-        communication: {
-          channels: {
-            work: {
-              signals: [
-                "WORK_ASSIGNED",
-                "WORKER_DONE",
-                "MERGE_REQUEST",
-                "MERGE_COMPLETE",
-              ],
-            },
-          },
-          subscriptions: {
-            coordinator: [{ channel: "work" }],
-            integrator: [
-              {
-                channel: "work",
-                signals: ["MERGE_REQUEST", "WORKER_DONE"],
-              },
-            ],
-            worker: [
-              { channel: "work", signals: ["WORK_ASSIGNED"] },
-            ],
-          },
-        },
-      };
-
-      const result = templateService.bootstrapFromManifest(structured);
-      expect(result.team.name).toBe("structured");
-      expect(result.roles).toHaveLength(4);
-
-      expect(
-        templateService.canSpawn("structured", "coordinator", "worker")
-      ).toBe(true);
-      expect(
-        templateService.canSpawn("structured", "worker", "worker")
-      ).toBe(false);
-
-      const coordinatorSubs = commService.getSubscriptionsForRole(
-        "structured",
-        "coordinator"
-      );
-      expect(coordinatorSubs).toHaveLength(1);
-      expect(coordinatorSubs[0].signal).toBeNull(); // all signals
-    });
-  });
-});

package/references/openteams/src/services/template-service.ts

@@ -1,182 +0,0 @@
-import type Database from "better-sqlite3";
-import type { Team } from "../types";
-import type { ResolvedTemplate, TeamManifest } from "../template/types";
-import { TemplateLoader } from "../template/loader";
-import { TeamService } from "./team-service";
-import { CommunicationService } from "./communication-service";
-
-export interface BootstrapResult {
-  team: Team;
-  roles: string[];
-  members: string[];
-  channels: string[];
-  spawnRules: Array<{ from: string; canSpawn: string[] }>;
-}
-
-export class TemplateService {
-  private teamService: TeamService;
-  private commService: CommunicationService;
-
-  constructor(private db: Database.Database) {
-    this.teamService = new TeamService(db);
-    this.commService = new CommunicationService(db);
-  }
-
-  /**
-   * Load a template from a directory and create a team from it.
-   * This is the primary entry point: load template → create team → wire communication → store spawn rules.
-   */
-  bootstrap(templateDir: string, teamNameOverride?: string): BootstrapResult {
-    const template = TemplateLoader.load(templateDir);
-    return this.bootstrapFromTemplate(template, teamNameOverride);
-  }
-
-  /**
-   * Bootstrap from an already-resolved template (for programmatic/test use).
-   */
-  bootstrapFromTemplate(
-    template: ResolvedTemplate,
-    teamNameOverride?: string
-  ): BootstrapResult {
-    const teamName = teamNameOverride ?? template.manifest.name;
-
-    // Create the team
-    const team = this.teamService.create({
-      name: teamName,
-      description: template.manifest.description,
-      templateName: template.manifest.name,
-      templatePath: template.sourcePath || undefined,
-    });
-
-    // Apply communication topology
-    if (template.manifest.communication) {
-      this.commService.applyConfig(teamName, template.manifest.communication);
-    }
-
-    // Register topology roles as initial members
-    const rootRole = template.manifest.topology.root.role;
-    const rootConfig = template.manifest.topology.root.config;
-    this.teamService.addMember(teamName, rootRole, {
-      role: rootRole,
-      agentType: "general-purpose",
-      model: rootConfig?.model as string | undefined,
-    });
-
-    if (template.manifest.topology.companions) {
-      for (const comp of template.manifest.topology.companions) {
-        this.teamService.addMember(teamName, comp.role, {
-          role: comp.role,
-          agentType: "general-purpose",
-          model: comp.config?.model as string | undefined,
-        });
-      }
-    }
-
-    // Store spawn rules
-    const spawnRules: Array<{ from: string; canSpawn: string[] }> = [];
-    if (template.manifest.topology.spawn_rules) {
-      const insertRule = this.db.prepare(
-        "INSERT OR IGNORE INTO spawn_rules (team_name, from_role, to_role) VALUES (?, ?, ?)"
-      );
-      for (const [from, targets] of Object.entries(
-        template.manifest.topology.spawn_rules
-      )) {
-        for (const to of targets) {
-          insertRule.run(teamName, from, to);
-        }
-        spawnRules.push({ from, canSpawn: targets });
-      }
-    }
-
-    const channels = template.manifest.communication?.channels
-      ? Object.keys(template.manifest.communication.channels)
-      : [];
-
-    const members = this.teamService.listMembers(teamName).map((m) => m.agent_name);
-
-    return {
-      team,
-      roles: template.manifest.roles,
-      members,
-      channels,
-      spawnRules,
-    };
-  }
-
-  /**
-   * Bootstrap from a raw manifest object (no filesystem needed).
-   */
-  bootstrapFromManifest(
-    manifest: TeamManifest,
-    teamNameOverride?: string
-  ): BootstrapResult {
-    const template = TemplateLoader.loadFromManifest(manifest);
-    return this.bootstrapFromTemplate(template, teamNameOverride);
-  }
-
-  /**
-   * Get the template info for a team.
-   */
-  getTemplateInfo(
-    teamName: string
-  ): { templateName: string | null; templatePath: string | null } | null {
-    const team = this.teamService.get(teamName);
-    if (!team) return null;
-    return {
-      templateName: team.template_name,
-      templatePath: team.template_path,
-    };
-  }
-
-  /**
-   * Check if a role can spawn another role within a team.
-   */
-  canSpawn(teamName: string, fromRole: string, toRole: string): boolean {
-    // If no spawn rules exist for this team, allow all (permissive)
-    const anyRules = this.db
-      .prepare(
-        "SELECT COUNT(*) as count FROM spawn_rules WHERE team_name = ?"
-      )
-      .get(teamName) as { count: number };
-
-    if (anyRules.count === 0) return true;
-
-    const row = this.db
-      .prepare(
-        "SELECT COUNT(*) as count FROM spawn_rules WHERE team_name = ? AND from_role = ? AND to_role = ?"
-      )
-      .get(teamName, fromRole, toRole) as { count: number };
-
-    return row.count > 0;
-  }
-
-  /**
-   * Get spawn rules for a role.
-   */
-  getSpawnRules(teamName: string, fromRole: string): string[] {
-    const rows = this.db
-      .prepare(
-        "SELECT to_role FROM spawn_rules WHERE team_name = ? AND from_role = ?"
-      )
-      .all(teamName, fromRole) as Array<{ to_role: string }>;
-    return rows.map((r) => r.to_role);
-  }
-
-  /**
-   * List all spawn rules for a team.
-   */
-  listSpawnRules(
-    teamName: string
-  ): Array<{ from: string; canSpawn: string[] }> {
-    const rows = this.db
-      .prepare(
-        "SELECT DISTINCT from_role FROM spawn_rules WHERE team_name = ? ORDER BY from_role"
-      )
-      .all(teamName) as Array<{ from_role: string }>;
-
-    return rows.map((r) => ({
-      from: r.from_role,
-      canSpawn: this.getSpawnRules(teamName, r.from_role),
-    }));
-  }
-}

package/references/openteams/src/spawner/acp-factory.ts

@@ -1,96 +0,0 @@
-import type {
-  AgentSpawner,
-  AgentInstance,
-  AgentUpdate,
-  SpawnAgentOptions,
-} from "../types";
-
-export class ACPFactorySpawner implements AgentSpawner {
-  private agents: Map<string, AgentInstance> = new Map();
-  private AgentFactoryModule: any = null;
-
-  private async loadFactory(): Promise<any> {
-    if (!this.AgentFactoryModule) {
-      try {
-        const mod = await import("acp-factory");
-        this.AgentFactoryModule = mod.AgentFactory ?? mod.default?.AgentFactory ?? mod;
-      } catch {
-        throw new Error(
-          "acp-factory is not installed. Install it with: npm install acp-factory"
-        );
-      }
-    }
-    return this.AgentFactoryModule;
-  }
-
-  async spawn(options: SpawnAgentOptions): Promise<AgentInstance> {
-    const Factory = await this.loadFactory();
-
-    const agentProvider = options.model ?? "claude-code";
-    const handle = await Factory.spawn(agentProvider, {
-      permissionMode: options.permissionMode ?? "auto-approve",
-      agentType: options.agentType,
-      env: options.env,
-    });
-
-    const session = await handle.createSession(options.cwd ?? process.cwd());
-
-    const id = `acp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    let running = true;
-
-    const instance: AgentInstance = {
-      id,
-      name: options.name,
-
-      isRunning(): boolean {
-        return running;
-      },
-
-      async *sendPrompt(prompt: string): AsyncIterable<AgentUpdate> {
-        try {
-          running = true;
-          for await (const update of session.prompt(prompt)) {
-            if (
-              update.sessionUpdate === "agent_message_chunk" &&
-              update.content?.type === "text"
-            ) {
-              yield { type: "text", content: update.content.text };
-            } else if (update.sessionUpdate === "tool_call") {
-              yield {
-                type: "tool_call",
-                content: update.toolName ?? "unknown tool",
-              };
-            } else if (update.sessionUpdate === "agent_thought_chunk") {
-              yield { type: "thought", content: update.content?.text ?? "" };
-            }
-          }
-          yield { type: "done", content: "" };
-        } catch (err: any) {
-          yield { type: "error", content: err.message ?? String(err) };
-        } finally {
-          running = false;
-        }
-      },
-
-      async shutdown(): Promise<void> {
-        running = false;
-        await handle.close();
-      },
-    };
-
-    this.agents.set(id, instance);
-    return instance;
-  }
-
-  async shutdown(agentId: string): Promise<void> {
-    const agent = this.agents.get(agentId);
-    if (agent) {
-      await agent.shutdown();
-      this.agents.delete(agentId);
-    }
-  }
-
-  list(): AgentInstance[] {
-    return Array.from(this.agents.values());
-  }
-}

package/references/openteams/src/spawner/interface.ts

@@ -1,31 +0,0 @@
-import type { AgentSpawner } from "../types";
-
-let currentSpawner: AgentSpawner | null = null;
-
-/**
- * @deprecated Use dependency injection instead. Pass spawner instances directly
- * to services/commands that need them (e.g. `new AgentService(db, spawner)`).
- */
-export function setSpawner(spawner: AgentSpawner): void {
-  currentSpawner = spawner;
-}
-
-/**
- * @deprecated Use dependency injection instead. Pass spawner instances directly
- * to services/commands that need them (e.g. `new AgentService(db, spawner)`).
- */
-export function getSpawner(): AgentSpawner {
-  if (!currentSpawner) {
-    throw new Error(
-      "No agent spawner configured. Call setSpawner() or use dependency injection instead."
-    );
-  }
-  return currentSpawner;
-}
-
-/**
- * @deprecated Use dependency injection instead.
- */
-export function hasSpawner(): boolean {
-  return currentSpawner !== null;
-}

package/references/openteams/src/spawner/mock.test.ts

@@ -1,93 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { MockSpawner } from "./mock";
-
-describe("MockSpawner", () => {
-  let spawner: MockSpawner;
-
-  beforeEach(() => {
-    spawner = new MockSpawner();
-  });
-
-  it("spawns a mock agent", async () => {
-    const instance = await spawner.spawn({
-      name: "test-agent",
-      teamName: "test-team",
-      prompt: "Do testing",
-    });
-
-    expect(instance.id).toMatch(/^mock-/);
-    expect(instance.name).toBe("test-agent");
-    expect(instance.isRunning()).toBe(true);
-  });
-
-  it("records spawn calls", async () => {
-    await spawner.spawn({
-      name: "a",
-      teamName: "team",
-      prompt: "Prompt A",
-    });
-    await spawner.spawn({
-      name: "b",
-      teamName: "team",
-      prompt: "Prompt B",
-    });
-
-    expect(spawner.spawnCalls).toHaveLength(2);
-    expect(spawner.spawnCalls[0].name).toBe("a");
-    expect(spawner.spawnCalls[1].name).toBe("b");
-  });
-
-  it("sends mock prompt responses", async () => {
-    const instance = await spawner.spawn({
-      name: "test",
-      teamName: "team",
-      prompt: "Init",
-    });
-
-    const updates = [];
-    for await (const update of instance.sendPrompt("Hello")) {
-      updates.push(update);
-    }
-
-    expect(updates).toHaveLength(2);
-    expect(updates[0].type).toBe("text");
-    expect(updates[0].content).toContain("Hello");
-    expect(updates[1].type).toBe("done");
-  });
-
-  it("shuts down an agent", async () => {
-    const instance = await spawner.spawn({
-      name: "test",
-      teamName: "team",
-      prompt: "Init",
-    });
-
-    await spawner.shutdown(instance.id);
-    expect(instance.isRunning()).toBe(false);
-    expect(spawner.shutdownCalls).toEqual([instance.id]);
-  });
-
-  it("lists active agents", async () => {
-    await spawner.spawn({ name: "a", teamName: "t", prompt: "P" });
-    await spawner.spawn({ name: "b", teamName: "t", prompt: "P" });
-
-    expect(spawner.list()).toHaveLength(2);
-  });
-
-  it("removes agent from list on shutdown", async () => {
-    const a = await spawner.spawn({ name: "a", teamName: "t", prompt: "P" });
-    await spawner.spawn({ name: "b", teamName: "t", prompt: "P" });
-
-    await spawner.shutdown(a.id);
-    expect(spawner.list()).toHaveLength(1);
-  });
-
-  it("resets all state", async () => {
-    await spawner.spawn({ name: "a", teamName: "t", prompt: "P" });
-    spawner.reset();
-
-    expect(spawner.list()).toHaveLength(0);
-    expect(spawner.spawnCalls).toHaveLength(0);
-    expect(spawner.shutdownCalls).toHaveLength(0);
-  });
-});