@poolzin/pool-bot 2026.3.13 → 2026.3.15

package/extensions/agency-agents/index.ts

@@ -0,0 +1,733 @@
+import { Type } from "@sinclair/typebox";
+import type { PoolBotPluginDefinition, PoolBotPluginApi } from "../../src/plugins/types.js";
+import { AgencyAgentsService } from "./src/AgencyAgentsService.js";
+import type { AgencyAgent, AgentTask, AgentMessage, AgentReview } from "./src/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface AgentDefinition {
+  name: string;
+  description: string;
+  color?: string;
+  category: string;
+  content: string;
+}
+
+function parseAgentFile(content: string, filename: string): AgentDefinition | null {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) return null;
+
+  const frontmatter = frontmatterMatch[1];
+  const body = frontmatterMatch[2];
+
+  const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim();
+  const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim();
+  const color = frontmatter.match(/color:\s*(.+)/)?.[1]?.trim();
+
+  if (!name || !description) return null;
+
+  const category = path.dirname(filename).split("/").pop() || "general";
+
+  return {
+    name,
+    description,
+    color,
+    category,
+    content: body.trim(),
+  };
+}
+
+function loadAgentsFromDirectory(dirPath: string): AgentDefinition[] {
+  const agents: AgentDefinition[] = [];
+
+  if (!fs.existsSync(dirPath)) return agents;
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
+      agents.push(...loadAgentsFromDirectory(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      try {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const agent = parseAgentFile(content, fullPath.replace(dirPath + "/", ""));
+        if (agent) agents.push(agent);
+      } catch {
+        // Skip files that can't be parsed
+      }
+    }
+  }
+
+  return agents;
+}
+
+const AgencyListAgentsSchema = Type.Object({
+  category: Type.Optional(Type.String({ description: "Filter by category (e.g., engineering, design, marketing, product, testing, strategy)" })),
+});
+
+const AgencyGetAgentSchema = Type.Object({
+  name: Type.String({ description: "Name of the agent to retrieve" }),
+});
+
+const AgencyActivateAgentSchema = Type.Object({
+  name: Type.String({ description: "Name of the agent to activate" }),
+  task: Type.String({ description: "Description of the task for the agent to work on" }),
+  context: Type.Optional(Type.String({ description: "Additional context or requirements for the task" })),
+});
+
+const AgencyFindAgentSchema = Type.Object({
+  task: Type.String({ description: "Description of the task you need help with" }),
+});
+
+const AgencyGetWorkflowSchema = Type.Object({
+  name: Type.String({ description: "Name of the workflow (e.g., 'startup-mvp', 'enterprise-feature', 'phase-0-discovery')" }),
+});
+
+const AgencyCreateTaskSchema = Type.Object({
+  agentName: Type.String({ description: "Name of the agent to assign the task to" }),
+  task: Type.String({ description: "Description of the task" }),
+  context: Type.Optional(Type.String({ description: "Additional context or requirements" })),
+  parentTaskId: Type.Optional(Type.String({ description: "ID of parent task if this is a subtask" })),
+});
+
+const AgencyGetTaskSchema = Type.Object({
+  taskId: Type.String({ description: "ID of the task to retrieve" }),
+});
+
+const AgencyUpdateTaskSchema = Type.Object({
+  taskId: Type.String({ description: "ID of the task to update" }),
+  status: Type.String({ description: "New status: pending, in_progress, completed, failed, reviewing" }),
+  output: Type.Optional(Type.String({ description: "Task output or result" })),
+});
+
+const AgencyListTasksSchema = Type.Object({
+  agentName: Type.Optional(Type.String({ description: "Filter by agent name" })),
+  status: Type.Optional(Type.String({ description: "Filter by status" })),
+});
+
+const AgencyCreateCollaborationSchema = Type.Object({
+  name: Type.String({ description: "Name of the collaboration project" }),
+  description: Type.String({ description: "Description of the collaboration" }),
+  leadAgent: Type.String({ description: "Name of the lead agent" }),
+  participatingAgents: Type.Array(Type.String(), { description: "Names of participating agents" }),
+});
+
+const AgencyGetCollaborationSchema = Type.Object({
+  collaborationId: Type.String({ description: "ID of the collaboration" }),
+});
+
+const AgencyAddTaskToCollaborationSchema = Type.Object({
+  collaborationId: Type.String({ description: "ID of the collaboration" }),
+  agentName: Type.String({ description: "Name of the agent to assign the task to" }),
+  task: Type.String({ description: "Description of the task" }),
+  context: Type.Optional(Type.String({ description: "Additional context" })),
+});
+
+const AgencySendMessageSchema = Type.Object({
+  collaborationId: Type.String({ description: "ID of the collaboration" }),
+  fromAgent: Type.String({ description: "Name of the sending agent" }),
+  toAgent: Type.String({ description: "Name of the receiving agent" }),
+  content: Type.String({ description: "Message content" }),
+  type: Type.Optional(Type.String({ description: "Message type: request, response, update, review, handoff" })),
+});
+
+const AgencyGetMessagesSchema = Type.Object({
+  collaborationId: Type.String({ description: "ID of the collaboration" }),
+});
+
+const AgencyCreateReviewSchema = Type.Object({
+  taskId: Type.String({ description: "ID of the task to review" }),
+  reviewerAgent: Type.String({ description: "Name of the reviewing agent" }),
+  revieweeAgent: Type.String({ description: "Name of the agent being reviewed" }),
+  feedback: Type.String({ description: "Review feedback" }),
+  approvalStatus: Type.String({ description: "approved, changes_requested, or pending" }),
+  suggestions: Type.Optional(Type.Array(Type.String(), { description: "List of improvement suggestions" })),
+});
+
+const AgencyDelegateTaskSchema = Type.Object({
+  fromAgent: Type.String({ description: "Name of the agent delegating the task" }),
+  toAgent: Type.String({ description: "Name of the agent receiving the task" }),
+  task: Type.String({ description: "Description of the task" }),
+  context: Type.Optional(Type.String({ description: "Additional context" })),
+  collaborationId: Type.Optional(Type.String({ description: "ID of collaboration if part of one" })),
+});
+
+const AgencyGetStatsSchema = Type.Object({});
+
+const plugin: PoolBotPluginDefinition = {
+  id: "agency-agents",
+  name: "Agency Agents",
+  description: "AI Specialists for PoolBot - Frontend, Backend, DevOps, Design, Marketing, and more",
+
+  register(api: PoolBotPluginApi) {
+    api.logger.info("[agency-agents] Registering plugin...");
+
+    const service = new AgencyAgentsService();
+    const agentsDir = path.join(__dirname, "..", "agents");
+    const agentDefs = loadAgentsFromDirectory(agentsDir);
+
+    for (const def of agentDefs) {
+      const agent: AgencyAgent = {
+        ...def,
+        capabilities: extractCapabilities(def.content),
+      };
+      service.registerAgent(agent);
+    }
+
+    api.logger.info(`[agency-agents] Loaded ${agentDefs.length} agency agents`);
+
+    api.registerTool({
+      name: "agency_list_agents",
+      label: "List Agency Agents",
+      description: "List all available AI specialist agents in the agency",
+      parameters: AgencyListAgentsSchema,
+      async execute(_toolCallId, args) {
+        const agents = service.listAgents(args.category as string | undefined);
+
+        const result = {
+          success: true,
+          count: agents.length,
+          agents: agents.map(a => ({
+            name: a.name,
+            description: a.description,
+            category: a.category,
+            color: a.color,
+            capabilities: a.capabilities?.slice(0, 5),
+          })),
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_agent",
+      label: "Get Agent Details",
+      description: "Get detailed information about a specific agent including their personality and capabilities",
+      parameters: AgencyGetAgentSchema,
+      async execute(_toolCallId, args) {
+        const agent = service.getAgent(args.name as string);
+
+        if (!agent) {
+          const result = {
+            success: false,
+            error: `Agent '${args.name}' not found. Use agency_list_agents to see available agents.`,
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result,
+          };
+        }
+
+        const result = {
+          success: true,
+          agent: {
+            name: agent.name,
+            description: agent.description,
+            category: agent.category,
+            color: agent.color,
+            capabilities: agent.capabilities,
+            personality: agent.content.slice(0, 3000) + (agent.content.length > 3000 ? "..." : ""),
+          },
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_activate_agent",
+      label: "Activate Agent",
+      description: "Activate an agent to work on a specific task with their full personality and expertise",
+      parameters: AgencyActivateAgentSchema,
+      async execute(_toolCallId, args) {
+        const systemPrompt = service.generateSystemPrompt(
+          args.name as string,
+          args.task as string,
+          args.context as string | undefined
+        );
+
+        if (!systemPrompt) {
+          const result = {
+            success: false,
+            error: `Agent '${args.name}' not found. Use agency_list_agents to see available agents.`,
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result,
+          };
+        }
+
+        const agent = service.getAgent(args.name as string);
+
+        const result = {
+          success: true,
+          activated: true,
+          agent: {
+            name: agent!.name,
+            category: agent!.category,
+            color: agent!.color,
+          },
+          systemPrompt,
+          message: `${agent!.name} is now activated and ready to work on: ${args.task}`,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_find_agent",
+      label: "Find Agent",
+      description: "Find the best agent for a specific task or requirement",
+      parameters: AgencyFindAgentSchema,
+      async execute(_toolCallId, args) {
+        const scored = service.findAgentsForTask(args.task as string);
+        const topMatches = scored.slice(0, 5).filter(s => s.score > 0);
+
+        const result = {
+          success: true,
+          task: args.task,
+          recommendations: topMatches.map(({ agent, score }) => ({
+            name: agent.name,
+            description: agent.description,
+            category: agent.category,
+            matchScore: score,
+          })),
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_workflow",
+      label: "Get Workflow",
+      description: "Get a predefined workflow or playbook from the strategy division",
+      parameters: AgencyGetWorkflowSchema,
+      async execute(_toolCallId, args) {
+        const workflowsDir = path.join(agentsDir, "..", "strategy");
+        const files = [
+          path.join(workflowsDir, "playbooks", `${args.name}.md`),
+          path.join(workflowsDir, "runbooks", `scenario-${args.name}.md`),
+          path.join(workflowsDir, "coordination", `${args.name}.md`),
+        ];
+
+        for (const file of files) {
+          if (fs.existsSync(file)) {
+            const content = fs.readFileSync(file, "utf-8");
+            const result = {
+              success: true,
+              workflow: args.name,
+              content: content.slice(0, 5000) + (content.length > 5000 ? "..." : ""),
+            };
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+              details: result,
+            };
+          }
+        }
+
+        const result = {
+          success: false,
+          error: `Workflow '${args.name}' not found. Available workflows include: phase-0-discovery, phase-1-strategy, phase-2-foundation, phase-3-build, phase-4-hardening, phase-5-launch, phase-6-operate, startup-mvp, enterprise-feature, marketing-campaign, incident-response`,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_create_task",
+      label: "Create Agent Task",
+      description: "Create a new task for an agent",
+      parameters: AgencyCreateTaskSchema,
+      async execute(_toolCallId, args) {
+        const task = service.createTask(
+          args.agentName as string,
+          args.task as string,
+          args.context as string | undefined,
+          args.parentTaskId as string | undefined
+        );
+
+        const result = {
+          success: true,
+          task: {
+            id: task.id,
+            agentName: task.agentName,
+            task: task.task,
+            status: task.status,
+            createdAt: task.createdAt,
+          },
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_task",
+      label: "Get Task Details",
+      description: "Get details of a specific task",
+      parameters: AgencyGetTaskSchema,
+      async execute(_toolCallId, args) {
+        const task = service.getTask(args.taskId as string);
+
+        if (!task) {
+          const result = {
+            success: false,
+            error: `Task '${args.taskId}' not found.`,
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result,
+          };
+        }
+
+        const result = {
+          success: true,
+          task,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_update_task",
+      label: "Update Task",
+      description: "Update task status and output",
+      parameters: AgencyUpdateTaskSchema,
+      async execute(_toolCallId, args) {
+        const task = service.updateTaskStatus(
+          args.taskId as string,
+          args.status as AgentTask["status"],
+          args.output as string | undefined
+        );
+
+        if (!task) {
+          const result = {
+            success: false,
+            error: `Task '${args.taskId}' not found.`,
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result,
+          };
+        }
+
+        const result = {
+          success: true,
+          task,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_list_tasks",
+      label: "List Tasks",
+      description: "List all tasks with optional filtering",
+      parameters: AgencyListTasksSchema,
+      async execute(_toolCallId, args) {
+        const tasks = service.listTasks(
+          args.agentName as string | undefined,
+          args.status as AgentTask["status"] | undefined
+        );
+
+        const result = {
+          success: true,
+          count: tasks.length,
+          tasks: tasks.map(t => ({
+            id: t.id,
+            agentName: t.agentName,
+            task: t.task,
+            status: t.status,
+            createdAt: t.createdAt,
+            updatedAt: t.updatedAt,
+          })),
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_create_collaboration",
+      label: "Create Collaboration",
+      description: "Create a new multi-agent collaboration project",
+      parameters: AgencyCreateCollaborationSchema,
+      async execute(_toolCallId, args) {
+        const collaboration = service.createCollaboration(
+          args.name as string,
+          args.description as string,
+          args.leadAgent as string,
+          args.participatingAgents as string[]
+        );
+
+        const result = {
+          success: true,
+          collaboration: {
+            id: collaboration.id,
+            name: collaboration.name,
+            description: collaboration.description,
+            leadAgent: collaboration.leadAgent,
+            participatingAgents: collaboration.participatingAgents,
+            status: collaboration.status,
+            createdAt: collaboration.createdAt,
+          },
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_collaboration",
+      label: "Get Collaboration",
+      description: "Get details of a collaboration project",
+      parameters: AgencyGetCollaborationSchema,
+      async execute(_toolCallId, args) {
+        const collaboration = service.getCollaboration(args.collaborationId as string);
+
+        if (!collaboration) {
+          const result = {
+            success: false,
+            error: `Collaboration '${args.collaborationId}' not found.`,
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result,
+          };
+        }
+
+        const result = {
+          success: true,
+          collaboration,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_add_task_to_collaboration",
+      label: "Add Task to Collaboration",
+      description: "Add a new task to an existing collaboration",
+      parameters: AgencyAddTaskToCollaborationSchema,
+      async execute(_toolCallId, args) {
+        const task = service.createTask(
+          args.agentName as string,
+          args.task as string,
+          args.context as string | undefined
+        );
+
+        service.addTaskToCollaboration(args.collaborationId as string, task);
+
+        const result = {
+          success: true,
+          task,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_send_message",
+      label: "Send Agent Message",
+      description: "Send a message between agents in a collaboration",
+      parameters: AgencySendMessageSchema,
+      async execute(_toolCallId, args) {
+        const message = service.createMessage(
+          args.fromAgent as string,
+          args.toAgent as string,
+          args.collaborationId as string,
+          args.content as string,
+          (args.type as AgentMessage["type"]) || "update"
+        );
+
+        const result = {
+          success: true,
+          message,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_messages",
+      label: "Get Collaboration Messages",
+      description: "Get all messages in a collaboration",
+      parameters: AgencyGetMessagesSchema,
+      async execute(_toolCallId, args) {
+        const messages = service.getMessagesForCollaboration(args.collaborationId as string);
+
+        const result = {
+          success: true,
+          count: messages.length,
+          messages,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_create_review",
+      label: "Create Review",
+      description: "Create a code/design review for a task",
+      parameters: AgencyCreateReviewSchema,
+      async execute(_toolCallId, args) {
+        const review = service.createReview(
+          args.taskId as string,
+          args.reviewerAgent as string,
+          args.revieweeAgent as string,
+          args.feedback as string,
+          args.approvalStatus as AgentReview["approvalStatus"],
+          args.suggestions as string[] | undefined
+        );
+
+        const result = {
+          success: true,
+          review,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_delegate_task",
+      label: "Delegate Task",
+      description: "Delegate a task from one agent to another",
+      parameters: AgencyDelegateTaskSchema,
+      async execute(_toolCallId, args) {
+        const task = service.createTask(
+          args.toAgent as string,
+          args.task as string,
+          args.context as string | undefined
+        );
+
+        if (args.collaborationId) {
+          service.addTaskToCollaboration(args.collaborationId as string, task);
+        }
+
+        const result = {
+          success: true,
+          delegated: true,
+          fromAgent: args.fromAgent,
+          toAgent: args.toAgent,
+          task,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "agency_get_stats",
+      label: "Get Agency Stats",
+      description: "Get statistics about the agency",
+      parameters: AgencyGetStatsSchema,
+      async execute(_toolCallId, _args) {
+        const stats = service.getStats();
+
+        const result = {
+          success: true,
+          stats,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+        };
+      },
+    });
+
+    api.logger.info("[agency-agents] Plugin registered successfully with 17 tools");
+  },
+};
+
+function extractCapabilities(content: string): string[] {
+  const capabilities: string[] = [];
+  const lines = content.split("\n");
+  let inCapabilities = false;
+
+  for (const line of lines) {
+    if (line.match(/^##?\s*(Capabilities|Skills|Expertise)/i)) {
+      inCapabilities = true;
+      continue;
+    }
+    if (inCapabilities) {
+      if (line.match(/^##?\s/)) {
+        inCapabilities = false;
+        continue;
+      }
+      const match = line.match(/^[-*]\s*(.+)/);
+      if (match) {
+        capabilities.push(match[1].trim());
+      }
+    }
+  }
+
+  return capabilities;
+}
+
+export default plugin;