monomind 1.11.8 → 1.11.10

package/packages/@monomind/shared/dist/core/orchestrator/health-monitor.js

@@ -1,166 +0,0 @@
-/**
- * V1 Health Monitor
- * Decomposed from orchestrator.ts - Agent health checks
- * ~150 lines (target achieved)
- */
-import { SystemEventTypes } from '../interfaces/event.interface.js';
-/**
- * Health monitor implementation
- */
-export class HealthMonitor {
-    eventBus;
-    config;
-    checks = new Map();
-    history = [];
-    interval;
-    listeners = [];
-    running = false;
-    constructor(eventBus, config = {
-        checkInterval: 30000,
-        historyLimit: 100,
-        degradedThreshold: 1,
-        unhealthyThreshold: 2,
-    }) {
-        this.eventBus = eventBus;
-        this.config = config;
-    }
-    start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        this.interval = setInterval(async () => {
-            const status = await this.getStatus();
-            this.addToHistory(status);
-            this.notifyListeners(status);
-            this.eventBus.emit(SystemEventTypes.SYSTEM_HEALTHCHECK, { status });
-        }, this.config.checkInterval);
-    }
-    stop() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = undefined;
-        }
-        this.running = false;
-    }
-    async getStatus() {
-        const components = {};
-        let unhealthyCount = 0;
-        let degradedCount = 0;
-        const checkPromises = Array.from(this.checks.entries()).map(async ([name, check]) => {
-            try {
-                const result = await Promise.race([
-                    check(),
-                    this.timeout(5000, 'Health check timeout'),
-                ]);
-                const health = {
-                    name,
-                    status: result.healthy ? 'healthy' : 'unhealthy',
-                    lastCheck: new Date(),
-                    error: result.error,
-                    metrics: result.metrics,
-                };
-                return { name, health };
-            }
-            catch (error) {
-                return {
-                    name,
-                    health: {
-                        name,
-                        status: 'unhealthy',
-                        lastCheck: new Date(),
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    },
-                };
-            }
-        });
-        const results = await Promise.allSettled(checkPromises);
-        for (const result of results) {
-            if (result.status === 'fulfilled') {
-                const { name, health } = result.value;
-                components[name] = health;
-                if (health.status === 'unhealthy') {
-                    unhealthyCount++;
-                }
-                else if (health.status === 'degraded') {
-                    degradedCount++;
-                }
-            }
-        }
-        let overallStatus = 'healthy';
-        if (unhealthyCount >= this.config.unhealthyThreshold) {
-            overallStatus = 'unhealthy';
-        }
-        else if (unhealthyCount > 0 ||
-            degradedCount >= this.config.degradedThreshold) {
-            overallStatus = 'degraded';
-        }
-        return {
-            status: overallStatus,
-            components,
-            timestamp: new Date(),
-        };
-    }
-    registerCheck(name, check) {
-        this.checks.set(name, check);
-    }
-    unregisterCheck(name) {
-        this.checks.delete(name);
-    }
-    getHistory(limit) {
-        const count = limit ?? this.config.historyLimit;
-        return this.history.slice(-count);
-    }
-    onHealthChange(callback) {
-        this.listeners.push(callback);
-        return () => {
-            const index = this.listeners.indexOf(callback);
-            if (index !== -1) {
-                this.listeners.splice(index, 1);
-            }
-        };
-    }
-    addToHistory(status) {
-        this.history.push(status);
-        // Trim history to limit
-        if (this.history.length > this.config.historyLimit) {
-            this.history = this.history.slice(-this.config.historyLimit);
-        }
-    }
-    notifyListeners(status) {
-        for (const listener of this.listeners) {
-            try {
-                listener(status);
-            }
-            catch {
-                // Ignore listener errors
-            }
-        }
-    }
-    timeout(ms, message) {
-        return new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(message)), ms);
-        });
-    }
-    /**
-     * Get component health by name
-     */
-    async getComponentHealth(name) {
-        const status = await this.getStatus();
-        return status.components[name];
-    }
-    /**
-     * Check if system is healthy
-     */
-    async isHealthy() {
-        const status = await this.getStatus();
-        return status.status === 'healthy';
-    }
-    /**
-     * Get registered check names
-     */
-    getRegisteredChecks() {
-        return Array.from(this.checks.keys());
-    }
-}
-//# sourceMappingURL=health-monitor.js.map

