@sethdouglasford/claude-flow/dist/coordination/advanced-scheduler.js

Claude Code Flow - Advanced AI-powered development workflows with SPARC methodology

/**
 * Simplified Advanced Task Scheduler
 * Basic agent selection without complex strategies
 */
import { TaskScheduler } from "./scheduler.js";
/**
 * Simple advanced scheduler that extends basic scheduler
 * Removed complex scheduling strategies and circuit breakers
 */
export class AdvancedTaskScheduler extends TaskScheduler {
    agentLoads = new Map();
    availableAgents = new Map();
    constructor(config, eventBus, logger) {
        super(config, eventBus, logger);
    }
    /**
     * Register an agent as available for tasks
     */
    registerAgent(agent) {
        this.availableAgents.set(agent.id, agent);
        this.agentLoads.set(agent.id, 0);
        this.logger.info("Agent registered", { agentId: agent.id });
    }
    /**
     * Unregister an agent
     */
    unregisterAgent(agentId) {
        this.availableAgents.delete(agentId);
        this.agentLoads.delete(agentId);
        // Reassign any tasks from this agent
        const tasks = this.agentTasks.get(agentId);
        if (tasks) {
            tasks.forEach(taskId => {
                const task = this.tasks.get(taskId);
                if (task) {
                    void this.reassignTask(task);
                }
            });
        }
        this.logger.info("Agent unregistered", { agentId });
    }
    /**
     * Simple agent selection - pick the least loaded agent
     */
    selectAgentForTask(task) {
        const agents = Array.from(this.availableAgents.values());
        if (agents.length === 0) {
            this.logger.warn("No agents available for task", { taskId: task.id });
            return null;
        }
        // Simple least-loaded selection
        let selectedAgent = null;
        let minLoad = Infinity;
        for (const agent of agents) {
            const load = this.agentLoads.get(agent.id) ?? 0;
            // Check if agent can handle the task type
            if (task.type !== "any" && agent.capabilities &&
                !agent.capabilities.includes(task.type) &&
                !agent.capabilities.includes("*")) {
                continue;
            }
            if (load < minLoad) {
                minLoad = load;
                selectedAgent = agent;
            }
        }
        return selectedAgent?.id ?? null;
    }
    /**
     * Schedule a task with simple agent selection
     */
    async scheduleTask(task, agentId) {
        // If no agent specified, select one
        if (!agentId) {
            const selected = this.selectAgentForTask(task);
            if (!selected) {
                throw new Error(`No suitable agent found for task ${task.id}`);
            }
            agentId = selected;
        }
        // Update load
        const currentLoad = this.agentLoads.get(agentId) ?? 0;
        this.agentLoads.set(agentId, currentLoad + 1);
        // Schedule the task
        await super.assignTask(task, agentId);
    }
    /**
     * Complete a task and update agent load
     */
    async completeTask(taskId, _result) {
        const scheduledTask = this.tasks.get(taskId);
        if (scheduledTask) {
            const load = this.agentLoads.get(scheduledTask.agentId) ?? 0;
            this.agentLoads.set(scheduledTask.agentId, Math.max(0, load - 1));
        }
        await super.completeTask(taskId, _result);
    }
    /**
     * Reassign a task to a different agent
     */
    async reassignTask(scheduledTask) {
        const newAgentId = this.selectAgentForTask(scheduledTask.task);
        if (newAgentId && newAgentId !== scheduledTask.agentId) {
            // Remove from old agent
            const oldTasks = this.agentTasks.get(scheduledTask.agentId);
            if (oldTasks) {
                oldTasks.delete(scheduledTask.task.id);
            }
            // Update scheduled task
            scheduledTask.agentId = newAgentId;
            // Add to new agent
            let newAgentTaskSet = this.agentTasks.get(newAgentId);
            if (!newAgentTaskSet) {
                newAgentTaskSet = new Set();
                this.agentTasks.set(newAgentId, newAgentTaskSet);
            }
            newAgentTaskSet.add(scheduledTask.task.id);
            // Update loads
            const oldLoad = this.agentLoads.get(scheduledTask.agentId) ?? 0;
            this.agentLoads.set(scheduledTask.agentId, Math.max(0, oldLoad - 1));
            const newLoad = this.agentLoads.get(newAgentId) ?? 0;
            this.agentLoads.set(newAgentId, newLoad + 1);
            this.logger.info("Task reassigned", {
                taskId: scheduledTask.task.id,
                from: scheduledTask.agentId,
                to: newAgentId,
            });
        }
    }
    /**
     * Get current scheduler status
     */
    getStatus() {
        const agents = Array.from(this.availableAgents.entries()).map(([id, agent]) => ({
            id,
            load: this.agentLoads.get(id) ?? 0,
            capabilities: agent.capabilities,
        }));
        const queuedTasks = Array.from(this.tasks.values())
            .filter(t => t.task.status === "pending").length;
        return {
            totalTasks: this.tasks.size,
            agents,
            queuedTasks,
        };
    }
}
//# sourceMappingURL=advanced-scheduler.js.map