@lov3kaizen/agentsea-crews 1.1.0 → 1.2.0

package/dist/nestjs/index.d.ts

@@ -0,0 +1,98 @@
+import { DynamicModule, Type, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { e as CrewConfig, D as DelegationStrategyType, a as Crew, f as CrewExecutionOptions, g as CrewResult, b as CrewEvent, R as RoleConfig, d as TaskConfig } from '../Crew-BnvVjN7A.js';
+import { C as CrewDashboard, D as DebugMode } from '../DebugMode-o5e9gmQ7.js';
+import 'eventemitter3';
+
+interface CrewsModuleOptions {
+    crews?: CrewConfig[];
+    defaultStrategy?: DelegationStrategyType;
+    enableMonitoring?: boolean;
+    enableDebug?: boolean;
+    global?: boolean;
+}
+interface CrewsModuleAsyncOptions {
+    imports?: Type<unknown>[];
+    useFactory?: (...args: unknown[]) => Promise<CrewsModuleOptions> | CrewsModuleOptions;
+    inject?: unknown[];
+    global?: boolean;
+}
+declare const CREWS_MODULE_OPTIONS = "CREWS_MODULE_OPTIONS";
+declare const CREWS_SERVICE = "CREWS_SERVICE";
+declare class CrewsModule {
+    static forRoot(options?: CrewsModuleOptions): DynamicModule;
+    static forRootAsync(options: CrewsModuleAsyncOptions): DynamicModule;
+    static forFeature(crews: CrewConfig[]): DynamicModule;
+    private static createProviders;
+    private static createAsyncProviders;
+}
+
+interface ManagedCrew {
+    crew: Crew;
+    dashboard?: CrewDashboard;
+    debugMode?: DebugMode;
+}
+declare class CrewsService implements OnModuleInit, OnModuleDestroy {
+    private readonly crews;
+    private readonly options;
+    constructor(options?: CrewsModuleOptions);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    registerCrew(config: CrewConfig): Promise<Crew>;
+    unregisterCrew(name: string): boolean;
+    getCrew(name: string): Crew | undefined;
+    getCrewNames(): string[];
+    hasCrew(name: string): boolean;
+    runCrew(name: string, options?: CrewExecutionOptions): Promise<CrewResult>;
+    runCrewStream(name: string, options?: CrewExecutionOptions): AsyncGenerator<CrewEvent>;
+    runCrewWithCallback(name: string, onEvent: (event: CrewEvent) => void, options?: CrewExecutionOptions): Promise<CrewResult>;
+    pauseCrew(name: string): void;
+    resumeCrew(name: string): void;
+    abortCrew(name: string): void;
+    getDashboard(name: string): CrewDashboard | undefined;
+    getDebugMode(name: string): DebugMode | undefined;
+    getCrewStatus(name: string): ReturnType<Crew['getStatus']> | undefined;
+    getCrewMetrics(name: string): ReturnType<Crew['getMetrics']> | undefined;
+    getAllStatus(): Map<string, ReturnType<Crew['getStatus']>>;
+    healthCheck(): Promise<{
+        healthy: boolean;
+        crews: Array<{
+            name: string;
+            status: string;
+            healthy: boolean;
+        }>;
+    }>;
+}
+declare function createCrewsService(options?: CrewsModuleOptions): CrewsService;
+
+declare function CrewDef(config: Partial<CrewConfig>): ClassDecorator;
+declare function RoleDef(config: RoleConfig): PropertyDecorator;
+declare function TaskDef(config: Partial<TaskConfig>): MethodDecorator;
+declare function OnCrewEvent(eventType: string): MethodDecorator;
+declare function InjectCrew(name?: string): ParameterDecorator;
+declare function getCrewMetadata(target: Function): Partial<CrewConfig> | undefined;
+declare function getRoleMetadata(target: Function): Array<{
+    propertyKey: string | symbol;
+    config: RoleConfig;
+}>;
+declare function getTaskMetadata(target: Function): Array<{
+    methodKey: string | symbol;
+    config: Partial<TaskConfig>;
+    handler: Function;
+}>;
+declare function getEventHandlerMetadata(target: Function): Array<{
+    eventType: string;
+    methodKey: string | symbol;
+    handler: Function;
+}>;
+declare function getInjectCrewMetadata(target: Function): Array<{
+    index: number;
+    name?: string;
+}>;
+declare function RequireCapability(...capabilities: string[]): PropertyDecorator;
+declare function Priority(priority: 'critical' | 'high' | 'medium' | 'low'): MethodDecorator;
+declare function Timeout(ms: number): MethodDecorator;
+declare function Retry(maxRetries: number): MethodDecorator;
+declare function DependsOn(...taskNames: string[]): MethodDecorator;
+declare function AssignTo(agentName: string): MethodDecorator;
+
+export { AssignTo, CREWS_MODULE_OPTIONS, CREWS_SERVICE, CrewDef, CrewsModule, type CrewsModuleAsyncOptions, type CrewsModuleOptions, CrewsService, DependsOn, InjectCrew, type ManagedCrew, OnCrewEvent, Priority, RequireCapability, Retry, RoleDef, TaskDef, Timeout, createCrewsService, getCrewMetadata, getEventHandlerMetadata, getInjectCrewMetadata, getRoleMetadata, getTaskMetadata };

package/dist/nestjs/index.js

@@ -340,8 +340,37 @@ Background: ${this.backstory}`);
   }
 };
 
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var import_node_crypto = require("crypto");
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    import_node_crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
 // src/core/Task.ts
-var import_nanoid = require("nanoid");
 var Task = class _Task {
   id;
   description;
@@ -361,7 +390,7 @@ var Task = class _Task {
   _result;
   _metadata;
   constructor(config) {
-    this.id = config.id ?? (0, import_nanoid.nanoid)();
+    this.id = config.id ?? nanoid();
     this.description = config.description;
     this.expectedOutput = config.expectedOutput;
     this.priority = config.priority ?? "medium";
@@ -967,7 +996,6 @@ var TaskQueue = class {
 
 // src/core/ExecutionContext.ts
 var import_eventemitter3 = __toESM(require("eventemitter3"));
-var import_nanoid2 = require("nanoid");
 var ExecutionContext = class {
   crewId;
   crewName;
@@ -984,7 +1012,7 @@ var ExecutionContext = class {
   startTime;
   endTime;
   constructor(config) {
-    this.crewId = config.crewId ?? (0, import_nanoid2.nanoid)();
+    this.crewId = config.crewId ?? nanoid();
     this.crewName = config.crewName;
     this.state = /* @__PURE__ */ new Map();
     this.completedTasks = /* @__PURE__ */ new Map();
@@ -1230,7 +1258,7 @@ var ExecutionContext = class {
    */
   createCheckpoint() {
     return {
-      id: (0, import_nanoid2.nanoid)(),
+      id: nanoid(),
       timestamp: /* @__PURE__ */ new Date(),
       crewId: this.crewId,
       crewName: this.crewName,
@@ -1316,12 +1344,6 @@ var ExecutionContext = class {
   }
 };
 
-// src/core/Crew.ts
-var import_nanoid4 = require("nanoid");
-
-// src/agents/CrewAgent.ts
-var import_nanoid3 = require("nanoid");
-
 // src/agents/AgentCapabilities.ts
 var PROFICIENCY_WEIGHTS = {
   novice: 0.25,
@@ -1606,7 +1628,7 @@ var CrewAgent = class _CrewAgent {
   totalTokensUsed = 0;
   constructor(options) {
     const { config, execute } = options;
-    this.id = (0, import_nanoid3.nanoid)();
+    this.id = nanoid();
     this.name = config.name;
     this.role = new Role(config.role);
     this.capabilities = config.role.capabilities;
@@ -1803,7 +1825,7 @@ ${JSON.stringify(task.context, null, 2)}`);
    */
   createHelpRequest(taskId, request) {
     return {
-      requestId: (0, import_nanoid3.nanoid)(),
+      requestId: nanoid(),
       fromAgent: this.name,
       taskId,
       request
@@ -4248,7 +4270,7 @@ var Crew = class {
   timeline = [];
   results = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.id = (0, import_nanoid4.nanoid)();
+    this.id = nanoid();
     this.name = config.name;
     this.description = config.description;
     this.config = config;
@@ -4397,27 +4419,40 @@ var Crew = class {
           await this.sleep(100);
           continue;
         }
-        for (const task of readyTasks) {
-          if (this.state !== "running") break;
-          const delegationResult = await this.delegateTask(task, options);
-          yield this.createEvent({
-            type: "task:assigned",
-            taskId: task.id,
-            agentName: delegationResult.selectedAgent,
-            reason: delegationResult.reason,
-            strategy: this.config.delegationStrategy
-          });
-          const taskResult = await this.executeTask(task, delegationResult);
-          yield this.createEvent({
-            type: "task:completed",
-            taskId: task.id,
-            result: taskResult,
-            agentName: delegationResult.selectedAgent,
-            durationMs: taskResult.latencyMs ?? 0
-          });
-          while (eventQueue.length > 0) {
-            yield eventQueue.shift();
+        const concurrency = Math.max(
+          1,
+          options.maxConcurrentTasks ?? this.config.maxConcurrentTasks ?? 1
+        );
+        if (concurrency === 1) {
+          for (const task of readyTasks) {
+            if (this.state !== "running") break;
+            const delegationResult = await this.delegateTask(task, options);
+            yield this.createEvent({
+              type: "task:assigned",
+              taskId: task.id,
+              agentName: delegationResult.selectedAgent,
+              reason: delegationResult.reason,
+              strategy: this.config.delegationStrategy
+            });
+            const taskResult = await this.executeTask(task, delegationResult);
+            yield this.createEvent({
+              type: "task:completed",
+              taskId: task.id,
+              result: taskResult,
+              agentName: delegationResult.selectedAgent,
+              durationMs: taskResult.latencyMs ?? 0
+            });
+            while (eventQueue.length > 0) {
+              yield eventQueue.shift();
+            }
           }
+        } else {
+          yield* this.processReadyTasksConcurrently(
+            readyTasks,
+            options,
+            eventQueue,
+            concurrency
+          );
         }
         while (this.state === "paused") {
           await this.sleep(100);
@@ -4460,6 +4495,78 @@ var Crew = class {
     });
     this.addTimelineEntry("crew_completed", this.name);
   }
+  /**
+   * Execute a batch of ready tasks concurrently with a bounded worker pool.
+   *
+   * Each task still emits its `task:assigned` and `task:completed` events in
+   * order relative to itself, but events across tasks are interleaved as the
+   * workers settle. At most `concurrency` tasks run at once. If any task throws
+   * (after exhausting retries), no further tasks are started, in-flight tasks
+   * are allowed to settle, and the first error is rethrown so the caller's
+   * error handling (crew:error) behaves identically to the sequential path.
+   */
+  async *processReadyTasksConcurrently(readyTasks, options, eventQueue, concurrency) {
+    let nextIndex = 0;
+    let firstError;
+    const buffer = [];
+    const inFlight = /* @__PURE__ */ new Set();
+    const launch = (task) => {
+      const worker = (async () => {
+        const delegationResult = await this.delegateTask(task, options);
+        buffer.push(
+          this.createEvent({
+            type: "task:assigned",
+            taskId: task.id,
+            agentName: delegationResult.selectedAgent,
+            reason: delegationResult.reason,
+            strategy: this.config.delegationStrategy
+          })
+        );
+        const taskResult = await this.executeTask(task, delegationResult);
+        buffer.push(
+          this.createEvent({
+            type: "task:completed",
+            taskId: task.id,
+            result: taskResult,
+            agentName: delegationResult.selectedAgent,
+            durationMs: taskResult.latencyMs ?? 0
+          })
+        );
+      })().catch((error) => {
+        if (firstError === void 0) {
+          firstError = error;
+        }
+      }).finally(() => {
+        inFlight.delete(worker);
+      });
+      inFlight.add(worker);
+    };
+    const fill = () => {
+      while (inFlight.size < concurrency && nextIndex < readyTasks.length && this.state === "running" && firstError === void 0) {
+        launch(readyTasks[nextIndex++]);
+      }
+    };
+    fill();
+    while (inFlight.size > 0) {
+      await Promise.race(inFlight);
+      while (buffer.length > 0) {
+        yield buffer.shift();
+      }
+      while (eventQueue.length > 0) {
+        yield eventQueue.shift();
+      }
+      fill();
+    }
+    while (buffer.length > 0) {
+      yield buffer.shift();
+    }
+    while (eventQueue.length > 0) {
+      yield eventQueue.shift();
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
   /**
    * Delegate a task to an agent
    */
@@ -4679,7 +4786,7 @@ ${r.output}`).join("\n\n---\n\n");
    */
   createCheckpoint() {
     return {
-      id: (0, import_nanoid4.nanoid)(),
+      id: nanoid(),
       crewId: this.id,
       crewName: this.name,
       timestamp: /* @__PURE__ */ new Date(),

package/dist/nestjs/index.mjs

@@ -4,7 +4,7 @@ import {
 } from "../chunk-4PF73ECN.mjs";
 import {
   createCrew
-} from "../chunk-V6VK6BOL.mjs";
+} from "../chunk-J5KQSOGT.mjs";
 
 // src/nestjs/crews.module.ts
 var CREWS_MODULE_OPTIONS = "CREWS_MODULE_OPTIONS";

package/dist/templates/index.d.mts

@@ -0,0 +1,78 @@
+import { d as TaskConfig, a as Crew, e as CrewConfig } from '../Crew-BnvVjN7A.mjs';
+
+interface ResearchCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    includeWriter?: boolean;
+    depth?: 'shallow' | 'standard' | 'deep';
+    tools?: string[];
+}
+declare function createResearchCrewConfig(options?: ResearchCrewOptions): CrewConfig;
+declare function createResearchCrew(options?: ResearchCrewOptions): Crew;
+declare const ResearchTasks: {
+    research(topic: string, depth?: "shallow" | "standard" | "deep"): TaskConfig;
+    analyze(data: string, focusAreas?: string[]): TaskConfig;
+    writeReport(topic: string, format?: "summary" | "detailed" | "executive"): TaskConfig;
+};
+
+interface WritingCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    contentType?: 'blog' | 'technical' | 'marketing' | 'creative' | 'general';
+    audience?: string;
+    tools?: string[];
+}
+declare function createWritingCrewConfig(options?: WritingCrewOptions): CrewConfig;
+declare function createWritingCrew(options?: WritingCrewOptions): Crew;
+declare const WritingTasks: {
+    draft(topic: string, wordCount?: number, style?: string): TaskConfig;
+    edit(content: string, focusAreas?: string[]): TaskConfig;
+    proofread(content: string): TaskConfig;
+    blogPost(topic: string, keywords?: string[]): TaskConfig;
+    technicalDoc(subject: string, audience?: "beginner" | "intermediate" | "advanced"): TaskConfig;
+};
+
+interface CodeReviewCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    languages?: string[];
+    includeSecurity?: boolean;
+    includePerformance?: boolean;
+    strictness?: 'relaxed' | 'standard' | 'strict';
+    tools?: string[];
+}
+declare function createCodeReviewCrewConfig(options?: CodeReviewCrewOptions): CrewConfig;
+declare function createCodeReviewCrew(options?: CodeReviewCrewOptions): Crew;
+declare const CodeReviewTasks: {
+    review(code: string, language?: string, context?: string): TaskConfig;
+    securityReview(code: string, language?: string): TaskConfig;
+    performanceReview(code: string, language?: string): TaskConfig;
+    pullRequestReview(diff: string, prDescription?: string): TaskConfig;
+    architectureReview(description: string, codebase?: string): TaskConfig;
+};
+
+interface CustomerSupportCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    productName?: string;
+    companyName?: string;
+    supportStyle?: 'formal' | 'friendly' | 'technical';
+    includeSpecialist?: boolean;
+    includeEscalation?: boolean;
+    tools?: string[];
+}
+declare function createCustomerSupportCrewConfig(options?: CustomerSupportCrewOptions): CrewConfig;
+declare function createCustomerSupportCrew(options?: CustomerSupportCrewOptions): Crew;
+declare const CustomerSupportTasks: {
+    handleTicket(customerMessage: string, priority?: "low" | "normal" | "high" | "urgent", customerTier?: string): TaskConfig;
+    resolveTechnicalIssue(issueDescription: string, errorLogs?: string, environment?: string): TaskConfig;
+    handleEscalation(caseHistory: string, customerSentiment?: "frustrated" | "angry" | "neutral", businessImpact?: string): TaskConfig;
+    respondToFeedback(feedback: string, sentiment: "positive" | "neutral" | "negative"): TaskConfig;
+    createKnowledgeBaseArticle(topic: string, resolution: string): TaskConfig;
+};
+
+export { type CodeReviewCrewOptions, CodeReviewTasks, type CustomerSupportCrewOptions, CustomerSupportTasks, type ResearchCrewOptions, ResearchTasks, type WritingCrewOptions, WritingTasks, createCodeReviewCrew, createCodeReviewCrewConfig, createCustomerSupportCrew, createCustomerSupportCrewConfig, createResearchCrew, createResearchCrewConfig, createWritingCrew, createWritingCrewConfig };

package/dist/templates/index.d.ts

@@ -0,0 +1,78 @@
+import { d as TaskConfig, a as Crew, e as CrewConfig } from '../Crew-BnvVjN7A.js';
+
+interface ResearchCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    includeWriter?: boolean;
+    depth?: 'shallow' | 'standard' | 'deep';
+    tools?: string[];
+}
+declare function createResearchCrewConfig(options?: ResearchCrewOptions): CrewConfig;
+declare function createResearchCrew(options?: ResearchCrewOptions): Crew;
+declare const ResearchTasks: {
+    research(topic: string, depth?: "shallow" | "standard" | "deep"): TaskConfig;
+    analyze(data: string, focusAreas?: string[]): TaskConfig;
+    writeReport(topic: string, format?: "summary" | "detailed" | "executive"): TaskConfig;
+};
+
+interface WritingCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    contentType?: 'blog' | 'technical' | 'marketing' | 'creative' | 'general';
+    audience?: string;
+    tools?: string[];
+}
+declare function createWritingCrewConfig(options?: WritingCrewOptions): CrewConfig;
+declare function createWritingCrew(options?: WritingCrewOptions): Crew;
+declare const WritingTasks: {
+    draft(topic: string, wordCount?: number, style?: string): TaskConfig;
+    edit(content: string, focusAreas?: string[]): TaskConfig;
+    proofread(content: string): TaskConfig;
+    blogPost(topic: string, keywords?: string[]): TaskConfig;
+    technicalDoc(subject: string, audience?: "beginner" | "intermediate" | "advanced"): TaskConfig;
+};
+
+interface CodeReviewCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    languages?: string[];
+    includeSecurity?: boolean;
+    includePerformance?: boolean;
+    strictness?: 'relaxed' | 'standard' | 'strict';
+    tools?: string[];
+}
+declare function createCodeReviewCrewConfig(options?: CodeReviewCrewOptions): CrewConfig;
+declare function createCodeReviewCrew(options?: CodeReviewCrewOptions): Crew;
+declare const CodeReviewTasks: {
+    review(code: string, language?: string, context?: string): TaskConfig;
+    securityReview(code: string, language?: string): TaskConfig;
+    performanceReview(code: string, language?: string): TaskConfig;
+    pullRequestReview(diff: string, prDescription?: string): TaskConfig;
+    architectureReview(description: string, codebase?: string): TaskConfig;
+};
+
+interface CustomerSupportCrewOptions {
+    name?: string;
+    model?: string;
+    provider?: string;
+    productName?: string;
+    companyName?: string;
+    supportStyle?: 'formal' | 'friendly' | 'technical';
+    includeSpecialist?: boolean;
+    includeEscalation?: boolean;
+    tools?: string[];
+}
+declare function createCustomerSupportCrewConfig(options?: CustomerSupportCrewOptions): CrewConfig;
+declare function createCustomerSupportCrew(options?: CustomerSupportCrewOptions): Crew;
+declare const CustomerSupportTasks: {
+    handleTicket(customerMessage: string, priority?: "low" | "normal" | "high" | "urgent", customerTier?: string): TaskConfig;
+    resolveTechnicalIssue(issueDescription: string, errorLogs?: string, environment?: string): TaskConfig;
+    handleEscalation(caseHistory: string, customerSentiment?: "frustrated" | "angry" | "neutral", businessImpact?: string): TaskConfig;
+    respondToFeedback(feedback: string, sentiment: "positive" | "neutral" | "negative"): TaskConfig;
+    createKnowledgeBaseArticle(topic: string, resolution: string): TaskConfig;
+};
+
+export { type CodeReviewCrewOptions, CodeReviewTasks, type CustomerSupportCrewOptions, CustomerSupportTasks, type ResearchCrewOptions, ResearchTasks, type WritingCrewOptions, WritingTasks, createCodeReviewCrew, createCodeReviewCrewConfig, createCustomerSupportCrew, createCustomerSupportCrewConfig, createResearchCrew, createResearchCrewConfig, createWritingCrew, createWritingCrewConfig };