package/packages/@monomind/shared/dist/core/orchestrator/index.d.ts

@@ -1,46 +0,0 @@
-/**
- * V1 Orchestrator Facade
- * Unified interface to decomposed orchestrator components
- * ~50 lines (target achieved)
- */
-import { TaskManager } from './task-manager.js';
-import { SessionManager, type SessionManagerConfig } from './session-manager.js';
-import { HealthMonitor, type HealthMonitorConfig } from './health-monitor.js';
-import { LifecycleManager, type LifecycleManagerConfig } from './lifecycle-manager.js';
-import { EventCoordinator } from './event-coordinator.js';
-import { EventBus } from '../event-bus.js';
-export * from './task-manager.js';
-export * from './session-manager.js';
-export * from './health-monitor.js';
-export * from './lifecycle-manager.js';
-export * from './event-coordinator.js';
-/**
- * Orchestrator facade configuration
- * (Note: For schema-validated config, use OrchestratorConfig from config/schema.ts)
- */
-export interface OrchestratorFacadeConfig {
-    session: SessionManagerConfig;
-    health: HealthMonitorConfig;
-    lifecycle: LifecycleManagerConfig;
-}
-/**
- * Default orchestrator facade configuration
- */
-export declare const defaultOrchestratorFacadeConfig: OrchestratorFacadeConfig;
-/**
- * Create orchestrator components
- */
-export declare function createOrchestrator(config?: Partial<OrchestratorFacadeConfig>): {
-    eventBus: EventBus;
-    taskManager: TaskManager;
-    sessionManager: SessionManager;
-    healthMonitor: HealthMonitor;
-    lifecycleManager: LifecycleManager;
-    eventCoordinator: EventCoordinator;
-    config: OrchestratorFacadeConfig;
-};
-/**
- * Orchestrator type for facade
- */
-export type OrchestratorComponents = ReturnType<typeof createOrchestrator>;
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/shared/dist/core/orchestrator/index.js

@@ -1,64 +0,0 @@
-/**
- * V1 Orchestrator Facade
- * Unified interface to decomposed orchestrator components
- * ~50 lines (target achieved)
- */
-import { TaskManager } from './task-manager.js';
-import { SessionManager } from './session-manager.js';
-import { HealthMonitor } from './health-monitor.js';
-import { LifecycleManager } from './lifecycle-manager.js';
-import { EventCoordinator } from './event-coordinator.js';
-import { EventBus } from '../event-bus.js';
-export * from './task-manager.js';
-export * from './session-manager.js';
-export * from './health-monitor.js';
-export * from './lifecycle-manager.js';
-export * from './event-coordinator.js';
-/**
- * Default orchestrator facade configuration
- */
-export const defaultOrchestratorFacadeConfig = {
-    session: {
-        persistSessions: true,
-        dataDir: './data',
-        sessionRetentionMs: 3600000,
-    },
-    health: {
-        checkInterval: 30000,
-        historyLimit: 100,
-        degradedThreshold: 1,
-        unhealthyThreshold: 2,
-    },
-    lifecycle: {
-        maxConcurrentAgents: 20,
-        spawnTimeout: 30000,
-        terminateTimeout: 10000,
-        maxSpawnRetries: 3,
-    },
-};
-/**
- * Create orchestrator components
- */
-export function createOrchestrator(config = {}) {
-    const mergedConfig = {
-        session: { ...defaultOrchestratorFacadeConfig.session, ...config.session },
-        health: { ...defaultOrchestratorFacadeConfig.health, ...config.health },
-        lifecycle: { ...defaultOrchestratorFacadeConfig.lifecycle, ...config.lifecycle },
-    };
-    const eventBus = new EventBus();
-    const taskManager = new TaskManager(eventBus);
-    const sessionManager = new SessionManager(eventBus, mergedConfig.session);
-    const healthMonitor = new HealthMonitor(eventBus, mergedConfig.health);
-    const lifecycleManager = new LifecycleManager(eventBus, mergedConfig.lifecycle);
-    const eventCoordinator = new EventCoordinator(eventBus);
-    return {
-        eventBus,
-        taskManager,
-        sessionManager,
-        healthMonitor,
-        lifecycleManager,
-        eventCoordinator,
-        config: mergedConfig,
-    };
-}
-//# sourceMappingURL=index.js.map

