create-minions-bundle 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# create-minions-bundle
+
+CLI tool to scaffold Minions ecosystem **bundles**.
+Bundles are curated assemblies of MinionTypes (schemas), relations, and views tailored for a specific domain.
+
+Unlike standard toolboxes, bundles do not have CLI or Python SDKs and use a simpler single-package structure.
+
+## Usage
+
+\`\`\`bash
+# Run with a TOML file
+node src/index.js path/to/my-bundle.toml
+
+# Test without writing files
+node src/index.js path/to/my-bundle.toml --dry-run
+\`\`\`

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "create-minions-bundle",
+    "version": "1.0.0",
+    "description": "Scaffold curated workflow bundles of MinionTypes, relations, and views",
+    "type": "module",
+    "license": "MIT",
+    "author": "Mehdi Nabhani <mehdi@the-mehdi.com> (https://the-mehdi.com)",
+    "bin": {
+        "create-minions-bundle": "./src/index.js"
+    },
+    "main": "./src/index.js",
+    "files": [
+        "src",
+        "templates",
+        "README.md"
+    ],
+    "keywords": [
+        "minions",
+        "scaffold",
+        "cli",
+        "create-app",
+        "bundle",
+        "generator"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mxn2020/create-minions-bundle"
+    },
+    "dependencies": {
+        "chalk": "^5.4.1",
+        "commander": "^14.0.3",
+        "dotenv": "^17.3.1",
+        "fs-extra": "^11.3.0",
+        "inquirer": "^13.2.5",
+        "ora": "^8.2.0",
+        "smol-toml": "^1.6.0"
+    },
+    "engines": {
+        "node": ">=20"
+    }
+}

package/src/bundle-codegen.js

@@ -0,0 +1,259 @@
+/**
+ * Contains the logic to generate TypeScript and Markdown code corresponding 
+ * to the types, relations, views, and skills defined in the bundle config.
+ */
+
+export function generateBundleCode(config) {
+    const { finalCode, importsMap } = generateTypesCode(config.types, config.projectSlug);
+    let bundleTypesCode = finalCode;
+    let relationsCode = generateRelationsCode(config.relations);
+    let viewsCode = generateViewsCode(config.views);
+    let skillsCode = generateSkillsCode(config.skills, config.types);
+    let pythonSchemas = generatePythonSchemas(config.types);
+    let bundleTestsCode = generateTypeScriptTests(config.types);
+
+    // Collect dependencies
+    const dependenciesObj = {};
+    for (const source of importsMap.keys()) {
+        dependenciesObj[source] = "latest"; // Use latest for external dependencies
+    }
+    const dependenciesJson = Object.keys(dependenciesObj).length > 0
+        ? ",\n    " + JSON.stringify(dependenciesObj, null, 4).slice(1, -1).trim()
+        : "";
+
+    return {
+        bundleTypesCode,
+        relationsCode,
+        viewsCode,
+        skillsCode,
+        dependenciesJson,
+        pythonSchemas,
+        bundleTestsCode,
+    };
+}
+
+function generateTypesCode(typesDef, projectSlug) {
+    let importsMap = new Map(); // e.g. '@minions-tasks/sdk' => ['taskType', 'taskListType']
+
+    if (!typesDef || Object.keys(typesDef).length === 0) {
+        return { finalCode: `export const bundleTypes: MinionType[] = [];\n`, importsMap };
+    }
+    let inlineTypes = [];
+    let exportedTypeNames = [];
+
+    for (const [slug, def] of Object.entries(typesDef)) {
+        if (def.source && def.import) {
+            // It's a referenced type
+            if (!importsMap.has(def.source)) {
+                importsMap.set(def.source, new Set());
+            }
+            importsMap.get(def.source).add(def.import);
+            exportedTypeNames.push({ name: def.import, isInline: false });
+        } else {
+            // It's an inline newly defined type
+            const name = slug.charAt(0).toUpperCase() + slug.slice(1).replace(/[-_]/g, ' ');
+            const tsVarName = `${slug.replace(/[-_]/g, '')}Type`;
+            const description = def.description || `Bundle type for ${name}`;
+            const icon = def.icon || '📦';
+
+            let code = `export const ${tsVarName}: MinionType = {\n`;
+            code += `  id: 'bundle-${projectSlug}-${slug}',\n`;
+            code += `  name: '${name}',\n`;
+            code += `  slug: '${slug}',\n`;
+            code += `  description: '${description.replace(/'/g, "\\'")}',\n`;
+            code += `  icon: '${icon}',\n`;
+
+            if (def.extends) {
+                // Not formally supported by MinionType but good for comments/future
+                code += `  // extends: '${def.extends}',\n`;
+            }
+
+            code += `  schema: [\n`;
+            for (const [fieldName, fieldType] of Object.entries(def.fields || {})) {
+                let finalType = fieldType === 'boolean' ? 'boolean' :
+                    fieldType === 'number' ? 'number' :
+                        fieldType === 'select' ? 'select' :
+                            fieldType === 'date' || fieldType === 'datetime' ? 'date' : 'string';
+
+                code += `    { name: '${fieldName}', type: '${finalType}', label: '${fieldName}' },\n`;
+            }
+            code += `  ],\n};\n`;
+
+            inlineTypes.push(code);
+            exportedTypeNames.push({ name: tsVarName, isInline: true });
+        }
+    }
+
+    let finalCode = `import type { MinionType } from 'minions-sdk';\n\n`;
+
+    // Add imports
+    for (const [source, namedImports] of importsMap.entries()) {
+        finalCode += `import { ${Array.from(namedImports).join(', ')} } from '${source}';\n`;
+    }
+
+    finalCode += `\n// --- Inline Bundle Types ---\n\n`;
+    finalCode += inlineTypes.join('\n');
+
+    finalCode += `\n// --- Bundle Export ---\n\n`;
+    finalCode += `export const bundleTypes: MinionType[] = [\n`;
+    for (const t of exportedTypeNames) {
+        finalCode += `  ${t.name},\n`;
+    }
+    finalCode += `];\n`;
+
+    return { finalCode, importsMap };
+}
+
+function generateRelationsCode(relationsDef) {
+    if (!relationsDef || !relationsDef.items || relationsDef.items.length === 0) {
+        return `export const bundleRelations = [];\n`;
+    }
+
+    let code = `export const bundleRelations = [\n`;
+    for (const rel of relationsDef.items) {
+        code += `  { from: '${rel.from}', relation: '${rel.relation}', to: '${rel.to}' },\n`;
+    }
+    code += `];\n`;
+    return code;
+}
+
+function generateViewsCode(viewsDef) {
+    if (!viewsDef || Object.keys(viewsDef).length === 0) {
+        return `export const bundleViews = {};\n`;
+    }
+
+    let code = `export const bundleViews = {\n`;
+    for (const [viewName, def] of Object.entries(viewsDef)) {
+        code += `  ${viewName}: {\n`;
+        if (def.description) code += `    description: '${def.description.replace(/'/g, "\\'")}',\n`;
+        if (def.type) code += `    type: '${def.type}',\n`;
+        if (def.filter) {
+            code += `    filter: ${JSON.stringify(def.filter, null, 6).replace(/\\n/g, '\\n').trim()},\n`;
+        }
+        if (def.aggregate) {
+            code += `    aggregate: ${JSON.stringify(def.aggregate, null, 6).replace(/\\n/g, '\\n').trim()},\n`;
+        }
+        code += `  },\n`;
+    }
+    code += `};\n`;
+    return code;
+}
+
+function generateSkillsCode(skillsDef, typesDef) {
+    if (!skillsDef) {
+        return `No skills defined.`;
+    }
+
+    let code = '';
+    if (skillsDef.context) {
+        code += `## Your Context\n\n${skillsDef.context}\n\n`;
+    }
+
+    const typeNames = Object.keys(typesDef || {});
+    if (typeNames.length > 0) {
+        code += `Your MinionTypes are: ${typeNames.join(', ')}.\n\n`;
+    }
+
+    if (skillsDef.rules && skillsDef.rules.length > 0) {
+        code += `## Hard Rules\n\n`;
+        for (const rule of skillsDef.rules) {
+            code += `- ${rule}\n`;
+        }
+        code += `\n`;
+    }
+
+    if (skillsDef.items && skillsDef.items.length > 0) {
+        for (const skill of skillsDef.items) {
+            code += `## Skill: ${skill.name}\n`;
+            for (let i = 0; i < (skill.steps || []).length; i++) {
+                code += `${i + 1}. ${skill.steps[i]}\n`;
+            }
+            code += `\n`;
+        }
+    }
+
+    return code.trim();
+}
+
+function generatePythonSchemas(typesDef) {
+    if (!typesDef || Object.keys(typesDef).length === 0) {
+        return '# No custom types defined.\nBUNDLE_TYPES = []\n';
+    }
+
+    const typeFieldMap = {
+        string: 'str',
+        number: 'float',
+        boolean: 'bool',
+        date: 'str',
+        datetime: 'str',
+        select: 'str',
+    };
+
+    let code = '';
+    const classNames = [];
+
+    for (const [slug, def] of Object.entries(typesDef)) {
+        if (def.source && def.import) continue; // Skip imported types
+
+        const className = slug.charAt(0).toUpperCase() + slug.slice(1).replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+        const description = def.description || `Bundle type for ${className}`;
+        classNames.push(className);
+
+        code += `\nclass ${className}(MinionType):\n`;
+        code += `    """${description}"""\n`;
+        code += `    slug = "${slug}"\n`;
+        code += `    icon = "${def.icon || '📦'}"\n\n`;
+
+        if (def.fields && Object.keys(def.fields).length > 0) {
+            code += `    fields = [\n`;
+            for (const [fieldName, fieldType] of Object.entries(def.fields)) {
+                const pyType = typeFieldMap[fieldType] || 'str';
+                code += `        FieldDefinition(name="${fieldName}", type="${pyType}", label="${fieldName}"),\n`;
+            }
+            code += `    ]\n`;
+        } else {
+            code += `    fields = []\n`;
+        }
+
+        code += `\n`;
+    }
+
+    code += `\nBUNDLE_TYPES = [${classNames.join(', ')}]\n`;
+
+    return code.trim();
+}
+
+function generateTypeScriptTests(typesDef) {
+    if (!typesDef || Object.keys(typesDef).length === 0) {
+        return '    // No custom bundle types defined.\n';
+    }
+
+    let testCode = '';
+
+    for (const [slug, def] of Object.entries(typesDef)) {
+        if (def.source && def.import) continue; // Skip imported types
+
+        const name = slug.charAt(0).toUpperCase() + slug.slice(1).replace(/[-_]/g, ' ');
+        const fields = def.fields || {};
+        const fieldNames = Object.keys(fields);
+        const tsVarName = `${slug.replace(/[-_]/g, '')}Type`;
+
+        testCode += `    it('should define the ${tsVarName} schema correctly', () => {\n`;
+        testCode += `        const type = bundleTypes.find(t => t.slug === '${slug}');\n`;
+        testCode += `        expect(type).toBeDefined();\n`;
+        testCode += `        expect(type?.name).toBe('${name}');\n`;
+        testCode += `        expect(type?.schema.length).toBe(${fieldNames.length});\n`;
+
+        if (fieldNames.length > 0) {
+            testCode += `\n`;
+            testCode += `        const fieldNames = type?.schema.map(f => f.name);\n`;
+            for (const fieldName of fieldNames) {
+                testCode += `        expect(fieldNames).toContain('${fieldName}');\n`;
+            }
+        }
+
+        testCode += `    });\n\n`;
+    }
+
+    return testCode.trimEnd();
+}

