bc-code-intelligence-mcp 1.7.1 → 1.7.2

package/dist/index.js

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { readFileSync, existsSync } from 'fs';
-import { allTools, debugTools } from './tools/index.js';
-import { createToolHandlers, createDebugToolHandlers } from './tools/handlers.js';
-import { KnowledgeService } from './services/knowledge-service.js';
-import { CodeAnalysisService } from './services/code-analysis-service.js';
-import { MethodologyService } from './services/methodology-service.js';
-import { WorkflowService } from './services/workflow-service.js';
-import { WorkflowSessionManager } from './services/workflow-v2/workflow-session-manager.js';
-import { RelevanceIndexService } from './services/relevance-index-service.js';
-import { getDomainList } from './types/bc-knowledge.js';
-import { MultiContentLayerService } from './services/multi-content-layer-service.js';
-import { SpecialistSessionManager } from './services/specialist-session-manager.js';
-import { SpecialistDiscoveryService } from './services/specialist-discovery.js';
-import { WorkflowSpecialistRouter } from './services/workflow-specialist-router.js';
-import { ConfigurationLoader } from './config/config-loader.js';
-import { ConfigurationValidator } from './config/config-validator.js';
-import { LayerSourceType } from './types/index.js';
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFileSync, existsSync } from "fs";
+import { allTools, debugTools, } from "./tools/index.js";
+import { createToolHandlers, createDebugToolHandlers, } from "./tools/handlers.js";
+import { KnowledgeService } from "./services/knowledge-service.js";
+import { CodeAnalysisService } from "./services/code-analysis-service.js";
+import { MethodologyService } from "./services/methodology-service.js";
+import { WorkflowService } from "./services/workflow-service.js";
+import { WorkflowSessionManager } from "./services/workflow-v2/workflow-session-manager.js";
+import { RelevanceIndexService } from "./services/relevance-index-service.js";
+import { getDomainList } from "./types/bc-knowledge.js";
+import { MultiContentLayerService } from "./services/multi-content-layer-service.js";
+import { SpecialistSessionManager } from "./services/specialist-session-manager.js";
+import { SpecialistDiscoveryService } from "./services/specialist-discovery.js";
+import { WorkflowSpecialistRouter } from "./services/workflow-specialist-router.js";
+import { ConfigurationLoader } from "./config/config-loader.js";
+import { ConfigurationValidator } from "./config/config-validator.js";
+import { LayerSourceType, } from "./types/index.js";
 /**
  * BC Code Intelligence MCP Server
  *
@@ -52,21 +52,21 @@ class BCCodeIntelligenceServer {
         try {
             const __filename = fileURLToPath(import.meta.url);
             const __dirname = dirname(__filename);
-            const packagePath = join(__dirname, '..', 'package.json');
+            const packagePath = join(__dirname, "..", "package.json");
             console.error(`🔍 Looking for package.json at: ${packagePath}`);
             console.error(`   Exists: ${existsSync(packagePath)}`);
             if (!existsSync(packagePath)) {
                 console.error(`⚠️  package.json not found at expected location`);
-                return '1.0.0'; // fallback
+                return "1.0.0"; // fallback
             }
-            const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
-            const version = packageJson.version || '1.0.0';
+            const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
+            const version = packageJson.version || "1.0.0";
             console.error(`   Version: ${version}`);
             return version;
         }
         catch (error) {
             console.error(`⚠️  Error reading package.json:`, error instanceof Error ? error.message : String(error));
-            return '1.0.0'; // fallback
+            return "1.0.0"; // fallback
         }
     }
     constructor() {
@@ -76,20 +76,20 @@ class BCCodeIntelligenceServer {
         console.error(`[startup] Node version: ${process.version}`);
         // Initialize MCP server with capabilities declaration (required by SDK 1.x)
         this.server = new Server({
-            name: 'bc-code-intelligence-mcp',
+            name: "bc-code-intelligence-mcp",
             version: this.getPackageVersion(),
         }, {
             capabilities: {
                 tools: {},
-                prompts: {}
-            }
+                prompts: {},
+            },
         });
         // Initialize configuration loader
         this.configLoader = new ConfigurationLoader();
         // Initialize workspace tool handlers (these work before services are initialized)
         const workspaceContext = {
             setWorkspaceInfo: this.setWorkspaceInfo.bind(this),
-            getWorkspaceInfo: this.getWorkspaceInfo.bind(this)
+            getWorkspaceInfo: this.getWorkspaceInfo.bind(this),
         };
         this.toolHandlers = createToolHandlers({}, workspaceContext);
         // Services will be initialized asynchronously in run()
@@ -111,7 +111,7 @@ class BCCodeIntelligenceServer {
             const { name, arguments: args } = request.params;
             try {
                 // Workspace tools are always available (no interception)
-                if (['set_workspace_info', 'get_workspace_info'].includes(name)) {
+                if (["set_workspace_info", "get_workspace_info"].includes(name)) {
                     const handler = this.toolHandlers.get(name);
                     if (!handler) {
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown workspace tool: ${name}`);
@@ -121,8 +121,9 @@ class BCCodeIntelligenceServer {
                 // Intercept all other tools if services not initialized
                 if (!this.servicesInitialized) {
                     return {
-                        content: [{
-                                type: 'text',
+                        content: [
+                            {
+                                type: "text",
                                 text: `⚠️ **Workspace Not Configured**
 
 The BC Code Intelligence server needs workspace information to load project-specific configuration and knowledge layers.
@@ -152,8 +153,9 @@ Place a configuration file at:
 
 Use absolute paths in the config for git/local layers.
 
-Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enable project layers and MCP ecosystem awareness.`
-                            }]
+Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enable project layers and MCP ecosystem awareness.`,
+                            },
+                        ],
                     };
                 }
                 // Try debug tool handlers first (if enabled)
@@ -180,236 +182,236 @@ Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enab
      * Setup prompts for workflow pipelines
      */
     setupPrompts() {
-        console.error('🎯 Setting up MCP Prompts for workflow pipelines...');
+        console.error("🎯 Setting up MCP Prompts for workflow pipelines...");
         // Define workflow prompts that guide users through structured pipelines
         const workflowPrompts = [
             {
-                name: 'code_optimization',
-                description: 'Optimize existing Business Central code using systematic analysis phases',
+                name: "code_optimization",
+                description: "Optimize existing Business Central code using systematic analysis phases",
                 arguments: [
                     {
-                        name: 'code_location',
-                        description: 'Path to the code file or description of the code to optimize',
-                        required: false // No more required fields - specialist will ask conversationally
-                    }
-                ]
+                        name: "code_location",
+                        description: "Path to the code file or description of the code to optimize",
+                        required: false, // No more required fields - specialist will ask conversationally
+                    },
+                ],
             },
             {
-                name: 'architecture_review',
-                description: 'Conduct comprehensive architecture review of Business Central solution',
+                name: "architecture_review",
+                description: "Conduct comprehensive architecture review of Business Central solution",
                 arguments: [
                     {
-                        name: 'scope',
-                        description: 'Scope of review (module, solution, or specific components)',
-                        required: false // Specialist will ask about scope naturally
-                    }
-                ]
+                        name: "scope",
+                        description: "Scope of review (module, solution, or specific components)",
+                        required: false, // Specialist will ask about scope naturally
+                    },
+                ],
             },
             {
-                name: 'security_audit',
-                description: 'Perform security analysis and compliance check for Business Central implementation',
+                name: "security_audit",
+                description: "Perform security analysis and compliance check for Business Central implementation",
                 arguments: [
                     {
-                        name: 'audit_scope',
-                        description: 'Security audit scope (permissions, data access, API security, etc.)',
-                        required: false // Specialist will gather this in conversation
-                    }
-                ]
+                        name: "audit_scope",
+                        description: "Security audit scope (permissions, data access, API security, etc.)",
+                        required: false, // Specialist will gather this in conversation
+                    },
+                ],
             },
             {
-                name: 'perf_review',
-                description: 'Analyze and optimize Business Central performance issues',
+                name: "perf_review",
+                description: "Analyze and optimize Business Central performance issues",
                 arguments: [
                     {
-                        name: 'performance_concern',
-                        description: 'Description of performance issue or area to analyze',
-                        required: false
-                    }
-                ]
+                        name: "performance_concern",
+                        description: "Description of performance issue or area to analyze",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'integration_design',
-                description: 'Design robust integration patterns for Business Central',
+                name: "integration_design",
+                description: "Design robust integration patterns for Business Central",
                 arguments: [
                     {
-                        name: 'integration_type',
-                        description: 'Type of integration (API, data sync, external service, etc.)',
-                        required: false
-                    }
-                ]
+                        name: "integration_type",
+                        description: "Type of integration (API, data sync, external service, etc.)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'upgrade_planning',
-                description: 'Plan Business Central version upgrade with risk assessment',
+                name: "upgrade_planning",
+                description: "Plan Business Central version upgrade with risk assessment",
                 arguments: [
                     {
-                        name: 'current_version',
-                        description: 'Current Business Central version',
-                        required: false
+                        name: "current_version",
+                        description: "Current Business Central version",
+                        required: false,
                     },
                     {
-                        name: 'target_version',
-                        description: 'Target Business Central version',
-                        required: false
-                    }
-                ]
+                        name: "target_version",
+                        description: "Target Business Central version",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'testing_strategy',
-                description: 'Develop comprehensive testing strategy for Business Central solutions',
+                name: "testing_strategy",
+                description: "Develop comprehensive testing strategy for Business Central solutions",
                 arguments: [
                     {
-                        name: 'testing_scope',
-                        description: 'Scope of testing (unit, integration, user acceptance, etc.)',
-                        required: false
-                    }
-                ]
+                        name: "testing_scope",
+                        description: "Scope of testing (unit, integration, user acceptance, etc.)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'dev_onboarding',
-                description: 'Guide new developer through Business Central development onboarding',
+                name: "dev_onboarding",
+                description: "Guide new developer through Business Central development onboarding",
                 arguments: [
                     {
-                        name: 'experience_level',
-                        description: 'Developer experience level (beginner, intermediate, expert)',
-                        required: false
+                        name: "experience_level",
+                        description: "Developer experience level (beginner, intermediate, expert)",
+                        required: false,
                     },
                     {
-                        name: 'focus_area',
-                        description: 'Primary focus area for onboarding (development, customization, integration)',
-                        required: false
-                    }
-                ]
+                        name: "focus_area",
+                        description: "Primary focus area for onboarding (development, customization, integration)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'app_takeover',
-                description: 'Analyze and orient developer taking over an unfamiliar Business Central app',
+                name: "app_takeover",
+                description: "Analyze and orient developer taking over an unfamiliar Business Central app",
                 arguments: [
                     {
-                        name: 'app_source',
-                        description: 'Source of the app (path, repository, AppSource, or description)',
-                        required: false
+                        name: "app_source",
+                        description: "Source of the app (path, repository, AppSource, or description)",
+                        required: false,
                     },
                     {
-                        name: 'takeover_context',
-                        description: 'Context for takeover (maintenance, enhancement, migration, or handoff scenario)',
-                        required: false
-                    }
-                ]
+                        name: "takeover_context",
+                        description: "Context for takeover (maintenance, enhancement, migration, or handoff scenario)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'spec_analysis',
-                description: 'Analyze requirements and specifications to determine development readiness',
+                name: "spec_analysis",
+                description: "Analyze requirements and specifications to determine development readiness",
                 arguments: [
                     {
-                        name: 'spec_source',
-                        description: 'Source of specifications (document, user story, requirements, or description)',
-                        required: false
+                        name: "spec_source",
+                        description: "Source of specifications (document, user story, requirements, or description)",
+                        required: false,
                     },
                     {
-                        name: 'analysis_focus',
-                        description: 'Analysis focus (completeness, feasibility, technical-gaps, or dependencies)',
-                        required: false
-                    }
-                ]
+                        name: "analysis_focus",
+                        description: "Analysis focus (completeness, feasibility, technical-gaps, or dependencies)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'bug_investigation',
-                description: 'Systematically investigate and resolve Business Central bugs and issues',
+                name: "bug_investigation",
+                description: "Systematically investigate and resolve Business Central bugs and issues",
                 arguments: [
                     {
-                        name: 'bug_context',
-                        description: 'Available context (call-stack, repro-steps, snapshot, sandbox-access, or description)',
-                        required: false
+                        name: "bug_context",
+                        description: "Available context (call-stack, repro-steps, snapshot, sandbox-access, or description)",
+                        required: false,
                     },
                     {
-                        name: 'issue_severity',
-                        description: 'Issue severity level (critical, high, medium, low)',
-                        required: false
-                    }
-                ]
+                        name: "issue_severity",
+                        description: "Issue severity level (critical, high, medium, low)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'monolith_to_modules',
-                description: 'Refactor monolithic Business Central code into modular architecture using SOLID principles',
+                name: "monolith_to_modules",
+                description: "Refactor monolithic Business Central code into modular architecture using SOLID principles",
                 arguments: [
                     {
-                        name: 'current_structure',
-                        description: 'Current code structure (monolithic-object, large-codeunit, tightly-coupled, or description)',
-                        required: false
+                        name: "current_structure",
+                        description: "Current code structure (monolithic-object, large-codeunit, tightly-coupled, or description)",
+                        required: false,
                     },
                     {
-                        name: 'modularization_goal',
-                        description: 'Modularization goal (dependency-injection, interface-patterns, loose-coupling, or testability)',
-                        required: false
-                    }
-                ]
+                        name: "modularization_goal",
+                        description: "Modularization goal (dependency-injection, interface-patterns, loose-coupling, or testability)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'data_flow_tracing',
-                description: 'Trace data flow and dependencies across Business Central objects and codeunits',
+                name: "data_flow_tracing",
+                description: "Trace data flow and dependencies across Business Central objects and codeunits",
                 arguments: [
                     {
-                        name: 'trace_target',
-                        description: 'What to trace (field-usage, table-relationships, posting-flow, or process-chain)',
-                        required: false
+                        name: "trace_target",
+                        description: "What to trace (field-usage, table-relationships, posting-flow, or process-chain)",
+                        required: false,
                     },
                     {
-                        name: 'trace_scope',
-                        description: 'Tracing scope (single-object, module-level, cross-module, or end-to-end)',
-                        required: false
-                    }
-                ]
+                        name: "trace_scope",
+                        description: "Tracing scope (single-object, module-level, cross-module, or end-to-end)",
+                        required: false,
+                    },
+                ],
             },
             {
-                name: 'full_review',
-                description: 'Conduct comprehensive review and analysis without implementation changes',
+                name: "full_review",
+                description: "Conduct comprehensive review and analysis without implementation changes",
                 arguments: [
                     {
-                        name: 'review_target',
-                        description: 'What to review (code, architecture, documentation, processes)',
-                        required: false
+                        name: "review_target",
+                        description: "What to review (code, architecture, documentation, processes)",
+                        required: false,
                     },
                     {
-                        name: 'review_depth',
-                        description: 'Review depth (surface, detailed, comprehensive)',
-                        required: false
-                    }
-                ]
-            }
+                        name: "review_depth",
+                        description: "Review depth (surface, detailed, comprehensive)",
+                        required: false,
+                    },
+                ],
+            },
         ];
         // Register prompt list handler
         this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-            prompts: workflowPrompts.map(p => ({
+            prompts: workflowPrompts.map((p) => ({
                 name: p.name,
                 description: p.description,
-                arguments: p.arguments
-            }))
+                arguments: p.arguments,
+            })),
         }));
         // Register get prompt handler for all workflows
         this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
