mcp-adr-analysis-server 2.1.19 → 2.1.22

package/dist/src/index.js

@@ -17,12 +17,16 @@ import { CONVERSATION_CONTEXT_SCHEMA } from './types/conversation-context.js';
 import { maskMcpResponse, createMaskingConfig, } from './utils/output-masking.js';
 import { loadConfig, validateProjectPath, createLogger, printConfigSummary, } from './utils/config.js';
 import { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
+import { getEnhancedModeDefault, getKnowledgeEnhancementDefault, } from './utils/test-aware-defaults.js';
 import { StateReinforcementManager } from './utils/state-reinforcement-manager.js';
 import { ConversationMemoryManager } from './utils/conversation-memory-manager.js';
 import { MemoryEntityManager } from './utils/memory-entity-manager.js';
 import { RootManager } from './utils/root-manager.js';
 import { ServerContextGenerator } from './utils/server-context-generator.js';
 import { createNoOpContext } from './types/tool-context.js';
+import { executeSearchTools, getSearchToolsDefinition, } from './tools/tool-dispatcher.js';
+import { shouldUseCEMCPDirective, getCEMCPDirective, formatDirectiveResponse, } from './tools/ce-mcp-tools.js';
+import { loadAIConfig, isCEMCPEnabled } from './config/ai-config.js';
 /**
  * Get version from package.json
  */
@@ -166,6 +170,8 @@ export class McpAdrAnalysisServer {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {
                 tools: [
+                    // Meta-tool for dynamic tool discovery (CE-MCP Phase 3)
+                    getSearchToolsDefinition(),
                     {
                         name: 'analyze_project_ecosystem',
                         description: 'Comprehensive recursive project ecosystem analysis with advanced prompting techniques (Knowledge Generation + Reflexion)',
@@ -1388,6 +1394,54 @@ export class McpAdrAnalysisServer {
                             required: ['question'],
                         },
                     },
+                    {
+                        name: 'search_codebase',
+                        description: 'Atomic tool for searching codebase files based on query patterns. Returns raw file matches with relevance scores. Extracted from ResearchOrchestrator per ADR-018.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: {
+                                    type: 'string',
+                                    description: 'Search query (e.g., "Docker configuration", "authentication")',
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project root',
+                                    default: '.',
+                                },
+                                scope: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Optional file scope patterns (e.g., ["src/**", "config/**"])',
+                                },
+                                includeContent: {
+                                    type: 'boolean',
+                                    description: 'Include file content in results',
+                                    default: false,
+                                },
+                                maxFiles: {
+                                    type: 'number',
+                                    description: 'Maximum files to return',
+                                    default: 20,
+                                    minimum: 1,
+                                    maximum: 100,
+                                },
+                                enableTreeSitter: {
+                                    type: 'boolean',
+                                    description: 'Use tree-sitter for enhanced analysis',
+                                    default: true,
+                                },
+                                relevanceThreshold: {
+                                    type: 'number',
+                                    description: 'Minimum relevance threshold (0-1)',
+                                    default: 0.2,
+                                    minimum: 0,
+                                    maximum: 1,
+                                },
+                            },
+                            required: ['query'],
+                        },
+                    },
                     {
                         name: 'llm_web_search',
                         description: 'LLM-managed web search using Firecrawl for cross-platform support',
@@ -2944,6 +2998,48 @@ export class McpAdrAnalysisServer {
                             properties: {},
                         },
                     },
+                    {
+                        name: 'update_knowledge',
+                        description: 'ADR-018: Simple CRUD operations for knowledge graph. Add/remove entities (intents, ADRs, tools, code) and relationships. Use knowledge://graph resource to read current state (zero token cost).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['add_entity', 'remove_entity', 'add_relationship', 'remove_relationship'],
+                                    description: 'Type of operation to perform on the knowledge graph',
+                                },
+                                entity: {
+                                    type: 'string',
+                                    description: 'Entity ID (for add_entity/remove_entity operations)',
+                                },
+                                entityType: {
+                                    type: 'string',
+                                    enum: ['intent', 'adr', 'code', 'tool', 'decision'],
+                                    description: 'Type of entity (required for add_entity operation)',
+                                },
+                                relationship: {
+                                    type: 'string',
+                                    enum: ['implements', 'uses', 'created', 'depends-on', 'supersedes'],
+                                    description: 'Relationship type (for add_relationship/remove_relationship)',
+                                },
+                                source: {
+                                    type: 'string',
+                                    description: 'Source node ID (for relationship operations)',
+                                },
+                                target: {
+                                    type: 'string',
+                                    description: 'Target node ID (for relationship operations)',
+                                },
+                                metadata: {
+                                    type: 'object',
+                                    description: 'Additional metadata for the entity or relationship',
+                                    additionalProperties: true,
+                                },
+                            },
+                            required: ['operation'],
+                        },
+                    },
                     {
                         name: 'get_server_context',
                         description: "Generate a comprehensive context file showing the server's current state, memory, and capabilities. Creates .mcp-server-context.md that can be @ referenced in conversations for instant LLM awareness",
@@ -2972,6 +3068,86 @@ export class McpAdrAnalysisServer {
                             },
                         },
                     },
