mcp-adr-analysis-server 2.7.36 → 2.7.37

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

@@ -118,6 +118,41 @@ const DeploymentReadinessSchema = z.object({
         .default(0.7)
         .describe('Minimum confidence for environment research (0-1)'),
 });
+function unmeasuredAdrCompliance(totalAdrs, reason) {
+    return {
+        measured: false,
+        omittedReason: reason,
+        totalAdrs,
+        missingImplementations: [],
+        recommendations: [],
+    };
+}
+function unmeasuredHistory(reason) {
+    return {
+        recentDeployments: [],
+        measured: false,
+        omittedReason: reason,
+        failurePatterns: [],
+        environmentStability: {
+            measured: false,
+            riskLevel: 'unknown',
+            recommendation: reason,
+        },
+        recommendedAction: 'unknown',
+    };
+}
+function fmtMeasuredPct(value, measured) {
+    return measured && value !== undefined ? `${value}%` : 'not measured';
+}
+function fmtAdrScore(result) {
+    if (!result.measured || result.score === undefined) {
+        return result.omittedReason ? `not measured (${result.omittedReason})` : 'not measured';
+    }
+    return `${result.score}%`;
+}
+function fmtScoreField(value, measured) {
+    return measured ? `${value}%` : 'not measured';
+}
 /**
  * Deployment Memory Manager for tracking deployment assessments and patterns
  * Supports dependency injection for improved testability
@@ -153,14 +188,21 @@ class DeploymentMemoryManager {
                         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
+                        vulnerabilities: readinessData.codeQualityAnalysis.securityIssues.length,
+                        ...(readinessData.codeQualityAnalysis.qualityMeasured
+                            ? {
+                                securityScore: Math.max(0, 1 -
+                                    readinessData.codeQualityAnalysis.securityIssues.filter(i => i.severity === 'critical').length *
+                                        0.3 -
+                                    readinessData.codeQualityAnalysis.securityIssues.filter(i => i.severity === 'high').length *
+                                        0.15),
+                            }
+                            : {}),
                         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: {},
                     },
@@ -197,13 +239,19 @@ class DeploymentMemoryManager {
                         : 'Cannot deploy - blockers present',
                 },
                 complianceChecks: {
-                    adrCompliance: readinessData.adrComplianceResult.score / 100, // Convert to 0-1 range
-                    regulatoryCompliance: [], // Could be enhanced with actual compliance data
+                    ...(readinessData.adrComplianceResult.measured &&
+                        readinessData.adrComplianceResult.score !== undefined
+                        ? { adrCompliance: readinessData.adrComplianceResult.score / 100 }
+                        : {}),
+                    regulatoryCompliance: [],
                     auditTrail: [
                         `Deployment assessment completed at ${new Date().toISOString()}`,
                         `Test validation: ${readinessData.testValidationResult.overallTestStatus}`,
                         `Overall readiness score: ${readinessData.overallScore}%`,
                         `Git push status: ${readinessData.gitPushStatus}`,
+                        readinessData.adrComplianceResult.measured
+                            ? `ADR compliance measured: ${readinessData.adrComplianceResult.score}`
+                            : `ADR compliance omitted: ${readinessData.adrComplianceResult.omittedReason}`,
                     ],
                 },
             };
@@ -219,7 +267,8 @@ class DeploymentMemoryManager {
                     `score-${Math.floor(readinessData.overallScore / 10) * 10}`,
                     ...(readinessData.criticalBlockers.length > 0 ? ['critical-issues'] : []),
                     ...(readinessData.testValidationResult.failureCount > 0 ? ['test-failures'] : []),
-                    ...(readinessData.deploymentHistoryAnalysis.rollbackRate > 20
+                    ...(readinessData.deploymentHistoryAnalysis.rollbackRate !== undefined &&
+                        readinessData.deploymentHistoryAnalysis.rollbackRate > 20
                         ? ['high-rollback-risk']
                         : []),
                 ],
@@ -381,11 +430,9 @@ class DeploymentMemoryManager {
                     },
                 securityValidation: {
                     vulnerabilities: 0,
-                    securityScore: 0.8,
                     criticalIssues: [],
                 },
                 performanceValidation: {
-                    performanceScore: deployment.status === 'success' ? 0.8 : 0.2,
                     bottlenecks: [],
                     resourceUtilization: {},
                 },
@@ -751,29 +798,13 @@ async function performTestValidation(args, projectPath) {
     return {
         isDeploymentReady: testBlockers.length === 0,
         overallScore: calculateTestScore(testResult, args),
-        confidence: 85,
+        scoreMeasured: testResult.overallTestStatus !== 'not_run',
+        confidence: calculateTestScore(testResult, args),
+        confidenceMeasured: testResult.overallTestStatus !== 'not_run',
         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: unmeasuredHistory('test validation does not load deployment history'),
+        adrComplianceResult: unmeasuredAdrCompliance(0, 'ADR compliance is not evaluated on the test-validation path'),
         criticalBlockers: testBlockers.filter(b => b.severity === 'critical'),
         testFailureBlockers: testBlockers,
         deploymentHistoryBlockers: [],
@@ -931,8 +962,10 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
     const history = loadDeploymentHistory(historyPath);
     const analysis = analyzeDeploymentHistory(history, args.targetEnvironment);
     const historyBlockers = [];
-    // Check success rate
-    if (analysis.successRate < args.deploymentSuccessThreshold) {
+    // Check success rate only when history was actually measured
+    if (analysis.measured &&
+        analysis.successRate !== undefined &&
+        analysis.successRate < args.deploymentSuccessThreshold) {
         historyBlockers.push({
             category: 'deployment_history',
             title: 'Low Deployment Success Rate',
@@ -950,7 +983,9 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
         });
     }
     // Check rollback rate
-    if (analysis.rollbackRate > args.rollbackFrequencyThreshold) {
+    if (analysis.measured &&
+        analysis.rollbackRate !== undefined &&
+        analysis.rollbackRate > args.rollbackFrequencyThreshold) {
         historyBlockers.push({
             category: 'deployment_history',
             title: 'High Rollback Frequency',
@@ -969,8 +1004,12 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
     }
     return {
         isDeploymentReady: historyBlockers.length === 0,
-        overallScore: Math.min(analysis.successRate, 100 - analysis.rollbackRate),
-        confidence: 80,
+        overallScore: analysis.measured && analysis.successRate !== undefined
+            ? Math.min(analysis.successRate, 100 - (analysis.rollbackRate ?? 0))
+            : 0,
+        scoreMeasured: analysis.measured,
+        confidence: analysis.measured ? Math.min(100, analysis.recentDeployments.length * 10) : 0,
+        confidenceMeasured: analysis.measured,
         codeQualityAnalysis: await analyzeCodeQualityWithTreeSitter(args.projectPath || process.cwd(), args.enableTreeSitterAnalysis, args.treeSitterLanguages),
         testValidationResult: {
             testSuitesExecuted: [],
@@ -983,13 +1022,7 @@ async function performDeploymentHistoryAnalysis(args, historyPath) {
             lastTestRun: '',
         },
         deploymentHistoryAnalysis: analysis,
-        adrComplianceResult: {
-            score: 100,
-            compliantAdrs: 0,
-            totalAdrs: 0,
-            missingImplementations: [],
-            recommendations: [],
-        },
+        adrComplianceResult: unmeasuredAdrCompliance(0, 'ADR compliance is not evaluated on the history-analysis path'),
         criticalBlockers: historyBlockers.filter(b => b.severity === 'critical'),
         testFailureBlockers: [],
         deploymentHistoryBlockers: historyBlockers,
@@ -1024,11 +1057,15 @@ function analyzeDeploymentHistory(history, environment) {
         .slice(0, 10);
     const successCount = recentDeployments.filter(d => d.status === 'success').length;
     const rollbackCount = recentDeployments.filter(d => d.rollbackRequired).length;
-    const successRate = recentDeployments.length > 0 ? (successCount / recentDeployments.length) * 100 : 100;
-    const rollbackRate = recentDeployments.length > 0 ? (rollbackCount / recentDeployments.length) * 100 : 0;
+    if (recentDeployments.length === 0) {
+        return unmeasuredHistory(`no deployment records for ${environment}`);
+    }
+    const successRate = (successCount / recentDeployments.length) * 100;
+    const rollbackRate = (rollbackCount / recentDeployments.length) * 100;
     const failurePatterns = analyzeFailurePatterns(recentDeployments.filter(d => d.status === 'failed'));
     return {
         recentDeployments,
+        measured: true,
         successRate,
         rollbackRate,
         averageDeploymentTime: calculateAverageDeploymentTime(recentDeployments),
@@ -1172,25 +1209,36 @@ async function performFullAudit(args, projectPath, historyPath) {
                     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']),
-                    ],
-                };
+                adrComplianceResult =
+                    relatedCodeResult.relatedFiles.length === 0
+                        ? {
+                            measured: true,
+                            score: 0,
+                            compliantAdrs: 0,
+                            totalAdrs: discoveryResult.adrs.length,
+                            missingImplementations: [
+                                'No related implementation files found for discovered ADRs',
+                            ],
+                            recommendations: [
+                                'ADR compliance failed: ADRs exist but no linked implementation was found',
+                            ],
+                        }
+                        : {
+                            measured: false,
+                            omittedReason: 'related-code linking is not a per-ADR compliance verdict; refusing to mark every ADR compliant',
+                            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']),
+                                'Do not treat file linkage as ADR compliance',
+                            ],
+                        };
                 smartCodeAnalysis = `
 
 ## 🔗 Smart Code Linking - Deployment Analysis
@@ -1261,11 +1309,43 @@ ${deploymentCriticalFiles.length > 0
             }
         });
     }
+    const adrBlockers = [];
+    if (args.requireAdrCompliance &&
+        adrComplianceResult.measured &&
+        adrComplianceResult.score === 0) {
+        adrBlockers.push({
+            category: 'adr_compliance',
+            title: 'ADR compliance failed',
+            description: adrComplianceResult.missingImplementations.join('; ') ||
+                'ADRs exist but compliance could not be established',
+            severity: 'critical',
+            impact: 'Blocks deployment: architectural decisions are not shown as implemented',
+            resolutionSteps: ['Link ADRs to implementing code', 'Or document why an ADR has no code yet'],
+            estimatedResolutionTime: '1-4 hours',
+            blocksDeployment: true,
+        });
+    }
+    const securityBlockers = [];
+    const criticalSecurity = testResult.codeQualityAnalysis.securityIssues.filter(i => i.severity === 'critical');
+    if (testResult.codeQualityAnalysis.qualityMeasured && criticalSecurity.length > 0) {
+        securityBlockers.push({
+            category: 'code_quality',
+            title: 'Critical security findings',
+            description: `${criticalSecurity.length} critical security issue(s) in scanned files`,
+            severity: 'critical',
+            impact: 'Blocks deployment: security issues were measured, not assumed',
+            resolutionSteps: criticalSecurity.slice(0, 5).map(i => `Fix ${i.type} in ${i.file}`),
+            estimatedResolutionTime: '1-8 hours',
+            blocksDeployment: true,
+        });
+    }
     const allBlockers = [
         ...testResult.criticalBlockers,
         ...testResult.testFailureBlockers,
         ...historyResult.deploymentHistoryBlockers,
         ...environmentBlockers,
+        ...adrBlockers,
+        ...securityBlockers,
     ];
     // Adjust overall score based on environment research confidence
     const baseScore = (testResult.overallScore + historyResult.overallScore) / 2;
@@ -1275,7 +1355,9 @@ ${deploymentCriticalFiles.length > 0
     const result = {
         isDeploymentReady: isReady,
         overallScore,
+        scoreMeasured: testResult.scoreMeasured || historyResult.scoreMeasured,
         confidence: Math.min(testResult.confidence, historyResult.confidence, environmentResearch.confidence * 100),
+        confidenceMeasured: testResult.confidenceMeasured || historyResult.confidenceMeasured,
         codeQualityAnalysis: testResult.codeQualityAnalysis,
         testValidationResult: testResult.testValidationResult,
         deploymentHistoryAnalysis: historyResult.deploymentHistoryAnalysis,
@@ -1316,8 +1398,10 @@ async function performEmergencyOverride(args, projectPath) {
     return {
         isDeploymentReady: true,
         overallScore: 100,
-        confidence: 50, // Lower confidence for overrides
-        codeQualityAnalysis: createDefaultCodeQualityAnalysis(100, 0, 0),
+        scoreMeasured: false,
+        confidence: 0,
+        confidenceMeasured: false,
+        codeQualityAnalysis: createDefaultCodeQualityAnalysis(),
         testValidationResult: {
             testSuitesExecuted: [],
             overallTestStatus: 'not_run',
@@ -1328,26 +1412,8 @@ async function performEmergencyOverride(args, projectPath) {
             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: [],
-        },
+        deploymentHistoryAnalysis: unmeasuredHistory('emergency override bypassed history measurement'),
+        adrComplianceResult: unmeasuredAdrCompliance(0, 'emergency override bypassed ADR compliance measurement'),
         criticalBlockers: [],
         testFailureBlockers: [],
         deploymentHistoryBlockers: [],
@@ -1384,6 +1450,7 @@ function assessEnvironmentStability(successRate, rollbackRate) {
     else
         riskLevel = 'critical';
     return {
+        measured: true,
         stabilityScore,
         riskLevel,
         recommendation: riskLevel === 'low' ? 'Proceed with deployment' : 'Investigate before deployment',
@@ -1456,8 +1523,8 @@ function generateSuccessResponse(result, args) {
 
 ## 🎯 Overall Assessment
 - **Deployment Ready**: ✅ **YES**
-- **Readiness Score**: ${result.overallScore}%
-- **Confidence**: ${result.confidence}%
+- **Readiness Score**: ${fmtScoreField(result.overallScore, result.scoreMeasured)}
+- **Confidence**: ${fmtScoreField(result.confidence, result.confidenceMeasured)}
 - **Target Environment**: ${args.targetEnvironment}
 - **Fast File Discovery**: ✅ Enhanced with fast-glob
 
@@ -1468,13 +1535,13 @@ function generateSuccessResponse(result, args) {
 - **Execution Time**: ${result.testValidationResult.testExecutionTime}ms
 
 ## 📊 Deployment History
-- **Success Rate**: ${result.deploymentHistoryAnalysis.successRate}%
-- **Rollback Rate**: ${result.deploymentHistoryAnalysis.rollbackRate}%
+- **Success Rate**: ${fmtMeasuredPct(result.deploymentHistoryAnalysis.successRate, result.deploymentHistoryAnalysis.measured)}
+- **Rollback Rate**: ${fmtMeasuredPct(result.deploymentHistoryAnalysis.rollbackRate, result.deploymentHistoryAnalysis.measured)}
 - **Environment Stability**: ${result.deploymentHistoryAnalysis.environmentStability.riskLevel}
 
 ## 🏛️ ADR Compliance
-- **Compliance Score**: ${result.adrComplianceResult.score}%
-- **ADRs Analyzed**: ${result.adrComplianceResult.compliantAdrs}/${result.adrComplianceResult.totalAdrs}
+- **Compliance Score**: ${fmtAdrScore(result.adrComplianceResult)}
+- **ADRs Analyzed**: ${result.adrComplianceResult.measured ? `${result.adrComplianceResult.compliantAdrs}/${result.adrComplianceResult.totalAdrs}` : `not measured (${result.adrComplianceResult.totalAdrs} discovered)`}
 - **Missing Implementations**: ${result.adrComplianceResult.missingImplementations.length} items
 
 ${result.environmentResearch
@@ -1525,8 +1592,8 @@ function generateBlockedResponse(result, args) {
                 text: `# 🚨 DEPLOYMENT BLOCKED - Critical Issues Detected
 
 ## ⚠️ Deployment Readiness: ${result.isDeploymentReady ? '✅ READY' : '❌ BLOCKED'}
-- **Overall Score**: ${result.overallScore}/100
-- **Confidence**: ${result.confidence}%
+- **Overall Score**: ${result.scoreMeasured ? `${result.overallScore}/100` : 'not measured'}
+- **Confidence**: ${fmtScoreField(result.confidence, result.confidenceMeasured)}
 - **Target Environment**: ${args.targetEnvironment}
 - **Tree-sitter Analysis**: ${args.enableTreeSitterAnalysis ? '✅ Enhanced' : '❌ Basic'}
 - **Fast File Discovery**: ✅ Enhanced with fast-glob
@@ -1556,8 +1623,8 @@ ${result.testValidationResult.criticalTestFailures.map(f => `- ❌ ${f.testSuite
 ## 📊 Deployment History Issues
 ${result.deploymentHistoryBlockers.length > 0
                     ? `
-**Success Rate**: ${result.deploymentHistoryAnalysis.successRate}% (Required: ${args.deploymentSuccessThreshold}%)
-**Rollback Rate**: ${result.deploymentHistoryAnalysis.rollbackRate}% (Threshold: ${args.rollbackFrequencyThreshold}%)
+**Success Rate**: ${fmtMeasuredPct(result.deploymentHistoryAnalysis.successRate, result.deploymentHistoryAnalysis.measured)} (Required: ${args.deploymentSuccessThreshold}%)
+**Rollback Rate**: ${fmtMeasuredPct(result.deploymentHistoryAnalysis.rollbackRate, result.deploymentHistoryAnalysis.measured)} (Threshold: ${args.rollbackFrequencyThreshold}%)
 
 ### Recent Failure Patterns:
 ${result.deploymentHistoryAnalysis.failurePatterns.map(p => `- **${p.pattern}**: ${p.frequency} occurrences`).join('\n')}
@@ -1638,11 +1705,10 @@ npm run deploy:emergency -- --justification="Critical security fix"
 /**
  * Create default CodeQualityAnalysis structure
  */
