vibe-coder-mcp/build/tools/vibe-task-manager/services/task-scheduler.d.ts

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import { AtomicTask } from '../types/task.js';
import { OptimizedDependencyGraph, ParallelBatch } from '../core/dependency-graph.js';
export interface TaskScores {
    priorityScore: number;
    deadlineScore: number;
    dependencyScore: number;
    resourceScore: number;
    durationScore: number;
    systemLoadScore: number;
    complexityScore: number;
    businessImpactScore: number;
    agentAvailabilityScore: number;
    totalScore: number;
}
export type SchedulingAlgorithm = 'priority_first' | 'earliest_deadline' | 'critical_path' | 'resource_balanced' | 'shortest_job' | 'hybrid_optimal';
export interface ResourceConstraints {
    maxConcurrentTasks: number;
    maxMemoryMB: number;
    maxCpuUtilization: number;
    availableAgents: number;
    taskTypeResources: Map<string, {
        memoryMB: number;
        cpuWeight: number;
        agentCount: number;
    }>;
}
export interface SchedulingConfig {
    algorithm: SchedulingAlgorithm;
    resources: ResourceConstraints;
    weights: {
        priority: number;
        deadline: number;
        dependencies: number;
        resources: number;
        duration: number;
        systemLoad: number;
        complexity: number;
        businessImpact: number;
        agentAvailability: number;
    };
    deadlineBuffer: number;
    rescheduleSensitivity: 'low' | 'medium' | 'high';
    enableDynamicOptimization: boolean;
    optimizationInterval: number;
}
export interface ScheduledTask {
    task: AtomicTask;
    scheduledStart: Date;
    scheduledEnd: Date;
    assignedResources: {
        memoryMB: number;
        cpuWeight: number;
        agentId?: string;
    };
    batchId: number;
    prerequisiteTasks: string[];
    dependentTasks: string[];
    metadata: {
        algorithm: SchedulingAlgorithm;
        priorityScore: number;
        resourceScore: number;
        deadlineScore: number;
        dependencyScore: number;
        durationScore: number;
        systemLoadScore: number;
        complexityScore: number;
        businessImpactScore: number;
        agentAvailabilityScore: number;
        totalScore: number;
        scheduledAt: Date;
        lastOptimized: Date;
    };
}
export interface ExecutionSchedule {
    id: string;
    projectId: string;
    scheduledTasks: Map<string, ScheduledTask>;
    executionBatches: ParallelBatch[];
    timeline: {
        startTime: Date;
        endTime: Date;
        totalDuration: number;
        criticalPath: string[];
        parallelismFactor: number;
    };
    resourceUtilization: {
        peakMemoryMB: number;
        averageCpuUtilization: number;
        agentUtilization: number;
        resourceEfficiency: number;
    };
    metadata: {
        algorithm: SchedulingAlgorithm;
        config: SchedulingConfig;
        generatedAt: Date;
        optimizedAt: Date;
        version: number;
        isOptimal: boolean;
    };
}
export interface ScheduleOptimizationResult {
    originalSchedule: ExecutionSchedule;
    optimizedSchedule: ExecutionSchedule;
    improvements: {
        timeReduction: number;
        resourceEfficiencyGain: number;
        parallelismIncrease: number;
        deadlineCompliance: number;
    };
    optimizationDetails: {
        algorithm: SchedulingAlgorithm;
        iterations: number;
        convergenceTime: number;
        changesApplied: string[];
    };
}
export declare const DEFAULT_SCHEDULING_CONFIG: SchedulingConfig;
export declare class TaskScheduler {
    private config;
    private currentSchedule;
    private optimizationTimer;
    private scheduleVersion;
    private static currentInstance;
    constructor(config?: Partial<SchedulingConfig>);
    static getCurrentInstance(): TaskScheduler | null;
    static resetCurrentInstance(): void;
    static hasCurrentInstance(): boolean;
    generateSchedule(tasks: AtomicTask[], dependencyGraph: OptimizedDependencyGraph, projectId: string): Promise<ExecutionSchedule>;
    updateSchedule(updatedTasks: AtomicTask[], dependencyGraph: OptimizedDependencyGraph): Promise<ExecutionSchedule>;
    getCurrentSchedule(): ExecutionSchedule | null;
    getReadyTasks(): ScheduledTask[];
    getNextExecutionBatch(): ParallelBatch | null;
    markTaskCompleted(taskId: string): Promise<void>;
    executeScheduledTasks(): Promise<{
        success: boolean;
        executedTasks: string[];
        queuedTasks: string[];
        errors: Array<{
            taskId: string;
            error: string;
        }>;
    }>;
    private mapTaskPriorityToExecutionPriority;
    dispose(): void;
    private isDisposed;
    private waitForExecutionDependencies;
    private validateSchedulingInputs;
    private calculateTaskScores;
    private applySchedulingAlgorithm;
    private priorityFirstScheduling;
    private hybridOptimalScheduling;
    private optimizeBatchOrder;
    private initializeResourceTracker;
    private updateResourceTracker;
    private calculateOptimalBatchStartTime;
    private calculateTimeline;
    private calculateResourceUtilization;
    private optimizeSchedule;
    private calculatePriorityScore;
    private calculateDeadlineScore;
    private calculateDependencyScore;
    private calculateResourceScore;
    private calculateDurationScore;
    private calculateSystemLoadScore;
    private calculateComplexityScore;
    private calculateBusinessImpactScore;
    private calculateAgentAvailabilityScore;
    private getCurrentMemoryUtilization;
    private getCurrentCpuUtilization;
    private getCurrentTaskLoad;
    private getCurrentBusyAgents;
    private calculateTaskDeadline;
    private allocateResources;
    private allocateOptimalResources;
    private assignAgent;
    private findCriticalPath;
    private findPathFromTask;
    private optimizeResourceAllocation;
    private optimizeParallelExecution;
    private optimizeDeadlineCompliance;
    private shouldReschedule;
    private incrementalUpdate;
    private arePrerequisitesComplete;
    private calculateActualHours;
    private checkForOptimization;
    private optimizeCurrentSchedule;
    private startOptimizationTimer;
    private earliestDeadlineScheduling;
    private criticalPathScheduling;
    private resourceBalancedScheduling;
    private shortestJobScheduling;
    getScheduleMetrics(): {
        resourceUtilization: number;
        timelineEfficiency: number;
        dependencyCompliance: number;
        parallelismFactor: number;
        criticalPathOptimization: number;
        overallScore: number;
    } | null;
    getScheduleAnalytics(): {
        taskDistribution: Record<string, number>;
        batchAnalysis: Array<{
            batchId: number;
            taskCount: number;
            estimatedDuration: number;
            resourceUsage: number;
            parallelismScore: number;
        }>;
        bottlenecks: Array<{
            taskId: string;
            type: 'resource' | 'dependency' | 'timeline';
            severity: 'low' | 'medium' | 'high';
            description: string;
        }>;
        optimizationOpportunities: Array<{
            type: 'parallelization' | 'resource_reallocation' | 'timeline_compression';
            impact: 'low' | 'medium' | 'high';
            description: string;
            estimatedImprovement: number;
        }>;
    } | null;
    loadSchedule(scheduleId: string): Promise<ExecutionSchedule | null>;
    cleanupOldSchedules(olderThanDays?: number): Promise<number>;
}
//# sourceMappingURL=task-scheduler.d.ts.map