mcp-adr-analysis-server 2.0.13 → 2.0.15

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,18 +23,8 @@ 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();
-        }
-        // Try multiple possible locations for package.json
+        const currentDir = getCurrentDirCompat();
+        // Strategy 1: Try multiple possible locations for package.json
         const possiblePaths = [
             join(currentDir, 'package.json'),
             join(currentDir, '..', 'package.json'),
@@ -52,11 +42,17 @@ function getPackageVersion() {
                 // Try next path
             }
         }
-        return '2.0.2'; // fallback version
+        // Strategy 2: Use process.env.npm_package_version if available (during npm scripts)
+        if (process.env['npm_package_version']) {
+            return process.env['npm_package_version'];
+        }
+        // Final fallback: Use generic version instead of hardcoded specific version
+        // This prevents the need to update this code when version changes
+        return 'unknown'; // Generic fallback - no longer tied to specific version
     }
     catch (error) {
         console.error('Error reading package.json:', error);
-        return '2.0.2'; // fallback version
+        return 'unknown'; // Generic fallback - no longer tied to specific version
     }
 }
 /**
@@ -330,6 +326,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 +387,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
                                 }
                             }
                         }
@@ -1935,6 +1967,208 @@ export class McpAdrAnalysisServer {
                             },
                             required: ['operation', 'projectPath']
                         }
+                    },
+                    {
+                        name: 'mcp_planning',
+                        description: 'Enhanced project planning and workflow management tool - phase-based project management, team resource allocation, progress tracking, risk analysis, and executive reporting',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['create_project', 'manage_phases', 'track_progress', 'manage_resources', 'risk_analysis', 'generate_reports'],
+                                    description: 'Project planning operation to perform'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Project root path'
+                                },
+                                projectName: {
+                                    type: 'string',
+                                    description: 'Project name (for create_project operation)'
+                                },
+                                description: {
+                                    type: 'string',
+                                    description: 'Project description (for create_project operation)'
+                                },
+                                phases: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            name: { type: 'string' },
+                                            duration: { type: 'string' },
+                                            dependencies: {
+                                                type: 'array',
+                                                items: { type: 'string' },
+                                                default: []
+                                            },
+                                            milestones: {
+                                                type: 'array',
+                                                items: { type: 'string' },
+                                                default: []
+                                            }
+                                        },
+                                        required: ['name', 'duration']
+                                    },
+                                    description: 'Initial project phases (for create_project operation)'
+                                },
+                                team: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            name: { type: 'string' },
+                                            role: { type: 'string' },
+                                            skills: {
+                                                type: 'array',
+                                                items: { type: 'string' },
+                                                default: []
+                                            },
+                                            capacity: { type: 'string' }
+                                        },
+                                        required: ['name', 'role', 'capacity']
+                                    },
+                                    default: [],
+                                    description: 'Team structure (for create_project operation)'
+                                },
+                                importFromAdrs: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Import phases from existing ADRs (for create_project operation)'
+                                },
+                                importFromTodos: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Import tasks from TODO system (for create_project operation)'
+                                },
+                                action: {
+                                    type: 'string',
+                                    enum: ['list', 'create', 'update', 'delete', 'transition', 'add', 'remove', 'allocate', 'optimize'],
+                                    description: 'Management action (for manage_phases/manage_resources operations)'
+                                },
+                                phaseId: {
+                                    type: 'string',
+                                    description: 'Phase ID for phase operations'
+                                },
+                                phaseData: {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string' },
+                                        description: { type: 'string' },
+                                        estimatedDuration: { type: 'string' },
+                                        dependencies: {
+                                            type: 'array',
+                                            items: { type: 'string' }
+                                        },
+                                        milestones: {
+                                            type: 'array',
+                                            items: { type: 'string' }
+                                        },
+                                        linkedAdrs: {
+                                            type: 'array',
+                                            items: { type: 'string' }
+                                        }
+                                    },
+                                    description: 'Phase data for create/update operations'
+                                },
+                                targetStatus: {
+                                    type: 'string',
+                                    enum: ['planning', 'active', 'completed', 'blocked', 'cancelled'],
+                                    description: 'Target status for phase transition'
+                                },
+                                reportType: {
+                                    type: 'string',
+                                    enum: ['summary', 'detailed', 'gantt', 'milestones', 'risks', 'executive', 'status', 'health', 'team_performance', 'milestone_tracking'],
+                                    default: 'summary',
+                                    description: 'Type of progress report or generated report'
+                                },
+                                timeframe: {
+                                    type: 'string',
+                                    enum: ['current', 'weekly', 'monthly', 'quarterly', 'week', 'month', 'quarter', 'project'],
+                                    default: 'current',
+                                    description: 'Time frame for reports and tracking'
+                                },
+                                includeVisuals: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include visual progress indicators'
+                                },
+                                updateTaskProgress: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Sync progress from TODO system'
+                                },
+                                memberId: {
+                                    type: 'string',
+                                    description: 'Team member ID for resource operations'
+                                },
+                                memberData: {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string' },
+                                        role: { type: 'string' },
+                                        skills: {
+                                            type: 'array',
+                                            items: { type: 'string' }
+                                        },
+                                        capacity: { type: 'string' }
+                                    },
+                                    description: 'Team member data for resource operations'
+                                },
+                                allocationData: {
+                                    type: 'object',
+                                    properties: {
+                                        phaseId: { type: 'string' },
+                                        allocation: {
+                                            type: 'number',
+                                            minimum: 0,
+                                            maximum: 100
+                                        }
+                                    },
+                                    required: ['phaseId', 'allocation'],
+                                    description: 'Resource allocation data'
+                                },
+                                analysisType: {
+                                    type: 'string',
+                                    enum: ['automated', 'manual', 'comprehensive'],
+                                    default: 'comprehensive',
+                                    description: 'Type of risk analysis'
+                                },
+                                includeAdrRisks: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Analyze risks from ADR complexity'
+                                },
+                                includeDependencyRisks: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Analyze dependency chain risks'
+                                },
+                                includeResourceRisks: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Analyze resource allocation risks'
+                                },
+                                generateMitigation: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Generate mitigation strategies'
+                                },
+                                format: {
+                                    type: 'string',
+                                    enum: ['markdown', 'json', 'html'],
+                                    default: 'markdown',
+                                    description: 'Report output format'
+                                },
+                                includeCharts: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include progress charts and graphs'
+                                }
+                            },
+                            required: ['operation', 'projectPath']
+                        }
                     }
                 ]
             };
@@ -2053,6 +2287,9 @@ export class McpAdrAnalysisServer {
                     case 'smart_score':
                         response = await this.smartScore(args);
                         break;
+                    case 'mcp_planning':
+                        response = await this.mcpPlanning(args);
+                        break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
                 }
@@ -3588,7 +3825,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
@@ -3596,7 +3833,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 = '';
@@ -3642,7 +3893,10 @@ ${importResult.content[0].text}
                 includeRuleValidation,
                 deepCodeAnalysis,
                 functionalValidation,
-                strictMode
+                strictMode,
+                environment: detectedEnvironment,
+                environmentConfig: finalEnvironmentConfig,
+                environmentValidation
             });
             return {
                 content: [
@@ -3657,11 +3911,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);
@@ -3669,15 +4013,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) {
@@ -3690,6 +4044,7 @@ ${importResult.content[0].text}
 **Project Path**: ${projectPath}
 **TODO Path**: ${todoPath}
 **ADR Directory**: ${adrDirectory}
+**Environment**: ${environment}${environmentValidation ? ` (validation enabled)` : ''}
 
 ## Summary
 - **Total ADRs**: ${totalAdrs}
@@ -3697,6 +4052,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'}
@@ -3704,6 +4060,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 ?
@@ -3736,6 +4099,8 @@ ${adrTaskMapping.missing.length > 0 ?
 
 ${fileCheckResults || '### File Existence Validation\n- File checks disabled or no project structure available'}
 
+${environmentAnalysisResults || ''}
+
 ${mockAnalysisResults || ''}
 
 ## Recommendations
@@ -3746,10 +4111,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
@@ -3825,9 +4194,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 = [];
@@ -3837,10 +4206,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 {
@@ -3860,6 +4244,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 };
     }
     /**
@@ -3971,6 +4374,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
      */
@@ -4765,6 +5284,15 @@ Please provide:
             throw new McpAdrError(`Smart score analysis failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_SCORE_ERROR');
         }
     }
+    async mcpPlanning(args) {
+        try {
+            const { mcpPlanning } = await import('./tools/mcp-planning-tool.js');
+            return await mcpPlanning(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`MCP planning failed: ${error instanceof Error ? error.message : String(error)}`, 'MCP_PLANNING_ERROR');
+        }
+    }
 }
 /**
  * Main execution
@@ -4833,4 +5361,5 @@ if (process.argv[1] && (process.argv[1].endsWith('index.js') ||
         process.exit(1);
     });
 }
+// Test comment for pre-commit hook
 //# sourceMappingURL=index.js.map