package/packages/@monomind/shared/dist/core/orchestrator/lifecycle-manager.d.ts

@@ -1,56 +0,0 @@
-/**
- * V1 Lifecycle Manager
- * Decomposed from orchestrator.ts - Agent spawn/terminate
- * ~150 lines (target achieved)
- */
-import type { IAgent, IAgentConfig, IAgentLifecycleManager, IAgentPool, AgentStatus } from '../interfaces/agent.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-/**
- * Agent pool implementation
- */
-export declare class AgentPool implements IAgentPool {
-    private agents;
-    add(agent: IAgent): void;
-    remove(agentId: string): boolean;
-    get(agentId: string): IAgent | undefined;
-    getAll(): IAgent[];
-    getByStatus(status: AgentStatus): IAgent[];
-    getByType(type: string): IAgent[];
-    getAvailable(): IAgent[];
-    size(): number;
-    hasCapacity(maxSize: number): boolean;
-    clear(): void;
-}
-/**
- * Lifecycle manager configuration
- */
-export interface LifecycleManagerConfig {
-    maxConcurrentAgents: number;
-    spawnTimeout: number;
-    terminateTimeout: number;
-    maxSpawnRetries: number;
-}
-/**
- * Lifecycle manager implementation
- */
-export declare class LifecycleManager implements IAgentLifecycleManager {
-    private eventBus;
-    private config;
-    private pool;
-    constructor(eventBus: IEventBus, config: LifecycleManagerConfig, pool?: IAgentPool);
-    spawn(config: IAgentConfig): Promise<IAgent>;
-    spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
-    terminate(agentId: string, reason?: string): Promise<void>;
-    terminateAll(reason?: string): Promise<void>;
-    restart(agentId: string): Promise<IAgent>;
-    updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
-    getAgent(agentId: string): IAgent | undefined;
-    getAllAgents(): IAgent[];
-    getActiveCount(): number;
-    checkHealth(agentId: string): Promise<IAgent['health']>;
-    /**
-     * Get agent pool
-     */
-    getPool(): IAgentPool;
-}
-//# sourceMappingURL=lifecycle-manager.d.ts.map

package/packages/@monomind/shared/dist/core/orchestrator/lifecycle-manager.js