+                    {
+                        name: 'get_current_datetime',
+                        description: 'Get the current date and time in various formats. Useful for timestamping ADRs, research documents, and other architectural artifacts. Returns ISO 8601, human-readable, and ADR-specific date formats.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                timezone: {
+                                    type: 'string',
+                                    description: 'Timezone for the datetime (e.g., "UTC", "America/New_York", "Europe/London"). Defaults to UTC.',
+                                    default: 'UTC',
+                                },
+                                format: {
+                                    type: 'string',
+                                    enum: ['iso', 'human', 'adr', 'all'],
+                                    description: 'Output format: "iso" for ISO 8601, "human" for human-readable, "adr" for ADR date format (YYYY-MM-DD), "all" for all formats',
+                                    default: 'all',
+                                },
+                                includeTimestamp: {
+                                    type: 'boolean',
+                                    description: 'Include Unix timestamp in milliseconds',
+                                    default: true,
+                                },
+                            },
+                        },
+                    },
+                    // Session management tool for dynamic project switching
+                    {
+                        name: 'set_project_path',
+                        description: 'Dynamically set the active project path for the current session. Call this at the start of a session to switch between projects without restarting the server or modifying environment variables. All subsequent tool calls will use this path as the default.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    description: 'Absolute path to the project directory. Must be an existing directory.',
+                                },
+                                validatePath: {
+                                    type: 'boolean',
+                                    description: 'Whether to validate that the path exists and is a directory (default: true)',
+                                    default: true,
+                                },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    // CE-MCP Phase 4: Lazy Prompt Loading Tool
+                    {
+                        name: 'load_prompt',
+                        description: 'Load a specific prompt or prompt section on-demand. Part of CE-MCP lazy loading system that reduces token usage by ~96% by loading prompts only when needed. Use this to retrieve prompt templates for ADR generation, analysis, deployment, and other operations.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                promptName: {
+                                    type: 'string',
+                                    description: 'Name of the prompt to load (e.g., "adr-suggestion", "deployment-analysis", "environment-analysis", "research-question", "rule-generation", "analysis", "security")',
+                                    enum: [
+                                        'adr-suggestion',
+                                        'deployment-analysis',
+                                        'environment-analysis',
+                                        'research-question',
+                                        'rule-generation',
+                                        'analysis',
+                                        'research-integration',
+                                        'validated-pattern',
+                                        'security',
+                                    ],
+                                },
+                                section: {
+                                    type: 'string',
+                                    description: 'Specific section within the prompt to load. If not provided, loads the entire prompt. Available sections depend on the prompt.',
+                                },
+                                estimateOnly: {
+                                    type: 'boolean',
+                                    description: 'If true, returns only token estimate without loading the full prompt content',
+                                    default: false,
+                                },
+                            },
+                            required: ['promptName'],
+                        },
+                    },
                 ],
             };
         });