-function createDefaultCodeQualityAnalysis(qualityScore = 75, productionIndicators = 10, mockIndicators = 2) {
+function createDefaultCodeQualityAnalysis() {
     return {
-        qualityScore,
-        productionIndicators,
-        mockIndicators,
+        qualityMeasured: false,
+        indicatorsMeasured: false,
         failingFiles: [],
         recommendations: [],
         securityIssues: [],
@@ -1676,9 +1742,21 @@ async function analyzeCodeQualityWithTreeSitter(projectPath, enableTreeSitter, _
         const filesToAnalyze = sourceFiles.slice(0, 20);
         let totalComplexity = 0;
         let totalFunctions = 0;
+        let productionIndicators = 0;
+        let mockIndicators = 0;
         const highComplexityFiles = [];
         for (const filePath of filesToAnalyze) {
             try {
+                const pathLower = filePath.toLowerCase();
+                if (pathLower.includes('mock') ||
+                    pathLower.includes('.test.') ||
+                    pathLower.includes('.spec.') ||
+                    pathLower.includes('__tests__')) {
+                    mockIndicators++;
+                }
+                else {
+                    productionIndicators++;
+                }
                 const analysis = await analyzer.analyzeFile(filePath);
                 // Security issues
                 if (analysis.hasSecrets && analysis.secrets.length > 0) {
@@ -1760,22 +1838,19 @@ async function analyzeCodeQualityWithTreeSitter(projectPath, enableTreeSitter, _
             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;
+        const qualityScore = Math.max(0, Math.min(100, 100 -
+            criticalSecurity * 20 -
+            highSecurity * 10 -
+            Math.min(baseAnalysis.dependencyAnalysis.dangerousImports.length * 5, 20) -
+            Math.min(highComplexityFiles.length * 2, 15) +
+            Math.min(baseAnalysis.dependencyAnalysis.securityLibraries.length * 2, 10)));
+        baseAnalysis.qualityScore = qualityScore;
+        baseAnalysis.qualityMeasured = true;
+        baseAnalysis.productionIndicators = productionIndicators;
+        baseAnalysis.mockIndicators = mockIndicators;
+        baseAnalysis.indicatorsMeasured = true;
         return baseAnalysis;
     }
     catch (error) {