@aws/ml-container-creator 0.6.0 → 0.7.1

package/bin/cli.js

@@ -102,6 +102,15 @@ program
     .addOption(new Option('--max-loras <n>', 'Maximum concurrent LoRA adapters in GPU memory (default: 30)'))
     .addOption(new Option('--max-lora-rank <n>', 'Maximum LoRA rank (default: 64)'))
 
+    // --- Benchmarking ---
+    .addOption(new Option('--include-benchmark', 'Include SageMaker AI Benchmarking (transformers/diffusors only)'))
+    .addOption(new Option('--benchmark-concurrency <n>', 'Benchmark concurrent requests (default: 10)'))
+    .addOption(new Option('--benchmark-input-tokens <n>', 'Benchmark mean input tokens (default: 550)'))
+    .addOption(new Option('--benchmark-output-tokens <n>', 'Benchmark mean output tokens (default: 150)'))
+    .addOption(new Option('--benchmark-streaming', 'Enable streaming in benchmark (default: true)'))
+    .addOption(new Option('--benchmark-request-count <n>', 'Total benchmark requests (optional)'))
+    .addOption(new Option('--benchmark-s3-output-path <path>', 'S3 path for benchmark results'))
+
     // --- MCP & Discovery ---
     .addOption(new Option('--smart', 'Enable Bedrock-powered smart mode on MCP servers'))
     .addOption(new Option('--discover', 'Enable live registry lookups via MCP discovery'))

package/config/bootstrap-stack.json

@@ -62,6 +62,7 @@
                     "sagemaker:DescribeEndpointConfig",
                     "sagemaker:DescribeModel",
                     "sagemaker:DescribeInferenceComponent",
+                    "sagemaker:ListInferenceComponents",
                     "sagemaker:InvokeEndpoint",
                     "sagemaker:InvokeEndpointAsync"
                   ],
@@ -131,11 +132,14 @@
                   "Action": [
                     "s3:GetObject",
                     "s3:PutObject",
+                    "s3:AbortMultipartUpload",
                     "s3:ListBucket"
                   ],
                   "Resource": [
                     "arn:aws:s3:::mlcc-*",
-                    "arn:aws:s3:::mlcc-*/*"
+                    "arn:aws:s3:::mlcc-*/*",
+                    "arn:aws:s3:::ml-container-creator-*",
+                    "arn:aws:s3:::ml-container-creator-*/*"
                   ]
                 },
                 {
@@ -163,18 +167,55 @@
                     "arn:aws:secretsmanager:*:*:secret:ml-container-creator/*"
                   ]
                 },
+                {
+                  "Sid": "SNSPublish",
+                  "Effect": "Allow",
+                  "Action": "sns:Publish",
+                  "Resource": [
+                    { "Fn::Sub": "arn:aws:sns:*:${AWS::AccountId}:mlcc-*" },
+                    { "Fn::Sub": "arn:aws:sns:*:${AWS::AccountId}:ml-container-creator-*" }
+                  ]
+                },
                 {
                   "Sid": "QuotaAndAvailability",
                   "Effect": "Allow",
                   "Action": [
                     "service-quotas:GetServiceQuota",
                     "service-quotas:ListServiceQuotas",
-                    "ec2:DescribeCapacityReservations",
                     "sagemaker:ListTrainingPlans",
                     "sagemaker:DescribeTrainingPlan",
                     "sagemaker:ListEndpoints"
                   ],
                   "Resource": "*"
+                },
+                {
+                  "Sid": "SageMakerModelCustomization",
+                  "Effect": "Allow",
+                  "Action": [
+                    "sagemaker:CreateTrainingJob",
+                    "sagemaker:DescribeTrainingJob",
+                    "sagemaker:ListTrainingJobs",
+                    "sagemaker:StopTrainingJob",
+                    "sagemaker:CreateModelPackage",
+                    "sagemaker:CreateModelPackageGroup",
+                    "sagemaker:DescribeModelPackage",
+                    "sagemaker:DescribeModelPackageGroup",
+                    "sagemaker:ListModelPackages",
+                    "sagemaker:CallMlflowAppApi"
+                  ],
+                  "Resource": "*"
+                },
+                {
+                  "Sid": "SageMakerMLflow",
+                  "Effect": "Allow",
+                  "Action": "sagemaker-mlflow:*",
+                  "Resource": "*"
+                },
+                {
+                  "Sid": "LambdaInvokeForReward",
+                  "Effect": "Allow",
+                  "Action": "lambda:InvokeFunction",
+                  "Resource": { "Fn::Sub": "arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:*" }
                 }
               ]
             }
