moflo 4.8.19 → 4.8.20

package/src/@claude-flow/shared/dist/core/config/schema.js

@@ -0,0 +1,158 @@
+/**
+ * V3 Configuration Schemas
+ * Zod schemas for all configuration types
+ */
+import { z } from 'zod';
+/**
+ * Agent configuration schema
+ */
+export const AgentConfigSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    type: z.string().min(1),
+    capabilities: z.array(z.string()).default([]),
+    maxConcurrentTasks: z.number().int().min(1).default(5),
+    priority: z.number().int().min(0).max(100).default(50),
+    timeout: z.number().int().positive().optional(),
+    retryPolicy: z.object({
+        maxRetries: z.number().int().min(0).default(3),
+        backoffMs: z.number().int().positive().default(1000),
+        backoffMultiplier: z.number().positive().default(2),
+    }).optional(),
+    resources: z.object({
+        maxMemoryMb: z.number().int().positive().optional(),
+        maxCpuPercent: z.number().min(0).max(100).optional(),
+    }).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+/**
+ * Task configuration schema
+ */
+export const TaskConfigSchema = z.object({
+    type: z.string().min(1),
+    description: z.string().min(1),
+    priority: z.number().int().min(0).max(100).default(50),
+    timeout: z.number().int().positive().optional(),
+    assignedAgent: z.string().optional(),
+    input: z.record(z.unknown()).optional(),
+    metadata: z.object({
+        requiredCapabilities: z.array(z.string()).optional(),
+        retryCount: z.number().int().min(0).optional(),
+        maxRetries: z.number().int().min(0).optional(),
+        critical: z.boolean().optional(),
+        parentTaskId: z.string().optional(),
+        childTaskIds: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+    }).optional(),
+});
+/**
+ * Swarm configuration schema
+ */
+export const SwarmConfigSchema = z.object({
+    topology: z.enum(['hierarchical', 'mesh', 'ring', 'star', 'adaptive', 'hierarchical-mesh']),
+    maxAgents: z.number().int().positive().default(20),
+    autoScale: z.object({
+        enabled: z.boolean().default(false),
+        minAgents: z.number().int().min(0).default(1),
+        maxAgents: z.number().int().positive().default(20),
+        scaleUpThreshold: z.number().min(0).max(1).default(0.8),
+        scaleDownThreshold: z.number().min(0).max(1).default(0.3),
+    }).optional(),
+    coordination: z.object({
+        consensusRequired: z.boolean().default(false),
+        timeoutMs: z.number().int().positive().default(10000),
+        retryPolicy: z.object({
+            maxRetries: z.number().int().min(0).default(3),
+            backoffMs: z.number().int().positive().default(500),
+        }),
+    }).optional(),
+    communication: z.object({
+        protocol: z.enum(['events', 'messages', 'shared-memory']).default('events'),
+        batchSize: z.number().int().positive().default(10),
+        flushIntervalMs: z.number().int().positive().default(100),
+    }).optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+/**
+ * Memory configuration schema
+ */
+export const MemoryConfigSchema = z.object({
+    type: z.enum(['sqlite', 'agentdb', 'hybrid', 'redis', 'memory']).default('hybrid'),
+    path: z.string().optional(),
+    maxSize: z.number().int().positive().optional(),
+    ttlMs: z.number().int().positive().optional(),
+    sqlite: z.object({
+        filename: z.string().optional(),
+        inMemory: z.boolean().default(false),
+        wal: z.boolean().default(true),
+    }).optional(),
+    agentdb: z.object({
+        dimensions: z.number().int().positive().default(1536),
+        indexType: z.enum(['hnsw', 'flat', 'ivf']).default('hnsw'),
+        efConstruction: z.number().int().positive().default(200),
+        m: z.number().int().positive().default(16),
+        quantization: z.enum(['none', 'scalar', 'product']).default('none'),
+    }).optional(),
+    redis: z.object({
+        host: z.string().default('localhost'),
+        port: z.number().int().positive().default(6379),
+        password: z.string().optional(),
+        db: z.number().int().min(0).default(0),
+        keyPrefix: z.string().default('claude-flow:'),
+    }).optional(),
+    hybrid: z.object({
+        vectorThreshold: z.number().int().positive().default(100),
+    }).optional(),
+});
+/**
+ * MCP server configuration schema
+ */
+export const MCPServerConfigSchema = z.object({
+    name: z.string().min(1).default('moflo'),
+    version: z.string().min(1).default('3.0.0'),
+    transport: z.object({
+        type: z.enum(['stdio', 'http', 'websocket']).default('stdio'),
+        port: z.number().int().positive().optional(),
+        host: z.string().optional(),
+        path: z.string().optional(),
+    }),
+    capabilities: z.object({
+        tools: z.boolean().default(true),
+        resources: z.boolean().default(true),
+        prompts: z.boolean().default(true),
+        logging: z.boolean().default(true),
+        experimental: z.record(z.boolean()).optional(),
+    }).optional(),
+});
+/**
+ * Orchestrator configuration schema
+ */
+export const OrchestratorConfigSchema = z.object({
+    session: z.object({
+        persistSessions: z.boolean().default(true),
+        dataDir: z.string().default('./data'),
+        sessionRetentionMs: z.number().int().positive().default(3600000),
+    }),
+    health: z.object({
+        checkInterval: z.number().int().positive().default(30000),
+        historyLimit: z.number().int().positive().default(100),
+        degradedThreshold: z.number().int().min(0).default(1),
+        unhealthyThreshold: z.number().int().min(0).default(2),
+    }),
+    lifecycle: z.object({
+        maxConcurrentAgents: z.number().int().positive().default(20),
+        spawnTimeout: z.number().int().positive().default(30000),
+        terminateTimeout: z.number().int().positive().default(10000),
+        maxSpawnRetries: z.number().int().min(0).default(3),
+    }),
+});
+/**
+ * Full system configuration schema
+ */
+export const SystemConfigSchema = z.object({
+    orchestrator: OrchestratorConfigSchema,
+    memory: MemoryConfigSchema.optional(),
+    mcp: MCPServerConfigSchema.optional(),
+    swarm: SwarmConfigSchema.optional(),
+});
+//# sourceMappingURL=schema.js.map

package/src/@claude-flow/shared/dist/core/config/validator.d.ts

@@ -0,0 +1,92 @@
+/**
+ * V3 Configuration Validator
+ * Validation logic using Zod schemas
+ */
+import { z } from 'zod';
+import { type AgentConfig, type TaskConfig, type SwarmConfig, type MemoryConfig, type MCPServerConfig, type OrchestratorConfig, type SystemConfig } from './schema.js';
+/**
+ * Validation result
+ */
+export interface ValidationResult<T> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationError[];
+}
+/**
+ * Validation error
+ */
+export interface ValidationError {
+    path: string;
+    message: string;
+    code: string;
+}
+/**
+ * Validate agent configuration
+ */
+export declare function validateAgentConfig(data: unknown): ValidationResult<AgentConfig>;
+/**
+ * Validate task configuration
+ */
+export declare function validateTaskConfig(data: unknown): ValidationResult<TaskConfig>;
+/**
+ * Validate swarm configuration
+ */
+export declare function validateSwarmConfig(data: unknown): ValidationResult<SwarmConfig>;
+/**
+ * Validate memory configuration
+ */
+export declare function validateMemoryConfig(data: unknown): ValidationResult<MemoryConfig>;
+/**
+ * Validate MCP server configuration
+ */
+export declare function validateMCPServerConfig(data: unknown): ValidationResult<MCPServerConfig>;
+/**
+ * Validate orchestrator configuration
+ */
+export declare function validateOrchestratorConfig(data: unknown): ValidationResult<OrchestratorConfig>;
+/**
+ * Validate full system configuration
+ */
+export declare function validateSystemConfig(data: unknown): ValidationResult<SystemConfig>;
+/**
+ * Configuration validator class
+ */
+export declare class ConfigValidator {
+    /**
+     * Validate and throw on error
+     */
+    static validateOrThrow<TInput, TOutput>(schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>, data: unknown, configName: string): TOutput;
+    /**
+     * Validate agent config or throw
+     */
+    static validateAgentOrThrow(data: unknown): AgentConfig;
+    /**
+     * Validate task config or throw
+     */
+    static validateTaskOrThrow(data: unknown): TaskConfig;
+    /**
+     * Validate swarm config or throw
+     */
+    static validateSwarmOrThrow(data: unknown): SwarmConfig;
+    /**
+     * Validate memory config or throw
+     */
+    static validateMemoryOrThrow(data: unknown): MemoryConfig;
+    /**
+     * Validate MCP server config or throw
+     */
+    static validateMCPServerOrThrow(data: unknown): MCPServerConfig;
+    /**
+     * Validate orchestrator config or throw
+     */
+    static validateOrchestratorOrThrow(data: unknown): OrchestratorConfig;
+    /**
+     * Validate system config or throw
+     */
+    static validateSystemOrThrow(data: unknown): SystemConfig;
+    /**
+     * Check if data matches schema
+     */
+    static isValid<TInput, TOutput>(schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>, data: unknown): boolean;
+}
+//# sourceMappingURL=validator.d.ts.map

package/src/@claude-flow/shared/dist/core/config/validator.js

@@ -0,0 +1,147 @@
+/**
+ * V3 Configuration Validator
+ * Validation logic using Zod schemas
+ */
+import { z } from 'zod';
+import { AgentConfigSchema, TaskConfigSchema, SwarmConfigSchema, MemoryConfigSchema, MCPServerConfigSchema, OrchestratorConfigSchema, SystemConfigSchema, } from './schema.js';
+/**
+ * Convert Zod error to validation errors
+ */
+function zodErrorToValidationErrors(error) {
+    return error.errors.map((e) => ({
+        path: e.path.join('.'),
+        message: e.message,
+        code: e.code,
+    }));
+}
+/**
+ * Generic validation function
+ * Uses parse + try/catch to get output types with defaults applied
+ */
+function validate(schema, data) {
+    try {
+        const parsed = schema.parse(data);
+        return {
+            success: true,
+            data: parsed,
+        };
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            return {
+                success: false,
+                errors: zodErrorToValidationErrors(error),
+            };
+        }
+        throw error;
+    }
+}
+/**
+ * Validate agent configuration
+ */
+export function validateAgentConfig(data) {
+    return validate(AgentConfigSchema, data);
+}
+/**
+ * Validate task configuration
+ */
+export function validateTaskConfig(data) {
+    return validate(TaskConfigSchema, data);
+}
+/**
+ * Validate swarm configuration
+ */
+export function validateSwarmConfig(data) {
+    return validate(SwarmConfigSchema, data);
+}
+/**
+ * Validate memory configuration
+ */
+export function validateMemoryConfig(data) {
+    return validate(MemoryConfigSchema, data);
+}
+/**
+ * Validate MCP server configuration
+ */
+export function validateMCPServerConfig(data) {
+    return validate(MCPServerConfigSchema, data);
+}
+/**
+ * Validate orchestrator configuration
+ */
+export function validateOrchestratorConfig(data) {
+    return validate(OrchestratorConfigSchema, data);
+}
+/**
+ * Validate full system configuration
+ */
+export function validateSystemConfig(data) {
+    return validate(SystemConfigSchema, data);
+}
+/**
+ * Configuration validator class
+ */
+export class ConfigValidator {
+    /**
+     * Validate and throw on error
+     */
+    static validateOrThrow(schema, data, configName) {
+        const result = validate(schema, data);
+        if (!result.success) {
+            const errorMessages = result.errors
+                ?.map((e) => `  - ${e.path}: ${e.message}`)
+                .join('\n');
+            throw new Error(`Invalid ${configName} configuration:\n${errorMessages}`);
+        }
+        return result.data;
+    }
+    /**
+     * Validate agent config or throw
+     */
+    static validateAgentOrThrow(data) {
+        return this.validateOrThrow(AgentConfigSchema, data, 'agent');
+    }
+    /**
+     * Validate task config or throw
+     */
+    static validateTaskOrThrow(data) {
+        return this.validateOrThrow(TaskConfigSchema, data, 'task');
+    }
+    /**
+     * Validate swarm config or throw
+     */
+    static validateSwarmOrThrow(data) {
+        return this.validateOrThrow(SwarmConfigSchema, data, 'swarm');
+    }
+    /**
+     * Validate memory config or throw
+     */
+    static validateMemoryOrThrow(data) {
+        return this.validateOrThrow(MemoryConfigSchema, data, 'memory');
+    }
+    /**
+     * Validate MCP server config or throw
+     */
+    static validateMCPServerOrThrow(data) {
+        return this.validateOrThrow(MCPServerConfigSchema, data, 'MCP server');
+    }
+    /**
+     * Validate orchestrator config or throw
+     */
+    static validateOrchestratorOrThrow(data) {
+        return this.validateOrThrow(OrchestratorConfigSchema, data, 'orchestrator');
+    }
+    /**
+     * Validate system config or throw
+     */
+    static validateSystemOrThrow(data) {
+        return this.validateOrThrow(SystemConfigSchema, data, 'system');
+    }
+    /**
+     * Check if data matches schema
+     */
+    static isValid(schema, data) {
+        return validate(schema, data).success;
+    }
+}
+//# sourceMappingURL=validator.js.map

