@aws/ml-container-creator 1.0.3 → 1.1.0

package/src/lib/configuration-exporter.js

@@ -1,204 +0,0 @@
-/**
- * Configuration Exporter
- * 
- * Handles prompting users to export configurations for community contribution
- * and saving exported configurations to files.
- * 
- * Requirements: 7.1, 7.2, 7.3, 7.4
- */
-
-import fs from 'fs';
-import path from 'path';
-import { runPrompts } from '../prompt-adapter.js';
-
-export default class ConfigurationExporter {
-    constructor() {
-        // No generator dependency — uses console.log and runPrompts directly
-    }
-    
-    /**
-     * Detect if configuration should be offered for export
-     * Offers export for experimental or unknown configurations
-     * 
-     * @param {Object} config - Configuration profile
-     * @returns {boolean} Whether to offer export
-     * 
-     * Requirements: 7.1
-     */
-    shouldOfferExport(config) {
-        if (!config) return false;
-        
-        const validationLevel = config.validationLevel || 'unknown';
-        
-        // Offer export for experimental or unknown configurations
-        return validationLevel === 'experimental' || validationLevel === 'unknown';
-    }
-    
-    /**
-     * Prompt user to export configuration
-     * Captures testing notes and deployment results
-     * 
-     * @param {Object} config - Configuration profile to export
-     * @returns {Promise<Object|null>} Export data or null if user declined
-     * 
-     * Requirements: 7.1, 7.2, 7.3, 7.4
-     */
-    async promptForExport(config) {
-        if (!this.shouldOfferExport(config)) {
-            return null;
-        }
-        
-        console.log('\n📤 Configuration Export');
-        console.log('━'.repeat(50));
-        console.log(`This configuration has validation level: ${config.validationLevel || 'unknown'}`);
-        console.log('If you successfully deploy and test this configuration, please consider');
-        console.log('sharing it with the community to help others!');
-        console.log('');
-        
-        // Ask if user wants to export
-        const { wantsToExport } = await runPrompts([
-            {
-                type: 'confirm',
-                name: 'wantsToExport',
-                message: 'Would you like to export this configuration for community contribution?',
-                default: false
-            }
-        ]);
-        
-        if (!wantsToExport) {
-            console.log('Skipping export. You can always export later after testing.');
-            return null;
-        }
-        
-        // Collect testing information
-        const exportData = await runPrompts([
-            {
-                type: 'input',
-                name: 'instanceType',
-                message: 'What instance type did you use (or plan to use) for testing?',
-                default: config.recommendedInstanceTypes?.[0] || 'ml.g5.xlarge',
-                validate: (input) => {
-                    if (!input || input.trim() === '') {
-                        return 'Instance type is required';
-                    }
-                    return true;
-                }
-            },
-            {
-                type: 'confirm',
-                name: 'deploymentSuccess',
-                message: 'Did the deployment succeed?',
-                default: false
-            },
-            {
-                type: 'confirm',
-                name: 'inferenceSuccess',
-                message: 'Did inference work correctly?',
-                default: false,
-                when: (answers) => answers.deploymentSuccess
-            },
-            {
-                type: 'input',
-                name: 'testingNotes',
-                message: 'Any notes about your testing experience? (optional)',
-                default: ''
-            },
-            {
-                type: 'input',
-                name: 'testerName',
-                message: 'Your name or GitHub handle (optional, for attribution):',
-                default: 'Anonymous'
-            }
-        ]);
-        
-        return exportData;
-    }
-    
-    /**
-     * Save exported configuration to file
-     * Creates a file in the project directory with export instructions
-     * 
-     * @param {Object} exportResult - Result from ConfigurationManager.exportConfiguration()
-     * @param {string} destinationPath - Destination directory path
-     * 
-     * Requirements: 7.2, 7.3, 7.5, 7.6
-     */
-    saveExportToFile(exportResult, destinationPath) {
-        const { registryType, configEntry, submissionInstructions, metadata } = exportResult;
-        
-        // Create export filename
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
-        const filename = `config-export-${registryType}-${timestamp}.md`;
-        const filepath = path.join(destinationPath, filename);
-        
-        // Create export file content
-        const content = `${submissionInstructions}
-
-## Export Metadata
-
-\`\`\`json
-${JSON.stringify(metadata, null, 2)}
-\`\`\`
-
-## Configuration Entry (JSON)
-
-\`\`\`json
-${JSON.stringify(configEntry, null, 2)}
-\`\`\`
-`;
-        
-        // Write file
-        fs.writeFileSync(filepath, content, 'utf-8');
-        
-        return filename;
-    }
-    
-    /**
-     * Display export success message
-     * 
-     * @param {string} filename - Name of exported file
-     */
-    displayExportSuccess(filename) {
-        console.log('');
-        console.log('✅ Configuration exported successfully!');
-        console.log(`📄 Export saved to: ${filename}`);
-        console.log('');
-        console.log('Next steps:');
-        console.log('1. Review the export file');
-        console.log('2. Test your deployment');
-        console.log('3. Submit via GitHub issue or pull request');
-        console.log('4. Help the community! 🎉');
-        console.log('');
-    }
-    
-    /**
-     * Complete export workflow
-     * Prompts user, exports configuration, and saves to file
-     * 
-     * @param {Object} config - Configuration profile
-     * @param {Object} configurationManager - ConfigurationManager instance
-     * @param {string} destinationPath - Destination directory path
-     * @returns {Promise<boolean>} Whether export was completed
-     * 
-     * Requirements: 7.1, 7.2, 7.3, 7.4, 7.5, 7.6
-     */
-    async exportWorkflow(config, configurationManager, destinationPath) {
-        // Prompt for export
-        const exportData = await this.promptForExport(config);
-        
-        if (!exportData) {
-            return false;
-        }
-        
-        // Export configuration
-        const exportResult = configurationManager.exportConfiguration(config, exportData);
-        
-        // Save to file
-        const filename = this.saveExportToFile(exportResult, destinationPath);
-        
-        // Display success message
-        this.displayExportSuccess(filename);
-        
-        return true;
-    }
-}

