sdlc-agent-4-enterprise-server 1.0.0

package/src/index.ts

@@ -0,0 +1,131 @@
+/**
+ * Backend MCP Server entry point.
+ * Initializes all modules, starts HTTP server on configured port.
+ * LLM TagAnalyzer: qwen3-8b via LM Studio (port 1234)
+ */
+
+import pino from 'pino/pino.js';
+import { loadConfig } from './config/BackendConfig.js';
+import { HttpServer } from './server/HttpServer.js';
+import { ModuleRegistry } from './modules/ModuleRegistry.js';
+import { MemoryModule } from './modules/memory/MemoryModule.js';
+import { CodeIntelModule } from './modules/code-intel/CodeIntelModule.js';
+import { OrchestrationModule } from './modules/orchestration/OrchestrationModule.js';
+import { AnalyticsModule } from './modules/analytics/AnalyticsModule.js';
+import { EmbeddingService } from './engine/parsers/embedding/EmbeddingService.js';
+import { KBGraphModule } from './modules/kb-graph/KBGraphModule.js';
+import { UtilityModule } from './modules/utility/UtilityModule.js';
+
+const VERSION = '1.0.0';
+
+async function main() {
+  const config = loadConfig();
+
+  const logger = pino({
+    level: config.logLevel,
+    transport: {
+      target: 'pino/file',
+      options: { destination: 1 }, // stdout
+    },
+  });
+
+  logger.info({ version: VERSION, config: { port: config.port, host: config.host } }, 'Starting Backend MCP Server');
+
+  // Initialize module registry
+  const registry = new ModuleRegistry(logger);
+
+  // Register all modules
+  registry.register(new MemoryModule(logger));
+  registry.register(new CodeIntelModule(logger));
+  registry.register(new OrchestrationModule(logger, registry));
+  registry.register(new AnalyticsModule(logger));
+  registry.register(new KBGraphModule(logger));
+  registry.register(new UtilityModule(logger));
+
+  // Initialize all modules in parallel
+  await registry.initializeAll();
+
+  // Ingest all registered tools into the dedicated mcp_tools table for dynamic search (find_tools)
+  const memoryModule = registry.getModule('memory') as MemoryModule | undefined;
+  if (memoryModule && memoryModule.status === 'ready') {
+    const memEngine = memoryModule.getEngine();
+    const db = memEngine.getDb();
+    const allTools = registry.getAllToolDefinitions();
+    let ingestedCount = 0;
+    
+    const embeddingService = EmbeddingService.getInstance();
+
+    // Prepare tools with embeddings asynchronously
+    const preparedTools = [];
+    for (const tool of allTools) {
+      const text = `Tool: ${tool.name}\nDescription: ${tool.description}`;
+      const vector = await embeddingService.generateEmbedding(text);
+      const vectorBuffer = Buffer.from(new Float32Array(vector).buffer);
+      preparedTools.push({ tool, vectorBuffer });
+    }
+    
+    // Use transaction for faster ingestion
+    const ingestTools = db.transaction((items: any[]) => {
+      for (const item of items) {
+        const tool = item.tool;
+        const existing = db.prepare('SELECT id FROM mcp_tools WHERE name = ?').get(tool.name) as { id: number } | undefined;
+        const schemaJson = JSON.stringify(tool.inputSchema || {});
+        if (!existing) {
+          db.prepare('INSERT INTO mcp_tools (name, description, schema_json, category, vector) VALUES (?, ?, ?, ?, ?)').run(
+            tool.name,
+            tool.description,
+            schemaJson,
+            tool.category || 'general',
+            item.vectorBuffer
+          );
+          ingestedCount++;
+        } else {
+          db.prepare('UPDATE mcp_tools SET description = ?, schema_json = ?, category = ?, vector = ? WHERE id = ?').run(
+            tool.description,
+            schemaJson,
+            tool.category || 'general',
+            item.vectorBuffer,
+            existing.id
+          );
+        }
+      }
+    });
+    
+    ingestTools(preparedTools);
+    logger.info({ ingestedTools: ingestedCount, totalTools: allTools.length }, 'Ingested dynamic tools with vector embeddings');
+  }
+
+  logger.info(
+    { readyModules: registry.getReadyCount(), totalModules: registry.getTotalCount() },
+    'Modules initialized'
+  );
+
+  // Start HTTP server
+  const server = new HttpServer({
+    port: config.port,
+    host: config.host,
+    logger,
+    registry,
+    version: VERSION,
+  });
+
+  await server.start();
+
+  // Graceful shutdown
+  const shutdown = async (signal: string) => {
+    logger.info({ signal }, 'Shutdown signal received');
+    await server.stop();
+    await registry.shutdownAll();
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+
+  logger.info({ pid: process.pid, port: config.port, version: VERSION }, 'Backend MCP Server ready');
+}
+
+main().catch((err) => {
+  console.error('Fatal error starting Backend:', err);
+  process.exit(1);
+});

package/src/logger.ts

@@ -0,0 +1,34 @@
+/**
+ * Minimal structured logger interface.
+ * In production, replace with pino or winston.
+ */
+export interface Logger {
+  trace(msg: string, data?: Record<string, unknown>): void;
+  debug(msg: string, data?: Record<string, unknown>): void;
+  info(msg: string, data?: Record<string, unknown>): void;
+  warn(msg: string, data?: Record<string, unknown>): void;
+  error(msg: string, data?: Record<string, unknown>): void;
+}
+
+/**
+ * Default console-based logger with JSON structured output.
+ */
+export const logger: Logger = {
+  trace(msg: string, data?: Record<string, unknown>) {
+    if (process.env.LOG_LEVEL === 'trace') {
+      console.log(JSON.stringify({ level: 'trace', msg, ...data, timestamp: new Date().toISOString() }));
+    }
+  },
+  debug(msg: string, data?: Record<string, unknown>) {
+    console.debug(JSON.stringify({ level: 'debug', msg, ...data, timestamp: new Date().toISOString() }));
+  },
+  info(msg: string, data?: Record<string, unknown>) {
+    console.info(JSON.stringify({ level: 'info', msg, ...data, timestamp: new Date().toISOString() }));
+  },
+  warn(msg: string, data?: Record<string, unknown>) {
+    console.warn(JSON.stringify({ level: 'warn', msg, ...data, timestamp: new Date().toISOString() }));
+  },
+  error(msg: string, data?: Record<string, unknown>) {
+    console.error(JSON.stringify({ level: 'error', msg, ...data, timestamp: new Date().toISOString() }));
+  },
+};

package/src/modules/ModuleRegistry.ts

@@ -0,0 +1,106 @@
+/**
+ * Module lifecycle registry.
+ * Manages initialization, shutdown, and health status of all backend modules.
+ */
+
+import type { IModule, ModuleHealth, ModuleStatus } from '../types/module.js';
+import type { ToolHandler, ToolDefinition } from '../types/tool.js';
+import type { Logger } from 'pino';
+
+export class ModuleRegistry {
+  private modules: Map<string, IModule> = new Map();
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger;
+  }
+
+  register(module: IModule): void {
+    this.modules.set(module.name, module);
+    this.logger.info({ module: module.name }, 'Module registered');
+  }
+
+  async initializeAll(): Promise<void> {
+    const initPromises = Array.from(this.modules.entries()).map(
+      async ([name, module]) => {
+        try {
+          this.logger.info({ module: name }, 'Initializing module');
+          await module.initialize();
+          this.logger.info({ module: name, status: module.status }, 'Module initialized');
+        } catch (err) {
+          this.logger.error({ module: name, err }, 'Module initialization failed');
+        }
+      }
+    );
+
+    await Promise.allSettled(initPromises);
+  }
+
+  async shutdownAll(): Promise<void> {
+    const shutdownPromises = Array.from(this.modules.entries()).map(
+      async ([name, module]) => {
+        try {
+          await module.shutdown();
+          this.logger.info({ module: name }, 'Module shutdown complete');
+        } catch (err) {
+          this.logger.error({ module: name, err }, 'Module shutdown failed');
+        }
+      }
+    );
+
+    await Promise.allSettled(shutdownPromises);
+  }
+
+  getToolHandlers(): Map<string, ToolHandler> {
+    const handlers = new Map<string, ToolHandler>();
+    for (const module of this.modules.values()) {
+      if (module.status === 'ready') {
+        for (const [name, handler] of module.getToolHandlers()) {
+          handlers.set(name, handler);
+        }
+      }
+    }
+    return handlers;
+  }
+
+  getModule(name: string): IModule | undefined {
+    return this.modules.get(name);
+  }
+
+  getAllToolDefinitions(): ToolDefinition[] {
+    const definitions: ToolDefinition[] = [];
+    for (const module of this.modules.values()) {
+      if (module.status === 'ready') {
+        definitions.push(...module.getToolDefinitions());
+      }
+    }
+    return definitions;
+  }
+
+  getHealth(): Record<string, ModuleStatus> {
+    const health: Record<string, ModuleStatus> = {};
+    for (const [name, module] of this.modules) {
+      health[name] = module.status;
+    }
+    return health;
+  }
+
+  getModuleHealth(): ModuleHealth[] {
+    return Array.from(this.modules.entries()).map(([name, module]) => ({
+      name,
+      status: module.status,
+    }));
+  }
+
+  getReadyCount(): number {
+    return Array.from(this.modules.values()).filter(m => m.status === 'ready').length;
+  }
+
+  getTotalCount(): number {
+    return this.modules.size;
+  }
+
+  isAllReady(): boolean {
+    return Array.from(this.modules.values()).every(m => m.status === 'ready');
+  }
+}