@@ -3040,6 +3216,18 @@ export class McpAdrAnalysisServer {
             try {
                 let response;
                 const safeArgs = args || {};
+                // CE-MCP Mode: Check if tool should return directive instead of executing
+                const aiConfig = loadAIConfig();
+                if (isCEMCPEnabled(aiConfig) &&
+                    shouldUseCEMCPDirective(name, { mode: aiConfig.executionMode })) {
+                    const directive = getCEMCPDirective(name, safeArgs);
+                    if (directive) {
+                        this.logger.info(`[CE-MCP] Returning directive for tool: ${name}`);
+                        return formatDirectiveResponse(directive);
+                    }
+                    // Fall through to legacy execution if no directive available
+                    this.logger.info(`[CE-MCP] No directive available for ${name}, using legacy path`);
+                }
                 switch (name) {
                     case 'analyze_project_ecosystem':
                         response = await this.analyzeProjectEcosystem(safeArgs, context);
@@ -3128,6 +3316,9 @@ export class McpAdrAnalysisServer {
                     case 'perform_research':
                         response = await this.performResearch(safeArgs, context);
                         break;
+                    case 'search_codebase':
+                        response = await this.searchCodebase(safeArgs);
+                        break;
                     case 'llm_web_search':
                         response = await this.llmWebSearch(safeArgs);
                         break;
@@ -3211,9 +3402,31 @@ export class McpAdrAnalysisServer {
                     case 'get_memory_stats':
                         response = await this.getMemoryStats();
                         break;
+                    case 'update_knowledge':
+                        response = await this.updateKnowledge(safeArgs);
+                        break;
                     case 'get_server_context':
                         response = await this.getServerContext(safeArgs);
                         break;
+                    case 'get_current_datetime':
+                        response = await this.getCurrentDatetime(safeArgs);
+                        break;
+                    case 'search_tools':
+                        response = {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(executeSearchTools(safeArgs), null, 2),
+                                },
+                            ],
+                        };
+                        break;
+                    case 'set_project_path':
+                        response = await this.setProjectPath(safeArgs);
+                        break;
+                    case 'load_prompt':
+                        response = await this.loadPrompt(safeArgs);
+                        break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
                 }
@@ -3410,6 +3623,13 @@ export class McpAdrAnalysisServer {
                         description: 'Base code repository information for a platform pattern including URL, integration instructions, required files, and script entrypoint',
                         mimeType: 'application/json',
                     },
+                    // NEW Knowledge Graph Resource (ADR-018)
+                    {
+                        uri: 'knowledge://graph',
+                        name: 'Knowledge Graph',
+                        description: 'Read-only knowledge graph structure with nodes (intents, ADRs, tools, code files) and edges (relationships). Zero token cost for querying graph state. Use update_knowledge tool to modify.',
+                        mimeType: 'application/json',
+                    },
                 ],
             };
         });
@@ -3579,6 +3799,10 @@ export class McpAdrAnalysisServer {
                         type: 'text',
                         text: `# AI Execution Status Diagnostic
 
+> **Note**: As of Phase 5, this server uses CE-MCP (Claude-Enriched MCP) mode by default.
+> In CE-MCP mode, tools return orchestration directives that the host LLM executes directly,
+> eliminating the need for external API calls. The configuration below applies to legacy mode only.
+
 ## Current Configuration
 - **AI Execution Enabled**: ${status.isEnabled ? '✅ YES' : '❌ NO'}
 - **Has API Key**: ${status.hasApiKey ? '✅ YES' : '❌ NO'}
@@ -4092,7 +4316,9 @@ This guidance ensures your development work is **architecturally aligned**, **qu
         const ctx = context || createNoOpContext();
         // Use configured project path if not provided in args
         const projectPath = args.projectPath || this.config.projectPath;
-        const { includePatterns, enhancedMode = true, knowledgeEnhancement = true, learningEnabled = true, technologyFocus = [], analysisDepth = 'comprehensive', includeEnvironment = true, recursiveDepth = 'comprehensive', analysisScope = [],
+        const { includePatterns, enhancedMode = getEnhancedModeDefault(), // Environment-aware default
+        knowledgeEnhancement = getKnowledgeEnhancementDefault(), // Environment-aware default
+        learningEnabled = true, technologyFocus = [], analysisDepth = 'comprehensive', includeEnvironment = true, recursiveDepth = 'comprehensive', analysisScope = [],
         // conversationContext - TODO: implement context integration for ecosystem analysis
          } = args;
         this.logger.info(`Generating comprehensive ecosystem analysis for project at: ${projectPath}`);
@@ -4131,7 +4357,10 @@ This guidance ensures your development work is **architecturally aligned**, **qu
                 this.logger.warn('Failed to initialize ADR knowledge base:', error);
                 // Don't fail the entire analysis if ADR initialization fails
             }
-            // Import advanced prompting utilities if enhanced mode is enabled
+            // DEPRECATED: Legacy context assembly for enhanced mode
+            // This section is part of the OpenRouter execution path and will be removed
+            // in a future release. For CE-MCP mode, use createAnalyzeProjectEcosystemDirective()
+            // from src/tools/ce-mcp-tools.ts instead. See ADR-014.
             let generateArchitecturalKnowledge = null;
             let executeWithReflexion = null;
             let retrieveRelevantMemories = null;
@@ -4698,7 +4927,9 @@ This **outcome-focused approach** ensures architectural work delivers **measurab
     }
     async generateAdrsFromPrd(args, context) {
         const ctx = context || createNoOpContext();
-        const { prdPath, enhancedMode = true, promptOptimization = true, knowledgeEnhancement = true, prdType = 'general', } = args;
+        const { prdPath, enhancedMode = getEnhancedModeDefault(), // Environment-aware default
+        promptOptimization = true, knowledgeEnhancement = getKnowledgeEnhancementDefault(), // Environment-aware default
+        prdType = 'general', } = args;
         const outputDirectory = args['outputDirectory'] || this.config.adrDirectory;
         this.logger.info(`Generating enhanced ADRs from PRD: ${prdPath} to ${outputDirectory}`);
         this.logger.info(`Enhancement features - APE: ${promptOptimization}, Knowledge: ${knowledgeEnhancement}, Type: ${prdType}`);
@@ -6182,13 +6413,11 @@ Please provide:
             responseText += `**ADR Directory:** ${adrDirectory}\n`;
             responseText += `**Total ADRs:** ${result.totalAdrs}\n\n`;
             // Add timeline summary
-            if (result.adrs.some((adr) => adr.timeline)) {
-                const withTimeline = result.adrs.filter((adr) => adr.timeline).length;
+            if (result.adrs.some(adr => adr.timeline)) {
+                const withTimeline = result.adrs.filter(adr => adr.timeline).length;
                 responseText += `## Timeline Data\n\n`;
                 responseText += `- **ADRs with Timeline:** ${withTimeline}/${result.totalAdrs}\n`;
-                const ages = result.adrs
-                    .filter((adr) => adr.timeline)
-                    .map((adr) => adr.timeline.age_days);
+                const ages = result.adrs.filter(adr => adr.timeline).map(adr => adr.timeline.age_days);
                 if (ages.length > 0) {
                     const avgAge = Math.floor(ages.reduce((a, b) => a + b, 0) / ages.length);
                     const oldestAge = Math.max(...ages);
@@ -6321,6 +6550,21 @@ Please provide:
             throw new McpAdrError(`Failed to perform research: ${error instanceof Error ? error.message : String(error)}`, 'RESEARCH_EXECUTION_ERROR');
         }
     }
