vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
161 lines (160 loc) • 7.26 kB
JavaScript
import { ServiceTokens, getContainer } from './di-container.js';
import logger from '../../../logger.js';
export class ServiceRegistry {
static initialized = false;
static container;
static async initialize() {
if (this.initialized) {
return this.container;
}
this.container = getContainer();
try {
await this.registerCoreServices();
await this.registerStorageServices();
await this.registerBusinessServices();
await this.registerUtilityServices();
this.container.validateDependencyGraph();
this.initialized = true;
logger.info('Service registry initialized successfully');
return this.container;
}
catch (error) {
logger.error('Failed to initialize service registry:', error);
throw error;
}
}
static async registerCoreServices() {
this.container.singleton(ServiceTokens.ConfigLoader, async () => {
const { getVibeTaskManagerConfig } = await import('../utils/config-loader.js');
return { getVibeTaskManagerConfig };
});
this.container.singleton(ServiceTokens.FileUtils, async () => {
const { FileUtils } = await import('../utils/file-utils.js');
return FileUtils;
});
this.container.singleton(ServiceTokens.IdGenerator, async (_container) => {
const { IdGenerator } = await import('../utils/id-generator.js');
return IdGenerator.getInstance();
});
}
static async registerStorageServices() {
this.container.singleton(ServiceTokens.UnifiedStorageEngine, async (_container) => {
const { UnifiedStorageEngine, createDefaultStorageConfig } = await import('./unified-storage-engine.js');
const config = createDefaultStorageConfig();
const engine = UnifiedStorageEngine.getInstance(config);
await engine.initialize();
return engine;
});
this.container.singleton(ServiceTokens.StorageManager, async (_container) => {
const { StorageManager } = await import('../core/storage/storage-manager.js');
return StorageManager.getInstance();
});
this.container.singleton(ServiceTokens.TaskFileManager, async (_container) => {
const { TaskFileManager } = await import('../core/task-file-manager.js');
return TaskFileManager.getInstance();
});
}
static async registerBusinessServices() {
this.container.singleton(ServiceTokens.TaskOperations, async () => {
const { getTaskOperations } = await import('../core/operations/task-operations.js');
return getTaskOperations();
});
this.container.singleton(ServiceTokens.ProjectOperations, async () => {
const { getProjectOperations } = await import('../core/operations/project-operations.js');
return getProjectOperations();
});
this.container.singleton(ServiceTokens.DependencyOperations, async () => {
const { getDependencyOperations } = await import('../core/operations/dependency-operations.js');
return getDependencyOperations();
});
this.container.singleton(ServiceTokens.RDDEngine, async () => {
return {
decomposeTask: async () => ({ tasks: [], dependencies: [] })
};
});
this.container.singleton(ServiceTokens.EpicService, async () => {
const { EpicService } = await import('../services/epic-service.js');
return EpicService.getInstance();
});
this.container.singleton(ServiceTokens.DecompositionService, async () => {
const { DecompositionService } = await import('../services/decomposition-service.js');
return DecompositionService.getInstance();
});
this.container.singleton(ServiceTokens.ContextEnrichmentService, async () => {
const { ContextEnrichmentService } = await import('../services/context-enrichment-service.js');
return ContextEnrichmentService.getInstance();
});
this.container.singleton(ServiceTokens.AgentOrchestrator, async () => {
const { AgentOrchestrator } = await import('../services/agent-orchestrator.js');
return AgentOrchestrator.getInstance();
});
this.container.singleton(ServiceTokens.UnifiedLifecycleManager, async () => {
const { UnifiedLifecycleManager } = await import('./unified-lifecycle-manager.js');
return UnifiedLifecycleManager.getInstance();
});
this.container.singleton(ServiceTokens.UnifiedTaskExecutionEngine, async () => {
const { UnifiedTaskExecutionEngine, createDefaultConfig } = await import('./unified-task-execution-engine.js');
return UnifiedTaskExecutionEngine.getInstance(createDefaultConfig());
});
this.container.singleton(ServiceTokens.UnifiedOrchestrationEngine, async () => {
const { UnifiedOrchestrationEngine, createDefaultOrchestrationConfig } = await import('./unified-orchestration-engine.js');
const config = createDefaultOrchestrationConfig();
const engine = UnifiedOrchestrationEngine.getInstance(config);
await engine.initialize();
return engine;
});
}
static async registerUtilityServices() {
this.container.singleton(ServiceTokens.UnifiedSecurityEngine, async () => {
const { UnifiedSecurityEngine, createDefaultSecurityConfig } = await import('./unified-security-engine.js');
const config = createDefaultSecurityConfig();
const engine = UnifiedSecurityEngine.getInstance(config);
await engine.initialize();
return engine;
});
this.container.singleton(ServiceTokens.DependencyValidator, async () => {
return {
validateDependency: async () => ({ isValid: true, errors: [] })
};
});
this.container.singleton(ServiceTokens.AtomicDetector, async () => {
return {
isAtomic: async () => true,
analyze: async () => ({ isAtomic: true, reasons: [] })
};
});
}
static async getService(token) {
if (!this.initialized) {
await this.initialize();
}
return this.container.resolve(token);
}
static isInitialized() {
return this.initialized;
}
static reset() {
if (this.container) {
this.container.dispose();
}
this.initialized = false;
}
static getDependencyGraph() {
if (!this.container) {
return 'Container not initialized';
}
return this.container.getDependencyGraph();
}
static getRegisteredServices() {
if (!this.container) {
return [];
}
return this.container.getRegisteredServices();
}
}
export async function getService(token) {
return ServiceRegistry.getService(token);
}
export async function initializeServices() {
return ServiceRegistry.initialize();
}