@aws/ml-container-creator 0.2.1 → 0.2.2

package/src/app.js

@@ -1,28 +1,28 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-import { spawn } from 'child_process'
-
-import { copyTpl } from './copy-tpl.js'
-import { runPrompts } from './prompt-adapter.js'
-import ConfigManager from './lib/config-manager.js'
-import PromptRunner from './lib/prompt-runner.js'
-import TemplateManager from './lib/template-manager.js'
-import DeploymentConfigResolver from './lib/deployment-config-resolver.js'
-import CommentGenerator from './lib/comment-generator.js'
-import ConfigurationManager from './lib/configuration-manager.js'
-import RegistryLoader from './lib/registry-loader.js'
-import { resolvePrefixedEnvVars } from './lib/engine-prefix-resolver.js'
-import ejs from 'ejs'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const GENERATOR_ROOT = path.resolve(__dirname, '..')
-const TEMPLATE_DIR = path.join(GENERATOR_ROOT, 'templates')
-const LIB_DIR = path.join(GENERATOR_ROOT, 'src', 'lib')
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+import { copyTpl } from './copy-tpl.js';
+import { runPrompts } from './prompt-adapter.js';
+import ConfigManager from './lib/config-manager.js';
+import PromptRunner from './lib/prompt-runner.js';
+import TemplateManager from './lib/template-manager.js';
+import DeploymentConfigResolver from './lib/deployment-config-resolver.js';
+import CommentGenerator from './lib/comment-generator.js';
+import ConfigurationManager from './lib/configuration-manager.js';
+import RegistryLoader from './lib/registry-loader.js';
+import { resolvePrefixedEnvVars } from './lib/engine-prefix-resolver.js';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const GENERATOR_ROOT = path.resolve(__dirname, '..');
+const TEMPLATE_DIR = path.join(GENERATOR_ROOT, 'templates');
+const LIB_DIR = path.join(GENERATOR_ROOT, 'src', 'lib');
 
 /**
  * Main application entry point.
@@ -37,41 +37,41 @@ export async function run(projectName, options) {
     // --- Phase: Initializing ---
     // Convert commander's camelCase options to kebab-case for ConfigManager compatibility
     // (ConfigManager expects kebab-case format for option keys)
-    const kebabOptions = _toKebabCaseOptions(options)
+    const kebabOptions = _toKebabCaseOptions(options);
 
     // Build a lightweight adapter that satisfies ConfigManager's generator interface
-    const generatorAdapter = _createGeneratorAdapter(projectName, kebabOptions)
-    const args = projectName ? [projectName] : []
+    const generatorAdapter = _createGeneratorAdapter(projectName, kebabOptions);
+    const args = projectName ? [projectName] : [];
 
-    const configManager = new ConfigManager({ options: kebabOptions, args })
+    const configManager = new ConfigManager({ options: kebabOptions, args });
 
-    let baseConfig
+    let baseConfig;
     try {
-        baseConfig = await configManager.loadConfiguration()
+        baseConfig = await configManager.loadConfiguration();
     } catch (error) {
-        console.log(`⚠️  ${error.message}`)
-        return
+        console.log(`⚠️  ${error.message}`);
+        return;
     }
 
-    const errors = configManager.validateConfiguration()
+    const errors = configManager.validateConfiguration();
     if (errors.length > 0) {
-        console.log(`⚠️  ${errors[0]}`)
-        return
+        console.log(`⚠️  ${errors[0]}`);
+        return;
     }
 
     // Initialize registry system
-    let registryConfigManager = null
-    let tritonBackends = {}
+    let registryConfigManager = null;
+    let tritonBackends = {};
     try {
-        const validateEnvVars = kebabOptions['validate-env-vars'] !== false
-        const validateWithDocker = kebabOptions['validate-with-docker'] === true
-        const offline = kebabOptions['offline'] === true
+        const validateEnvVars = kebabOptions['validate-env-vars'] !== false;
+        const validateWithDocker = kebabOptions['validate-with-docker'] === true;
+        const offline = kebabOptions['offline'] === true;
 
-        let effectiveValidateWithDocker = validateWithDocker
+        let effectiveValidateWithDocker = validateWithDocker;
         if (validateWithDocker && !validateEnvVars) {
-            console.log('\n⚠️  Warning: --validate-with-docker requires --validate-env-vars to be enabled')
-            console.log('   Docker validation will be disabled')
-            effectiveValidateWithDocker = false
+            console.log('\n⚠️  Warning: --validate-with-docker requires --validate-env-vars to be enabled');
+            console.log('   Docker validation will be disabled');
+            effectiveValidateWithDocker = false;
         }
 
         registryConfigManager = new ConfigurationManager({
@@ -79,82 +79,82 @@ export async function run(projectName, options) {
             validateWithDocker: effectiveValidateWithDocker,
             offline,
             hfTimeout: 5000
-        })
+        });
 
-        await registryConfigManager.loadRegistries()
+        await registryConfigManager.loadRegistries();
 
-        const registryLoader = new RegistryLoader()
-        tritonBackends = await registryLoader.loadTritonBackends()
+        const registryLoader = new RegistryLoader();
+        tritonBackends = await registryLoader.loadTritonBackends();
 
-        console.log('\n📚 Registry System Initialized')
-        console.log('   • Framework Registry: Loaded')
-        console.log('   • Model Registry: Loaded')
-        console.log('   • Instance Accelerator Mapping: Loaded')
+        console.log('\n📚 Registry System Initialized');
+        console.log('   • Framework Registry: Loaded');
+        console.log('   • Model Registry: Loaded');
+        console.log('   • Instance Accelerator Mapping: Loaded');
 
         if (validateEnvVars) {
-            console.log('   • Environment Variable Validation: Enabled')
+            console.log('   • Environment Variable Validation: Enabled');
             if (effectiveValidateWithDocker) {
-                console.log('   • Docker Introspection Validation: Enabled (experimental)')
+                console.log('   • Docker Introspection Validation: Enabled (experimental)');
             }
         } else {
-            console.log('   • Environment Variable Validation: Disabled')
+            console.log('   • Environment Variable Validation: Disabled');
         }
 
         if (offline) {
-            console.log('   • HuggingFace API: Offline mode')
+            console.log('   • HuggingFace API: Offline mode');
         }
     } catch (error) {
-        console.log('\n⚠️  Registry system initialization failed, using defaults')
-        console.log(`   Error: ${error.message}`)
-        registryConfigManager = null
-        tritonBackends = {}
+        console.log('\n⚠️  Registry system initialization failed, using defaults');
+        console.log(`   Error: ${error.message}`);
+        registryConfigManager = null;
+        tritonBackends = {};
     }
 
     // Attach registry info to the adapter so PromptRunner can access it
-    generatorAdapter.registryConfigManager = registryConfigManager
-    generatorAdapter.configManager = configManager
-    generatorAdapter.baseConfig = baseConfig
+    generatorAdapter.registryConfigManager = registryConfigManager;
+    generatorAdapter.configManager = configManager;
+    generatorAdapter.baseConfig = baseConfig;
 
     // --- Phase: Prompting ---
-    let answers
+    let answers;
     if (configManager.shouldSkipPrompts()) {
-        console.log('\n🚀 Skipping prompts - using configuration from other sources')
-        answers = configManager.getFinalConfiguration()
+        console.log('\n🚀 Skipping prompts - using configuration from other sources');
+        answers = configManager.getFinalConfiguration();
 
         // Infer modelSource from model name prefix if not set
-        const modelName = answers.modelName
+        const modelName = answers.modelName;
         if (!answers.modelSource && modelName) {
             if (modelName.startsWith('s3://')) {
-                answers.modelSource = 's3'
+                answers.modelSource = 's3';
                 if (!answers.artifactUri) {
-                    answers.artifactUri = modelName
+                    answers.artifactUri = modelName;
                 }
             } else if (modelName.startsWith('jumpstart://')) {
-                answers.modelSource = 'jumpstart'
+                answers.modelSource = 'jumpstart';
             } else if (modelName.startsWith('jumpstart-hub://')) {
-                answers.modelSource = 'jumpstart-hub'
+                answers.modelSource = 'jumpstart-hub';
             } else if (modelName.startsWith('registry://')) {
-                answers.modelSource = 'registry'
+                answers.modelSource = 'registry';
             }
         }
 
         // Warn about unsupported model sources
         if (answers.modelSource === 'jumpstart-hub') {
-            console.log('\n   ⚠️  JumpStart Private Hub models are not yet fully supported.')
-            console.log('   The generated project will not be able to download model artifacts at runtime.')
-            console.log('   This feature is tracked for a future release.')
-            console.log('   Falling back to HuggingFace source.\n')
-            answers.modelSource = 'huggingface'
-            delete answers.artifactUri
+            console.log('\n   ⚠️  JumpStart Private Hub models are not yet fully supported.');
+            console.log('   The generated project will not be able to download model artifacts at runtime.');
+            console.log('   This feature is tracked for a future release.');
+            console.log('   Falling back to HuggingFace source.\n');
+            answers.modelSource = 'huggingface';
+            delete answers.artifactUri;
         }
 
         // Note about registry model requirements
         if (answers.modelSource === 'registry') {
-            console.log('\n   ℹ️  Registry model: the container will resolve the artifact URI at startup')
-            console.log('   via DescribeModelPackage. Ensure the model package has a valid')
-            console.log('   InferenceSpecification with ModelDataUrl or S3DataSource.')
-            console.log('   If your model package lacks an InferenceSpecification, use the S3 path')
-            console.log('   directly instead: --model-name="s3://bucket/path/model.tar.gz"\n')
+            console.log('\n   ℹ️  Registry model: the container will resolve the artifact URI at startup');
+            console.log('   via DescribeModelPackage. Ensure the model package has a valid');
+            console.log('   InferenceSpecification with ModelDataUrl or S3DataSource.');
+            console.log('   If your model package lacks an InferenceSpecification, use the S3 path');
+            console.log('   directly instead: --model-name="s3://bucket/path/model.tar.gz"\n');
         }
     } else {
         const promptRunner = new PromptRunner({
@@ -162,25 +162,25 @@ export async function run(projectName, options) {
             options: kebabOptions,
             registryConfigManager,
             baseConfig
-        })
-        const promptAnswers = await promptRunner.run()
-        answers = configManager.getFinalConfiguration(promptAnswers)
+        });
+        const promptAnswers = await promptRunner.run();
+        answers = configManager.getFinalConfiguration(promptAnswers);
     }
 
     // Ensure template variables have defaults and enrich with registry data
-    await _ensureTemplateVariables(answers, registryConfigManager)
+    await _ensureTemplateVariables(answers, registryConfigManager);
 
     // --- Phase: Writing ---
-    const destDir = path.resolve(answers.destinationDir)
-    fs.mkdirSync(destDir, { recursive: true })
+    const destDir = path.resolve(answers.destinationDir);
+    fs.mkdirSync(destDir, { recursive: true });
 
-    await writeProject(TEMPLATE_DIR, destDir, answers, registryConfigManager, tritonBackends, configManager)
+    await writeProject(TEMPLATE_DIR, destDir, answers, registryConfigManager, tritonBackends, configManager);
 
     // --- Phase: End ---
-    await postGenerate(destDir, answers, tritonBackends)
+    await postGenerate(destDir, answers, tritonBackends);
 
-    console.log('\n✅ Project generated successfully!')
-    console.log(`   📁 ${destDir}`)
+    console.log('\n✅ Project generated successfully!');
+    console.log(`   📁 ${destDir}`);
 }
 
 /**
@@ -196,46 +196,46 @@ export async function run(projectName, options) {
 export async function writeProject(templateDir, destDir, answers, registryConfigManager = null, tritonBackends = {}, configManager = null) {
     // Validate required parameters via ConfigManager
     if (configManager) {
-        const requiredParamErrors = configManager.validateRequiredParameters(answers)
+        const requiredParamErrors = configManager.validateRequiredParameters(answers);
         if (requiredParamErrors.length > 0) {
-            console.log('\n❌ Required Parameter Validation Failed:')
+            console.log('\n❌ Required Parameter Validation Failed:');
             requiredParamErrors.forEach(error => {
-                console.log(`   • ${error}`)
-            })
-            console.log('\nPlease provide the missing required parameters and try again.')
-            throw new Error('Required parameters are missing. Cannot proceed with file generation.')
+                console.log(`   • ${error}`);
+            });
+            console.log('\nPlease provide the missing required parameters and try again.');
+            throw new Error('Required parameters are missing. Cannot proceed with file generation.');
         }
     }
 
     // Validate environment variables if registry system is available
     if (registryConfigManager && (answers.frameworkVersion || answers.architecture === 'triton')) {
-        await _validateEnvironmentVariables(answers, registryConfigManager)
+        await _validateEnvironmentVariables(answers, registryConfigManager);
     }
 
     // Validate template configuration
-    const templateManager = new TemplateManager(answers)
-    templateManager.validate()
+    const templateManager = new TemplateManager(answers);
+    templateManager.validate();
 
     // Generate comments for templates
-    const commentGenerator = new CommentGenerator()
-    const comments = commentGenerator.generateDockerfileComments(answers)
+    const commentGenerator = new CommentGenerator();
+    const comments = commentGenerator.generateDockerfileComments(answers);
 
     // Prepare ordered environment variables
-    const orderedEnvVars = _getOrderedEnvVars(answers.envVars || {})
+    const orderedEnvVars = _getOrderedEnvVars(answers.envVars || {});
 
     // Append model env vars and prefixed server env vars
-    const modelEnvVars = answers.modelEnvVars || {}
-    const serverEnvVars = answers.serverEnvVars || {}
-    const engine = answers.modelServer || answers.backend || ''
+    const modelEnvVars = answers.modelEnvVars || {};
+    const serverEnvVars = answers.serverEnvVars || {};
+    const engine = answers.modelServer || answers.backend || '';
 
     Object.entries(modelEnvVars).forEach(([key, value]) => {
-        orderedEnvVars.push({ key, value })
-    })
+        orderedEnvVars.push({ key, value });
+    });
 
-    const prefixedServerEnvVars = resolvePrefixedEnvVars(engine, serverEnvVars)
+    const prefixedServerEnvVars = resolvePrefixedEnvVars(engine, serverEnvVars);
     Object.entries(prefixedServerEnvVars).forEach(([key, value]) => {
-        orderedEnvVars.push({ key, value })
-    })
+        orderedEnvVars.push({ key, value });
+    });
 
     // Prepare template variables
     const templateVars = {
@@ -243,130 +243,130 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
         comments,
         orderedEnvVars,
         serverEnvVars: prefixedServerEnvVars
-    }
+    };
 
     // Build ignore patterns
-    const ignorePatterns = []
+    const ignorePatterns = [];
 
     if (answers.deploymentTarget !== 'hyperpod-eks') {
-        ignorePatterns.push('**/hyperpod/**')
+        ignorePatterns.push('**/hyperpod/**');
     }
 
     // Resolve architecture
-    const resolver = new DeploymentConfigResolver()
-    let architecture = answers.architecture
+    const resolver = new DeploymentConfigResolver();
+    let architecture = answers.architecture;
 
     if (!architecture && answers.deploymentConfig) {
         try {
-            const parts = resolver.decompose(answers.deploymentConfig)
-            architecture = parts.architecture
+            const parts = resolver.decompose(answers.deploymentConfig);
+            architecture = parts.architecture;
         } catch (e) {
-            architecture = answers.framework === 'transformers' ? 'transformers' : 'http'
+            architecture = answers.framework === 'transformers' ? 'transformers' : 'http';
         }
     } else if (!architecture) {
-        architecture = answers.framework === 'transformers' ? 'transformers' : 'http'
+        architecture = answers.framework === 'transformers' ? 'transformers' : 'http';
     }
 
     // Exclude sample_model when not needed
     if (!answers.includeSampleModel || architecture === 'transformers' || architecture === 'diffusors') {
-        ignorePatterns.push('**/sample_model/**')
+        ignorePatterns.push('**/sample_model/**');
     }
 
     // Always exclude triton and diffusors source directories
-    ignorePatterns.push('**/triton/**')
-    ignorePatterns.push('**/diffusors/**')
+    ignorePatterns.push('**/triton/**');
+    ignorePatterns.push('**/diffusors/**');
 
     // For triton and diffusors, exclude the default Dockerfile
     if (architecture === 'triton' || architecture === 'diffusors') {
-        ignorePatterns.push('**/Dockerfile')
+        ignorePatterns.push('**/Dockerfile');
     }
 
     // Copy all templates with EJS rendering
