vibe-coder-mcp/build/tools/vibe-task-manager/core/unified-task-execution-engine.d.ts

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

import { EventEmitter } from 'events';
import { AtomicTask, TaskStatus, TaskPriority } from '../types/task.js';
import { EnhancedError } from '../utils/enhanced-errors.js';
import { Result } from './unified-lifecycle-manager.js';
export type TaskId = string & {
    readonly __brand: 'TaskId';
};
export type AgentId = string & {
    readonly __brand: 'AgentId';
};
export type ExecutionId = string & {
    readonly __brand: 'ExecutionId';
};
export type StreamId = string & {
    readonly __brand: 'StreamId';
};
export declare function createTaskId(id: string): TaskId;
export declare function createAgentId(id: string): AgentId;
export declare function createExecutionId(id: string): ExecutionId;
export declare function createStreamId(id: string): StreamId;
export type ExecutionStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
export type SchedulingAlgorithm = 'priority_first' | 'earliest_deadline' | 'critical_path' | 'resource_balanced' | 'shortest_job' | 'hybrid_optimal';
export interface Agent {
    id: AgentId;
    name: string;
    status: 'idle' | 'busy' | 'offline' | 'error';
    capacity: {
        maxMemoryMB: number;
        maxCpuWeight: number;
        maxConcurrentTasks: number;
    };
    currentUsage: {
        memoryMB: number;
        cpuWeight: number;
        activeTasks: number;
    };
    metadata: {
        lastHeartbeat: Date;
        totalTasksExecuted: number;
        averageExecutionTime: number;
        successRate: number;
    };
}
export interface TaskExecution {
    executionId: ExecutionId;
    taskId: TaskId;
    agentId?: AgentId;
    status: ExecutionStatus;
    priority: TaskPriority;
    scheduledAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    estimatedDuration?: number;
    actualDuration?: number;
    retryCount: number;
    maxRetries: number;
    timeoutAt?: Date;
    result?: {
        success: boolean;
        output?: string;
        error?: string;
        metadata?: Record<string, unknown>;
    };
    resourceRequirements: {
        memoryMB: number;
        cpuWeight: number;
        estimatedDurationMinutes: number;
    };
}
export interface TaskScores {
    priorityScore: number;
    deadlineScore: number;
    dependencyScore: number;
    resourceScore: number;
    durationScore: number;
    systemLoadScore: number;
    complexityScore: number;
    businessImpactScore: number;
    agentAvailabilityScore: number;
    totalScore: number;
}
export interface ResourceConstraints {
    maxMemoryMB: number;
    maxCpuWeight: number;
    maxConcurrentTasks: number;
    reservedMemoryMB: number;
    reservedCpuWeight: number;
}
export interface StreamConfig {
    batchSize: number;
    streamInterval: number;
    maxQueueSize: number;
    priorityThreshold: number;
    enableRealTimeStreaming: boolean;
    loadBalancingEnabled: boolean;
}
export interface StreamStatus {
    streamId: StreamId;
    isActive: boolean;
    queuedTasks: number;
    streamedTasks: number;
    failedTasks: number;
    averageStreamTime: number;
    lastStreamAt?: Date;
}
export interface WatchdogConfig {
    taskType: string;
    timeoutMinutes: number;
    warningThresholdMinutes: number;
    maxRetries: number;
    escalationDelayMinutes: number;
    healthCheckIntervalMinutes: number;
}
export interface TaskMonitor {
    taskId: TaskId;
    agentId?: AgentId;
    startTime: Date;
    lastHeartbeat: Date;
    timeoutAt: Date;
    warningAt: Date;
    status: 'monitoring' | 'warning' | 'timeout' | 'escalated' | 'recovered';
    retryCount: number;
    escalationLevel: number;
    taskType: string;
    estimatedDuration?: number;
}
export interface TaskTransition {
    taskId: TaskId;
    fromStatus: TaskStatus;
    toStatus: TaskStatus;
    timestamp: Date;
    reason?: string;
    triggeredBy?: string;
    metadata?: Record<string, unknown>;
    isAutomated: boolean;
}
export interface UnifiedTaskExecutionEngineConfig {
    scheduling: {
        algorithm: SchedulingAlgorithm;
        enableDynamicPriority: boolean;
        resourceConstraints: ResourceConstraints;
        batchSize: number;
        schedulingInterval: number;
    };
    streaming: StreamConfig;
    execution: {
        maxConcurrentExecutions: number;
        enableLoadBalancing: boolean;
        enableResourceMonitoring: boolean;
        executionTimeout: number;
    };
    watchdog: {
        enabled: boolean;
        defaultTimeout: number;
        healthCheckInterval: number;
        maxRetries: number;
        escalationEnabled: boolean;
    };
    lifecycle: {
        enableAutomation: boolean;
        transitionTimeout: number;
        enableStateHistory: boolean;
        enableDependencyTracking: boolean;
    };
}
export declare class UnifiedTaskExecutionEngine extends EventEmitter {
    private static instance;
    private readonly config;
    private readonly agents;
    private readonly executions;
    private readonly monitors;
    private readonly streams;
    private readonly schedulingQueue;
    private schedulingTimer;
    private isSchedulingActive;
    private readonly streamingQueues;
    private streamingTimers;
    private watchdogTimer;
    private readonly watchdogConfigs;
    private constructor();
    static getInstance(config?: UnifiedTaskExecutionEngineConfig): UnifiedTaskExecutionEngine;
    static resetInstance(): void;
    registerAgent(agent: Agent): Promise<Result<void, EnhancedError>>;
    unregisterAgent(agentId: AgentId): Promise<Result<void, EnhancedError>>;
    updateAgentStatus(agentId: AgentId, status: Agent['status'], usage?: Partial<Agent['currentUsage']>): Promise<Result<void, EnhancedError>>;
    submitTask(task: AtomicTask, resourceRequirements?: Partial<TaskExecution['resourceRequirements']>): Promise<Result<ExecutionId, EnhancedError>>;
    cancelExecution(executionId: ExecutionId): Promise<Result<void, EnhancedError>>;
    getExecution(executionId: ExecutionId): TaskExecution | null;
    getAllExecutions(): TaskExecution[];
    getExecutionsByStatus(status: ExecutionStatus): TaskExecution[];
    private startScheduler;
    private processSchedulingQueue;
    private sortTasksByAlgorithm;
    private comparePriority;
    private compareResourceRequirements;
    private calculateTaskScore;
    private selectOptimalAgent;
    private canAgentHandleTask;
    private calculateAgentScore;
    private assignTaskToAgent;
    private initializeDefaultWatchdogConfigs;
    private startWatchdog;
    private startTaskMonitoring;
    private processWatchdogChecks;
    private handleTaskTimeout;
    private handleTaskWarning;
    private retryExecution;
    completeExecution(executionId: ExecutionId, result: TaskExecution['result']): Promise<Result<void, EnhancedError>>;
    getExecutionStatistics(): {
        total: number;
        byStatus: Record<ExecutionStatus, number>;
        averageExecutionTime: number;
        successRate: number;
        agentUtilization: Record<string, number>;
    };
    dispose(): void;
}
export declare function createDefaultConfig(): UnifiedTaskExecutionEngineConfig;
//# sourceMappingURL=unified-task-execution-engine.d.ts.map