package/src/modules/analytics/AnalyticsModule.ts

@@ -0,0 +1,49 @@
+/**
+ * Analytics Module — quality scoring and analytics data.
+ */
+
+import type { IModule, ModuleStatus } from '../../types/module.js';
+import type { ToolHandler, ToolDefinition } from '../../types/tool.js';
+import type { Logger } from 'pino';
+
+export class AnalyticsModule implements IModule {
+  readonly name = 'analytics';
+  private _status: ModuleStatus = 'initializing';
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ module: this.name });
+  }
+
+  get status(): ModuleStatus { return this._status; }
+
+  async initialize(): Promise<void> {
+    this.logger.info('Initializing analytics module');
+    this._status = 'ready';
+  }
+
+  async shutdown(): Promise<void> { this._status = 'stopped'; }
+
+  getToolHandlers(): Map<string, ToolHandler> {
+    const handlers = new Map<string, ToolHandler>();
+
+    handlers.set('analytics_summary', async () => ({
+      content: [{ type: 'text', text: JSON.stringify({ totalCalls: 0, avgResponseTime: 0 }) }],
+      isError: false,
+    }));
+
+    handlers.set('quality_score', async (args) => ({
+      content: [{ type: 'text', text: JSON.stringify({ score: 0, entry_id: args.entry_id }) }],
+      isError: false,
+    }));
+
+    return handlers;
+  }
+
+  getToolDefinitions(): ToolDefinition[] {
+    return [
+      { name: 'analytics_summary', description: 'Get analytics summary data', inputSchema: { type: 'object', properties: {} }, category: 'analytics' },
+      { name: 'quality_score', description: 'Get quality score for an entry', inputSchema: { type: 'object', properties: { entry_id: { type: 'string' } }, required: ['entry_id'] }, category: 'analytics' },
+    ];
+  }
+}