package/src/@claude-flow/shared/dist/core/event-bus.d.ts

@@ -0,0 +1,31 @@
+/**
+ * V3 Event Bus
+ * Core event pub/sub implementation
+ */
+import type { IEventBus, IEventCreate, IEventHandler, IEventSubscription, IEventFilter } from './interfaces/event.interface.js';
+/**
+ * Event bus implementation
+ */
+export declare class EventBus implements IEventBus {
+    private handlers;
+    private subscriptions;
+    private subscriptionId;
+    emit<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): void;
+    emitAsync<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): Promise<void>;
+    on<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
+    subscribe<T = unknown>(filter: IEventFilter, handler: IEventHandler<T>): IEventSubscription;
+    once<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
+    off(type: string, handler: IEventHandler): void;
+    removeAllListeners(type?: string): void;
+    listenerCount(type: string): number;
+    eventNames(): string[];
+    private createEvent;
+    private dispatchEvent;
+    private dispatchEventAsync;
+    private removeSubscription;
+}
+/**
+ * Create a new event bus instance
+ */
+export declare function createEventBus(): IEventBus;
+//# sourceMappingURL=event-bus.d.ts.map

package/src/@claude-flow/shared/dist/core/event-bus.js

@@ -0,0 +1,197 @@
+/**
+ * V3 Event Bus
+ * Core event pub/sub implementation
+ */
+import { randomBytes } from 'crypto';
+// Secure event ID generation
+function generateSecureEventId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(12).toString('hex');
+    return `evt_${timestamp}_${random}`;
+}
+/**
+ * Event subscription implementation
+ */
+class EventSubscription {
+    id;
+    filter;
+    removeCallback;
+    active = true;
+    paused = false;
+    constructor(id, filter, removeCallback) {
+        this.id = id;
+        this.filter = filter;
+        this.removeCallback = removeCallback;
+    }
+    unsubscribe() {
+        this.active = false;
+        this.removeCallback();
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+    }
+    isActive() {
+        return this.active && !this.paused;
+    }
+}
+/**
+ * Event bus implementation
+ */
+export class EventBus {
+    handlers = new Map();
+    subscriptions = new Map();
+    subscriptionId = 0;
+    emit(type, payload, options) {
+        const event = this.createEvent(type, payload, options);
+        this.dispatchEvent(event);
+    }
+    async emitAsync(type, payload, options) {
+        const event = this.createEvent(type, payload, options);
+        await this.dispatchEventAsync(event);
+    }
+    on(type, handler) {
+        return this.subscribe({ types: [type] }, handler);
+    }
+    subscribe(filter, handler) {
+        const id = `sub_${++this.subscriptionId}`;
+        // Register for all matching types
+        const types = filter.types ?? ['*'];
+        for (const type of types) {
+            let handlers = this.handlers.get(type);
+            if (!handlers) {
+                handlers = new Set();
+                this.handlers.set(type, handlers);
+            }
+            handlers.add(handler);
+        }
+        const subscription = new EventSubscription(id, filter, () => {
+            this.removeSubscription(id);
+        });
+        this.subscriptions.set(id, { filter, handler: handler, subscription });
+        return subscription;
+    }
+    once(type, handler) {
+        const wrappedHandler = async (event) => {
+            subscription.unsubscribe();
+            await handler(event);
+        };
+        const subscription = this.on(type, wrappedHandler);
+        return subscription;
+    }
+    off(type, handler) {
+        const handlers = this.handlers.get(type);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.handlers.delete(type);
+            }
+        }
+    }
+    removeAllListeners(type) {
+        if (type) {
+            this.handlers.delete(type);
+        }
+        else {
+            this.handlers.clear();
+        }
+    }
+    listenerCount(type) {
+        return this.handlers.get(type)?.size ?? 0;
+    }
+    eventNames() {
+        return Array.from(this.handlers.keys());
+    }
+    createEvent(type, payload, options) {
+        return {
+            id: generateSecureEventId(),
+            type,
+            timestamp: new Date(),
+            source: options?.source ?? 'event-bus',
+            payload,
+            priority: options?.priority,
+            correlationId: options?.correlationId,
+            causationId: options?.causationId,
+            metadata: options?.metadata,
+        };
+    }
+    dispatchEvent(event) {
+        // Get handlers for specific type
+        const typeHandlers = this.handlers.get(event.type);
+        // Get wildcard handlers
+        const wildcardHandlers = this.handlers.get('*');
+        const allHandlers = new Set();
+        if (typeHandlers) {
+            for (const handler of typeHandlers) {
+                allHandlers.add(handler);
+            }
+        }
+        if (wildcardHandlers) {
+            for (const handler of wildcardHandlers) {
+                allHandlers.add(handler);
+            }
+        }
+        for (const handler of allHandlers) {
+            try {
+                const result = handler(event);
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        console.error(`Error in async event handler for ${event.type}:`, error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${event.type}:`, error);
+            }
+        }
+    }
+    async dispatchEventAsync(event) {
+        const typeHandlers = this.handlers.get(event.type);
+        const wildcardHandlers = this.handlers.get('*');
+        const allHandlers = new Set();
+        if (typeHandlers) {
+            for (const handler of typeHandlers) {
+                allHandlers.add(handler);
+            }
+        }
+        if (wildcardHandlers) {
+            for (const handler of wildcardHandlers) {
+                allHandlers.add(handler);
+            }
+        }
+        const promises = Array.from(allHandlers).map(async (handler) => {
+            try {
+                await handler(event);
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${event.type}:`, error);
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    removeSubscription(id) {
+        const sub = this.subscriptions.get(id);
+        if (sub) {
+            const types = sub.filter.types ?? ['*'];
+            for (const type of types) {
+                const handlers = this.handlers.get(type);
+                if (handlers) {
+                    handlers.delete(sub.handler);
+                    if (handlers.size === 0) {
+                        this.handlers.delete(type);
+                    }
+                }
+            }
+            this.subscriptions.delete(id);
+        }
+    }
+}
+/**
+ * Create a new event bus instance
+ */
+export function createEventBus() {
+    return new EventBus();
+}
+//# sourceMappingURL=event-bus.js.map

package/src/@claude-flow/shared/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * V3 Core Module - Public API
+ * Domain-Driven Design with Clean Architecture
+ *
+ * This module provides the core architecture for claude-flow v3:
+ * - Decomposed orchestrator (task, session, health, lifecycle management)
+ * - Event-driven architecture with event bus and coordinator
+ * - Type-safe configuration with Zod validation
+ * - Clean interfaces following DDD principles
+ */
+export * from './interfaces/index.js';
+export { EventBus, createEventBus } from './event-bus.js';
+export * from './orchestrator/index.js';
+export * from './config/index.js';
+//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/core/index.js

@@ -0,0 +1,19 @@
+/**
+ * V3 Core Module - Public API
+ * Domain-Driven Design with Clean Architecture
+ *
+ * This module provides the core architecture for claude-flow v3:
+ * - Decomposed orchestrator (task, session, health, lifecycle management)
+ * - Event-driven architecture with event bus and coordinator
+ * - Type-safe configuration with Zod validation
+ * - Clean interfaces following DDD principles
+ */
+// Interfaces (Domain contracts)
+export * from './interfaces/index.js';
+// Event system
+export { EventBus, createEventBus } from './event-bus.js';
+// Orchestrator components (decomposed)
+export * from './orchestrator/index.js';
+// Configuration
+export * from './config/index.js';
+//# sourceMappingURL=index.js.map