@@ -285,6 +326,26 @@
           { "Key": "mlcc:purpose", "Value": "benchmark-results" }
         ]
       }
+    },
+
+    "TuneS3Bucket": {
+      "Type": "AWS::S3::Bucket",
+      "Condition": "ShouldCreateS3Buckets",
+      "DeletionPolicy": "Retain",
+      "UpdateReplacePolicy": "Retain",
+      "Properties": {
+        "BucketName": { "Fn::Sub": "mlcc-tune-${AWS::AccountId}-${AWS::Region}" },
+        "VersioningConfiguration": { "Status": "Enabled" },
+        "BucketEncryption": {
+          "ServerSideEncryptionConfiguration": [
+            { "ServerSideEncryptionByDefault": { "SSEAlgorithm": "AES256" } }
+          ]
+        },
+        "Tags": [
+          { "Key": "mlcc:managed-by", "Value": "ml-container-creator" },
+          { "Key": "mlcc:purpose", "Value": "tune-datasets-and-output" }
+        ]
+      }
     }
   },
 
@@ -327,9 +388,14 @@
       "Description": "S3 bucket for benchmark results output",
       "Value": { "Ref": "BenchmarkS3Bucket" }
     },
+    "TuneS3BucketName": {
+      "Condition": "ShouldCreateS3Buckets",
+      "Description": "S3 bucket for tune datasets and output",
+      "Value": { "Ref": "TuneS3Bucket" }
+    },
     "StackVersion": {
       "Description": "Bootstrap stack template version for forward compatibility tracking",
-      "Value": "2026-05-04"
+      "Value": "2026-05-18"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws/ml-container-creator",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Generator for SageMaker AI BYOC paradigm for predictive inference use-cases.",
   "type": "module",
   "main": "src/app.js",

package/src/app.js

@@ -16,6 +16,7 @@ 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 { isTuneSupported } from './lib/tune-catalog-validator.js';
 import ejs from 'ejs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -350,6 +351,12 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
         ignorePatterns.push('**/do/adapters/**');
     }
 
+    // Exclude tune files when framework is NOT transformers OR deploymentTarget is batch-transform
+    if (architecture !== 'transformers' || answers.deploymentTarget === 'batch-transform') {
+        ignorePatterns.push('**/do/tune');
+        ignorePatterns.push('**/do/.tune_helper.py');
+    }
+
     // Exclude do/test when hosted-model-endpoint is not selected
     const testTypes = answers.testTypes || [];
     if (!testTypes.includes('hosted-model-endpoint')) {
@@ -452,6 +459,13 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
     _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'));
 
+    // Copy tune catalog to generated project when tune is included
+    if (architecture === 'transformers' && answers.deploymentTarget !== 'batch-transform') {
+        const tuneCatalogSrc = path.join(GENERATOR_ROOT, 'config', 'tune-catalog.json');
+        const tuneCatalogDest = path.join(destDir, 'do', '.tune_catalog.json');
+        _copyFile(tuneCatalogSrc, tuneCatalogDest);
+    }
+
     // Generate .gitignore with benchmarks/ when benchmarking is enabled
     if (answers.includeBenchmark) {
         const gitignorePath = path.join(destDir, '.gitignore');
@@ -742,6 +756,19 @@ async function _ensureTemplateVariables(answers, registryConfigManager = null) {
             }
         }
     }
