@desplega.ai/agent-swarm 1.2.1 → 1.9.0

package/src/types.ts

@@ -1,21 +1,56 @@
 import * as z from "zod";
 
-export const AgentTaskStatusSchema = z.enum(["pending", "in_progress", "completed", "failed"]);
+// Task status - includes new unassigned and offered states
+export const AgentTaskStatusSchema = z.enum([
+  "unassigned", // Task pool - no owner yet
+  "offered", // Offered to agent, awaiting accept/reject
+  "pending", // Assigned/accepted, waiting to start
+  "in_progress",
+  "completed",
+  "failed",
+]);
+
+export const AgentTaskSourceSchema = z.enum(["mcp", "slack", "api"]);
+export type AgentTaskSource = z.infer<typeof AgentTaskSourceSchema>;
 
 export const AgentTaskSchema = z.object({
   id: z.uuid(),
-  agentId: z.uuid(),
+  agentId: z.uuid().nullable(), // Nullable for unassigned tasks
+  creatorAgentId: z.uuid().optional(), // Who created this task (optional for Slack/API)
   task: z.string().min(1),
   status: AgentTaskStatusSchema,
+  source: AgentTaskSourceSchema.default("mcp"),
+
+  // Task metadata
+  taskType: z.string().max(50).optional(), // e.g., "bug", "feature", "chore"
+  tags: z.array(z.string()).default([]), // e.g., ["urgent", "frontend"]
+  priority: z.number().int().min(0).max(100).default(50),
+  dependsOn: z.array(z.uuid()).default([]), // Task IDs this depends on
 
+  // Acceptance tracking
+  offeredTo: z.uuid().optional(), // Agent the task was offered to
+  offeredAt: z.iso.datetime().optional(),
+  acceptedAt: z.iso.datetime().optional(),
+  rejectionReason: z.string().optional(),
+
+  // Timestamps
   createdAt: z.iso.datetime().default(() => new Date().toISOString()),
   lastUpdatedAt: z.iso.datetime().default(() => new Date().toISOString()),
-
   finishedAt: z.iso.datetime().optional(),
 
+  // Completion data
   failureReason: z.string().optional(),
   output: z.string().optional(),
   progress: z.string().optional(),
+
+  // Slack-specific metadata (optional)
+  slackChannelId: z.string().optional(),
+  slackThreadTs: z.string().optional(),
+  slackUserId: z.string().optional(),
+
+  // Mention-to-task metadata (optional)
+  mentionMessageId: z.uuid().optional(),
+  mentionChannelId: z.uuid().optional(),
 });
 
 export const AgentStatusSchema = z.enum(["idle", "busy", "offline"]);
@@ -26,6 +61,11 @@ export const AgentSchema = z.object({
   isLead: z.boolean().default(false),
   status: AgentStatusSchema,
 
+  // Profile fields
+  description: z.string().optional(),
+  role: z.string().max(100).optional(), // Free-form, e.g., "frontend dev"
+  capabilities: z.array(z.string()).default([]), // e.g., ["typescript", "react"]
+
   createdAt: z.iso.datetime().default(() => new Date().toISOString()),
   lastUpdatedAt: z.iso.datetime().default(() => new Date().toISOString()),
 });
@@ -41,6 +81,62 @@ export type AgentStatus = z.infer<typeof AgentStatusSchema>;
 export type Agent = z.infer<typeof AgentSchema>;
 export type AgentWithTasks = z.infer<typeof AgentWithTasksSchema>;
 