-            const prompt = workflowPrompts.find(p => p.name === name);
+            const prompt = workflowPrompts.find((p) => p.name === name);
             if (!prompt) {
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown prompt: ${name}`);
             }
             try {
                 // Convert workflow name to type and create start request
                 const workflowTypeMap = {
-                    'code_optimization': 'new-bc-app',
-                    'architecture_review': 'enhance-bc-app',
-                    'security_audit': 'debug-bc-issues',
-                    'perf_review': 'debug-bc-issues',
-                    'integration_design': 'add-ecosystem-features',
-                    'upgrade_planning': 'upgrade-bc-version',
-                    'testing_strategy': 'modernize-bc-code',
-                    'dev_onboarding': 'onboard-developer',
-                    'app_takeover': 'enhance-bc-app',
-                    'spec_analysis': 'review-bc-code',
-                    'bug_investigation': 'debug-bc-issues',
-                    'monolith_to_modules': 'modernize-bc-code',
-                    'data_flow_tracing': 'review-bc-code',
-                    'full_review': 'review-bc-code'
+                    code_optimization: "new-bc-app",
+                    architecture_review: "enhance-bc-app",
+                    security_audit: "debug-bc-issues",
+                    perf_review: "debug-bc-issues",
+                    integration_design: "add-ecosystem-features",
+                    upgrade_planning: "upgrade-bc-version",
+                    testing_strategy: "modernize-bc-code",
+                    dev_onboarding: "onboard-developer",
+                    app_takeover: "enhance-bc-app",
+                    spec_analysis: "review-bc-code",
+                    bug_investigation: "debug-bc-issues",
+                    monolith_to_modules: "modernize-bc-code",
+                    data_flow_tracing: "review-bc-code",
+                    full_review: "review-bc-code",
                 };
                 const workflowType = workflowTypeMap[name];
                 if (!workflowType) {
@@ -417,22 +419,30 @@ Currently only embedded knowledge is loaded. Call \`set_workspace_info\` to enab
                 }
                 const startRequest = {
                     workflow_type: workflowType,
-                    project_context: args?.code_location || args?.scope || args?.audit_scope ||
-                        args?.performance_concern || args?.integration_type ||
-                        args?.testing_scope || args?.review_target ||
-                        'General workflow request',
+                    project_context: args?.code_location ||
+                        args?.scope ||
+                        args?.audit_scope ||
+                        args?.performance_concern ||
+                        args?.integration_type ||
+                        args?.testing_scope ||
+                        args?.review_target ||
+                        "General workflow request",
                     bc_version: args?.target_version || args?.current_version,
-                    additional_context: args
+                    additional_context: args,
                 };
                 // Start the workflow session
                 const session = await this.workflowService.startWorkflow(startRequest);
                 // Get the initial guidance for this workflow
                 const initialGuidance = await this.workflowService.getPhaseGuidance(session.id);
                 // Enhance with specialist routing
-                const userContext = args?.code_location || args?.scope || args?.audit_scope ||
-                    args?.performance_concern || args?.integration_type ||
-                    args?.testing_scope || args?.review_target ||
-                    'General workflow request';
+                const userContext = args?.code_location ||
+                    args?.scope ||
+                    args?.audit_scope ||
+                    args?.performance_concern ||
+                    args?.integration_type ||
+                    args?.testing_scope ||
+                    args?.review_target ||
+                    "General workflow request";
                 const enhancedResult = await this.workflowSpecialistRouter.enhanceWorkflowPrompt(name, userContext, initialGuidance);
                 // Construct explicit prompt that bypasses VS Code prompt creation
                 const promptContent = `# ${prompt.description}
@@ -444,27 +454,27 @@ ${enhancedResult.enhancedContent}
 ## 🎯 Next Actions
 
 **Use these MCP tools immediately to proceed:**
-${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start session with', '**Use MCP tool:**')}`).join('\n')}
+${enhancedResult.routingOptions.map((option) => `- ${option.replace("🎯 Start session with", "**Use MCP tool:**")}`).join("\n")}
 
 **Remember:** You have access to 20+ MCP tools from bc-code-intelligence-mcp. Use them actively for specialist consultation and knowledge access.`;
                 return {
                     description: `Starting ${workflowType} workflow with specialist guidance`,
                     messages: [
                         {
-                            role: 'user',
+                            role: "user",
                             content: {
-                                type: 'text',
-                                text: promptContent
-                            }
-                        }
-                    ]
+                                type: "text",
+                                text: promptContent,
+                            },
+                        },
+                    ],
                 };
             }
             catch (error) {
                 throw new McpError(ErrorCode.InternalError, `Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`);
             }
         });
-        console.error('✅ MCP Prompts configured for workflow orchestration');
+        console.error("✅ MCP Prompts configured for workflow orchestration");
     }
     /**
      * Initialize all services with configuration
@@ -479,14 +489,16 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = dirname(__filename);
         const legacyConfig = {
-            knowledge_base_path: process.env['BCKB_KB_PATH'] || join(__dirname, '../embedded-knowledge'),
-            indexes_path: process.env['BCKB_INDEXES_PATH'] || join(__dirname, '../embedded-knowledge/indexes'),
-            workflows_path: process.env['BCKB_WORKFLOWS_PATH'] || join(__dirname, '../embedded-knowledge/workflows'),
+            knowledge_base_path: process.env["BCKB_KB_PATH"] || join(__dirname, "../embedded-knowledge"),
+            indexes_path: process.env["BCKB_INDEXES_PATH"] ||
+                join(__dirname, "../embedded-knowledge/indexes"),
+            workflows_path: process.env["BCKB_WORKFLOWS_PATH"] ||
+                join(__dirname, "../embedded-knowledge/workflows"),
             cache_size: this.configuration.cache.max_size_mb * 1024, // Convert MB to entries approximation
             max_search_results: 20,
-            default_bc_version: 'BC22',
+            default_bc_version: "BC22",
             enable_fuzzy_search: true,
-            search_threshold: 0.6
+            search_threshold: 0.6,
         };
         // Initialize specialist services using a dedicated MultiContentLayerService FIRST
         this.layerService = new MultiContentLayerService();
@@ -502,15 +514,15 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                     case LayerSourceType.EMBEDDED: {
                         // Embedded layer - ALWAYS use the server's embedded knowledge directory
                         // The 'path' field is ignored for embedded layers since they reference the built-in knowledge
-                        const embeddedPath = join(__dirname, '../embedded-knowledge');
+                        const embeddedPath = join(__dirname, "../embedded-knowledge");
                         console.error(`📋 Embedded layer using built-in knowledge: ${embeddedPath}`);
-                        const { EmbeddedKnowledgeLayer } = await import('./layers/embedded-layer.js');
+                        const { EmbeddedKnowledgeLayer } = await import("./layers/embedded-layer.js");
                         layer = new EmbeddedKnowledgeLayer(embeddedPath);
                         break;
                     }
                     case LayerSourceType.LOCAL: {
                         // Local filesystem layer - use ProjectKnowledgeLayer
-                        const { ProjectKnowledgeLayer } = await import('./layers/project-layer.js');
+                        const { ProjectKnowledgeLayer } = await import("./layers/project-layer.js");
                         layer = new ProjectKnowledgeLayer(layerConfig.source.path);
                         // Override name and priority from config
                         layer.name = layerConfig.name;
@@ -519,13 +531,13 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                     }
                     case LayerSourceType.GIT: {
                         // Git repository layer
-                        const { GitKnowledgeLayer } = await import('./layers/git-layer.js');
+                        const { GitKnowledgeLayer } = await import("./layers/git-layer.js");
                         const gitSource = layerConfig.source; // GitLayerSource
                         layer = new GitKnowledgeLayer(layerConfig.name, layerConfig.priority, {
                             type: LayerSourceType.GIT,
                             url: gitSource.url,
                             branch: gitSource.branch,
-                            subpath: gitSource.subpath
+                            subpath: gitSource.subpath,
                         }, layerConfig.auth);
                         break;
                     }
@@ -591,7 +603,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         // Create tool handlers with all service dependencies
         const workspaceContext = {
             setWorkspaceInfo: this.setWorkspaceInfo.bind(this),
-            getWorkspaceInfo: this.getWorkspaceInfo.bind(this)
+            getWorkspaceInfo: this.getWorkspaceInfo.bind(this),
         };
         const handlerServices = {
             knowledgeService: this.knowledgeService,
@@ -602,16 +614,16 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             sessionManager: this.specialistSessionManager,
             discoveryService: this.specialistDiscoveryService,
             configLoader: this.configLoader,
-            workflowSessionManager: this.workflowSessionManager
+            workflowSessionManager: this.workflowSessionManager,
         };
         this.toolHandlers = createToolHandlers(handlerServices, workspaceContext);
         // Initialize debug tool handlers ONLY if enabled (reduces token overhead)
         if (this.configuration.developer.enable_diagnostic_tools) {
             this.debugToolHandlers = createDebugToolHandlers(handlerServices);
-            console.error('🔧 Configuration diagnostic tools enabled');
+            console.error("🔧 Configuration diagnostic tools enabled");
         }
         else {
-            console.error('💡 Tip: Set developer.enable_diagnostic_tools=true for git layer diagnostics');
+            console.error("💡 Tip: Set developer.enable_diagnostic_tools=true for git layer diagnostics");
         }
         // Report final totals
         const specialists = await this.layerService.getAllSpecialists();
@@ -654,8 +666,8 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                 server_version: this.getPackageVersion(),
                 layers_active: this.layerService?.getLayers().length || 0,
                 configuration_loaded: !!this.configuration,
-                total_topics: this.layerService?.getAllTopicIds().length || 0
-            }
+                total_topics: this.layerService?.getAllTopicIds().length || 0,
+            },
         };
         if (includeTopicAnalytics && this.layerService) {
             analytics.topic_analytics = await this.generateTopicAnalytics();
@@ -664,7 +676,8 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             analytics.layer_performance = this.generateLayerPerformanceAnalytics();
         }
         if (includeConfigurationInsights && this.configuration) {
-            analytics.configuration_insights = await this.generateConfigurationInsights();
+            analytics.configuration_insights =
+                await this.generateConfigurationInsights();
         }
         return analytics;
     }
@@ -689,7 +702,8 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                     domainDistribution[domain] = (domainDistribution[domain] || 0) + 1;
                 }
                 if (difficulty) {
-                    difficultyDistribution[difficulty] = (difficultyDistribution[difficulty] || 0) + 1;
+                    difficultyDistribution[difficulty] =
+                        (difficultyDistribution[difficulty] || 0) + 1;
                 }
             }
         }
@@ -701,15 +715,16 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             override_statistics: {
                 total_overrides: Object.keys(overrideStats).length,
                 override_percentage: allTopicIds.length > 0
-                    ? ((Object.keys(overrideStats).length / allTopicIds.length) * 100).toFixed(1) + '%'
-                    : '0%'
+                    ? ((Object.keys(overrideStats).length / allTopicIds.length) *
+                        100).toFixed(1) + "%"
+                    : "0%",
             },
             coverage_insights: {
                 domains_covered: Object.keys(domainDistribution).length,
                 difficulty_levels: Object.keys(difficultyDistribution).length,
-                most_common_domain: Object.entries(domainDistribution).sort(([, a], [, b]) => b - a)[0]?.[0] || 'N/A',
-                most_common_difficulty: Object.entries(difficultyDistribution).sort(([, a], [, b]) => b - a)[0]?.[0] || 'N/A'
-            }
+                most_common_domain: Object.entries(domainDistribution).sort(([, a], [, b]) => b - a)[0]?.[0] || "N/A",
+                most_common_difficulty: Object.entries(difficultyDistribution).sort(([, a], [, b]) => b - a)[0]?.[0] || "N/A",
+            },
         };
     }
     /**
@@ -718,16 +733,18 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
     generateLayerPerformanceAnalytics() {
         const layerStats = this.layerService.getLayerStatistics();
         const layerMetrics = this.layerService.getStatistics();
-        const formattedMetrics = layerMetrics.map(stats => {
+        const formattedMetrics = layerMetrics.map((stats) => {
             return {
                 name: stats.name,
                 priority: stats.priority,
                 enabled: stats.enabled,
                 topic_count: stats.topicCount,
                 index_count: stats.indexCount,
-                memory_usage_mb: stats.memoryUsage?.total ? (stats.memoryUsage.total / (1024 * 1024)).toFixed(2) : 'N/A',
+                memory_usage_mb: stats.memoryUsage?.total
+                    ? (stats.memoryUsage.total / (1024 * 1024)).toFixed(2)
+                    : "N/A",
                 load_time_ms: stats.loadTimeMs || 0,
-                type: 'MultiContentLayer'
+                type: "MultiContentLayer",
             };
         });
         const totalTopics = layerMetrics.reduce((sum, stats) => sum + stats.topicCount, 0);
@@ -736,16 +753,19 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                 total_layers: layerMetrics.length,
                 total_topics: totalTopics,
                 total_indexes: layerMetrics.reduce((sum, stats) => sum + stats.indexCount, 0),
-                total_memory_mb: 'N/A' // Memory tracking not implemented in new system
+                total_memory_mb: "N/A", // Memory tracking not implemented in new system
             },
             layer_metrics: formattedMetrics,
             performance_insights: {
-                fastest_layer: formattedMetrics.sort((a, b) => a.load_time_ms - b.load_time_ms)[0]?.name || 'N/A',
-                most_topics: formattedMetrics.sort((a, b) => b.topic_count - a.topic_count)[0]?.name || 'N/A',
+                fastest_layer: formattedMetrics.sort((a, b) => a.load_time_ms - b.load_time_ms)[0]
+                    ?.name || "N/A",
+                most_topics: formattedMetrics.sort((a, b) => b.topic_count - a.topic_count)[0]
+                    ?.name || "N/A",
                 layer_efficiency: layerMetrics.length > 0
-                    ? (totalTopics / layerMetrics.length).toFixed(1) + ' topics/layer avg'
-                    : 'N/A'
-            }
+                    ? (totalTopics / layerMetrics.length).toFixed(1) +
+                        " topics/layer avg"
+                    : "N/A",
+            },
         };
     }
     /**
@@ -759,46 +779,49 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                 overall_score: validation.score,
                 is_valid: validation.valid,
                 error_count: validation.errors.length,
-                warning_count: validation.warnings.length
+                warning_count: validation.warnings.length,
             },
             layer_configuration: {
                 total_layers: this.configuration.layers.length,
-                enabled_layers: this.configuration.layers.filter(l => l.enabled).length,
+                enabled_layers: this.configuration.layers.filter((l) => l.enabled)
+                    .length,
                 layer_types: this.configuration.layers.reduce((acc, layer) => {
                     acc[layer.source.type] = (acc[layer.source.type] || 0) + 1;
                     return acc;
                 }, {}),
-                priority_distribution: this.configuration.layers.map(l => l.priority).sort((a, b) => a - b)
+                priority_distribution: this.configuration.layers
+                    .map((l) => l.priority)
+                    .sort((a, b) => a - b),
             },
-            optimization_recommendations: []
+            optimization_recommendations: [],
         };
         // Generate optimization recommendations
-        if (this.configuration.layers.filter(l => l.enabled).length < 2) {
+        if (this.configuration.layers.filter((l) => l.enabled).length < 2) {
             insights.optimization_recommendations.push({
-                type: 'layer_diversity',
-                message: 'Consider adding more layer types (git, local overrides) for better customization',
-                impact: 'medium'
+                type: "layer_diversity",
+                message: "Consider adding more layer types (git, local overrides) for better customization",
+                impact: "medium",
             });
         }
         if (this.configuration.performance.max_concurrent_loads < 3) {
             insights.optimization_recommendations.push({
-                type: 'performance',
-                message: 'Increase max_concurrent_loads for better performance on modern systems',
-                impact: 'low'
+                type: "performance",
+                message: "Increase max_concurrent_loads for better performance on modern systems",
+                impact: "low",
             });
         }
         if (!this.configuration.security.validate_sources) {
             insights.optimization_recommendations.push({
-                type: 'security',
-                message: 'Enable source validation for better security',
-                impact: 'high'
+                type: "security",
+                message: "Enable source validation for better security",
+                impact: "high",
             });
         }
         if (validation.warnings.length > 0) {
             insights.optimization_recommendations.push({
-                type: 'configuration',
+                type: "configuration",
                 message: `Address ${validation.warnings.length} configuration warnings`,
-                impact: 'medium'
+                impact: "medium",
             });
         }
         return insights;
@@ -806,7 +829,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
     async run() {
         try {
             // Ultra-early diagnostics for platform issues
-            console.error('=== BC Code Intelligence MCP Server Startup Diagnostics ===');
+            console.error("=== BC Code Intelligence MCP Server Startup Diagnostics ===");
             console.error(`Platform: ${process.platform}`);
             console.error(`Node version: ${process.version}`);
             console.error(`Architecture: ${process.arch}`);
@@ -816,20 +839,20 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             console.error(`🚀 BC Code Intelligence MCP Server v${version} starting...`);
             // CRITICAL FIX for Issue #31: Connect transport BEFORE heavy initialization
             // This allows the MCP handshake to complete quickly, preventing timeouts
-            console.error('🔌 Connecting MCP transport (fast handshake)...');
+            console.error("🔌 Connecting MCP transport (fast handshake)...");
             const transport = new StdioServerTransport();
             await this.server.connect(transport);
-            console.error('✅ MCP transport connected - handshake complete');
+            console.error("✅ MCP transport connected - handshake complete");
             // Now perform heavy initialization in background
-            console.error('📦 Starting service initialization (deferred after handshake)...');
+            console.error("📦 Starting service initialization (deferred after handshake)...");
             // Verify embedded knowledge path BEFORE any service initialization
             const __filename = fileURLToPath(import.meta.url);
             const __dirname = dirname(__filename);
-            const embeddedPath = join(__dirname, '..', 'embedded-knowledge');
+            const embeddedPath = join(__dirname, "..", "embedded-knowledge");
             console.error(`Embedded knowledge path: ${embeddedPath}`);
             console.error(`Embedded knowledge exists: ${existsSync(embeddedPath)}`);
             if (existsSync(embeddedPath)) {
-                const expectedDirs = ['domains', 'specialists', 'workflows'];
+                const expectedDirs = ["domains", "specialists", "workflows"];
                 for (const dir of expectedDirs) {
                     const dirPath = join(embeddedPath, dir);
                     console.error(`  ${dir}/: ${existsSync(dirPath)}`);
@@ -837,10 +860,11 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             }
             // Try to load user-level configuration first (company layers)
             // If no user config exists, fall back to embedded-only mode
-            console.error('📦 Checking for user-level configuration (company layers)...');
+            console.error("📦 Checking for user-level configuration (company layers)...");
             try {
                 const userConfigResult = await this.configLoader.loadConfiguration();
-                if (userConfigResult.config.layers && userConfigResult.config.layers.length > 1) {
+                if (userConfigResult.config.layers &&
+                    userConfigResult.config.layers.length > 1) {
                     // User has configured layers (embedded + company/git layers)
                     console.error(`✅ Found user-level configuration with ${userConfigResult.config.layers.length} layers`);
                     this.configuration = userConfigResult.config;
@@ -850,27 +874,29 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                     catch (configError) {
                         // CRITICAL FIX: If user config initialization fails (e.g. git layer auth failure),
                         // fall back to embedded-only mode instead of crashing the server
-                        console.error('❌ Failed to initialize with user configuration:', configError instanceof Error ? configError.message : String(configError));
-                        console.error('🔄 Falling back to embedded-only mode...');
+                        console.error("❌ Failed to initialize with user configuration:", configError instanceof Error
+                            ? configError.message
+                            : String(configError));
+                        console.error("🔄 Falling back to embedded-only mode...");
                         await this.initializeEmbeddedOnly();
                     }
                 }
                 else {
                     // No user config or only embedded layer - use embedded-only mode
-                    console.error('📦 No user-level configuration found, loading embedded knowledge only...');
+                    console.error("📦 No user-level configuration found, loading embedded knowledge only...");
                     await this.initializeEmbeddedOnly();
                 }
             }
             catch (error) {
-                console.error('⚠️  Failed to load user configuration, falling back to embedded-only:', error instanceof Error ? error.message : String(error));
+                console.error("⚠️  Failed to load user configuration, falling back to embedded-only:", error instanceof Error ? error.message : String(error));
                 await this.initializeEmbeddedOnly();
             }
             console.error(`✅ BC Code Intelligence MCP Server v${this.getPackageVersion()} started successfully`);
             console.error(`💡 To enable project-specific layers, call set_workspace_info with your project path`);
         }
         catch (error) {
-            console.error('💥 Fatal error during server startup:', error);
-            console.error('Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+            console.error("💥 Fatal error during server startup:", error);
+            console.error("Error stack:", error instanceof Error ? error.stack : "No stack trace");
             process.exit(1);
         }
     }
@@ -880,23 +906,23 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
     async initializeEmbeddedOnly() {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = dirname(__filename);
-        const embeddedPath = join(__dirname, '../embedded-knowledge');
+        const embeddedPath = join(__dirname, "../embedded-knowledge");
         // Initialize minimal layer service with only embedded
         this.layerService = new MultiContentLayerService();
-        const { EmbeddedKnowledgeLayer } = await import('./layers/embedded-layer.js');
+        const { EmbeddedKnowledgeLayer } = await import("./layers/embedded-layer.js");
         const embeddedLayer = new EmbeddedKnowledgeLayer(embeddedPath);
         this.layerService.addLayer(embeddedLayer);
         await this.layerService.initialize();
         // Initialize minimal services for embedded-only mode
         const legacyConfig = {
             knowledge_base_path: embeddedPath,
-            indexes_path: join(embeddedPath, 'indexes'),
-            workflows_path: join(embeddedPath, 'workflows'),
+            indexes_path: join(embeddedPath, "indexes"),
+            workflows_path: join(embeddedPath, "workflows"),
             cache_size: 1000,
             max_search_results: 20,
-            default_bc_version: 'BC22',
+            default_bc_version: "BC22",
             enable_fuzzy_search: true,
-            search_threshold: 0.6
+            search_threshold: 0.6,
         };
         this.knowledgeService = new KnowledgeService(legacyConfig);
         await this.knowledgeService.initialize();
@@ -909,9 +935,9 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         const sessionStorageConfig = this.layerService.getSessionStorageConfig();
         this.specialistSessionManager = new SpecialistSessionManager(this.layerService, sessionStorageConfig);
         this.specialistDiscoveryService = new SpecialistDiscoveryService(this.layerService);
-        // Note: Services and tools are initialized, but servicesInitialized = false 
+        // Note: Services and tools are initialized, but servicesInitialized = false
         // This prevents tools from being called until workspace is set
-        console.error('✅ Embedded knowledge loaded. Workspace-specific services pending set_workspace_info.');
+        console.error("✅ Embedded knowledge loaded. Workspace-specific services pending set_workspace_info.");
     }
     /**
      * Initialize with user-level configuration (company layers from ~/.bc-code-intel/config.yaml)
@@ -925,7 +951,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
         const topics = this.layerService.getAllTopicIds();
         const layers = this.layerService.getLayers();
         console.error(`✅ User configuration loaded: ${topics.length} topics from ${layers.length} layers, ${specialists.length} specialists`);
-        layers.forEach(layer => {
+        layers.forEach((layer) => {
             const topicCount = layer.getTopicIds().length;
             console.error(`   📚 ${layer.name}: ${topicCount} topics (priority ${layer.priority})`);
         });
@@ -936,14 +962,14 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
     async setWorkspaceInfo(path, availableMcps = []) {
         try {
             // Normalize and validate path
-            const { resolve } = await import('path');
-            const { existsSync } = await import('fs');
+            const { resolve } = await import("path");
+            const { existsSync } = await import("fs");
             const resolvedPath = resolve(path);
             if (!existsSync(resolvedPath)) {
                 return {
                     success: false,
                     message: `Path does not exist: ${resolvedPath}`,
-                    reloaded: false
+                    reloaded: false,
                 };
             }
             // Check if this is the same workspace
@@ -956,13 +982,13 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
                 }
                 return {
                     success: true,
-                    message: `Workspace root already set to: ${resolvedPath}${availableMcps.length > 0 ? ` | Updated MCP ecosystem: ${availableMcps.length} servers` : ''}`,
-                    reloaded: false
+                    message: `Workspace root already set to: ${resolvedPath}${availableMcps.length > 0 ? ` | Updated MCP ecosystem: ${availableMcps.length} servers` : ""}`,
+                    reloaded: false,
                 };
             }
             console.error(`📁 Setting workspace root to: ${resolvedPath}`);
             if (availableMcps.length > 0) {
-                console.error(`🔧 MCP Ecosystem: ${availableMcps.join(', ')}`);
+                console.error(`🔧 MCP Ecosystem: ${availableMcps.join(", ")}`);
             }
             // Change working directory
             process.chdir(resolvedPath);
@@ -975,8 +1001,8 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             // Load configuration with workspace context (merges user + project configs)
             const configResult = await this.configLoader.loadConfiguration(resolvedPath);
             if (configResult.validation_errors.length > 0) {
-                console.error('⚠️  Configuration validation errors:');
-                configResult.validation_errors.forEach(error => {
+                console.error("⚠️  Configuration validation errors:");
+                configResult.validation_errors.forEach((error) => {
                     console.error(`   - ${error.field}: ${error.message}`);
                 });
             }
@@ -985,19 +1011,21 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
             this.servicesInitialized = true;
             const specialists = await this.layerService.getAllSpecialists();
             const topics = this.layerService.getAllTopicIds();
-            const mcpInfo = availableMcps.length > 0 ? ` | MCP Ecosystem: ${availableMcps.length} servers` : '';
+            const mcpInfo = availableMcps.length > 0
+                ? ` | MCP Ecosystem: ${availableMcps.length} servers`
+                : "";
             return {
                 success: true,
                 message: `Workspace configured successfully. Loaded ${topics.length} topics from ${this.layerService.getLayers().length} layers, ${specialists.length} specialists available.${mcpInfo}`,
-                reloaded: true
+                reloaded: true,
             };
         }
         catch (error) {
-            console.error('❌ Error setting workspace info:', error);
+            console.error("❌ Error setting workspace info:", error);
             return {
                 success: false,
                 message: `Failed to set workspace info: ${error instanceof Error ? error.message : String(error)}`,
-                reloaded: false
+                reloaded: false,
             };
         }
     }
@@ -1007,7 +1035,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
     getWorkspaceInfo() {
         return {
             workspace_root: this.workspaceRoot,
-            available_mcps: this.availableMcps
+            available_mcps: this.availableMcps,
         };
     }
     /**
@@ -1030,7 +1058,7 @@ ${enhancedResult.routingOptions.map(option => `- ${option.replace('🎯 Start se
 async function main() {
     try {
         // Ultra-early platform diagnostics (before any server initialization)
-        console.error('=== Pre-Initialization Platform Check ===');
+        console.error("=== Pre-Initialization Platform Check ===");
         console.error(`Node.js: ${process.version}`);
         console.error(`Platform: ${process.platform} (${process.arch})`);
         console.error(`PWD: ${process.cwd()}`);
@@ -1039,7 +1067,7 @@ async function main() {
         const workspaceArg = process.argv[2];
         if (workspaceArg) {
             console.error(`Workspace argument provided: "${workspaceArg}"`);
-            const { resolve } = await import('path');
+            const { resolve } = await import("path");
             const resolvedPath = resolve(workspaceArg);
             console.error(`Resolved to: ${resolvedPath}`);
             // Override process.cwd() for config/layer discovery
@@ -1050,48 +1078,48 @@ async function main() {
         await server.run();
     }
     catch (error) {
-        console.error('💥 Fatal error in main():', error);
-        console.error('Error details:', {
-            name: error instanceof Error ? error.name : 'Unknown',
+        console.error("💥 Fatal error in main():", error);
+        console.error("Error details:", {
+            name: error instanceof Error ? error.name : "Unknown",
             message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : 'No stack trace'
+            stack: error instanceof Error ? error.stack : "No stack trace",
         });
         process.exit(1);
     }
 }
 // Handle process termination
-process.on('SIGINT', async () => {
-    console.error('BC Code Intelligence MCP Server shutting down (SIGINT)...');
+process.on("SIGINT", async () => {
+    console.error("BC Code Intelligence MCP Server shutting down (SIGINT)...");
     process.exit(0);
 });
-process.on('SIGTERM', async () => {
-    console.error('BC Code Intelligence MCP Server shutting down (SIGTERM)...');
+process.on("SIGTERM", async () => {
+    console.error("BC Code Intelligence MCP Server shutting down (SIGTERM)...");
     process.exit(0);
 });
 // Catch unhandled promise rejections (common cause of silent crashes)
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('💥 Unhandled Promise Rejection:');
-    console.error('Reason:', reason);
-    console.error('Promise:', promise);
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("💥 Unhandled Promise Rejection:");
+    console.error("Reason:", reason);
+    console.error("Promise:", promise);
     if (reason instanceof Error) {
-        console.error('Stack:', reason.stack);
+        console.error("Stack:", reason.stack);
     }
     process.exit(1);
 });
 // Catch uncaught exceptions
-process.on('uncaughtException', (error) => {
-    console.error('💥 Uncaught Exception:');
-    console.error('Error:', error);
-    console.error('Stack:', error.stack);
+process.on("uncaughtException", (error) => {
+    console.error("💥 Uncaught Exception:");
+    console.error("Error:", error);
+    console.error("Stack:", error.stack);
     process.exit(1);
 });
 // Run server if this is the main module
 // Check both direct execution (index.js) and binary execution (bc-code-intelligence-mcp, bc-code-intel-server)
-if (process.argv[1]?.endsWith('index.js') ||
-    process.argv[1]?.endsWith('bc-code-intelligence-mcp') ||
-    process.argv[1]?.endsWith('bc-code-intel-server')) {
+if (process.argv[1]?.endsWith("index.js") ||
+    process.argv[1]?.endsWith("bc-code-intelligence-mcp") ||
+    process.argv[1]?.endsWith("bc-code-intel-server")) {
     main().catch((error) => {
-        console.error('Fatal error in BC Code Intelligence MCP Server:', error);
+        console.error("Fatal error in BC Code Intelligence MCP Server:", error);
         process.exit(1);
     });
 }