mcp-adr-analysis-server 2.0.21 → 2.0.24

package/dist/src/tools/deployment-readiness-tool.js

@@ -1,20 +1,23 @@
 /**
- * Deployment Readiness Tool - Version 1.0
+ * Deployment Readiness Tool - Version 2.0
  *
  * Comprehensive deployment validation with test failure tracking, deployment history analysis,
  * and hard blocking integration with smart git push.
+ * Enhanced with memory integration for deployment assessment tracking and pattern recognition.
  *
  * IMPORTANT FOR AI ASSISTANTS: This tool provides:
  * 1. Test Execution Validation: Zero tolerance for test failures
  * 2. Deployment History Analysis: Pattern detection and success rate tracking
  * 3. Code Quality Gates: Mock vs production code detection
  * 4. Hard Blocking: Prevents unsafe deployments via smart git push integration
+ * 5. Memory Integration: Stores deployment assessments as memory entities
  *
- * Cache Dependencies:
- * - CREATES/UPDATES: .mcp-adr-cache/deployment-history.json (deployment tracking)
- * - CREATES/UPDATES: .mcp-adr-cache/deployment-readiness-cache.json (analysis cache)
+ * Memory Dependencies:
+ * - CREATES: deployment_assessment memory entities
+ * - MIGRATES: Existing deployment history to memory entities
+ * - ANALYZES: Deployment patterns across memory entities
  * - INTEGRATES: smart-git-push-tool for deployment blocking
- * - INTEGRATES: todo-management-tool for automatic task creation
+ * - INTEGRATES: todo-file-watcher for automatic task creation
  */
 import { z } from 'zod';
 import { McpAdrError } from '../types/index.js';
@@ -23,34 +26,59 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { validateMcpResponse } from '../utils/mcp-response-validator.js';
 import { jsonSafeError } from '../utils/json-safe.js';