package/src/modules/code-intel/CodeIntelModule.ts

@@ -0,0 +1,84 @@
+/**
+ * Code Intelligence Module — handles code_* tool operations.
+ * Provides code indexing, search, and symbol resolution.
+ */
+
+import type { IModule, ModuleStatus } from '../../types/module.js';
+import type { ToolHandler, ToolDefinition } from '../../types/tool.js';
+import type { Logger } from 'pino';
+import { DatabaseManager } from '../../engine/db/database-manager.js';
+import { IndexingEngine } from '../../engine/indexer/indexing-engine.js';
+import { loadConfig } from '../../engine/config.js';
+import { CODE_INTEL_TOOL_DEFINITIONS, dispatchCodeIntelTool } from '../../engine/tools/register-tools.js';
+
+export class CodeIntelModule implements IModule {
+  readonly name = 'codeIntel';
+  private _status: ModuleStatus = 'initializing';
+  private logger: Logger;
+  private dbManager!: DatabaseManager;
+  private indexer!: IndexingEngine;
+  private workspace!: string;
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ module: this.name });
+  }
+
+  get status(): ModuleStatus { return this._status; }
+
+  getIndexer(): IndexingEngine {
+    return this.indexer;
+  }
+
+  async initialize(): Promise<void> {
+    this.logger.info('Initializing code intelligence module');
+    try {
+      const config = loadConfig();
+      this.workspace = config.workspace;
+      this.dbManager = new DatabaseManager(config.dbPath);
+      this.dbManager.initialize();
+      this.indexer = new IndexingEngine(this.dbManager, config);
+      this.indexer.startBackgroundIndexing();
+      this._status = 'ready';
+    } catch (error) {
+      this.logger.error({ err: error }, 'Failed to initialize code intelligence module');
+      this._status = 'error';
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    this.logger.info('Shutting down code intelligence module');
+    if (this.indexer) {
+      this.indexer.stop();
+    }
+    if (this.dbManager) {
+      this.dbManager.close();
+    }
+    this._status = 'stopped';
+  }
+
+  getToolHandlers(): Map<string, ToolHandler> {
+    const handlers = new Map<string, ToolHandler>();
+
+    for (const def of CODE_INTEL_TOOL_DEFINITIONS) {
+      handlers.set(def.name, async (args) => {
+        try {
+          const result = await dispatchCodeIntelTool(def.name, args, this.dbManager, this.indexer, this.workspace);
+          return { content: [{ type: 'text', text: result }], isError: false };
+        } catch (error: any) {
+          return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+        }
+      });
+    }
+
+    return handlers;
+  }
+
+  getToolDefinitions(): ToolDefinition[] {
+    return CODE_INTEL_TOOL_DEFINITIONS.map(def => ({
+      name: def.name,
+      description: def.description,
+      inputSchema: def.inputSchema as any,
+      category: 'code'
+    }));
+  }
+}

