nestgen-cli 0.1.0 → 0.2.2

package/nestgen.js

@@ -7,11 +7,27 @@ import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import { inspectProject } from './nestjs-generator/features/preflight.mjs';
-import { generateModule } from './dist/engine/module-generator.js';
-import { generateResource } from './dist/engine/resource-generator.js';
-import { parseResourceFields } from './dist/engine/resource-spec.js';
+import { generateModule, planModuleGeneration } from './dist/engine/module-generator.js';
+import { generateResource, planResourceGeneration } from './dist/engine/resource-generator.js';
+import {
+    parseResourceFields,
+    parseResourceIndexes,
+    parseResourceListOptions,
+    parseResourceRelations,
+} from './dist/engine/resource-spec.js';
 import { configFileName, defaultConfig, loadConfigIfPresent, writeConfig } from './dist/engine/project-config.js';
 import { parseArchitectureProfile } from './dist/engine/architecture-profile.js';
+import { planResourceMigration } from './dist/engine/migration-plan.js';
+import { formatDoctorOutput } from './dist/cli/doctor-output.js';
+import {
+    heading,
+    success,
+    formatError,
+    formatConfig,
+    formatPlan,
+    formatMigration,
+    formatHelp,
+} from './dist/cli/output.js';
 
 // ────── Resolve __dirname compatible ES Modules
 const __filename = fileURLToPath(import.meta.url);
@@ -26,17 +42,7 @@ const MODULE_NAME_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/i;
 
 // ────── Logo CLI
 function printLogo() {
-    console.log(
-        chalk.magentaBright(`
-███╗   ██╗███████╗███████╗████████╗ ██████╗ ███████╗███╗   ██╗
-████╗  ██║██╔════╝██╔════╝╚══██╔══╝██╔════╝ ██╔════╝████╗  ██║
-██╔██╗ ██║█████╗  ███████╗   ██║   ██║  ███╗█████╗  ██╔██╗ ██║
-██║╚██╗██║██╔══╝  ╚════██║   ██║   ██║   ██║██╔══╝  ██║╚██╗██║
-██║ ╚████║███████╗███████║   ██║   ╚██████╔╝███████╗██║ ╚████║
-╚═╝  ╚═══╝╚══════╝╚══════╝   ╚═╝    ╚═════╝ ╚══════╝╚═╝  ╚═══╝
-`),
-    );
-    console.log(chalk.cyan.bold('✨ NestGen CLI — Générateur modulaire NestJS'));
+    console.log(heading('CLI', 'Générateur modulaire NestJS'));
 }
 
 // ────── Helpers
@@ -68,6 +74,11 @@ export function validateOrm(value) {
     return orm;
 }
 
