mcp-adr-analysis-server 2.0.21 → 2.0.24

package/dist/src/tools/environment-analysis-tool.js

@@ -2,16 +2,375 @@
  * MCP Tool for environment context analysis
  * Implements prompt-driven environment analysis and compliance assessment
  * Enhanced with Generated Knowledge Prompting (GKP) for DevOps and infrastructure expertise
+ * Now includes memory integration for environment snapshot tracking and evolution analysis
  */
 import { McpAdrError } from '../types/index.js';
+import { MemoryEntityManager } from '../utils/memory-entity-manager.js';
+import { EnhancedLogger } from '../utils/enhanced-logging.js';
+/**
+ * Environment Memory Manager for tracking environment snapshots and evolution
+ */
+class EnvironmentMemoryManager {
+    memoryManager;
+    logger;
+    constructor() {
+        this.memoryManager = new MemoryEntityManager();
+        this.logger = new EnhancedLogger();
+    }
+    async initialize() {
+        await this.memoryManager.initialize();
+    }
+    /**
+     * Store environment snapshot as memory entity
+     */
+    async storeEnvironmentSnapshot(environmentType, configuration, complianceData, projectPath) {
+        try {
+            const environmentData = {
+                environmentType: environmentType,
+                configuration: {
+                    infrastructure: configuration.infrastructure || {},
+                    containerization: configuration.containerization || {},
+                    cloudServices: configuration.cloudServices || {},
+                    networking: configuration.networking || {},
+                    storage: configuration.storage || {},
+                    security: configuration.security || {},
+                    monitoring: configuration.monitoring || {},
+                    deployment: configuration.deployment || {},
+                },
+                complianceStatus: {
+                    performanceMetrics: complianceData?.performanceMetrics || {},
+                    securityPosture: complianceData?.securityPosture || 0,
+                    adrAlignment: complianceData?.adrAlignment || 0,
+                    lastValidation: new Date().toISOString(),
+                    complianceIssues: complianceData?.violations?.map((v) => v.description) || [],
+                },
+                infrastructureSpecs: {
+                    dependencies: configuration.dependencies || [],
+                    containerization: configuration.containerization || {},
+                    resourceLimits: configuration.resourceLimits || {},
+                    networkConfiguration: configuration.networking || {},
+                    storageConfiguration: configuration.storage || {},
+                },
+                changeHistory: [
+                    {
+                        timestamp: new Date().toISOString(),
+                        changeType: 'configuration',
+                        description: `Environment snapshot created for ${environmentType}`,
+                        impact: 'medium',
+                        author: 'environment-analysis-tool',
+                    },
+                ],
+                recommendations: configuration.recommendations || [],
+                qualityAttributes: configuration.qualityAttributes || {},
+                riskAssessment: configuration.riskAssessment || {},
+                optimizationOpportunities: this.identifyOptimizationOpportunities(configuration),
+                complianceGaps: complianceData?.violations?.map((v) => ({
+                    requirement: v.requirement,
+                    gap: v.description,
+                    severity: v.severity || 'medium',
+                    remediation: v.remediation,
+                })) || [],
+            };
+            const entity = await this.memoryManager.upsertEntity({
+                type: 'environment_snapshot',
+                title: `Environment Snapshot: ${environmentType} - ${new Date().toISOString().split('T')[0]}`,
+                description: `Comprehensive environment analysis snapshot for ${environmentType} environment`,
+                tags: [
+                    'environment',
+                    environmentType.toLowerCase(),
+                    'infrastructure',
+                    complianceData ? 'compliance-assessed' : 'configuration-only',
+                    ...(configuration.containerization?.detected ? ['containerized'] : []),
+                    ...(configuration.cloudServices?.providers?.length > 0 ? ['cloud-native'] : []),
+                ],
+                environmentData,
+                relationships: [],
+                context: {
+                    projectPhase: 'environment-analysis',
+                    technicalStack: this.extractTechnicalStack(configuration),
+                    environmentalFactors: [environmentType, projectPath || 'unknown-project'].filter(Boolean),
+                    stakeholders: ['infrastructure-team', 'devops-team', 'security-team'],
+                },
+                accessPattern: {
+                    lastAccessed: new Date().toISOString(),
+                    accessCount: 1,
+                    accessContext: ['environment-analysis'],
+                },
+                evolution: {
+                    origin: 'created',
+                    transformations: [
+                        {
+                            timestamp: new Date().toISOString(),
+                            type: 'snapshot_creation',
+                            description: `Environment snapshot created for ${environmentType}`,
+                            agent: 'environment-analysis-tool',
+                        },
+                    ],
+                },
+                validation: {
+                    isVerified: Boolean(complianceData && complianceData.overallScore > 70),
+                    verificationMethod: complianceData ? 'compliance-assessment' : 'configuration-analysis',
+                    verificationTimestamp: new Date().toISOString(),
+                },
+            });
+            this.logger.info(`Environment snapshot stored for ${environmentType}`, 'EnvironmentMemoryManager', {
+                environmentType,
+                entityId: entity.id,
+                complianceScore: complianceData?.overallScore,
+                configurationsStored: Object.keys(environmentData.configuration).length,
+            });
+            return entity.id;
+        }
+        catch (error) {
+            this.logger.error('Failed to store environment snapshot', 'EnvironmentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Track configuration changes between snapshots
+     */
+    async trackConfigurationChange(previousSnapshotId, newSnapshotId, changeDescription, changeDetails) {
+        try {
+            // Create relationship between snapshots using relationship creation
+            await this.memoryManager.upsertRelationship({
+                sourceId: previousSnapshotId,
+                targetId: newSnapshotId,
+                type: 'supersedes',
+                strength: 1.0,
+                context: changeDescription,
+                evidence: [JSON.stringify(changeDetails)],
+            });
+            this.logger.info('Configuration change relationship created', 'EnvironmentMemoryManager', {
+                from: previousSnapshotId,
+                to: newSnapshotId,
+                change: changeDescription,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to track configuration change', 'EnvironmentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Analyze environment evolution over time
+     */
+    async analyzeEnvironmentEvolution(environmentType) {
+        try {
+            const snapshots = await this.memoryManager.queryEntities({
+                entityTypes: ['environment_snapshot'],
+                tags: [environmentType.toLowerCase()],
+                limit: 50,
+                sortBy: 'lastModified',
+            });
+            const trends = this.calculateEnvironmentTrends(snapshots.entities);
+            const recommendations = this.generateEvolutionRecommendations(trends);
+            return {
+                snapshots: snapshots.entities,
+                trends,
+                recommendations,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to analyze environment evolution', 'EnvironmentMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Compare current environment with previous snapshots
+     */
+    async compareWithPreviousSnapshots(currentConfiguration, environmentType) {
+        try {
+            const recentSnapshots = await this.memoryManager.queryEntities({
+                entityTypes: ['environment_snapshot'],
+                tags: [environmentType.toLowerCase()],
+                limit: 5,
+                sortBy: 'lastModified',
+            });
+            if (recentSnapshots.entities.length === 0) {
+                return {
+                    hasChanges: true,
+                    changes: ['Initial environment snapshot'],
+                    regressions: [],
+                    improvements: [],
+                };
+            }
+            const lastSnapshot = recentSnapshots.entities[0];
+            const comparison = this.compareConfigurations(lastSnapshot.environmentData?.configuration || {}, currentConfiguration);
+            return comparison;
+        }
+        catch (error) {
+            this.logger.error('Failed to compare with previous snapshots', 'EnvironmentMemoryManager', error);
+            return {
+                hasChanges: true,
+                changes: ['Comparison failed - treating as new snapshot'],
+                regressions: [],
+                improvements: [],
+            };
+        }
+    }
+    // Private helper methods
+    identifyOptimizationOpportunities(configuration) {
+        const opportunities = [];
+        // Containerization opportunities
+        if (!configuration.containerization?.detected) {
+            opportunities.push('Consider containerizing application for better deployment consistency');
+        }
+        // Cloud optimization
+        if (!configuration.cloudServices?.providers?.length) {
+            opportunities.push('Evaluate cloud services adoption for improved scalability');
+        }
+        // Security improvements
+        if (!configuration.security?.httpsEnabled) {
+            opportunities.push('Enable HTTPS for secure communication');
+        }
+        // Monitoring gaps
+        if (!configuration.monitoring?.metrics) {
+            opportunities.push('Implement comprehensive monitoring and metrics collection');
+        }
+        // Performance optimization
+        if (!configuration.deployment?.loadBalancing) {
+            opportunities.push('Consider load balancing for improved performance and availability');
+        }
+        return opportunities;
+    }
+    extractTechnicalStack(configuration) {
+        const stack = [];
+        // Container technologies
+        if (configuration.containerization?.technologies) {
+            stack.push(...configuration.containerization.technologies);
+        }
+        // Cloud providers
+        if (configuration.cloudServices?.providers) {
+            stack.push(...configuration.cloudServices.providers);
+        }
+        // Infrastructure components
+        if (configuration.infrastructure?.components) {
+            stack.push(...Object.keys(configuration.infrastructure.components));
+        }
+        return [...new Set(stack)]; // Remove duplicates
+    }
+    calculateEnvironmentTrends(snapshots) {
+        const trends = [];
+        if (snapshots.length < 2) {
+            return trends;
+        }
+        // Analyze compliance score trends
+        const complianceScores = snapshots
+            .filter(s => s.environmentData.complianceStatus?.overallScore)
+            .map(s => ({
+            timestamp: s.lastModified,
+            score: s.environmentData.complianceStatus.overallScore,
+        }))
+            .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        if (complianceScores.length >= 2) {
+            const latest = complianceScores[complianceScores.length - 1];
+            const previous = complianceScores[complianceScores.length - 2];
+            if (latest && previous) {
+                trends.push({
+                    metric: 'compliance_score',
+                    direction: latest.score > previous.score ? 'improving' : 'declining',
+                    change: latest.score - previous.score,
+                    trend: 'compliance_trend',
+                });
+            }
+        }
+        // Analyze technology adoption trends
+        const techStacks = snapshots.map(s => s.context?.technicalStack || []);
+        const techGrowth = this.calculateTechGrowth(techStacks);
+        if (techGrowth.length > 0) {
+            trends.push({
+                metric: 'technology_adoption',
+                direction: 'expanding',
+                change: techGrowth,
+                trend: 'technology_trend',
+            });
+        }
+        return trends;
+    }
+    calculateTechGrowth(techStacks) {
+        if (techStacks.length < 2)
+            return [];
+        const latest = new Set(techStacks[techStacks.length - 1]);
+        const previous = new Set(techStacks[techStacks.length - 2]);
+        return Array.from(latest).filter(tech => !previous.has(tech));
+    }
+    generateEvolutionRecommendations(trends) {
+        const recommendations = [];
+        trends.forEach(trend => {
+            if (trend.trend === 'compliance_trend') {
+                if (trend.direction === 'declining') {
+                    recommendations.push(`Address compliance regression: score decreased by ${Math.abs(trend.change)} points`);
+                }
+                else {
+                    recommendations.push(`Maintain compliance momentum: score improved by ${trend.change} points`);
+                }
+            }
+            if (trend.trend === 'technology_trend') {
+                recommendations.push(`Document new technology adoption: ${trend.change.join(', ')}`);
+                recommendations.push('Create ADRs for significant technology choices');
+            }
+        });
+        if (recommendations.length === 0) {
+            recommendations.push('Continue regular environment monitoring');
+            recommendations.push('Consider setting up automated compliance checks');
+        }
+        return recommendations;
+    }
+    compareConfigurations(previous, current) {
+        const changes = [];
+        const regressions = [];
+        const improvements = [];
+        // Compare infrastructure components
+        const prevInfra = previous.infrastructure?.components || {};
+        const currInfra = current.infrastructure?.components || {};
+        Object.keys(currInfra).forEach(component => {
+            if (!prevInfra[component]) {
+                changes.push(`Added infrastructure component: ${component}`);
+                improvements.push(`New component improves infrastructure: ${component}`);
+            }
+        });
+        Object.keys(prevInfra).forEach(component => {
+            if (!currInfra[component]) {
+                changes.push(`Removed infrastructure component: ${component}`);
+                regressions.push(`Lost infrastructure component: ${component}`);
+            }
+        });
+        // Compare security settings
+        const prevSecurity = previous.security || {};
+        const currSecurity = current.security || {};
+        if (prevSecurity.httpsEnabled && !currSecurity.httpsEnabled) {
+            changes.push('HTTPS disabled');
+            regressions.push('Security regression: HTTPS disabled');
+        }
+        else if (!prevSecurity.httpsEnabled && currSecurity.httpsEnabled) {
+            changes.push('HTTPS enabled');
+            improvements.push('Security improvement: HTTPS enabled');
+        }
+        return {
+            hasChanges: changes.length > 0,
+            changes,
+            regressions,
+            improvements,
+        };
+    }
+}
 /**
  * Analyze environment context and provide optimization recommendations
  * Enhanced with Generated Knowledge Prompting for DevOps and infrastructure expertise
+ * Now includes memory integration for environment tracking
  */
 export async function analyzeEnvironment(args) {
     const { projectPath = process.cwd(), adrDirectory = 'docs/adrs', analysisType = 'comprehensive', currentEnvironment, requirements, industryStandards, knowledgeEnhancement = true, // Default to GKP enabled
     enhancedMode = true, // Default to enhanced mode
+    enableMemoryIntegration = true, // Default to memory integration enabled
+    environmentType = 'development', // Default environment type
      } = args;
+    // Initialize memory manager if enabled
+    let memoryManager = null;
+    if (enableMemoryIntegration) {
+        memoryManager = new EnvironmentMemoryManager();
+        await memoryManager.initialize();
+    }
     try {
         const { analyzeEnvironmentSpecs, detectContainerization, determineEnvironmentRequirements, assessEnvironmentCompliance, } = await import('../utils/environment-analysis.js');
         switch (analysisType) {
@@ -26,11 +385,11 @@ export async function analyzeEnvironment(args) {
                             projectPath,
                             technologies: [],
                             patterns: [],
-                            projectType: 'infrastructure-environment-analysis'
+                            projectType: 'infrastructure-environment-analysis',
                         }, {
                             domains: ['cloud-infrastructure', 'devops-cicd'],
                             depth: 'intermediate',
-                            cacheEnabled: true
+                            cacheEnabled: true,
                         });
                         knowledgeContext = `\n## Infrastructure & DevOps Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
                     }
@@ -52,10 +411,58 @@ Leverage the provided cloud infrastructure and DevOps knowledge to create compre
 Focus on providing actionable insights for environment optimization, security, scalability, and modern DevOps practices.
 Consider cloud-native patterns, containerization best practices, and deployment automation.
 Provide specific recommendations with implementation guidance.`,
-                    responseFormat: 'text'
+                    responseFormat: 'text',
                 });
                 if (executionResult.isAIGenerated) {
                     // AI execution successful - return actual environment analysis results
+                    // Store environment snapshot in memory if enabled
+                    let memoryIntegrationInfo = '';
+                    if (memoryManager) {
+                        try {
+                            // Parse AI result to extract configuration data
+                            const analysisData = parseAnalysisResults(executionResult.content, result.actualData);
+                            // Compare with previous snapshots
+                            const comparison = await memoryManager.compareWithPreviousSnapshots(analysisData, environmentType);
+                            // Store new snapshot
+                            const snapshotId = await memoryManager.storeEnvironmentSnapshot(environmentType, analysisData, undefined, // No compliance data for specs analysis
+                            projectPath);
+                            memoryIntegrationInfo = `
+## 🧠 Memory Integration Status
+
+- **Snapshot Stored**: ✅ Environment snapshot saved (ID: ${snapshotId.substring(0, 8)}...)
+- **Environment Type**: ${environmentType}
+- **Change Detection**: ${comparison.hasChanges ? '🔄 Changes detected' : '✅ No changes from previous snapshot'}
+- **Improvements**: ${comparison.improvements.length} detected
+- **Regressions**: ${comparison.regressions.length} detected
+
+${comparison.changes.length > 0
+                                ? `### Configuration Changes
+${comparison.changes.map(change => `- ${change}`).join('\n')}
+`
+                                : ''}
+
+${comparison.improvements.length > 0
+                                ? `### Improvements Detected
+${comparison.improvements.map(improvement => `- ${improvement}`).join('\n')}
+`
+                                : ''}
+
+${comparison.regressions.length > 0
+                                ? `### Regressions Detected  
+${comparison.regressions.map(regression => `- ⚠️ ${regression}`).join('\n')}
+`
+                                : ''}
+`;
+                        }
+                        catch (memoryError) {
+                            memoryIntegrationInfo = `
+## 🧠 Memory Integration Status
+
+- **Status**: ⚠️ Memory storage failed - analysis continued without persistence
+- **Error**: ${memoryError instanceof Error ? memoryError.message : 'Unknown error'}
+`;
+                        }
+                    }
                     return formatMCPResponse({
                         ...executionResult,
                         content: `# Environment Specification Analysis Results (GKP Enhanced)
@@ -63,17 +470,23 @@ Provide specific recommendations with implementation guidance.`,
 ## Enhancement Features
 - **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
 - **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
+- **Memory Integration**: ${enableMemoryIntegration ? '✅ Enabled' : '❌ Disabled'}
 - **Knowledge Domains**: Cloud infrastructure, DevOps practices, containerization, deployment patterns
 
+${memoryIntegrationInfo}
+
 ## Analysis Information
 - **Project Path**: ${projectPath}
 - **ADR Directory**: ${adrDirectory}
 - **Analysis Type**: Environment Specifications
+- **Environment Type**: ${environmentType}
 
-${knowledgeContext ? `## Applied Infrastructure Knowledge
+${knowledgeContext
+                            ? `## Applied Infrastructure Knowledge
 
 ${knowledgeContext}
-` : ''}
+`
+                            : ''}
 
 ## AI Environment Analysis Results
 
@@ -119,10 +532,12 @@ For deeper insights, consider running:
 - **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Applied' : '❌ Disabled'}
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 
-${knowledgeContext ? `## Infrastructure Knowledge Context
+${knowledgeContext
+                                    ? `## Infrastructure Knowledge Context
 
 ${knowledgeContext}
-` : ''}
+`
+                                    : ''}
 
 ${result.instructions}
 
@@ -153,11 +568,11 @@ ${enhancedPrompt}
                             projectPath,
                             technologies: [],
                             patterns: [],
-                            projectType: 'containerization-analysis'
+                            projectType: 'containerization-analysis',
                         }, {
                             domains: ['cloud-infrastructure', 'devops-cicd'],
                             depth: 'intermediate',
-                            cacheEnabled: true
+                            cacheEnabled: true,
                         });
                         knowledgeContext = `\n## Containerization Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
                     }
@@ -179,10 +594,12 @@ ${enhancedPrompt}
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 - **Knowledge Domains**: Containerization, Kubernetes, Docker best practices, container security
 
-${knowledgeContext ? `## Containerization Knowledge Context
+${knowledgeContext
+                                ? `## Containerization Knowledge Context
 
 ${knowledgeContext}
-` : ''}
+`
+                                : ''}
 
 ${result.instructions}
 
@@ -234,11 +651,11 @@ Use the detection results to:
                             projectPath,
                             technologies: [],
                             patterns: [],
-                            projectType: 'requirements-analysis'
+                            projectType: 'requirements-analysis',
                         }, {
                             domains: ['cloud-infrastructure', 'performance-optimization'],
                             depth: 'intermediate',
-                            cacheEnabled: true
+                            cacheEnabled: true,
                         });
                         knowledgeContext = `\n## Requirements Engineering Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
                     }
@@ -260,10 +677,12 @@ Use the detection results to:
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 - **Knowledge Domains**: Requirements engineering, infrastructure planning, performance requirements, security requirements
 
-${knowledgeContext ? `## Requirements Knowledge Context
+${knowledgeContext
+                                ? `## Requirements Knowledge Context
 
 ${knowledgeContext}
-` : ''}
+`
+                                : ''}
 
 ${result.instructions}
 
@@ -317,11 +736,11 @@ Use the extracted requirements to:
                             projectPath,
                             technologies: [],
                             patterns: [],
-                            projectType: 'compliance-assessment'
+                            projectType: 'compliance-assessment',
                         }, {
                             domains: ['security-patterns', 'cloud-infrastructure'],
                             depth: 'intermediate',
-                            cacheEnabled: true
+                            cacheEnabled: true,
                         });
                         knowledgeContext = `\n## Compliance & Security Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
                     }
@@ -343,10 +762,12 @@ Use the extracted requirements to:
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 - **Knowledge Domains**: Compliance frameworks, security standards, regulatory requirements, audit practices
 
-${knowledgeContext ? `## Compliance Knowledge Context
+${knowledgeContext
+                                ? `## Compliance Knowledge Context
 
 ${knowledgeContext}
-` : ''}
+`
+                                : ''}
 
 ${result.instructions}
 
@@ -397,17 +818,18 @@ Use the assessment results to:
                             projectPath,
                             technologies: [],
                             patterns: [],
-                            projectType: 'comprehensive-environment-analysis'
+                            projectType: 'comprehensive-environment-analysis',
                         }, {
                             domains: ['cloud-infrastructure', 'devops-cicd', 'security-patterns'],
                             depth: 'advanced',
-                            cacheEnabled: true
+                            cacheEnabled: true,
                         });
                         comprehensiveKnowledgeContext = `\n## Comprehensive Environment Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
                     }
                     catch (error) {
                         console.error('[WARNING] GKP knowledge generation failed for comprehensive environment analysis:', error);
-                        comprehensiveKnowledgeContext = '<!-- Comprehensive environment knowledge generation unavailable -->\n';
+                        comprehensiveKnowledgeContext =
+                            '<!-- Comprehensive environment knowledge generation unavailable -->\n';
                     }
                 }
                 const specsResult = await analyzeEnvironmentSpecs(projectPath);
@@ -425,10 +847,12 @@ Use the assessment results to:
 - **Knowledge Domains**: Cloud infrastructure, DevOps practices, containerization, deployment patterns, compliance frameworks, security standards
 - **Knowledge Depth**: Advanced (comprehensive coverage)
 
-${comprehensiveKnowledgeContext ? `## Applied Comprehensive Knowledge
+${comprehensiveKnowledgeContext
+                                ? `## Applied Comprehensive Knowledge
 
 ${comprehensiveKnowledgeContext}
-` : ''}
+`
+                                : ''}
 
 This comprehensive analysis will examine all aspects of your environment context and provide optimization recommendations.
 
@@ -515,4 +939,124 @@ All analyses follow these principles:
         throw new McpAdrError(`Failed to analyze environment: ${error instanceof Error ? error.message : String(error)}`, 'ENVIRONMENT_ANALYSIS_ERROR');
     }
 }
+/**
+ * Helper function to parse AI analysis results into structured configuration data
+ */
+function parseAnalysisResults(aiContent, actualData) {
+    // Try to extract structured data from AI response
+    const configuration = {
+        infrastructure: actualData?.infrastructure || {},
+        containerization: {
+            detected: aiContent.toLowerCase().includes('docker') || aiContent.toLowerCase().includes('container'),
+            technologies: extractTechnologies(aiContent, [
+                'docker',
+                'kubernetes',
+                'podman',
+                'containerd',
+            ]),
+        },
+        cloudServices: {
+            providers: extractTechnologies(aiContent, [
+                'aws',
+                'azure',
+                'gcp',
+                'google cloud',
+                'heroku',
+                'vercel',
+                'netlify',
+            ]),
+        },
+        security: {
+            httpsEnabled: aiContent.toLowerCase().includes('https') || aiContent.toLowerCase().includes('ssl'),
+            securityMentioned: aiContent.toLowerCase().includes('security'),
+        },
+        monitoring: {
+            metrics: aiContent.toLowerCase().includes('monitoring') ||
+                aiContent.toLowerCase().includes('metrics'),
+        },
+        deployment: {
+            automated: aiContent.toLowerCase().includes('ci/cd') || aiContent.toLowerCase().includes('pipeline'),
+            loadBalancing: aiContent.toLowerCase().includes('load balanc') || aiContent.toLowerCase().includes('lb'),
+        },
+        discoveredFiles: actualData?.discoveredFiles || [],
+        recommendations: extractRecommendations(aiContent),
+        qualityAttributes: extractQualityAttributes(aiContent),
+        riskAssessment: extractRiskAssessment(aiContent),
+    };
+    return configuration;
+}
+/**
+ * Extract technology mentions from AI content
+ */
+function extractTechnologies(content, technologies) {
+    const found = [];
+    const lowerContent = content.toLowerCase();
+    for (const tech of technologies) {
+        if (lowerContent.includes(tech.toLowerCase())) {
+            found.push(tech);
+        }
+    }
+    return found;
+}
+/**
+ * Extract recommendations from AI content
+ */
+function extractRecommendations(content) {
+    const recommendations = [];
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') &&
+            (trimmed.toLowerCase().includes('recommend') ||
+                trimmed.toLowerCase().includes('suggest') ||
+                trimmed.toLowerCase().includes('consider') ||
+                trimmed.toLowerCase().includes('should'))) {
+            recommendations.push(trimmed.substring(2)); // Remove '- ' prefix
+        }
+    }
+    return recommendations;
+}
+/**
+ * Extract quality attributes from AI content
+ */
+function extractQualityAttributes(content) {
+    const attributes = {};
+    const lowerContent = content.toLowerCase();
+    if (lowerContent.includes('performance')) {
+        attributes.performance = 'mentioned';
+    }
+    if (lowerContent.includes('scalability') || lowerContent.includes('scalable')) {
+        attributes.scalability = 'mentioned';
+    }
+    if (lowerContent.includes('security')) {
+        attributes.security = 'mentioned';
+    }
+    if (lowerContent.includes('reliability') || lowerContent.includes('reliable')) {
+        attributes.reliability = 'mentioned';
+    }
+    if (lowerContent.includes('maintainability') || lowerContent.includes('maintainable')) {
+        attributes.maintainability = 'mentioned';
+    }
+    return attributes;
+}
+/**
+ * Extract risk assessment from AI content
+ */
+function extractRiskAssessment(content) {
+    const risks = [];
+    const lowerContent = content.toLowerCase();
+    if (lowerContent.includes('risk') || lowerContent.includes('vulnerability')) {
+        risks.push('Security risks mentioned in analysis');
+    }
+    if (lowerContent.includes('single point of failure') || lowerContent.includes('spof')) {
+        risks.push('Single point of failure identified');
+    }
+    if (lowerContent.includes('outdated') || lowerContent.includes('deprecated')) {
+        risks.push('Outdated technologies or dependencies detected');
+    }
+    return {
+        risks,
+        riskLevel: risks.length > 2 ? 'high' : risks.length > 0 ? 'medium' : 'low',
+    };
+}
 //# sourceMappingURL=environment-analysis-tool.js.map