+
+    // Determine tune support based on model presence in the tune catalog.
+    // Used by the do/config template to write TUNE_SUPPORTED=true|false.
+    if (answers.tuneSupported === undefined) {
+        try {
+            const tuneCatalogPath = path.resolve(__dirname, '..', 'config', 'tune-catalog.json');
+            const tuneCatalog = JSON.parse(fs.readFileSync(tuneCatalogPath, 'utf-8'));
+            const modelId = answers.modelName || '';
+            answers.tuneSupported = isTuneSupported(modelId, tuneCatalog);
+        } catch {
+            answers.tuneSupported = false;
+        }
+    }
 }
 
 /**
@@ -1083,7 +1110,8 @@ function _setExecutablePermissions(destDir) {
         'do/optimize',
         'do/status',
         'do/add-ic',
-        'do/adapter'
+        'do/adapter',
+        'do/tune'
     ];
 
     shellScripts.forEach(script => {

package/src/lib/bootstrap-command-handler.js

@@ -182,38 +182,80 @@ export default class BootstrapCommandHandler {
         this._displayProgress('☁️', 'Deploying bootstrap infrastructure stack...');
         const stackName = `${STACK_NAME_PREFIX}-${profileName}`;
 
+        // Check for existing bootstrap stack in this account-region (resources are singletons)
         try {
-            const stackOutputs = this._deployStack(stackName, {
-                CreateS3Buckets: createS3Buckets ? 'true' : 'false',
-                UseExistingRoleArn: useExistingRoleArn
-            }, awsProfile, region);
+            const existingStacks = this._execAws(
+                `cloudformation list-stacks --stack-status-filter CREATE_COMPLETE UPDATE_COMPLETE UPDATE_ROLLBACK_COMPLETE --query "StackSummaries[?starts_with(StackName,'${STACK_NAME_PREFIX}-')].StackName" --output json`,
+                awsProfile
+            );
+            const stacks = Array.isArray(existingStacks) ? existingStacks : [];
+            const otherStack = stacks.find(s => s !== stackName);
+            if (otherStack) {
+                console.log(`  ℹ️  Bootstrap infrastructure already exists in ${accountId}/${region} (stack: ${otherStack})`);
+                console.log('     Reusing existing resources (IAM role, ECR repo are singletons per account-region).');
+                console.log('     Use `ml-container-creator bootstrap update` to apply latest permissions.\n');
+
+                // Read outputs from existing stack
+                const outputs = this._execAws(
+                    `cloudformation describe-stacks --stack-name ${otherStack} --query "Stacks[0].Outputs" --output json`,
+                    awsProfile
+                );
+                const stackOutputs = {};
+                if (Array.isArray(outputs)) {
+                    for (const o of outputs) {
+                        stackOutputs[o.OutputKey] = o.OutputValue;
+                    }
+                }
 
-            // Read outputs into profile data
-            profileData.roleArn = stackOutputs.RoleArn;
-            profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
-            profileData.stackName = stackName;
+                profileData.roleArn = stackOutputs.RoleArn;
+                profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
+                profileData.stackName = otherStack;
+                if (stackOutputs.AsyncS3BucketName) profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
+                if (stackOutputs.BatchS3BucketName) profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                if (stackOutputs.AdapterS3BucketName) profileData.adapterS3Bucket = stackOutputs.AdapterS3BucketName;
+                if (stackOutputs.BenchmarkS3BucketName) profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
 
-            if (stackOutputs.AsyncS3BucketName) {
-                profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
-            }
-            if (stackOutputs.BatchS3BucketName) {
-                profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                // Skip stack deployment, continue to CI setup and profile save
+                console.log('  ✅ Existing bootstrap infrastructure reused');
             }
-            if (stackOutputs.AdapterS3BucketName) {
-                profileData.adapterS3Bucket = stackOutputs.AdapterS3BucketName;
-            }
-            if (stackOutputs.BenchmarkS3BucketName) {
-                profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
-            }
-
-            console.log('  ✅ Bootstrap stack deployed successfully');
-        } catch (error) {
-            console.log(`  ❌ Stack deployment failed: ${error.message}`);
-            console.log('  Check the CloudFormation console for details:');
-            console.log(`  https://console.aws.amazon.com/cloudformation/home?region=${region}#/stacks`);
-            return;
+        } catch (_) {
+            // If list-stacks fails, proceed with normal deployment
         }
 
+        if (!profileData.stackName) {
+            try {
+                const stackOutputs = this._deployStack(stackName, {
+                    CreateS3Buckets: createS3Buckets ? 'true' : 'false',
+                    UseExistingRoleArn: useExistingRoleArn
+                }, awsProfile, region);
+
+                // Read outputs into profile data
+                profileData.roleArn = stackOutputs.RoleArn;
+                profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
+                profileData.stackName = stackName;
+
+                if (stackOutputs.AsyncS3BucketName) {
+                    profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
+                }
+                if (stackOutputs.BatchS3BucketName) {
+                    profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                }
+                if (stackOutputs.AdapterS3BucketName) {
+                    profileData.adapterS3Bucket = stackOutputs.AdapterS3BucketName;
+                }
+                if (stackOutputs.BenchmarkS3BucketName) {
+                    profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
+                }
+
+                console.log('  ✅ Bootstrap stack deployed successfully');
+            } catch (error) {
+                console.log(`  ❌ Stack deployment failed: ${error.message}`);
+                console.log('  Check the CloudFormation console for details:');
+                console.log(`  https://console.aws.amazon.com/cloudformation/home?region=${region}#/stacks`);
+                return;
+            }
+        } // end if (!profileData.stackName)
+
         // Step 5: CI Infrastructure setup (separate CDK stack — unchanged)
         this._displayProgress('🧪', 'CI Testing Infrastructure...');
         try {

package/src/lib/tune-catalog-validator.js

@@ -0,0 +1,143 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Tune Catalog Validator
+ *
+ * Validates model IDs, techniques, and training types against the
+ * Supported Model Catalog. Provides descriptive error messages when
+ * a requested configuration is not supported.
+ *
+ * Requirements: 1.3, 1.4, 1.5, 1.6, 4.1, 4.2, 4.3, 4.4
+ */
+
+/**
+ * Look up a model entry in the catalog by model ID.
+ * @param {string} modelId - The JumpStart model ID to look up
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {Object|null} The catalog entry for the model, or null if not found
+ */
+export function lookupModel(modelId, catalog) {
+    if (!catalog || !catalog.models) {
+        return null;
+    }
+    if (!Object.hasOwn(catalog.models, modelId)) {
+        return null;
+    }
+    return catalog.models[modelId] || null;
+}
+
+/**
+ * Check whether a model ID is present in the Supported Model Catalog.
+ * @param {string} modelId - The JumpStart model ID to check
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {boolean} True if the model is in the catalog
+ */
+export function isTuneSupported(modelId, catalog) {
+    return lookupModel(modelId, catalog) !== null;
+}
+
+/**
+ * Validate that a model ID exists in the catalog.
+ * Returns a descriptive error when the model is not supported, including
+ * the model name, supported families, and a reference to `do/train`.
+ * @param {string} modelId - The JumpStart model ID to validate
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateModel(modelId, catalog) {
+    if (isTuneSupported(modelId, catalog)) {
+        return { valid: true };
+    }
+
+    const families = _getSupportedFamilies(catalog);
+    const familyList = families.join(', ');
+
+    return {
+        valid: false,
+        error: `Model "${modelId}" is not yet supported for managed serverless customization. ` +
+            `Supported model families: ${familyList}. ` +
+            'For custom training workflows, see `do/train`.'
+    };
+}
+
+/**
+ * Validate that a technique is supported for the given model.
+ * Returns a descriptive error listing the supported techniques when
+ * the requested technique is not available.
+ * @param {string} modelId - The JumpStart model ID
+ * @param {string} technique - The technique to validate (e.g., 'sft', 'dpo')
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateTechnique(modelId, technique, catalog) {
+    const entry = lookupModel(modelId, catalog);
+    if (!entry) {
+        return validateModel(modelId, catalog);
+    }
+
+    const supportedTechniques = Object.keys(entry.techniques);
+    if (supportedTechniques.includes(technique)) {
+        return { valid: true };
+    }
+
+    return {
+        valid: false,
+        error: `Technique "${technique}" is not supported for model "${modelId}". ` +
+            `Supported techniques: ${supportedTechniques.join(', ')}.`
+    };
+}
+
+/**
+ * Validate that a training type is supported for the given model and technique.
+ * Returns a descriptive error listing the supported training types when
+ * the requested type is not available.
+ * @param {string} modelId - The JumpStart model ID
+ * @param {string} technique - The technique (e.g., 'sft', 'dpo')
+ * @param {string} trainingType - The training type to validate (e.g., 'lora', 'full-rank')
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateTrainingType(modelId, technique, trainingType, catalog) {
+    const entry = lookupModel(modelId, catalog);
+    if (!entry) {
+        return validateModel(modelId, catalog);
+    }
+
+    const techniqueEntry = entry.techniques[technique];
+    if (!techniqueEntry) {
+        return validateTechnique(modelId, technique, catalog);
+    }
+
+    const supportedTypes = techniqueEntry.trainingTypes;
+    if (supportedTypes.includes(trainingType)) {
+        return { valid: true };
+    }
+
+    return {
+        valid: false,
+        error: `Training type "${trainingType}" is not supported for model "${modelId}" ` +
+            `with technique "${technique}". ` +
+            `Supported training types: ${supportedTypes.join(', ')}.`
+    };
+}
+
+/**
+ * Extract unique model family names from the catalog.
+ * @param {Object} catalog - The tune catalog object
+ * @returns {string[]} Array of unique family names
+ * @private
+ */
+function _getSupportedFamilies(catalog) {
+    if (!catalog || !catalog.models) {
+        return [];
+    }
+
+    const families = new Set();
+    for (const entry of Object.values(catalog.models)) {
+        if (entry.family) {
+            families.add(entry.family);
+        }
+    }
+    return [...families];
+}