+function validatePackageManager(value) {
+    if (!['npm', 'pnpm', 'yarn'].includes(value)) throw new Error('Package manager invalide.');
+    return value;
+}
+
 export function resolveProjectPath(value) {
     const projectPath = String(value ?? '').trim();
 
@@ -90,6 +101,15 @@ export function parseCliArgs(args) {
         orm: undefined,
         profile: undefined,
         packageManager: undefined,
+        projectPath: undefined,
+        docker: undefined,
+        swagger: undefined,
+        operations: undefined,
+        git: undefined,
+        modules: undefined,
+        application: undefined,
+        indexes: undefined,
+        definitionFile: undefined,
         noInteractive: false,
         quiet: false,
         verbose: false,
@@ -97,6 +117,9 @@ export function parseCliArgs(args) {
         help: false,
         version: false,
         dryRun: false,
+        update: false,
+        migrationName: undefined,
+        json: false,
     };
     const positionals = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -110,8 +133,29 @@ export function parseCliArgs(args) {
         else if (argument.startsWith('--profile=')) options.profile = argument.slice(10);
         else if (argument === '--package-manager') options.packageManager = args[++index];
         else if (argument.startsWith('--package-manager=')) options.packageManager = argument.slice(18);
+        else if (argument === '--project-path') options.projectPath = args[++index];
+        else if (argument.startsWith('--project-path=')) options.projectPath = argument.slice(15);
+        else if (argument === '--docker') options.docker = true;
+        else if (argument === '--no-docker') options.docker = false;
+        else if (argument === '--swagger') options.swagger = true;
+        else if (argument === '--no-swagger') options.swagger = false;
+        else if (argument === '--operations') options.operations = true;
+        else if (argument === '--no-operations') options.operations = false;
+        else if (argument === '--git') options.git = true;
+        else if (argument === '--no-git') options.git = false;
+        else if (argument === '--modules') options.modules = args[++index];
+        else if (argument.startsWith('--modules=')) options.modules = argument.slice(10);
+        else if (argument === '--application') {
+            const value = args[++index];
+            if (!value || value.startsWith('-')) throw new Error('--application requiert une valeur.');
+            options.application = value;
+        } else if (argument.startsWith('--application=')) options.application = argument.slice(14);
         else if (argument === '--fields') options.fields = args[++index];
         else if (argument.startsWith('--fields=')) options.fields = argument.slice(9);
+        else if (argument === '--indexes') options.indexes = args[++index];
+        else if (argument.startsWith('--indexes=')) options.indexes = argument.slice(10);
+        else if (argument === '--file') options.definitionFile = args[++index];
+        else if (argument.startsWith('--file=')) options.definitionFile = argument.slice(7);
         else if (argument === '--route') options.route = args[++index];
         else if (argument.startsWith('--route=')) options.route = argument.slice(8);
         else if (argument === '--table') options.table = args[++index];
@@ -120,6 +164,10 @@ export function parseCliArgs(args) {
         else if (argument === '--quiet') options.quiet = true;
         else if (argument === '--verbose') options.verbose = true;
         else if (argument === '--dry-run') options.dryRun = true;
+        else if (argument === '--update') options.update = true;
+        else if (argument === '--migration-name') options.migrationName = args[++index];
+        else if (argument.startsWith('--migration-name=')) options.migrationName = argument.slice(17);
+        else if (argument === '--json') options.json = true;
         else if (argument === '--no-color') options.color = false;
         else if (argument === '--help' || argument === '-h') options.help = true;
         else if (argument === '--version' || argument === '-V') options.version = true;
@@ -129,10 +177,10 @@ export function parseCliArgs(args) {
     return { command: positionals.shift(), positionals, options };
 }
 
-export function createModulePlan(projectRoot, moduleName, orm) {
+export function createModulePlan(projectRoot, moduleName, orm, sourceRoot = 'src') {
     const normalizedName = validateModuleName(moduleName);
     const normalizedOrm = validateOrm(orm);
-    const resourceRoot = `src/app/${normalizedName}`;
+    const resourceRoot = `${sourceRoot}/app/${normalizedName}`;
     return {
         operation: 'module',
         module: normalizedName,
@@ -148,8 +196,8 @@ export function createModulePlan(projectRoot, moduleName, orm) {
             `${resourceRoot}/${normalizedName}.module.ts`,
         ],
         mutations: [
-            'Ajoute le module dans @Module({ imports }) de src/app.module.ts.',
-            'Ajoute CqrsModule dans src/app.module.ts si nécessaire.',
+            `Ajoute le module dans @Module({ imports }) de ${sourceRoot}/app.module.ts.`,
+            `Ajoute CqrsModule dans ${sourceRoot}/app.module.ts si nécessaire.`,
             ...(normalizedOrm === 'typeorm'
                 ? ['Ajoute la configuration TypeORM racine seulement si elle est absente.']
                 : []),
@@ -157,9 +205,28 @@ export function createModulePlan(projectRoot, moduleName, orm) {
     };
 }
 
+function dryRunOutput(operation, plan) {
+    const conflicts = [
+        ...(plan.featureConflict ? [{ path: '', reason: plan.featureConflict }] : []),
+        ...plan.preview.filter((change) => change.status === 'conflict').map(({ path, reason }) => ({ path, reason })),
+    ];
+    return {
+        version: 1,
+        operation,
+        changes: plan.preview.map(({ path, operation: fileOperation, status, diff, reason }) => ({
+            path,
+            operation: fileOperation,
+            status,
+            ...(diff ? { diff } : {}),
+            ...(reason ? { reason } : {}),
+        })),
+        conflicts,
+    };
+}
+
 export function runBashScript(scriptPath, args = [], env = {}, quiet = false) {
     const result = spawnSync('bash', [scriptPath, ...args], {
-        env: { ...process.env, ...env },
+        env: { ...process.env, ...(chalk.level === 0 ? { NO_COLOR: '1' } : {}), ...env },
         stdio: quiet ? 'pipe' : 'inherit',
     });
 
@@ -215,6 +282,12 @@ async function askInitQuestions() {
             message: '🐳 Activer Docker ?',
             default: false,
         },
+        {
+            type: 'confirm',
+            name: 'withOperations',
+            message: '🩺 Activer le socle d’exploitation (santé, logs, arrêt propre) ?',
+            default: false,
+        },
         {
             type: 'confirm',
             name: 'withGit',
@@ -249,42 +322,75 @@ function validatePromptValue(validator) {
 
 async function runInteractiveInit(options) {
     if (!options.quiet) printLogo();
-    if (options.noInteractive)
-        throw new Error(
-            'init --no-interactive requiert des options de projet qui ne sont pas encore prises en charge.',
-        );
-
     if (!fs.existsSync(GENERATE_SCRIPT)) {
         throw new Error(`Script introuvable : ${GENERATE_SCRIPT}`);
     }
 
-    const answers = await askInitQuestions();
-    const { projectName, projectPath, packageManager, orm, withSwagger, withDocker, withGit, modules } = answers;
+    const answers = options.noInteractive
+        ? (() => {
+              const missing = [
+                  ['nom du projet', options.projectName],
+                  ['--project-path', options.projectPath],
+                  ['--package-manager', options.packageManager],
+                  ['--orm', options.orm],
+                  ['--docker ou --no-docker', options.docker],
+                  ['--swagger ou --no-swagger', options.swagger],
+                  ['--operations ou --no-operations', options.operations],
+                  ['--git ou --no-git', options.git],
+                  ['--modules', options.modules],
+              ]
+                  .filter(([, value]) => value === undefined)
+                  .map(([name]) => name);
+              if (missing.length) throw new Error(`init --no-interactive requiert : ${missing.join(', ')}.`);
+              return {
+                  projectName: options.projectName,
+                  projectPath: options.projectPath,
+                  packageManager: options.packageManager,
+                  orm: options.orm,
+                  withDocker: options.docker,
+                  withSwagger: options.swagger,
+                  withOperations: options.operations,
+                  withGit: options.git,
+                  modules: options.modules ? options.modules.split(',').filter(Boolean) : [],
+              };
+          })()
+        : await askInitQuestions();
+    const { projectName, projectPath, packageManager, orm, withSwagger, withDocker, withOperations, withGit, modules } =
+        answers;
 
     const env = {
         APP_NAME: validateModuleName(projectName),
         PROJECT_PATH: resolveProjectPath(projectPath),
-        PM: packageManager,
+        PM: validatePackageManager(packageManager),
         ORM: validateOrm(orm),
         WITH_SWAGGER: withSwagger ? 'y' : 'n',
+        WITH_OPERATIONS: withOperations ? 'y' : 'n',
         WITH_DOCKER: withDocker ? 'y' : 'n',
         WITH_GIT: withGit ? 'y' : 'n',
         MODULES: modules.map(validateModuleName).join(' '),
     };
 
-    console.log('\n🚀 Lancement de la génération du projet...\n');
-    runBashScript(GENERATE_SCRIPT, [], env);
+    if (!options.quiet) console.log(chalk.cyan('  › Génération du projet…'));
+    runBashScript(GENERATE_SCRIPT, [], env, options.quiet);
+    return {
+        projectName: env.APP_NAME,
+        projectPath: env.PROJECT_PATH,
+        packageManager: env.PM,
+        orm: env.ORM,
+        operations: env.WITH_OPERATIONS === 'y',
+    };
 }
 
 // ────── Commande : MODULE
 async function runModuleGeneration(parsed) {
     if (!parsed.options.quiet) printLogo();
+    const config = loadConfigIfPresent(process.cwd()) ?? defaultConfig;
 
     let moduleName, orm;
 
     if (parsed.positionals[0]) {
         moduleName = validateModuleName(parsed.positionals[0]);
-        orm = validateOrm(parsed.options.orm ?? 'typeorm');
+        orm = validateOrm(parsed.options.orm ?? config.orm);
     } else {
         if (parsed.options.noInteractive) throw new Error('module --no-interactive requiert un nom de module.');
         const answers = await inquirer.prompt([
@@ -311,109 +417,385 @@ async function runModuleGeneration(parsed) {
     }
 
     if (parsed.options.dryRun) {
-        inspectProject(process.cwd(), orm);
-        console.log(JSON.stringify(createModulePlan(process.cwd(), moduleName, orm), null, 2));
-        return;
+        const plan = await planModuleGeneration(process.cwd(), moduleName, orm, parsed.options.application);
+        const output = dryRunOutput('module', plan);
+        if (!parsed.options.json) console.log(formatPlan(output, parsed.options.verbose));
+        return output;
     }
 
-    if (!parsed.options.quiet) console.log(chalk.cyan(`\n⚙️  Génération du module ${moduleName}...\n`));
+    if (!parsed.options.quiet) console.log(chalk.cyan(`  › Génération du module ${moduleName}…`));
     if (process.env.NESTGEN_ROOT) {
         runBashScript(ADD_MODULE_SCRIPT, [moduleName, orm], {}, parsed.options.quiet);
-        return;
+        return { module: moduleName, orm, generated: true };
+    }
+
+    await generateModule(process.cwd(), moduleName, orm, parsed.options.application);
+    return { module: moduleName, orm, generated: true };
+}
+
+export function loadResourceDefinition(file, projectRoot = process.cwd()) {
+    const candidate = path.resolve(projectRoot, String(file ?? ''));
+    if (!candidate.startsWith(`${path.resolve(projectRoot)}${path.sep}`))
+        throw new Error('--file doit désigner un fichier situé dans le projet courant.');
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+    } catch (error) {
+        throw new Error(`Définition de ressource invalide (${candidate}) : ${error.message}`);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`Définition de ressource invalide (${candidate}) : un objet JSON est requis.`);
+    if (value.version !== 1) throw new Error(`Définition de ressource invalide (${candidate}) : version 1 requise.`);
+    if (!Array.isArray(value.fields) || value.fields.some((field) => typeof field !== 'string'))
+        throw new Error(`Définition de ressource invalide (${candidate}) : fields doit être un tableau de chaînes.`);
+    for (const [index, field] of value.fields.entries()) {
+        try {
+            parseResourceFields([field]);
+        } catch (error) {
+            throw new Error(`Définition de ressource invalide (${candidate}) : fields[${index}] — ${error.message}`);
+        }
+    }
+    const fields = parseResourceFields(value.fields);
+    if (value.relations !== undefined && !Array.isArray(value.relations))
+        throw new Error(`Définition de ressource invalide (${candidate}) : relations doit être un tableau.`);
+    let relations;
+    try {
+        relations = parseResourceRelations(value.relations ?? []);
+    } catch (error) {
+        throw new Error(`Définition de ressource invalide (${candidate}) : relations — ${error.message}`);
+    }
+    const relationFields = relationIndexFields(relations);
+    try {
+        parseResourceListOptions(value.list, [...fields, ...relationFields]);
+    } catch (error) {
+        throw new Error(`Définition de ressource invalide (${candidate}) : list — ${error.message}`);
     }
+    if (
+        value.indexes !== undefined &&
+        (!Array.isArray(value.indexes) || value.indexes.some((index) => typeof index !== 'string'))
+    )
+        throw new Error(`Définition de ressource invalide (${candidate}) : indexes doit être un tableau de chaînes.`);
+    try {
+        if (
+            value.uniqueIndexes !== undefined &&
+            (!Array.isArray(value.uniqueIndexes) || value.uniqueIndexes.some((index) => typeof index !== 'string'))
+        )
+            throw new Error(
+                `Définition de ressource invalide (${candidate}) : uniqueIndexes doit être un tableau de chaînes.`,
+            );
+        parseResourceIndexes(value.indexes ?? [], [...fields, ...relationFields], value.uniqueIndexes ?? []);
+    } catch (error) {
+        throw new Error(`Définition de ressource invalide (${candidate}) : indexes — ${error.message}`);
+    }
+    return value;
+}
 
-    generateModule(process.cwd(), moduleName, orm);
+function relationIndexFields(relations) {
+    return relations
+        .filter((relation) => relation.type === 'belongsTo')
+        .map((relation) => ({
+            name: `${relation.field ?? relation.target.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())}Id`,
+        }));
 }
 
-function runResourceGeneration(parsed) {
-    const name = validateModuleName(parsed.positionals[0] ?? '');
-    if (!parsed.options.fields) throw new Error('resource requiert --fields champ:type[,champ:type].');
+async function runResourceGeneration(parsed) {
+    const definition = parsed.options.definitionFile ? loadResourceDefinition(parsed.options.definitionFile) : {};
+    const name = validateModuleName(parsed.positionals[0] ?? definition.name ?? '');
+    const fieldValues = parsed.options.fields?.split(',').filter(Boolean) ?? definition.fields;
+    if (!fieldValues) throw new Error('resource requiert --fields ou --file avec fields.');
     const config = loadConfigIfPresent(process.cwd()) ?? defaultConfig;
-    const orm = validateOrm(parsed.options.orm ?? config.orm);
-    const profile = parseArchitectureProfile(parsed.options.profile ?? config.profile);
-    const fields = parseResourceFields(parsed.options.fields.split(',').filter(Boolean));
-    const route = parsed.options.route ?? `${name}s`;
-    const table = parsed.options.table ?? `${name}s`;
+    const orm = validateOrm(parsed.options.orm ?? definition.orm ?? config.orm);
+    const profile = parseArchitectureProfile(parsed.options.profile ?? definition.profile ?? config.profile);
+    const fields = parseResourceFields(fieldValues);
+    const relations = parseResourceRelations(definition.relations ?? []);
+    const relationFields = relationIndexFields(relations);
+    const list = parseResourceListOptions(definition.list, [...fields, ...relationFields]);
+    const indexes = parseResourceIndexes(
+        parsed.options.indexes?.split(',').filter(Boolean) ?? definition.indexes ?? [],
+        [...fields, ...relationFields],
+        definition.uniqueIndexes ?? [],
+    );
+    const route = parsed.options.route ?? definition.route ?? `${name}s`;
+    const table = parsed.options.table ?? definition.table ?? `${name}s`;
     if (!/^[a-z][a-z0-9/-]*$/.test(route) || !/^[a-z][a-z0-9_]*$/.test(table))
         throw new Error('Route ou table invalide.');
+    if (parsed.options.migrationName && !parsed.options.update) throw new Error('--migration-name requiert --update.');
+    const resourceOptions = {
+        name,
+        route,
+        table,
+        fields,
+        indexes,
+        relations,
+        list,
+        orm,
+        profile,
+        application: parsed.options.application,
+        update: parsed.options.update,
+    };
+    const migration = parsed.options.migrationName
+        ? planResourceMigration(
+              process.cwd(),
+              inspectProject(process.cwd(), orm, { application: parsed.options.application }).sourceRoot,
+              name,
+              orm,
+              parsed.options.migrationName,
+              fields,
+              indexes,
+              relations,
+          )
+        : undefined;
     if (parsed.options.dryRun) {
-        console.log(JSON.stringify({ operation: 'resource', name, route, table, orm, profile, fields }, null, 2));
-        return;
+        const plan = await planResourceGeneration(process.cwd(), resourceOptions);
+        const output = { ...dryRunOutput('resource', plan), ...(migration ? { migration } : {}) };
+        if (!parsed.options.json) console.log(formatPlan(output, parsed.options.verbose));
+        return output;
     }
-    generateResource(process.cwd(), { name, route, table, fields, orm, profile });
+    await generateResource(process.cwd(), resourceOptions);
+    return {
+        resource: name,
+        orm,
+        profile,
+        generated: true,
+        ...(parsed.options.update ? { updated: true } : {}),
+        ...(migration ? { migration } : {}),
+    };
 }
 
 function printUsage() {
     console.log(
-        `Usage: nestgen <commande> [options]\n\nCommandes:\n  init                         Génère un projet NestJS en mode interactif\n  module <nom> [--orm <orm>]  Génère un module\n  resource <nom> --fields ...    Génère un CRUD TypeORM
+        formatHelp(`Usage: nestgen <commande> [options]\n\nCommandes:\n  init [nom]                   Génère un projet NestJS\n  module <nom> [--orm <orm>]  Génère un module\n  resource <nom> --fields ...    Génère un CRUD TypeORM ou Prisma
   config init|show               Gère nestgen.config.json
   doctor                       Vérifie l'installation\n\nOptions:\n  -h, --help                   Affiche cette aide\n  -V, --version                Affiche la version\n  --no-interactive             Refuse les prompts\n  --quiet                      Supprime les sorties non essentielles\n  --verbose                    Active les diagnostics\n  --no-color                   Désactive les couleurs\n  --profile <simple|advanced>   Choisit le profil d'architecture
-  --package-manager <pm>        Définit le package manager du config init
-  --dry-run                    Affiche le plan sans écrire`,
+  --package-manager <pm>        Définit npm, pnpm ou yarn
+  --project-path <chemin>       Définit le dossier parent du projet init
+  --docker, --no-docker         Active ou désactive Docker pour init
+  --swagger, --no-swagger       Active ou désactive Swagger pour init
+  --operations, --no-operations  Active ou désactive le socle d’exploitation pour init
+  --git, --no-git               Active ou désactive Git pour init
+  --modules <a,b>               Définit les modules init, séparés par des virgules
+  --application <nom>           Cible une application d’un workspace Nest
+  --update                     Met à jour une ressource déjà générée sans écraser les fichiers modifiés
+  --migration-name <nom>       Prépare une commande de migration officielle avec --update, sans l’appliquer
+  --dry-run                    Affiche le plan sans écrire
+  --json                       Retourne un résultat JSON versionné
+  --indexes <a+b,c>            Ajoute des index composites ou simples\n\nChamps resource : string, number, integer, decimal(precision;scale), enum(VALEUR|VALEUR), boolean, date, uuid.`),
     );
 }
 
-function runDoctor() {
-    const checks = [
-        [
-            'Node.js',
-            process.versions.node,
-            Number(process.versions.node.split('.')[0]) >= 24,
-            'Installe Node.js 24 LTS ou une version supportée.',
-        ],
-        [
-            'Scripts NestGen',
-            `${GENERATE_SCRIPT}, ${ADD_MODULE_SCRIPT}`,
-            fs.existsSync(GENERATE_SCRIPT) && fs.existsSync(ADD_MODULE_SCRIPT),
-            'Réinstalle NestGen.',
-        ],
-    ];
-    for (const [name, detail, valid, advice] of checks)
-        console.log(`${valid ? 'OK' : 'ERREUR'} ${name}: ${detail}${valid ? '' : ` — ${advice}`}`);
+function runDoctor(options = {}) {
+    const diagnostics = [];
+    const add = (id, severity, cause, action, detail) => diagnostics.push({ id, severity, cause, action, detail });
+    const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
+    const supportedNode = (nodeMajor === 24 && nodeMinor >= 15) || nodeMajor === 25 || nodeMajor === 26;
+    add(
+        'NODE_VERSION',
+        supportedNode ? 'INFO' : 'ERROR',
+        supportedNode ? 'Version Node.js compatible.' : 'Node.js doit être >=24.15.0 et <27.',
+        'Installe une version Node.js supportée puis relance doctor.',
+        process.versions.node,
+    );
+    add(
+        'GENERATOR_SCRIPTS',
+        fs.existsSync(GENERATE_SCRIPT) && fs.existsSync(ADD_MODULE_SCRIPT) ? 'INFO' : 'ERROR',
+        fs.existsSync(GENERATE_SCRIPT) && fs.existsSync(ADD_MODULE_SCRIPT)
+            ? 'Scripts du générateur disponibles.'
+            : 'Un script du générateur est introuvable.',
+        'Réinstalle NestGen.',
+        `${GENERATE_SCRIPT}, ${ADD_MODULE_SCRIPT}`,
+    );
+    const projectRoot = process.cwd();
+    const packagePath = path.join(projectRoot, 'package.json');
+    let manifest;
+    if (!fs.existsSync(packagePath)) {
+        add(
+            'PROJECT_PACKAGE',
+            'WARNING',
+            'Aucun package.json de projet détecté.',
+            'Exécute doctor à la racine du projet Nest.',
+            packagePath,
+        );
+    } else {
+        try {
+            manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            const dependencies = { ...(manifest.dependencies ?? {}), ...(manifest.devDependencies ?? {}) };
+            for (const dependency of ['@nestjs/common', '@nestjs/core'])
+                add(
+                    `DEPENDENCY_${dependency.replace(/^@/, '').replaceAll(/[/-]/g, '_').toUpperCase()}`,
+                    dependencies[dependency] ? 'INFO' : 'ERROR',
+                    dependencies[dependency] ? `${dependency} est déclaré.` : `${dependency} est absent.`,
+                    `Installe ${dependency} avec le package manager du projet.`,
+                    dependencies[dependency] ?? '',
+                );
+            const nestVersion = String(dependencies['@nestjs/common'] ?? '');
+            if (nestVersion)
+                add(
+                    'NEST_VERSION',
+                    /(?:\^|~)?12(?:\.|$)/.test(nestVersion) ? 'INFO' : 'WARNING',
+                    /(?:\^|~)?12(?:\.|$)/.test(nestVersion)
+                        ? 'La version Nest déclarée est supportée.'
+                        : 'La version Nest déclarée est hors de la matrice testée.',
+                    'Utilise Nest 12 ou vérifie cette combinaison avec la matrice de compatibilité.',
+                    nestVersion,
+                );
+            if (dependencies['@nestjs/typeorm'] || dependencies.typeorm)
+                add(
+                    'TYPEORM_COHERENCE',
+                    dependencies['@nestjs/typeorm'] && dependencies.typeorm ? 'INFO' : 'WARNING',
+                    dependencies['@nestjs/typeorm'] && dependencies.typeorm
+                        ? 'Les dépendances TypeORM sont cohérentes.'
+                        : 'Le support TypeORM est incomplet.',
+                    'Installe @nestjs/typeorm et typeorm ensemble, ou utilise Prisma.',
+                    '',
+                );
+            if (dependencies['@prisma/client'])
+                add(
+                    'PRISMA_CLIENT',
+                    'INFO',
+                    '@prisma/client est déclaré.',
+                    'Exécute npx prisma generate après une modification du schéma.',
+                    dependencies['@prisma/client'],
+                );
+        } catch (error) {
+            add(
+                'PROJECT_PACKAGE',
+                'ERROR',
+                'package.json est invalide.',
+                'Corrige le JSON du manifeste.',
+                error.message,
+            );
+        }
+    }
     try {
-        const project = inspectProject(process.cwd(), 'typeorm');
-        console.log(
-            `OK Projet Nest: ${project.packageManager ?? 'lockfile absent'}; connexion TypeORM racine: ${project.hasRootTypeOrmConnection ? 'présente' : 'absente'}.`,
+        const config = loadConfigIfPresent(projectRoot);
+        add(
+            'NESTGEN_CONFIG',
+            'INFO',
+            config
+                ? 'Configuration NestGen valide.'
+                : 'Configuration NestGen absente ; les valeurs par défaut seront utilisées.',
+            config ? 'Aucune action requise.' : 'Exécute nestgen config init pour figer les choix du projet.',
+            config ? `orm=${config.orm}; profile=${config.profile}; packageManager=${config.packageManager}` : '',
         );
+        if (config) {
+            const lockfile =
+                config.packageManager === 'npm'
+                    ? 'package-lock.json'
+                    : config.packageManager === 'pnpm'
+                      ? 'pnpm-lock.yaml'
+                      : 'yarn.lock';
+            add(
+                'PACKAGE_MANAGER_LOCKFILE',
+                fs.existsSync(path.join(projectRoot, lockfile)) ? 'INFO' : 'WARNING',
+                fs.existsSync(path.join(projectRoot, lockfile))
+                    ? `Le lockfile ${lockfile} correspond à la configuration.`
+                    : `Le lockfile ${lockfile} est absent.`,
+                `Installe les dépendances avec ${config.packageManager} pour créer le lockfile attendu.`,
+                lockfile,
+            );
+        }
     } catch (error) {
-        console.log(
-            `INFO Projet Nest: ${error.message} — Lance doctor depuis un projet Nest compatible pour analyser son intégration.`,
+        add(
+            'NESTGEN_CONFIG',
+            'ERROR',
+            'Configuration NestGen invalide.',
+            'Corrige nestgen.config.json ou recrée-la.',
+            error.message,
         );
     }
-    if (checks.some(([, , valid]) => !valid)) throw new Error('Des prérequis NestGen sont manquants.');
+    let project;
+    try {
+        project = inspectProject(projectRoot, 'typeorm', { cqrs: false });
+        add(
+            'NEST_INTEGRATION',
+            'INFO',
+            'Structure Nest et intégration TypeORM valides.',
+            'Aucune action requise.',
+            project.sourceRoot,
+        );
+    } catch (error) {
+        project = { error: error.message };
+        add(
+            'NEST_INTEGRATION',
+            'WARNING',
+            'Le projet ne remplit pas toutes les préconditions TypeORM.',
+            'Lis le diagnostic puis complète la structure ou les dépendances indiquées.',
+            error.message,
+        );
+    }
+    if (!options.json) {
+        const output = formatDoctorOutput(diagnostics, options);
+        if (output) console.log(output);
+    }
+    return { diagnostics, project };
+}
+
+function machineResult(command, result) {
+    return { version: 1, ok: true, command, result };
+}
+
+function errorCode(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/^(Option inconnue|Commande inconnue|.* requiert |Route ou table invalide|Nom de )/.test(message))
+        return 'USAGE';
+    if (message.startsWith('Préflight échoué')) return 'PROJECT_INVALID';
+    if (/(existe déjà|Destination |Conflit |Transaction interrompue)/.test(message)) return 'CONFLICT';
+    return 'INTERNAL';
 }
 
 // ────── Entrée CLI
 export async function main(args = process.argv.slice(2)) {
     const parsed = parseCliArgs(args);
+    const machine = parsed.options.json;
+    if (machine) {
+        parsed.options.quiet = true;
+        parsed.options.color = false;
+        parsed.options.noInteractive = true;
+    }
     if (!parsed.options.color) chalk.level = 0;
     if (parsed.options.version) {
         const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
-        console.log(packageJson.version);
-        return;
+        const result = { cliVersion: packageJson.version };
+        console.log(machine ? JSON.stringify(machineResult('version', result)) : packageJson.version);
+        return result;
     }
     if (parsed.options.help || !parsed.command) {
-        printUsage();
+        if (machine)
+            console.log(
+                JSON.stringify(machineResult('help', { commands: ['init', 'module', 'resource', 'config', 'doctor'] })),
+            );
+        else printUsage();
         return;
     }
 
+    let result;
     switch (parsed.command) {
         case 'init':
-            await runInteractiveInit(parsed.options);
+            if (parsed.positionals.length > 1) throw new Error('init accepte au plus un nom de projet.');
+            result = await runInteractiveInit({ ...parsed.options, projectName: parsed.positionals[0] });
             break;
 
         case 'module':
-            await runModuleGeneration(parsed);
+            result = await runModuleGeneration(parsed);
             break;
 
         case 'resource':
-            runResourceGeneration(parsed);
+            result = await runResourceGeneration(parsed);
             break;
 
         case 'config': {
             const action = parsed.positionals[0];
             if (action === 'show') {
-                console.log(JSON.stringify(loadConfigIfPresent(process.cwd()) ?? defaultConfig, null, 2));
+                result = loadConfigIfPresent(process.cwd()) ?? defaultConfig;
+                if (!machine)
+                    console.log(
+                        formatConfig(
+                            result,
+                            fs.existsSync(path.join(process.cwd(), configFileName))
+                                ? configFileName
+                                : 'Valeurs par défaut',
+                        ),
+                    );
                 break;
             }
             if (action === 'init') {
@@ -426,28 +808,50 @@ export async function main(args = process.argv.slice(2)) {
                 if (!['npm', 'pnpm', 'yarn'].includes(config.packageManager))
                     throw new Error('Package manager invalide.');
                 if (parsed.options.dryRun) {
-                    console.log(JSON.stringify({ operation: 'config-init', file: configFileName, config }, null, 2));
+                    result = { operation: 'config-init', file: configFileName, config };
+                    if (!parsed.options.quiet) console.log(formatConfig(config, 'Aperçu · aucun fichier écrit'));
                     break;
                 }
                 writeConfig(process.cwd(), config);
-                console.log(configFileName);
+                result = { file: configFileName, created: true, config };
+                if (!parsed.options.quiet) console.log(success(`Configuration créée : ${configFileName}`));
                 break;
             }
             throw new Error('config requiert init ou show.');
         }
 
         case 'doctor':
-            runDoctor();
+            result = runDoctor(parsed.options);
             break;
 
         default:
             throw new Error(`Commande inconnue : ${parsed.command}. Utilise --help.`);
     }
+    if (machine) console.log(JSON.stringify(machineResult(parsed.command, result)));
+    else if (!parsed.options.quiet && result) {
+        if (parsed.command === 'module' && result.generated)
+            console.log(success(`Module ${result.module} généré (${result.orm}).`));
+        if (parsed.command === 'resource' && result.generated) {
+            console.log(
+                success(
+                    `Ressource ${result.resource} ${result.updated ? 'mise à jour' : 'générée'} (${result.orm} · ${result.profile}).`,
+                ),
+            );
+            if (result.migration) console.log(formatMigration(result.migration));
+        }
+    }
+    return result;
 }
 
 if (process.argv[1] && fs.realpathSync(process.argv[1]) === __filename) {
     main().catch((error) => {
-        console.error(chalk.red(`❌ ${error.message}`));
+        if (process.argv.includes('--json')) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(JSON.stringify({ version: 1, ok: false, error: { code: errorCode(error), message } }));
+        } else {
+            if (process.argv.includes('--no-color')) chalk.level = 0;
+            console.error(formatError(error.message));
+        }
         process.exitCode = 1;
     });
 }