+    /**
+     * Search codebase tool implementation
+     */
+    async searchCodebase(args) {
+        if (!('query' in args) || typeof args['query'] !== 'string') {
+            throw new McpAdrError('Missing required parameter: query', 'INVALID_ARGUMENTS');
+        }
+        try {
+            const { searchCodebaseTool } = await import('./tools/search-codebase-tool.js');
+            return await searchCodebaseTool(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to search codebase: ${error instanceof Error ? error.message : String(error)}`, 'SEARCH_ERROR');
+        }
+    }
     /**
      * LLM web search tool implementation
      */
@@ -6666,6 +6910,33 @@ Please provide:
             await import('./resources/validated-pattern-by-platform-resource.js');
             await import('./resources/pattern-sources-by-platform-resource.js');
             await import('./resources/pattern-base-code-by-platform-resource.js');
+            // Phase 1 & 2 resources (PR #346)
+            await import('./resources/server-context-resource.js');
+            await import('./resources/memory-stats-resource.js');
+            await import('./resources/conversation-snapshot-resource.js');
+            await import('./resources/tool-catalog-resource.js');
+            await import('./resources/adrs-discovered-resource.js');
+            // Knowledge Graph Resource (ADR-018)
+            const { generateKnowledgeGraphResource } = await import('./resources/knowledge-graph-resource.js');
+            // Handle knowledge://graph specially to inject KnowledgeGraphManager
+            if (uri === 'knowledge://graph') {
+                const url = new globalThis.URL(uri);
+                const result = await generateKnowledgeGraphResource({}, url.searchParams, this.kgManager);
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: result.contentType,
+                            text: JSON.stringify(result.data, null, 2),
+                        },
+                    ],
+                    _meta: {
+                        lastModified: result.lastModified,
+                        etag: result.etag,
+                        cacheKey: result.cacheKey,
+                    },
+                };
+            }
             // Try routing first (handles templated resources)
             if (resourceRouter.canRoute(uri)) {
                 const result = await resourceRouter.route(uri);
@@ -7298,6 +7569,19 @@ This tool has been deprecated and replaced with memory-centric health scoring.
             throw new McpAdrError(`Memory stats retrieval failed: ${error instanceof Error ? error.message : String(error)}`, 'MEMORY_STATS_ERROR');
         }
     }
+    /**
+     * Update Knowledge Tool (ADR-018)
+     * Simple CRUD operations for knowledge graph
+     */
+    async updateKnowledge(args) {
+        try {
+            const { updateKnowledge } = await import('./tools/update-knowledge-tool.js');
+            return await updateKnowledge(args, createNoOpContext(), this.kgManager);
+        }
+        catch (error) {
+            throw new McpAdrError(`Knowledge update failed: ${error instanceof Error ? error.message : String(error)}`, 'KNOWLEDGE_UPDATE_ERROR');
+        }
+    }
     /**
      * Get Server Context Tool
      * Generates comprehensive server context file for LLM @ referencing
@@ -7311,6 +7595,278 @@ This tool has been deprecated and replaced with memory-centric health scoring.
             throw new McpAdrError(`Server context generation failed: ${error instanceof Error ? error.message : String(error)}`, 'SERVER_CONTEXT_ERROR');
         }
     }
+    /**
+     * Get Current Datetime Tool
+     * Returns the current date and time in various formats for ADR generation and timestamping
+     */
+    async getCurrentDatetime(args) {
+        const { timezone = 'UTC', format = 'all', includeTimestamp = true } = args;
+        try {
+            const now = new Date();
+            // Format date for different timezones
+            const formatOptions = {
+                timeZone: timezone,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                hour12: false,
+            };
+            // Get date parts for the specified timezone
+            const formatter = new Intl.DateTimeFormat('en-CA', {
+                timeZone: timezone,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+            });
+            const parts = formatter.formatToParts(now);
+            const year = parts.find(p => p.type === 'year')?.value || '';
+            const month = parts.find(p => p.type === 'month')?.value || '';
+            const day = parts.find(p => p.type === 'day')?.value || '';
+            // ADR date format: YYYY-MM-DD
+            const adrDate = `${year}-${month}-${day}`;
+            // ISO 8601 format
+            const isoDate = now.toISOString();
+            // Human-readable format
+            const humanFormatter = new Intl.DateTimeFormat('en-US', {
+                ...formatOptions,
+                weekday: 'long',
+                month: 'long',
+            });
+            const humanDate = humanFormatter.format(now);
+            // Build response based on requested format
+            let responseData = {};
+            switch (format) {
+                case 'iso':
+                    responseData = { iso: isoDate };
+                    break;
+                case 'human':
+                    responseData = { human: humanDate };
+                    break;
+                case 'adr':
+                    responseData = { adr: adrDate };
+                    break;
+                case 'all':
+                default:
+                    responseData = {
+                        iso: isoDate,
+                        human: humanDate,
+                        adr: adrDate,
+                        timezone: timezone,
+                    };
+            }
+            if (includeTimestamp) {
+                responseData['timestamp'] = now.getTime();
+            }
+            const responseText = `# Current Date and Time
+
+## Formats
+${format === 'all' || format === 'iso' ? `- **ISO 8601**: ${isoDate}` : ''}
+${format === 'all' || format === 'human' ? `- **Human Readable**: ${humanDate}` : ''}
+${format === 'all' || format === 'adr' ? `- **ADR Date (YYYY-MM-DD)**: ${adrDate}` : ''}
+${format === 'all' ? `- **Timezone**: ${timezone}` : ''}
+${includeTimestamp ? `- **Unix Timestamp (ms)**: ${now.getTime()}` : ''}
+
+## Usage for ADR Generation
+
+When generating ADRs, use the ADR date format (\`${adrDate}\`) in the Date field:
+
+\`\`\`markdown
+# ADR-XXXX: [Title]
+
+## Date
+${adrDate}
+
+## Status
+Proposed
+\`\`\`
+
+## Raw Data
+
+\`\`\`json
+${JSON.stringify(responseData, null, 2)}
+\`\`\`
+`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to get current datetime: ${error instanceof Error ? error.message : String(error)}`, 'DATETIME_ERROR');
+        }
+    }
+    /**
+     * Set Project Path Tool - Dynamic Session Configuration
+     *
+     * @description Dynamically sets the active project path for the current session.
+     * This allows switching between projects without restarting the server or modifying
+     * environment variables. Updates both the config and the RootManager.
+     *
+     * @param args - Set project path arguments
+     * @param args.path - Absolute path to the project directory
+     * @param args.validatePath - Whether to validate the path exists (default: true)
+     * @returns Promise<CallToolResult> - Confirmation of the path change
+     */
+    async setProjectPath(args) {
+        const { path: newPath, validatePath = true } = args;
+        const { resolve } = await import('path');
+        try {
+            // Resolve to absolute path
+            const absolutePath = resolve(newPath);
+            const previousPath = this.config.projectPath;
+            // Validate the path if requested
+            if (validatePath) {
+                await validateProjectPath(absolutePath);
+            }
+            // Update the server configuration
+            this.config.projectPath = absolutePath;
+            // Re-initialize the RootManager with the new path
+            this.rootManager = new RootManager(absolutePath, this.config.adrDirectory);
+            this.logger.info(`Project path changed: ${previousPath} -> ${absolutePath}`);
+            const responseText = `# Project Path Updated
+
+## Configuration
+- **Previous Path**: \`${previousPath}\`
+- **New Path**: \`${absolutePath}\`
+- **ADR Directory**: \`${this.config.adrDirectory}\`
+- **Full ADR Path**: \`${resolve(absolutePath, this.config.adrDirectory)}\`
+
+## Status
+✅ Project path successfully updated for this session.
+
+## Note
+All subsequent tool calls will use this path as the default project path.
+You can still override it per-tool by passing \`projectPath\` as an argument.
+
+To make this permanent, set the \`PROJECT_PATH\` environment variable.
+`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to set project path: ${error instanceof Error ? error.message : String(error)}`, 'SET_PROJECT_PATH_ERROR');
+        }
+    }
+    /**
+     * Load Prompt Tool - CE-MCP Phase 4 Lazy Loading
+     *
+     * @description Loads prompts on-demand instead of eagerly loading all prompts at startup.
+     * This reduces token usage by ~96% (from 28K tokens to ~1K on-demand).
+     *
+     * @param args - Load prompt arguments
+     * @param args.promptName - Name of the prompt to load
+     * @param args.section - Optional section within the prompt
+     * @param args.estimateOnly - If true, returns only token estimate
+     * @returns Promise<CallToolResult> - Loaded prompt content or estimate
+     */
+    async loadPrompt(args) {
+        const { promptName, section, estimateOnly = false } = args;
+        // Import the prompt catalog dynamically to enable lazy loading
+        const { getPromptLoader, getPromptMetadata, calculateTokenSavings } = await import('./prompts/prompt-catalog.js');
+        const metadata = getPromptMetadata(promptName);
+        if (!metadata) {
+            const availablePrompts = [
+                'adr-suggestion',
+                'deployment-analysis',
+                'environment-analysis',
+                'research-question',
+                'rule-generation',
+                'analysis',
+                'research-integration',
+                'validated-pattern',
+                'security',
+            ];
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Unknown prompt: ${promptName}`,
+                            availablePrompts,
+                            hint: 'Use one of the available prompt names listed above',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // If estimate only, return token information without loading
+        if (estimateOnly) {
+            const loader = getPromptLoader();
+            const estimatedTokens = loader.getEstimatedTokens(promptName, section);
+            const savings = calculateTokenSavings([promptName]);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            promptName,
+                            section: section || 'full',
+                            estimatedTokens,
+                            metadata: {
+                                file: metadata.file,
+                                category: metadata.category,
+                                totalTokens: metadata.tokens,
+                                availableSections: metadata.sections,
+                                loadOnDemand: metadata.loadOnDemand,
+                            },
+                            tokenSavings: {
+                                loaded: savings.loaded,
+                                total: savings.total,
+                                saved: savings.saved,
+                                percentage: `${savings.percentage}%`,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Load the prompt content
+        try {
+            const loader = getPromptLoader();
+            const content = await loader.loadPrompt(promptName, section);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `# Loaded Prompt: ${promptName}${section ? ` (section: ${section})` : ''}
+
+## Metadata
+- **Category**: ${metadata.category}
+- **Estimated Tokens**: ${metadata.tokens}
+- **Available Sections**: ${metadata.sections.join(', ')}
+
+## Content
+
+${content}
+
+---
+
+*Loaded on-demand via CE-MCP lazy loading system. Token savings: ~96% compared to eager loading all prompts.*
+`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpAdrError(`Failed to load prompt '${promptName}'${section ? ` section '${section}'` : ''}: ${error instanceof Error ? error.message : String(error)}`, 'PROMPT_LOAD_ERROR');
+        }
+    }
 }
 /**
  * Main execution function for the MCP ADR Analysis Server