monomind 1.10.0 → 1.10.1

package/packages/@monomind/shared/dist/core/config/validator.js

@@ -1,147 +0,0 @@
-/**
- * v1 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/packages/@monomind/shared/dist/core/event-bus.d.ts

@@ -1,31 +0,0 @@
-/**
- * V1 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/packages/@monomind/shared/dist/core/event-bus.js

@@ -1,197 +0,0 @@
-/**
- * V1 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/packages/@monomind/shared/dist/core/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * V1 Core Module - Public API
- * Domain-Driven Design with Clean Architecture
- *
- * This module provides the core architecture for monomind v1:
- * - 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/packages/@monomind/shared/dist/core/index.js

@@ -1,19 +0,0 @@
-/**
- * V1 Core Module - Public API
- * Domain-Driven Design with Clean Architecture
- *
- * This module provides the core architecture for monomind v1:
- * - 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

package/packages/@monomind/shared/dist/core/interfaces/agent.interface.d.ts

@@ -1,200 +0,0 @@
-/**
- * Agent Interfaces
- * Domain-Driven Design - Agent Lifecycle Bounded Context
- */
-/**
- * Agent status in the system
- */
-export type AgentStatus = 'spawning' | 'active' | 'idle' | 'busy' | 'error' | 'terminated';
-/**
- * Agent type classification
- */
-export type AgentType = 'coder' | 'reviewer' | 'tester' | 'researcher' | 'planner' | 'architect' | 'coordinator' | 'security' | 'performance' | 'custom';
-/**
- * Agent capability declaration
- */
-export interface IAgentCapability {
-    name: string;
-    level: 'basic' | 'intermediate' | 'advanced' | 'expert';
-    description?: string;
-}
-/**
- * Agent configuration for spawning
- */
-export interface IAgentConfig {
-    readonly id: string;
-    readonly name: string;
-    readonly type: AgentType | string;
-    capabilities: string[];
-    maxConcurrentTasks: number;
-    priority: number;
-    timeout?: number;
-    retryPolicy?: {
-        maxRetries: number;
-        backoffMs: number;
-        backoffMultiplier: number;
-    };
-    resources?: {
-        maxMemoryMb?: number;
-        maxCpuPercent?: number;
-    };
-    metadata?: Record<string, unknown>;
-}
-/**
- * Core agent entity
- */
-export interface IAgent {
-    readonly id: string;
-    readonly name: string;
-    readonly type: AgentType | string;
-    readonly config: IAgentConfig;
-    readonly createdAt: Date;
-    status: AgentStatus;
-    currentTaskCount: number;
-    lastActivity: Date;
-    sessionId?: string;
-    terminalId?: string;
-    memoryBankId?: string;
-    metrics?: {
-        tasksCompleted: number;
-        tasksFailed: number;
-        avgTaskDuration: number;
-        errorCount: number;
-        uptime: number;
-    };
-    health?: {
-        status: 'healthy' | 'degraded' | 'unhealthy';
-        lastCheck: Date;
-        issues?: string[];
-    };
-}
-/**
- * Agent session for tracking active work
- */
-export interface IAgentSession {
-    readonly id: string;
-    readonly agentId: string;
-    readonly startTime: Date;
-    status: 'active' | 'idle' | 'terminated';
-    terminalId: string;
-    memoryBankId: string;
-    lastActivity: Date;
-    endTime?: Date;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Agent pool for managing multiple agents
- */
-export interface IAgentPool {
-    /**
-     * Add an agent to the pool
-     */
-    add(agent: IAgent): void;
-    /**
-     * Remove an agent from the pool
-     */
-    remove(agentId: string): boolean;
-    /**
-     * Get an agent by ID
-     */
-    get(agentId: string): IAgent | undefined;
-    /**
-     * Get all agents in the pool
-     */
-    getAll(): IAgent[];
-    /**
-     * Get agents by status
-     */
-    getByStatus(status: AgentStatus): IAgent[];
-    /**
-     * Get agents by type
-     */
-    getByType(type: AgentType | string): IAgent[];
-    /**
-     * Get available agents (can accept more tasks)
-     */
-    getAvailable(): IAgent[];
-    /**
-     * Get pool size
-     */
-    size(): number;
-    /**
-     * Check if pool has capacity
-     */
-    hasCapacity(maxSize: number): boolean;
-    /**
-     * Clear all agents
-     */
-    clear(): void;
-}
-/**
- * Agent lifecycle manager interface
- */
-export interface IAgentLifecycleManager {
-    /**
-     * Spawn a new agent
-     */
-    spawn(config: IAgentConfig): Promise<IAgent>;
-    /**
-     * Spawn multiple agents in parallel
-     */
-    spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
-    /**
-     * Terminate an agent
-     */
-    terminate(agentId: string, reason?: string): Promise<void>;
-    /**
-     * Terminate all agents
-     */
-    terminateAll(reason?: string): Promise<void>;
-    /**
-     * Restart an agent
-     */
-    restart(agentId: string): Promise<IAgent>;
-    /**
-     * Update agent configuration
-     */
-    updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
-    /**
-     * Get agent by ID
-     */
-    getAgent(agentId: string): IAgent | undefined;
-    /**
-     * Get all agents
-     */
-    getAllAgents(): IAgent[];
-    /**
-     * Get active agents count
-     */
-    getActiveCount(): number;
-    /**
-     * Check agent health
-     */
-    checkHealth(agentId: string): Promise<IAgent['health']>;
-}
-/**
- * Agent registry for type definitions
- */
-export interface IAgentRegistry {
-    /**
-     * Register an agent type with default config
-     */
-    register(type: string, defaultConfig: Partial<IAgentConfig>): void;
-    /**
-     * Unregister an agent type
-     */
-    unregister(type: string): boolean;
-    /**
-     * Get default config for a type
-     */
-    getDefaultConfig(type: string): Partial<IAgentConfig> | undefined;
-    /**
-     * Get all registered types
-     */
-    getRegisteredTypes(): string[];
-    /**
-     * Check if a type is registered
-     */
-    isRegistered(type: string): boolean;
-}
-//# sourceMappingURL=agent.interface.d.ts.map

package/packages/@monomind/shared/dist/core/interfaces/agent.interface.js

@@ -1,6 +0,0 @@
-/**
- * Agent Interfaces
- * Domain-Driven Design - Agent Lifecycle Bounded Context
- */
-export {};
-//# sourceMappingURL=agent.interface.js.map