mcp-adr-analysis-server 2.0.21 → 2.1.0

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

@@ -1,56 +1,87 @@
 /**
- * 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';
 import { execSync } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
+import * as os from 'os';
 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';
+import { TreeSitterAnalyzer } from '../utils/tree-sitter-analyzer.js';
+import { findFiles, findRelatedCode } from '../utils/file-system.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 +90,489 @@ 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'),
+    // Tree-sitter Analysis
+    enableTreeSitterAnalysis: z
+        .boolean()
+        .default(true)
+        .describe('Use tree-sitter for enhanced code analysis'),
+    treeSitterLanguages: z
+        .array(z.string())
+        .default(['typescript', 'javascript', 'python', 'yaml', 'hcl'])
+        .describe('Languages to analyze with tree-sitter'),
 });
+/**
+ * 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
  */
@@ -69,13 +581,24 @@ export async function deploymentReadiness(args) {
         const validatedArgs = DeploymentReadinessSchema.parse(args);
         // Initialize paths and cache
         const projectPath = validatedArgs.projectPath || process.cwd();
-        const cacheDir = join(projectPath, '.mcp-adr-cache');
+        const projectName = basename(projectPath);
+        const cacheDir = join(os.tmpdir(), projectName, 'cache');
         const deploymentHistoryPath = join(cacheDir, 'deployment-history.json');
         const readinessCachePath = join(cacheDir, 'deployment-readiness-cache.json');
         // Ensure cache directory exists
         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 +622,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 +707,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 +724,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 +735,28 @@ 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: await analyzeCodeQualityWithTreeSitter(args.projectPath || process.cwd(), args.enableTreeSitterAnalysis, args.treeSitterLanguages),
         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 +764,7 @@ async function performTestValidation(args, projectPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: testBlockers.length === 0 ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
     };
 }
 /**
@@ -183,7 +782,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 +805,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 +816,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 +840,7 @@ function parseTestOutput(output) {
                 failedTests: 0,
                 coverage: 0,
                 executionTime: 0,
-                failureDetails: []
+                failureDetails: [],
             };
         }
         // Count tests
@@ -258,7 +857,7 @@ function parseTestOutput(output) {
                     errorMessage: line,
                     severity: 'medium',
                     blocksDeployment: true,
-                    relatedFiles: []
+                    relatedFiles: [],
                 });
             }
         }
@@ -266,15 +865,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 +888,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);
@@ -299,7 +902,7 @@ async function checkTestCoverage(projectPath) {
             }
         }
     }
-    catch (error) {
+    catch {
         // Coverage not available
     }
     return 0; // Default to 0 if coverage cannot be determined
@@ -323,10 +926,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 +944,35 @@ 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: await analyzeCodeQualityWithTreeSitter(args.projectPath || process.cwd(), args.enableTreeSitterAnalysis, args.treeSitterLanguages),
+        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 +980,7 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: historyBlockers.length === 0 ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
     };
 }
 /**
@@ -376,7 +994,7 @@ function loadDeploymentHistory(historyPath) {
         const content = readFileSync(historyPath, 'utf8');
         return JSON.parse(content);
     }
-    catch (error) {
+    catch {
         return { deployments: [] };
     }
 }
@@ -399,7 +1017,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 +1040,7 @@ function analyzeFailurePatterns(failedDeployments) {
                     environments: [deployment.environment],
                     lastOccurrence: deployment.timestamp,
                     resolution: suggestResolution(category),
-                    preventable: isPreventable(category)
+                    preventable: isPreventable(category),
                 });
             }
         }
@@ -436,21 +1054,123 @@ async function performFullAudit(args, projectPath, historyPath) {
     // Combine all validations
     const testResult = await performTestValidation(args, projectPath);
     const historyResult = await performDeploymentHistoryAnalysis(args, historyPath);
+    // Smart Code Linking - Enhanced deployment readiness with ADR analysis
+    let smartCodeAnalysis = '';
+    let adrComplianceResult = testResult.adrComplianceResult;
+    if (args.requireAdrCompliance) {
+        try {
+            // Discover ADRs in the project
+            const { discoverAdrsInDirectory } = await import('../utils/adr-discovery.js');
+            const adrDirectory = 'docs/adrs';
+            const discoveryResult = await discoverAdrsInDirectory(adrDirectory, true, projectPath);
+            if (discoveryResult.adrs.length > 0) {
+                // Combine all ADR content for Smart Code Linking analysis
+                const combinedAdrContent = discoveryResult.adrs
+                    .map(adr => `# ${adr.title}\n${adr.content || ''}`)
+                    .join('\n\n');
+                const relatedCodeResult = await findRelatedCode('deployment-readiness-analysis', combinedAdrContent, projectPath, {
+                    useAI: true,
+                    useRipgrep: true,
+                    maxFiles: 25,
+                    includeContent: false,
+                });
+                // Enhanced ADR compliance analysis with related code context
+                const deploymentCriticalFiles = relatedCodeResult.relatedFiles.filter(file => {
+                    const deploymentKeywords = [
+                        'deploy',
+                        'config',
+                        'env',
+                        'docker',
+                        'k8s',
+                        'terraform',
+                        'ci',
+                        'cd',
+                    ];
+                    return deploymentKeywords.some(keyword => file.path.toLowerCase().includes(keyword) ||
+                        file.directory.toLowerCase().includes(keyword));
+                });
+                adrComplianceResult = {
+                    score: Math.min(100, 70 + relatedCodeResult.confidence * 30),
+                    compliantAdrs: discoveryResult.adrs.length,
+                    totalAdrs: discoveryResult.adrs.length,
+                    missingImplementations: deploymentCriticalFiles.length === 0
+                        ? ['Deployment-specific implementations not found in related code']
+                        : [],
+                    recommendations: [
+                        ...(deploymentCriticalFiles.length > 0
+                            ? [`Found ${deploymentCriticalFiles.length} deployment-critical files linked to ADRs`]
+                            : ['Consider documenting deployment procedures in ADRs']),
+                        ...(relatedCodeResult.relatedFiles.length > 10
+                            ? ['High code-ADR linkage indicates good architectural documentation']
+                            : ['Consider improving ADR-to-code traceability']),
+                        ...(relatedCodeResult.confidence > 0.8
+                            ? ['Strong architectural alignment detected between ADRs and implementation']
+                            : ['Review ADR implementation alignment before deployment']),
+                    ],
+                };
+                smartCodeAnalysis = `
+
+## 🔗 Smart Code Linking - Deployment Analysis
+
+**ADR Discovery**: Found ${discoveryResult.adrs.length} architectural decision records
+**Related Code Files**: ${relatedCodeResult.relatedFiles.length} files linked to ADRs
+**Deployment-Critical Files**: ${deploymentCriticalFiles.length} files identified
+
+### Deployment-Critical Code Analysis
+${deploymentCriticalFiles.length > 0
+                    ? deploymentCriticalFiles
+                        .slice(0, 5)
+                        .map((file, index) => `${index + 1}. **${file.path}** - ${file.extension} file (${file.size} bytes)`)
+                        .join('\n')
+                    : '*No deployment-specific files found in ADR-related code*'}
+
+### Architectural Alignment
+- **ADR-Code Confidence**: ${(relatedCodeResult.confidence * 100).toFixed(1)}%
+- **Keywords Used**: ${relatedCodeResult.keywords.join(', ')}
+- **Implementation Coverage**: ${relatedCodeResult.relatedFiles.length > 0 ? 'Adequate' : 'Needs Review'}
+
+**Deployment Impact**: ${deploymentCriticalFiles.length > 0
+                    ? 'ADR-guided deployment files found - architectural decisions are implemented'
+                    : 'Limited deployment-specific code found - verify manual deployment procedures'}
+`;
+            }
+            else {
+                smartCodeAnalysis = `
+
+## 🔗 Smart Code Linking - Deployment Analysis
+
+**Status**: No ADRs found in project
+**Recommendation**: Consider creating ADRs to document deployment architecture and decisions
+**Impact**: Proceeding with deployment readiness check without architectural guidance
+`;
+            }
+        }
+        catch (error) {
+            console.warn('[WARNING] Smart Code Linking for deployment analysis failed:', error);
+            smartCodeAnalysis = `
+
+## 🔗 Smart Code Linking - Deployment Analysis
+
+**Status**: ⚠️ ADR analysis failed - continuing with standard deployment checks
+**Error**: ${error instanceof Error ? error.message : 'Unknown error'}
+`;
+        }
+    }
     const allBlockers = [
         ...testResult.criticalBlockers,
         ...testResult.testFailureBlockers,
-        ...historyResult.deploymentHistoryBlockers
+        ...historyResult.deploymentHistoryBlockers,
     ];
     const overallScore = (testResult.overallScore + historyResult.overallScore) / 2;
     const isReady = allBlockers.length === 0;
-    return {
+    const result = {
         isDeploymentReady: isReady,
         overallScore,
         confidence: Math.min(testResult.confidence, historyResult.confidence),
         codeQualityAnalysis: testResult.codeQualityAnalysis,
         testValidationResult: testResult.testValidationResult,
         deploymentHistoryAnalysis: historyResult.deploymentHistoryAnalysis,
-        adrComplianceResult: testResult.adrComplianceResult,
+        adrComplianceResult,
         criticalBlockers: allBlockers.filter(b => b.severity === 'critical'),
         testFailureBlockers: testResult.testFailureBlockers,
         deploymentHistoryBlockers: historyResult.deploymentHistoryBlockers,
@@ -458,8 +1178,10 @@ async function performFullAudit(args, projectPath, historyPath) {
         todoTasksCreated: [],
         healthScoreUpdate: {},
         gitPushStatus: isReady ? 'allowed' : 'blocked',
-        overrideStatus: {}
+        overrideStatus: {},
+        smartCodeAnalysis, // Include Smart Code Linking analysis
     };
+    return result;
 }
 /**
  * Perform emergency override
@@ -473,9 +1195,11 @@ 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 projectName = basename(projectPath);
+    const cacheDir = join(os.tmpdir(), projectName, 'cache');
+    const overridePath = join(cacheDir, 'emergency-overrides.json');
     const overrides = existsSync(overridePath) ? JSON.parse(readFileSync(overridePath, 'utf8')) : [];
     overrides.push(overrideRecord);
     writeFileSync(overridePath, JSON.stringify(overrides, null, 2));
@@ -483,10 +1207,37 @@ 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: createDefaultCodeQualityAnalysis(100, 0, 0),
+        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 +1245,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 +1276,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 +1295,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 +1313,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 +1322,7 @@ function isPreventable(category) {
         'Test Failures',
         'Environment Configuration',
         'Build Failures',
-        'Dependency Issues'
+        'Dependency Issues',
     ];
     return preventableCategories.includes(category);
 }
@@ -588,7 +1339,8 @@ function generateDeploymentReadinessResponse(result, args) {
 }
 function generateSuccessResponse(result, args) {
     return validateMcpResponse({
-        content: [{
+        content: [
+            {
                 type: 'text',
                 text: `✅ **DEPLOYMENT READY - All Gates Passed**
 
@@ -597,6 +1349,7 @@ function generateSuccessResponse(result, args) {
 - **Readiness Score**: ${result.overallScore}%
 - **Confidence**: ${result.confidence}%
 - **Target Environment**: ${args.targetEnvironment}
+- **Fast File Discovery**: ✅ Enhanced with fast-glob
 
 ## 🧪 Test Validation
 - **Test Status**: ✅ ${result.testValidationResult.overallTestStatus.toUpperCase()}
@@ -609,55 +1362,76 @@ function generateSuccessResponse(result, args) {
 - **Rollback Rate**: ${result.deploymentHistoryAnalysis.rollbackRate}%
 - **Environment Stability**: ${result.deploymentHistoryAnalysis.environmentStability.riskLevel}
 
+## 🏛️ ADR Compliance
+- **Compliance Score**: ${result.adrComplianceResult.score}%
+- **ADRs Analyzed**: ${result.adrComplianceResult.compliantAdrs}/${result.adrComplianceResult.totalAdrs}
+- **Missing Implementations**: ${result.adrComplianceResult.missingImplementations.length} items
+
+${result.smartCodeAnalysis || ''}
+
 ## 🚀 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**
+                text: `# 🚨 DEPLOYMENT BLOCKED - Critical Issues Detected
 
-## 🎯 Overall Assessment
-- **Deployment Ready**: ❌ **NO**
-- **Readiness Score**: ${result.overallScore}%
+## ⚠️ Deployment Readiness: ${result.isDeploymentReady ? '✅ READY' : '❌ BLOCKED'}
+- **Overall Score**: ${result.overallScore}/100
 - **Confidence**: ${result.confidence}%
 - **Target Environment**: ${args.targetEnvironment}
+- **Tree-sitter Analysis**: ${args.enableTreeSitterAnalysis ? '✅ Enhanced' : '❌ Basic'}
+- **Fast File Discovery**: ✅ Enhanced with fast-glob
+- **Smart Code Linking**: ${args.requireAdrCompliance ? '✅ ADR Analysis Enabled' : '❌ Disabled'}
 
 ## 🧪 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'}
+
+${result.smartCodeAnalysis || ''}
 
 ## 🚨 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
 
@@ -683,14 +1457,164 @@ npm run test:coverage
 deployment_readiness --operation full_audit --target-environment ${args.targetEnvironment}
 \`\`\`
 
-## ⚠️ Emergency Override
-For critical fixes only:
+### 3. Emergency Override (If Justified)
 \`\`\`bash
-deployment_readiness --operation emergency_override --business-justification "Your justification"
+# Only if business critical and approved
+npm run deploy:emergency -- --justification="Critical security fix"
 \`\`\`
 
-**❌ DEPLOYMENT CANNOT PROCEED UNTIL ALL CRITICAL BLOCKERS ARE RESOLVED**`
-            }]
+**⚠️ WARNING**: Emergency overrides bypass safety checks. Use only when absolutely necessary.
+`,
+            },
+        ],
     });
 }
+/**
+ * Create default CodeQualityAnalysis structure
+ */
+function createDefaultCodeQualityAnalysis(qualityScore = 75, productionIndicators = 10, mockIndicators = 2) {
+    return {
+        qualityScore,
+        productionIndicators,
+        mockIndicators,
+        failingFiles: [],
+        recommendations: [],
+        securityIssues: [],
+        architecturalViolations: [],
+        codeComplexity: {
+            averageComplexity: 0,
+            highComplexityFiles: [],
+            totalFunctions: 0,
+        },
+        dependencyAnalysis: {
+            dangerousImports: [],
+            frameworksDetected: [],
+            securityLibraries: [],
+        },
+    };
+}
+/**
+ * Perform tree-sitter enhanced code quality analysis
+ */
+async function analyzeCodeQualityWithTreeSitter(projectPath, enableTreeSitter, _languages) {
+    const baseAnalysis = createDefaultCodeQualityAnalysis();
+    if (!enableTreeSitter) {
+        return baseAnalysis;
+    }
+    try {
+        const analyzer = new TreeSitterAnalyzer();
+        // Use fast-glob based file discovery for enhanced performance
+        const findResult = await findFiles(projectPath, ['**/*.{ts,js,py,yml,yaml,tf,hcl,sh}']);
+        // Analyze files (limit to first 20 for performance)
+        const sourceFiles = findResult.files.map(f => f.path);
+        const filesToAnalyze = sourceFiles.slice(0, 20);
+        let totalComplexity = 0;
+        let totalFunctions = 0;
+        const highComplexityFiles = [];
+        for (const filePath of filesToAnalyze) {
+            try {
+                const analysis = await analyzer.analyzeFile(filePath);
+                // Security issues
+                if (analysis.hasSecrets && analysis.secrets.length > 0) {
+                    analysis.secrets.forEach(secret => {
+                        baseAnalysis.securityIssues.push({
+                            type: secret.type,
+                            severity: secret.confidence > 0.8 ? 'high' : secret.confidence > 0.6 ? 'medium' : 'low',
+                            message: `${secret.type} detected: ${secret.context}`,
+                            file: filePath,
+                            line: secret.location.line,
+                        });
+                    });
+                }
+                // Security issues from general analysis
+                if (analysis.securityIssues && analysis.securityIssues.length > 0) {
+                    analysis.securityIssues.forEach(issue => {
+                        baseAnalysis.securityIssues.push({
+                            type: issue.type,
+                            severity: issue.severity,
+                            message: issue.message,
+                            file: filePath,
+                            line: issue.location.line,
+                        });
+                    });
+                }
+                // Dangerous imports
+                if (analysis.imports) {
+                    analysis.imports.forEach(imp => {
+                        if (imp.isDangerous) {
+                            baseAnalysis.dependencyAnalysis.dangerousImports.push({
+                                module: imp.module,
+                                file: filePath,
+                                reason: imp.reason || 'Potentially dangerous import',
+                            });
+                        }
+                        // Detect frameworks
+                        const frameworks = ['express', 'react', 'vue', 'angular', 'fastapi', 'django', 'flask'];
+                        frameworks.forEach(framework => {
+                            if (imp.module.toLowerCase().includes(framework) &&
+                                !baseAnalysis.dependencyAnalysis.frameworksDetected.includes(framework)) {
+                                baseAnalysis.dependencyAnalysis.frameworksDetected.push(framework);
+                            }
+                        });
+                        // Detect security libraries
+                        const securityLibs = ['bcrypt', 'crypto', 'jwt', 'passport', 'helmet'];
+                        securityLibs.forEach(lib => {
+                            if (imp.module.toLowerCase().includes(lib) &&
+                                !baseAnalysis.dependencyAnalysis.securityLibraries.includes(lib)) {
+                                baseAnalysis.dependencyAnalysis.securityLibraries.push(lib);
+                            }
+                        });
+                    });
+                }
+                // Function complexity analysis
+                if (analysis.functions) {
+                    analysis.functions.forEach(func => {
+                        totalFunctions++;
+                        totalComplexity += func.complexity;
+                        if (func.complexity > 10) {
+                            highComplexityFiles.push(`${filePath}:${func.name} (complexity: ${func.complexity})`);
+                        }
+                    });
+                }
+                // Architectural violations (basic detection)
+                if (analysis.architecturalViolations && analysis.architecturalViolations.length > 0) {
+                    analysis.architecturalViolations.forEach(violation => {
+                        baseAnalysis.architecturalViolations.push(`${filePath}: ${violation.message}`);
+                    });
+                }
+            }
+            catch (error) {
+                // Skip files that can't be analyzed
+                console.warn(`Could not analyze file ${filePath}:`, error);
+            }
+        }
+        // Update complexity metrics
+        baseAnalysis.codeComplexity = {
+            averageComplexity: totalFunctions > 0 ? totalComplexity / totalFunctions : 0,
+            highComplexityFiles: highComplexityFiles.slice(0, 10), // Limit to top 10
+            totalFunctions,
+        };
+        // Calculate enhanced quality score
+        let qualityScore = 85; // Base score
+        // Deduct for security issues
+        const criticalSecurity = baseAnalysis.securityIssues.filter(i => i.severity === 'critical').length;
+        const highSecurity = baseAnalysis.securityIssues.filter(i => i.severity === 'high').length;
+        qualityScore -= criticalSecurity * 20 + highSecurity * 10;
+        // Deduct for dangerous imports
+        qualityScore -= Math.min(baseAnalysis.dependencyAnalysis.dangerousImports.length * 5, 20);
+        // Deduct for high complexity
+        qualityScore -= Math.min(highComplexityFiles.length * 2, 15);
+        // Bonus for security libraries
+        qualityScore += Math.min(baseAnalysis.dependencyAnalysis.securityLibraries.length * 2, 10);
+        baseAnalysis.qualityScore = Math.max(0, Math.min(100, qualityScore));
+        // Update production/mock indicators based on analysis
+        baseAnalysis.productionIndicators = Math.max(10, baseAnalysis.qualityScore - 20);
+        baseAnalysis.mockIndicators = Math.max(0, 100 - baseAnalysis.qualityScore) / 10;
+        return baseAnalysis;
+    }
+    catch (error) {
+        console.warn('Tree-sitter analysis failed, using basic analysis:', error);
+        return baseAnalysis;
+    }
+}
 //# sourceMappingURL=deployment-readiness-tool.js.map