mcp-adr-analysis-server 2.0.12 → 2.0.14

package/dist/src/index.js

@@ -10,8 +10,8 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+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';
@@ -23,17 +23,7 @@ import { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
 function getPackageVersion() {
     try {
         // Handle both Jest environment and normal execution
-        let currentDir;
-        if (typeof import.meta !== 'undefined' && import.meta.url) {
-            // Normal ESM execution
-            const __filename = fileURLToPath(import.meta.url);
-            currentDir = dirname(__filename);
-        }
-        else {
-            // Jest or other environments without import.meta support
-            // Use process.cwd() as fallback
-            currentDir = process.cwd();
-        }
+        const currentDir = getCurrentDirCompat();
         // Try multiple possible locations for package.json
         const possiblePaths = [
             join(currentDir, 'package.json'),
@@ -330,6 +320,37 @@ export class McpAdrAnalysisServer {
                                     description: 'Path to project root for environment analysis',
                                     default: '.'
                                 },
+                                environment: {
+                                    type: 'string',
+                                    enum: ['development', 'staging', 'production', 'testing', 'auto-detect'],
+                                    description: 'Target environment context for validation (auto-detect will infer from project structure)',
+                                    default: 'auto-detect'
+                                },
+                                environmentConfig: {
+                                    type: 'object',
+                                    description: 'Environment-specific configuration and requirements',
+                                    properties: {
+                                        requiredFiles: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                            description: 'Files required for this environment'
+                                        },
+                                        requiredServices: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                            description: 'Services that must be implemented for this environment'
+                                        },
+                                        securityLevel: {
+                                            type: 'string',
+                                            enum: ['low', 'medium', 'high', 'critical'],
+                                            description: 'Required security level for this environment'
+                                        },
+                                        performanceRequirements: {
+                                            type: 'object',
+                                            description: 'Performance requirements for this environment'
+                                        }
+                                    }
+                                },
                                 validationType: {
                                     type: 'string',
                                     enum: ['full', 'todo-only', 'adr-only', 'environment-only'],
@@ -360,6 +381,11 @@ export class McpAdrAnalysisServer {
                                     type: 'boolean',
                                     description: 'Enable strict validation mode with reality-check mechanisms against overconfident assessments',
                                     default: true
+                                },
+                                environmentValidation: {
+                                    type: 'boolean',
+                                    description: 'Enable environment-specific validation rules and checks',
+                                    default: true
                                 }
                             }
                         }
@@ -1598,6 +1624,126 @@ export class McpAdrAnalysisServer {
                             }
                         }
                     },
