@cerema/cadriciel 1.6.6 → 1.7.2

package/cli/global/create.js

@@ -0,0 +1,257 @@
+module.exports = (args) => {
+    const fs = require('fs');
+    const fse = require('fs-extra');
+    const path = require('path');
+    const chalk = require('chalk-v2');
+    const inquirer = require('inquirer');
+    const { spawnSync } = require('child_process');
+    const ora = require('ora');
+    const os = require('os');
+
+    const CACHE_DIR = path.join(os.homedir(), '.cadriciel', 'starters-cache');
+    const PACKAGE_NAME = '@cadriciel/starters';
+
+    // Helper: Fetch/Update the starters package
+    const fetchStarters = async () => {
+        const spinner = ora('Fetching latest starters...').start();
+        try {
+            fse.ensureDirSync(CACHE_DIR);
+            // We use npm install to handle downloading and unpacking
+            // We install to a distinct prefix to avoid polluting global or current project
+            // --no-save ensures it doesn't try to write to a package.json
+            const result = spawnSync(`npm install ${PACKAGE_NAME}@latest --force --no-save --prefix "${CACHE_DIR}"`, {
+                stdio: 'pipe',
+                encoding: 'utf-8',
+                shell: true
+            });
+
+            if (result.status !== 0) {
+                throw new Error(`npm install failed: ${result.stderr}`);
+            }
+
+            spinner.succeed('Starters updated.');
+            // The package will be in CACHE_DIR/node_modules/@cadriciel/starters
+            return path.join(CACHE_DIR, 'node_modules', PACKAGE_NAME);
+        } catch (err) {
+            spinner.fail('Failed to fetch starters.');
+            console.error(chalk.red(err.message));
+            return null;
+        }
+    };
+
+    // Helper: Scan for starters
+    const scanStarters = (startersPath) => {
+        if (!fs.existsSync(startersPath)) return [];
+
+        // Check files is list of possible starter folders
+        // We look for any directory that has a starter.config.json
+        const entries = fs.readdirSync(startersPath, { withFileTypes: true });
+        const starters = [];
+
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const configPath = path.join(startersPath, entry.name, 'starter.config.json');
+                if (fs.existsSync(configPath)) {
+                    try {
+                        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                        starters.push({
+                            id: entry.name,
+                            name: config.name || entry.name,
+                            description: config.description || 'No description',
+                            path: path.join(startersPath, entry.name),
+                            config: config
+                        });
+                    } catch (e) {
+                        // Ignore malformed configs
+                    }
+                }
+            }
+        }
+        return starters;
+    };
+
+    // Helper: Generate Project
+    const generateProject = async (starter, options, targetName) => {
+        const targetPath = path.resolve(process.cwd(), targetName);
+
+        if (fs.existsSync(targetPath)) {
+            const { replace } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'replace',
+                    message: `Directory ${targetName} already exists. Overwrite?`,
+                    default: false
+                }
+            ]);
+            if (!replace) return;
+        }
+
+        const spinner = ora(`Generating project ${targetName}...`).start();
+
+        try {
+            fse.ensureDirSync(targetPath);
+
+            // 1. Process features
+            // Loop through configured options in the starter config
+            const starterOptions = starter.config.options || {};
+
+            // Always process 'core' (implied) or features selected by user
+            // We need to map options.selectedFeatures keys to starterOptions keys
+            const selectedKeys = options.selectedFeatures || [];
+
+            // Collect all sources to copy
+            const copyTasks = [];
+
+            // Add Core/Default implicit sections if they exist in config structure
+            // The config structure: options: { "featureA": { type: "feature", ... }, "core": { type: "core", ... } }
+            Object.keys(starterOptions).forEach(key => {
+                const opt = starterOptions[key];
+
+                // Include if it is 'core' OR if it is in selectedKeys
+                // OR if it is default true and not opt-out (simplification: just rely on selection for optional ones)
+                // For CLI 'checklist', we usually only pass explicitly selected items back, 
+                // so we must ensure 'required' or 'core' items are handled.
+
+                let shouldInclude = false;
+                if (opt.type === 'core') shouldInclude = true;
+                else if (selectedKeys.includes(key)) shouldInclude = true;
+
+                if (shouldInclude && opt.sources) {
+                    opt.sources.forEach(source => {
+                        copyTasks.push(source);
+                    });
+                }
+            });
+
+            // Execute Copy
+            copyTasks.forEach(task => {
+                const srcPath = path.join(starter.path, task.src);
+                const destPath = path.join(targetPath, task.dest);
+
+                if (fs.existsSync(srcPath)) {
+                    // Check if file or directory
+                    const stat = fs.statSync(srcPath);
+                    if (stat.isDirectory()) {
+                        fse.copySync(srcPath, destPath);
+                    } else {
+                        fse.ensureDirSync(path.dirname(destPath));
+                        fse.copySync(srcPath, destPath);
+                    }
+                }
+            });
+
+            // 2. Run Hooks (post_create)
+            if (starter.config.hooks && starter.config.hooks.post_create) {
+                // Copy the hook script if needed or just run it?
+                // Usually hooks run inside the project.
+                // For now, we just log. Smart implementation would spawn the script.
+                spinner.info(`Post-create hook defined: ${starter.config.hooks.post_create}`);
+            }
+
+            spinner.succeed(`Project ${targetName} created successfully!`);
+            console.log(chalk.green(`\nNext steps:\n  cd ${targetName}`));
+            console.log(chalk.green(`  # Install dependencies (frontend & backend)`));
+            console.log(chalk.green(`  cd frontend && bun install`));
+            console.log(chalk.green(`  cd backend && bun install`));
+            console.log(chalk.green(`  # Start the project`));
+            console.log(chalk.green(`  bun run dev`));
+
+        } catch (err) {
+            spinner.fail('Project generation failed.');
+            console.error(chalk.red(err));
+        }
+    };
+
+    return {
+        info: {
+            title: 'create',
+            label: 'beta',
+            description: 'Create a new project from Cadriciel templates',
+        },
+        start: async (cmdArgs) => {
+            console.log(chalk.bold.cyan('Cadriciel Project Generator'));
+
+            // Check for --test flag
+            const isTestMode = cmdArgs.includes('--test');
+            // Remove --test from args so it doesn't interfere with project name
+            const filteredArgs = cmdArgs.filter(arg => arg !== '--test');
+
+            // 1. Fetch Starters
+            let startersPath;
+            if (isTestMode) {
+                console.log(chalk.yellow('Running in TEST mode: Using current directory for starters.'));
+                startersPath = process.cwd();
+            } else {
+                startersPath = await fetchStarters();
+            }
+
+            if (!startersPath) return;
+
+            const starters = scanStarters(startersPath);
+            if (starters.length === 0) {
+                console.log(chalk.yellow('No starters found in the registry.'));
+                return;
+            }
+
+            // 2. Ask for Project Name (if not provided)
+            let args = [...filteredArgs];
+            if (args.length > 0 && args[0] === 'create') {
+                args.shift();
+            }
+            let targetName = args[0];
+            if (!targetName) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: 'Project name:',
+                        validate: input => !!input || 'Name is required'
+                    }
+                ]);
+                targetName = answers.name;
+            }
+
+            // 3. Select Starter
+            const { selectedStarterId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedStarterId',
+                    message: 'Select a template:',
+                    choices: starters.map(s => ({
+                        name: `${chalk.bold(s.name)} - ${s.description}`,
+                        value: s.id
+                    }))
+                }
+            ]);
+
+            const starter = starters.find(s => s.id === selectedStarterId);
+
+            // 4. Select Features
+            // Determine selectable features from config
+            const optionsConfig = starter.config.options || {};
+            const selectableFeatures = Object.keys(optionsConfig)
+                .filter(key => optionsConfig[key].type !== 'core') // Exclude core
+                .map(key => ({
+                    name: optionsConfig[key].description || key,
+                    value: key,
+                    checked: optionsConfig[key].default === true
+                }));
+
+            let selectedFeatures = [];
+            if (selectableFeatures.length > 0) {
+                const featureAnswers = await inquirer.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'features',
+                        message: 'Select features:',
+                        choices: selectableFeatures
+                    }
+                ]);
+                selectedFeatures = featureAnswers.features;
+            }
+
+            // 5. Generate
+            await generateProject(starter, { selectedFeatures }, targetName);
+        },
+    };
+};

package/cli/global/install.js

@@ -7,7 +7,7 @@ module.exports = (args) => {
   const { spawn } = require('child_process');
 
   const checkIfCommandExists = (command, callback) => {
-    const proc = spawn('which', [command], { shell: true });
+    const proc = spawn(`which ${command}`, { shell: true });
 
     let found = false;
     proc.stdout.on('data', (data) => {
@@ -87,7 +87,7 @@ module.exports = (args) => {
     }
     args.push(imageEntry.image);
 
-    const dockerPull = spawn('docker', args, { shell: true });
+    const dockerPull = spawn(`docker ${args.join(' ')}`, { shell: true });
     let stderrOutput = '';
 
     dockerPull.stdout.on('data', () => { });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cerema/cadriciel",
-  "version": "1.6.6",
+  "version": "1.7.2",
   "main": "index.js",
   "license": "MIT",
   "npm": ">=8.0.0",