mcp-adr-analysis-server 2.0.24 → 2.1.0

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

@@ -23,11 +23,14 @@ 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
@@ -94,6 +97,15 @@ const DeploymentReadinessSchema = z.object({
         .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
@@ -569,7 +581,8 @@ 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
@@ -722,13 +735,7 @@ 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: [],
@@ -895,7 +902,7 @@ async function checkTestCoverage(projectPath) {
             }
         }
     }
-    catch (error) {
+    catch {
         // Coverage not available
     }
     return 0; // Default to 0 if coverage cannot be determined
@@ -947,13 +954,7 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
         isDeploymentReady: historyBlockers.length === 0,
         overallScore: Math.min(analysis.successRate, 100 - analysis.rollbackRate),
         confidence: 80,
-        codeQualityAnalysis: {
-            qualityScore: 75,
-            productionIndicators: 10,
-            mockIndicators: 2,
-            failingFiles: [],
-            recommendations: [],
-        },
+        codeQualityAnalysis: await analyzeCodeQualityWithTreeSitter(args.projectPath || process.cwd(), args.enableTreeSitterAnalysis, args.treeSitterLanguages),
         testValidationResult: {
             testSuitesExecuted: [],
             overallTestStatus: 'not_run',
@@ -993,7 +994,7 @@ function loadDeploymentHistory(historyPath) {
         const content = readFileSync(historyPath, 'utf8');
         return JSON.parse(content);
     }
-    catch (error) {
+    catch {
         return { deployments: [] };
     }
 }
@@ -1053,6 +1054,108 @@ 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,
@@ -1060,14 +1163,14 @@ async function performFullAudit(args, projectPath, historyPath) {
     ];
     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,
@@ -1076,7 +1179,9 @@ async function performFullAudit(args, projectPath, historyPath) {
         healthScoreUpdate: {},
         gitPushStatus: isReady ? 'allowed' : 'blocked',
         overrideStatus: {},
+        smartCodeAnalysis, // Include Smart Code Linking analysis
     };
+    return result;
 }
 /**
  * Perform emergency override
@@ -1092,7 +1197,9 @@ async function performEmergencyOverride(args, projectPath) {
         environment: args.targetEnvironment,
         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));
@@ -1100,13 +1207,7 @@ 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'],
-        },
+        codeQualityAnalysis: createDefaultCodeQualityAnalysis(100, 0, 0),
         testValidationResult: {
             testSuitesExecuted: [],
             overallTestStatus: 'not_run',
@@ -1248,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()}
@@ -1260,6 +1362,13 @@ 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'}
 
@@ -1280,13 +1389,15 @@ function generateBlockedResponse(result, args) {
         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
@@ -1310,6 +1421,8 @@ ${result.deploymentHistoryAnalysis.failurePatterns.map(p => `- **${p.pattern}**:
 `
                     : '✅ Deployment history stable'}
 
+${result.smartCodeAnalysis || ''}
+
 ## 🚨 Critical Blockers (Must Fix Before Deployment)
 ${result.criticalBlockers
                     .map(blocker => `
@@ -1344,15 +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