@cerema/cadriciel 1.7.4 → 1.8.0

package/cli/global/create.js

@@ -11,6 +11,157 @@ module.exports = (args) => {
     const CACHE_DIR = path.join(os.homedir(), '.cadriciel', 'starters-cache');
     const PACKAGE_NAME = '@cadriciel/starters';
 
+    // Helper: Parse CLI arguments
+    const parseArgs = (cmdArgs) => {
+        const options = {
+            name: null,
+            template: null,
+            features: null,
+            allFeatures: false,
+            defaults: false,
+            list: false,
+            listFeatures: null,
+            yes: false,
+            test: false,
+            help: false
+        };
+
+        for (let i = 0; i < cmdArgs.length; i++) {
+            const arg = cmdArgs[i];
+            const nextArg = cmdArgs[i + 1];
+
+            switch (arg) {
+                case '-n':
+                case '--name':
+                    options.name = nextArg;
+                    i++;
+                    break;
+                case '-t':
+                case '--template':
+                    options.template = nextArg;
+                    i++;
+                    break;
+                case '-f':
+                case '--features':
+                    options.features = nextArg ? nextArg.split(',').map(f => f.trim()) : [];
+                    i++;
+                    break;
+                case '-a':
+                case '--all-features':
+                    options.allFeatures = true;
+                    break;
+                case '-d':
+                case '--defaults':
+                    options.defaults = true;
+                    break;
+                case '-l':
+                case '--list':
+                    options.list = true;
+                    break;
+                case '--list-features':
+                    options.listFeatures = nextArg;
+                    i++;
+                    break;
+                case '-y':
+                case '--yes':
+                    options.yes = true;
+                    break;
+                case '--test':
+                    options.test = true;
+                    break;
+                case '-h':
+                case '--help':
+                    options.help = true;
+                    break;
+                default:
+                    // Positional argument (project name if not already set)
+                    if (!arg.startsWith('-') && !options.name && arg !== 'create') {
+                        options.name = arg;
+                    }
+                    break;
+            }
+        }
+
+        return options;
+    };
+
+    // Helper: Display help
+    const showHelp = () => {
+        console.log(chalk.bold.cyan('\nUsage: cad create [options] [project-name]\n'));
+        console.log(chalk.bold('Options:'));
+        console.log('  -n, --name <name>        Project name');
+        console.log('  -t, --template <id>      Template ID (skip template selection)');
+        console.log('  -f, --features <list>    Comma-separated list of features to enable');
+        console.log('  -a, --all-features       Enable all available features');
+        console.log('  -d, --defaults           Use default feature selection');
+        console.log('  -l, --list               List available templates');
+        console.log('  --list-features <id>     List features for a specific template');
+        console.log('  -y, --yes                Auto-confirm prompts (e.g., overwrite)');
+        console.log('  --test                   Use current directory for starters (dev mode)');
+        console.log('  -h, --help               Show this help message');
+        console.log(chalk.bold('\nExamples:'));
+        console.log(chalk.gray('  # Interactive mode (default)'));
+        console.log('  cad create');
+        console.log('  cad create my-project');
+        console.log(chalk.gray('\n  # Automated mode'));
+        console.log('  cad create -n my-project -t basic -d');
+        console.log('  cad create -n my-project -t basic -f auth,api');
+        console.log('  cad create -n my-project -t basic -a -y');
+        console.log(chalk.gray('\n  # List templates and features'));
+        console.log('  cad create --list');
+        console.log('  cad create --list-features basic');
+    };
+
+    // Helper: List templates
+    const listTemplates = (starters) => {
+        console.log(chalk.bold.cyan('\nAvailable templates:\n'));
+        starters.forEach(s => {
+            console.log(`  ${chalk.bold.green(s.id)}`);
+            console.log(`    Name: ${s.name}`);
+            console.log(`    Description: ${s.description}`);
+            console.log('');
+        });
+    };
+
+    // Helper: List features for a template
+    const listFeatures = (starter) => {
+        const optionsConfig = starter.config.options || {};
+        const coreFeatures = [];
+        const optionalFeatures = [];
+
+        Object.keys(optionsConfig).forEach(key => {
+            const opt = optionsConfig[key];
+            if (opt.type === 'core') {
+                coreFeatures.push({ id: key, ...opt });
+            } else {
+                optionalFeatures.push({ id: key, ...opt });
+            }
+        });
+
+        console.log(chalk.bold.cyan(`\nFeatures for template: ${starter.name}\n`));
+
+        if (coreFeatures.length > 0) {
+            console.log(chalk.bold('Core (always included):'));
+            coreFeatures.forEach(f => {
+                console.log(`  ${chalk.gray('•')} ${f.id}${f.description ? ` - ${f.description}` : ''}`);
+            });
+            console.log('');
+        }
+
+        if (optionalFeatures.length > 0) {
+            console.log(chalk.bold('Optional:'));
+            optionalFeatures.forEach(f => {
+                const defaultTag = f.default ? chalk.green(' [default]') : '';
+                console.log(`  ${chalk.gray('•')} ${chalk.bold(f.id)}${f.description ? ` - ${f.description}` : ''}${defaultTag}`);
+            });
+            console.log('');
+        }
+
+        if (optionalFeatures.length === 0 && coreFeatures.length === 0) {
+            console.log(chalk.yellow('  No features defined for this template.'));
+        }
+    };
+
     // Helper: Fetch/Update the starters package
     const fetchStarters = async () => {
         const spinner = ora('Fetching latest starters...').start();
@@ -71,19 +222,23 @@ module.exports = (args) => {
     };
 
     // Helper: Generate Project
-    const generateProject = async (starter, options, targetName) => {
+    const generateProject = async (starter, options, targetName, autoConfirm = false) => {
         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;
+            if (autoConfirm) {
+                console.log(chalk.yellow(`Directory ${targetName} already exists. Overwriting...`));
+            } else {
+                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();
@@ -133,7 +288,14 @@ module.exports = (args) => {
                     // Check if file or directory
                     const stat = await fs.promises.stat(srcPath);
                     const filterFunc = (src, dest) => {
-                        if (path.basename(src) === 'node_modules') return false;
+                        const basename = path.basename(src);
+                        // Exclude node_modules and runtime state files
+                        if (basename === 'node_modules') return false;
+                        // Exclude runtime state files in .store (uuid, workspace, runtime json)
+                        if (basename === '.uuid' ||
+                            basename === '.workspace.json' ||
+                            basename === '.node-runtime.json' ||
+                            basename === '.rls.json') return false;
                         return true;
                     }
 
@@ -175,16 +337,23 @@ module.exports = (args) => {
             description: 'Create a new project from Cadriciel templates',
         },
         start: async (cmdArgs) => {
+            // Parse CLI arguments
+            const opts = parseArgs(cmdArgs);
+
+            // Show help if requested
+            if (opts.help) {
+                showHelp();
+                return;
+            }
+
             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');
+            // Determine if running in automated mode
+            const isAutomated = opts.template && opts.name && (opts.features || opts.allFeatures || opts.defaults);
 
             // 1. Fetch Starters
             let startersPath;
-            if (isTestMode) {
+            if (opts.test) {
                 console.log(chalk.yellow('Running in TEST mode: Using current directory for starters.'));
                 startersPath = process.cwd();
             } else {
@@ -199,12 +368,26 @@ module.exports = (args) => {
                 return;
             }
 
-            // 2. Ask for Project Name (if not provided)
-            let args = [...filteredArgs];
-            if (args.length > 0 && args[0] === 'create') {
-                args.shift();
+            // Handle --list: show available templates and exit
+            if (opts.list) {
+                listTemplates(starters);
+                return;
+            }
+
+            // Handle --list-features: show features for a template and exit
+            if (opts.listFeatures) {
+                const starter = starters.find(s => s.id === opts.listFeatures);
+                if (!starter) {
+                    console.log(chalk.red(`Template '${opts.listFeatures}' not found.`));
+                    console.log(chalk.gray('Use --list to see available templates.'));
+                    return;
+                }
+                listFeatures(starter);
+                return;
             }
-            let targetName = args[0];
+
+            // 2. Get Project Name
+            let targetName = opts.name;
             if (!targetName) {
                 const answers = await inquirer.prompt([
                     {
@@ -218,25 +401,38 @@ module.exports = (args) => {
             }
 
             // 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}${isTestMode ? ` (${s.path})` : ''}`,
-                        value: s.id
-                    }))
+            let starter;
+            if (opts.template) {
+                starter = starters.find(s => s.id === opts.template);
+                if (!starter) {
+                    console.log(chalk.red(`Template '${opts.template}' not found.`));
+                    console.log(chalk.gray('Use --list to see available templates.'));
+                    return;
                 }
-            ]);
-
-            const starter = starters.find(s => s.id === selectedStarterId);
+                console.log(chalk.gray(`Using template: ${starter.name}`));
+            } else if (opts.defaults || opts.allFeatures || opts.features) {
+                // In automated mode without explicit template, use first available
+                starter = starters[0];
+                console.log(chalk.gray(`Using default template: ${starter.name}`));
+            } else {
+                const { selectedStarterId } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedStarterId',
+                        message: 'Select a template:',
+                        choices: starters.map(s => ({
+                            name: `${chalk.bold(s.name)} - ${s.description}${opts.test ? ` (${s.path})` : ''}`,
+                            value: s.id
+                        }))
+                    }
+                ]);
+                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
+                .filter(key => optionsConfig[key].type !== 'core')
                 .map(key => ({
                     name: optionsConfig[key].description || key,
                     value: key,
@@ -244,7 +440,26 @@ module.exports = (args) => {
                 }));
 
             let selectedFeatures = [];
-            if (selectableFeatures.length > 0) {
+
+            if (opts.allFeatures) {
+                // Enable all features
+                selectedFeatures = selectableFeatures.map(f => f.value);
+                console.log(chalk.gray(`Enabling all features: ${selectedFeatures.join(', ') || 'none'}`));
+            } else if (opts.features) {
+                // Use specified features
+                const validFeatures = selectableFeatures.map(f => f.value);
+                const invalidFeatures = opts.features.filter(f => !validFeatures.includes(f));
+                if (invalidFeatures.length > 0) {
+                    console.log(chalk.yellow(`Warning: Unknown features ignored: ${invalidFeatures.join(', ')}`));
+                }
+                selectedFeatures = opts.features.filter(f => validFeatures.includes(f));
+                console.log(chalk.gray(`Selected features: ${selectedFeatures.join(', ') || 'none'}`));
+            } else if (opts.defaults) {
+                // Use default features
+                selectedFeatures = selectableFeatures.filter(f => f.checked).map(f => f.value);
+                console.log(chalk.gray(`Using default features: ${selectedFeatures.join(', ') || 'none'}`));
+            } else if (selectableFeatures.length > 0) {
+                // Interactive mode
                 const featureAnswers = await inquirer.prompt([
                     {
                         type: 'checkbox',
@@ -257,9 +472,9 @@ module.exports = (args) => {
             }
 
             // 5. Generate
-            await generateProject(starter, { selectedFeatures }, targetName);
+            await generateProject(starter, { selectedFeatures }, targetName, opts.yes);
 
-            if (isTestMode) process.exit(0);
+            if (opts.test) process.exit(0);
         },
     };
 };

package/cli/global/doctor.js

@@ -1,226 +1,94 @@
 module.exports = (args) => {
-    const { exec } = require('child_process');
-    const Listr = require('listr');
-    const chalk = require('chalk-v2');
-    const os = require('os');
-    const fs = require('fs');
-    const path = require('path');
-    const platform = os.platform();
-    const checkInstallation = (command, postProcess = (output) => output) => {
-        return new Promise((resolve, reject) => {
-            exec(command, (error, stdout) => {
-                if (error) {
-                    reject(new Error('Not installed'));
-                } else {
-                    resolve(postProcess(stdout.trim()));
-                }
-            });
-        });
-    };
-    const checkOneOfInstallations = (candidates = [], label = 'commande') => {
-        const tryCandidate = (index) => {
-            if (index >= candidates.length) {
-                return Promise.reject(new Error(`${label} non détecté`));
-            }
-            const candidate = candidates[index];
-            const postProcess =
-                candidate.postProcess ||
-                ((output) => `${candidate.label || candidate.command}: ${output}`);
-            return checkInstallation(candidate.command, postProcess).catch(() =>
-                tryCandidate(index + 1)
-            );
-        };
-        return tryCandidate(0);
-    };
-    const PACKAGE_MANAGERS = [
+  const { exec } = require('child_process');
+  const Listr = require('listr');
+  const chalk = require('chalk-v2');
+  const os = require('os');
+  const platform = os.platform();
+  const checkInstallation = (command, postProcess = (output) => output) => {
+    return new Promise((resolve, reject) => {
+      exec(command, (error, stdout) => {
+        if (error) {
+          reject(new Error('Not installed'));
+        } else {
+          resolve(postProcess(stdout.trim()));
+        }
+      });
+    });
+  };
+  return {
+    info: {
+      title: 'doctor',
+      description: `Affichage des pré-requis du cadriciel.`,
+    },
+    start: () => {
+      console.log(' ');
+      
+      console.log(' 🏥 ' + chalk.bold('Pré-requis globaux'));
+      console.log(' ');
+      const myTasks = [
         {
-            id: 'bun',
-            displayName: 'Bun',
-            command: 'bun --version',
-            detectors: ['bun.lock', 'bun.lockb'],
+          title: 'Homebrew',
+          task: () =>  checkInstallation('brew --version'),
         },
         {
-            id: 'pnpm',
-            displayName: 'pnpm',
-            command: 'pnpm -v',
-            detectors: ['pnpm-lock.yaml', 'pnpm-lock.yml'],
+          title: 'Pnpm',
+          task: () =>  checkInstallation('pnpm -v'),
         },
         {
-            id: 'yarn',
-            displayName: 'Yarn',
-            command: 'yarn -v',
-            detectors: ['yarn.lock'],
+          title: 'Git',
+          task: () =>  checkInstallation('git --version'),
         },
         {
-            id: 'npm',
-            displayName: 'npm',
-            command: 'npm -v',
-            detectors: ['package-lock.json'],
-        },
-    ];
-    const findCadricielContext = () => {
-        let currentPath = process.cwd();
-        const rootPath = path.parse(currentPath).root;
-        while (true) {
-            const versionPath = path.join(currentPath, '.cadriciel', 'version.json');
-            if (fs.existsSync(versionPath)) {
-                try {
-                    const version = JSON.parse(fs.readFileSync(versionPath, 'utf8'));
-                    return {
-                        architecture: typeof version.name === 'string' ? version.name : null,
-                        projectRoot: currentPath,
-                    };
-                } catch (error) {
-                    return {
-                        architecture: null,
-                        projectRoot: currentPath,
-                    };
-                }
-            }
-            if (currentPath === rootPath) break;
-            currentPath = path.dirname(currentPath);
-        }
-        return {
-            architecture: null,
-            projectRoot: null,
-        };
-    };
-    const detectPackageManager = (projectRoot) => {
-        const searchRoot = projectRoot || process.cwd();
-        const packageJsonPath = path.join(searchRoot, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-                if (pkgJson.packageManager && typeof pkgJson.packageManager === 'string') {
-                    const requested = pkgJson.packageManager.split('@')[0].trim().toLowerCase();
-                    const pm = PACKAGE_MANAGERS.find((el) => el.id === requested);
-                    if (pm) return pm;
-                }
-            } catch (error) { }
-        }
-        for (const pm of PACKAGE_MANAGERS) {
-            if (
-                pm.detectors.some((fileName) =>
-                    fs.existsSync(path.join(searchRoot, fileName))
-                )
-            ) {
-                return pm;
-            }
-        }
-        return PACKAGE_MANAGERS.find((el) => el.id === 'npm');
-    };
-    const createNodeArchitectureTasks = (projectRoot) => {
-        const detectedManager = detectPackageManager(projectRoot);
-        const tasks = [
-            {
-                title: 'Node ou Bun',
-                task: () =>
-                    checkOneOfInstallations(
-                        [
-                            { command: 'node -v', label: 'Node' },
-                            { command: 'bun --version', label: 'Bun' },
-                        ],
-                        'Node ou Bun'
-                    ),
-            },
-            {
-                title: 'npm ou Bun',
-                task: () =>
-                    checkOneOfInstallations(
-                        [
-                            { command: 'npm -v', label: 'npm' },
-                            { command: 'bun --version', label: 'Bun' },
-                        ],
-                        'npm ou Bun'
-                    ),
-            },
-        ];
-        if (detectedManager) {
-            tasks.push({
-                title: `Gestionnaire (${detectedManager.displayName})`,
-                task: () => checkInstallation(detectedManager.command),
-            });
-        }
-        tasks.push(
-            {
-                title: 'Docker',
-                task: () => checkInstallation('docker ps'),
-            },
-            {
-                title: 'Docker Compose',
-                task: () => checkInstallation('docker-compose --version'),
-            }
-        );
-        return tasks;
-    };
-    const runArchitectureDoctor = ({ architecture, projectRoot }) => {
-        if (!architecture) {
-            if (!projectRoot) {
-                console.log(' ');
-                console.log(
-                    chalk.yellow(
-                        " ⚠️  Impossible de détecter l'architecture du cadriciel (.cadriciel/version.json introuvable)."
-                    )
-                );
-            }
-            return Promise.resolve();
-        }
-        const normalized = architecture.toLowerCase();
-        if (normalized === 'node') {
-            console.log(' ');
-            console.log(' 🧱 ' + chalk.bold('Pré-requis architecture Node'));
-            console.log(' ');
-            const nodeTasks = new Listr(createNodeArchitectureTasks(projectRoot), {
-                concurrent: true,
-                exitOnError: false,
-            });
-            return nodeTasks.run().catch(() => { });
-        }
-        console.log(' ');
-        console.log(' 🧱 ' + chalk.bold('Pré-requis architecture'));
-        console.log(' ');
-        console.log(
-            chalk.yellow(
-                ` Architecture '${architecture}' détectée mais non prise en charge par ce docteur.`
-            )
-        );
-        return Promise.resolve();
-    };
-    return {
-        info: {
-            title: 'doctor',
-            description: `Affichage des pré-requis du cadriciel.`,
+          title: 'Java',
+          task: () =>  checkInstallation('java --version'),
         },
-        start: () => {
-            console.log(' ');
+      ];
+      if (platform === 'linux ') myTasks.splice(0, 1);
+      if (platform === 'win32') myTasks.splice(0, 1);
 
-            console.log(' 🏥 ' + chalk.bold('Pré-requis globaux'));
-            console.log(' ');
-            const myTasks = [
-                {
-                    title: 'Git',
-                    task: () => checkInstallation('git --version'),
-                },
-                {
-                    title: 'Java',
-                    task: () => checkInstallation('java --version'),
-                },
-            ];
-            if (platform === 'linux') myTasks.splice(0, 1);
-            if (platform === 'win32') myTasks.splice(0, 1);
+      const tasks = new Listr(myTasks, {
+        concurrent: true,
+        exitOnError: false,
+      });
 
-            const tasks = new Listr(myTasks, {
-                concurrent: true,
-                exitOnError: false,
-            });
+      const dockerTasks = new Listr(
+        [
+          {
+            title: 'Docker',
+            task: () =>  checkInstallation('docker ps'),
+          },
+          {
+            title: 'Docker Compose',
+            task: () =>  checkInstallation('docker-compose --version'),
+          },
+        ],
+        { concurrent: true, exitOnError: false }
+      );
 
-            const architectureContext = findCadricielContext();
-
-            tasks
-                .run()
-                .catch(() => { })
-                .then(() => runArchitectureDoctor(architectureContext))
-                .catch(() => { });
-        },
-    };
+      tasks
+        .run()
+        .then(() => {
+          console.log(' ');
+          console.log(
+            ' 📦 ' +
+              chalk.bold('Pré-requis Docker') +
+              ' (si vous utilisez docker)'
+          );
+          console.log(' ');
+          dockerTasks.run().then(()=>{
+          }).catch((err) => {});
+        })
+        .catch((err) => {
+          console.log(' ');
+          console.log(
+            ' 📦 ' +
+              chalk.bold('Pré-requis Docker') +
+              ' (si vous utilisez docker)'
+          );
+          console.log(' ');
+          dockerTasks.run().then(()=>{
+          }).catch((err) => {});
+        });
+    },
+  };
 };