@@ -1,195 +0,0 @@
-/**
- * V1 Lifecycle Manager
- * Decomposed from orchestrator.ts - Agent spawn/terminate
- * ~150 lines (target achieved)
- */
-import { SystemEventTypes } from '../interfaces/event.interface.js';
-/**
- * Agent pool implementation
- */
-export class AgentPool {
-    agents = new Map();
-    add(agent) {
-        this.agents.set(agent.id, agent);
-    }
-    remove(agentId) {
-        return this.agents.delete(agentId);
-    }
-    get(agentId) {
-        return this.agents.get(agentId);
-    }
-    getAll() {
-        return Array.from(this.agents.values());
-    }
-    getByStatus(status) {
-        return this.getAll().filter(agent => agent.status === status);
-    }
-    getByType(type) {
-        return this.getAll().filter(agent => agent.type === type);
-    }
-    getAvailable() {
-        return this.getAll().filter(agent => (agent.status === 'active' || agent.status === 'idle') &&
-            agent.currentTaskCount < agent.config.maxConcurrentTasks);
-    }
-    size() {
-        return this.agents.size;
-    }
-    hasCapacity(maxSize) {
-        return this.agents.size < maxSize;
-    }
-    clear() {
-        this.agents.clear();
-    }
-}
-/**
- * Lifecycle manager implementation
- */
-export class LifecycleManager {
-    eventBus;
-    config;
-    pool;
-    constructor(eventBus, config, pool) {
-        this.eventBus = eventBus;
-        this.config = config;
-        this.pool = pool ?? new AgentPool();
-    }
-    async spawn(config) {
-        // Validate capacity
-        if (!this.pool.hasCapacity(this.config.maxConcurrentAgents)) {
-            throw new Error('Maximum concurrent agents reached');
-        }
-        // Validate agent doesn't already exist
-        if (this.pool.get(config.id)) {
-            throw new Error(`Agent with ID ${config.id} already exists`);
-        }
-        const agent = {
-            id: config.id,
-            name: config.name,
-            type: config.type,
-            config,
-            createdAt: new Date(),
-            status: 'spawning',
-            currentTaskCount: 0,
-            lastActivity: new Date(),
-            metrics: {
-                tasksCompleted: 0,
-                tasksFailed: 0,
-                avgTaskDuration: 0,
-                errorCount: 0,
-                uptime: 0,
-            },
-        };
-        // Add to pool
-        this.pool.add(agent);
-        // Mark as active
-        agent.status = 'active';
-        this.eventBus.emit(SystemEventTypes.AGENT_SPAWNED, {
-            agentId: agent.id,
-            profile: config,
-            sessionId: undefined,
-        });
-        return agent;
-    }
-    async spawnBatch(configs) {
-        const results = new Map();
-        // Check total capacity
-        if (this.pool.size() + configs.length > this.config.maxConcurrentAgents) {
-            throw new Error('Batch would exceed maximum concurrent agents');
-        }
-        // Spawn in parallel
-        const spawnPromises = configs.map(async (config) => {
-            try {
-                const agent = await this.spawn(config);
-                return { id: config.id, agent, error: null };
-            }
-            catch (error) {
-                return { id: config.id, agent: null, error };
-            }
-        });
-        const settled = await Promise.allSettled(spawnPromises);
-        for (const result of settled) {
-            if (result.status === 'fulfilled' && result.value.agent) {
-                results.set(result.value.id, result.value.agent);
-            }
-        }
-        return results;
-    }
-    async terminate(agentId, reason) {
-        const agent = this.pool.get(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        agent.status = 'terminated';
-        // Remove from pool
-        this.pool.remove(agentId);
-        this.eventBus.emit(SystemEventTypes.AGENT_TERMINATED, {
-            agentId,
-            reason: reason ?? 'User requested',
-        });
-    }
-    async terminateAll(reason) {
-        const agents = this.pool.getAll();
-        await Promise.allSettled(agents.map(agent => this.terminate(agent.id, reason)));
-    }
-    async restart(agentId) {
-        const agent = this.pool.get(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        const config = agent.config;
-        await this.terminate(agentId, 'Restart requested');
-        return this.spawn(config);
-    }
-    async updateConfig(agentId, config) {
-        const agent = this.pool.get(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        Object.assign(agent.config, config);
-    }
-    getAgent(agentId) {
-        return this.pool.get(agentId);
-    }
-    getAllAgents() {
-        return this.pool.getAll();
-    }
-    getActiveCount() {
-        return this.pool.getByStatus('active').length +
-            this.pool.getByStatus('idle').length;
-    }
-    async checkHealth(agentId) {
-        const agent = this.pool.get(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        // Simple health check based on metrics
-        const errorRate = agent.metrics
-            ? agent.metrics.errorCount / Math.max(1, agent.metrics.tasksCompleted + agent.metrics.tasksFailed)
-            : 0;
-        const health = {
-            status: errorRate > 0.5 ? 'unhealthy' : errorRate > 0.2 ? 'degraded' : 'healthy',
-            lastCheck: new Date(),
-            issues: [],
-        };
-        if (errorRate > 0.2) {
-            health.issues?.push(`High error rate: ${(errorRate * 100).toFixed(1)}%`);
-        }
-        agent.health = health;
-        if (health.status !== 'healthy') {
-            this.eventBus.emit(SystemEventTypes.AGENT_HEALTH_CHANGED, {
-                agentId,
-                previousStatus: agent.status,
-                currentStatus: agent.status,
-                issues: health.issues,
-            });
-        }
-        return health;
-    }
-    /**
-     * Get agent pool
-     */
-    getPool() {
-        return this.pool;
-    }
-}
-//# sourceMappingURL=lifecycle-manager.js.map

package/packages/@monomind/shared/dist/core/orchestrator/session-manager.d.ts

@@ -1,83 +0,0 @@
-/**
- * V1 Session Manager
- * Decomposed from orchestrator.ts - Session handling
- * ~200 lines (target achieved)
- */
-import type { IAgentSession } from '../interfaces/agent.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-import type { AgentProfile } from '../../types/agent.types.js';
-/**
- * Session persistence structure
- */
-export interface SessionPersistence {
-    sessions: Array<IAgentSession & {
-        profile: AgentProfile;
-    }>;
-    metrics: {
-        completedTasks: number;
-        failedTasks: number;
-        totalTaskDuration: number;
-    };
-    savedAt: Date;
-}
-/**
- * Session manager configuration
- */
-export interface SessionManagerConfig {
-    persistSessions: boolean;
-    dataDir: string;
-    sessionRetentionMs?: number;
-}
-/**
- * Session manager interface
- */
-export interface ISessionManager {
-    createSession(profile: AgentProfile, terminalId: string, memoryBankId: string): Promise<IAgentSession>;
-    getSession(sessionId: string): IAgentSession | undefined;
-    getActiveSessions(): IAgentSession[];
-    getSessionsByAgent(agentId: string): IAgentSession[];
-    terminateSession(sessionId: string): Promise<void>;
-    terminateAllSessions(): Promise<void>;
-    persistSessions(): Promise<void>;
-    restoreSessions(): Promise<SessionPersistence | null>;
-    removeSession(sessionId: string): void;
-    updateSessionActivity(sessionId: string): void;
-}
-/**
- * Session manager implementation
- */
-export declare class SessionManager implements ISessionManager {
-    private eventBus;
-    private config;
-    private sessions;
-    private sessionProfiles;
-    private persistencePath;
-    constructor(eventBus: IEventBus, config: SessionManagerConfig);
-    createSession(profile: AgentProfile, terminalId: string, memoryBankId: string): Promise<IAgentSession>;
-    getSession(sessionId: string): IAgentSession | undefined;
-    getActiveSessions(): IAgentSession[];
-    getSessionsByAgent(agentId: string): IAgentSession[];
-    terminateSession(sessionId: string): Promise<void>;
-    terminateAllSessions(): Promise<void>;
-    removeSession(sessionId: string): void;
-    updateSessionActivity(sessionId: string): void;
-    persistSessions(): Promise<void>;
-    restoreSessions(): Promise<SessionPersistence | null>;
-    /**
-     * Clean up old terminated sessions
-     */
-    cleanupTerminatedSessions(retentionMs?: number): Promise<number>;
-    /**
-     * Get session profile
-     */
-    getSessionProfile(sessionId: string): AgentProfile | undefined;
-    /**
-     * Get session count
-     */
-    getSessionCount(): number;
-    /**
-     * Get active session count
-     */
-    getActiveSessionCount(): number;
-}
-//# sourceMappingURL=session-manager.d.ts.map