@aws/ml-container-creator 0.2.0

package/src/lib/template-manager.js

@@ -0,0 +1,341 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Template Manager - Handles configuration validation
+ * 
+ * This module validates user configuration choices to ensure they are
+ * supported by the generator. With do-framework integration, conditional
+ * file exclusion logic has been removed - all template files are now
+ * generated unconditionally, and runtime scripts handle conditional logic.
+ * 
+ * Requirements: 7.1, 7.2, 7.3, 7.4, 2.1
+ */
+
+/**
+ * GPU-requiring Triton backends that must use GPU instance types
+ */
+const GPU_REQUIRING_BACKENDS = ['triton-vllm', 'triton-tensorrtllm', 'diffusors-vllm-omni']
+
+/**
+ * CPU-only instance type families (patterns that indicate non-GPU instances)
+ */
+const CPU_ONLY_INSTANCE_PATTERNS = [
+    /^ml\.m[0-9]+\./,   // ml.m4.*, ml.m5.*, ml.m6i.*, etc.
+    /^ml\.c[0-9]+\./,   // ml.c4.*, ml.c5.*, ml.c6i.*, etc.
+    /^ml\.t[0-9]+\./,   // ml.t2.*, ml.t3.*, etc.
+    /^ml\.r[0-9]+\./,   // ml.r5.*, ml.r6i.*, etc.
+]
+
+/**
+ * Check if an instance type is CPU-only (no GPU)
+ * @param {string} instanceType - e.g. 'ml.m5.large', 'ml.g5.xlarge'
+ * @returns {boolean} true if CPU-only, false if GPU-capable
+ */
+function isCpuOnlyInstance(instanceType) {
+    if (!instanceType || instanceType === 'custom') {
+        return false
+    }
+    return CPU_ONLY_INSTANCE_PATTERNS.some(pattern => pattern.test(instanceType))
+}
+
+export default class TemplateManager {
+    constructor(answers) {
+        this.answers = answers
+    }
+
+    /**
+     * Validates that the configuration is supported
+     * @throws {Error} If unsupported configuration detected
+     */
+    validate() {
+        const supportedOptions = {
+            // 15 canonical deployment-config values (2 http, 5 transformers, 7 triton, 1 diffusors)
+            deploymentConfigs: [
+                // HTTP architecture (2)
+                'http-flask', 'http-fastapi',
+                // Transformers architecture (5)
+                'transformers-vllm', 'transformers-sglang',
+                'transformers-tensorrt-llm', 'transformers-lmi', 'transformers-djl',
+                // Triton architecture (7)
+                'triton-fil', 'triton-onnxruntime', 'triton-tensorflow',
+                'triton-pytorch', 'triton-vllm', 'triton-tensorrtllm', 'triton-python',
+                // Diffusors architecture (1)
+                'diffusors-vllm-omni'
+            ],
+            buildTargets: ['codebuild'],
+            deploymentTargets: ['managed-inference', 'async-inference', 'batch-transform', 'hyperpod-eks'],
+            testTypes: ['local-model-cli', 'local-model-server', 'hosted-model-endpoint'],
+            awsRegions: [
+                'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
+                'eu-west-1', 'eu-west-2', 'eu-central-1', 'eu-north-1',
+                'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1',
+                'ca-central-1', 'sa-east-1'
+            ]
+        }
+
+        // Validate deployment configuration if present
+        if (this.answers.deploymentConfig) {
+            this._validateChoice('deploymentConfig', supportedOptions.deploymentConfigs)
+            
+            // GPU instance type enforcement for GPU-requiring backends
+            this._validateGpuRequirement()
+        } else {
+            // Fallback: validate architecture and backend separately (new canonical format)
+            const architectures = ['http', 'transformers', 'triton', 'diffusors']
+            const backends = [
+                // http backends
+                'flask', 'fastapi',
+                // transformers backends
+                'vllm', 'sglang', 'tensorrt-llm', 'lmi', 'djl',
+                // triton backends
+                'fil', 'onnxruntime', 'tensorflow', 'pytorch', 'tensorrtllm', 'python',
+                // diffusors backends
+                'vllm-omni'
+            ]
+            
+            this._validateChoice('architecture', architectures)
+            this._validateChoice('backend', backends)
+            
+            // Validate tensorrt-llm is only used with transformers architecture
+            if (this.answers.backend === 'tensorrt-llm' && this.answers.architecture !== 'transformers') {
+                throw new Error('⚠️  TensorRT-LLM is only supported with the transformers architecture. Please select "transformers" as your architecture or choose a different backend.')
+            }
+            
+            // GPU instance type enforcement for GPU-requiring backends (fallback path)
+            const deploymentConfig = this.answers.architecture && this.answers.backend
+                ? `${this.answers.architecture}-${this.answers.backend}`
+                : null
+            if (deploymentConfig && GPU_REQUIRING_BACKENDS.includes(deploymentConfig)) {
+                this._validateGpuRequirementForConfig(deploymentConfig)
+            }
+        }
+
+        // Validate buildTarget (replaces deployTarget)
+        if (this.answers.buildTarget) {
+            this._validateChoice('buildTarget', supportedOptions.buildTargets)
+        } else if (this.answers.deployTarget) {
+            // Backward compatibility: validate deployTarget against buildTargets
+            this._validateChoice('deployTarget', supportedOptions.buildTargets)
+        }
+
+        // Validate deploymentTarget
+        if (this.answers.deploymentTarget) {
+            this._validateChoice('deploymentTarget', supportedOptions.deploymentTargets)
+        }
+
+        // Validate HyperPod EKS specific fields
+        if (this.answers.deploymentTarget === 'hyperpod-eks') {
+            this._validateHyperPodConfig()
+        }
+
+        // Validate async inference specific fields
+        this._validateAsyncConfig()
+
+        // Validate batch transform specific fields
+        this._validateBatchTransformConfig()
+        
+        // Validate instance type format (ml.*.*) - only for managed-inference
+        if (this.answers.instanceType && this.answers.instanceType !== 'custom') {
+            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/
+            if (!instancePattern.test(this.answers.instanceType)) {
+                throw new Error(`⚠️  Invalid instance type format: ${this.answers.instanceType}. Expected format: ml.{family}.{size} (e.g., ml.m5.large, ml.g5.xlarge)`)
+            }
+        }
+        
+        this._validateChoice('awsRegion', supportedOptions.awsRegions)
+
+        // Validate test types if testing is enabled
+        if (this.answers.includeTesting && this.answers.testTypes) {
+            for (const testType of this.answers.testTypes) {
+                this._validateChoice('testType', supportedOptions.testTypes, testType)
+            }
+        }
+    }
+
+    /**
+     * Validates HyperPod EKS specific configuration
+     * @private
+     * @throws {Error} If HyperPod configuration is invalid
+     */
+    _validateHyperPodConfig() {
+        // Validate hyperPodCluster is non-empty
+        if (!this.answers.hyperPodCluster || this.answers.hyperPodCluster.trim() === '') {
+            throw new Error('⚠️  hyperPodCluster is required when deploymentTarget is "hyperpod-eks". Please provide a valid HyperPod cluster name.')
+        }
+
+        // Validate hyperPodNamespace conforms to RFC 1123 DNS label format
+        if (this.answers.hyperPodNamespace) {
+            if (!this._isValidRfc1123DnsLabel(this.answers.hyperPodNamespace)) {
+                throw new Error(`⚠️  Invalid hyperPodNamespace: "${this.answers.hyperPodNamespace}". Namespace must conform to RFC 1123 DNS label format: lowercase alphanumeric characters or hyphens, must start and end with an alphanumeric character, and be at most 63 characters.`)
+            }
+        }
+
+        // Validate hyperPodReplicas is an integer >= 1
+        if (this.answers.hyperPodReplicas !== undefined) {
+            const replicas = this.answers.hyperPodReplicas
+            if (!Number.isInteger(replicas) || replicas < 1) {
+                throw new Error(`⚠️  Invalid hyperPodReplicas: "${replicas}". Replicas must be an integer greater than or equal to 1.`)
+            }
+        }
+    }
+
+    /**
+     * Validates a string conforms to RFC 1123 DNS label format
+     * @private
+     * @param {string} value - The value to validate
+     * @returns {boolean} True if valid RFC 1123 DNS label
+     */
+    _isValidRfc1123DnsLabel(value) {
+        if (!value || typeof value !== 'string') {
+            return false
+        }
+        // RFC 1123 DNS label: lowercase alphanumeric, hyphens allowed (not at start/end), max 63 chars
+        const rfc1123Pattern = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/
+        return value.length <= 63 && rfc1123Pattern.test(value)
+    }
+
+    /**
+     * Validates async inference specific configuration
+     * @private
+     * @throws {Error} If async configuration is invalid
+     */
+    _validateAsyncConfig() {
+        if (this.answers.deploymentTarget !== 'async-inference') return
+
+        // Validate S3 output path format if explicitly provided
+        if (this.answers.asyncS3OutputPath && this.answers.asyncS3OutputPath.trim() !== '') {
+            if (!this.answers.asyncS3OutputPath.startsWith('s3://')) {
+                throw new Error('⚠️  asyncS3OutputPath must start with "s3://". Example: s3://my-bucket/output/')
+            }
+        }
+
+        // Validate SNS topic ARN format if explicitly provided
+        const snsArnPattern = /^arn:aws:sns:[a-z0-9-]+:\d{12}:.+$/
+        if (this.answers.asyncSnsSuccessTopic && this.answers.asyncSnsSuccessTopic.trim() !== '') {
+            if (!snsArnPattern.test(this.answers.asyncSnsSuccessTopic)) {
+                throw new Error('⚠️  asyncSnsSuccessTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>')
+            }
+        }
+        if (this.answers.asyncSnsErrorTopic && this.answers.asyncSnsErrorTopic.trim() !== '') {
+            if (!snsArnPattern.test(this.answers.asyncSnsErrorTopic)) {
+                throw new Error('⚠️  asyncSnsErrorTopic must be a valid SNS ARN. Format: arn:aws:sns:<region>:<account-id>:<topic-name>')
+            }
+        }
+
+        // Validate max concurrent invocations
+        if (this.answers.asyncMaxConcurrentInvocations !== undefined) {
+            const val = this.answers.asyncMaxConcurrentInvocations
+            if (!Number.isInteger(val) || val < 1) {
+                throw new Error('⚠️  asyncMaxConcurrentInvocations must be an integer >= 1')
+            }
+        }
+    }
+
+    /**
+     * Validates batch transform specific configuration
+     * @private
+     * @throws {Error} If batch transform configuration is invalid
+     */
+    _validateBatchTransformConfig() {
+        if (this.answers.deploymentTarget !== 'batch-transform') return
+
+        // Validate S3 input path format if provided
+        if (this.answers.batchInputPath && this.answers.batchInputPath.trim() !== '') {
+            if (!this.answers.batchInputPath.startsWith('s3://')) {
+                throw new Error('⚠️  batchInputPath must start with "s3://". Example: s3://my-bucket/input/')
+            }
+        }
+
+        // Validate S3 output path format if provided
+        if (this.answers.batchOutputPath && this.answers.batchOutputPath.trim() !== '') {
+            if (!this.answers.batchOutputPath.startsWith('s3://')) {
+                throw new Error('⚠️  batchOutputPath must start with "s3://". Example: s3://my-bucket/output/')
+            }
+        }
+
+        // Validate instance count
+        if (this.answers.batchInstanceCount !== undefined) {
+            const val = this.answers.batchInstanceCount
+            if (!Number.isInteger(val) || val < 1) {
+                throw new Error('⚠️  batchInstanceCount must be an integer >= 1')
+            }
+        }
+
+        // Validate split type
+        const validSplitTypes = ['Line', 'RecordIO', 'None']
+        if (this.answers.batchSplitType && !validSplitTypes.includes(this.answers.batchSplitType)) {
+            throw new Error(`⚠️  batchSplitType must be one of: ${validSplitTypes.join(', ')}`)
+        }
+
+        // Validate batch strategy
+        const validStrategies = ['MultiRecord', 'SingleRecord']
+        if (this.answers.batchStrategy && !validStrategies.includes(this.answers.batchStrategy)) {
+            throw new Error(`⚠️  batchStrategy must be one of: ${validStrategies.join(', ')}`)
+        }
+
+        // Validate join source
+        const validJoinSources = ['Input', 'None']
+        if (this.answers.batchJoinSource && !validJoinSources.includes(this.answers.batchJoinSource)) {
+            throw new Error(`⚠️  batchJoinSource must be one of: ${validJoinSources.join(', ')}`)
+        }
+
+        // Validate max concurrent transforms
+        if (this.answers.batchMaxConcurrentTransforms !== undefined) {
+            const val = this.answers.batchMaxConcurrentTransforms
+            if (!Number.isInteger(val) || val < 0) {
+                throw new Error('⚠️  batchMaxConcurrentTransforms must be an integer >= 0')
+            }
+        }
+
+        // Validate max payload in MB
+        if (this.answers.batchMaxPayloadInMB !== undefined) {
+            const val = this.answers.batchMaxPayloadInMB
+            if (!Number.isInteger(val) || val < 0 || val > 100) {
+                throw new Error('⚠️  batchMaxPayloadInMB must be an integer between 0 and 100')
+            }
+        }
+    }
+
+    /**
+     * Validates GPU instance type requirement for GPU-requiring backends.
+     * Called when deploymentConfig is present.
+     * @private
+     * @throws {Error} If a GPU-requiring backend is paired with a CPU-only instance
+     */
+    _validateGpuRequirement() {
+        const dc = this.answers.deploymentConfig
+        if (GPU_REQUIRING_BACKENDS.includes(dc)) {
+            this._validateGpuRequirementForConfig(dc)
+        }
+    }
+
+    /**
+     * Validates that a GPU-requiring deployment config is not paired with a CPU-only instance.
+     * @private
+     * @param {string} deploymentConfig - The deployment config string
+     * @throws {Error} If instance type is CPU-only
+     */
+    _validateGpuRequirementForConfig(deploymentConfig) {
+        const instanceType = this.answers.instanceType
+        if (isCpuOnlyInstance(instanceType)) {
+            throw new Error(
+                `⚠️  ${deploymentConfig} requires a GPU instance type. ` +
+                `Selected: ${instanceType}. ` +
+                `Recommended: ml.g5.xlarge, ml.g5.2xlarge`
+            )
+        }
+    }
+
+    /**
+     * Validates a single configuration choice
+     * @private
+     */
+    _validateChoice(field, supportedValues, value = null) {
+        const actualValue = value || this.answers[field]
+        if (actualValue && !supportedValues.includes(actualValue)) {
+            throw new Error(`⚠️  ${actualValue} not implemented yet for ${field}.`)
+        }
+    }
+}
+

