@lov3kaizen/agentsea-crews 0.5.1

package/dist/chunk-4PF73ECN.mjs

@@ -0,0 +1,587 @@
+// src/monitoring/CrewDashboard.ts
+import { EventEmitter } from "eventemitter3";
+var CrewDashboard = class extends EventEmitter {
+  crew;
+  config;
+  events = [];
+  updateTimer;
+  lastStatus;
+  subscribed = false;
+  constructor(crew, config = {}) {
+    super();
+    this.crew = crew;
+    this.config = {
+      updateInterval: config.updateInterval ?? 1e3,
+      trackEvents: config.trackEvents ?? true,
+      maxEvents: config.maxEvents ?? 1e3
+    };
+  }
+  /**
+   * Start monitoring
+   */
+  start() {
+    if (this.subscribed) return;
+    this.subscribed = true;
+    this.updateTimer = setInterval(() => {
+      this.emitUpdate();
+    }, this.config.updateInterval);
+    this.emitUpdate();
+  }
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = void 0;
+    }
+    this.subscribed = false;
+  }
+  /**
+   * Subscribe to updates
+   */
+  subscribe(callback) {
+    this.on("update", callback);
+    if (!this.subscribed) {
+      this.start();
+    }
+    return () => {
+      this.off("update", callback);
+    };
+  }
+  /**
+   * Record an event
+   */
+  recordEvent(event) {
+    if (!this.config.trackEvents) return;
+    this.events.push(event);
+    if (this.events.length > this.config.maxEvents) {
+      this.events.shift();
+    }
+    this.emit("update", {
+      type: "event",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: event
+    });
+  }
+  // ============ Status Getters ============
+  /**
+   * Get current crew status
+   */
+  getCrewStatus() {
+    return this.crew.getStatus();
+  }
+  /**
+   * Get agent statuses
+   */
+  getAgentStatuses() {
+    const statuses = /* @__PURE__ */ new Map();
+    for (const agent of this.crew.getAgents()) {
+      const stats = agent.getStats();
+      statuses.set(agent.name, {
+        name: agent.name,
+        role: agent.role.name,
+        status: stats.isBusy ? "busy" : "idle",
+        currentTask: stats.currentTask,
+        tasksCompleted: stats.tasksCompleted,
+        tasksFailed: stats.tasksFailed,
+        tokensUsed: stats.totalTokensUsed
+      });
+    }
+    return statuses;
+  }
+  /**
+   * Get crew metrics
+   */
+  getMetrics() {
+    return this.crew.getMetrics();
+  }
+  /**
+   * Get timeline
+   */
+  getTimeline() {
+    return this.crew.getTimeline();
+  }
+  /**
+   * Get events
+   */
+  getEvents(filter) {
+    let filtered = [...this.events];
+    if (filter?.type) {
+      filtered = filtered.filter((e) => e.type === filter.type);
+    }
+    if (filter?.agent) {
+      filtered = filtered.filter((e) => {
+        const anyEvent = e;
+        return anyEvent.agentName === filter.agent;
+      });
+    }
+    if (filter?.since) {
+      filtered = filtered.filter((e) => {
+        return e.timestamp >= filter.since;
+      });
+    }
+    if (filter?.limit) {
+      filtered = filtered.slice(-filter.limit);
+    }
+    return filtered;
+  }
+  // ============ Progress Tracking ============
+  /**
+   * Get progress summary
+   */
+  getProgress() {
+    const status = this.getCrewStatus();
+    const metrics = this.getMetrics();
+    const total = status.tasksPending + status.tasksInProgress + status.tasksCompleted + status.tasksFailed;
+    const completed = status.tasksCompleted;
+    return {
+      percentage: total > 0 ? completed / total * 100 : 0,
+      completedTasks: completed,
+      totalTasks: total,
+      elapsedTime: metrics.totalExecutionTimeMs
+    };
+  }
+  /**
+   * Get task breakdown
+   */
+  getTaskBreakdown() {
+    const status = this.getCrewStatus();
+    return {
+      pending: status.tasksPending,
+      inProgress: status.tasksInProgress,
+      completed: status.tasksCompleted,
+      failed: status.tasksFailed,
+      total: status.tasksPending + status.tasksInProgress + status.tasksCompleted + status.tasksFailed
+    };
+  }
+  /**
+   * Get agent breakdown
+   */
+  getAgentBreakdown() {
+    const agents = this.crew.getAgents();
+    const performance = agents.map((agent) => {
+      const stats = agent.getStats();
+      return {
+        name: agent.name,
+        completed: stats.tasksCompleted,
+        failed: stats.tasksFailed,
+        successRate: stats.successRate
+      };
+    });
+    const status = this.getCrewStatus();
+    return {
+      total: agents.length,
+      busy: status.agentsBusy,
+      idle: status.agentsAvailable,
+      performance
+    };
+  }
+  // ============ Internal ============
+  /**
+   * Emit an update
+   */
+  emitUpdate() {
+    const currentStatus = this.getCrewStatus();
+    if (this.lastStatus && this.lastStatus.state !== currentStatus.state) {
+      this.emit("statusChange", currentStatus);
+    }
+    this.lastStatus = currentStatus;
+    this.emit("update", {
+      type: "metrics_update",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        status: currentStatus,
+        metrics: this.getMetrics(),
+        agents: Object.fromEntries(this.getAgentStatuses())
+      }
+    });
+  }
+  /**
+   * Get dashboard snapshot
+   */
+  getSnapshot() {
+    return {
+      timestamp: /* @__PURE__ */ new Date(),
+      status: this.getCrewStatus(),
+      metrics: this.getMetrics(),
+      agents: Object.fromEntries(this.getAgentStatuses()),
+      progress: this.getProgress(),
+      taskBreakdown: this.getTaskBreakdown(),
+      agentBreakdown: this.getAgentBreakdown(),
+      recentEvents: this.events.slice(-10)
+    };
+  }
+};
+function createDashboard(crew, config) {
+  return new CrewDashboard(crew, config);
+}
+
+// src/monitoring/DebugMode.ts
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+var DebugMode = class extends EventEmitter2 {
+  crew;
+  config;
+  breakpoints = /* @__PURE__ */ new Map();
+  eventQueue = [];
+  callStack = [];
+  context;
+  enabled = false;
+  paused = false;
+  stepMode = false;
+  breakpointCounter = 0;
+  resolveStep;
+  constructor(crew, config = {}) {
+    super();
+    this.crew = crew;
+    this.config = {
+      pauseOnError: config.pauseOnError ?? true,
+      verbose: config.verbose ?? false,
+      maxCallStackDepth: config.maxCallStackDepth ?? 100
+    };
+    this.context = this.createContext();
+  }
+  // ============ Enable/Disable ============
+  /**
+   * Enable debug mode
+   */
+  enable() {
+    if (this.enabled) return;
+    this.enabled = true;
+    this.paused = false;
+    if (this.config.verbose) {
+      console.log("[Debug] Debug mode enabled");
+    }
+  }
+  /**
+   * Disable debug mode
+   */
+  disable() {
+    this.enabled = false;
+    this.paused = false;
+    this.stepMode = false;
+    this.breakpoints.clear();
+    this.eventQueue.length = 0;
+    this.callStack.length = 0;
+    if (this.resolveStep) {
+      this.resolveStep();
+      this.resolveStep = void 0;
+    }
+    if (this.config.verbose) {
+      console.log("[Debug] Debug mode disabled");
+    }
+  }
+  /**
+   * Check if debug mode is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  // ============ Breakpoints ============
+  /**
+   * Set a breakpoint
+   */
+  setBreakpoint(type, condition) {
+    const id = `bp-${++this.breakpointCounter}`;
+    const breakpoint = {
+      id,
+      type,
+      condition,
+      enabled: true,
+      hitCount: 0
+    };
+    this.breakpoints.set(id, breakpoint);
+    if (this.config.verbose) {
+      console.log(`[Debug] Breakpoint set: ${id} (${type})`);
+    }
+    return id;
+  }
+  /**
+   * Remove a breakpoint
+   */
+  removeBreakpoint(id) {
+    const removed = this.breakpoints.delete(id);
+    if (removed && this.config.verbose) {
+      console.log(`[Debug] Breakpoint removed: ${id}`);
+    }
+    return removed;
+  }
+  /**
+   * Enable a breakpoint
+   */
+  enableBreakpoint(id) {
+    const bp = this.breakpoints.get(id);
+    if (bp) {
+      bp.enabled = true;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Disable a breakpoint
+   */
+  disableBreakpoint(id) {
+    const bp = this.breakpoints.get(id);
+    if (bp) {
+      bp.enabled = false;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all breakpoints
+   */
+  getBreakpoints() {
+    return Array.from(this.breakpoints.values());
+  }
+  /**
+   * Clear all breakpoints
+   */
+  clearBreakpoints() {
+    this.breakpoints.clear();
+  }
+  // ============ Execution Control ============
+  /**
+   * Step to next event
+   */
+  async step() {
+    if (!this.enabled) {
+      throw new Error("Debug mode not enabled");
+    }
+    this.stepMode = true;
+    this.paused = false;
+    return new Promise((resolve) => {
+      this.resolveStep = () => {
+        const event = this.eventQueue.shift();
+        if (!event) {
+          resolve({
+            event: {
+              type: "crew:completed",
+              crewName: this.crew.name,
+              metrics: this.crew.getMetrics(),
+              success: true,
+              results: [],
+              timestamp: /* @__PURE__ */ new Date()
+            },
+            agentStates: this.getAgentStates(),
+            continueExecution: false
+          });
+          return;
+        }
+        this.updateContext(event);
+        const hitBreakpoint = this.checkBreakpoints(event);
+        resolve({
+          event,
+          breakpointHit: hitBreakpoint,
+          agentStates: this.getAgentStates(),
+          continueExecution: true
+        });
+      };
+    });
+  }
+  /**
+   * Continue execution
+   */
+  continue() {
+    if (!this.enabled) {
+      throw new Error("Debug mode not enabled");
+    }
+    this.stepMode = false;
+    this.paused = false;
+    this.emit("resumed");
+    if (this.config.verbose) {
+      console.log("[Debug] Execution resumed");
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Pause execution
+   */
+  pause() {
+    this.paused = true;
+    this.emit("paused");
+    if (this.config.verbose) {
+      console.log("[Debug] Execution paused");
+    }
+  }
+  /**
+   * Resume from pause
+   */
+  resume() {
+    this.paused = false;
+    this.emit("resumed");
+    if (this.config.verbose) {
+      console.log("[Debug] Execution resumed");
+    }
+  }
+  /**
+   * Check if paused
+   */
+  isPaused() {
+    return this.paused;
+  }
+  // ============ Inspection ============
+  /**
+   * Inspect an agent
+   */
+  inspect(agentName) {
+    const agent = this.crew.getAgent(agentName);
+    if (!agent) return void 0;
+    return this.createAgentInspection(agent);
+  }
+  /**
+   * Inspect all agents
+   */
+  inspectAll() {
+    return this.getAgentStates();
+  }
+  /**
+   * Get debug context
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Get call stack
+   */
+  getCallStack() {
+    return [...this.callStack];
+  }
+  /**
+   * Evaluate expression in context
+   */
+  evaluate(expression) {
+    if (this.context.variables.has(expression)) {
+      return this.context.variables.get(expression);
+    }
+    const agentMatch = expression.match(/^agent\.(\w+)\.(\w+)$/);
+    if (agentMatch) {
+      const [, agentName, property] = agentMatch;
+      const agent = this.context.agents.get(agentName);
+      if (agent) {
+        return agent[property];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Set a watch expression
+   */
+  watch(expression) {
+    return {
+      expression,
+      value: this.evaluate(expression)
+    };
+  }
+  // ============ Event Handling ============
+  /**
+   * Handle a crew event (called by crew during execution)
+   */
+  handleEvent(event) {
+    if (!this.enabled) return;
+    this.eventQueue.push(event);
+    this.updateContext(event);
+    if (this.config.verbose) {
+      console.log(`[Debug] Event: ${event.type}`);
+    }
+    const hitBreakpoint = this.checkBreakpoints(event);
+    if (hitBreakpoint) {
+      this.paused = true;
+      this.emit("breakpointHit", hitBreakpoint, event);
+      if (this.config.verbose) {
+        console.log(`[Debug] Breakpoint hit: ${hitBreakpoint.id}`);
+      }
+    }
+    if (this.config.pauseOnError && event.type === "crew:error") {
+      this.pause();
+    }
+    if (this.stepMode && this.resolveStep) {
+      this.resolveStep();
+      this.resolveStep = void 0;
+    }
+  }
+  // ============ Internal ============
+  /**
+   * Create debug context
+   */
+  createContext() {
+    return {
+      agents: /* @__PURE__ */ new Map(),
+      tasks: [],
+      variables: /* @__PURE__ */ new Map(),
+      callStack: []
+    };
+  }
+  /**
+   * Update context from event
+   */
+  updateContext(event) {
+    this.context.currentEvent = event;
+    this.callStack.push(event.type);
+    if (this.callStack.length > this.config.maxCallStackDepth) {
+      this.callStack.shift();
+    }
+    this.context.agents = this.getAgentStates();
+    this.context.tasks = this.crew.getTasks().map((t) => t.toConfig());
+  }
+  /**
+   * Check breakpoints against event
+   */
+  checkBreakpoints(event) {
+    for (const bp of this.breakpoints.values()) {
+      if (!bp.enabled) continue;
+      if (bp.type !== "custom" && bp.type !== event.type) continue;
+      if (bp.condition && !bp.condition(event, this.context)) continue;
+      bp.hitCount++;
+      return bp;
+    }
+    return void 0;
+  }
+  /**
+   * Get agent states
+   */
+  getAgentStates() {
+    const states = /* @__PURE__ */ new Map();
+    for (const agent of this.crew.getAgents()) {
+      states.set(agent.name, this.createAgentInspection(agent));
+    }
+    return states;
+  }
+  /**
+   * Create agent inspection
+   */
+  createAgentInspection(agent) {
+    const stats = agent.getStats();
+    return {
+      name: agent.name,
+      role: agent.role.name,
+      status: stats.isBusy ? "busy" : this.paused ? "paused" : "idle",
+      currentTask: stats.currentTask,
+      memory: /* @__PURE__ */ new Map()
+      // Would need access to agent's internal state
+    };
+  }
+  /**
+   * Get debug summary
+   */
+  getSummary() {
+    return {
+      enabled: this.enabled,
+      paused: this.paused,
+      stepMode: this.stepMode,
+      breakpointCount: this.breakpoints.size,
+      queuedEvents: this.eventQueue.length,
+      callStackDepth: this.callStack.length
+    };
+  }
+};
+function createDebugMode(crew, config) {
+  return new DebugMode(crew, config);
+}
+
+export {
+  CrewDashboard,
+  createDashboard,
+  DebugMode,
+  createDebugMode
+};