+// Channel Types
+export const ChannelTypeSchema = z.enum(["public", "dm"]);
+
+export const ChannelSchema = z.object({
+  id: z.uuid(),
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional(),
+  type: ChannelTypeSchema.default("public"),
+  createdBy: z.uuid().optional(),
+  participants: z.array(z.uuid()).default([]), // For DMs
+  createdAt: z.iso.datetime(),
+});
+
+export const ChannelMessageSchema = z.object({
+  id: z.uuid(),
+  channelId: z.uuid(),
+  agentId: z.uuid().nullable(), // Null for human users
+  agentName: z.string().optional(), // Denormalized for convenience, "Human" when agentId is null
+  content: z.string().min(1).max(4000),
+  replyToId: z.uuid().optional(),
+  mentions: z.array(z.uuid()).default([]), // Agent IDs mentioned
+  createdAt: z.iso.datetime(),
+});
+
+export type ChannelType = z.infer<typeof ChannelTypeSchema>;
+export type Channel = z.infer<typeof ChannelSchema>;
+export type ChannelMessage = z.infer<typeof ChannelMessageSchema>;
+
+// Service Types (for PM2/background services)
+export const ServiceStatusSchema = z.enum(["starting", "healthy", "unhealthy", "stopped"]);
+
+export const ServiceSchema = z.object({
+  id: z.uuid(),
+  agentId: z.uuid(),
+  name: z.string().min(1).max(50),
+  port: z.number().int().min(1).max(65535).default(3000),
+  description: z.string().optional(),
+  url: z.string().url().optional(),
+  healthCheckPath: z.string().default("/health"),
+  status: ServiceStatusSchema.default("starting"),
+
+  // PM2 configuration (required for ecosystem-based restart)
+  script: z.string().min(1), // Path to script (required)
+  cwd: z.string().optional(), // Working directory (defaults to script dir)
+  interpreter: z.string().optional(), // e.g., "node", "bun" (auto-detected if not set)
+  args: z.array(z.string()).optional(), // Command line arguments
+  env: z.record(z.string(), z.string()).optional(), // Environment variables
+
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  createdAt: z.iso.datetime(),
+  lastUpdatedAt: z.iso.datetime(),
+});
+
+export type ServiceStatus = z.infer<typeof ServiceStatusSchema>;
+export type Service = z.infer<typeof ServiceSchema>;
+
 // Agent Log Types
 export const AgentLogEventTypeSchema = z.enum([
   "agent_joined",
@@ -49,6 +145,17 @@ export const AgentLogEventTypeSchema = z.enum([
   "task_created",
   "task_status_change",
   "task_progress",
+  // Task pool events
+  "task_offered",
+  "task_accepted",
+  "task_rejected",
+  "task_claimed",
+  "task_released",
+  "channel_message",
+  // Service registry events
+  "service_registered",
+  "service_unregistered",
+  "service_status_change",
 ]);
 
 export const AgentLogSchema = z.object({

package/src/utils/pretty-print.ts

@@ -0,0 +1,224 @@
+/**
+ * Pretty print utilities for Claude CLI output
+ */
+
+// ANSI color codes
+const colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  italic: "\x1b[3m",
+  underline: "\x1b[4m",
+
+  // Foreground colors
+  black: "\x1b[30m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+
+  // Bright colors
+  brightBlack: "\x1b[90m",
+  brightRed: "\x1b[91m",
+  brightGreen: "\x1b[92m",
+  brightYellow: "\x1b[93m",
+  brightBlue: "\x1b[94m",
+  brightMagenta: "\x1b[95m",
+  brightCyan: "\x1b[96m",
+  brightWhite: "\x1b[97m",
+
+  // Background colors
+  bgBlue: "\x1b[44m",
+  bgMagenta: "\x1b[45m",
+  bgCyan: "\x1b[46m",
+};
+
+const c = colors;
+
+/** Truncate string with ellipsis */
+function truncate(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 3)}...`;
+}
+
+/** Format a tool name nicely */
+function formatToolName(name: string): string {
+  // Shorten MCP tool names
+  if (name.startsWith("mcp__")) {
+    const parts = name.split("__");
+    return parts.length >= 3 ? `${parts[1]}:${parts[2]}` : name;
+  }
+  return name;
+}
+
+/** Format input parameters for tool calls */
+function formatToolInput(input: Record<string, unknown>): string {
+  const entries = Object.entries(input);
+  if (entries.length === 0) return "";
+
+  const formatted = entries
+    .map(([k, v]) => {
+      const value = typeof v === "string" ? truncate(v, 50) : JSON.stringify(v);
+      return `${c.dim}${k}=${c.reset}${truncate(String(value), 60)}`;
+    })
+    .join(", ");
+
+  return ` (${formatted})`;
+}
+
+/** Pretty print a single JSON line from Claude output */
+export function prettyPrintLine(line: string, role: string): void {
+  if (!line.trim()) return;
+
+  let json: Record<string, unknown>;
+  try {
+    json = JSON.parse(line.trim());
+  } catch {
+    // Raw output - just print it
+    console.log(`${c.dim}[${role}]${c.reset} ${line.trim()}`);
+    return;
+  }
+
+  const type = json.type as string;
+  const prefix = `${c.dim}[${role}]${c.reset}`;
+
+  switch (type) {
+    case "system": {
+      const subtype = json.subtype as string;
+      if (subtype === "init") {
+        const model = json.model as string;
+        const tools = json.tools as string[];
+        console.log(
+          `${prefix} ${c.cyan}●${c.reset} ${c.bold}Session started${c.reset} ${c.dim}(${model}, ${tools?.length || 0} tools)${c.reset}`,
+        );
+      } else if (subtype === "hook_response") {
+        const hookName = json.hook_name as string;
+        const stdout = json.stdout as string;
+        console.log(`${prefix} ${c.yellow}⚡${c.reset} Hook: ${c.yellow}${hookName}${c.reset}`);
+        if (stdout) {
+          const lines = stdout.split("\n").filter((l) => l.trim());
+          for (const l of lines.slice(0, 3)) {
+            console.log(`${prefix}    ${c.dim}${truncate(l, 80)}${c.reset}`);
+          }
+          if (lines.length > 3) {
+            console.log(`${prefix}    ${c.dim}... (${lines.length - 3} more lines)${c.reset}`);
+          }
+        }
+      } else {
+        const msg = (json.message as string) || (json.content as string) || "";
+        console.log(
+          `${prefix} ${c.cyan}ℹ${c.reset} System${subtype ? ` (${subtype})` : ""}: ${truncate(msg, 100)}`,
+        );
+      }
+      break;
+    }
+
+    case "assistant": {
+      const message = json.message as Record<string, unknown>;
+      if (!message) break;
+
+      const content = message.content as Array<Record<string, unknown>>;
+      if (!content) break;
+
+      for (const block of content) {
+        if (block.type === "text") {
+          const text = block.text as string;
+          console.log(`${prefix} ${c.green}◆${c.reset} ${c.bold}Assistant:${c.reset}`);
+          // Print text with nice indentation, truncate long lines
+          const lines = text.split("\n");
+          for (const l of lines.slice(0, 5)) {
+            console.log(`${prefix}    ${truncate(l, 100)}`);
+          }
+          if (lines.length > 5) {
+            console.log(`${prefix}    ${c.dim}... (${lines.length - 5} more lines)${c.reset}`);
+          }
+        } else if (block.type === "tool_use") {
+          const toolName = formatToolName((block.name as string) || "unknown");
+          const input = (block.input as Record<string, unknown>) || {};
+          console.log(
+            `${prefix} ${c.magenta}▶${c.reset} Tool: ${c.magenta}${toolName}${c.reset}${formatToolInput(input)}`,
+          );
+        } else if (block.type === "thinking") {
+          const thinking = block.thinking as string;
+          console.log(`${prefix} ${c.blue}💭${c.reset} ${c.dim}Thinking...${c.reset}`);
+          if (thinking) {
+            console.log(`${prefix}    ${c.dim}${truncate(thinking, 80)}${c.reset}`);
+          }
+        }
+      }
+      break;
+    }
+
+    case "user": {
+      const message = json.message as Record<string, unknown>;
+      const toolResult = json.tool_use_result as string;
+
+      if (toolResult) {
+        const isError = toolResult.includes("Error") || toolResult.includes("error");
+        const icon = isError ? `${c.red}✗${c.reset}` : `${c.green}✓${c.reset}`;
+        console.log(`${prefix} ${icon} Result: ${truncate(toolResult, 100)}`);
+      } else if (message) {
+        const content = message.content as Array<Record<string, unknown>>;
+        if (content) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              const result = block.content as string;
+              const isError = block.is_error as boolean;
+              const icon = isError ? `${c.red}✗${c.reset}` : `${c.green}✓${c.reset}`;
+              console.log(`${prefix} ${icon} Result: ${truncate(result || "", 100)}`);
+            }
+          }
+        }
+      }
+      break;
+    }
+
+    case "result": {
+      const subtype = json.subtype as string;
+      const isError = json.is_error as boolean;
+      const duration = json.duration_ms as number;
+      const cost = json.total_cost_usd as number;
+      const numTurns = json.num_turns as number;
+      const result = json.result as string;
+
+      const icon = isError ? `${c.red}✗${c.reset}` : `${c.green}✓${c.reset}`;
+      const durationStr = duration ? `${(duration / 1000).toFixed(1)}s` : "";
+      const costStr = cost ? `$${cost.toFixed(4)}` : "";
+
+      console.log(
+        `${prefix} ${icon} ${c.bold}Done${c.reset} ${c.dim}(${subtype}, ${numTurns} turns, ${durationStr}, ${costStr})${c.reset}`,
+      );
+
+      if (result) {
+        const lines = result.split("\n").filter((l) => l.trim());
+        for (const l of lines.slice(0, 3)) {
+          console.log(`${prefix}    ${truncate(l, 100)}`);
+        }
+        if (lines.length > 3) {
+          console.log(`${prefix}    ${c.dim}... (${lines.length - 3} more lines)${c.reset}`);
+        }
+      }
+      break;
+    }
+
+    case "error": {
+      const error = (json.error as string) || (json.message as string) || JSON.stringify(json);
+      console.log(`${prefix} ${c.red}✗ Error:${c.reset} ${truncate(error, 100)}`);
+      break;
+    }
+
+    default: {
+      // Unknown type - print a summary
+      console.log(`${prefix} ${c.dim}[${type}]${c.reset} ${truncate(JSON.stringify(json), 100)}`);
+    }
+  }
+}
+
+/** Pretty print stderr output */
+export function prettyPrintStderr(text: string, role: string): void {
+  const prefix = `${c.dim}[${role}]${c.reset}`;
+  console.error(`${prefix} ${c.red}stderr:${c.reset} ${truncate(text.trim(), 100)}`);
+}