package/src/lib/validation-engine.js

@@ -0,0 +1,314 @@
+import CudaValidator from './cuda-validator.js';
+import NeuronValidator from './neuron-validator.js';
+import CpuValidator from './cpu-validator.js';
+import RocmValidator from './rocm-validator.js';
+
+/**
+ * Validation engine for framework and instance compatibility.
+ * Orchestrates accelerator validation using pluggable validators.
+ * 
+ * Requirements: 4.7, 4.8, 4.10, 4.11, 4.12, 4.13, 4.14, 4.15, 4.16, 4.17, 4.18, 4.20, 4.21
+ */
+export default class ValidationEngine {
+    constructor() {
+        // Initialize accelerator validators registry
+        this.acceleratorValidators = new Map();
+        
+        // Register default validators
+        this.registerAcceleratorValidator('cuda', new CudaValidator());
+        this.registerAcceleratorValidator('neuron', new NeuronValidator());
+        this.registerAcceleratorValidator('cpu', new CpuValidator());
+        this.registerAcceleratorValidator('rocm', new RocmValidator());
+    }
+    
+    /**
+     * Register a custom accelerator validator.
+     * Enables extensibility for new accelerator types.
+     * 
+     * @param {string} acceleratorType - Accelerator type (cuda, neuron, cpu, rocm, etc.)
+     * @param {AcceleratorValidator} validator - Validator instance
+     * 
+     * Requirements: 4.10, 4.21
+     */
+    registerAcceleratorValidator(acceleratorType, validator) {
+        this.acceleratorValidators.set(acceleratorType, validator);
+    }
+    
+    /**
+     * Validate accelerator compatibility between framework and instance.
+     * Delegates to appropriate accelerator-specific validator.
+     * 
+     * @param {Object} frameworkConfig - Framework accelerator requirements
+     * @param {Object} frameworkConfig.accelerator - Accelerator configuration
+     * @param {string} frameworkConfig.accelerator.type - Accelerator type
+     * @param {string} frameworkConfig.accelerator.version - Required version
+     * @param {Object} instanceConfig - Instance accelerator capabilities
+     * @param {Object} instanceConfig.accelerator - Accelerator configuration
+     * @param {string} instanceConfig.accelerator.type - Accelerator type
+     * @param {Array<string>} instanceConfig.accelerator.versions - Supported versions
+     * @returns {Object} ValidationResult
+     * @returns {boolean} ValidationResult.compatible - Whether configuration is compatible
+     * @returns {string} [ValidationResult.error] - Error message if incompatible
+     * @returns {string} [ValidationResult.warning] - Warning message if issues detected
+     * @returns {string} [ValidationResult.info] - Informational message
+     * 
+     * Requirements: 4.11, 4.12, 4.13, 4.14, 4.15, 4.16, 4.17, 4.18
+     */
+    validateAcceleratorCompatibility(frameworkConfig, instanceConfig) {
+        // Check if accelerator types match
+        if (frameworkConfig.accelerator.type !== instanceConfig.accelerator.type) {
+            return {
+                compatible: false,
+                error: `Framework requires ${frameworkConfig.accelerator.type} accelerator, ` +
+                       `but instance provides ${instanceConfig.accelerator.type}. ` +
+                       `Please select an instance type with ${frameworkConfig.accelerator.type} support.`
+            };
+        }
+        
+        // Get validator for accelerator type
+        const validator = this.acceleratorValidators.get(frameworkConfig.accelerator.type);
+        
+        if (!validator) {
+            return {
+                compatible: true,
+                warning: `No validator available for ${frameworkConfig.accelerator.type} accelerator. ` +
+                        'Proceeding without version validation.'
+            };
+        }
+        
+        // Delegate to accelerator-specific validator
+        return validator.validate(frameworkConfig, instanceConfig);
+    }
+    
+    /**
+     * Get recommended instance types for a framework configuration.
+     * 
+     * @param {Object} frameworkConfig - Framework configuration
+     * @param {Object} instanceAcceleratorMapping - Instance accelerator mapping registry
+     * @returns {Array<Object>} Recommended instance types with compatibility info
+     * 
+     * Requirements: 4.2, 4.3, 4.7, 4.8
+     */
+    getRecommendedInstanceTypes(frameworkConfig, instanceAcceleratorMapping) {
+        const recommendations = [];
+        
+        // Iterate through all instance types in mapping
+        for (const [instanceType, instanceConfig] of Object.entries(instanceAcceleratorMapping)) {
+            // Validate compatibility
+            const validation = this.validateAcceleratorCompatibility(frameworkConfig, instanceConfig);
+            
+            if (validation.compatible) {
+                recommendations.push({
+                    instanceType,
+                    acceleratorType: instanceConfig.accelerator.type,
+                    acceleratorVersions: instanceConfig.accelerator.versions,
+                    compatible: true,
+                    info: validation.info
+                });
+            }
+        }
+        
+        return recommendations;
+    }
+    
+    /**
+     * Validate environment variables against framework specifications.
+     * Uses multiple validation strategies based on configuration.
+     * 
+     * @param {Object} environmentVariables - Environment variables to validate
+     * @param {Object} frameworkConfig - Framework configuration with known flags
+     * @param {Object} options - Validation options
+     * @param {boolean} options.enabled - Enable/disable validation completely (default: true)
+     * @param {boolean} options.useKnownFlags - Use known flags registry (default: true)
+     * @param {boolean} options.useCommunityReports - Use community reports (default: true)
+     * @param {boolean} options.useDockerIntrospection - Use Docker introspection (default: false)
+     * @returns {Object} ValidationResult
+     * @returns {Array<Object>} ValidationResult.errors - Validation errors
+     * @returns {Array<Object>} ValidationResult.warnings - Validation warnings
+     * @returns {Array<string>} ValidationResult.strategiesUsed - Validation strategies used
+     * 
+     * Requirements: 13.9, 13.10, 13.11, 13.13, 13.14, 13.15, 13.16, 13.17, 13.31
+     */
+    validateEnvironmentVariables(environmentVariables, frameworkConfig, options = {}) {
+        const {
+            enabled = true,
+            useKnownFlags = true,
+            useCommunityReports = true,
+            useDockerIntrospection = false
+        } = options;
+        
+        // If validation is completely disabled, return empty result
+        if (!enabled) {
+            return {
+                errors: [],
+                warnings: [],
+                strategiesUsed: []
+            };
+        }
+        
+        const errors = [];
+        const warnings = [];
+        const strategiesUsed = [];
+        
+        // Known flags validation
+        if (useKnownFlags && frameworkConfig.knownFlags) {
+            strategiesUsed.push('known-flags-registry');
+            const knownFlagsResult = this._validateWithKnownFlags(
+                environmentVariables,
+                frameworkConfig.knownFlags
+            );
+            errors.push(...knownFlagsResult.errors);
+            warnings.push(...knownFlagsResult.warnings);
+        }
+        
+        // Community reports validation
+        if (useCommunityReports && frameworkConfig.communityReports) {
+            strategiesUsed.push('community-reports');
+            const communityResult = this._validateWithCommunityReports(
+                environmentVariables,
+                frameworkConfig.communityReports
+            );
+            errors.push(...communityResult.errors);
+            warnings.push(...communityResult.warnings);
+        }
+        
+        // Docker introspection validation (opt-in, experimental)
+        if (useDockerIntrospection) {
+            strategiesUsed.push('docker-introspection');
+            warnings.push({
+                variable: null,
+                message: 'Docker introspection validation is experimental and not tested in CI/CD'
+            });
+        }
+        
+        return {
+            errors,
+            warnings,
+            strategiesUsed
+        };
+    }
+    
+    /**
+     * Validate environment variables using known flags registry.
+     * 
+     * @param {Object} environmentVariables - Environment variables to validate
+     * @param {Object} knownFlags - Known flags registry
+     * @returns {Object} Validation result with errors and warnings
+     * 
+     * Requirements: 13.13, 13.14, 13.15, 13.16, 13.17
+     * @private
+     */
+    _validateWithKnownFlags(environmentVariables, knownFlags) {
+        const errors = [];
+        const warnings = [];
+        
+        for (const [varName, varValue] of Object.entries(environmentVariables)) {
+            const flagSpec = knownFlags[varName];
+            
+            if (!flagSpec) {
+                // Unknown flag - not an error, just informational
+                continue;
+            }
+            
+            // Check if deprecated
+            if (flagSpec.deprecated) {
+                warnings.push({
+                    variable: varName,
+                    message: `${varName} is deprecated. ${flagSpec.deprecationMessage || ''}`,
+                    replacement: flagSpec.replacement
+                });
+            }
+            
+            // Validate type
+            if (flagSpec.type) {
+                const typeValid = this._validateType(varValue, flagSpec.type);
+                if (!typeValid) {
+                    errors.push({
+                        variable: varName,
+                        message: `${varName} must be of type ${flagSpec.type}, got ${typeof varValue}`
+                    });
+                }
+            }
+            
+            // Validate range constraints
+            if (flagSpec.min !== undefined || flagSpec.max !== undefined) {
+                const numValue = Number(varValue);
+                if (flagSpec.min !== undefined && numValue < flagSpec.min) {
+                    errors.push({
+                        variable: varName,
+                        message: `${varName} must be >= ${flagSpec.min}, got ${numValue}`
+                    });
+                }
+                if (flagSpec.max !== undefined && numValue > flagSpec.max) {
+                    errors.push({
+                        variable: varName,
+                        message: `${varName} must be <= ${flagSpec.max}, got ${numValue}`
+                    });
+                }
+            }
+        }
+        
+        return { errors, warnings };
+    }
+    
+    /**
+     * Validate environment variables using community reports.
+     * 
+     * @param {Object} environmentVariables - Environment variables to validate
+     * @param {Object} communityReports - Community validation reports
+     * @returns {Object} Validation result with errors and warnings
+     * 
+     * Requirements: 13.13, 13.14, 13.15
+     * @private
+     */
+    _validateWithCommunityReports(environmentVariables, communityReports) {
+        const errors = [];
+        const warnings = [];
+        
+        for (const [varName] of Object.entries(environmentVariables)) {
+            const reports = communityReports[varName];
+            
+            if (!reports || reports.length === 0) {
+                continue;
+            }
+            
+            // Check for reported issues
+            const issueReports = reports.filter(r => r.status === 'invalid' || r.status === 'deprecated');
+            if (issueReports.length > 0) {
+                warnings.push({
+                    variable: varName,
+                    message: `Community reports indicate potential issues with ${varName}`,
+                    reports: issueReports
+                });
+            }
+        }
+        
+        return { errors, warnings };
+    }
+    
+    /**
+     * Validate value type.
+     * 
+     * @param {*} value - Value to validate
+     * @param {string} expectedType - Expected type (integer, float, string, boolean)
+     * @returns {boolean} True if type is valid
+     * @private
+     */
+    _validateType(value, expectedType) {
+        switch (expectedType) {
+        case 'integer':
+            return Number.isInteger(Number(value));
+        case 'float':
+            return !isNaN(Number(value));
+        case 'string':
+            return typeof value === 'string';
+        case 'boolean':
+            return value === 'true' || value === 'false' || 
+                       value === true || value === false ||
+                       value === '1' || value === '0' ||
+                       value === 1 || value === 0;
+        default:
+            return true;
+        }
+    }
+}