macro-agent 0.1.0 → 0.1.2

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

@@ -0,0 +1,239 @@
+import type Database from "better-sqlite3";
+import type {
+  Task,
+  TaskRow,
+  TaskSummary,
+  CreateTaskOptions,
+  UpdateTaskOptions,
+  TaskStatus,
+} from "../types";
+
+function rowToTask(row: TaskRow): Task {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}"),
+  };
+}
+
+export class TaskService {
+  constructor(private db: Database.Database) {}
+
+  private assertTeamExists(teamName: string): void {
+    const row = this.db
+      .prepare("SELECT name FROM teams WHERE name = ? AND status = 'active'")
+      .get(teamName) as { name: string } | undefined;
+    if (!row) {
+      throw new Error(`Team "${teamName}" not found`);
+    }
+  }
+
+  create(options: CreateTaskOptions): Task {
+    this.assertTeamExists(options.teamName);
+
+    const result = this.db
+      .prepare(
+        `INSERT INTO tasks (team_name, subject, description, active_form, metadata)
+         VALUES (?, ?, ?, ?, ?)`
+      )
+      .run(
+        options.teamName,
+        options.subject,
+        options.description,
+        options.activeForm ?? null,
+        JSON.stringify(options.metadata ?? {})
+      );
+
+    const taskId = Number(result.lastInsertRowid);
+
+    if (options.blockedBy && options.blockedBy.length > 0) {
+      if (options.blockedBy.includes(taskId)) {
+        throw new Error(
+          `Adding dependency would create a cycle: task #${taskId} cannot block itself`
+        );
+      }
+      const insertDep = this.db.prepare(
+        "INSERT INTO task_deps (task_id, blocked_by) VALUES (?, ?)"
+      );
+      for (const depId of options.blockedBy) {
+        insertDep.run(taskId, depId);
+      }
+    }
+
+    return this.get(options.teamName, taskId)!;
+  }
+
+  get(teamName: string, taskId: number): Task | null {
+    const row = this.db
+      .prepare("SELECT * FROM tasks WHERE id = ? AND team_name = ?")
+      .get(taskId, teamName) as TaskRow | undefined;
+    return row ? rowToTask(row) : null;
+  }
+
+  list(
+    teamName: string,
+    filters?: { status?: TaskStatus; owner?: string }
+  ): TaskSummary[] {
+    let sql = "SELECT id, subject, status, owner FROM tasks WHERE team_name = ? AND status != 'deleted'";
+    const params: any[] = [teamName];
+
+    if (filters?.status) {
+      sql += " AND status = ?";
+      params.push(filters.status);
+    }
+    if (filters?.owner) {
+      sql += " AND owner = ?";
+      params.push(filters.owner);
+    }
+
+    sql += " ORDER BY id ASC";
+
+    const rows = this.db.prepare(sql).all(...params) as Array<{
+      id: number;
+      subject: string;
+      status: TaskStatus;
+      owner: string | null;
+    }>;
+
+    return rows.map((row) => ({
+      ...row,
+      blockedBy: this.getBlockedBy(row.id),
+    }));
+  }
+
+  update(teamName: string, taskId: number, options: UpdateTaskOptions): Task {
+    const task = this.get(teamName, taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found in team "${teamName}"`);
+    }
+
+    const sets: string[] = [];
+    const params: any[] = [];
+
+    if (options.status !== undefined) {
+      sets.push("status = ?");
+      params.push(options.status);
+    }
+    if (options.subject !== undefined) {
+      sets.push("subject = ?");
+      params.push(options.subject);
+    }
+    if (options.description !== undefined) {
+      sets.push("description = ?");
+      params.push(options.description);
+    }
+    if (options.activeForm !== undefined) {
+      sets.push("active_form = ?");
+      params.push(options.activeForm);
+    }
+    if (options.owner !== undefined) {
+      sets.push("owner = ?");
+      params.push(options.owner);
+    }
+    if (options.metadata !== undefined) {
+      const merged = { ...task.metadata, ...options.metadata };
+      // Remove keys set to null
+      for (const [k, v] of Object.entries(merged)) {
+        if (v === null) delete merged[k];
+      }
+      sets.push("metadata = ?");
+      params.push(JSON.stringify(merged));
+    }
+
+    if (sets.length > 0) {
+      sets.push("updated_at = datetime('now')");
+      params.push(taskId, teamName);
+      this.db
+        .prepare(
+          `UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND team_name = ?`
+        )
+        .run(...params);
+    }
+
+    if (options.addBlockedBy && options.addBlockedBy.length > 0) {
+      for (const depId of options.addBlockedBy) {
+        this.assertNoCycle(taskId, depId);
+      }
+      const insertDep = this.db.prepare(
+        "INSERT OR IGNORE INTO task_deps (task_id, blocked_by) VALUES (?, ?)"
+      );
+      for (const depId of options.addBlockedBy) {
+        insertDep.run(taskId, depId);
+      }
+    }
+
+    if (options.addBlocks && options.addBlocks.length > 0) {
+      for (const blockedTaskId of options.addBlocks) {
+        this.assertNoCycle(blockedTaskId, taskId);
+      }
+      const insertDep = this.db.prepare(
+        "INSERT OR IGNORE INTO task_deps (task_id, blocked_by) VALUES (?, ?)"
+      );
+      for (const blockedTaskId of options.addBlocks) {
+        insertDep.run(blockedTaskId, taskId);
+      }
+    }
+
+    return this.get(teamName, taskId)!;
+  }
+
+  getBlockedBy(taskId: number): number[] {
+    const rows = this.db
+      .prepare("SELECT blocked_by FROM task_deps WHERE task_id = ?")
+      .all(taskId) as Array<{ blocked_by: number }>;
+    return rows.map((r) => r.blocked_by);
+  }
+
+  getBlocks(taskId: number): number[] {
+    const rows = this.db
+      .prepare("SELECT task_id FROM task_deps WHERE blocked_by = ?")
+      .all(taskId) as Array<{ task_id: number }>;
+    return rows.map((r) => r.task_id);
+  }
+
+  /**
+   * Check if adding edge (taskId blocked_by depId) would create a cycle.
+   * Follows blocked_by edges from depId to see if it reaches taskId.
+   */
+  private assertNoCycle(taskId: number, depId: number): void {
+    if (taskId === depId) {
+      throw new Error(
+        `Adding dependency would create a cycle: task #${taskId} cannot block itself`
+      );
+    }
+
+    const visited = new Set<number>();
+    const queue = [depId];
+
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      if (current === taskId) {
+        throw new Error(
+          `Adding dependency would create a cycle: task #${taskId} -> #${depId} creates a circular dependency`
+        );
+      }
+      if (visited.has(current)) continue;
+      visited.add(current);
+
+      const deps = this.getBlockedBy(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+
+  isBlocked(taskId: number): boolean {
+    const deps = this.getBlockedBy(taskId);
+    if (deps.length === 0) return false;
+
+    const placeholders = deps.map(() => "?").join(",");
+    const row = this.db
+      .prepare(
+        `SELECT COUNT(*) as count FROM tasks WHERE id IN (${placeholders}) AND status != 'completed'`
+      )
+      .get(...deps) as { count: number };
+
+    return row.count > 0;
+  }
+}

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

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import type Database from "better-sqlite3";
+import { createInMemoryDatabase } from "../db/database";
+import { TeamService } from "./team-service";
+
+describe("TeamService", () => {
+  let db: Database.Database;
+  let service: TeamService;
+
+  beforeEach(() => {
+    db = createInMemoryDatabase();
+    service = new TeamService(db);
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe("create", () => {
+    it("creates a team with name only", () => {
+      const team = service.create({ name: "test-team" });
+      expect(team.name).toBe("test-team");
+      expect(team.description).toBeNull();
+      expect(team.agent_type).toBeNull();
+      expect(team.status).toBe("active");
+    });
+
+    it("creates a team with description and agent type", () => {
+      const team = service.create({
+        name: "my-project",
+        description: "A test project",
+        agentType: "general-purpose",
+      });
+      expect(team.name).toBe("my-project");
+      expect(team.description).toBe("A test project");
+      expect(team.agent_type).toBe("general-purpose");
+    });
+
+    it("throws on duplicate team name", () => {
+      service.create({ name: "dup" });
+      expect(() => service.create({ name: "dup" })).toThrow(
+        'Team "dup" already exists'
+      );
+    });
+  });
+
+  describe("get", () => {
+    it("returns null for nonexistent team", () => {
+      expect(service.get("nope")).toBeNull();
+    });
+
+    it("returns the team by name", () => {
+      service.create({ name: "findme" });
+      const team = service.get("findme");
+      expect(team).not.toBeNull();
+      expect(team!.name).toBe("findme");
+    });
+
+    it("does not return deleted teams", () => {
+      service.create({ name: "gone" });
+      service.delete("gone");
+      expect(service.get("gone")).toBeNull();
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no teams", () => {
+      expect(service.list()).toEqual([]);
+    });
+
+    it("returns active teams", () => {
+      service.create({ name: "a" });
+      service.create({ name: "b" });
+      const teams = service.list();
+      expect(teams).toHaveLength(2);
+    });
+
+    it("excludes deleted teams", () => {
+      service.create({ name: "keep" });
+      service.create({ name: "remove" });
+      service.delete("remove");
+      const teams = service.list();
+      expect(teams).toHaveLength(1);
+      expect(teams[0].name).toBe("keep");
+    });
+  });
+
+  describe("delete", () => {
+    it("soft-deletes a team", () => {
+      service.create({ name: "deleteme" });
+      service.delete("deleteme");
+      expect(service.get("deleteme")).toBeNull();
+    });
+
+    it("throws when team not found", () => {
+      expect(() => service.delete("nope")).toThrow('Team "nope" not found');
+    });
+
+    it("throws when team has active members", () => {
+      service.create({ name: "busy" });
+      service.addMember("busy", "agent1");
+      expect(() => service.delete("busy")).toThrow("active member");
+    });
+
+    it("allows delete when all members are shut down", () => {
+      service.create({ name: "done" });
+      service.addMember("done", "agent1");
+      service.updateMemberStatus("done", "agent1", "shutdown");
+      service.delete("done");
+      expect(service.get("done")).toBeNull();
+    });
+  });
+
+  describe("members", () => {
+    it("adds a member to a team", () => {
+      service.create({ name: "team1" });
+      const member = service.addMember("team1", "researcher");
+      expect(member.agent_name).toBe("researcher");
+      expect(member.team_name).toBe("team1");
+      expect(member.status).toBe("idle");
+      expect(member.agent_type).toBe("general-purpose");
+    });
+
+    it("adds a member with options", () => {
+      service.create({ name: "team1" });
+      const member = service.addMember("team1", "coder", {
+        agentId: "abc-123",
+        agentType: "bash",
+        spawnPrompt: "Run tests",
+        model: "sonnet",
+      });
+      expect(member.agent_id).toBe("abc-123");
+      expect(member.agent_type).toBe("bash");
+      expect(member.spawn_prompt).toBe("Run tests");
+      expect(member.model).toBe("sonnet");
+    });
+
+    it("throws when adding member to nonexistent team", () => {
+      expect(() => service.addMember("nope", "agent")).toThrow(
+        'Team "nope" not found'
+      );
+    });
+
+    it("lists members", () => {
+      service.create({ name: "team1" });
+      service.addMember("team1", "a");
+      service.addMember("team1", "b");
+      const members = service.listMembers("team1");
+      expect(members).toHaveLength(2);
+    });
+
+    it("gets a specific member", () => {
+      service.create({ name: "team1" });
+      service.addMember("team1", "finder");
+      const member = service.getMember("team1", "finder");
+      expect(member).not.toBeNull();
+      expect(member!.agent_name).toBe("finder");
+    });
+
+    it("returns null for nonexistent member", () => {
+      service.create({ name: "team1" });
+      expect(service.getMember("team1", "nope")).toBeNull();
+    });
+
+    it("updates member status", () => {
+      service.create({ name: "team1" });
+      service.addMember("team1", "worker");
+      service.updateMemberStatus("team1", "worker", "running");
+      const member = service.getMember("team1", "worker");
+      expect(member!.status).toBe("running");
+    });
+
+    it("updates member agent id", () => {
+      service.create({ name: "team1" });
+      service.addMember("team1", "worker");
+      service.updateMemberAgentId("team1", "worker", "new-id-123");
+      const member = service.getMember("team1", "worker");
+      expect(member!.agent_id).toBe("new-id-123");
+    });
+  });
+});

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

@@ -0,0 +1,139 @@
+import type Database from "better-sqlite3";
+import type { Team, CreateTeamOptions, Member, MemberStatus } from "../types";
+
+export class TeamService {
+  constructor(private db: Database.Database) {}
+
+  create(options: CreateTeamOptions): Team {
+    const existing = this.db
+      .prepare("SELECT name FROM teams WHERE name = ? AND status = 'active'")
+      .get(options.name) as { name: string } | undefined;
+
+    if (existing) {
+      throw new Error(`Team "${options.name}" already exists`);
+    }
+
+    this.db
+      .prepare(
+        "INSERT INTO teams (name, description, agent_type, template_name, template_path) VALUES (?, ?, ?, ?, ?)"
+      )
+      .run(
+        options.name,
+        options.description ?? null,
+        options.agentType ?? null,
+        options.templateName ?? null,
+        options.templatePath ?? null
+      );
+
+    return this.get(options.name)!;
+  }
+
+  get(name: string): Team | null {
+    const row = this.db
+      .prepare("SELECT * FROM teams WHERE name = ? AND status = 'active'")
+      .get(name) as Team | undefined;
+    return row ?? null;
+  }
+
+  list(): Team[] {
+    return this.db
+      .prepare("SELECT * FROM teams WHERE status = 'active' ORDER BY created_at DESC")
+      .all() as Team[];
+  }
+
+  delete(name: string): void {
+    const team = this.get(name);
+    if (!team) {
+      throw new Error(`Team "${name}" not found`);
+    }
+
+    const activeMembers = this.db
+      .prepare(
+        "SELECT COUNT(*) as count FROM members WHERE team_name = ? AND status != 'shutdown'"
+      )
+      .get(name) as { count: number };
+
+    if (activeMembers.count > 0) {
+      throw new Error(
+        `Team "${name}" still has ${activeMembers.count} active member(s). Shut them down first.`
+      );
+    }
+
+    this.db
+      .prepare("UPDATE teams SET status = 'deleted' WHERE name = ?")
+      .run(name);
+  }
+
+  addMember(
+    teamName: string,
+    agentName: string,
+    options?: {
+      agentId?: string;
+      agentType?: string;
+      role?: string;
+      spawnPrompt?: string;
+      model?: string;
+    }
+  ): Member {
+    const team = this.get(teamName);
+    if (!team) {
+      throw new Error(`Team "${teamName}" not found`);
+    }
+
+    this.db
+      .prepare(
+        `INSERT INTO members (team_name, agent_name, agent_id, agent_type, role, spawn_prompt, model)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        teamName,
+        agentName,
+        options?.agentId ?? null,
+        options?.agentType ?? "general-purpose",
+        options?.role ?? null,
+        options?.spawnPrompt ?? null,
+        options?.model ?? null
+      );
+
+    return this.getMember(teamName, agentName)!;
+  }
+
+  getMember(teamName: string, agentName: string): Member | null {
+    const row = this.db
+      .prepare(
+        "SELECT * FROM members WHERE team_name = ? AND agent_name = ?"
+      )
+      .get(teamName, agentName) as Member | undefined;
+    return row ?? null;
+  }
+
+  listMembers(teamName: string): Member[] {
+    return this.db
+      .prepare("SELECT * FROM members WHERE team_name = ? ORDER BY created_at")
+      .all(teamName) as Member[];
+  }
+
+  updateMemberStatus(
+    teamName: string,
+    agentName: string,
+    status: MemberStatus
+  ): void {
+    this.db
+      .prepare(
+        "UPDATE members SET status = ? WHERE team_name = ? AND agent_name = ?"
+      )
+      .run(status, teamName, agentName);
+  }
+
+  updateMemberAgentId(
+    teamName: string,
+    agentName: string,
+    agentId: string
+  ): void {
+    this.db
+      .prepare(
+        "UPDATE members SET agent_id = ? WHERE team_name = ? AND agent_name = ?"
+      )
+      .run(agentId, teamName, agentName);
+  }
+}