mcp-adr-analysis-server 2.0.24 → 2.1.9

package/dist/src/index.js

@@ -14,7 +14,7 @@ import { join } from 'path';
 import { getCurrentDirCompat } from './utils/directory-compat.js';
 import { McpAdrError } from './types/index.js';
 import { CONVERSATION_CONTEXT_SCHEMA } from './types/conversation-context.js';
-import { maskMcpResponse, createMaskingConfig } from './utils/output-masking.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';
 /**
@@ -99,7 +99,8 @@ export class McpAdrAnalysisServer {
             this.logger.info(`Project path validated: ${this.config.projectPath}`);
         }
         catch (error) {
-            this.logger.error(`Configuration validation failed: ${error.message}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Configuration validation failed: ${errorMessage}`);
             throw error;
         }
     }
@@ -686,6 +687,52 @@ export class McpAdrAnalysisServer {
                             required: ['decisionData'],
                         },
                     },
+                    {
+                        name: 'generate_adr_bootstrap',
+                        description: 'Generate bootstrap.sh and validate_bootstrap.sh scripts to ensure deployed code follows ADR requirements',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to the project directory',
+                                    default: '.',
+                                },
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'Directory where ADRs are stored',
+                                    default: 'docs/adrs',
+                                },
+                                outputPath: {
+                                    type: 'string',
+                                    description: 'Directory where to generate scripts',
+                                    default: '.',
+                                },
+                                scriptType: {
+                                    type: 'string',
+                                    enum: ['bootstrap', 'validate', 'both'],
+                                    description: 'Which scripts to generate',
+                                    default: 'both',
+                                },
+                                includeTests: {
+                                    type: 'boolean',
+                                    description: 'Include test execution in bootstrap',
+                                    default: true,
+                                },
+                                includeDeployment: {
+                                    type: 'boolean',
+                                    description: 'Include deployment steps in bootstrap',
+                                    default: true,
+                                },
+                                customValidations: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Custom validation commands to include',
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
+                    },
                     {
                         name: 'discover_existing_adrs',
                         description: 'Discover and catalog existing ADRs in the project',
@@ -705,6 +752,46 @@ export class McpAdrAnalysisServer {
                             },
                         },
                     },
+                    {
+                        name: 'review_existing_adrs',
+                        description: 'Review existing ADRs against actual code implementation with cloud/DevOps expertise',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'Directory containing ADR files',
+                                    default: 'docs/adrs',
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to the project directory',
+                                    default: '.',
+                                },
+                                specificAdr: {
+                                    type: 'string',
+                                    description: 'Specific ADR filename or title to review (optional)',
+                                },
+                                analysisDepth: {
+                                    type: 'string',
+                                    enum: ['basic', 'detailed', 'comprehensive'],
+                                    description: 'Depth of analysis to perform',
+                                    default: 'detailed',
+                                },
+                                includeTreeSitter: {
+                                    type: 'boolean',
+                                    description: 'Use tree-sitter for enhanced code analysis',
+                                    default: true,
+                                },
+                                generateUpdatePlan: {
+                                    type: 'boolean',
+                                    description: 'Generate action plan for updating non-compliant ADRs',
+                                    default: true,
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
+                    },
                     {
                         name: 'incorporate_research',
                         description: 'Incorporate research findings into architectural decisions',
@@ -2573,6 +2660,46 @@ export class McpAdrAnalysisServer {
                             },
                         },
                     },
+                    {
+                        name: 'tool_chain_orchestrator',
+                        description: 'AI-powered dynamic tool sequencing - intelligently analyze user requests and generate structured tool execution plans',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                userRequest: {
+                                    type: 'string',
+                                    description: 'User request to analyze and create tool execution plan for',
+                                },
+                                availableTools: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'List of available MCP tools to orchestrate',
+                                },
+                                executionMode: {
+                                    type: 'string',
+                                    enum: ['plan_only', 'plan_and_execute', 'validate_plan'],
+                                    description: 'Orchestration mode',
+                                    default: 'plan_only',
+                                },
+                                maxSteps: {
+                                    type: 'number',
+                                    description: 'Maximum number of steps in the execution plan',
+                                    default: 10,
+                                },
+                                allowParallel: {
+                                    type: 'boolean',
+                                    description: 'Allow parallel execution of independent steps',
+                                    default: true,
+                                },
+                                contextHints: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Additional context hints for better plan generation',
+                                },
+                            },
+                            required: ['userRequest'],
+                        },
+                    },
                 ],
             };
         });
@@ -2581,123 +2708,133 @@ export class McpAdrAnalysisServer {
             const { name, arguments: args } = request.params;
             try {
                 let response;
+                const safeArgs = args || {};
                 switch (name) {
                     case 'analyze_project_ecosystem':
-                        response = await this.analyzeProjectEcosystem(args);
+                        response = await this.analyzeProjectEcosystem(safeArgs);
                         break;
                     case 'get_architectural_context':
-                        response = await this.getArchitecturalContext(args);
+                        response = await this.getArchitecturalContext(safeArgs);
                         break;
                     case 'generate_adrs_from_prd':
-                        response = await this.generateAdrsFromPrd(args);
+                        response = await this.generateAdrsFromPrd(safeArgs);
                         break;
                     case 'generate_adr_todo':
-                        response = await this.generateAdrTodo(args);
+                        response = await this.generateAdrTodo(safeArgs);
                         break;
                     case 'compare_adr_progress':
-                        response = await this.compareAdrProgress(args);
+                        response = await this.compareAdrProgress(safeArgs);
                         break;
                     case 'analyze_content_security':
-                        response = await this.analyzeContentSecurity(args);
+                        response = await this.analyzeContentSecurity(safeArgs);
                         break;
                     case 'generate_content_masking':
-                        response = await this.generateContentMasking(args);
+                        response = await this.generateContentMasking(safeArgs);
                         break;
                     case 'configure_custom_patterns':
-                        response = await this.configureCustomPatterns(args);
+                        response = await this.configureCustomPatterns(safeArgs);
                         break;
                     case 'apply_basic_content_masking':
-                        response = await this.applyBasicContentMasking(args);
+                        response = await this.applyBasicContentMasking(safeArgs);
                         break;
                     case 'validate_content_masking':
-                        response = await this.validateContentMasking(args);
+                        response = await this.validateContentMasking(safeArgs);
                         break;
                     case 'manage_cache':
-                        response = await this.manageCache(args);
+                        response = await this.manageCache(safeArgs);
                         break;
                     case 'configure_output_masking':
-                        response = await this.configureOutputMasking(args);
+                        response = await this.configureOutputMasking(safeArgs);
                         break;
                     case 'suggest_adrs':
-                        response = await this.suggestAdrs(args);
+                        response = await this.suggestAdrs(safeArgs);
                         break;
                     case 'generate_adr_from_decision':
-                        response = await this.generateAdrFromDecision(args);
+                        response = await this.generateAdrFromDecision(safeArgs);
+                        break;
+                    case 'generate_adr_bootstrap':
+                        response = await this.generateAdrBootstrap(safeArgs);
                         break;
                     case 'discover_existing_adrs':
-                        response = await this.discoverExistingAdrs(args);
+                        response = await this.discoverExistingAdrs(safeArgs);
+                        break;
+                    case 'review_existing_adrs':
+                        response = await this.reviewExistingAdrs(safeArgs);
                         break;
                     case 'incorporate_research':
-                        response = await this.incorporateResearch(args);
+                        response = await this.incorporateResearch(safeArgs);
                         break;
                     case 'create_research_template':
-                        response = await this.createResearchTemplate(args);
+                        response = await this.createResearchTemplate(safeArgs);
                         break;
                     case 'request_action_confirmation':
-                        response = await this.requestActionConfirmation(args);
+                        response = await this.requestActionConfirmation(safeArgs);
                         break;
                     case 'generate_rules':
-                        response = await this.generateRules(args);
+                        response = await this.generateRules(safeArgs);
                         break;
                     case 'validate_rules':
-                        response = await this.validateRules(args);
+                        response = await this.validateRules(safeArgs);
                         break;
                     case 'create_rule_set':
-                        response = await this.createRuleSet(args);
+                        response = await this.createRuleSet(safeArgs);
                         break;
                     case 'analyze_environment':
-                        response = await this.analyzeEnvironment(args);
+                        response = await this.analyzeEnvironment(safeArgs);
                         break;
                     case 'generate_research_questions':
-                        response = await this.generateResearchQuestions(args);
+                        response = await this.generateResearchQuestions(safeArgs);
                         break;
                     case 'analyze_deployment_progress':
-                        response = await this.analyzeDeploymentProgress(args);
+                        response = await this.analyzeDeploymentProgress(safeArgs);
                         break;
                     case 'check_ai_execution_status':
-                        response = await this.checkAIExecutionStatus(args);
+                        response = await this.checkAIExecutionStatus(safeArgs);
                         break;
                     case 'get_workflow_guidance':
-                        response = await this.getWorkflowGuidance(args);
+                        response = await this.getWorkflowGuidance(safeArgs);
                         break;
                     case 'get_development_guidance':
-                        response = await this.getDevelopmentGuidance(args);
+                        response = await this.getDevelopmentGuidance(safeArgs);
                         break;
                     case 'read_file':
-                        response = await this.readFile(args);
+                        response = await this.readFile(safeArgs);
                         break;
                     case 'write_file':
-                        response = await this.writeFile(args);
+                        response = await this.writeFile(safeArgs);
                         break;
                     case 'list_directory':
-                        response = await this.listDirectory(args);
+                        response = await this.listDirectory(safeArgs);
                         break;
                     case 'manage_todo_json':
-                        response = await this.manageTodoJson(args);
+                        response = await this.manageTodoJson(safeArgs);
                         break;
                     case 'generate_deployment_guidance':
-                        response = await this.generateDeploymentGuidance(args);
+                        response = await this.generateDeploymentGuidance(safeArgs);
                         break;
                     case 'smart_git_push':
-                        response = await this.smartGitPush(args);
+                        response = await this.smartGitPush(safeArgs);
                         break;
                     case 'deployment_readiness':
-                        response = await this.deploymentReadiness(args);
+                        response = await this.deploymentReadiness(safeArgs);
                         break;
                     case 'troubleshoot_guided_workflow':
-                        response = await this.troubleshootGuidedWorkflow(args);
+                        response = await this.troubleshootGuidedWorkflow(safeArgs);
                         break;
                     case 'smart_score':
-                        response = await this.smartScore(args);
+                        response = await this.smartScore(safeArgs);
                         break;
                     case 'mcp_planning':
-                        response = await this.mcpPlanning(args);
+                        response = await this.mcpPlanning(safeArgs);
                         break;
                     case 'memory_loading':
-                        response = await this.memoryLoading(args);
+                        response = await this.memoryLoading(safeArgs);
                         break;
                     case 'interactive_adr_planning':
-                        response = await this.interactiveAdrPlanning(args);
+                        response = await this.interactiveAdrPlanning(safeArgs);
+                        break;
+                    case 'tool_chain_orchestrator':
+                        response = await this.toolChainOrchestrator(safeArgs);
                         break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
@@ -3338,7 +3475,7 @@ This guidance ensures your development work is **architecturally aligned**, **qu
         this.logger.info(`Analysis scope: ${analysisScope.length > 0 ? analysisScope.join(', ') : 'Full ecosystem analysis'}`);
         try {
             // Import utilities dynamically to avoid circular dependencies
-            const { analyzeProjectStructure } = await import('./utils/file-system.js');
+            const { analyzeProjectStructureCompat: analyzeProjectStructure } = await import('./utils/file-system.js');
             // Import advanced prompting utilities if enhanced mode is enabled
             let generateArchitecturalKnowledge = null;
             let executeWithReflexion = null;
@@ -3654,7 +3791,7 @@ The enhanced analysis should provide:
     async getArchitecturalContext(args) {
         const { filePath, includeCompliance = true } = args;
         try {
-            const { analyzeProjectStructure, fileExists, ensureDirectory } = await import('./utils/file-system.js');
+            const { analyzeProjectStructureCompat: analyzeProjectStructure, fileExistsCompat: fileExists, ensureDirectoryCompat: ensureDirectory, } = await import('./utils/file-system.js');
             const path = await import('path');
             // Determine project path
             const projectPath = filePath
@@ -3894,11 +4031,11 @@ This **outcome-focused approach** ensures architectural work delivers **measurab
     }
     async generateAdrsFromPrd(args) {
         const { prdPath, enhancedMode = true, promptOptimization = true, knowledgeEnhancement = true, prdType = 'general', } = args;
-        const outputDirectory = args.outputDirectory || this.config.adrDirectory;
+        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}`);
         try {
-            const { readFileContent, fileExists } = await import('./utils/file-system.js');
+            const { readFileContentCompat: readFileContent, fileExistsCompat: fileExists } = await import('./utils/file-system.js');
             // Import advanced prompting utilities if enhanced mode is enabled
             let generateArchitecturalKnowledge = null;
             let optimizePromptWithAPE = null;
@@ -4167,11 +4304,11 @@ The enhanced process maintains full traceability from PRD requirements to genera
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
         // Use absolute ADR path relative to project
-        const absoluteAdrPath = args.adrDirectory
-            ? path.resolve(this.config.projectPath, args.adrDirectory)
+        const absoluteAdrPath = args['adrDirectory']
+            ? path.resolve(this.config.projectPath, args['adrDirectory'])
             : getAdrDirectoryPath(this.config);
         // Keep relative path for display purposes
-        const adrDirectory = args.adrDirectory || this.config.adrDirectory;
+        const adrDirectory = args['adrDirectory'] || this.config.adrDirectory;
         this.logger.info(`Generating JSON-first TODO for ADRs in: ${absoluteAdrPath} (phase: ${phase})`);
         try {
             // Always use JSON-first TODO system
@@ -4183,7 +4320,7 @@ The enhanced process maintains full traceability from PRD requirements to genera
                 try {
                     this.logger.info('Backup feature deprecated - use mcp-shrimp-task-manager for task management');
                 }
-                catch (error) {
+                catch {
                     // Continue if backup fails - might be first time setup
                     this.logger.debug('No existing JSON data to backup');
                 }
@@ -4329,16 +4466,16 @@ ${importResult.content?.[0]?.text || 'TODO management feature has been deprecate
                 discoveredAdrs: discoveryResult?.adrs || [],
                 adrDirectory: absoluteAdrPath,
                 projectStructure: projectStructure || null,
-                projectPath,
-                validationType,
-                includeFileChecks,
-                includeRuleValidation,
-                deepCodeAnalysis,
-                functionalValidation,
-                strictMode,
+                projectPath: projectPath,
+                validationType: validationType,
+                includeFileChecks: includeFileChecks,
+                includeRuleValidation: includeRuleValidation,
+                deepCodeAnalysis: deepCodeAnalysis,
+                functionalValidation: functionalValidation,
+                strictMode: strictMode,
                 environment: detectedEnvironment,
                 environmentConfig: finalEnvironmentConfig,
-                environmentValidation,
+                environmentValidation: environmentValidation,
             });
             return {
                 content: [
@@ -5168,7 +5305,8 @@ ${this.maskingConfig.enabled ? '✅ Output masking is ACTIVE' : '⚠️ Output m
                     if (typeof enabled === 'boolean') {
                         newConfig.enabled = enabled;
                     }
-                    if (strategy && ['full', 'partial', 'placeholder', 'environment'].includes(strategy)) {
+                    if (strategy &&
+                        ['full', 'partial', 'placeholder', 'environment'].includes(strategy)) {
                         newConfig.strategy = strategy;
                     }
                     if (Array.isArray(customPatterns)) {
@@ -5402,10 +5540,18 @@ Please provide:
         const { generateAdrFromDecision } = await import('./tools/adr-suggestion-tool.js');
         return await generateAdrFromDecision(args);
     }
+    async generateAdrBootstrap(args) {
+        const { default: generateAdrBootstrapScripts } = await import('./tools/adr-bootstrap-validation-tool.js');
+        return await generateAdrBootstrapScripts(args);
+    }
     async discoverExistingAdrs(args) {
         const { discoverExistingAdrs } = await import('./tools/adr-suggestion-tool.js');
         return await discoverExistingAdrs(args);
     }
+    async reviewExistingAdrs(args) {
+        const { reviewExistingAdrs } = await import('./tools/review-existing-adrs-tool.js');
+        return await reviewExistingAdrs(args);
+    }
     /**
      * Research integration tool implementations
      */
