vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
194 lines • 6.68 kB
TypeScript
import { AtomicTask } from '../types/task.js';
import { ProjectContext } from '../types/project-context.js';
import { AgentResponse } from '../cli/sentinel-protocol.js';
export type AgentCapability = 'frontend' | 'backend' | 'database' | 'testing' | 'devops' | 'documentation' | 'refactoring' | 'debugging' | 'general';
export interface AgentInfo {
id: string;
name: string;
capabilities: AgentCapability[];
maxConcurrentTasks: number;
currentTasks: string[];
status: 'available' | 'busy' | 'offline' | 'error';
lastHeartbeat: Date;
performance: {
tasksCompleted: number;
averageCompletionTime: number;
successRate: number;
lastTaskCompletedAt?: Date;
};
metadata: {
version: string;
supportedProtocols: string[];
preferences: Record<string, unknown>;
};
}
export interface TaskAssignment {
id?: string;
taskId: string;
task: AtomicTask;
agentId: string;
assignedAt: Date;
expectedCompletionAt: Date;
status: 'assigned' | 'in_progress' | 'completed' | 'failed' | 'timeout';
attempts: number;
lastStatusUpdate: Date;
priority: 'low' | 'normal' | 'high' | 'urgent';
estimatedDuration?: number;
deadline?: Date;
sentinelPayload?: string;
context?: {
projectId: string;
epicId?: string;
dependencies: string[];
resources?: string[];
constraints?: string[];
};
metadata?: {
assignedBy?: string;
assignedAt?: number;
executionId?: string;
retryCount?: number;
maxRetries?: number;
[key: string]: unknown;
};
}
export interface ExecutionOptions {
force?: boolean;
priority?: 'low' | 'medium' | 'high' | 'critical';
sessionId?: string;
timeout?: number;
maxRetries?: number;
enableMonitoring?: boolean;
}
export interface TaskExecutionResult {
success: boolean;
assignment?: TaskAssignment;
status: 'completed' | 'failed' | 'timeout' | 'queued' | 'in_progress';
message: string;
startTime?: Date;
endTime?: Date;
agentResponse?: AgentResponse;
error?: string;
queued?: boolean;
metadata?: {
executionId: string;
attempts: number;
totalDuration?: number;
agentId?: string;
};
}
export interface AgentCommunicationChannel {
sendTask(agentId: string, taskPayload: string): Promise<boolean>;
receiveResponse(agentId: string, timeout?: number): Promise<string>;
isAgentReachable(agentId: string): Promise<boolean>;
close(): Promise<void>;
}
export interface OrchestratorConfig {
heartbeatInterval: number;
taskTimeout: number;
maxRetries: number;
loadBalancingStrategy: 'round_robin' | 'capability_based' | 'performance_based';
enableHealthChecks: boolean;
conflictResolutionStrategy: 'queue' | 'reassign' | 'parallel';
heartbeatTimeoutMultiplier: number;
enableAdaptiveTimeouts: boolean;
maxHeartbeatMisses: number;
}
export declare class AgentOrchestrator {
private static instance;
private static isInitializing;
private agents;
private assignments;
private taskQueue;
private sentinelProtocol;
private memoryManager;
private config;
private heartbeatTimer?;
private agentHeartbeatMisses;
private integrationBridge;
private workflowAwareManager;
private isBridgeRegistration;
private activeExecutions;
private communicationChannel;
private executionMonitors;
private sseNotifier;
private taskCompletionCallbacks;
private constructor();
private initializeSSENotifier;
static getInstance(config?: Partial<OrchestratorConfig>): AgentOrchestrator;
private static createSafeFallback;
registerAgent(agentInfo: Omit<AgentInfo, 'lastHeartbeat' | 'performance'>): Promise<void>;
unregisterAgent(agentId: string): Promise<void>;
updateAgentHeartbeat(agentId: string, status?: AgentInfo['status']): void;
getAdaptiveTaskTimeout(task: AtomicTask): number;
private determineTaskComplexity;
assignTask(task: AtomicTask, context: ProjectContext, epicTitle?: string): Promise<TaskAssignment | null>;
executeTask(task: AtomicTask, context: ProjectContext, options?: ExecutionOptions): Promise<TaskExecutionResult>;
private monitorTaskExecution;
processAgentResponse(responseText: string, agentId: string): Promise<void>;
private processResponseThroughUnifiedProcessor;
private mapResponseStatusToUnified;
private extractCompletionDetails;
registerTaskCompletionCallback(taskId: string, callback: (taskId: string, success: boolean, details?: Record<string, unknown>) => Promise<void>): void;
registerSchedulerCallback(): Promise<void>;
private triggerTaskCompletionCallbacks;
getAssignmentsMap(): Map<string, TaskAssignment>;
getCommunicationChannel(): AgentCommunicationChannel;
getAgentStats(): {
totalAgents: number;
availableAgents: number;
busyAgents: number;
offlineAgents: number;
totalAssignments: number;
queuedTasks: number;
};
getAgents(): AgentInfo[];
getAssignments(): TaskAssignment[];
getActiveExecutions(): TaskExecutionResult[];
getExecutionResult(executionId: string): TaskExecutionResult | undefined;
cancelExecution(executionId: string): Promise<boolean>;
private isAgentCapableOfTask;
private mapTaskPriorityToAssignmentPriority;
private selectBestAgent;
private selectByCapability;
private isAgentCapableForTask;
private selectByLoadBalancing;
private selectBestCapableAgent;
private calculateAgentScore;
private calculateCapabilityRelevance;
private calculateContextScore;
private selectByPerformance;
private handleExecutionFailure;
private retryTaskExecution;
private handleTaskCompletion;
private handleHelpRequest;
private handleTaskBlocked;
private handleTaskFailure;
private reassignAgentTasks;
private processTaskQueue;
private startHeartbeatMonitoring;
private checkAgentHealth;
private calculateAdaptiveHeartbeatTimeout;
getTransportStatus(): {
websocket: {
available: boolean;
port?: number;
endpoint?: string;
};
http: {
available: boolean;
port?: number;
endpoint?: string;
};
sse: {
available: boolean;
port?: number;
endpoint?: string;
};
stdio: {
available: boolean;
};
};
destroy(): Promise<void>;
}
//# sourceMappingURL=agent-orchestrator.d.ts.map