claude-flow 3.28.0 → 3.29.0

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

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

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

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

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

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