@@ -5751,7 +5897,7 @@ Please provide:
      * File system tool implementations
      */
     async readFile(args) {
-        const { path: filePath } = args;
+        const { filePath } = args;
         try {
             const fs = await import('fs/promises');
             const path = await import('path');
@@ -5776,7 +5922,7 @@ Please provide:
         }
     }
     async writeFile(args) {
-        const { path: filePath, content } = args;
+        const { filePath, content } = args;
         try {
             const fs = await import('fs/promises');
             const path = await import('path');
@@ -5954,6 +6100,18 @@ This tool has been deprecated and replaced with memory-centric health scoring.
             throw new McpAdrError(`Interactive ADR planning failed: ${error instanceof Error ? error.message : String(error)}`, 'INTERACTIVE_ADR_PLANNING_ERROR');
         }
     }
+    /**
+     * Tool chain orchestrator implementation
+     */
+    async toolChainOrchestrator(args) {
+        try {
+            const { toolChainOrchestrator } = await import('./tools/tool-chain-orchestrator.js');
+            return await toolChainOrchestrator(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Tool chain orchestration failed: ${error instanceof Error ? error.message : String(error)}`, 'TOOL_CHAIN_ORCHESTRATOR_ERROR');
+        }
+    }
 }
 /**
  * Main execution