claude-flow 3.25.5 → 3.26.0

package/v3/@claude-flow/shared/dist/core/orchestrator/lifecycle-manager.d.ts

@@ -1,56 +0,0 @@
-/**
- * V3 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/v3/@claude-flow/shared/dist/core/orchestrator/lifecycle-manager.js

@@ -1,195 +0,0 @@
-/**
- * V3 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/v3/@claude-flow/shared/dist/core/orchestrator/session-manager.d.ts

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

package/v3/@claude-flow/shared/dist/core/orchestrator/session-manager.js

@@ -1,193 +0,0 @@
-/**
- * V3 Session Manager
- * Decomposed from orchestrator.ts - Session handling
- * ~200 lines (target achieved)
- */
-import { SystemEventTypes } from '../interfaces/event.interface.js';
-import { mkdir, writeFile, readFile } from 'fs/promises';
-import { join, dirname } from 'path';
-import { randomBytes } from 'crypto';
-// Secure session ID generation
-function generateSecureSessionId() {
-    const timestamp = Date.now().toString(36);
-    const random = randomBytes(12).toString('hex');
-    return `session_${timestamp}_${random}`;
-}
-/**
- * Session manager implementation
- */
-export class SessionManager {
-    eventBus;
-    config;
-    sessions = new Map();
-    sessionProfiles = new Map();
-    persistencePath;
-    constructor(eventBus, config) {
-        this.eventBus = eventBus;
-        this.config = config;
-        this.persistencePath = join(config.dataDir || './data', 'sessions.json');
-    }
-    async createSession(profile, terminalId, memoryBankId) {
-        const session = {
-            id: generateSecureSessionId(),
-            agentId: profile.id,
-            terminalId,
-            startTime: new Date(),
-            status: 'active',
-            lastActivity: new Date(),
-            memoryBankId,
-        };
-        this.sessions.set(session.id, session);
-        this.sessionProfiles.set(session.id, profile);
-        this.eventBus.emit(SystemEventTypes.SESSION_CREATED, {
-            sessionId: session.id,
-            agentId: profile.id,
-            terminalId,
-            memoryBankId,
-        });
-        // Persist sessions asynchronously
-        this.persistSessions().catch(() => {
-            // Silently ignore persistence errors
-        });
-        return session;
-    }
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    getActiveSessions() {
-        return Array.from(this.sessions.values()).filter(session => session.status === 'active' || session.status === 'idle');
-    }
-    getSessionsByAgent(agentId) {
-        return Array.from(this.sessions.values()).filter(session => session.agentId === agentId);
-    }
-    async terminateSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        session.status = 'terminated';
-        session.endTime = new Date();
-        const duration = session.endTime.getTime() - session.startTime.getTime();
-        this.eventBus.emit(SystemEventTypes.SESSION_TERMINATED, {
-            sessionId,
-            agentId: session.agentId,
-            duration,
-        });
-        // Clean up profile reference
-        this.sessionProfiles.delete(sessionId);
-        // Persist sessions asynchronously
-        this.persistSessions().catch(() => {
-            // Silently ignore persistence errors
-        });
-    }
-    async terminateAllSessions() {
-        const sessions = this.getActiveSessions();
-        const batchSize = 5;
-        for (let i = 0; i < sessions.length; i += batchSize) {
-            const batch = sessions.slice(i, i + batchSize);
-            await Promise.allSettled(batch.map(session => this.terminateSession(session.id)));
-        }
-    }
-    removeSession(sessionId) {
-        this.sessions.delete(sessionId);
-        this.sessionProfiles.delete(sessionId);
-    }
-    updateSessionActivity(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.lastActivity = new Date();
-        }
-    }
-    async persistSessions() {
-        if (!this.config.persistSessions) {
-            return;
-        }
-        try {
-            const data = {
-                sessions: Array.from(this.sessions.values())
-                    .map(session => ({
-                    ...session,
-                    profile: this.sessionProfiles.get(session.id),
-                }))
-                    .filter(s => s.profile),
-                metrics: {
-                    completedTasks: 0,
-                    failedTasks: 0,
-                    totalTaskDuration: 0,
-                },
-                savedAt: new Date(),
-            };
-            await mkdir(dirname(this.persistencePath), { recursive: true });
-            await writeFile(this.persistencePath, JSON.stringify(data, null, 2), 'utf8');
-            this.eventBus.emit(SystemEventTypes.SESSION_PERSISTED, {
-                sessionCount: data.sessions.length,
-                path: this.persistencePath,
-            });
-        }
-        catch (error) {
-            // Let caller handle persistence errors
-            throw error;
-        }
-    }
-    async restoreSessions() {
-        if (!this.config.persistSessions) {
-            return null;
-        }
-        try {
-            const data = await readFile(this.persistencePath, 'utf8');
-            const persistence = JSON.parse(data);
-            // Filter to only active/idle sessions
-            const sessionsToRestore = persistence.sessions.filter(s => s.status === 'active' || s.status === 'idle');
-            this.eventBus.emit(SystemEventTypes.SESSION_RESTORED, {
-                sessionCount: sessionsToRestore.length,
-                path: this.persistencePath,
-            });
-            return {
-                ...persistence,
-                sessions: sessionsToRestore,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return null;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Clean up old terminated sessions
-     */
-    async cleanupTerminatedSessions(retentionMs) {
-        const cutoffTime = Date.now() - (retentionMs ?? this.config.sessionRetentionMs ?? 3600000);
-        let cleaned = 0;
-        for (const [sessionId, session] of this.sessions.entries()) {
-            if (session.status === 'terminated' && session.endTime) {
-                if (session.endTime.getTime() < cutoffTime) {
-                    this.sessions.delete(sessionId);
-                    this.sessionProfiles.delete(sessionId);
-                    cleaned++;
-                }
-            }
-        }
-        return cleaned;
-    }
-    /**
-     * Get session profile
-     */
-    getSessionProfile(sessionId) {
-        return this.sessionProfiles.get(sessionId);
-    }
-    /**
-     * Get session count
-     */
-    getSessionCount() {
-        return this.sessions.size;
-    }
-    /**
-     * Get active session count
-     */
-    getActiveSessionCount() {
-        return this.getActiveSessions().length;
-    }
-}
-//# sourceMappingURL=session-manager.js.map

package/v3/@claude-flow/shared/dist/core/orchestrator/task-manager.d.ts

@@ -1,49 +0,0 @@
-/**
- * V3 Task Manager
- * Decomposed from orchestrator.ts - Task lifecycle management
- * ~200 lines (target achieved)
- */
-import type { ITask, ITaskCreate, ITaskResult, ITaskManager, ITaskQueue, TaskManagerMetrics } from '../interfaces/task.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-/**
- * Priority queue implementation for tasks
- */
-export declare class TaskQueue implements ITaskQueue {
-    private tasks;
-    enqueue(task: ITask): Promise<void>;
-    dequeue(): Promise<ITask | undefined>;
-    peek(): Promise<ITask | undefined>;
-    size(): number;
-    isEmpty(): boolean;
-    clear(): Promise<void>;
-    getAll(): Promise<ITask[]>;
-    remove(taskId: string): Promise<boolean>;
-    updatePriority(taskId: string, priority: number): Promise<boolean>;
-}
-/**
- * Task manager implementation
- */
-export declare class TaskManager implements ITaskManager {
-    private eventBus;
-    private tasks;
-    private queue;
-    private metrics;
-    constructor(eventBus: IEventBus, queue?: ITaskQueue);
-    createTask(params: ITaskCreate): Promise<ITask>;
-    getTask(taskId: string): ITask | undefined;
-    getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[];
-    assignTask(taskId: string, agentId: string): Promise<void>;
-    startTask(taskId: string): Promise<void>;
-    completeTask(taskId: string, result: ITaskResult): Promise<void>;
-    failTask(taskId: string, error: Error): Promise<void>;
-    cancelTask(taskId: string, reason?: string): Promise<void>;
-    retryTask(taskId: string): Promise<void>;
-    getMetrics(): TaskManagerMetrics;
-    cleanup(olderThan: Date): Promise<number>;
-    private isRetryable;
-    /**
-     * Get the task queue
-     */
-    getQueue(): ITaskQueue;
-}
-//# sourceMappingURL=task-manager.d.ts.map