package/src/lib/dataset-slug.js

@@ -1,152 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * Dataset Slug Derivation
- *
- * Derives a deterministic, short slug from a dataset URI for use in
- * tuning-job-aware adapter naming conventions.
- *
- * Slugification rules:
- * - Lowercase
- * - Strip non-alphanumeric characters (keep hyphens)
- * - Truncate to 20 characters
- * - Replace consecutive hyphens with single hyphen
- * - Strip leading/trailing hyphens
- *
- * Examples:
- *   hf://org/name           -> "name"
- *   hf://tatsu-lab/alpaca   -> "alpaca"
- *   hf://Open-Orca/OpenOrca -> "openorca"
- *   s3://bucket/path/file.jsonl -> "file"
- *
- * Requirements: US-4 (AC-4.2)
- */
-
-/**
- * Derive a dataset slug from a dataset URI.
- *
- * @param {string} datasetUri - Dataset URI (s3://... or hf://...)
- * @returns {string} The derived slug, or empty string if extraction fails
- */
-export function deriveDatasetSlug(datasetUri) {
-    if (!datasetUri || typeof datasetUri !== 'string') {
-        return '';
-    }
-
-    let rawName = '';
-
-    if (datasetUri.startsWith('hf://')) {
-        // hf://org/name[/split][?file=pattern]
-        // Extract the dataset name (second path component)
-        const hfPath = datasetUri.slice(5); // remove "hf://"
-        const withoutQuery = hfPath.split('?')[0]; // remove ?file=...
-        const parts = withoutQuery.split('/');
-        // parts[0] = org, parts[1] = name, parts[2+] = split
-        rawName = parts[1] || parts[0] || '';
-    } else if (datasetUri.startsWith('s3://')) {
-        // s3://bucket/path/file.jsonl -> slug from filename (without extension)
-        const s3Path = datasetUri.slice(5); // remove "s3://"
-        const parts = s3Path.split('/');
-        const filename = parts[parts.length - 1] || '';
-        // Remove file extension
-        const dotIndex = filename.lastIndexOf('.');
-        rawName = dotIndex > 0 ? filename.substring(0, dotIndex) : filename;
-    } else {
-        // Unknown format — try to extract last path component
-        const parts = datasetUri.split('/');
-        rawName = parts[parts.length - 1] || '';
-    }
-
-    return slugify(rawName);
-}
-
-/**
- * Apply slugification rules to a raw name.
- *
- * @param {string} raw - Raw name to slugify
- * @returns {string} Slugified string
- */
-export function slugify(raw) {
-    if (!raw) return '';
-
-    let slug = raw
-        .toLowerCase()                      // lowercase
-        .replace(/[^a-z0-9-]/g, '')         // strip non-alphanumeric (keep hyphens)
-        .replace(/-{2,}/g, '-')             // replace consecutive hyphens
-        .replace(/^-+/, '')                 // strip leading hyphens
-        .replace(/-+$/, '');                // strip trailing hyphens
-
-    // Truncate to 20 chars
-    if (slug.length > 20) {
-        slug = slug.substring(0, 20);
-        // Don't end on a hyphen after truncation
-        slug = slug.replace(/-+$/, '');
-    }
-
-    return slug;
-}
-
-/**
- * Resolve a --from-tune argument to the appropriate config variable name.
- *
- * Resolution rules:
- * - No arg (empty/null) -> TUNE_OUTPUT_PATH_LATEST
- * - technique only (e.g., "sft") -> TUNE_ADAPTER_PATH_SFT
- * - technique-dataset compound (e.g., "sft-alpaca") -> TUNE_ADAPTER_PATH_SFT_ALPACA
- *
- * @param {string} fromTuneArg - The --from-tune argument value
- * @param {function} configVarExists - Function that checks if a config var exists
- * @returns {{ varName: string, technique: string, slug: string, isCompound: boolean, fallback: string|null }}
- */
-export function resolveFromTuneVar(fromTuneArg, configVarExists) {
-    if (!fromTuneArg) {
-        return {
-            varName: 'TUNE_OUTPUT_PATH_LATEST',
-            technique: '',
-            slug: '',
-            isCompound: false,
-            fallback: null
-        };
-    }
-
-    const upper = fromTuneArg.toUpperCase();
-
-    // Check if argument contains a hyphen — potential compound key
-    const hyphenIndex = fromTuneArg.indexOf('-');
-    if (hyphenIndex > 0) {
-        const technique = fromTuneArg.substring(0, hyphenIndex);
-        const slug = fromTuneArg.substring(hyphenIndex + 1);
-        const techniqueUpper = technique.toUpperCase();
-        const slugUpper = slug.toUpperCase().replace(/-/g, '_');
-        const compoundVar = `TUNE_ADAPTER_PATH_${techniqueUpper}_${slugUpper}`;
-
-        if (configVarExists(compoundVar)) {
-            return {
-                varName: compoundVar,
-                technique,
-                slug,
-                isCompound: true,
-                fallback: null
-            };
-        }
-
-        // Compound key doesn't exist — fallback to technique-only
-        return {
-            varName: `TUNE_ADAPTER_PATH_${techniqueUpper}`,
-            technique,
-            slug,
-            isCompound: false,
-            fallback: compoundVar // the compound var that was tried but didn't exist
-        };
-    }
-
-    // No hyphen — technique-only
-    return {
-        varName: `TUNE_ADAPTER_PATH_${upper}`,
-        technique: fromTuneArg,
-        slug: '',
-        isCompound: false,
-        fallback: null
-    };
-}

