vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
285 lines (284 loc) • 10.8 kB
JavaScript
import { ConfigLoader } from './config-loader.js';
import { TaskManagerMemoryManager } from './memory-manager-integration.js';
import { PerformanceMonitor } from './performance-monitor.js';
import logger from '../../../logger.js';
export var ServicePriority;
(function (ServicePriority) {
ServicePriority[ServicePriority["CRITICAL"] = 0] = "CRITICAL";
ServicePriority[ServicePriority["HIGH"] = 1] = "HIGH";
ServicePriority[ServicePriority["MEDIUM"] = 2] = "MEDIUM";
ServicePriority[ServicePriority["LOW"] = 3] = "LOW";
})(ServicePriority || (ServicePriority = {}));
export class StartupOptimizer {
static instance;
services = new Map();
initializedServices = new Set();
connectionPools = new Map();
performanceConfig;
startupMetrics = null;
startTime = 0;
constructor() {
this.performanceConfig = ConfigLoader.getInstance().getPerformanceConfig();
this.registerCoreServices();
}
static getInstance() {
if (!StartupOptimizer.instance) {
StartupOptimizer.instance = new StartupOptimizer();
}
return StartupOptimizer.instance;
}
registerCoreServices() {
this.registerService({
name: 'config-loader',
priority: ServicePriority.CRITICAL,
dependencies: [],
initFunction: async () => {
const configLoader = ConfigLoader.getInstance();
await configLoader.loadConfig();
await configLoader.warmupCache();
},
lazy: false,
preload: true
});
this.registerService({
name: 'memory-manager',
priority: ServicePriority.CRITICAL,
dependencies: ['config-loader'],
initFunction: async () => {
const config = await ConfigLoader.getInstance().getConfig();
if (config?.taskManager.performance.memoryManagement.enabled) {
TaskManagerMemoryManager.getInstance(config.taskManager.performance.memoryManagement);
}
},
lazy: false,
preload: true
});
this.registerService({
name: 'performance-monitor',
priority: ServicePriority.HIGH,
dependencies: ['config-loader'],
initFunction: async () => {
const config = await ConfigLoader.getInstance().getConfig();
if (config?.taskManager.performance.monitoring.enabled) {
const monitorConfig = {
...config.taskManager.performance.monitoring,
bottleneckDetection: {
enabled: true,
analysisInterval: 30000,
minSampleSize: 10
},
regressionDetection: {
enabled: true,
baselineWindow: 24,
comparisonWindow: 1,
significanceThreshold: 20
}
};
PerformanceMonitor.getInstance(monitorConfig);
}
},
lazy: false,
preload: true
});
this.registerService({
name: 'connection-pools',
priority: ServicePriority.HIGH,
dependencies: ['config-loader'],
initFunction: async () => {
await this.initializeConnectionPools();
},
lazy: false,
preload: true
});
this.registerService({
name: 'execution-coordinator',
priority: ServicePriority.MEDIUM,
dependencies: ['config-loader', 'memory-manager'],
initFunction: async () => {
},
lazy: true,
preload: this.performanceConfig.preloadCriticalServices.includes('execution-coordinator')
});
this.registerService({
name: 'agent-orchestrator',
priority: ServicePriority.MEDIUM,
dependencies: ['config-loader', 'connection-pools'],
initFunction: async () => {
},
lazy: true,
preload: this.performanceConfig.preloadCriticalServices.includes('agent-orchestrator')
});
}
registerService(service) {
this.services.set(service.name, service);
logger.debug({
serviceName: service.name,
priority: service.priority,
lazy: service.lazy
}, 'Service registered for startup optimization');
}
async initializeConnectionPools() {
const poolConfig = {
maxConnections: this.performanceConfig.connectionPoolSize,
minConnections: Math.ceil(this.performanceConfig.connectionPoolSize / 2),
acquireTimeout: 5000,
idleTimeout: 30000,
maxRetries: 3
};
const httpPool = {
config: poolConfig,
connections: new Map(),
available: [],
busy: new Set(),
async acquire() {
const now = new Date();
return {
id: Date.now(),
type: 'http',
created: now,
lastUsed: now,
isActive: true
};
},
async release(connection) {
connection.lastUsed = new Date();
connection.isActive = false;
}
};
this.connectionPools.set('http', httpPool);
const wsPool = {
config: poolConfig,
connections: new Map(),
available: [],
busy: new Set(),
async acquire() {
const now = new Date();
return {
id: Date.now(),
type: 'websocket',
created: now,
lastUsed: now,
isActive: true
};
},
async release(connection) {
connection.lastUsed = new Date();
connection.isActive = false;
}
};
this.connectionPools.set('websocket', wsPool);
logger.debug({ poolConfig }, 'Connection pools initialized');
}
async optimizeStartup() {
this.startTime = performance.now();
try {
logger.debug('Starting optimized startup sequence');
const criticalServices = this.getServicesByPriority(ServicePriority.CRITICAL);
await this.initializeServicesInParallel(criticalServices);
const highPriorityServices = this.getServicesByPriority(ServicePriority.HIGH);
await this.initializeServicesInParallel(highPriorityServices);
if (this.performanceConfig.preloadCriticalServices.length > 0) {
const preloadServices = this.getPreloadServices();
await this.initializeServicesInParallel(preloadServices);
}
const totalTime = performance.now() - this.startTime;
const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
this.startupMetrics = {
totalStartupTime: totalTime,
configLoadTime: 0,
serviceInitTime: totalTime,
connectionPoolTime: 0,
servicesLoaded: this.initializedServices.size,
servicesLazy: this.getLazyServices().length,
memoryUsage,
targetMet: totalTime < this.performanceConfig.maxStartupTime
};
if (this.startupMetrics.targetMet) {
logger.info({
totalTime,
target: this.performanceConfig.maxStartupTime,
servicesLoaded: this.startupMetrics.servicesLoaded
}, 'Startup optimization successful - target met');
}
else {
logger.warn({
totalTime,
target: this.performanceConfig.maxStartupTime,
overage: totalTime - this.performanceConfig.maxStartupTime
}, 'Startup optimization target missed');
}
return this.startupMetrics;
}
catch (error) {
const totalTime = performance.now() - this.startTime;
logger.error({
err: error,
totalTime
}, 'Startup optimization failed');
throw error;
}
}
getServicesByPriority(priority) {
return Array.from(this.services.values())
.filter(service => service.priority === priority && !service.lazy);
}
getPreloadServices() {
return Array.from(this.services.values())
.filter(service => service.preload && !this.initializedServices.has(service.name));
}
getLazyServices() {
return Array.from(this.services.values())
.filter(service => service.lazy);
}
async initializeServicesInParallel(services) {
const initPromises = [];
for (const service of services) {
if (this.initializedServices.has(service.name)) {
continue;
}
const dependenciesMet = service.dependencies.every(dep => this.initializedServices.has(dep));
if (dependenciesMet) {
initPromises.push(this.initializeService(service));
}
}
await Promise.all(initPromises);
}
async initializeService(service) {
const startTime = performance.now();
try {
await service.initFunction();
this.initializedServices.add(service.name);
const initTime = performance.now() - startTime;
logger.debug({
serviceName: service.name,
initTime
}, 'Service initialized');
}
catch (error) {
logger.error({
err: error,
serviceName: service.name
}, 'Service initialization failed');
throw error;
}
}
getConnectionPool(type) {
return this.connectionPools.get(type);
}
getStartupMetrics() {
return this.startupMetrics;
}
isServiceInitialized(serviceName) {
return this.initializedServices.has(serviceName);
}
async lazyLoadService(serviceName) {
const service = this.services.get(serviceName);
if (!service) {
throw new Error(`Service ${serviceName} not found`);
}
if (this.initializedServices.has(serviceName)) {
return;
}
await this.initializeService(service);
}
}