macro-agent 0.1.1 → 0.1.2

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

@@ -0,0 +1,203 @@
+import type Database from "better-sqlite3";
+import type {
+  Message,
+  MessageRow,
+  SendMessageOptions,
+  BroadcastMessageOptions,
+  ShutdownRequestOptions,
+  ShutdownResponseOptions,
+  PlanApprovalResponseOptions,
+} from "../types";
+import { randomUUID } from "crypto";
+
+function rowToMessage(row: MessageRow): Message {
+  return {
+    ...row,
+    approve: row.approve === null ? null : row.approve === 1,
+    delivered: row.delivered === 1,
+  };
+}
+
+export class MessageService {
+  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`);
+    }
+  }
+
+  private assertMemberExists(teamName: string, agentName: string): void {
+    const row = this.db
+      .prepare(
+        "SELECT agent_name FROM members WHERE team_name = ? AND agent_name = ?"
+      )
+      .get(teamName, agentName) as { agent_name: string } | undefined;
+    if (!row) {
+      throw new Error(
+        `Agent "${agentName}" is not a member of team "${teamName}"`
+      );
+    }
+  }
+
+  send(options: SendMessageOptions): Message {
+    this.assertTeamExists(options.teamName);
+    this.assertMemberExists(options.teamName, options.recipient);
+
+    const result = this.db
+      .prepare(
+        `INSERT INTO messages (team_name, type, sender, recipient, content, summary)
+         VALUES (?, 'message', ?, ?, ?, ?)`
+      )
+      .run(
+        options.teamName,
+        options.sender,
+        options.recipient,
+        options.content,
+        options.summary
+      );
+
+    return this.getById(Number(result.lastInsertRowid))!;
+  }
+
+  broadcast(options: BroadcastMessageOptions): Message[] {
+    this.assertTeamExists(options.teamName);
+
+    const members = this.db
+      .prepare(
+        "SELECT agent_name FROM members WHERE team_name = ? AND status != 'shutdown'"
+      )
+      .all(options.teamName) as Array<{ agent_name: string }>;
+
+    const messages: Message[] = [];
+    for (const member of members) {
+      if (member.agent_name === options.sender) continue;
+
+      const result = this.db
+        .prepare(
+          `INSERT INTO messages (team_name, type, sender, recipient, content, summary)
+           VALUES (?, 'broadcast', ?, ?, ?, ?)`
+        )
+        .run(
+          options.teamName,
+          options.sender,
+          member.agent_name,
+          options.content,
+          options.summary
+        );
+
+      messages.push(this.getById(Number(result.lastInsertRowid))!);
+    }
+
+    return messages;
+  }
+
+  sendShutdownRequest(options: ShutdownRequestOptions): Message {
+    this.assertTeamExists(options.teamName);
+    this.assertMemberExists(options.teamName, options.recipient);
+
+    const requestId = randomUUID();
+    const result = this.db
+      .prepare(
+        `INSERT INTO messages (team_name, type, sender, recipient, content, request_id)
+         VALUES (?, 'shutdown_request', ?, ?, ?, ?)`
+      )
+      .run(
+        options.teamName,
+        options.sender,
+        options.recipient,
+        options.reason ?? "Shutdown requested",
+        requestId
+      );
+
+    return this.getById(Number(result.lastInsertRowid))!;
+  }
+
+  sendShutdownResponse(options: ShutdownResponseOptions): Message {
+    const result = this.db
+      .prepare(
+        `INSERT INTO messages (team_name, type, sender, content, request_id, approve)
+         VALUES (?, 'shutdown_response', ?, ?, ?, ?)`
+      )
+      .run(
+        options.teamName,
+        options.sender,
+        options.content ?? (options.approve ? "Shutting down" : "Rejecting shutdown"),
+        options.requestId,
+        options.approve ? 1 : 0
+      );
+
+    return this.getById(Number(result.lastInsertRowid))!;
+  }
+
+  sendPlanApprovalResponse(options: PlanApprovalResponseOptions): Message {
+    this.assertTeamExists(options.teamName);
+    this.assertMemberExists(options.teamName, options.recipient);
+
+    const result = this.db
+      .prepare(
+        `INSERT INTO messages (team_name, type, sender, recipient, content, request_id, approve)
+         VALUES (?, 'plan_approval_response', ?, ?, ?, ?, ?)`
+      )
+      .run(
+        options.teamName,
+        options.sender,
+        options.recipient,
+        options.content ?? (options.approve ? "Plan approved" : "Plan rejected"),
+        options.requestId,
+        options.approve ? 1 : 0
+      );
+
+    return this.getById(Number(result.lastInsertRowid))!;
+  }
+
+  listForAgent(teamName: string, agentName: string): Message[] {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM messages
+         WHERE team_name = ? AND (recipient = ? OR sender = ?)
+         ORDER BY created_at ASC`
+      )
+      .all(teamName, agentName, agentName) as MessageRow[];
+
+    return rows.map(rowToMessage);
+  }
+
+  listForTeam(teamName: string): Message[] {
+    const rows = this.db
+      .prepare(
+        "SELECT * FROM messages WHERE team_name = ? ORDER BY created_at ASC"
+      )
+      .all(teamName) as MessageRow[];
+
+    return rows.map(rowToMessage);
+  }
+
+  getUndelivered(teamName: string, agentName: string): Message[] {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM messages
+         WHERE team_name = ? AND recipient = ? AND delivered = 0
+         ORDER BY created_at ASC`
+      )
+      .all(teamName, agentName) as MessageRow[];
+
+    return rows.map(rowToMessage);
+  }
+
+  markDelivered(messageId: number): void {
+    this.db
+      .prepare("UPDATE messages SET delivered = 1 WHERE id = ?")
+      .run(messageId);
+  }
+
+  private getById(id: number): Message | null {
+    const row = this.db
+      .prepare("SELECT * FROM messages WHERE id = ?")
+      .get(id) as MessageRow | undefined;
+    return row ? rowToMessage(row) : null;
+  }
+}

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

@@ -0,0 +1,434 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import type Database from "better-sqlite3";
+import { createInMemoryDatabase } from "../db/database";
+import { TaskService } from "./task-service";
+import { TeamService } from "./team-service";
+
+describe("TaskService", () => {
+  let db: Database.Database;
+  let taskService: TaskService;
+  let teamService: TeamService;
+
+  beforeEach(() => {
+    db = createInMemoryDatabase();
+    taskService = new TaskService(db);
+    teamService = new TeamService(db);
+    teamService.create({ name: "test-team" });
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe("create", () => {
+    it("creates a task with required fields", () => {
+      const task = taskService.create({
+        teamName: "test-team",
+        subject: "Fix bug",
+        description: "There is a bug in auth",
+      });
+      expect(task.id).toBeGreaterThan(0);
+      expect(task.subject).toBe("Fix bug");
+      expect(task.description).toBe("There is a bug in auth");
+      expect(task.status).toBe("pending");
+      expect(task.owner).toBeNull();
+    });
+
+    it("throws when team does not exist", () => {
+      expect(() =>
+        taskService.create({
+          teamName: "nonexistent",
+          subject: "Test",
+          description: "D",
+        })
+      ).toThrow('Team "nonexistent" not found');
+    });
+
+    it("creates a task with all optional fields", () => {
+      const task = taskService.create({
+        teamName: "test-team",
+        subject: "Add feature",
+        description: "Add dark mode",
+        activeForm: "Adding dark mode",
+        metadata: { priority: "high" },
+      });
+      expect(task.active_form).toBe("Adding dark mode");
+      expect(task.metadata).toEqual({ priority: "high" });
+    });
+
+    it("creates a task with blockedBy dependencies", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "Task 1",
+        description: "First task",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "Task 2",
+        description: "Depends on task 1",
+        blockedBy: [t1.id],
+      });
+      const blockedBy = taskService.getBlockedBy(t2.id);
+      expect(blockedBy).toEqual([t1.id]);
+    });
+  });
+
+  describe("get", () => {
+    it("returns null for nonexistent task", () => {
+      expect(taskService.get("test-team", 999)).toBeNull();
+    });
+
+    it("returns the task with parsed metadata", () => {
+      const created = taskService.create({
+        teamName: "test-team",
+        subject: "Test",
+        description: "Desc",
+        metadata: { key: "value" },
+      });
+      const task = taskService.get("test-team", created.id);
+      expect(task).not.toBeNull();
+      expect(task!.metadata).toEqual({ key: "value" });
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no tasks", () => {
+      expect(taskService.list("test-team")).toEqual([]);
+    });
+
+    it("returns task summaries with blockedBy", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "Task 1",
+        description: "D1",
+      });
+      taskService.create({
+        teamName: "test-team",
+        subject: "Task 2",
+        description: "D2",
+        blockedBy: [t1.id],
+      });
+
+      const list = taskService.list("test-team");
+      expect(list).toHaveLength(2);
+      expect(list[0].blockedBy).toEqual([]);
+      expect(list[1].blockedBy).toEqual([t1.id]);
+    });
+
+    it("filters by status", () => {
+      taskService.create({
+        teamName: "test-team",
+        subject: "Pending",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "Done",
+        description: "D",
+      });
+      taskService.update("test-team", t2.id, { status: "completed" });
+
+      const pending = taskService.list("test-team", { status: "pending" });
+      expect(pending).toHaveLength(1);
+      expect(pending[0].subject).toBe("Pending");
+    });
+
+    it("filters by owner", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "Mine",
+        description: "D",
+      });
+      taskService.create({
+        teamName: "test-team",
+        subject: "Yours",
+        description: "D",
+      });
+      taskService.update("test-team", t1.id, { owner: "alice" });
+
+      const list = taskService.list("test-team", { owner: "alice" });
+      expect(list).toHaveLength(1);
+      expect(list[0].subject).toBe("Mine");
+    });
+
+    it("excludes deleted tasks", () => {
+      const t = taskService.create({
+        teamName: "test-team",
+        subject: "Gone",
+        description: "D",
+      });
+      taskService.update("test-team", t.id, { status: "deleted" });
+      expect(taskService.list("test-team")).toHaveLength(0);
+    });
+  });
+
+  describe("update", () => {
+    it("updates status", () => {
+      const t = taskService.create({
+        teamName: "test-team",
+        subject: "Task",
+        description: "D",
+      });
+      const updated = taskService.update("test-team", t.id, {
+        status: "in_progress",
+      });
+      expect(updated.status).toBe("in_progress");
+    });
+
+    it("updates owner", () => {
+      const t = taskService.create({
+        teamName: "test-team",
+        subject: "Task",
+        description: "D",
+      });
+      const updated = taskService.update("test-team", t.id, {
+        owner: "bob",
+      });
+      expect(updated.owner).toBe("bob");
+    });
+
+    it("updates subject and description", () => {
+      const t = taskService.create({
+        teamName: "test-team",
+        subject: "Old",
+        description: "Old desc",
+      });
+      const updated = taskService.update("test-team", t.id, {
+        subject: "New",
+        description: "New desc",
+      });
+      expect(updated.subject).toBe("New");
+      expect(updated.description).toBe("New desc");
+    });
+
+    it("merges metadata and removes null keys", () => {
+      const t = taskService.create({
+        teamName: "test-team",
+        subject: "Task",
+        description: "D",
+        metadata: { a: 1, b: 2 },
+      });
+      const updated = taskService.update("test-team", t.id, {
+        metadata: { b: null, c: 3 } as any,
+      });
+      expect(updated.metadata).toEqual({ a: 1, c: 3 });
+    });
+
+    it("adds blockedBy dependencies", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+      });
+      taskService.update("test-team", t2.id, { addBlockedBy: [t1.id] });
+      expect(taskService.getBlockedBy(t2.id)).toEqual([t1.id]);
+    });
+
+    it("adds blocks dependencies", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+      });
+      taskService.update("test-team", t1.id, { addBlocks: [t2.id] });
+      expect(taskService.getBlockedBy(t2.id)).toEqual([t1.id]);
+      expect(taskService.getBlocks(t1.id)).toEqual([t2.id]);
+    });
+
+    it("throws for nonexistent task", () => {
+      expect(() =>
+        taskService.update("test-team", 999, { status: "completed" })
+      ).toThrow("Task 999 not found");
+    });
+  });
+
+  describe("dependencies", () => {
+    it("getBlockedBy returns blocking task ids", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+      });
+      const t3 = taskService.create({
+        teamName: "test-team",
+        subject: "T3",
+        description: "D",
+        blockedBy: [t1.id, t2.id],
+      });
+      expect(taskService.getBlockedBy(t3.id)).toEqual([t1.id, t2.id]);
+    });
+
+    it("getBlocks returns tasks this task blocks", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      taskService.create({
+        teamName: "test-team",
+        subject: "T3",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      const blocks = taskService.getBlocks(t1.id);
+      expect(blocks).toHaveLength(2);
+    });
+
+    it("isBlocked returns true when dependencies are not completed", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      expect(taskService.isBlocked(t2.id)).toBe(true);
+    });
+
+    it("isBlocked returns false when all dependencies are completed", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      taskService.update("test-team", t1.id, { status: "completed" });
+      expect(taskService.isBlocked(t2.id)).toBe(false);
+    });
+
+    it("isBlocked returns false when no dependencies", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      expect(taskService.isBlocked(t1.id)).toBe(false);
+    });
+  });
+
+  describe("cycle detection", () => {
+    it("detects direct self-dependency via addBlockedBy", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      expect(() =>
+        taskService.update("test-team", t1.id, { addBlockedBy: [t1.id] })
+      ).toThrow("cycle");
+    });
+
+    it("detects circular dependency via addBlockedBy", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      // t2 is blocked by t1. Now trying to make t1 blocked by t2 → cycle
+      expect(() =>
+        taskService.update("test-team", t1.id, { addBlockedBy: [t2.id] })
+      ).toThrow("cycle");
+    });
+
+    it("detects transitive cycle via addBlockedBy", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      const t3 = taskService.create({
+        teamName: "test-team",
+        subject: "T3",
+        description: "D",
+        blockedBy: [t2.id],
+      });
+      // t3 -> t2 -> t1. Now trying to make t1 blocked by t3 → cycle
+      expect(() =>
+        taskService.update("test-team", t1.id, { addBlockedBy: [t3.id] })
+      ).toThrow("cycle");
+    });
+
+    it("detects cycle via addBlocks", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      // t2 blocked by t1. addBlocks t2 → [t1] means t1 is blocked by t2 → cycle
+      expect(() =>
+        taskService.update("test-team", t2.id, { addBlocks: [t1.id] })
+      ).toThrow("cycle");
+    });
+
+    it("allows valid non-cyclic dependencies", () => {
+      const t1 = taskService.create({
+        teamName: "test-team",
+        subject: "T1",
+        description: "D",
+      });
+      const t2 = taskService.create({
+        teamName: "test-team",
+        subject: "T2",
+        description: "D",
+      });
+      const t3 = taskService.create({
+        teamName: "test-team",
+        subject: "T3",
+        description: "D",
+        blockedBy: [t1.id],
+      });
+      // t3 -> t1. Adding t3 -> t2 is fine (no cycle)
+      expect(() =>
+        taskService.update("test-team", t3.id, { addBlockedBy: [t2.id] })
+      ).not.toThrow();
+    });
+  });
+});