package/src/lib/docker-introspection-validator.js

@@ -1,51 +0,0 @@
-/**
- * Docker Introspection Validator Strategy (Opt-in)
- * 
- * Validates environment variables by introspecting Docker images.
- * This is an experimental strategy that requires Docker to be available.
- * 
- * Requirements: 13.11, 13.18
- */
-export default class DockerIntrospectionValidator {
-    /**
-     * Create a new DockerIntrospectionValidator.
-     */
-    constructor() {
-        this.name = 'docker-introspection';
-    }
-    
-    /**
-     * Validate environment variables using Docker introspection.
-     * 
-     * Note: This is an experimental feature and not tested in CI/CD.
-     * It requires Docker to be available and the framework image to be pullable.
-     * 
-     * @param {string} framework - Framework name
-     * @param {string} version - Framework version
-     * @param {Object} envVars - Environment variables to validate
-     * @returns {Object} ValidationResult
-     * @returns {Array<Object>} ValidationResult.warnings - Warning messages
-     * @returns {Array<Object>} ValidationResult.errors - Error messages
-     */
-    async validate(_framework, _version, _envVars) {
-        const warnings = [];
-        const errors = [];
-        
-        // Add experimental warning
-        warnings.push({
-            key: null,
-            message: 'Docker introspection validation is experimental and not tested in CI/CD'
-        });
-        
-        // Docker introspection implementation would go here
-        // This is a placeholder for the opt-in experimental feature
-        // Actual implementation would:
-        // 1. Pull the framework Docker image
-        // 2. Run a container with the env vars
-        // 3. Check if the container starts successfully
-        // 4. Parse any error messages from the container logs
-        
-        // For now, just return the experimental warning
-        return { warnings, errors };
-    }
-}

package/src/lib/known-flags-validator.js

