macro-agent 0.1.1 → 0.1.2

package/references/openteams/src/cli/message.ts

@@ -0,0 +1,241 @@
+import { Command } from "commander";
+import { MessageService } from "../services/message-service";
+import type { Message } from "../types";
+import type Database from "better-sqlite3";
+
+function messageToJson(m: Message) {
+  return {
+    id: m.id,
+    team_name: m.team_name,
+    type: m.type,
+    sender: m.sender,
+    recipient: m.recipient,
+    content: m.content,
+    summary: m.summary,
+    request_id: m.request_id,
+    approve: m.approve,
+    delivered: m.delivered,
+    created_at: m.created_at,
+  };
+}
+
+export function createMessageCommands(db: Database.Database): Command {
+  const messageService = new MessageService(db);
+  const message = new Command("message").description("Send and view messages");
+
+  message
+    .command("send <team>")
+    .description("Send a direct message to a teammate")
+    .requiredOption("--to <recipient>", "Recipient agent name")
+    .requiredOption("--content <content>", "Message content")
+    .requiredOption("--summary <summary>", "Short summary (5-10 words)")
+    .option("--from <sender>", "Sender name", "lead")
+    .action((team: string, opts) => {
+      try {
+        const msg = messageService.send({
+          teamName: team,
+          sender: opts.from,
+          recipient: opts.to,
+          content: opts.content,
+          summary: opts.summary,
+        });
+        console.log(`Message #${msg.id} sent to ${opts.to}.`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("broadcast <team>")
+    .description("Broadcast a message to all teammates")
+    .requiredOption("--content <content>", "Message content")
+    .requiredOption("--summary <summary>", "Short summary (5-10 words)")
+    .option("--from <sender>", "Sender name", "lead")
+    .action((team: string, opts) => {
+      try {
+        const msgs = messageService.broadcast({
+          teamName: team,
+          sender: opts.from,
+          content: opts.content,
+          summary: opts.summary,
+        });
+        console.log(`Broadcast sent to ${msgs.length} teammate(s).`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("shutdown <team>")
+    .description("Send a shutdown request to a teammate")
+    .requiredOption("--to <recipient>", "Recipient agent name")
+    .option("--reason <reason>", "Reason for shutdown")
+    .option("--from <sender>", "Sender name", "lead")
+    .action((team: string, opts) => {
+      try {
+        const msg = messageService.sendShutdownRequest({
+          teamName: team,
+          sender: opts.from,
+          recipient: opts.to,
+          reason: opts.reason,
+        });
+        console.log(
+          `Shutdown request #${msg.id} sent to ${opts.to} (request_id: ${msg.request_id}).`
+        );
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("list <team>")
+    .description("List messages for a team or agent")
+    .option("--agent <name>", "Filter messages for a specific agent")
+    .option("--json", "Output as JSON")
+    .action((team: string, opts) => {
+      const msgs = opts.agent
+        ? messageService.listForAgent(team, opts.agent)
+        : messageService.listForTeam(team);
+
+      if (opts.json) {
+        console.log(JSON.stringify(msgs.map(messageToJson)));
+        return;
+      }
+
+      if (msgs.length === 0) {
+        console.log("No messages found.");
+        return;
+      }
+
+      for (const m of msgs) {
+        const to = m.recipient ? ` -> ${m.recipient}` : "";
+        const summary = m.summary ? ` (${m.summary})` : "";
+        const delivery = m.delivered ? "" : " [undelivered]";
+        console.log(
+          `  #${m.id} [${m.type}] ${m.sender}${to}${summary}${delivery}`
+        );
+        console.log(`    ${m.content}`);
+      }
+    });
+
+  message
+    .command("poll <team>")
+    .description("List undelivered messages for an agent")
+    .requiredOption("--agent <name>", "Agent name")
+    .option("--mark-delivered", "Mark messages as delivered after listing")
+    .option("--json", "Output as JSON")
+    .action((team: string, opts) => {
+      try {
+        const msgs = messageService.getUndelivered(team, opts.agent);
+
+        if (opts.json) {
+          console.log(JSON.stringify(msgs.map(messageToJson)));
+        } else if (msgs.length === 0) {
+          console.log("No undelivered messages.");
+        } else {
+          for (const m of msgs) {
+            const from = m.sender;
+            const summary = m.summary ? ` (${m.summary})` : "";
+            console.log(`  #${m.id} [${m.type}] ${from}${summary}`);
+            console.log(`    ${m.content}`);
+          }
+        }
+
+        if (opts.markDelivered) {
+          for (const m of msgs) {
+            messageService.markDelivered(m.id);
+          }
+          if (!opts.json && msgs.length > 0) {
+            console.log(`Marked ${msgs.length} message(s) as delivered.`);
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("shutdown-response <team>")
+    .description("Respond to a shutdown request")
+    .requiredOption("--request-id <id>", "Request ID from the shutdown request")
+    .option("--approve", "Approve the shutdown")
+    .option("--reject", "Reject the shutdown")
+    .option("--content <content>", "Response message")
+    .option("--from <sender>", "Sender name")
+    .action((team: string, opts) => {
+      try {
+        if (!opts.approve && !opts.reject) {
+          throw new Error("Must specify either --approve or --reject");
+        }
+        const approve = !!opts.approve;
+        const msg = messageService.sendShutdownResponse({
+          teamName: team,
+          sender: opts.from ?? "unknown",
+          requestId: opts.requestId,
+          approve,
+          content: opts.content,
+        });
+        console.log(
+          `Shutdown ${approve ? "approved" : "rejected"} (message #${msg.id}, request_id: ${msg.request_id}).`
+        );
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("plan-response <team>")
+    .description("Respond to a plan approval request")
+    .requiredOption("--to <recipient>", "Recipient agent name")
+    .requiredOption("--request-id <id>", "Request ID from the plan approval request")
+    .option("--approve", "Approve the plan")
+    .option("--reject", "Reject the plan")
+    .option("--content <content>", "Response message")
+    .option("--from <sender>", "Sender name", "lead")
+    .action((team: string, opts) => {
+      try {
+        if (!opts.approve && !opts.reject) {
+          throw new Error("Must specify either --approve or --reject");
+        }
+        const approve = !!opts.approve;
+        const msg = messageService.sendPlanApprovalResponse({
+          teamName: team,
+          sender: opts.from,
+          recipient: opts.to,
+          requestId: opts.requestId,
+          approve,
+          content: opts.content,
+        });
+        console.log(
+          `Plan ${approve ? "approved" : "rejected"} for ${opts.to} (message #${msg.id}, request_id: ${msg.request_id}).`
+        );
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  message
+    .command("ack <team> <message-id>")
+    .description("Mark a message as delivered")
+    .action((team: string, messageId: string) => {
+      try {
+        const id = parseInt(messageId, 10);
+        if (isNaN(id)) {
+          throw new Error(`Invalid message ID: "${messageId}"`);
+        }
+        messageService.markDelivered(id);
+        console.log(`Message #${id} marked as delivered.`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  return message;
+}

package/references/openteams/src/cli/task.ts

@@ -0,0 +1,154 @@
+import { Command } from "commander";
+import { TaskService } from "../services/task-service";
+import type Database from "better-sqlite3";
+import type { TaskStatus } from "../types";
+
+function parseCommaSeparatedInts(val: string): number[] {
+  return val.split(",").map((s) => {
+    const n = parseInt(s.trim(), 10);
+    if (isNaN(n)) throw new Error(`Invalid task ID: "${s.trim()}"`);
+    return n;
+  });
+}
+
+export function createTaskCommands(db: Database.Database): Command {
+  const taskService = new TaskService(db);
+  const task = new Command("task").description("Manage tasks");
+
+  task
+    .command("create <team>")
+    .description("Create a new task")
+    .requiredOption("-s, --subject <subject>", "Task subject")
+    .requiredOption("-d, --description <description>", "Task description")
+    .option("-a, --active-form <text>", "Present continuous form for display")
+    .option("--blocked-by <ids>", "Comma-separated task IDs that block this task")
+    .option("--metadata <json>", "JSON metadata object")
+    .action((team: string, opts) => {
+      try {
+        const result = taskService.create({
+          teamName: team,
+          subject: opts.subject,
+          description: opts.description,
+          activeForm: opts.activeForm,
+          blockedBy: opts.blockedBy
+            ? parseCommaSeparatedInts(opts.blockedBy)
+            : undefined,
+          metadata: opts.metadata ? JSON.parse(opts.metadata) : undefined,
+        });
+        console.log(`Task #${result.id} created: ${result.subject}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command("list <team>")
+    .description("List tasks for a team")
+    .option("--status <status>", "Filter by status")
+    .option("--owner <name>", "Filter by owner")
+    .option("--json", "Output as JSON")
+    .action((team: string, opts) => {
+      const tasks = taskService.list(team, {
+        status: opts.status as TaskStatus | undefined,
+        owner: opts.owner,
+      });
+
+      if (opts.json) {
+        console.log(JSON.stringify(tasks));
+        return;
+      }
+
+      if (tasks.length === 0) {
+        console.log("No tasks found.");
+        return;
+      }
+      for (const t of tasks) {
+        const owner = t.owner ? ` (${t.owner})` : "";
+        const blocked =
+          t.blockedBy.length > 0
+            ? ` [blocked by: ${t.blockedBy.join(", ")}]`
+            : "";
+        console.log(`  #${t.id} [${t.status}]${owner} ${t.subject}${blocked}`);
+      }
+    });
+
+  task
+    .command("get <team> <task-id>")
+    .description("Get full task details")
+    .option("--json", "Output as JSON")
+    .action((team: string, taskId: string, opts) => {
+      const id = parseInt(taskId, 10);
+      const t = taskService.get(team, id);
+      if (!t) {
+        console.error(`Error: Task #${id} not found in team "${team}".`);
+        process.exitCode = 1;
+        return;
+      }
+
+      if (opts.json) {
+        const blockedBy = taskService.getBlockedBy(t.id);
+        const blocks = taskService.getBlocks(t.id);
+        console.log(JSON.stringify({ ...t, blockedBy, blocks }));
+        return;
+      }
+
+      console.log(`Task #${t.id}: ${t.subject}`);
+      console.log(`Status: ${t.status}`);
+      if (t.owner) console.log(`Owner: ${t.owner}`);
+      if (t.active_form) console.log(`Active Form: ${t.active_form}`);
+      console.log(`Description: ${t.description}`);
+
+      const blockedBy = taskService.getBlockedBy(t.id);
+      if (blockedBy.length > 0) {
+        console.log(`Blocked By: ${blockedBy.join(", ")}`);
+      }
+      const blocks = taskService.getBlocks(t.id);
+      if (blocks.length > 0) {
+        console.log(`Blocks: ${blocks.join(", ")}`);
+      }
+
+      if (Object.keys(t.metadata).length > 0) {
+        console.log(`Metadata: ${JSON.stringify(t.metadata)}`);
+      }
+      console.log(`Created: ${t.created_at}`);
+      console.log(`Updated: ${t.updated_at}`);
+    });
+
+  task
+    .command("update <team> <task-id>")
+    .description("Update a task")
+    .option("--status <status>", "New status (pending, in_progress, completed, deleted)")
+    .option("--owner <name>", "Assign to agent")
+    .option("-s, --subject <subject>", "New subject")
+    .option("-d, --description <description>", "New description")
+    .option("-a, --active-form <text>", "New active form text")
+    .option("--add-blocks <ids>", "Task IDs this task blocks")
+    .option("--add-blocked-by <ids>", "Task IDs that block this task")
+    .option("--metadata <json>", "JSON metadata to merge")
+    .action((team: string, taskId: string, opts) => {
+      try {
+        const id = parseInt(taskId, 10);
+        const result = taskService.update(team, id, {
+          status: opts.status as TaskStatus | undefined,
+          owner: opts.owner,
+          subject: opts.subject,
+          description: opts.description,
+          activeForm: opts.activeForm,
+          addBlocks: opts.addBlocks
+            ? parseCommaSeparatedInts(opts.addBlocks)
+            : undefined,
+          addBlockedBy: opts.addBlockedBy
+            ? parseCommaSeparatedInts(opts.addBlockedBy)
+            : undefined,
+          metadata: opts.metadata ? JSON.parse(opts.metadata) : undefined,
+        });
+        console.log(`Task #${result.id} updated: [${result.status}] ${result.subject}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  return task;
+}

package/references/openteams/src/cli/team.ts

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import { TeamService } from "../services/team-service";
+import type Database from "better-sqlite3";
+
+export function createTeamCommands(db: Database.Database): Command {
+  const teamService = new TeamService(db);
+  const team = new Command("team").description("Manage teams");
+
+  team
+    .command("create <name>")
+    .description("Create a new team")
+    .option("-d, --description <description>", "Team description")
+    .option("-t, --agent-type <type>", "Agent type for team lead")
+    .action((name: string, opts) => {
+      try {
+        const result = teamService.create({
+          name,
+          description: opts.description,
+          agentType: opts.agentType,
+        });
+        console.log(`Team "${result.name}" created.`);
+        if (result.description) console.log(`  Description: ${result.description}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  team
+    .command("list")
+    .description("List all active teams")
+    .action(() => {
+      const teams = teamService.list();
+      if (teams.length === 0) {
+        console.log("No active teams.");
+        return;
+      }
+      for (const t of teams) {
+        const desc = t.description ? ` - ${t.description}` : "";
+        console.log(`  ${t.name}${desc}`);
+      }
+    });
+
+  team
+    .command("info <name>")
+    .description("Show team details")
+    .action((name: string) => {
+      const t = teamService.get(name);
+      if (!t) {
+        console.error(`Error: Team "${name}" not found.`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(`Team: ${t.name}`);
+      if (t.description) console.log(`Description: ${t.description}`);
+      if (t.agent_type) console.log(`Agent Type: ${t.agent_type}`);
+      console.log(`Created: ${t.created_at}`);
+
+      const members = teamService.listMembers(name);
+      if (members.length > 0) {
+        console.log(`\nMembers (${members.length}):`);
+        for (const m of members) {
+          console.log(`  ${m.agent_name} [${m.status}] (${m.agent_type})`);
+        }
+      }
+    });
+
+  team
+    .command("add-member <team-name> <agent-name>")
+    .description("Register a member in a team without spawning an agent")
+    .option("-r, --role <role>", "Role for the member")
+    .option("-t, --type <type>", "Agent type", "general-purpose")
+    .option("-m, --model <model>", "Model to use")
+    .action((teamNameArg: string, agentName: string, opts) => {
+      try {
+        const member = teamService.addMember(teamNameArg, agentName, {
+          agentType: opts.type,
+          role: opts.role,
+          model: opts.model,
+        });
+        console.log(
+          `Member "${member.agent_name}" added to team "${teamNameArg}"${member.role ? ` (role: ${member.role})` : ""}.`
+        );
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  team
+    .command("delete <name>")
+    .description("Delete a team (all members must be shut down first)")
+    .action((name: string) => {
+      try {
+        teamService.delete(name);
+        console.log(`Team "${name}" deleted.`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  return team;
+}