package/src/modules/kb-graph/KBGraphModule.ts

@@ -0,0 +1,63 @@
+/**
+ * KB Graph Module — knowledge graph operations.
+ */
+
+import type { IModule, ModuleStatus } from '../../types/module.js';
+import type { ToolHandler, ToolDefinition } from '../../types/tool.js';
+import type { Logger } from 'pino';
+import { SqliteGraphService } from './SqliteGraphService.js';
+
+export class KBGraphModule implements IModule {
+  readonly name = 'kbGraph';
+  private _status: ModuleStatus = 'initializing';
+  private logger: Logger;
+  private graphService: SqliteGraphService;
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ module: this.name });
+    this.graphService = new SqliteGraphService(this.logger);
+  }
+
+  get status(): ModuleStatus { return this._status; }
+
+  async initialize(): Promise<void> {
+    this.logger.info('Initializing KB graph module');
+    this.graphService.initialize();
+    // Expose globally for admin routes spatial endpoint
+    (globalThis as any).__sqliteGraphService = this.graphService;
+    this._status = 'ready';
+  }
+
+  async shutdown(): Promise<void> {
+    this._status = 'stopped';
+  }
+
+  getToolHandlers(): Map<string, ToolHandler> {
+    const handlers = new Map<string, ToolHandler>();
+
+    handlers.set('kb_graph_query', async (args) => ({
+      content: [{ type: 'text', text: JSON.stringify({ nodes: [], edges: [], query: args.query }) }],
+      isError: false,
+    }));
+
+    handlers.set('kb_graph_add_node', async (args) => ({
+      content: [{ type: 'text', text: `Node added: ${args.title}` }],
+      isError: false,
+    }));
+
+    handlers.set('kb_graph_add_edge', async (args) => ({
+      content: [{ type: 'text', text: `Edge added: ${args.from} -> ${args.to}` }],
+      isError: false,
+    }));
+
+    return handlers;
+  }
+
+  getToolDefinitions(): ToolDefinition[] {
+    return [
+      { name: 'kb_graph_query', description: 'Query the knowledge base graph', inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] }, category: 'kb-graph' },
+      { name: 'kb_graph_add_node', description: 'Add a node to the KB graph', inputSchema: { type: 'object', properties: { title: { type: 'string' }, content: { type: 'string' } }, required: ['title'] }, category: 'kb-graph' },
+      { name: 'kb_graph_add_edge', description: 'Add an edge between KB graph nodes', inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, relation: { type: 'string' } }, required: ['from', 'to'] }, category: 'kb-graph' },
+    ];
+  }
+}