moflo 4.8.16 → 4.8.17

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

@@ -1,158 +0,0 @@
-/**
- * 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('claude-flow'),
-    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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,197 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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