+                    {
+                        name: 'deployment_readiness',
+                        description: 'Comprehensive deployment readiness validation with test failure tracking, deployment history analysis, and hard blocking for unsafe deployments. Integrates with smart_git_push for deployment gating.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['check_readiness', 'validate_production', 'test_validation', 'deployment_history', 'full_audit', 'emergency_override'],
+                                    description: 'Type of deployment readiness check to perform'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory (defaults to current working directory)'
+                                },
+                                targetEnvironment: {
+                                    type: 'string',
+                                    enum: ['staging', 'production', 'integration'],
+                                    default: 'production',
+                                    description: 'Target deployment environment'
+                                },
+                                strictMode: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Enable strict validation (recommended for production)'
+                                },
+                                allowMockCode: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Allow mock code in deployment (NOT RECOMMENDED)'
+                                },
+                                productionCodeThreshold: {
+                                    type: 'number',
+                                    default: 85,
+                                    description: 'Minimum production code quality score (0-100)'
+                                },
+                                mockCodeMaxAllowed: {
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Maximum mock code indicators allowed'
+                                },
+                                maxTestFailures: {
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Maximum test failures allowed (0 = zero tolerance)'
+                                },
+                                requireTestCoverage: {
+                                    type: 'number',
+                                    default: 80,
+                                    description: 'Minimum test coverage percentage required'
+                                },
+                                blockOnFailingTests: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Block deployment if tests are failing'
+                                },
+                                testSuiteRequired: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    default: [],
+                                    description: 'Required test suites that must pass'
+                                },
+                                maxRecentFailures: {
+                                    type: 'number',
+                                    default: 2,
+                                    description: 'Maximum recent deployment failures allowed'
+                                },
+                                deploymentSuccessThreshold: {
+                                    type: 'number',
+                                    default: 80,
+                                    description: 'Minimum deployment success rate required (%)'
+                                },
+                                blockOnRecentFailures: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Block if recent deployments failed'
+                                },
+                                rollbackFrequencyThreshold: {
+                                    type: 'number',
+                                    default: 20,
+                                    description: 'Maximum rollback frequency allowed (%)'
+                                },
+                                requireAdrCompliance: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Require ADR compliance validation'
+                                },
+                                integrateTodoTasks: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Auto-create blocking tasks for issues'
+                                },
+                                updateHealthScoring: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Update project health scores'
+                                },
+                                triggerSmartGitPush: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Trigger smart git push validation'
+                                },
+                                emergencyBypass: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Emergency bypass for critical fixes'
+                                },
+                                businessJustification: {
+                                    type: 'string',
+                                    description: 'Business justification for overrides (required for emergency_override)'
+                                },
+                                approvalRequired: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Require approval for overrides'
+                                }
+                            },
+                            required: ['operation']
+                        }
+                    },
                     {
                         name: 'troubleshoot_guided_workflow',
                         description: 'Structured failure analysis and test plan generation - provide JSON failure info to get specific test commands',
@@ -1924,6 +2070,9 @@ export class McpAdrAnalysisServer {
                     case 'smart_git_push':
                         response = await this.smartGitPush(args);
                         break;
+                    case 'deployment_readiness':
+                        response = await this.deploymentReadiness(args);
+                        break;
                     case 'troubleshoot_guided_workflow':
                         response = await this.troubleshootGuidedWorkflow(args);
                         break;
@@ -3465,7 +3614,7 @@ ${importResult.content[0].text}
         }
     }
     async compareAdrProgress(args) {
-        const { todoPath = 'TODO.md', adrDirectory = this.config.adrDirectory, projectPath = this.config.projectPath, validationType = 'full', includeFileChecks = true, includeRuleValidation = true, deepCodeAnalysis = true, functionalValidation = true, strictMode = true } = args;
+        const { todoPath = 'TODO.md', adrDirectory = this.config.adrDirectory, projectPath = this.config.projectPath, environment = 'auto-detect', environmentConfig = {}, validationType = 'full', includeFileChecks = true, includeRuleValidation = true, deepCodeAnalysis = true, functionalValidation = true, strictMode = true, environmentValidation = true } = args;
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
         // Resolve paths
@@ -3473,7 +3622,21 @@ ${importResult.content[0].text}
         const absoluteAdrPath = adrDirectory ?
             path.resolve(projectPath, adrDirectory) :
             getAdrDirectoryPath(this.config);
-        this.logger.info(`Comparing ADR progress: TODO(${absoluteTodoPath}) vs ADRs(${absoluteAdrPath}) vs Environment(${projectPath})`);
+        this.logger.info(`Comparing ADR progress: TODO(${absoluteTodoPath}) vs ADRs(${absoluteAdrPath}) vs Environment(${projectPath}) [env: ${environment}]`);
+        // Environment validation and auto-detection
+        let detectedEnvironment = environment;
+        let finalEnvironmentConfig = { ...environmentConfig };
+        if (environmentValidation && (validationType === 'full' || validationType === 'environment-only')) {
+            try {
+                const envResult = await this.detectAndValidateEnvironment(projectPath, environment, environmentConfig);
+                detectedEnvironment = envResult.detectedEnvironment;
+                finalEnvironmentConfig = { ...finalEnvironmentConfig, ...envResult.environmentConfig };
+                this.logger.info(`Environment detection result: ${detectedEnvironment}`);
+            }
+            catch (error) {
+                this.logger.warn(`Environment detection failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         try {
             // Step 1: Read TODO.md file directly
             let todoContent = '';
@@ -3519,7 +3682,10 @@ ${importResult.content[0].text}
                 includeRuleValidation,
                 deepCodeAnalysis,
                 functionalValidation,
-                strictMode
+                strictMode,
+                environment: detectedEnvironment,
+                environmentConfig: finalEnvironmentConfig,
+                environmentValidation
             });
             return {
                 content: [
@@ -3534,11 +3700,101 @@ ${importResult.content[0].text}
             throw new McpAdrError(`Failed to compare ADR progress: ${error instanceof Error ? error.message : String(error)}`, 'VALIDATION_ERROR');
         }
     }
+    /**
+     * Detect and validate environment context
+     */
+    async detectAndValidateEnvironment(projectPath, environment, environmentConfig) {
+        const path = await import('path');
+        const fs = await import('fs/promises');
+        let detectedEnvironment = environment;
+        let finalConfig = { ...environmentConfig };
+        if (environment === 'auto-detect') {
+            // Auto-detect environment based on project structure
+            try {
+                // Check for environment indicator files
+                const envFiles = [
+                    '.env.development',
+                    '.env.staging',
+                    '.env.production',
+                    '.env.test',
+                    'package.json',
+                    'docker-compose.yml',
+                    'Dockerfile'
+                ];
+                const existingFiles = [];
+                for (const file of envFiles) {
+                    try {
+                        await fs.access(path.join(projectPath, file));
+                        existingFiles.push(file);
+                    }
+                    catch {
+                        // File doesn't exist, continue
+                    }
+                }
+                // Environment detection logic
+                if (existingFiles.includes('.env.production') || existingFiles.includes('Dockerfile')) {
+                    detectedEnvironment = 'production';
+                }
+                else if (existingFiles.includes('.env.staging')) {
+                    detectedEnvironment = 'staging';
+                }
+                else if (existingFiles.includes('.env.test')) {
+                    detectedEnvironment = 'testing';
+                }
+                else {
+                    detectedEnvironment = 'development';
+                }
+                // Set environment-specific default configurations
+                switch (detectedEnvironment) {
+                    case 'production':
+                        finalConfig = {
+                            securityLevel: 'critical',
+                            requiredFiles: ['package.json', 'README.md'],
+                            requiredServices: ['monitoring', 'logging'],
+                            performanceRequirements: { minUptime: 99.9 },
+                            ...finalConfig
+                        };
+                        break;
+                    case 'staging':
+                        finalConfig = {
+                            securityLevel: 'high',
+                            requiredFiles: ['package.json'],
+                            requiredServices: ['testing', 'monitoring'],
+                            performanceRequirements: { minUptime: 95 },
+                            ...finalConfig
+                        };
+                        break;
+                    case 'testing':
+                        finalConfig = {
+                            securityLevel: 'medium',
+                            requiredFiles: ['package.json'],
+                            requiredServices: ['testing'],
+                            performanceRequirements: {},
+                            ...finalConfig
+                        };
+                        break;
+                    default: // development
+                        finalConfig = {
+                            securityLevel: 'medium',
+                            requiredFiles: ['package.json'],
+                            requiredServices: [],
+                            performanceRequirements: {},
+                            ...finalConfig
+                        };
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Environment auto-detection failed: ${error instanceof Error ? error.message : String(error)}`);
+                detectedEnvironment = 'development'; // fallback
+            }
+        }
+        return { detectedEnvironment, environmentConfig: finalConfig };
+    }
     /**
      * Perform local ADR progress analysis without relying on AI execution
      */
     async performLocalAdrProgressAnalysis(params) {
-        const { todoContent, todoPath, discoveredAdrs, adrDirectory, projectStructure, projectPath, validationType, includeFileChecks, includeRuleValidation, deepCodeAnalysis, functionalValidation, strictMode } = params;
+        const { todoContent, todoPath, discoveredAdrs, adrDirectory, projectStructure, projectPath, validationType, includeFileChecks, includeRuleValidation, deepCodeAnalysis, functionalValidation, strictMode, environment, environmentConfig, environmentValidation } = params;
         const currentDate = new Date().toISOString().split('T')[0];
         // Parse TODO content to extract tasks
         const todoTasks = this.parseTodoTasks(todoContent);
@@ -3546,15 +3802,25 @@ ${importResult.content[0].text}
         const totalAdrs = discoveredAdrs.length;
         const totalTasks = todoTasks.length;
         const completedTasks = todoTasks.filter(task => task.completed).length;
-        // Calculate alignment score (simplified)
-        const adrTaskMapping = this.mapTasksToAdrs(todoTasks, discoveredAdrs);
+        // Calculate alignment score (simplified, now environment-aware)
+        const adrTaskMapping = this.mapTasksToAdrs(todoTasks, discoveredAdrs, environment, environmentConfig);
         const alignedTasks = adrTaskMapping.aligned.length;
-        const alignmentScore = totalTasks > 0 ? Math.round((alignedTasks / totalTasks) * 100) : 0;
+        let alignmentScore = totalTasks > 0 ? Math.round((alignedTasks / totalTasks) * 100) : 0;
+        // Environment-aware scoring adjustments
+        if (environmentValidation && environmentConfig) {
+            const envScore = this.calculateEnvironmentScore(projectStructure, environment, environmentConfig);
+            alignmentScore = Math.round((alignmentScore + envScore) / 2); // Blend scores
+        }
         // File existence checks
         let fileCheckResults = '';
         if (includeFileChecks && projectStructure) {
             fileCheckResults = this.performFileExistenceChecks(todoTasks, projectStructure);
         }
+        // Environment compliance checks
+        let environmentAnalysisResults = '';
+        if (environmentValidation && environmentConfig) {
+            environmentAnalysisResults = this.performEnvironmentComplianceAnalysis(projectStructure, environment, environmentConfig, strictMode);
+        }
         // Mock vs Production analysis
         let mockAnalysisResults = '';
         if (deepCodeAnalysis && projectStructure) {
@@ -3567,6 +3833,7 @@ ${importResult.content[0].text}
 **Project Path**: ${projectPath}
 **TODO Path**: ${todoPath}
 **ADR Directory**: ${adrDirectory}
+**Environment**: ${environment}${environmentValidation ? ` (validation enabled)` : ''}
 
 ## Summary
 - **Total ADRs**: ${totalAdrs}
@@ -3574,6 +3841,7 @@ ${importResult.content[0].text}
 - **Completed Tasks**: ${completedTasks}
 - **Alignment Score**: ${alignmentScore}%
 - **Compliance Score**: ${Math.max(alignmentScore - 10, 0)}%
+- **Environment**: ${environment}
 
 ## Configuration
 - **File Checks**: ${includeFileChecks ? 'Enabled' : 'Disabled'}
@@ -3581,6 +3849,13 @@ ${importResult.content[0].text}
 - **Deep Code Analysis**: ${deepCodeAnalysis ? 'Enabled' : 'Disabled'}
 - **Functional Validation**: ${functionalValidation ? 'Enabled' : 'Disabled'}
 - **Strict Mode**: ${strictMode ? 'Enabled - High scrutiny for mock vs production' : 'Disabled'}
+- **Environment Validation**: ${environmentValidation ? 'Enabled' : 'Disabled'}
+
+## Environment Context
+- **Target Environment**: ${environment}
+- **Security Level**: ${environmentConfig.securityLevel || 'Not specified'}
+- **Required Files**: ${environmentConfig.requiredFiles?.length || 0} files
+- **Required Services**: ${environmentConfig.requiredServices?.length || 0} services
 
 ## ADR Discovery Results
 ${totalAdrs > 0 ?
@@ -3613,6 +3888,8 @@ ${adrTaskMapping.missing.length > 0 ?
 
 ${fileCheckResults || '### File Existence Validation\n- File checks disabled or no project structure available'}
 
+${environmentAnalysisResults || ''}
+
 ${mockAnalysisResults || ''}
 
 ## Recommendations
@@ -3623,10 +3900,14 @@ ${alignmentScore < 70 ?
             '1. **Maintain Current Alignment**: Continue following ADR specifications'}
 ${completedTasks < totalTasks * 0.5 ?
             '\n3. **Accelerate Implementation**: Focus on completing pending tasks' : ''}
+${environmentValidation && environment === 'production' && alignmentScore < 90 ?
+            '\n4. **⚠️ Production Environment Warning**: Current alignment may not meet production requirements' : ''}
 
 ### Medium Priority Actions
 1. **Review Implementation Quality**: ${strictMode ? 'Strict mode analysis above shows' : 'Consider enabling strict mode for'} detailed quality assessment
 2. **Update Documentation**: Ensure TODO.md reflects current project state
+${environmentValidation ?
+            `3. **Environment Compliance**: Ensure ${environment} environment requirements are met` : ''}
 
 ### Low Priority Actions
 1. **Optimize Workflow**: Consider tools for automated ADR-TODO synchronization
@@ -3702,9 +3983,9 @@ To re-run this validation with strict mode:
         return tasks;
     }
     /**
-     * Map TODO tasks to ADRs to identify alignment
+     * Map TODO tasks to ADRs to identify alignment (now environment-aware)
      */
-    mapTasksToAdrs(tasks, adrs) {
+    mapTasksToAdrs(tasks, adrs, environment, environmentConfig) {
         const aligned = [];
         const misaligned = [];
         const missing = [];
@@ -3714,10 +3995,25 @@ To re-run this validation with strict mode:
             ...(adr.decision || '').toLowerCase().split(/\s+/).filter((w) => w.length > 4),
             ...(adr.context || '').toLowerCase().split(/\s+/).filter((w) => w.length > 4)
         ]);
+        // Environment-specific keywords that should be prioritized
+        const envKeywords = [];
+        if (environment && environmentConfig) {
+            if (environment === 'production') {
+                envKeywords.push('deploy', 'production', 'monitoring', 'security', 'performance');
+            }
+            else if (environment === 'staging') {
+                envKeywords.push('test', 'staging', 'integration', 'validation');
+            }
+            else if (environment === 'development') {
+                envKeywords.push('setup', 'development', 'local', 'debug');
+            }
+        }
         for (const task of tasks) {
             const taskLower = task.title.toLowerCase();
             const hasKeywordMatch = adrKeywords.some(keyword => taskLower.includes(keyword) || keyword.includes(taskLower.split(' ')[0]));
-            if (hasKeywordMatch) {
+            // Environment-aware alignment scoring
+            const hasEnvKeywordMatch = envKeywords.some(keyword => taskLower.includes(keyword));
+            if (hasKeywordMatch || hasEnvKeywordMatch) {
                 aligned.push(task);
             }
             else {
@@ -3737,6 +4033,25 @@ To re-run this validation with strict mode:
                 }
             }
         }
+        // Environment-specific missing tasks
+        if (environment && environmentConfig) {
+            if (environmentConfig.requiredFiles) {
+                for (const file of environmentConfig.requiredFiles) {
+                    const hasFileTask = tasks.some(task => task.title.toLowerCase().includes(file.toLowerCase()));
+                    if (!hasFileTask) {
+                        missing.push(`Create ${file} for ${environment} environment`);
+                    }
+                }
+            }
+            if (environmentConfig.requiredServices) {
+                for (const service of environmentConfig.requiredServices) {
+                    const hasServiceTask = tasks.some(task => task.title.toLowerCase().includes(service.toLowerCase()));
+                    if (!hasServiceTask) {
+                        missing.push(`Setup ${service} service for ${environment}`);
+                    }
+                }
+            }
+        }
         return { aligned, misaligned, missing };
     }
     /**
@@ -3848,6 +4163,122 @@ To re-run this validation with strict mode:
         }
         return results;
     }
+    /**
+     * Calculate environment-specific compliance score
+     */
+    calculateEnvironmentScore(projectStructure, environment, environmentConfig) {
+        if (!projectStructure || !environmentConfig)
+            return 0;
+        let score = 100; // Start with perfect score
+        // Check required files
+        if (environmentConfig.requiredFiles) {
+            const allFiles = [
+                ...projectStructure.packageFiles || [],
+                ...projectStructure.configFiles || [],
+                ...projectStructure.buildFiles || [],
+                ...projectStructure.dockerFiles || [],
+                ...projectStructure.ciFiles || [],
+                ...projectStructure.scriptFiles || []
+            ];
+            const existingFiles = allFiles.map(f => f.filename);
+            const missingFiles = environmentConfig.requiredFiles.filter((file) => !existingFiles.includes(file));
+            // Deduct 10 points per missing required file
+            score -= missingFiles.length * 10;
+        }
+        // Environment-specific penalties
+        if (environment === 'production') {
+            // Production requires higher standards
+            if (!projectStructure.dockerFiles?.length)
+                score -= 15;
+            if (!projectStructure.ciFiles?.length)
+                score -= 10;
+        }
+        return Math.max(score, 0);
+    }
+    /**
+     * Perform environment compliance analysis
+     */
+    performEnvironmentComplianceAnalysis(projectStructure, environment, environmentConfig, strictMode) {
+        if (!projectStructure || !environmentConfig) {
+            return '\n### Environment Compliance Analysis\n- Environment analysis disabled or no project structure available\n';
+        }
+        let results = '\n### Environment Compliance Analysis\n';
+        // Required files analysis
+        if (environmentConfig.requiredFiles) {
+            results += `#### Required Files for ${environment} Environment\n`;
+            const allFiles = [
+                ...projectStructure.packageFiles || [],
+                ...projectStructure.configFiles || [],
+                ...projectStructure.buildFiles || [],
+                ...projectStructure.dockerFiles || [],
+                ...projectStructure.ciFiles || [],
+                ...projectStructure.scriptFiles || []
+            ];
+            const existingFiles = allFiles.map(f => f.filename);
+            for (const requiredFile of environmentConfig.requiredFiles) {
+                const exists = existingFiles.includes(requiredFile);
+                results += `- ${exists ? '✅' : '❌'} **${requiredFile}**: ${exists ? 'Found' : 'Missing'}\n`;
+            }
+        }
+        // Security level compliance
+        if (environmentConfig.securityLevel) {
+            results += `\n#### Security Level: ${environmentConfig.securityLevel}\n`;
+            const securityIndicators = this.analyzeSecurityCompliance(projectStructure, environmentConfig.securityLevel);
+            results += securityIndicators;
+        }
+        // Environment-specific recommendations
+        results += `\n#### ${environment} Environment Recommendations\n`;
+        switch (environment) {
+            case 'production':
+                results += '- ⚠️ **Production Critical**: Ensure monitoring, logging, and backup strategies are implemented\n';
+                results += '- 🔒 **Security**: Implement comprehensive security measures\n';
+                results += '- 📊 **Performance**: Monitor and optimize for production workloads\n';
+                if (strictMode) {
+                    results += '- 🔍 **Strict Mode**: Enhanced validation enabled for production environment\n';
+                }
+                break;
+            case 'staging':
+                results += '- 🧪 **Testing**: Ensure comprehensive test coverage and validation\n';
+                results += '- 📋 **Validation**: Implement environment parity checks\n';
+                break;
+            case 'development':
+                results += '- 🛠️ **Development**: Focus on developer experience and debugging tools\n';
+                results += '- 🔄 **Iteration**: Ensure fast feedback loops\n';
+                break;
+        }
+        return results;
+    }
+    /**
+     * Analyze security compliance based on security level
+     */
+    analyzeSecurityCompliance(projectStructure, securityLevel) {
+        let results = '';
+        const securityFiles = [
+            ...projectStructure.configFiles || [],
+            ...projectStructure.dockerFiles || []
+        ].filter(file => file.filename.includes('security') ||
+            file.filename.includes('auth') ||
+            file.filename.includes('.env') ||
+            file.filename === 'Dockerfile');
+        const hasSecurityConfig = securityFiles.length > 0;
+        switch (securityLevel) {
+            case 'critical':
+                results += `- ${hasSecurityConfig ? '✅' : '❌'} **Critical Security**: ${hasSecurityConfig ? 'Security configuration found' : 'No security configuration detected'}\n`;
+                if (!hasSecurityConfig) {
+                    results += '  - **Action Required**: Implement comprehensive security measures\n';
+                }
+                break;
+            case 'high':
+                results += `- ${hasSecurityConfig ? '✅' : '⚠️'} **High Security**: ${hasSecurityConfig ? 'Some security configuration found' : 'Limited security configuration'}\n`;
+                break;
+            case 'medium':
+                results += `- ℹ️ **Medium Security**: Basic security measures recommended\n`;
+                break;
+            default:
+                results += `- ℹ️ **Security Level**: ${securityLevel} (consider increasing for production)\n`;
+        }
+        return results;
+    }
     /**
      * Content masking tool implementations
      */
@@ -4615,6 +5046,15 @@ Please provide:
             throw new McpAdrError(`Smart git push failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_GIT_PUSH_ERROR');
         }
     }
+    async deploymentReadiness(args) {
+        try {
+            const { deploymentReadiness } = await import('./tools/deployment-readiness-tool.js');
+            return await deploymentReadiness(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Deployment readiness check failed: ${error instanceof Error ? error.message : String(error)}`, 'DEPLOYMENT_READINESS_ERROR');
+        }
+    }
     async troubleshootGuidedWorkflow(args) {
         try {
             const { troubleshootGuidedWorkflow } = await import('./tools/troubleshoot-guided-workflow-tool.js');
@@ -4701,4 +5141,5 @@ if (process.argv[1] && (process.argv[1].endsWith('index.js') ||
         process.exit(1);
     });
 }
+// Test comment for pre-commit hook
 //# sourceMappingURL=index.js.map