package/src/lib/tune-config-state.js

@@ -0,0 +1,116 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Tune Config State Manager
+ *
+ * JavaScript module that mimics the bash _update_config_var() behavior
+ * from do/tune for testing purposes. Manages config variables written
+ * after job submission.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+
+/**
+ * Update or add a config variable in a do/config-style file.
+ * Mimics the bash _update_config_var() function:
+ * - If the variable exists (line starts with `export VAR_NAME=`), replace it
+ * - Otherwise, append a new line
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {string} varName - Variable name (e.g., TUNE_JOB_NAME_SFT)
+ * @param {string} varValue - Variable value
+ */
+export function updateConfigVar(configPath, varName, varValue) {
+    let content = readFileSync(configPath, 'utf8');
+    const pattern = new RegExp(`^export ${varName}=.*$`, 'm');
+
+    if (pattern.test(content)) {
+        content = content.replace(pattern, `export ${varName}="${varValue}"`);
+    } else {
+        if (content.length > 0 && !content.endsWith('\n')) {
+            content += '\n';
+        }
+        content += `export ${varName}="${varValue}"\n`;
+    }
+
+    writeFileSync(configPath, content, 'utf8');
+}
+
+/**
+ * Read a config variable from a do/config-style file.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {string} varName - Variable name to read
+ * @returns {string|null} The variable value, or null if not found
+ */
+export function readConfigVar(configPath, varName) {
+    const content = readFileSync(configPath, 'utf8');
+    const pattern = new RegExp(`^export ${varName}="([^"]*)"`, 'm');
+    const match = content.match(pattern);
+    return match ? match[1] : null;
+}
+
+/**
+ * Simulate the config writes that happen after a successful job submission.
+ * This mirrors the behavior in do/tune's _submit_job() function.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {object} params - Submission parameters
+ * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {string} params.trainingType - Training type (lora, full-rank)
+ * @param {string} params.datasetPath - Dataset path (s3://... or hf://...)
+ * @param {string} params.jobName - Generated job name
+ */
+export function persistSubmissionState(configPath, { technique, trainingType, datasetPath, jobName }) {
+    const techniqueUpper = technique.toUpperCase();
+    updateConfigVar(configPath, `TUNE_JOB_NAME_${techniqueUpper}`, jobName);
+    updateConfigVar(configPath, 'TUNE_TECHNIQUE', technique);
+    updateConfigVar(configPath, 'TUNE_TRAINING_TYPE', trainingType);
+    updateConfigVar(configPath, 'TUNE_DATASET_PATH', datasetPath);
+}
+
+/**
+ * Simulate the config writes that happen after a job completes successfully.
+ * This mirrors the behavior in do/tune's _handle_completion() function.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {object} params - Completion parameters
+ * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {string} params.trainingType - Training type (lora, full-rank)
+ * @param {string} params.artifactPath - S3 path to the output artifact
+ * @param {string} params.outputType - Output type (adapter, full-model)
+ */
+export function persistCompletionState(configPath, { technique, trainingType, artifactPath, outputType }) {
+    const techniqueUpper = technique.toUpperCase();
+
+    if (trainingType === 'lora') {
+        updateConfigVar(configPath, `TUNE_ADAPTER_PATH_${techniqueUpper}`, artifactPath);
+    } else if (trainingType === 'full-rank') {
+        updateConfigVar(configPath, `TUNE_MODEL_PATH_${techniqueUpper}`, artifactPath);
+    }
+
+    updateConfigVar(configPath, 'TUNE_OUTPUT_PATH_LATEST', artifactPath);
+    updateConfigVar(configPath, 'TUNE_OUTPUT_TYPE_LATEST', outputType);
+}
+
+/**
+ * Generate a job name following the pattern used by do/tune.
+ * Pattern: ${projectName}-tune-${technique}-YYYYMMDD-HHMMSS
+ *
+ * @param {string} projectName - Project name
+ * @param {string} technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {Date} [timestamp] - Optional timestamp (defaults to now)
+ * @returns {string} Generated job name
+ */
+export function generateJobName(projectName, technique, timestamp = new Date()) {
+    const year = timestamp.getFullYear().toString();
+    const month = (timestamp.getMonth() + 1).toString().padStart(2, '0');
+    const day = timestamp.getDate().toString().padStart(2, '0');
+    const hours = timestamp.getHours().toString().padStart(2, '0');
+    const minutes = timestamp.getMinutes().toString().padStart(2, '0');
+    const seconds = timestamp.getSeconds().toString().padStart(2, '0');
+    const dateStr = `${year}${month}${day}`;
+    const timeStr = `${hours}${minutes}${seconds}`;
+    return `${projectName}-tune-${technique}-${dateStr}-${timeStr}`;
+}