package/src/generator.js

@@ -0,0 +1,107 @@
+import { readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { render, buildVariables } from './template.js';
+import { generateManual } from './manual.js';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+/**
+ * Generate a project from templates.
+ * @param {object} config - Project configuration
+ * @returns {{ outputDir: string, filesCreated: number, dirsCreated: number }}
+ */
+export async function generateProject(config) {
+    const outputDir = join(process.cwd(), config.projectName);
+    const variables = buildVariables(config);
+
+    if (config.dryRun) {
+        console.log(chalk.yellow('\n  ── DRY RUN ──\n'));
+        const files = collectTemplateFiles(TEMPLATES_DIR);
+        for (const file of files) {
+            const relPath = relative(TEMPLATES_DIR, file);
+            const outputPath = resolveOutputPath(relPath, variables);
+            console.log(`  ${chalk.dim('create')} ${outputPath}`);
+        }
+        console.log(`\n  ${chalk.dim(`${files.length} files would be created`)}\n`);
+        return { outputDir, filesCreated: 0, dirsCreated: 0 };
+    }
+
+    if (existsSync(outputDir)) {
+        throw new Error(`Directory "${config.projectName}" already exists`);
+    }
+
+    let filesCreated = 0;
+    let dirsCreated = 0;
+
+    // Walk templates and render each file
+    const files = collectTemplateFiles(TEMPLATES_DIR);
+
+    for (const templateFile of files) {
+        const relPath = relative(TEMPLATES_DIR, templateFile);
+        const outputPath = resolveOutputPath(relPath, variables);
+        const fullOutputPath = join(outputDir, outputPath);
+
+        // Create parent directories
+        const parentDir = dirname(fullOutputPath);
+        if (!existsSync(parentDir)) {
+            mkdirSync(parentDir, { recursive: true });
+            dirsCreated++;
+        }
+
+        // Read template and render
+        const content = readFileSync(templateFile, 'utf-8');
+        const rendered = render(content, variables);
+
+        writeFileSync(fullOutputPath, rendered, 'utf-8');
+        filesCreated++;
+    }
+
+    // Generate MANUAL.md
+    const manualContent = generateManual(config);
+    const manualPath = join(outputDir, 'MANUAL.md');
+    writeFileSync(manualPath, manualContent, 'utf-8');
+    filesCreated++;
+
+    return { outputDir, filesCreated, dirsCreated };
+}
+
+/**
+ * Recursively collect all files in a directory.
+ */
+function collectTemplateFiles(dir) {
+    const results = [];
+    const entries = readdirSync(dir);
+
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            results.push(...collectTemplateFiles(fullPath));
+        } else {
+            results.push(fullPath);
+        }
+    }
+
+    return results;
+}
+
+function resolveOutputPath(relPath, variables) {
+    // Replace __pythonModule__ with actual python module name
+    let outputPath = relPath.replace(/__pythonModule__/g, variables.pythonModule);
+
+    // Map template directory prefixes to output paths
+    if (outputPath.startsWith('root/')) {
+        outputPath = outputPath.replace(/^root\//, '');
+    } else if (outputPath.startsWith('github/')) {
+        outputPath = outputPath.replace(/^github\//, '.github/');
+    }
+
+    // Remove .template extension if present
+    outputPath = outputPath.replace(/\.template$/, '');
+
+    return outputPath;
+}

package/src/github.js

@@ -0,0 +1,110 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Setup GitHub repository using the `gh` CLI.
+ * @param {object} config - Project configuration
+ */
+export async function setupGitHub(config) {
+    const repoName = `${config.githubOrg}/${config.projectName}`;
+    const projectDir = config.projectName;
+
+    // Check if gh CLI is available
+    try {
+        execSync('gh --version', { stdio: 'ignore' });
+    } catch {
+        throw new Error(
+            'GitHub CLI (gh) not found. Install it from https://cli.github.com/ or run without --github'
+        );
+    }
+
+    // Check if authenticated
+    try {
+        execSync('gh auth status', { stdio: 'ignore' });
+    } catch {
+        throw new Error(
+            'Not authenticated with GitHub CLI. Run: gh auth login'
+        );
+    }
+
+    console.log(chalk.dim(`\n  Creating repository ${repoName}...`));
+
+    // Create repo
+    execSync(
+        `gh repo create ${repoName} --public --description "${config.projectDescription}" --source ${projectDir} --push`,
+        { stdio: 'inherit', cwd: process.cwd() }
+    );
+
+    // Initialize git and push
+    console.log(chalk.dim('  Initializing git...'));
+    execSync('git init', { cwd: projectDir, stdio: 'ignore' });
+    execSync('git add .', { cwd: projectDir, stdio: 'ignore' });
+    execSync('git commit -m "chore: initial bundle scaffold from create-minions-bundle"', {
+        cwd: projectDir,
+        stdio: 'ignore',
+    });
+    execSync('git branch -M main', { cwd: projectDir, stdio: 'ignore' });
+
+    // Push to main
+    console.log(chalk.dim('  Pushing to main...'));
+    execSync(`git remote add origin https://github.com/${repoName}.git`, {
+        cwd: projectDir,
+        stdio: 'ignore',
+    });
+    execSync('git push -u origin main', { cwd: projectDir, stdio: 'inherit' });
+
+    // Create dev branch
+    console.log(chalk.dim('  Creating dev branch...'));
+    execSync('git checkout -b dev', { cwd: projectDir, stdio: 'ignore' });
+    execSync('git push -u origin dev', { cwd: projectDir, stdio: 'inherit' });
+
+    // Switch back to dev as the working branch
+    execSync('git checkout dev', { cwd: projectDir, stdio: 'ignore' });
+
+    // Set repo topics
+    const topics = config.keywords.slice(0, 10).join(',');
+    try {
+        execSync(`gh repo edit ${repoName} --add-topic "${topics}"`, { stdio: 'ignore' });
+    } catch {
+        // topics are best-effort
+    }
+
+    // Enable issues and discussions
+    try {
+        execSync(`gh repo edit ${repoName} --enable-issues --enable-wiki=false`, { stdio: 'ignore' });
+    } catch {
+        // best-effort
+    }
+
+    // Set Secrets from Environment
+    if (process.env.NPM_TOKEN) {
+        console.log(chalk.dim('  Setting NPM_TOKEN secret...'));
+        try {
+            execSync(`gh secret set NPM_TOKEN --body "${process.env.NPM_TOKEN}"`, { cwd: projectDir, stdio: 'ignore' });
+        } catch (e) {
+            console.log(chalk.yellow('  Failed to set NPM_TOKEN secret'));
+        }
+    }
+
+    if (process.env.PYPI_TOKEN) {
+        console.log(chalk.dim('  Setting PYPI_TOKEN secret...'));
+        try {
+            execSync(`gh secret set PYPI_TOKEN --body "${process.env.PYPI_TOKEN}"`, { cwd: projectDir, stdio: 'ignore' });
+        } catch (e) {
+            console.log(chalk.yellow('  Failed to set PYPI_TOKEN secret'));
+        }
+    }
+
+    console.log(chalk.green(`\n  ✅ Repository created: https://github.com/${repoName}`));
+    console.log(chalk.dim(`  Branches: main, dev (currently on dev)`));
+    console.log('');
+    console.log(chalk.yellow('  ⚠️  Manual steps required:'));
+    if (!process.env.NPM_TOKEN) {
+        console.log(chalk.dim('  • Add NPM_TOKEN secret to repository'));
+    }
+    if (!process.env.PYPI_TOKEN) {
+        console.log(chalk.dim('  • Add PYPI_TOKEN secret to repository'));
+    }
+    console.log(chalk.dim('  • Enable branch protection on main'));
+    console.log(chalk.dim('  • See MANUAL.md for full details'));
+}

package/src/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { runInteractivePrompts } from './prompts.js';
+import { generateProject } from './generator.js';
+import { setupGitHub } from './github.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join, extname } from 'path';
+import * as dotenv from 'dotenv';
+import { parse } from 'smol-toml';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load .env from the CLI's installation directory
+dotenv.config({ path: join(__dirname, '..', '.env') });
+
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+    .name('create-minions-bundle')
+    .description('Scaffold a new Minions ecosystem bundle project')
+    .version(pkg.version)
+    .argument('[config-file]', 'Path to the TOML configuration file (e.g., crm-bundle.toml)')
+    .option('-o, --org <org>', 'GitHub org/user', 'mxn2020')
+    .option('-a, --author <name>', 'Author name', 'Mehdi Nabhani')
+    .option('-e, --email <email>', 'Author email', 'mehdi@the-mehdi.com')
+    .option('--github', 'Setup GitHub repository (requires gh CLI)')
+    .option('--dry-run', 'Print what would be created without writing files')
+    .option('--license <license>', 'License type', 'MIT')
+    .action(async (configFile, options) => {
+        console.log('');
+        console.log(chalk.bold.hex('#8B5CF6')('  🚀 create-minions-bundle'));
+        console.log(chalk.dim('  Scaffold a new Minions organized bundle\n'));
+
+        let config;
+        let tomlData = null;
+
+        // Ensure we have a config file in non-interactive / mixed mode
+        if (configFile && extname(configFile) === '.toml') {
+            try {
+                const tomlContent = readFileSync(configFile, 'utf-8');
+                tomlData = parse(tomlContent);
+                console.log(chalk.dim(`  Loaded configuration from ${configFile}`));
+
+                // Merge options with TOML
+                if (tomlData.org) options.org = tomlData.org;
+                if (tomlData.colors) {
+                    if (tomlData.colors.accent) options.accent = tomlData.colors.accent;
+                    if (tomlData.colors['accent-hover']) options.accentHover = tomlData.colors['accent-hover'];
+                }
+            } catch (err) {
+                console.error(chalk.red(`  Failed to parse TOML file: ${err.message}`));
+                process.exit(1);
+            }
+        }
+
+        if (tomlData && tomlData.name && tomlData.description) {
+            // Non-interactive mode mostly — all required fields provided in TOML
+            config = buildConfigFromToml(tomlData, options);
+        } else {
+            // Interactive mode — prompt for missing values
+            config = await runInteractivePrompts(tomlData, options);
+        }
+
+        // Attach types, relations, views, and skills if parsed from TOML
+        if (tomlData) {
+            config.types = tomlData.types || {};
+            config.relations = tomlData.relations || {};
+            config.views = tomlData.views || {};
+            config.skills = tomlData.skills || {};
+        }
+
+        // Generate the project
+        const spinner = ora({ text: 'Generating bundle...', color: 'magenta' }).start();
+
+        try {
+            const result = await generateProject(config);
+            spinner.succeed(chalk.green(`Bundle generated at ${chalk.bold(result.outputDir)}`));
+
+            console.log('');
+            console.log(chalk.dim('  ─────────────────────────────────────'));
+            console.log(`  📁 ${chalk.bold(result.filesCreated)} files created`);
+            console.log(`  📂 ${chalk.bold(result.dirsCreated)} directories created`);
+            console.log('');
+
+            // Optional GitHub setup
+            if (config.setupGitHub) {
+                const ghSpinner = ora({ text: 'Setting up GitHub repository...', color: 'cyan' }).start();
+                try {
+                    await setupGitHub(config);
+                    ghSpinner.succeed(chalk.green('GitHub repository configured'));
+                } catch (err) {
+                    ghSpinner.fail(chalk.red(`GitHub setup failed: ${err.message}`));
+                    console.log(chalk.yellow('  You can set up the repo manually. See MANUAL.md'));
+                }
+            }
+
+            // Print next steps
+            console.log(chalk.bold('\n  📋 Next steps:\n'));
+            console.log(`  ${chalk.cyan('cd')} ${config.projectName}`);
+            console.log(`  ${chalk.cyan('pnpm install')}`);
+            console.log(`  ${chalk.cyan('pnpm run build')}`);
+            console.log(`  ${chalk.cyan('pnpm run test')}`);
+            console.log('');
+            console.log(chalk.yellow(`  📖 Read ${chalk.bold('MANUAL.md')} for manual setup steps`));
+
+        } catch (err) {
+            spinner.fail(chalk.red(`Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+
+function buildConfigFromToml(tomlData, options) {
+    const projectName = tomlData.name;
+    const slug = projectName.replace(/^minions-bundles-/, '');
+    const capitalizedSlug = slug.charAt(0).toUpperCase() + slug.slice(1);
+
+    return {
+        projectName,
+        projectSlug: slug,
+        projectCapitalized: `Minions Bundle: ${capitalizedSlug}`,
+        projectDescription: tomlData.description || `A curated Minions ecosystem bundle for ${slug}`,
+        authorName: options.author,
+        authorEmail: options.email,
+        authorUrl: 'https://the-mehdi.com',
+        githubOrg: options.org,
+        githubRepo: `${options.org}/${projectName}`,
+        license: options.license,
+        keywords: [slug, 'bundle', 'ai', 'minions'],
+        year: new Date().getFullYear().toString(),
+        accentColor: options.accent || '#8B5CF6',
+        accentHoverColor: options.accentHover || '#7C3AED',
+        setupGitHub: options.github || false,
+        dryRun: options.dryRun || false,
+    };
+}
+
+program.parse();