@@ -1,200 +0,0 @@
-/**
- * Known Flags Validator Strategy
- * 
- * Validates environment variables against a registry of known flags for each framework.
- * Checks variable names, types, and range constraints.
- * 
- * Requirements: 13.9, 13.13, 13.14, 13.15
- */
-export default class KnownFlagsValidator {
-    /**
-     * Create a new KnownFlagsValidator.
-     * 
-     * @param {Object} frameworkFlags - Framework flags registry
-     */
-    constructor(frameworkFlags = {}) {
-        this.frameworkFlags = frameworkFlags;
-        this.name = 'known-flags-registry';
-    }
-    
-    /**
-     * Validate environment variables against known flags registry.
-     * 
-     * @param {string} framework - Framework name
-     * @param {string} version - Framework version
-     * @param {Object} envVars - Environment variables to validate
-     * @returns {Object} ValidationResult
-     * @returns {Array<Object>} ValidationResult.warnings - Warning messages
-     * @returns {Array<Object>} ValidationResult.errors - Error messages
-     */
-    async validate(framework, version, envVars) {
-        const warnings = [];
-        const errors = [];
-        
-        // Get known flags for this framework version
-        const knownFlags = this.getKnownFlags(framework, version);
-        
-        if (!knownFlags || Object.keys(knownFlags).length === 0) {
-            // No known flags data available
-            return { warnings, errors };
-        }
-        
-        // Validate each environment variable
-        for (const [key, value] of Object.entries(envVars)) {
-            const flagSpec = knownFlags[key];
-            
-            if (!flagSpec) {
-                // Unknown flag - might be valid but not in our registry
-                warnings.push({
-                    key,
-                    message: `Unknown environment variable '${key}' for ${framework} ${version}`
-                });
-                continue;
-            }
-            
-            // Check if flag is deprecated
-            if (flagSpec.deprecated) {
-                warnings.push({
-                    key,
-                    message: `Environment variable '${key}' is deprecated. ${flagSpec.deprecationMessage || ''}`
-                });
-                
-                if (flagSpec.replacement) {
-                    warnings.push({
-                        key,
-                        message: `Consider using '${flagSpec.replacement}' instead of '${key}'`
-                    });
-                }
-            }
-            
-            // Validate type
-            const typeError = this.validateType(key, value, flagSpec.type);
-            if (typeError) {
-                errors.push(typeError);
-                continue; // Skip range validation if type is wrong
-            }
-            
-            // Validate range constraints
-            const rangeError = this.validateRange(key, value, flagSpec);
-            if (rangeError) {
-                errors.push(rangeError);
-            }
-        }
-        
-        return { warnings, errors };
-    }
-    
-    /**
-     * Get known flags for a framework version.
-     * 
-     * @param {string} framework - Framework name
-     * @param {string} version - Framework version
-     * @returns {Object|null} Known flags specification
-     * @private
-     */
-    getKnownFlags(framework, version) {
-        if (!this.frameworkFlags[framework]) {
-            return null;
-        }
-        
-        // Try exact version match first
-        if (this.frameworkFlags[framework][version]) {
-            return this.frameworkFlags[framework][version];
-        }
-        
-        // Try to find closest version (simplified - just use 'default' if available)
-        if (this.frameworkFlags[framework].default) {
-            return this.frameworkFlags[framework].default;
-        }
-        
-        return null;
-    }
-    
-    /**
-     * Validate environment variable type.
-     * 
-     * @param {string} key - Variable name
-     * @param {string} value - Variable value
-     * @param {string} expectedType - Expected type (integer, float, string, boolean)
-     * @returns {Object|null} Error object or null if valid
-     * @private
-     */
-    validateType(key, value, expectedType) {
-        if (!expectedType) {
-            return null; // No type constraint
-        }
-        
-        switch (expectedType) {
-        case 'integer':
-            if (!/^-?\d+$/.test(value)) {
-                return {
-                    key,
-                    message: `Environment variable '${key}' must be an integer, got '${value}'`
-                };
-            }
-            break;
-                
-        case 'float':
-            if (!/^-?\d+(\.\d+)?$/.test(value)) {
-                return {
-                    key,
-                    message: `Environment variable '${key}' must be a float, got '${value}'`
-                };
-            }
-            break;
-                
-        case 'boolean':
-            if (!['true', 'false', '0', '1', 'yes', 'no'].includes(value.toLowerCase())) {
-                return {
-                    key,
-                    message: `Environment variable '${key}' must be a boolean (true/false, 0/1, yes/no), got '${value}'`
-                };
-            }
-            break;
-                
-        case 'string':
-            // String is always valid
-            break;
-                
-        default:
-            // Unknown type - skip validation
-            break;
-        }
-        
-        return null;
-    }
-    
-    /**
-     * Validate environment variable range constraints.
-     * 
-     * @param {string} key - Variable name
-     * @param {string} value - Variable value
-     * @param {Object} flagSpec - Flag specification with min/max constraints
-     * @returns {Object|null} Error object or null if valid
-     * @private
-     */
-    validateRange(key, value, flagSpec) {
-        // Only validate range for numeric types
-        if (flagSpec.type !== 'integer' && flagSpec.type !== 'float') {
-            return null;
-        }
-        
-        const numValue = parseFloat(value);
-        
-        if (flagSpec.min !== undefined && numValue < flagSpec.min) {
-            return {
-                key,
-                message: `Environment variable '${key}' must be >= ${flagSpec.min}, got ${value}`
-            };
-        }
-        
-        if (flagSpec.max !== undefined && numValue > flagSpec.max) {
-            return {
-                key,
-                message: `Environment variable '${key}' must be <= ${flagSpec.max}, got ${value}`
-            };
-        }
-        
-        return null;
-    }
-}