@lov3kaizen/agentsea-crews 0.5.1

package/dist/nestjs/index.mjs

@@ -0,0 +1,453 @@
+import {
+  CrewDashboard,
+  DebugMode
+} from "../chunk-4PF73ECN.mjs";
+import {
+  createCrew
+} from "../chunk-QMK3HWFX.mjs";
+
+// src/nestjs/crews.module.ts
+var CREWS_MODULE_OPTIONS = "CREWS_MODULE_OPTIONS";
+var CREWS_SERVICE = "CREWS_SERVICE";
+var CrewsModule = class _CrewsModule {
+  /**
+   * Configure module with static options
+   */
+  static forRoot(options = {}) {
+    const providers = this.createProviders(options);
+    return {
+      module: _CrewsModule,
+      global: options.global ?? false,
+      providers,
+      exports: providers
+    };
+  }
+  /**
+   * Configure module with async options
+   */
+  static forRootAsync(options) {
+    const providers = this.createAsyncProviders(options);
+    return {
+      module: _CrewsModule,
+      imports: options.imports ?? [],
+      global: options.global ?? false,
+      providers,
+      exports: providers
+    };
+  }
+  /**
+   * Register crew configurations
+   */
+  static forFeature(crews) {
+    const providers = crews.map((config) => ({
+      provide: `CREW_${config.name.toUpperCase().replace(/-/g, "_")}`,
+      useValue: config
+    }));
+    return {
+      module: _CrewsModule,
+      providers,
+      exports: providers
+    };
+  }
+  /**
+   * Create providers from static options
+   */
+  static createProviders(options) {
+    return [
+      {
+        provide: CREWS_MODULE_OPTIONS,
+        useValue: options
+      },
+      // Crew configurations
+      ...(options.crews ?? []).map((config) => ({
+        provide: `CREW_CONFIG_${config.name.toUpperCase().replace(/-/g, "_")}`,
+        useValue: config
+      }))
+    ];
+  }
+  /**
+   * Create providers from async options
+   */
+  static createAsyncProviders(options) {
+    const providers = [];
+    if (options.useFactory) {
+      providers.push({
+        provide: CREWS_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        inject: options.inject ?? []
+      });
+    }
+    return providers;
+  }
+};
+
+// src/nestjs/crews.service.ts
+var CrewsService = class {
+  crews = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Initialize module
+   */
+  async onModuleInit() {
+    for (const config of this.options.crews ?? []) {
+      await this.registerCrew(config);
+    }
+  }
+  /**
+   * Cleanup on module destroy
+   */
+  onModuleDestroy() {
+    for (const managed of this.crews.values()) {
+      if (managed.crew.getStatus().state === "running") {
+        managed.crew.abort();
+      }
+      managed.dashboard?.stop();
+    }
+    this.crews.clear();
+    return Promise.resolve();
+  }
+  // ============ Crew Management ============
+  /**
+   * Register a crew
+   */
+  registerCrew(config) {
+    if (this.crews.has(config.name)) {
+      throw new Error(`Crew already registered: ${config.name}`);
+    }
+    const crew = createCrew({
+      ...config,
+      delegationStrategy: config.delegationStrategy ?? this.options.defaultStrategy
+    });
+    const managed = { crew };
+    if (this.options.enableMonitoring) {
+      managed.dashboard = new CrewDashboard(crew);
+      managed.dashboard.start();
+    }
+    if (this.options.enableDebug) {
+      managed.debugMode = new DebugMode(crew);
+      managed.debugMode.enable();
+    }
+    this.crews.set(config.name, managed);
+    return Promise.resolve(crew);
+  }
+  /**
+   * Unregister a crew
+   */
+  unregisterCrew(name) {
+    const managed = this.crews.get(name);
+    if (!managed) return false;
+    managed.dashboard?.stop();
+    managed.debugMode?.disable();
+    return this.crews.delete(name);
+  }
+  /**
+   * Get a crew by name
+   */
+  getCrew(name) {
+    return this.crews.get(name)?.crew;
+  }
+  /**
+   * Get all crew names
+   */
+  getCrewNames() {
+    return Array.from(this.crews.keys());
+  }
+  /**
+   * Check if crew exists
+   */
+  hasCrew(name) {
+    return this.crews.has(name);
+  }
+  // ============ Execution ============
+  /**
+   * Run a crew
+   */
+  async runCrew(name, options) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    return crew.kickoff(options);
+  }
+  /**
+   * Run a crew with streaming
+   */
+  async *runCrewStream(name, options) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    yield* crew.kickoffStream(options);
+  }
+  /**
+   * Run crew with callback for events
+   */
+  async runCrewWithCallback(name, onEvent, options) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    const events = [];
+    for await (const event of crew.kickoffStream(options)) {
+      events.push(event);
+      onEvent(event);
+    }
+    const taskResults = Array.from(crew.getTasks()).filter((t) => t.getState().result).map((t) => t.getState().result);
+    return {
+      success: crew.getStatus().state === "completed",
+      taskResults,
+      metrics: crew.getMetrics(),
+      timeline: crew.getTimeline(),
+      finalOutput: taskResults.map((r) => r.output).join("\n\n"),
+      events
+    };
+  }
+  // ============ Control ============
+  /**
+   * Pause a crew
+   */
+  pauseCrew(name) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    crew.pause();
+  }
+  /**
+   * Resume a crew
+   */
+  resumeCrew(name) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    crew.resume();
+  }
+  /**
+   * Abort a crew
+   */
+  abortCrew(name) {
+    const crew = this.getCrew(name);
+    if (!crew) {
+      throw new Error(`Crew not found: ${name}`);
+    }
+    crew.abort();
+  }
+  // ============ Monitoring ============
+  /**
+   * Get dashboard for a crew
+   */
+  getDashboard(name) {
+    return this.crews.get(name)?.dashboard;
+  }
+  /**
+   * Get debug mode for a crew
+   */
+  getDebugMode(name) {
+    return this.crews.get(name)?.debugMode;
+  }
+  /**
+   * Get crew status
+   */
+  getCrewStatus(name) {
+    return this.getCrew(name)?.getStatus();
+  }
+  /**
+   * Get crew metrics
+   */
+  getCrewMetrics(name) {
+    return this.getCrew(name)?.getMetrics();
+  }
+  /**
+   * Get all crews status
+   */
+  getAllStatus() {
+    const statuses = /* @__PURE__ */ new Map();
+    for (const [name, managed] of this.crews) {
+      statuses.set(name, managed.crew.getStatus());
+    }
+    return statuses;
+  }
+  // ============ Health ============
+  /**
+   * Health check
+   */
+  healthCheck() {
+    const crewsHealth = [];
+    let allHealthy = true;
+    for (const [name, managed] of this.crews) {
+      const status = managed.crew.getStatus();
+      const healthy = status.state !== "failed";
+      crewsHealth.push({
+        name,
+        status: status.state,
+        healthy
+      });
+      if (!healthy) {
+        allHealthy = false;
+      }
+    }
+    return Promise.resolve({
+      healthy: allHealthy,
+      crews: crewsHealth
+    });
+  }
+};
+function createCrewsService(options) {
+  return new CrewsService(options);
+}
+
+// src/nestjs/decorators.ts
+import "reflect-metadata";
+var CREW_METADATA = "crews:crew";
+var ROLE_METADATA = "crews:role";
+var TASK_METADATA = "crews:task";
+var ON_CREW_EVENT_METADATA = "crews:on_event";
+var INJECT_CREW_METADATA = "crews:inject_crew";
+function CrewDef(config) {
+  return (target) => {
+    Reflect.defineMetadata(CREW_METADATA, config, target);
+  };
+}
+function RoleDef(config) {
+  return (target, propertyKey) => {
+    const existingRoles = Reflect.getMetadata(ROLE_METADATA, target.constructor) || [];
+    existingRoles.push({
+      propertyKey,
+      config
+    });
+    Reflect.defineMetadata(ROLE_METADATA, existingRoles, target.constructor);
+  };
+}
+function TaskDef(config) {
+  return (target, propertyKey, descriptor) => {
+    const existingTasks = Reflect.getMetadata(TASK_METADATA, target.constructor) || [];
+    existingTasks.push({
+      methodKey: propertyKey,
+      config,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(TASK_METADATA, existingTasks, target.constructor);
+  };
+}
+function OnCrewEvent(eventType) {
+  return (target, propertyKey, descriptor) => {
+    const existingHandlers = Reflect.getMetadata(ON_CREW_EVENT_METADATA, target.constructor) || [];
+    existingHandlers.push({
+      eventType,
+      methodKey: propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(
+      ON_CREW_EVENT_METADATA,
+      existingHandlers,
+      target.constructor
+    );
+  };
+}
+function InjectCrew(name) {
+  return (target, propertyKey, parameterIndex) => {
+    const existingInjections = Reflect.getMetadata(INJECT_CREW_METADATA, target) || [];
+    existingInjections.push({
+      index: parameterIndex,
+      name
+    });
+    Reflect.defineMetadata(INJECT_CREW_METADATA, existingInjections, target);
+  };
+}
+function getCrewMetadata(target) {
+  return Reflect.getMetadata(CREW_METADATA, target);
+}
+function getRoleMetadata(target) {
+  return Reflect.getMetadata(ROLE_METADATA, target) || [];
+}
+function getTaskMetadata(target) {
+  return Reflect.getMetadata(TASK_METADATA, target) || [];
+}
+function getEventHandlerMetadata(target) {
+  return Reflect.getMetadata(ON_CREW_EVENT_METADATA, target) || [];
+}
+function getInjectCrewMetadata(target) {
+  return Reflect.getMetadata(INJECT_CREW_METADATA, target) || [];
+}
+function RequireCapability(...capabilities) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:required_capabilities", target.constructor) || {};
+    existing[propertyKey] = capabilities;
+    Reflect.defineMetadata(
+      "crews:required_capabilities",
+      existing,
+      target.constructor
+    );
+  };
+}
+function Priority(priority) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:task_priority", target.constructor) || {};
+    existing[propertyKey] = priority;
+    Reflect.defineMetadata("crews:task_priority", existing, target.constructor);
+  };
+}
+function Timeout(ms) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:task_timeout", target.constructor) || {};
+    existing[propertyKey] = ms;
+    Reflect.defineMetadata("crews:task_timeout", existing, target.constructor);
+  };
+}
+function Retry(maxRetries) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:task_retries", target.constructor) || {};
+    existing[propertyKey] = maxRetries;
+    Reflect.defineMetadata("crews:task_retries", existing, target.constructor);
+  };
+}
+function DependsOn(...taskNames) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:task_dependencies", target.constructor) || {};
+    existing[propertyKey] = taskNames;
+    Reflect.defineMetadata(
+      "crews:task_dependencies",
+      existing,
+      target.constructor
+    );
+  };
+}
+function AssignTo(agentName) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata("crews:task_assignment", target.constructor) || {};
+    existing[propertyKey] = agentName;
+    Reflect.defineMetadata(
+      "crews:task_assignment",
+      existing,
+      target.constructor
+    );
+  };
+}
+export {
+  AssignTo,
+  CREWS_MODULE_OPTIONS,
+  CREWS_SERVICE,
+  CrewDef,
+  CrewsModule,
+  CrewsService,
+  DependsOn,
+  InjectCrew,
+  OnCrewEvent,
+  Priority,
+  RequireCapability,
+  Retry,
+  RoleDef,
+  TaskDef,
+  Timeout,
+  createCrewsService,
+  getCrewMetadata,
+  getEventHandlerMetadata,
+  getInjectCrewMetadata,
+  getRoleMetadata,
+  getTaskMetadata
+};