+import { MemoryEntityManager } from '../utils/memory-entity-manager.js';
+import { EnhancedLogger } from '../utils/enhanced-logging.js';
 // Core schemas
 const DeploymentReadinessSchema = z.object({
-    operation: z.enum([
+    operation: z
+        .enum([
         'check_readiness', // Full deployment readiness check
         'validate_production', // Production-specific validation
         'test_validation', // Test execution and failure analysis
         'deployment_history', // Deployment history analysis
         'full_audit', // Comprehensive audit (all checks)
-        'emergency_override' // Emergency bypass with justification
-    ]).describe('Operation to perform'),
+        'emergency_override', // Emergency bypass with justification
+    ])
+        .describe('Operation to perform'),
     // Core Configuration
     projectPath: z.string().optional().describe('Project root path'),
-    targetEnvironment: z.enum(['staging', 'production', 'integration']).default('production').describe('Target deployment environment'),
+    targetEnvironment: z
+        .enum(['staging', 'production', 'integration'])
+        .default('production')
+        .describe('Target deployment environment'),
     strictMode: z.boolean().default(true).describe('Enable strict validation (recommended)'),
     // Code Quality Gates
-    allowMockCode: z.boolean().default(false).describe('Allow mock code in deployment (NOT RECOMMENDED)'),
-    productionCodeThreshold: z.number().default(85).describe('Minimum production code quality score (0-100)'),
+    allowMockCode: z
+        .boolean()
+        .default(false)
+        .describe('Allow mock code in deployment (NOT RECOMMENDED)'),
+    productionCodeThreshold: z
+        .number()
+        .default(85)
+        .describe('Minimum production code quality score (0-100)'),
     mockCodeMaxAllowed: z.number().default(0).describe('Maximum mock code indicators allowed'),
     // Test Failure Gates
-    maxTestFailures: z.number().default(0).describe('Maximum test failures allowed (0 = zero tolerance)'),
+    maxTestFailures: z
+        .number()
+        .default(0)
+        .describe('Maximum test failures allowed (0 = zero tolerance)'),
     requireTestCoverage: z.number().default(80).describe('Minimum test coverage percentage required'),
     blockOnFailingTests: z.boolean().default(true).describe('Block deployment if tests are failing'),
-    testSuiteRequired: z.array(z.string()).default([]).describe('Required test suites that must pass'),
+    testSuiteRequired: z
+        .array(z.string())
+        .default([])
+        .describe('Required test suites that must pass'),
     // Deployment History Gates
     maxRecentFailures: z.number().default(2).describe('Maximum recent deployment failures allowed'),
-    deploymentSuccessThreshold: z.number().default(80).describe('Minimum deployment success rate required (%)'),
+    deploymentSuccessThreshold: z
+        .number()
+        .default(80)
+        .describe('Minimum deployment success rate required (%)'),
     blockOnRecentFailures: z.boolean().default(true).describe('Block if recent deployments failed'),
-    rollbackFrequencyThreshold: z.number().default(20).describe('Maximum rollback frequency allowed (%)'),
+    rollbackFrequencyThreshold: z
+        .number()
+        .default(20)
+        .describe('Maximum rollback frequency allowed (%)'),
     // Integration Rules
     requireAdrCompliance: z.boolean().default(true).describe('Require ADR compliance validation'),
     integrateTodoTasks: z.boolean().default(true).describe('Auto-create blocking tasks for issues'),
@@ -59,8 +87,480 @@ const DeploymentReadinessSchema = z.object({
     // Human Override System
     emergencyBypass: z.boolean().default(false).describe('Emergency bypass for critical fixes'),
     businessJustification: z.string().optional().describe('Business justification for overrides'),
-    approvalRequired: z.boolean().default(true).describe('Require approval for overrides')
+    approvalRequired: z.boolean().default(true).describe('Require approval for overrides'),
+    // Memory Integration
+    enableMemoryIntegration: z.boolean().default(true).describe('Enable memory entity storage'),
+    migrateExistingHistory: z
+        .boolean()
+        .default(false)
+        .describe('Migrate existing deployment history to memory'),
 });
+/**
+ * Deployment Memory Manager for tracking deployment assessments and patterns
+ */
+class DeploymentMemoryManager {
+    memoryManager;
+    logger;
+    constructor() {
+        this.memoryManager = new MemoryEntityManager();
+        this.logger = new EnhancedLogger();
+    }
+    async initialize() {
+        await this.memoryManager.initialize();
+    }
+    /**
+     * Store deployment assessment as memory entity
+     */
+    async storeDeploymentAssessment(environment, readinessData, validationResults, projectPath) {
+        try {
+            const assessmentData = {
+                environment: environment,
+                readinessScore: readinessData.overallScore / 100, // Convert to 0-1 range
+                validationResults: {
+                    testResults: {
+                        passed: readinessData.testValidationResult.testSuitesExecuted.reduce((sum, suite) => sum + suite.passedTests, 0),
+                        failed: readinessData.testValidationResult.failureCount,
+                        coverage: readinessData.testValidationResult.coveragePercentage / 100, // Convert to 0-1 range
+                        criticalFailures: readinessData.testValidationResult.criticalTestFailures.map(f => f.testName),
+                    },
+                    securityValidation: {
+                        vulnerabilities: 0, // Default - could be enhanced with actual security scan data
+                        securityScore: 0.8, // Default - could be enhanced with actual security analysis
+                        criticalIssues: readinessData.criticalBlockers
+                            .filter(b => b.category === 'adr_compliance')
+                            .map(b => b.title),
+                    },
+                    performanceValidation: {
+                        performanceScore: Math.max(0, (readinessData.overallScore - 20) / 80), // Derived from overall score
+                        bottlenecks: [],
+                        resourceUtilization: {},
+                    },
+                },
+                blockingIssues: [
+                    ...readinessData.criticalBlockers.map(b => ({
+                        issue: `${b.title}: ${b.description}`,
+                        severity: b.severity,
+                        category: this.mapBlockerCategory(b.category),
+                        resolution: b.resolutionSteps.join('; '),
+                        estimatedEffort: b.estimatedResolutionTime,
+                    })),
+                    ...readinessData.testFailureBlockers.map(b => ({
+                        issue: `${b.title}: ${b.description}`,
+                        severity: b.severity,
+                        category: 'test',
+                        resolution: b.resolutionSteps.join('; '),
+                        estimatedEffort: b.estimatedResolutionTime,
+                    })),
+                    ...readinessData.deploymentHistoryBlockers.map(b => ({
+                        issue: `${b.title}: ${b.description}`,
+                        severity: b.severity,
+                        category: 'configuration',
+                        resolution: b.resolutionSteps.join('; '),
+                        estimatedEffort: b.estimatedResolutionTime,
+                    })),
+                ],
+                deploymentStrategy: {
+                    type: 'rolling', // Default strategy - could be made configurable
+                    rollbackPlan: 'Automated rollback via deployment pipeline with health check validation',
+                    monitoringPlan: 'Monitor application metrics, error rates, and performance indicators for 30 minutes post-deployment',
+                    estimatedDowntime: readinessData.isDeploymentReady
+                        ? '0 minutes (rolling deployment)'
+                        : 'Cannot deploy - blockers present',
+                },
+                complianceChecks: {
+                    adrCompliance: readinessData.adrComplianceResult.score / 100, // Convert to 0-1 range
+                    regulatoryCompliance: [], // Could be enhanced with actual compliance data
+                    auditTrail: [
+                        `Deployment assessment completed at ${new Date().toISOString()}`,
+                        `Test validation: ${readinessData.testValidationResult.overallTestStatus}`,
+                        `Overall readiness score: ${readinessData.overallScore}%`,
+                        `Git push status: ${readinessData.gitPushStatus}`,
+                    ],
+                },
+            };
+            const entity = await this.memoryManager.upsertEntity({
+                type: 'deployment_assessment',
+                title: `Deployment Assessment: ${environment} - ${readinessData.isDeploymentReady ? 'READY' : 'BLOCKED'} - ${new Date().toISOString().split('T')[0]}`,
+                description: `Deployment readiness assessment for ${environment} environment${readinessData.isDeploymentReady ? ' - APPROVED' : ' - BLOCKED'}`,
+                tags: [
+                    'deployment',
+                    environment.toLowerCase(),
+                    'readiness-assessment',
+                    readinessData.isDeploymentReady ? 'approved' : 'blocked',
+                    `score-${Math.floor(readinessData.overallScore / 10) * 10}`,
+                    ...(readinessData.criticalBlockers.length > 0 ? ['critical-issues'] : []),
+                    ...(readinessData.testValidationResult.failureCount > 0 ? ['test-failures'] : []),
+                    ...(readinessData.deploymentHistoryAnalysis.rollbackRate > 20
+                        ? ['high-rollback-risk']
+                        : []),
+                ],
+                assessmentData,
+                relationships: [],
+                context: {
+                    projectPhase: 'deployment-validation',
+                    technicalStack: this.extractTechnicalStack(validationResults),
+                    environmentalFactors: [environment, projectPath || 'unknown-project'].filter(Boolean),
+                    stakeholders: ['deployment-team', 'qa-team', 'infrastructure-team'],
+                },
+                accessPattern: {
+                    lastAccessed: new Date().toISOString(),
+                    accessCount: 1,
+                    accessContext: ['deployment-assessment'],
+                },
+                evolution: {
+                    origin: 'created',
+                    transformations: [
+                        {
+                            timestamp: new Date().toISOString(),
+                            type: 'assessment_creation',
+                            description: `Deployment assessment created for ${environment}`,
+                            agent: 'deployment-readiness-tool',
+                        },
+                    ],
+                },
+                validation: {
+                    isVerified: readinessData.isDeploymentReady,
+                    verificationMethod: 'comprehensive-deployment-audit',
+                    verificationTimestamp: new Date().toISOString(),
+                },
+            });
+            this.logger.info(`Deployment assessment stored for ${environment}`, 'DeploymentMemoryManager', {
+                environment,
+                entityId: entity.id,
+                readinessScore: readinessData.overallScore,
+                isReady: readinessData.isDeploymentReady,
+                blockingIssues: assessmentData.blockingIssues.length,
+            });
+            return entity.id;
+        }
+        catch (error) {
+            this.logger.error('Failed to store deployment assessment', 'DeploymentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Migrate existing deployment history to memory entities
+     */
+    async migrateExistingHistory(historyPath) {
+        try {
+            if (!existsSync(historyPath)) {
+                this.logger.info('No existing deployment history found to migrate', 'DeploymentMemoryManager');
+                return;
+            }
+            const historyData = JSON.parse(readFileSync(historyPath, 'utf8'));
+            const deployments = historyData.deployments || [];
+            let migratedCount = 0;
+            for (const deployment of deployments) {
+                try {
+                    await this.migrateDeploymentRecord(deployment);
+                    migratedCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Failed to migrate deployment ${deployment.deploymentId}`, 'DeploymentMemoryManager', error);
+                }
+            }
+            this.logger.info(`Migration completed: ${migratedCount}/${deployments.length} deployments migrated`, 'DeploymentMemoryManager');
+        }
+        catch (error) {
+            this.logger.error('Failed to migrate deployment history', 'DeploymentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Analyze deployment patterns across memory entities
+     */
+    async analyzeDeploymentPatterns(environment) {
+        try {
+            const query = {
+                entityTypes: ['deployment_assessment'],
+                limit: 100,
+                sortBy: 'lastModified',
+            };
+            if (environment) {
+                query.tags = [environment.toLowerCase()];
+            }
+            const assessments = await this.memoryManager.queryEntities(query);
+            const patterns = this.detectDeploymentPatterns(assessments.entities);
+            const trends = this.calculateDeploymentTrends(assessments.entities);
+            const recommendations = this.generatePatternRecommendations(patterns, trends);
+            const riskFactors = this.identifyRiskFactors(assessments.entities);
+            return {
+                patterns,
+                trends,
+                recommendations,
+                riskFactors,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to analyze deployment patterns', 'DeploymentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Compare current assessment with historical patterns
+     */
+    async compareWithHistory(currentAssessment, environment) {
+        try {
+            const recentAssessments = await this.memoryManager.queryEntities({
+                entityTypes: ['deployment_assessment'],
+                tags: [environment.toLowerCase()],
+                limit: 10,
+                sortBy: 'lastModified',
+            });
+            if (recentAssessments.entities.length === 0) {
+                return {
+                    isImprovement: true,
+                    comparison: { type: 'first_assessment' },
+                    insights: ['This is the first deployment assessment for this environment'],
+                };
+            }
+            const lastAssessment = recentAssessments.entities[0];
+            const comparison = this.compareAssessments(currentAssessment, lastAssessment.assessmentData);
+            return {
+                isImprovement: comparison.scoreImprovement > 0,
+                comparison,
+                insights: this.generateComparisonInsights(comparison),
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to compare with history', 'DeploymentMemoryManager', error);
+            return {
+                isImprovement: false,
+                comparison: { type: 'comparison_failed' },
+                insights: ['Unable to compare with historical data'],
+            };
+        }
+    }
+    // Private helper methods
+    async migrateDeploymentRecord(deployment) {
+        const assessmentData = {
+            environment: deployment.environment,
+            readinessScore: deployment.status === 'success' ? 1.0 : 0.0, // Use 0-1 range
+            validationResults: {
+                testResults: deployment.testResults
+                    ? {
+                        passed: deployment.testResults.testSuitesExecuted.reduce((sum, suite) => sum + suite.passedTests, 0),
+                        failed: deployment.testResults.failureCount,
+                        coverage: deployment.testResults.coveragePercentage / 100,
+                        criticalFailures: deployment.testResults.criticalTestFailures.map(f => f.testName),
+                    }
+                    : {
+                        passed: 0,
+                        failed: 0,
+                        coverage: 0,
+                        criticalFailures: [],
+                    },
+                securityValidation: {
+                    vulnerabilities: 0,
+                    securityScore: 0.8,
+                    criticalIssues: [],
+                },
+                performanceValidation: {
+                    performanceScore: deployment.status === 'success' ? 0.8 : 0.2,
+                    bottlenecks: [],
+                    resourceUtilization: {},
+                },
+            },
+            blockingIssues: deployment.failureReason
+                ? [
+                    {
+                        issue: `Historical Deployment Failure: ${deployment.failureReason}`,
+                        severity: 'high',
+                        category: 'configuration',
+                        resolution: 'Review and address historical failure causes',
+                    },
+                ]
+                : [],
+            deploymentStrategy: {
+                type: 'rolling',
+                rollbackPlan: 'Standard rollback procedure',
+                monitoringPlan: 'Basic monitoring',
+                estimatedDowntime: deployment.rollbackRequired ? 'Variable' : '0 minutes',
+            },
+            complianceChecks: {
+                adrCompliance: 1.0,
+                regulatoryCompliance: [],
+                auditTrail: [
+                    `Migrated deployment record from ${deployment.timestamp}`,
+                    `Original status: ${deployment.status}`,
+                    `Rollback required: ${deployment.rollbackRequired}`,
+                ],
+            },
+        };
+        await this.memoryManager.upsertEntity({
+            type: 'deployment_assessment',
+            title: `Historical Deployment: ${deployment.environment} - ${deployment.status.toUpperCase()} - ${deployment.timestamp.split('T')[0]}`,
+            description: `Migrated deployment record for ${deployment.environment} (ID: ${deployment.deploymentId})`,
+            tags: [
+                'deployment',
+                deployment.environment.toLowerCase(),
+                'migrated-record',
+                deployment.status,
+                ...(deployment.rollbackRequired ? ['rollback-required'] : []),
+            ],
+            assessmentData,
+            relationships: [],
+            context: {
+                projectPhase: 'deployment-execution',
+                technicalStack: [],
+                environmentalFactors: [deployment.environment],
+                stakeholders: ['deployment-team'],
+            },
+            accessPattern: {
+                lastAccessed: new Date().toISOString(),
+                accessCount: 1,
+                accessContext: ['migration'],
+            },
+            evolution: {
+                origin: 'imported',
+                transformations: [
+                    {
+                        timestamp: new Date().toISOString(),
+                        type: 'migration',
+                        description: `Migrated from deployment-history.json (original: ${deployment.timestamp})`,
+                        agent: 'deployment-readiness-tool',
+                    },
+                ],
+            },
+            validation: {
+                isVerified: true,
+                verificationMethod: 'historical-migration',
+                verificationTimestamp: new Date().toISOString(),
+            },
+        });
+    }
+    extractTechnicalStack(_validationResults) {
+        // Extract technical stack from validation results
+        // This is a simplified implementation
+        return [];
+    }
+    detectDeploymentPatterns(assessments) {
+        // Analyze deployment patterns across assessments
+        const patterns = [];
+        // Pattern: Time-based failures
+        const timePatterns = this.analyzeTimePatterns(assessments);
+        if (timePatterns.length > 0) {
+            patterns.push({ type: 'time_based', patterns: timePatterns });
+        }
+        // Pattern: Environment-specific issues
+        const envPatterns = this.analyzeEnvironmentPatterns(assessments);
+        if (envPatterns.length > 0) {
+            patterns.push({ type: 'environment_specific', patterns: envPatterns });
+        }
+        return patterns;
+    }
+    calculateDeploymentTrends(assessments) {
+        if (assessments.length < 3)
+            return [];
+        const trends = [];
+        const scores = assessments.map((a) => a.assessmentData.readinessScore);
+        // Calculate score trend
+        const scoreTrend = this.calculateTrend(scores);
+        trends.push({
+            metric: 'readiness_score',
+            trend: scoreTrend > 0 ? 'improving' : scoreTrend < 0 ? 'declining' : 'stable',
+            change: scoreTrend,
+        });
+        return trends;
+    }
+    generatePatternRecommendations(patterns, trends) {
+        const recommendations = [];
+        // Generate recommendations based on patterns
+        patterns.forEach(pattern => {
+            if (pattern.type === 'time_based') {
+                recommendations.push('Consider scheduling deployments during low-risk time windows');
+            }
+            if (pattern.type === 'environment_specific') {
+                recommendations.push('Address environment-specific configuration issues');
+            }
+        });
+        // Generate recommendations based on trends
+        trends.forEach(trend => {
+            if (trend.metric === 'readiness_score' && trend.trend === 'declining') {
+                recommendations.push('Investigate causes of declining deployment readiness scores');
+            }
+        });
+        return recommendations;
+    }
+    /**
+     * Map deployment blocker category to schema-compliant category
+     */
+    mapBlockerCategory(category) {
+        switch (category) {
+            case 'test_failure':
+                return 'test';
+            case 'adr_compliance':
+            case 'environment':
+            case 'deployment_history':
+                return 'configuration';
+            case 'code_quality':
+                return 'performance';
+            default:
+                return 'configuration';
+        }
+    }
+    identifyRiskFactors(assessments) {
+        const riskFactors = [];
+        // Analyze recent failures
+        const recentFailures = assessments
+            .filter((a) => !a.assessmentData.deploymentReady)
+            .slice(0, 5);
+        if (recentFailures.length >= 3) {
+            riskFactors.push({
+                factor: 'frequent_failures',
+                description: `${recentFailures.length} deployment blocks in recent assessments`,
+                severity: 'high',
+            });
+        }
+        return riskFactors;
+    }
+    compareAssessments(current, historical) {
+        return {
+            scoreImprovement: current.overallScore - historical.readinessScore,
+            confidenceChange: current.confidence - historical.confidence,
+            blockingIssuesChange: current.criticalBlockers.length - historical.blockingIssues.length,
+            testImprovements: {
+                failureCountChange: current.testValidationResult.failureCount -
+                    (historical.validationResults?.testValidation?.failureCount || 0),
+                coverageChange: current.testValidationResult.coveragePercentage -
+                    (historical.validationResults?.testValidation?.coveragePercentage || 0),
+            },
+        };
+    }
+    generateComparisonInsights(comparison) {
+        const insights = [];
+        if (comparison.scoreImprovement > 0) {
+            insights.push(`Deployment readiness improved by ${comparison.scoreImprovement} points`);
+        }
+        else if (comparison.scoreImprovement < 0) {
+            insights.push(`Deployment readiness declined by ${Math.abs(comparison.scoreImprovement)} points`);
+        }
+        if (comparison.testImprovements.failureCountChange < 0) {
+            insights.push(`Test stability improved: ${Math.abs(comparison.testImprovements.failureCountChange)} fewer failures`);
+        }
+        if (comparison.testImprovements.coverageChange > 0) {
+            insights.push(`Test coverage increased by ${comparison.testImprovements.coverageChange}%`);
+        }
+        return insights;
+    }
+    analyzeTimePatterns(_assessments) {
+        // Simplified time pattern analysis
+        return [];
+    }
+    analyzeEnvironmentPatterns(_assessments) {
+        // Simplified environment pattern analysis
+        return [];
+    }
+    calculateTrend(values) {
+        if (values.length < 2)
+            return 0;
+        const recent = values.slice(0, Math.min(5, values.length));
+        const older = values.slice(Math.min(5, values.length));
+        const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+        const olderAvg = older.length > 0 ? older.reduce((a, b) => a + b, 0) / older.length : recentAvg;
+        return recentAvg - olderAvg;
+    }
+}
 /**
  * Main deployment readiness function
  */
@@ -76,6 +576,16 @@ export async function deploymentReadiness(args) {
         if (!existsSync(cacheDir)) {
             mkdirSync(cacheDir, { recursive: true });
         }
+        // Initialize memory manager if enabled
+        let memoryManager = null;
+        if (validatedArgs.enableMemoryIntegration) {
+            memoryManager = new DeploymentMemoryManager();
+            await memoryManager.initialize();
+            // Migrate existing history if requested
+            if (validatedArgs.migrateExistingHistory) {
+                await memoryManager.migrateExistingHistory(deploymentHistoryPath);
+            }
+        }
         let result;
         switch (validatedArgs.operation) {
             case 'test_validation':
@@ -99,10 +609,68 @@ export async function deploymentReadiness(args) {
         writeFileSync(readinessCachePath, JSON.stringify({
             timestamp: new Date().toISOString(),
             operation: validatedArgs.operation,
-            result
+            result,
         }, null, 2));
-        // Generate response based on deployment readiness
-        return generateDeploymentReadinessResponse(result, validatedArgs);
+        // Memory integration: store assessment and analyze patterns
+        let memoryIntegrationInfo = '';
+        if (memoryManager) {
+            try {
+                // Store deployment assessment
+                const assessmentId = await memoryManager.storeDeploymentAssessment(validatedArgs.targetEnvironment, result, { projectPath, operation: validatedArgs.operation }, projectPath);
+                // Compare with historical patterns
+                const historyComparison = await memoryManager.compareWithHistory(result, validatedArgs.targetEnvironment);
+                // Analyze deployment patterns
+                const patternAnalysis = await memoryManager.analyzeDeploymentPatterns(validatedArgs.targetEnvironment);
+                memoryIntegrationInfo = `
+
+## 🧠 Memory Integration Analysis
+
+- **Assessment Stored**: ✅ Deployment assessment saved (ID: ${assessmentId.substring(0, 8)}...)
+- **Environment**: ${validatedArgs.targetEnvironment}
+- **Historical Comparison**: ${historyComparison.isImprovement ? '📈 Improvement detected' : '📊 Baseline established'}
+
+${historyComparison.insights.length > 0
+                    ? `### Historical Insights
+${historyComparison.insights.map(insight => `- ${insight}`).join('\n')}
+`
+                    : ''}
+
+${patternAnalysis.trends.length > 0
+                    ? `### Deployment Trends
+${patternAnalysis.trends.map(trend => `- **${trend.metric}**: ${trend.trend} (${trend.change > 0 ? '+' : ''}${trend.change})`).join('\n')}
+`
+                    : ''}
+
+${patternAnalysis.recommendations.length > 0
+                    ? `### Pattern-Based Recommendations
+${patternAnalysis.recommendations.map(rec => `- ${rec}`).join('\n')}
+`
+                    : ''}
+
+${patternAnalysis.riskFactors.length > 0
+                    ? `### Risk Factors Identified
+${patternAnalysis.riskFactors.map(risk => `- **${risk.factor}**: ${risk.description} (${risk.severity})`).join('\n')}
+`
+                    : ''}
+`;
+            }
+            catch (memoryError) {
+                memoryIntegrationInfo = `
+
+## 🧠 Memory Integration Status
+
+- **Status**: ⚠️ Memory integration failed - assessment continued without persistence
+- **Error**: ${memoryError instanceof Error ? memoryError.message : 'Unknown error'}
+`;
+            }
+        }
+        // Generate enhanced response with memory integration
+        const baseResponse = generateDeploymentReadinessResponse(result, validatedArgs);
+        // Add memory integration info if available
+        if (memoryIntegrationInfo && baseResponse.content?.[0]?.text) {
+            baseResponse.content[0].text += memoryIntegrationInfo;
+        }
+        return baseResponse;
     }
     catch (error) {
         throw new McpAdrError('DEPLOYMENT_READINESS_ERROR', `Deployment readiness check failed: ${jsonSafeError(error)}`);
@@ -126,10 +694,10 @@ async function performTestValidation(args, projectPath) {
                 'Run npm test to see detailed failures',
                 'Fix failing tests one by one',
                 'Ensure all tests pass before deployment',
-                'Consider increasing test coverage'
+                'Consider increasing test coverage',
             ],
             estimatedResolutionTime: `${Math.ceil(testResult.failureCount * 0.5)} hours`,
-            blocksDeployment: args.blockOnFailingTests
+            blocksDeployment: args.blockOnFailingTests,
         });
     }
     // Check test coverage
@@ -143,10 +711,10 @@ async function performTestValidation(args, projectPath) {
             resolutionSteps: [
                 'Add tests for uncovered code',
                 'Run npm run test:coverage to see detailed coverage',
-                'Focus on critical business logic first'
+                'Focus on critical business logic first',
             ],
             estimatedResolutionTime: '2-4 hours',
-            blocksDeployment: args.strictMode
+            blocksDeployment: args.strictMode,
         });
     }
     // Basic result structure
@@ -154,10 +722,34 @@ async function performTestValidation(args, projectPath) {
         isDeploymentReady: testBlockers.length === 0,
         overallScore: calculateTestScore(testResult, args),
         confidence: 85,
-        codeQualityAnalysis: { qualityScore: 75, productionIndicators: 10, mockIndicators: 2, failingFiles: [], recommendations: [] },
+        codeQualityAnalysis: {
+            qualityScore: 75,
+            productionIndicators: 10,
+            mockIndicators: 2,
+            failingFiles: [],
+            recommendations: [],
+        },
         testValidationResult: testResult,
-        deploymentHistoryAnalysis: { recentDeployments: [], successRate: 100, rollbackRate: 0, averageDeploymentTime: 0, failurePatterns: [], environmentStability: { stabilityScore: 100, riskLevel: 'low', recommendation: 'Proceed with deployment' }, recommendedAction: 'proceed' },
-        adrComplianceResult: { score: 100, compliantAdrs: 0, totalAdrs: 0, missingImplementations: [], recommendations: [] },
+        deploymentHistoryAnalysis: {
+            recentDeployments: [],
+            successRate: 100,
+            rollbackRate: 0,
+            averageDeploymentTime: 0,
+            failurePatterns: [],
+            environmentStability: {
+                stabilityScore: 100,
+                riskLevel: 'low',
+                recommendation: 'Proceed with deployment',
+            },
+            recommendedAction: 'proceed',
+        },
+        adrComplianceResult: {
+            score: 100,
+            compliantAdrs: 0,
+            totalAdrs: 0,
+            missingImplementations: [],
+            recommendations: [],
+        },
         criticalBlockers: testBlockers.filter(b => b.severity === 'critical'),
         testFailureBlockers: testBlockers,
         deploymentHistoryBlockers: [],
@@ -165,7 +757,7 @@ async function performTestValidation(args, projectPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: testBlockers.length === 0 ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
     };
 }
 /**
@@ -183,7 +775,7 @@ async function executeTestSuite(projectPath, _requiredSuites) {
                 testOutput = execSync(command, {
                     cwd: projectPath,
                     encoding: 'utf8',
-                    timeout: 300000 // 5 minute timeout
+                    timeout: 300000, // 5 minute timeout
                 });
                 break;
             }
@@ -206,7 +798,7 @@ async function executeTestSuite(projectPath, _requiredSuites) {
     // Parse test results (simplified for now)
     const testSuites = parseTestOutput(testOutput);
     const totalFailures = testSuites.reduce((sum, suite) => sum + suite.failedTests, 0);
-    const overallStatus = exitCode === 0 ? 'passed' : (totalFailures > 0 ? 'failed' : 'partial');
+    const overallStatus = exitCode === 0 ? 'passed' : totalFailures > 0 ? 'failed' : 'partial';
     // Check coverage (simplified)
     const coverage = await checkTestCoverage(projectPath);
     return {
@@ -217,7 +809,7 @@ async function executeTestSuite(projectPath, _requiredSuites) {
         requiredSuitesMissing: [],
         criticalTestFailures: testSuites.flatMap(suite => suite.failureDetails.filter(f => f.severity === 'critical')),
         testExecutionTime: executionTime,
-        lastTestRun: new Date().toISOString()
+        lastTestRun: new Date().toISOString(),
     };
 }
 /**
@@ -241,7 +833,7 @@ function parseTestOutput(output) {
                 failedTests: 0,
                 coverage: 0,
                 executionTime: 0,
-                failureDetails: []
+                failureDetails: [],
             };
         }
         // Count tests
@@ -258,7 +850,7 @@ function parseTestOutput(output) {
                     errorMessage: line,
                     severity: 'medium',
                     blocksDeployment: true,
-                    relatedFiles: []
+                    relatedFiles: [],
                 });
             }
         }
@@ -266,15 +858,19 @@ function parseTestOutput(output) {
     if (currentSuite.suiteName) {
         suites.push(currentSuite);
     }
-    return suites.length > 0 ? suites : [{
-            suiteName: 'default',
-            status: output.includes('failing') ? 'failed' : 'passed',
-            passedTests: 0,
-            failedTests: output.includes('failing') ? 1 : 0,
-            coverage: 0,
-            executionTime: 0,
-            failureDetails: []
-        }];
+    return suites.length > 0
+        ? suites
+        : [
+            {
+                suiteName: 'default',
+                status: output.includes('failing') ? 'failed' : 'passed',
+                passedTests: 0,
+                failedTests: output.includes('failing') ? 1 : 0,
+                coverage: 0,
+                executionTime: 0,
+                failureDetails: [],
+            },
+        ];
 }
 /**
  * Check test coverage
@@ -285,7 +881,7 @@ async function checkTestCoverage(projectPath) {
         const coverageFiles = [
             'coverage/lcov-report/index.html',
             'coverage/coverage-summary.json',
-            'coverage/coverage-final.json'
+            'coverage/coverage-final.json',
         ];
         for (const file of coverageFiles) {
             const filePath = join(projectPath, file);
@@ -323,10 +919,10 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
                 'Review recent deployment failures',
                 'Fix underlying infrastructure issues',
                 'Improve deployment process reliability',
-                'Add more comprehensive pre-deployment checks'
+                'Add more comprehensive pre-deployment checks',
             ],
             estimatedResolutionTime: '1-2 days',
-            blocksDeployment: args.blockOnRecentFailures
+            blocksDeployment: args.blockOnRecentFailures,
         });
     }
     // Check rollback rate
@@ -341,20 +937,41 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
                 'Improve testing before deployment',
                 'Add more validation steps',
                 'Review rollback causes',
-                'Strengthen deployment pipeline'
+                'Strengthen deployment pipeline',
             ],
             estimatedResolutionTime: '4-8 hours',
-            blocksDeployment: args.strictMode
+            blocksDeployment: args.strictMode,
         });
     }
     return {
         isDeploymentReady: historyBlockers.length === 0,
         overallScore: Math.min(analysis.successRate, 100 - analysis.rollbackRate),
         confidence: 80,
-        codeQualityAnalysis: { qualityScore: 75, productionIndicators: 10, mockIndicators: 2, failingFiles: [], recommendations: [] },
-        testValidationResult: { testSuitesExecuted: [], overallTestStatus: 'not_run', failureCount: 0, coveragePercentage: 0, requiredSuitesMissing: [], criticalTestFailures: [], testExecutionTime: 0, lastTestRun: '' },
+        codeQualityAnalysis: {
+            qualityScore: 75,
+            productionIndicators: 10,
+            mockIndicators: 2,
+            failingFiles: [],
+            recommendations: [],
+        },
+        testValidationResult: {
+            testSuitesExecuted: [],
+            overallTestStatus: 'not_run',
+            failureCount: 0,
+            coveragePercentage: 0,
+            requiredSuitesMissing: [],
+            criticalTestFailures: [],
+            testExecutionTime: 0,
+            lastTestRun: '',
+        },
         deploymentHistoryAnalysis: analysis,
-        adrComplianceResult: { score: 100, compliantAdrs: 0, totalAdrs: 0, missingImplementations: [], recommendations: [] },
+        adrComplianceResult: {
+            score: 100,
+            compliantAdrs: 0,
+            totalAdrs: 0,
+            missingImplementations: [],
+            recommendations: [],
+        },
         criticalBlockers: historyBlockers.filter(b => b.severity === 'critical'),
         testFailureBlockers: [],
         deploymentHistoryBlockers: historyBlockers,
@@ -362,7 +979,7 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: historyBlockers.length === 0 ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
     };
 }
 /**
@@ -399,7 +1016,7 @@ function analyzeDeploymentHistory(history, environment) {
         averageDeploymentTime: calculateAverageDeploymentTime(recentDeployments),
         failurePatterns,
         environmentStability: assessEnvironmentStability(successRate, rollbackRate),
-        recommendedAction: recommendAction(successRate, rollbackRate, failurePatterns.length)
+        recommendedAction: recommendAction(successRate, rollbackRate, failurePatterns.length),
     };
 }
 /**
@@ -422,7 +1039,7 @@ function analyzeFailurePatterns(failedDeployments) {
                     environments: [deployment.environment],
                     lastOccurrence: deployment.timestamp,
                     resolution: suggestResolution(category),
-                    preventable: isPreventable(category)
+                    preventable: isPreventable(category),
                 });
             }
         }
@@ -439,7 +1056,7 @@ async function performFullAudit(args, projectPath, historyPath) {
     const allBlockers = [
         ...testResult.criticalBlockers,
         ...testResult.testFailureBlockers,
-        ...historyResult.deploymentHistoryBlockers
+        ...historyResult.deploymentHistoryBlockers,
     ];
     const overallScore = (testResult.overallScore + historyResult.overallScore) / 2;
     const isReady = allBlockers.length === 0;
@@ -458,7 +1075,7 @@ async function performFullAudit(args, projectPath, historyPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: isReady ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
     };
 }
 /**
@@ -473,7 +1090,7 @@ async function performEmergencyOverride(args, projectPath) {
         timestamp: new Date().toISOString(),
         justification: args.businessJustification || 'No justification provided',
         environment: args.targetEnvironment,
-        overriddenBy: process.env['USER'] || 'unknown'
+        overriddenBy: process.env['USER'] || 'unknown',
     };
     const overridePath = join(projectPath, '.mcp-adr-cache', 'emergency-overrides.json');
     const overrides = existsSync(overridePath) ? JSON.parse(readFileSync(overridePath, 'utf8')) : [];
@@ -483,10 +1100,43 @@ async function performEmergencyOverride(args, projectPath) {
         isDeploymentReady: true,
         overallScore: 100,
         confidence: 50, // Lower confidence for overrides
-        codeQualityAnalysis: { qualityScore: 100, productionIndicators: 0, mockIndicators: 0, failingFiles: [], recommendations: ['Emergency override active - review post-deployment'] },
-        testValidationResult: { testSuitesExecuted: [], overallTestStatus: 'not_run', failureCount: 0, coveragePercentage: 0, requiredSuitesMissing: [], criticalTestFailures: [], testExecutionTime: 0, lastTestRun: '' },
-        deploymentHistoryAnalysis: { recentDeployments: [], successRate: 100, rollbackRate: 0, averageDeploymentTime: 0, failurePatterns: [], environmentStability: { stabilityScore: 50, riskLevel: 'medium', recommendation: 'Monitor closely post-deployment' }, recommendedAction: 'proceed' },
-        adrComplianceResult: { score: 100, compliantAdrs: 0, totalAdrs: 0, missingImplementations: [], recommendations: [] },
+        codeQualityAnalysis: {
+            qualityScore: 100,
+            productionIndicators: 0,
+            mockIndicators: 0,
+            failingFiles: [],
+            recommendations: ['Emergency override active - review post-deployment'],
+        },
+        testValidationResult: {
+            testSuitesExecuted: [],
+            overallTestStatus: 'not_run',
+            failureCount: 0,
+            coveragePercentage: 0,
+            requiredSuitesMissing: [],
+            criticalTestFailures: [],
+            testExecutionTime: 0,
+            lastTestRun: '',
+        },
+        deploymentHistoryAnalysis: {
+            recentDeployments: [],
+            successRate: 100,
+            rollbackRate: 0,
+            averageDeploymentTime: 0,
+            failurePatterns: [],
+            environmentStability: {
+                stabilityScore: 50,
+                riskLevel: 'medium',
+                recommendation: 'Monitor closely post-deployment',
+            },
+            recommendedAction: 'proceed',
+        },
+        adrComplianceResult: {
+            score: 100,
+            compliantAdrs: 0,
+            totalAdrs: 0,
+            missingImplementations: [],
+            recommendations: [],
+        },
         criticalBlockers: [],
         testFailureBlockers: [],
         deploymentHistoryBlockers: [],
@@ -494,14 +1144,14 @@ async function performEmergencyOverride(args, projectPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: 'allowed',
-        overrideStatus: overrideRecord
+        overrideStatus: overrideRecord,
     };
 }
 /**
  * Helper functions
  */
 function calculateTestScore(testResult, _args) {
-    const failureScore = Math.max(0, 100 - (testResult.failureCount * 20));
+    const failureScore = Math.max(0, 100 - testResult.failureCount * 20);
     const coverageScore = testResult.coveragePercentage;
     return Math.min(failureScore, coverageScore);
 }
@@ -525,7 +1175,7 @@ function assessEnvironmentStability(successRate, rollbackRate) {
     return {
         stabilityScore,
         riskLevel,
-        recommendation: riskLevel === 'low' ? 'Proceed with deployment' : 'Investigate before deployment'
+        recommendation: riskLevel === 'low' ? 'Proceed with deployment' : 'Investigate before deployment',
     };
 }
 function recommendAction(successRate, rollbackRate, failurePatternCount) {
@@ -544,7 +1194,7 @@ function categorizeFailure(failureReason) {
         { regex: /dependency.*error/i, category: 'Dependency Issues' },
         { regex: /timeout/i, category: 'Timeout Issues' },
         { regex: /permission.*denied/i, category: 'Permission Issues' },
-        { regex: /out.*of.*memory/i, category: 'Resource Issues' }
+        { regex: /out.*of.*memory/i, category: 'Resource Issues' },
     ];
     for (const pattern of patterns) {
         if (pattern.regex.test(failureReason)) {
@@ -562,7 +1212,7 @@ function suggestResolution(category) {
         'Dependency Issues': 'Update and verify package dependencies',
         'Timeout Issues': 'Optimize performance and increase timeout values',
         'Permission Issues': 'Check file and directory permissions',
-        'Resource Issues': 'Increase available memory and resources'
+        'Resource Issues': 'Increase available memory and resources',
     };
     return resolutions[category] || 'Investigate failure details and resolve underlying issue';
 }
@@ -571,7 +1221,7 @@ function isPreventable(category) {
         'Test Failures',
         'Environment Configuration',
         'Build Failures',
-        'Dependency Issues'
+        'Dependency Issues',
     ];
     return preventableCategories.includes(category);
 }
@@ -588,7 +1238,8 @@ function generateDeploymentReadinessResponse(result, args) {
 }
 function generateSuccessResponse(result, args) {
     return validateMcpResponse({
-        content: [{
+        content: [
+            {
                 type: 'text',
                 text: `✅ **DEPLOYMENT READY - All Gates Passed**
 
@@ -612,18 +1263,22 @@ function generateSuccessResponse(result, args) {
 ## 🚀 Deployment Approved
 ${args.triggerSmartGitPush ? 'Triggering smart git push...' : 'Ready to proceed with deployment'}
 
-${result.warnings.length > 0 ? `
+${result.warnings.length > 0
+                    ? `
 ## ⚠️ Warnings
 ${result.warnings.map(w => `- ${w}`).join('\n')}
-` : ''}
+`
+                    : ''}
 
-**✅ DEPLOYMENT CAN PROCEED SAFELY**`
-            }]
+**✅ DEPLOYMENT CAN PROCEED SAFELY**`,
+            },
+        ],
     });
 }
 function generateBlockedResponse(result, args) {
     return validateMcpResponse({
-        content: [{
+        content: [
+            {
                 type: 'text',
                 text: `🚨 **DEPLOYMENT BLOCKED - Critical Issues Found**
 
@@ -634,30 +1289,36 @@ function generateBlockedResponse(result, args) {
 - **Target Environment**: ${args.targetEnvironment}
 
 ## 🧪 Test Validation Issues
-${result.testFailureBlockers.length > 0 ? `
+${result.testFailureBlockers.length > 0
+                    ? `
 **Test Failures**: ${result.testValidationResult.failureCount} failures detected
 **Coverage**: ${result.testValidationResult.coveragePercentage}% (Required: ${args.requireTestCoverage}%)
 
 ### Critical Test Failures:
 ${result.testValidationResult.criticalTestFailures.map(f => `- ❌ ${f.testSuite}: ${f.testName}`).join('\n')}
-` : '✅ Tests passing'}
+`
+                    : '✅ Tests passing'}
 
 ## 📊 Deployment History Issues
-${result.deploymentHistoryBlockers.length > 0 ? `
+${result.deploymentHistoryBlockers.length > 0
+                    ? `
 **Success Rate**: ${result.deploymentHistoryAnalysis.successRate}% (Required: ${args.deploymentSuccessThreshold}%)
 **Rollback Rate**: ${result.deploymentHistoryAnalysis.rollbackRate}% (Threshold: ${args.rollbackFrequencyThreshold}%)
 
 ### Recent Failure Patterns:
 ${result.deploymentHistoryAnalysis.failurePatterns.map(p => `- **${p.pattern}**: ${p.frequency} occurrences`).join('\n')}
-` : '✅ Deployment history stable'}
+`
+                    : '✅ Deployment history stable'}
 
 ## 🚨 Critical Blockers (Must Fix Before Deployment)
-${result.criticalBlockers.map(blocker => `
+${result.criticalBlockers
+                    .map(blocker => `
 ### ${blocker.category.toUpperCase()}: ${blocker.title}
 - **Impact**: ${blocker.impact}
 - **Resolution**: ${blocker.resolutionSteps.join(' → ')}
 - **Estimated Time**: ${blocker.estimatedResolutionTime}
-`).join('\n')}
+`)
+                    .join('\n')}
 
 ## 🛠️ Immediate Actions Required
 
@@ -689,8 +1350,9 @@ For critical fixes only:
 deployment_readiness --operation emergency_override --business-justification "Your justification"
 \`\`\`
 
-**❌ DEPLOYMENT CANNOT PROCEED UNTIL ALL CRITICAL BLOCKERS ARE RESOLVED**`
-            }]
+**❌ DEPLOYMENT CANNOT PROCEED UNTIL ALL CRITICAL BLOCKERS ARE RESOLVED**`,
+            },
+        ],
     });
 }
 //# sourceMappingURL=deployment-readiness-tool.js.map