-    copyTpl(templateDir, destDir, templateVars, ignorePatterns)
+    copyTpl(templateDir, destDir, templateVars, ignorePatterns);
 
     // Architecture-specific file routing (delete files that don't belong)
     switch (architecture) {
     case 'http':
-        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'))
-        _unlinkIfExists(path.join(destDir, 'code/serve'))
-        _unlinkIfExists(path.join(destDir, 'code/serving.properties'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'))
+        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'));
+        _unlinkIfExists(path.join(destDir, 'code/serve'));
+        _unlinkIfExists(path.join(destDir, 'code/serving.properties'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'));
 
         if (answers.modelServer !== 'flask' && answers.backend !== 'flask') {
-            _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'))
-            _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'))
+            _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'));
+            _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'));
         }
-        break
+        break;
 
     case 'transformers':
-        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'))
-        _unlinkIfExists(path.join(destDir, 'code/serve.py'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.py'))
-        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'))
-        break
+        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'));
+        _unlinkIfExists(path.join(destDir, 'code/serve.py'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.py'));
+        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'));
+        break;
 
     case 'triton':
-        _unlinkIfExists(path.join(destDir, 'code/serve.py'))
-        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.py'))
-        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'))
-        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'))
-        _unlinkIfExists(path.join(destDir, 'code/serve'))
-        _unlinkIfExists(path.join(destDir, 'code/serving.properties'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'))
+        _unlinkIfExists(path.join(destDir, 'code/serve.py'));
+        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.py'));
+        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'));
+        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'));
+        _unlinkIfExists(path.join(destDir, 'code/serve'));
+        _unlinkIfExists(path.join(destDir, 'code/serving.properties'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'));
 
         // Generate Triton-specific files
-        _generateTritonFiles(templateDir, destDir, templateVars, answers, tritonBackends)
-        break
+        _generateTritonFiles(templateDir, destDir, templateVars, answers, tritonBackends);
+        break;
 
     case 'diffusors':
-        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'))
-        _unlinkIfExists(path.join(destDir, 'code/serve.py'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.py'))
-        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'))
-        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'))
-        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'))
-        _unlinkIfExists(path.join(destDir, 'code/serving.properties'))
+        _unlinkIfExists(path.join(destDir, 'code/model_handler.py'));
+        _unlinkIfExists(path.join(destDir, 'code/serve.py'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.py'));
+        _unlinkIfExists(path.join(destDir, 'nginx-predictors.conf'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/wsgi.py'));
+        _unlinkIfExists(path.join(destDir, 'code/flask/gunicorn_config.py'));
+        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'));
+        _unlinkIfExists(path.join(destDir, 'code/serving.properties'));
 
         // Copy diffusors-specific templates
-        _renderTemplate(path.join(templateDir, 'diffusors/Dockerfile'), path.join(destDir, 'Dockerfile'), templateVars)
-        _renderTemplate(path.join(templateDir, 'diffusors/serve'), path.join(destDir, 'code/serve'), templateVars)
-        _renderTemplate(path.join(templateDir, 'diffusors/start_server.sh'), path.join(destDir, 'code/start_server.sh'), templateVars)
-        _copyFile(path.join(templateDir, 'diffusors/patch_image_api.py'), path.join(destDir, 'code/patch_image_api.py'))
-        break
+        _renderTemplate(path.join(templateDir, 'diffusors/Dockerfile'), path.join(destDir, 'Dockerfile'), templateVars);
+        _renderTemplate(path.join(templateDir, 'diffusors/serve'), path.join(destDir, 'code/serve'), templateVars);
+        _renderTemplate(path.join(templateDir, 'diffusors/start_server.sh'), path.join(destDir, 'code/start_server.sh'), templateVars);
+        _copyFile(path.join(templateDir, 'diffusors/patch_image_api.py'), path.join(destDir, 'code/patch_image_api.py'));
+        break;
 
     default:
         // Fallback to HTTP behavior
-        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'))
-        _unlinkIfExists(path.join(destDir, 'code/serve'))
-        _unlinkIfExists(path.join(destDir, 'code/serving.properties'))
-        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'))
+        _unlinkIfExists(path.join(destDir, 'code/chat_template.jinja'));
+        _unlinkIfExists(path.join(destDir, 'code/serve'));
+        _unlinkIfExists(path.join(destDir, 'code/serving.properties'));
+        _unlinkIfExists(path.join(destDir, 'code/start_server.sh'));
     }
 
     // nginx-tensorrt.conf: only needed for TensorRT-LLM
     if (answers.modelServer !== 'tensorrt-llm' && answers.backend !== 'tensorrt-llm') {
-        _unlinkIfExists(path.join(destDir, 'nginx-tensorrt.conf'))
+        _unlinkIfExists(path.join(destDir, 'nginx-tensorrt.conf'));
     }
 
     // nginx-diffusors.conf: only needed for diffusors architecture
     if (answers.architecture !== 'diffusors') {
-        _unlinkIfExists(path.join(destDir, 'nginx-diffusors.conf'))
+        _unlinkIfExists(path.join(destDir, 'nginx-diffusors.conf'));
     }
 
     // Copy PROJECT_README.md as README.md (overwriting the template README)
-    _renderTemplate(path.join(templateDir, 'PROJECT_README.md'), path.join(destDir, 'README.md'), templateVars)
+    _renderTemplate(path.join(templateDir, 'PROJECT_README.md'), path.join(destDir, 'README.md'), templateVars);
 
     // Copy do/lib/ Node.js modules (plain copy, no EJS)
-    const doLibDir = path.join(destDir, 'do', 'lib')
-    fs.mkdirSync(doLibDir, { recursive: true })
-    _copyFile(path.join(LIB_DIR, 'manifest-cli.js'), path.join(doLibDir, 'manifest-cli.js'))
-    _copyFile(path.join(LIB_DIR, 'asset-manager.js'), path.join(doLibDir, 'asset-manager.js'))
-    _copyFile(path.join(LIB_DIR, 'bootstrap-config.js'), path.join(doLibDir, 'bootstrap-config.js'))
+    const doLibDir = path.join(destDir, 'do', 'lib');
+    fs.mkdirSync(doLibDir, { recursive: true });
+    _copyFile(path.join(LIB_DIR, 'manifest-cli.js'), path.join(doLibDir, 'manifest-cli.js'));
+    _copyFile(path.join(LIB_DIR, 'asset-manager.js'), path.join(doLibDir, 'asset-manager.js'));
+    _copyFile(path.join(LIB_DIR, 'bootstrap-config.js'), path.join(doLibDir, 'bootstrap-config.js'));
 }
 
 /**
@@ -379,15 +379,15 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
  */
 export async function postGenerate(destDir, answers, tritonBackends = {}) {
     // Set executable permissions on shell scripts
-    _setExecutablePermissions(destDir)
+    _setExecutablePermissions(destDir);
 
     // Run sample model training if requested
-    const architecture = answers.architecture
+    const architecture = answers.architecture;
     const skipSampleTraining = architecture === 'transformers' ||
-        (architecture === 'triton' && !tritonBackends[answers.backend]?.supportsSampleModel)
+        (architecture === 'triton' && !tritonBackends[answers.backend]?.supportsSampleModel);
 
     if (answers.includeSampleModel && !skipSampleTraining) {
-        await _runSampleModelTraining(destDir)
+        await _runSampleModelTraining(destDir);
     }
 }
 
@@ -402,13 +402,13 @@ export async function postGenerate(destDir, answers, tritonBackends = {}) {
  * @returns {object} Options with kebab-case keys
  */
 function _toKebabCaseOptions(options) {
-    const kebabOptions = {}
+    const kebabOptions = {};
     for (const [key, value] of Object.entries(options)) {
         // Convert camelCase to kebab-case
-        const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()
-        kebabOptions[kebabKey] = value
+        const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
+        kebabOptions[kebabKey] = value;
     }
-    return kebabOptions
+    return kebabOptions;
 }
 
 /**
@@ -420,31 +420,31 @@ function _toKebabCaseOptions(options) {
  * @returns {object} Generator-like adapter
  */
 function _createGeneratorAdapter(projectName, options) {
-    const args = projectName ? [projectName] : []
-    let _destinationPath = process.cwd()
+    const args = projectName ? [projectName] : [];
+    let _destinationPath = process.cwd();
 
     const adapter = {
         options,
         args,
         destinationPath(...segments) {
-            if (segments.length === 0) return _destinationPath
-            return path.join(_destinationPath, ...segments)
+            if (segments.length === 0) return _destinationPath;
+            return path.join(_destinationPath, ...segments);
         },
         destinationRoot(newRoot) {
             if (newRoot !== undefined) {
-                _destinationPath = path.resolve(newRoot)
+                _destinationPath = path.resolve(newRoot);
             }
-            return _destinationPath
+            return _destinationPath;
         },
         registryConfigManager: null,
         configManager: null,
         baseConfig: {},
         async prompt(prompts) {
-            return runPrompts(prompts)
+            return runPrompts(prompts);
         }
-    }
+    };
 
-    return adapter
+    return adapter;
 }
 
 /**
@@ -491,62 +491,62 @@ async function _ensureTemplateVariables(answers, registryConfigManager = null) {
         modelSource: 'huggingface',
         artifactUri: '',
         modelLoadStrategy: 'runtime'
-    }
+    };
 
     Object.entries(defaults).forEach(([key, value]) => {
         if (answers[key] === undefined) {
-            answers[key] = value
+            answers[key] = value;
         }
-    })
+    });
 
     // Backward compatibility: populate framework and modelServer from architecture/backend
     if (!answers.framework && answers.architecture) {
-        answers.framework = answers.architecture
+        answers.framework = answers.architecture;
     }
     if (!answers.modelServer && answers.backend) {
-        answers.modelServer = answers.backend
+        answers.modelServer = answers.backend;
     }
 
     // Always include testing with all available test types
-    answers.includeTesting = true
+    answers.includeTesting = true;
     if (!answers.testTypes || answers.testTypes.length === 0) {
         if (answers.architecture === 'transformers' || answers.framework === 'transformers') {
-            answers.testTypes = ['hosted-model-endpoint']
+            answers.testTypes = ['hosted-model-endpoint'];
         } else {
-            answers.testTypes = ['local-model-cli', 'local-model-server', 'hosted-model-endpoint']
+            answers.testTypes = ['local-model-cli', 'local-model-server', 'hosted-model-endpoint'];
         }
     }
 
     // Merge catalog env vars into answers.envVars with correct precedence
-    await _mergeEnvVarsWithPrecedence(answers, registryConfigManager)
+    await _mergeEnvVarsWithPrecedence(answers, registryConfigManager);
 
     // For Triton architecture, set default base image fallback
     if (answers.architecture === 'triton' && !answers.baseImage) {
         // Try to look up base image from framework registry using deployment-config key
-        const tritonRegistryKey = answers.deploymentConfig
+        const tritonRegistryKey = answers.deploymentConfig;
         if (tritonRegistryKey && registryConfigManager?.frameworkRegistry) {
-            const tritonFrameworkConfig = registryConfigManager.frameworkRegistry[tritonRegistryKey]
+            const tritonFrameworkConfig = registryConfigManager.frameworkRegistry[tritonRegistryKey];
             if (tritonFrameworkConfig) {
                 const versions = Object.keys(tritonFrameworkConfig).sort((a, b) =>
                     b.localeCompare(a, undefined, { numeric: true })
-                )
+                );
                 if (versions.length > 0) {
-                    const latestConfig = tritonFrameworkConfig[versions[0]]
+                    const latestConfig = tritonFrameworkConfig[versions[0]];
                     if (latestConfig.baseImage) {
-                        answers.baseImage = latestConfig.baseImage
+                        answers.baseImage = latestConfig.baseImage;
                     }
                     if (latestConfig.inferenceAmiVersion && !answers.inferenceAmiVersion) {
-                        answers.inferenceAmiVersion = latestConfig.inferenceAmiVersion
+                        answers.inferenceAmiVersion = latestConfig.inferenceAmiVersion;
                     }
                     if (latestConfig.accelerator) {
-                        answers.accelerator = latestConfig.accelerator
+                        answers.accelerator = latestConfig.accelerator;
                     }
                 }
             }
         }
         // Final fallback: hardcoded default Triton base image
         if (!answers.baseImage) {
-            answers.baseImage = 'nvcr.io/nvidia/tritonserver:24.08-py3'
+            answers.baseImage = 'nvcr.io/nvidia/tritonserver:24.08-py3';
         }
     }
 
@@ -554,34 +554,34 @@ async function _ensureTemplateVariables(answers, registryConfigManager = null) {
     if (answers.framework === 'transformers' && answers.modelName && registryConfigManager) {
         try {
             // Fetch HuggingFace data for model-specific info
-            const hfData = await registryConfigManager._fetchHuggingFaceData(answers.modelName)
+            const hfData = await registryConfigManager._fetchHuggingFaceData(answers.modelName);
 
             // Merge chatTemplate if available and not already set
             if (hfData && hfData.chatTemplate && !answers.chatTemplate) {
-                answers.chatTemplate = hfData.chatTemplate
-                answers.chatTemplateSource = 'HuggingFace_Hub_API'
+                answers.chatTemplate = hfData.chatTemplate;
+                answers.chatTemplateSource = 'HuggingFace_Hub_API';
             }
 
             // Check Model Registry for chatTemplate overrides
             if (registryConfigManager.modelRegistry) {
-                const modelConfig = _findModelConfig(answers.modelName, registryConfigManager)
+                const modelConfig = _findModelConfig(answers.modelName, registryConfigManager);
 
                 if (modelConfig && modelConfig.chatTemplate) {
-                    answers.chatTemplate = modelConfig.chatTemplate
-                    answers.chatTemplateSource = 'Model_Registry'
+                    answers.chatTemplate = modelConfig.chatTemplate;
+                    answers.chatTemplateSource = 'Model_Registry';
                 }
             }
 
             // Set framework-level metadata (non-envVar fields)
             if (answers.frameworkVersion && registryConfigManager.frameworkRegistry) {
-                const frameworkConfig = registryConfigManager.frameworkRegistry[answers.framework]?.[answers.frameworkVersion]
+                const frameworkConfig = registryConfigManager.frameworkRegistry[answers.framework]?.[answers.frameworkVersion];
 
                 if (frameworkConfig) {
                     if (frameworkConfig.inferenceAmiVersion && !answers.inferenceAmiVersion) {
-                        answers.inferenceAmiVersion = frameworkConfig.inferenceAmiVersion
+                        answers.inferenceAmiVersion = frameworkConfig.inferenceAmiVersion;
                     }
                     if (frameworkConfig.accelerator) {
-                        answers.accelerator = frameworkConfig.accelerator
+                        answers.accelerator = frameworkConfig.accelerator;
                     }
                 }
             }
@@ -598,7 +598,7 @@ async function _ensureTemplateVariables(answers, registryConfigManager = null) {
  * @returns {Array<{key: string, value: string}>} Ordered array
  */
 function _getOrderedEnvVars(envVars) {
-    const entries = Object.entries(envVars)
+    const entries = Object.entries(envVars);
 
     const priorities = {
         'LD_LIBRARY_PATH': 1,
@@ -617,26 +617,26 @@ function _getOrderedEnvVars(envVars) {
         'WORKER': 4,
         'THREAD': 4,
         'default': 5
-    }
+    };
 
     function getPriority(key) {
-        if (priorities[key]) return priorities[key]
+        if (priorities[key]) return priorities[key];
         for (const [pattern, priority] of Object.entries(priorities)) {
             if (pattern !== 'default' && key.includes(pattern)) {
-                return priority
+                return priority;
             }
         }
-        return priorities.default
+        return priorities.default;
     }
 
     const sorted = entries.sort(([keyA], [keyB]) => {
-        const priorityA = getPriority(keyA)
-        const priorityB = getPriority(keyB)
-        if (priorityA !== priorityB) return priorityA - priorityB
-        return keyA.localeCompare(keyB)
-    })
+        const priorityA = getPriority(keyA);
+        const priorityB = getPriority(keyB);
+        if (priorityA !== priorityB) return priorityA - priorityB;
+        return keyA.localeCompare(keyB);
+    });
 
-    return sorted.map(([key, value]) => ({ key, value }))
+    return sorted.map(([key, value]) => ({ key, value }));
 }
 
 /**
@@ -649,60 +649,60 @@ function _getOrderedEnvVars(envVars) {
 async function _validateEnvironmentVariables(answers, registryConfigManager) {
     // Get framework configuration
     // For Triton configs, look up using deploymentConfig key (e.g. 'triton-fil')
-    let frameworkConfig
+    let frameworkConfig;
     if (answers.architecture === 'triton' && answers.deploymentConfig) {
-        const tritonEntry = registryConfigManager.frameworkRegistry?.[answers.deploymentConfig]
+        const tritonEntry = registryConfigManager.frameworkRegistry?.[answers.deploymentConfig];
         if (tritonEntry) {
-            const versions = Object.keys(tritonEntry)
+            const versions = Object.keys(tritonEntry);
             if (versions.length > 0) {
-                frameworkConfig = tritonEntry[versions[0]]
+                frameworkConfig = tritonEntry[versions[0]];
             }
         }
     }
     if (!frameworkConfig) {
-        frameworkConfig = registryConfigManager.frameworkRegistry?.[answers.framework]?.[answers.frameworkVersion]
+        frameworkConfig = registryConfigManager.frameworkRegistry?.[answers.framework]?.[answers.frameworkVersion];
     }
 
     if (!frameworkConfig || !frameworkConfig.envVars) {
-        return // No env vars to validate
+        return; // No env vars to validate
     }
 
-    console.log('\n🔍 Validating environment variables...')
+    console.log('\n🔍 Validating environment variables...');
 
     // Validate environment variables
     const validationResult = registryConfigManager.validateEnvironmentVariables(
         frameworkConfig.envVars,
         frameworkConfig
-    )
+    );
 
     // Display validation results
     if (validationResult.errors && validationResult.errors.length > 0) {
-        console.log('\n❌ Environment Variable Validation Errors:')
+        console.log('\n❌ Environment Variable Validation Errors:');
         validationResult.errors.forEach(error => {
-            console.log(`   • ${error.key}: ${error.message}`)
-        })
+            console.log(`   • ${error.key}: ${error.message}`);
+        });
     }
 
     if (validationResult.warnings && validationResult.warnings.length > 0) {
-        console.log('\n⚠️  Environment Variable Validation Warnings:')
+        console.log('\n⚠️  Environment Variable Validation Warnings:');
         validationResult.warnings.forEach(warning => {
-            console.log(`   • ${warning.key ? `${warning.key}: ` : ''}${warning.message}`)
-        })
+            console.log(`   • ${warning.key ? `${warning.key}: ` : ''}${warning.message}`);
+        });
     }
 
     if (validationResult.strategiesUsed && validationResult.strategiesUsed.length > 0) {
-        console.log(`\n✅ Validation methods used: ${validationResult.strategiesUsed.join(', ')}`)
+        console.log(`\n✅ Validation methods used: ${validationResult.strategiesUsed.join(', ')}`);
     }
 
     if (!validationResult.errors || validationResult.errors.length === 0) {
         if (!validationResult.warnings || validationResult.warnings.length === 0) {
-            console.log('   ✅ All environment variables validated successfully')
+            console.log('   ✅ All environment variables validated successfully');
         }
     }
 
     // In non-interactive mode (skip-prompts), throw on errors
     if (validationResult.errors && validationResult.errors.length > 0) {
-        throw new Error('Environment variable validation failed. Please fix the errors and try again.')
+        throw new Error('Environment variable validation failed. Please fix the errors and try again.');
     }
 }
 
@@ -719,60 +719,60 @@ async function _validateEnvironmentVariables(answers, registryConfigManager) {
  * @param {object|null} registryConfigManager - Registry configuration manager
  */
 async function _mergeEnvVarsWithPrecedence(answers, registryConfigManager) {
-    if (!registryConfigManager) return
+    if (!registryConfigManager) return;
 
     // Capture CLI-provided env vars before merging (highest precedence)
-    const cliEnvVars = { ...answers.envVars }
+    const cliEnvVars = { ...answers.envVars };
 
     // Resolve the framework config for the selected framework + version
-    const frameworkName = answers.framework || answers.deploymentConfig
-    const frameworkVersion = answers.frameworkVersion
-    let frameworkConfig = null
+    const frameworkName = answers.framework || answers.deploymentConfig;
+    const frameworkVersion = answers.frameworkVersion;
+    let frameworkConfig = null;
 
     if (frameworkName && registryConfigManager.frameworkRegistry) {
-        const frameworkVersions = registryConfigManager.frameworkRegistry[frameworkName]
+        const frameworkVersions = registryConfigManager.frameworkRegistry[frameworkName];
         if (frameworkVersions) {
             if (frameworkVersion && frameworkVersions[frameworkVersion]) {
-                frameworkConfig = frameworkVersions[frameworkVersion]
+                frameworkConfig = frameworkVersions[frameworkVersion];
             } else {
                 // Fall back to latest version for Triton and other non-versioned lookups
                 const versions = Object.keys(frameworkVersions).sort((a, b) =>
                     b.localeCompare(a, undefined, { numeric: true })
-                )
+                );
                 if (versions.length > 0) {
-                    frameworkConfig = frameworkVersions[versions[0]]
+                    frameworkConfig = frameworkVersions[versions[0]];
                 }
             }
         }
     }
 
     // Resolve the model config (exact match or pattern match)
-    let modelConfig = null
+    let modelConfig = null;
     if (answers.modelName && registryConfigManager.modelRegistry) {
-        modelConfig = _findModelConfig(answers.modelName, registryConfigManager)
+        modelConfig = _findModelConfig(answers.modelName, registryConfigManager);
     }
 
     // Layer 1: catalog defaults (Image_Entry defaults.envVars)
-    const catalogDefaults = frameworkConfig?.envVars || {}
+    const catalogDefaults = frameworkConfig?.envVars || {};
 
     // Layer 2: framework profile envVars
-    let frameworkProfileEnvVars = {}
+    let frameworkProfileEnvVars = {};
     if (answers.frameworkProfile && frameworkConfig?.profiles) {
-        const profile = frameworkConfig.profiles[answers.frameworkProfile]
+        const profile = frameworkConfig.profiles[answers.frameworkProfile];
         if (profile?.envVars) {
-            frameworkProfileEnvVars = profile.envVars
+            frameworkProfileEnvVars = profile.envVars;
         }
     }
 
     // Layer 3: model entry envVars
-    const modelEntryEnvVars = modelConfig?.envVars || {}
+    const modelEntryEnvVars = modelConfig?.envVars || {};
 
     // Layer 4: model profile envVars
-    let modelProfileEnvVars = {}
+    let modelProfileEnvVars = {};
     if (answers.modelProfile && modelConfig?.profiles) {
-        const profile = modelConfig.profiles[answers.modelProfile]
+        const profile = modelConfig.profiles[answers.modelProfile];
         if (profile?.envVars) {
-            modelProfileEnvVars = profile.envVars
+            modelProfileEnvVars = profile.envVars;
         }
     }
 
@@ -785,7 +785,7 @@ async function _mergeEnvVarsWithPrecedence(answers, registryConfigManager) {
         ...modelEntryEnvVars,
         ...modelProfileEnvVars,
         ...cliEnvVars
-    }
+    };
 }
 
 /**
@@ -796,23 +796,23 @@ async function _mergeEnvVarsWithPrecedence(answers, registryConfigManager) {
  * @returns {object|null} Model configuration or null
  */
 function _findModelConfig(modelName, registryConfigManager) {
-    if (!registryConfigManager?.modelRegistry) return null
+    if (!registryConfigManager?.modelRegistry) return null;
 
     // Exact match first
-    const exact = registryConfigManager.modelRegistry[modelName]
-    if (exact) return exact
+    const exact = registryConfigManager.modelRegistry[modelName];
+    if (exact) return exact;
 
     // Pattern matching with glob-style wildcards
     for (const [pattern, config] of Object.entries(registryConfigManager.modelRegistry)) {
         if (pattern.includes('*')) {
-            const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`)
+            const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
             if (regex.test(modelName)) {
-                return config
+                return config;
             }
         }
     }
 
-    return null
+    return null;
 }
 
 /**
@@ -824,33 +824,33 @@ function _findModelConfig(modelName, registryConfigManager) {
  * @param {object} answers - Configuration answers
  * @param {object} tritonBackends - Triton backends catalog
  */
-function _generateTritonFiles(templateDir, destDir, templateVars, answers, tritonBackends) {
-    const modelName = answers.modelName || 'model'
-    const backend = answers.backend
+function _generateTritonFiles(templateDir, destDir, templateVars, answers, _tritonBackends) {
+    const modelName = answers.modelName || 'model';
+    const backend = answers.backend;
 
     // Copy Triton Dockerfile
     _renderTemplate(
         path.join(templateDir, 'triton/Dockerfile'),
         path.join(destDir, 'Dockerfile'),
         templateVars
-    )
+    );
 
     // Create model repository directory structure
-    const modelRepoPath = path.join(destDir, `model_repository/${modelName}`)
-    fs.mkdirSync(path.join(modelRepoPath, '1'), { recursive: true })
+    const modelRepoPath = path.join(destDir, `model_repository/${modelName}`);
+    fs.mkdirSync(path.join(modelRepoPath, '1'), { recursive: true });
 
     // Copy config.pbtxt
     _renderTemplate(
         path.join(templateDir, 'triton/config.pbtxt'),
         path.join(modelRepoPath, 'config.pbtxt'),
         templateVars
-    )
+    );
 
     // Create version 1 directory with .gitkeep
     fs.writeFileSync(
         path.join(modelRepoPath, '1/.gitkeep'),
         '# Placeholder for model artifacts\n'
-    )
+    );
 
     // For triton-python backend: copy model.py and requirements.txt
     if (backend === 'python') {
@@ -858,12 +858,12 @@ function _generateTritonFiles(templateDir, destDir, templateVars, answers, trito
             path.join(templateDir, 'triton/model.py'),
             path.join(modelRepoPath, '1/model.py'),
             templateVars
-        )
+        );
         _renderTemplate(
             path.join(templateDir, 'triton/requirements.txt'),
             path.join(destDir, 'triton/requirements.txt'),
             templateVars
-        )
+        );
     }
 }
 
@@ -875,10 +875,10 @@ function _generateTritonFiles(templateDir, destDir, templateVars, answers, trito
  * @param {object} vars - Template variables
  */
 function _renderTemplate(src, dest, vars) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true })
-    const content = fs.readFileSync(src, 'utf8')
-    const rendered = ejs.render(content, vars, { filename: src })
-    fs.writeFileSync(dest, rendered)
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const content = fs.readFileSync(src, 'utf8');
+    const rendered = ejs.render(content, vars, { filename: src });
+    fs.writeFileSync(dest, rendered);
 }
 
 /**
@@ -888,8 +888,8 @@ function _renderTemplate(src, dest, vars) {
  * @param {string} dest - Destination file path
  */
 function _copyFile(src, dest) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true })
-    fs.copyFileSync(src, dest)
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
 }
 
 /**
@@ -900,7 +900,7 @@ function _copyFile(src, dest) {
 function _unlinkIfExists(filePath) {
     try {
         if (fs.existsSync(filePath)) {
-            fs.unlinkSync(filePath)
+            fs.unlinkSync(filePath);
         }
     } catch (e) {
         // Silently continue
@@ -926,20 +926,20 @@ function _setExecutablePermissions(destDir) {
         'do/register',
         'do/ci',
         'do/manifest'
-    ]
+    ];
 
     shellScripts.forEach(script => {
-        const scriptPath = path.join(destDir, script)
+        const scriptPath = path.join(destDir, script);
         try {
             if (fs.existsSync(scriptPath)) {
-                const stats = fs.statSync(scriptPath)
-                const newMode = stats.mode | 0o755
-                fs.chmodSync(scriptPath, newMode)
+                const stats = fs.statSync(scriptPath);
+                const newMode = stats.mode | 0o755;
+                fs.chmodSync(scriptPath, newMode);
             }
         } catch (error) {
             // Silently continue if chmod fails (e.g., on Windows)
         }
-    })
+    });
 }
 
 /**
@@ -949,33 +949,33 @@ function _setExecutablePermissions(destDir) {
  * @param {string} destDir - Path to the generated project directory
  */
 async function _runSampleModelTraining(destDir) {
-    const trainingScriptName = 'train_abalone.py'
-    const trainingScript = path.join(destDir, `sample_model/${trainingScriptName}`)
-    const sampleModelDir = path.join(destDir, 'sample_model')
-    const requirementsFile = path.join(destDir, 'requirements.txt')
+    const trainingScriptName = 'train_abalone.py';
+    const trainingScript = path.join(destDir, `sample_model/${trainingScriptName}`);
+    const sampleModelDir = path.join(destDir, 'sample_model');
+    const requirementsFile = path.join(destDir, 'requirements.txt');
 
-    console.log('\n🤖 Training sample model...')
-    console.log('This will generate the model file needed for Docker build.')
+    console.log('\n🤖 Training sample model...');
+    console.log('This will generate the model file needed for Docker build.');
 
     try {
         if (!fs.existsSync(trainingScript)) {
-            console.log('⚠️  Training script not found, skipping model training')
-            return
+            console.log('⚠️  Training script not found, skipping model training');
+            return;
         }
 
         // Install dependencies
         if (fs.existsSync(requirementsFile)) {
-            console.log('📦 Installing dependencies from requirements.txt...')
-            await _spawnAsync('pip', ['install', '-q', '-r', requirementsFile], { cwd: destDir })
+            console.log('📦 Installing dependencies from requirements.txt...');
+            await _spawnAsync('pip', ['install', '-q', '-r', requirementsFile], { cwd: destDir });
         }
 
         // Run training script
-        await _spawnAsync('python', [trainingScriptName], { cwd: sampleModelDir })
-        console.log('✅ Sample model training completed successfully!')
-        console.log(`📁 Model file saved in: ${sampleModelDir}`)
+        await _spawnAsync('python', [trainingScriptName], { cwd: sampleModelDir });
+        console.log('✅ Sample model training completed successfully!');
+        console.log(`📁 Model file saved in: ${sampleModelDir}`);
     } catch (error) {
-        console.log('⚠️  Error during sample model training:', error.message)
-        console.log(`Please run manually: python sample_model/${trainingScriptName}`)
+        console.log('⚠️  Error during sample model training:', error.message);
+        console.log(`Please run manually: python sample_model/${trainingScriptName}`);
     }
 }
 
@@ -990,18 +990,18 @@ async function _runSampleModelTraining(destDir) {
  */
 function _spawnAsync(command, args, opts = {}) {
     return new Promise((resolve, reject) => {
-        const proc = spawn(command, args, { ...opts, stdio: 'inherit' })
+        const proc = spawn(command, args, { ...opts, stdio: 'inherit' });
 
         proc.on('close', (code) => {
             if (code === 0) {
-                resolve()
+                resolve();
             } else {
-                reject(new Error(`${command} exited with code ${code}`))
+                reject(new Error(`${command} exited with code ${code}`));
             }
-        })
+        });
 
         proc.on('error', (error) => {
-            reject(error)
-        })
-    })
+            reject(error);
+        });
+    });
 }