@devstroupe/devkit-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1967 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const cli_templates_1 = require("./templates/cli-templates");
+const ui_templates_1 = require("./templates/ui-templates");
+const linter_rules_1 = require("./rules/linter-rules");
+const relationships_1 = require("./templates/shared/relationships");
+const sort_entities_1 = require("./migrations/sort-entities");
+const child_process_1 = require("child_process");
+// Registra ts-node para poder carregar arquivos .ts (como o config)
+try {
+    require('ts-node').register({
+        compilerOptions: { module: 'commonjs' }
+    });
+}
+catch (e) {
+    // Silencioso se ts-node não estiver presente localmente
+}
+const program = new commander_1.Command();
+const SPARTAN_STYLES = ['nova', 'vega', 'lyra', 'maia', 'mira', 'luma'];
+function isSpartanStyle(value) {
+    return SPARTAN_STYLES.includes(value);
+}
+function getDesignSystemConfig(config) {
+    return config?.designSystem || {};
+}
+function assertValidRelationshipConfig(config) {
+    (0, relationships_1.validateRelationships)(config.entities ?? []);
+    if (config.backendType !== 'microservices')
+        return;
+    const manyToMany = (config.entities ?? []).flatMap((item) => (0, relationships_1.getRelationships)(item.properties ?? []).filter((relation) => relation.kind === 'many-to-many'));
+    if (manyToMany.length > 0) {
+        throw new Error('Many-to-many relationships require a dedicated junction CRUD when backendType is "microservices".');
+    }
+}
+function ensureMigrationInfrastructure(backendRoot) {
+    const databaseDir = path.join(backendRoot, 'src', 'database');
+    fs.ensureDirSync(path.join(databaseDir, 'migrations'));
+    const dataSourcePath = path.join(databaseDir, 'data-source.ts');
+    if (!fs.existsSync(dataSourcePath)) {
+        fs.writeFileSync(dataSourcePath, (0, cli_templates_1.nestDataSourceTemplate)(), 'utf-8');
+    }
+    const packagePath = path.join(backendRoot, 'package.json');
+    if (fs.existsSync(packagePath)) {
+        const packageJson = fs.readJsonSync(packagePath);
+        packageJson.scripts = {
+            ...(packageJson.scripts ?? {}),
+            'migration:run': 'typeorm-ts-node-commonjs -d src/database/data-source.ts migration:run',
+            'migration:revert': 'typeorm-ts-node-commonjs -d src/database/data-source.ts migration:revert',
+            'migration:generate': 'typeorm-ts-node-commonjs -d src/database/data-source.ts migration:generate src/database/migrations/schema',
+        };
+        packageJson.devDependencies = { ...(packageJson.devDependencies ?? {}), 'ts-node': '^10.9.2' };
+        packageJson.dependencies = { ...(packageJson.dependencies ?? {}), dotenv: '^16.4.5' };
+        fs.writeJsonSync(packagePath, packageJson, { spaces: 2 });
+    }
+    const appModulePath = path.join(backendRoot, 'src', 'app.module.ts');
+    if (fs.existsSync(appModulePath)) {
+        const appModule = fs.readFileSync(appModulePath, 'utf-8');
+        const updated = appModule.replace(/synchronize:\s*true/g, 'synchronize: false');
+        if (updated !== appModule)
+            fs.writeFileSync(appModulePath, updated, 'utf-8');
+    }
+}
+function ensureInitialMigrations(backendRoot, entities, propertyOverrides = new Map()) {
+    ensureMigrationInfrastructure(backendRoot);
+    const migrationsDir = path.join(backendRoot, 'src', 'database', 'migrations');
+    const existing = fs.readdirSync(migrationsDir);
+    const missing = (0, sort_entities_1.sortEntitiesForMigrations)(entities).filter((entity) => !existing.some((file) => file.endsWith(`-create-${entity.name}.ts`)));
+    const baseTimestamp = Date.now();
+    missing.forEach((entity, index) => {
+        const timestamp = baseTimestamp + index;
+        const fileName = `${timestamp}-create-${entity.name}.ts`;
+        const properties = propertyOverrides.get(entity.name) ?? entity.properties;
+        fs.writeFileSync(path.join(migrationsDir, fileName), (0, cli_templates_1.nestMigrationTemplate)(entity, entities, timestamp, properties), 'utf-8');
+        console.log(`[Migration] Criada ${fileName}`);
+    });
+}
+function getSpartanStyle(config) {
+    const designSystem = getDesignSystemConfig(config);
+    const configuredStyle = designSystem.spartanStyle || designSystem.style || designSystem.preset || 'vega';
+    return isSpartanStyle(configuredStyle) ? configuredStyle : 'vega';
+}
+function getCurrentSpartanStyle(frontendRoot, config) {
+    const componentsPath = path.join(frontendRoot, 'components.json');
+    if (fs.existsSync(componentsPath)) {
+        try {
+            const componentsConfig = fs.readJsonSync(componentsPath);
+            if (isSpartanStyle(componentsConfig.style)) {
+                return componentsConfig.style;
+            }
+        }
+        catch {
+            // fallback para o devstroupe.config.ts abaixo
+        }
+    }
+    return getSpartanStyle(config);
+}
+function getPackageManagerCommand(projectRoot) {
+    const localNg = path.join(projectRoot, 'node_modules', '.bin', process.platform === 'win32' ? 'ng.cmd' : 'ng');
+    if (fs.existsSync(localNg)) {
+        return `"${localNg}"`;
+    }
+    const pkgPath = path.join(projectRoot, 'package.json');
+    try {
+        const pkg = fs.existsSync(pkgPath) ? fs.readJsonSync(pkgPath) : {};
+        if (typeof pkg.packageManager === 'string' && pkg.packageManager.startsWith('pnpm')) {
+            return 'pnpm exec ng';
+        }
+    }
+    catch {
+        // fallback abaixo
+    }
+    if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) {
+        return 'pnpm exec ng';
+    }
+    return 'npx ng';
+}
+function ensureSpartanComponentsJson(frontendRoot, style) {
+    const componentsPath = path.join(frontendRoot, 'components.json');
+    const nextConfig = {
+        componentsPath: 'libs/ui',
+        importAlias: '@spartan-ng/helm',
+        style
+    };
+    fs.writeJsonSync(componentsPath, nextConfig, { spaces: 2 });
+    console.log(`[Spartan] components.json configurado com style="${style}".`);
+}
+function ensureSpartanTsconfigPaths(frontendRoot) {
+    const tsconfigPath = path.join(frontendRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath))
+        return;
+    const utilsIndexPath = path.join(frontendRoot, 'libs', 'ui', 'utils', 'src', 'index.ts');
+    if (!fs.existsSync(utilsIndexPath)) {
+        throw new Error('[Spartan] libs/ui/utils não foi gerado. Execute o generator do Spartan antes de registrar os aliases.');
+    }
+    const tsconfig = fs.readJsonSync(tsconfigPath);
+    tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+    tsconfig.compilerOptions.paths = tsconfig.compilerOptions.paths || {};
+    tsconfig.compilerOptions.paths['@spartan-ng/helm/utils'] = ['libs/ui/utils/src/index.ts'];
+    tsconfig.compilerOptions.paths['@spartan-ng/helm/*'] = ['libs/ui/*/src/index.ts'];
+    fs.writeJsonSync(tsconfigPath, tsconfig, { spaces: 2 });
+    console.log('[Spartan] Path aliases @spartan-ng/helm configurados no tsconfig.json.');
+}
+function removeStaleSpartanTsconfigPaths(frontendRoot) {
+    const tsconfigPath = path.join(frontendRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath))
+        return;
+    const tsconfig = fs.readJsonSync(tsconfigPath);
+    const paths = tsconfig.compilerOptions?.paths;
+    if (!paths)
+        return;
+    const utilsIndexPath = path.join(frontendRoot, 'libs', 'ui', 'utils', 'src', 'index.ts');
+    let updated = false;
+    if (!fs.existsSync(utilsIndexPath) && paths['@spartan-ng/helm/utils']) {
+        delete paths['@spartan-ng/helm/utils'];
+        updated = true;
+    }
+    if (paths['@spartan-ng/helm/*']) {
+        delete paths['@spartan-ng/helm/*'];
+        updated = true;
+    }
+    if (updated) {
+        fs.writeJsonSync(tsconfigPath, tsconfig, { spaces: 2 });
+        console.log('[Spartan] Aliases genéricos antigos removidos antes da geração.');
+    }
+}
+function removeSpartanGeneratedUi(frontendRoot) {
+    const uiRoot = path.join(frontendRoot, 'libs', 'ui');
+    if (fs.existsSync(uiRoot)) {
+        fs.removeSync(uiRoot);
+        console.log('[Spartan] libs/ui removido para regenerar o style real.');
+    }
+    const tsconfigPath = path.join(frontendRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath))
+        return;
+    const tsconfig = fs.readJsonSync(tsconfigPath);
+    const paths = tsconfig.compilerOptions?.paths;
+    if (!paths)
+        return;
+    let updated = false;
+    for (const alias of Object.keys(paths)) {
+        if (alias === '@spartan-ng/helm/utils' || alias.startsWith('@spartan-ng/helm/')) {
+            delete paths[alias];
+            updated = true;
+        }
+    }
+    if (updated) {
+        fs.writeJsonSync(tsconfigPath, tsconfig, { spaces: 2 });
+        console.log('[Spartan] Aliases Helm removidos para forçar nova geração.');
+    }
+}
+function ensureSpartanTailwindSource(frontendRoot) {
+    const styleCandidates = [
+        path.join(frontendRoot, 'src', 'styles.scss'),
+        path.join(frontendRoot, 'src', 'styles.css')
+    ];
+    const stylesPath = styleCandidates.find((candidate) => fs.existsSync(candidate));
+    if (!stylesPath)
+        return;
+    let content = fs.readFileSync(stylesPath, 'utf-8');
+    if (!content.includes("@source './app'") && !content.includes('@source "./app"')) {
+        content = content.replace(/(@import ['"]@angular\/cdk\/overlay-prebuilt\.css['"];?)/, `$1\n\n@source './app';`);
+    }
+    if (!content.includes("@source '../libs/ui'") && !content.includes('@source "../libs/ui"')) {
+        content = content.replace(/(@import ['"]@spartan-ng\/brain\/hlm-tailwind-preset\.css['"];?)/, `$1\n\n@source '../libs/ui';`);
+    }
+    fs.writeFileSync(stylesPath, content, 'utf-8');
+    console.log('[Spartan] @source ./app e ../libs/ui garantidos nos estilos globais.');
+}
+function ensureSpartanProvider(frontendRoot) {
+    const appConfigPath = path.join(frontendRoot, 'src', 'app', 'app.config.ts');
+    if (!fs.existsSync(appConfigPath))
+        return;
+    let content = fs.readFileSync(appConfigPath, 'utf-8');
+    if (!content.includes("provideSpartanHlm")) {
+        content = content.replace("import { ApplicationConfig } from '@angular/core';", "import { ApplicationConfig } from '@angular/core';\nimport { provideSpartanHlm } from '@spartan-ng/helm/utils';");
+        content = content.replace(/providers:\s*\[/, 'providers: [\n    provideSpartanHlm(),');
+        fs.writeFileSync(appConfigPath, content, 'utf-8');
+        console.log('[Spartan] provideSpartanHlm() registrado no app.config.ts.');
+    }
+}
+function getSupportedSpartanPrimitiveNames(frontendRoot) {
+    const supportedLibrariesPath = path.join(frontendRoot, 'node_modules', '@spartan-ng', 'cli', 'src', 'generators', 'ui', 'supported-ui-libraries.json');
+    if (!fs.existsSync(supportedLibrariesPath)) {
+        throw new Error('[Spartan] @spartan-ng/cli não encontrado em node_modules. Instale as dependências do frontend antes de executar init-ui.');
+    }
+    const supportedLibraries = JSON.parse(fs.readFileSync(supportedLibrariesPath, 'utf-8'));
+    return Object.keys(supportedLibraries).sort();
+}
+function runSpartanGenerator(frontendRoot, style, forceRegenerate = false) {
+    ensureSpartanComponentsJson(frontendRoot, style);
+    if (forceRegenerate) {
+        removeSpartanGeneratedUi(frontendRoot);
+    }
+    removeStaleSpartanTsconfigPaths(frontendRoot);
+    ensureSpartanTailwindSource(frontendRoot);
+    ensureSpartanProvider(frontendRoot);
+    const ng = getPackageManagerCommand(frontendRoot);
+    const primitiveNames = getSupportedSpartanPrimitiveNames(frontendRoot);
+    console.log(`[Spartan] Gerando ${primitiveNames.length} primitives Helm reais (${style})...`);
+    for (const primitiveName of primitiveNames) {
+        (0, child_process_1.execSync)(`${ng} g @spartan-ng/cli:ui ${primitiveName} --defaults --force`, {
+            cwd: frontendRoot,
+            stdio: 'inherit'
+        });
+    }
+    ensureSpartanTsconfigPaths(frontendRoot);
+}
+function ensureOfficialSpartanTheme(frontendRoot, theme = 'neutral') {
+    const stylesPath = [
+        path.join(frontendRoot, 'src', 'styles.css'),
+        path.join(frontendRoot, 'src', 'styles.scss')
+    ].find((candidate) => fs.existsSync(candidate));
+    if (!stylesPath)
+        return;
+    const currentStyles = fs.readFileSync(stylesPath, 'utf-8');
+    if (/--radius\s*:/.test(currentStyles) && /--sidebar-background|--sidebar\s*:/.test(currentStyles)) {
+        return;
+    }
+    const ng = getPackageManagerCommand(frontendRoot);
+    console.log(`[Spartan] Aplicando tema oficial "${theme}"...`);
+    (0, child_process_1.execSync)(`${ng} g @spartan-ng/cli:ui-theme --theme=${theme} --defaults`, {
+        cwd: frontendRoot,
+        stdio: 'inherit'
+    });
+}
+function runSpartanPrimitiveGenerator(frontendRoot, style, primitiveName) {
+    ensureSpartanComponentsJson(frontendRoot, style);
+    removeStaleSpartanTsconfigPaths(frontendRoot);
+    ensureSpartanTailwindSource(frontendRoot);
+    ensureSpartanProvider(frontendRoot);
+    const supportedPrimitives = getSupportedSpartanPrimitiveNames(frontendRoot);
+    if (!supportedPrimitives.includes(primitiveName)) {
+        throw new Error(`[Spartan] Primitive "${primitiveName}" não existe na lista oficial do Spartan CLI.`);
+    }
+    const ng = getPackageManagerCommand(frontendRoot);
+    console.log(`[Spartan] Gerando primitive Helm real "${primitiveName}" (${style})...`);
+    (0, child_process_1.execSync)(`${ng} g @spartan-ng/cli:ui ${primitiveName} --defaults --force`, {
+        cwd: frontendRoot,
+        stdio: 'inherit'
+    });
+    ensureSpartanTsconfigPaths(frontendRoot);
+}
+function createBoilerplateCopyFilter(templateRoot) {
+    const ignored = new Set([
+        'node_modules',
+        '.angular',
+        'dist',
+        'coverage',
+        '.turbo',
+        '.nx'
+    ]);
+    return (src) => {
+        const relativePath = path.relative(templateRoot, src);
+        return !relativePath.split(path.sep).some((part) => ignored.has(part));
+    };
+}
+// Helper para garantir e configurar os caminhos de path alias no tsconfig.json do Frontend
+function ensureTsconfigPaths(frontendRoot) {
+    const tsconfigPath = path.join(frontendRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        console.warn(`[Aviso] tsconfig.json não encontrado em ${frontendRoot}. Certifique-se de configurar os path aliases manualmente.`);
+        return;
+    }
+    try {
+        const tsconfig = fs.readJsonSync(tsconfigPath);
+        if (!tsconfig.compilerOptions) {
+            tsconfig.compilerOptions = {};
+        }
+        if (!tsconfig.compilerOptions.paths) {
+            tsconfig.compilerOptions.paths = {};
+        }
+        const aliasKey = '@devstroupe/ui/*';
+        const aliasVal = ['src/app/shared/components/devkit/*'];
+        const spartanUtilsKey = '@spartan-ng/helm/utils';
+        const spartanUtilsVal = ['libs/ui/utils/src/index.ts'];
+        const spartanAliasKey = '@spartan-ng/helm/*';
+        const spartanAliasVal = ['libs/ui/*/src/index.ts'];
+        let updated = false;
+        if (!tsconfig.compilerOptions.paths[aliasKey] ||
+            JSON.stringify(tsconfig.compilerOptions.paths[aliasKey]) !== JSON.stringify(aliasVal)) {
+            tsconfig.compilerOptions.paths[aliasKey] = aliasVal;
+            updated = true;
+        }
+        if (!tsconfig.compilerOptions.paths[spartanUtilsKey] ||
+            JSON.stringify(tsconfig.compilerOptions.paths[spartanUtilsKey]) !== JSON.stringify(spartanUtilsVal)) {
+            tsconfig.compilerOptions.paths[spartanUtilsKey] = spartanUtilsVal;
+            updated = true;
+        }
+        if (!tsconfig.compilerOptions.paths[spartanAliasKey] ||
+            JSON.stringify(tsconfig.compilerOptions.paths[spartanAliasKey]) !== JSON.stringify(spartanAliasVal)) {
+            tsconfig.compilerOptions.paths[spartanAliasKey] = spartanAliasVal;
+            updated = true;
+        }
+        if (updated) {
+            fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), 'utf-8');
+            console.log(`[TSConfig] Path aliases configurados com sucesso em: ${tsconfigPath}`);
+        }
+    }
+    catch (err) {
+        console.error(`[Erro] Falha ao atualizar o tsconfig.json em ${tsconfigPath}:`, err);
+    }
+}
+function ensureIconDependencies(frontendRoot) {
+    const pkgJsonPath = path.join(frontendRoot, 'package.json');
+    if (!fs.existsSync(pkgJsonPath))
+        return;
+    try {
+        const pkgJson = fs.readJsonSync(pkgJsonPath);
+        const deps = ['@ng-icons/core', '@ng-icons/lucide'];
+        const missingDeps = deps.filter(dep => {
+            const hasDep = (pkgJson.dependencies && pkgJson.dependencies[dep]) ||
+                (pkgJson.devDependencies && pkgJson.devDependencies[dep]);
+            return !hasDep;
+        });
+        if (missingDeps.length > 0) {
+            console.log(`[Icones] Instalando dependências de ícones necessárias: ${missingDeps.join(', ')}...`);
+            const workspaceRoot = process.cwd();
+            const isPnpm = fs.existsSync(path.join(workspaceRoot, 'pnpm-lock.yaml'));
+            const { execSync } = require('child_process');
+            for (const dep of missingDeps) {
+                if (isPnpm) {
+                    execSync(`pnpm --dir "${frontendRoot}" add ${dep}`, { stdio: 'inherit' });
+                }
+                else {
+                    execSync(`npm --prefix "${frontendRoot}" install ${dep} --legacy-peer-deps`, { stdio: 'inherit' });
+                }
+            }
+            console.log('[Icones] Dependências de ícones instaladas com sucesso!');
+        }
+    }
+    catch (err) {
+        console.warn('[Aviso] Falha ao instalar automaticamente dependências de ícones:', err);
+    }
+}
+// Helper para inicializar o Design System local copiando os arquivos de template de UI
+function initUi(frontendRoot, config) {
+    ensureIconDependencies(frontendRoot);
+    const designSystemConfig = config.designSystem || {};
+    const projectName = config.projectName || 'DevsTroupe Project';
+    // Obter navegação configurada ou padrão
+    let navigation = [];
+    if (config.layout && config.layout.navigation) {
+        navigation = config.layout.navigation;
+    }
+    else {
+        navigation = [
+            { label: 'Dashboard', icon: 'lucideHome', route: '/dashboard' },
+            { label: 'Playground', icon: 'lucidePalette', route: '/playground' }
+        ];
+        if (config.entities && Array.isArray(config.entities)) {
+            config.entities.forEach((entity) => {
+                navigation.push({
+                    label: entity.label || entity.name,
+                    icon: 'lucideTable',
+                    route: `/${entity.name}`
+                });
+            });
+        }
+    }
+    const targetDir = path.join(frontendRoot, 'src', 'app', 'shared', 'components', 'devkit');
+    const layoutsDir = path.join(frontendRoot, 'src', 'app', 'shared', 'layouts', 'main-layout');
+    const spartanStyle = getSpartanStyle(config);
+    console.log(`Injetando componentes locais do Design System em: ${targetDir}...`);
+    runSpartanGenerator(frontendRoot, spartanStyle);
+    ensureOfficialSpartanTheme(frontendRoot, designSystemConfig.spartanTheme || 'neutral');
+    // Garantir diretórios dos componentes
+    fs.ensureDirSync(targetDir);
+    fs.ensureDirSync(path.join(targetDir, 'button'));
+    fs.ensureDirSync(path.join(targetDir, 'input'));
+    fs.ensureDirSync(path.join(targetDir, 'select'));
+    fs.ensureDirSync(path.join(targetDir, 'table'));
+    fs.ensureDirSync(path.join(targetDir, 'filter'));
+    fs.ensureDirSync(path.join(targetDir, 'card-list'));
+    fs.ensureDirSync(path.join(targetDir, 'simple-list'));
+    fs.ensureDirSync(path.join(targetDir, 'dialog'));
+    fs.ensureDirSync(path.join(targetDir, 'shell'));
+    fs.ensureDirSync(path.join(targetDir, 'sidebar'));
+    fs.ensureDirSync(path.join(targetDir, 'header'));
+    fs.ensureDirSync(path.join(targetDir, 'ui-badge-helm'));
+    fs.ensureDirSync(path.join(targetDir, 'ui-avatar-helm'));
+    // Garantir diretório do Layout
+    fs.ensureDirSync(layoutsDir);
+    // O tema e os tokens visuais pertencem ao gerador oficial do Spartan.
+    fs.writeFileSync(path.join(targetDir, 'README.md'), (0, ui_templates_1.devkitLocalReadmeTemplate)(), 'utf-8');
+    // 2. Escrever Button Component
+    const btn = (0, ui_templates_1.devkitButtonTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'button', 'button.component.ts'), btn.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'button', 'button.component.html'), btn.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'button', 'button.component.css'), btn.css, 'utf-8');
+    // 3. Escrever Input Component
+    const inp = (0, ui_templates_1.devkitInputTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'input', 'input.component.ts'), inp.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'input', 'input.component.html'), inp.html, 'utf-8');
+    // 4. Escrever Select Component
+    const sel = (0, ui_templates_1.devkitSelectTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'select', 'select.component.ts'), sel.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'select', 'select.component.html'), sel.html, 'utf-8');
+    // 5. Escrever Table Component
+    const tbl = (0, ui_templates_1.devkitTableTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'table', 'table.component.ts'), tbl.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'table', 'table.component.html'), tbl.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'table', 'table.component.css'), tbl.css, 'utf-8');
+    // 6. Escrever Filter Component
+    const flt = (0, ui_templates_1.devkitFilterTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'filter', 'filter.component.ts'), flt.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'filter', 'filter.component.html'), flt.html, 'utf-8');
+    // 7. Escrever Card List Component
+    const crd = (0, ui_templates_1.devkitCardListTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'card-list', 'card-list.component.ts'), crd.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'card-list', 'card-list.component.html'), crd.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'card-list', 'card-list.component.css'), crd.css, 'utf-8');
+    // 8. Escrever Simple List Component
+    const smp = (0, ui_templates_1.devkitSimpleListTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'simple-list', 'simple-list.component.ts'), smp.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'simple-list', 'simple-list.component.html'), smp.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'simple-list', 'simple-list.component.css'), smp.css, 'utf-8');
+    // 9. Escrever Dialog Component
+    const dlg = (0, ui_templates_1.devkitDialogTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'dialog', 'dialog.component.ts'), dlg.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'dialog', 'dialog.component.html'), dlg.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'dialog', 'dialog.component.css'), dlg.css, 'utf-8');
+    // 10. Escrever Shell Component
+    const shl = (0, ui_templates_1.devkitShellTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'shell', 'shell.component.ts'), shl.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'shell', 'shell.component.html'), shl.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'shell', 'shell.component.css'), shl.css, 'utf-8');
+    // 11. Escrever Sidebar Component
+    const sdb = (0, ui_templates_1.devkitSidebarTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'sidebar', 'sidebar.component.ts'), sdb.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'sidebar', 'sidebar.component.html'), sdb.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'sidebar', 'sidebar.component.css'), sdb.css, 'utf-8');
+    // 12. Escrever Header Component
+    const hdr = (0, ui_templates_1.devkitHeaderTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'header', 'header.component.ts'), hdr.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'header', 'header.component.html'), hdr.html, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'header', 'header.component.css'), hdr.css, 'utf-8');
+    // 13. Escrever MainLayout Component
+    writeAppNavigation(frontendRoot, navigation);
+    const brandLogo = config.layout?.brandLogo || '';
+    const brandLogoCollapsed = config.layout?.brandLogoCollapsed || '';
+    const lyt = (0, ui_templates_1.devkitMainLayoutTemplate)(projectName, brandLogo, brandLogoCollapsed);
+    fs.writeFileSync(path.join(layoutsDir, 'main-layout.component.ts'), lyt.ts, 'utf-8');
+    fs.writeFileSync(path.join(layoutsDir, 'main-layout.component.html'), lyt.html, 'utf-8');
+    fs.writeFileSync(path.join(layoutsDir, 'main-layout.component.css'), lyt.css, 'utf-8');
+    // 14. Escrever DevkitBadge Component baseado no HlmBadge real gerado pelo Spartan
+    const bdg = (0, ui_templates_1.devkitBadgeTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'ui-badge-helm', 'badge.component.ts'), bdg.ts, 'utf-8');
+    // 15. Escrever DevkitAvatar Component
+    const avt = (0, ui_templates_1.devkitAvatarTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'ui-avatar-helm', 'avatar.component.ts'), avt.ts, 'utf-8');
+    // 16. Escrever Playground Component
+    const playgroundDir = path.join(frontendRoot, 'src', 'app', 'modules', 'playground');
+    fs.ensureDirSync(playgroundDir);
+    const ply = (0, ui_templates_1.devkitPlaygroundComponentTemplate)(getSupportedSpartanPrimitiveNames(frontendRoot));
+    fs.writeFileSync(path.join(playgroundDir, 'playground.component.ts'), ply.ts, 'utf-8');
+    fs.writeFileSync(path.join(playgroundDir, 'playground.component.html'), ply.html, 'utf-8');
+    fs.writeFileSync(path.join(playgroundDir, 'playground.component.css'), ply.css, 'utf-8');
+    // 17. Escrever ThemeService
+    const servicesDir = path.join(frontendRoot, 'src', 'app', 'core', 'services');
+    fs.ensureDirSync(servicesDir);
+    fs.writeFileSync(path.join(servicesDir, 'theme.service.ts'), (0, ui_templates_1.devkitThemeServiceTemplate)(), 'utf-8');
+    // 18. Escrever ProfileService
+    fs.writeFileSync(path.join(servicesDir, 'profile.service.ts'), (0, ui_templates_1.devkitProfileServiceTemplate)(), 'utf-8');
+    // 19. Escrever ProfileComponent
+    const profileDir = path.join(frontendRoot, 'src', 'app', 'modules', 'profile');
+    fs.ensureDirSync(profileDir);
+    const prf = (0, ui_templates_1.devkitProfileComponentTemplate)();
+    fs.writeFileSync(path.join(profileDir, 'profile.component.ts'), prf.ts, 'utf-8');
+    fs.writeFileSync(path.join(profileDir, 'profile.component.html'), prf.html, 'utf-8');
+    fs.writeFileSync(path.join(profileDir, 'profile.component.css'), prf.css, 'utf-8');
+    console.log(`[UI] Componentes DevKit, layout, Playground, ThemeService, ProfileService e ProfileComponent gerados com Spartan style="${spartanStyle}".`);
+    // Configurar tsconfig.json
+    ensureTsconfigPaths(frontendRoot);
+    // Atualizar roteamento para suportar MainLayoutComponent
+    updateAppRoutes(frontendRoot, config);
+}
+function updateAppRoutes(frontendRoot, config = {}) {
+    const routesPath = path.join(frontendRoot, 'src', 'app', 'app.routes.ts');
+    if (!fs.existsSync(routesPath)) {
+        return;
+    }
+    // Filtrar entidades que possuem pasta em src/app/modules
+    const entities = Array.isArray(config) ? config : config.entities;
+    const activeEntities = (entities || []).filter((entity) => {
+        if (!entity || !entity.name)
+            return false;
+        const modulePath = path.join(frontendRoot, 'src', 'app', 'modules', entity.name);
+        return fs.existsSync(modulePath);
+    });
+    let routeImports = '';
+    let entityRoutes = '';
+    activeEntities.forEach((entity) => {
+        const pascalName = kebabToPascal(entity.name);
+        const formDialogPath = path.join(frontendRoot, 'src', 'app', 'modules', entity.name, 'form-dialog-handler');
+        const hasDialog = fs.existsSync(formDialogPath);
+        const routeConstant = `${entity.name.replace(/-/g, '_').toUpperCase()}_ROUTES`;
+        const featureRoutesPath = path.join(frontendRoot, 'src', 'app', 'modules', entity.name, `${entity.name}.routes.ts`);
+        let featureRoutes = `import { Routes } from '@angular/router';\n\nexport const ${routeConstant}: Routes = [\n`;
+        if (hasDialog) {
+            featureRoutes += `  {\n`;
+            featureRoutes += `    path: '',\n`;
+            featureRoutes += `    loadComponent: () => import('./list/${entity.name}-list.component').then(m => m.${pascalName}ListComponent),\n`;
+            featureRoutes += `    children: [\n`;
+            featureRoutes += `      { path: 'new', loadComponent: () => import('./form-dialog-handler/${entity.name}-form-dialog-handler.component').then(m => m.${pascalName}FormDialogHandlerComponent) },\n`;
+            featureRoutes += `      { path: ':id/edit', loadComponent: () => import('./form-dialog-handler/${entity.name}-form-dialog-handler.component').then(m => m.${pascalName}FormDialogHandlerComponent) }\n`;
+            featureRoutes += `    ]\n`;
+            featureRoutes += `  }\n`;
+        }
+        else {
+            featureRoutes += `  { path: 'new', loadComponent: () => import('./form/${entity.name}-form.component').then(m => m.${pascalName}FormComponent) },\n`;
+            featureRoutes += `  { path: ':id/edit', loadComponent: () => import('./form/${entity.name}-form.component').then(m => m.${pascalName}FormComponent) },\n`;
+            featureRoutes += `  { path: '', loadComponent: () => import('./list/${entity.name}-list.component').then(m => m.${pascalName}ListComponent) }\n`;
+        }
+        featureRoutes += `];\n`;
+        fs.writeFileSync(featureRoutesPath, featureRoutes, 'utf-8');
+        routeImports += `import { ${routeConstant} } from './modules/${entity.name}/${entity.name}.routes';\n`;
+        entityRoutes += `  { path: '${entity.name}', children: ${routeConstant} },\n`;
+    });
+    const entityRoutesPath = path.join(frontendRoot, 'src', 'app', 'app.entity-routes.ts');
+    fs.writeFileSync(entityRoutesPath, `import { Routes } from '@angular/router';
+
+${routeImports}
+// Gerado a partir do devstroupe.config.ts. As rotas de cada feature ficam no próprio módulo.
+export const ENTITY_ROUTES: Routes = [
+${entityRoutes}];
+`, 'utf-8');
+    const currentRoutes = fs.readFileSync(routesPath, 'utf-8');
+    if (!currentRoutes.includes('ENTITY_ROUTES')) {
+        const updatedRoutesContent = `import { Routes } from '@angular/router';
+import { authGuard } from './core/guards/auth.guard';
+import { LoginComponent } from './modules/auth/login/login.component';
+import { RegisterComponent } from './modules/auth/register/register.component';
+import { DashboardComponent } from './modules/dashboard/dashboard.component';
+import { MainLayoutComponent } from './shared/layouts/main-layout/main-layout.component';
+import { ENTITY_ROUTES } from './app.entity-routes';
+
+export const routes: Routes = [
+  { path: 'login', component: LoginComponent },
+  { path: 'register', component: RegisterComponent },
+  {
+    path: '',
+    component: MainLayoutComponent,
+    canActivate: [authGuard],
+    children: [
+      { path: '', component: DashboardComponent },
+      { path: 'dashboard', component: DashboardComponent },
+      { path: 'profile', loadComponent: () => import('./modules/profile/profile.component').then(m => m.ProfileComponent) },
+      { path: 'playground', loadComponent: () => import('./modules/playground/playground.component').then(m => m.PlaygroundComponent) },
+      ...ENTITY_ROUTES
+    ]
+  },
+  { path: '**', redirectTo: '' }
+];
+`;
+        fs.writeFileSync(routesPath, updatedRoutesContent, 'utf-8');
+    }
+    console.log('[Roteamento] app.entity-routes.ts sincronizado com as entidades ativas.');
+    updateMainLayoutNavigation(frontendRoot, activeEntities, config.layout?.navigation);
+}
+function updateMainLayoutNavigation(frontendRoot, entities = [], configuredNavigation) {
+    const layoutPath = path.join(frontendRoot, 'src', 'app', 'shared', 'layouts', 'main-layout', 'main-layout.component.ts');
+    if (!fs.existsSync(layoutPath))
+        return;
+    const navigation = configuredNavigation ?? [
+        { label: 'Dashboard', icon: 'lucideHome', route: '/dashboard' },
+        { label: 'Playground', icon: 'lucidePalette', route: '/playground' },
+        ...entities
+            .filter((entity) => !entity.navigation?.hidden)
+            .sort((left, right) => (left.navigation?.order ?? Number.MAX_SAFE_INTEGER) -
+            (right.navigation?.order ?? Number.MAX_SAFE_INTEGER))
+            .map((entity) => ({
+            label: entity.navigation?.label || entity.label || entity.name,
+            icon: entity.navigation?.icon || 'lucideTable',
+            route: `/${entity.name}`
+        }))
+    ];
+    writeAppNavigation(frontendRoot, navigation);
+    const content = fs.readFileSync(layoutPath, 'utf-8');
+    const declaration = 'menuItems: INavigationItem[] =';
+    const declarationIndex = content.indexOf(declaration);
+    if (declarationIndex < 0)
+        return;
+    const initializerEnd = content.indexOf(';', declarationIndex + declaration.length);
+    const initializer = content.slice(declarationIndex + declaration.length, initializerEnd).trim();
+    if (initializer === 'APP_NAVIGATION') {
+        console.log('[Navegação] Menu principal sincronizado com as entidades ativas.');
+        return;
+    }
+    const arrayStart = content.indexOf('[', declarationIndex + declaration.length);
+    if (arrayStart < 0)
+        return;
+    let depth = 0;
+    let arrayEnd = -1;
+    for (let index = arrayStart; index < content.length; index++) {
+        if (content[index] === '[')
+            depth++;
+        if (content[index] === ']')
+            depth--;
+        if (depth === 0) {
+            arrayEnd = index;
+            break;
+        }
+    }
+    if (arrayEnd < 0)
+        return;
+    let updated = `${content.slice(0, arrayStart)}APP_NAVIGATION${content.slice(arrayEnd + 1)}`;
+    if (!updated.includes("from '../../../app.navigation'")) {
+        const importLine = "import { APP_NAVIGATION } from '../../../app.navigation';\n";
+        const lastImportEnd = updated.lastIndexOf('\n', updated.lastIndexOf('import '));
+        updated = `${updated.slice(0, lastImportEnd + 1)}${importLine}${updated.slice(lastImportEnd + 1)}`;
+    }
+    fs.writeFileSync(layoutPath, updated, 'utf-8');
+    console.log('[Navegação] Menu principal sincronizado com as entidades ativas.');
+}
+function writeAppNavigation(frontendRoot, navigation) {
+    const navigationPath = path.join(frontendRoot, 'src', 'app', 'app.navigation.ts');
+    const items = JSON.stringify(navigation, null, 2)
+        .replace(/"(label|icon|route|badge|roles|children)":/g, '$1:');
+    const content = `import { INavigationItem } from './shared/components/devkit/sidebar/sidebar.component';
+
+// Gerado a partir do devstroupe.config.ts. Customize pela configuração da entidade.
+export const APP_NAVIGATION: INavigationItem[] = ${items};
+`;
+    fs.writeFileSync(navigationPath, content, 'utf-8');
+    ensureNavigationIcons(frontendRoot, navigation.map((item) => item.icon).filter(Boolean));
+}
+function ensureNavigationIcons(frontendRoot, icons) {
+    const configPath = path.join(frontendRoot, 'src', 'app', 'app.config.ts');
+    if (!fs.existsSync(configPath))
+        return;
+    const validIcons = [...new Set(icons)].filter((icon) => /^lucide[A-Z][A-Za-z0-9]*$/.test(icon));
+    let content = fs.readFileSync(configPath, 'utf-8');
+    const missingIcons = validIcons.filter((icon) => !new RegExp(`\\b${icon}\\b`).test(content));
+    if (missingIcons.length === 0)
+        return;
+    content = content.replace(/([\s\S]*?)(\n} from '@ng-icons\/lucide';)/, (match, imports, suffix) => `${imports.replace(/\s*$/, '')},\n  ${missingIcons.join(',\n  ')}${suffix}`);
+    content = content.replace(/(provideIcons\(\{[\s\S]*?)(\n\s*}\))/, (match, providers, suffix) => `${providers.replace(/\s*$/, '')},\n      ${missingIcons.join(',\n      ')}${suffix}`);
+    fs.writeFileSync(configPath, content, 'utf-8');
+}
+program
+    .name('devstroupe')
+    .description('DevsTroupe Development Kit (DT-DevKit) CLI')
+    .version('1.0.0');
+// Comando init
+program
+    .command('init')
+    .description('Inicializa o arquivo de configuração devstroupe.config.ts na raiz do projeto')
+    .action(() => {
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (fs.existsSync(configPath)) {
+        console.log('O arquivo devstroupe.config.ts já existe na raiz do projeto.');
+        return;
+    }
+    const configContent = `export default {
+  projectName: 'TrevoIA',
+  backendPath: './backend',
+  frontendPath: './frontend',
+  designSystem: {
+    provider: 'spartan',
+    spartanStyle: 'vega', // 'nova' | 'vega' | 'lyra' | 'maia' | 'mira' | 'luma'
+    spartanTheme: 'neutral', // 'neutral' | 'stone' | 'zinc' | 'gray' | 'slate'
+    installAllPrimitives: true,
+    includePlayground: true,
+  },
+  entities: [
+    {
+      name: 'company',
+      label: 'Empresa',
+      tableName: 'companies',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        {
+          name: 'cabins', type: 'relationship', required: false, label: 'Cabines',
+          relation: {
+            target: 'cabin', kind: 'one-to-many', foreignKey: 'company_id',
+            inverseSide: 'company', control: 'table', embedded: true,
+            columns: ['name', 'code', 'is_active'], lookup: { pageSize: 10 }
+          }
+        }
+      ],
+      crud: { generateFrontend: true, generateBackend: true }
+    },
+    {
+      name: 'cabin',
+      label: 'Cabine',
+      tableName: 'cabins',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        { name: 'code', type: 'string', required: false, label: 'Código' },
+        {
+          name: 'company_id', type: 'relationship', required: true, label: 'Empresa',
+          relation: {
+            target: 'company', kind: 'many-to-one', relationName: 'company',
+            inverseSide: 'cabins', control: 'select', displayField: 'name', onDelete: 'CASCADE',
+            lookup: { mode: 'remote', pageSize: 20, minSearchLength: 0 }
+          }
+        },
+        { name: 'is_active', type: 'boolean', required: true, label: 'Ativo', default: true }
+      ],
+      crud: {
+        generateFrontend: true,
+        generateBackend: true
+      }
+    }
+  ]
+};
+`;
+    fs.writeFileSync(configPath, configContent, 'utf-8');
+    console.log('Arquivo devstroupe.config.ts criado com sucesso!');
+});
+// Novo Comando init-ui para forçar geração manual do Design System
+program
+    .command('init-ui')
+    .description('Inicializa o Design System local copiando estilos e componentes primitivos para o projeto Angular')
+    .option('-s, --style <style>', 'Style Spartan: nova, vega, lyra, maia, mira ou luma')
+    .action((options) => {
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath)) {
+        console.error('Arquivo devstroupe.config.ts não encontrado na raiz. Rode "devstroupe init" primeiro.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        const importedConfig = require(configPath);
+        config = importedConfig.default || importedConfig;
+    }
+    catch (error) {
+        console.error('Erro ao carregar devstroupe.config.ts:', error);
+        process.exit(1);
+    }
+    try {
+        assertValidRelationshipConfig(config);
+    }
+    catch (error) {
+        console.error('Configuração de relacionamentos inválida:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    const frontendRoot = path.resolve(process.cwd(), config.frontendPath || './frontend');
+    if (!fs.existsSync(frontendRoot)) {
+        console.error(`Diretório frontend não encontrado em: ${frontendRoot}. Certifique-se de configurar o "frontendPath" no devstroupe.config.ts corretamente.`);
+        process.exit(1);
+    }
+    const requestedStyle = options.style;
+    if (requestedStyle) {
+        if (!isSpartanStyle(requestedStyle)) {
+            console.error(`Style Spartan inválido "${requestedStyle}". Use: ${SPARTAN_STYLES.join(', ')}.`);
+            process.exit(1);
+        }
+        config.designSystem = { ...(config.designSystem || {}), spartanStyle: requestedStyle };
+    }
+    initUi(frontendRoot, config);
+    console.log('Design System local inicializado e mapeado com sucesso!');
+});
+program
+    .command('ui:set-style <style>')
+    .description('Altera o style do Spartan e regenera todos os primitives Helm reais em libs/ui')
+    .action((style) => {
+    if (!isSpartanStyle(style)) {
+        console.error(`Style Spartan inválido "${style}". Use: ${SPARTAN_STYLES.join(', ')}.`);
+        process.exit(1);
+    }
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath)) {
+        console.error('Arquivo devstroupe.config.ts não encontrado na raiz. Rode "devstroupe init" primeiro.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        delete require.cache[require.resolve(configPath)];
+        const importedConfig = require(configPath);
+        config = importedConfig.default || importedConfig;
+    }
+    catch (error) {
+        console.error('Erro ao carregar devstroupe.config.ts:', error);
+        process.exit(1);
+    }
+    const frontendRoot = path.resolve(process.cwd(), config.frontendPath || './frontend');
+    if (!fs.existsSync(frontendRoot)) {
+        console.error(`Diretório frontend não encontrado em: ${frontendRoot}.`);
+        process.exit(1);
+    }
+    runSpartanGenerator(frontendRoot, style, true);
+    console.log(`[Spartan] Style alterado para "${style}" e primitives regenerados em libs/ui.`);
+});
+// Novo comando lint:rules
+program
+    .command('lint:rules')
+    .description('Audita o projeto para garantir a conformidade com as regras e boas práticas de governança da DevsTroupe')
+    .action(() => {
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath)) {
+        console.error('Arquivo devstroupe.config.ts não encontrado na raiz. Rode "devstroupe init" primeiro.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        const importedConfig = require(configPath);
+        config = importedConfig.default || importedConfig;
+    }
+    catch (error) {
+        console.error('Erro ao carregar devstroupe.config.ts:', error);
+        process.exit(1);
+    }
+    console.log('Iniciando varredura estática de governança da DevsTroupe...');
+    const result = (0, linter_rules_1.runLinter)(process.cwd(), config);
+    console.log(`\nVarredura finalizada. Escaneados ${result.filesScanned} arquivos.`);
+    if (result.violations.length === 0) {
+        console.log('\x1b[32m[SUCESSO] Nenhuma violação de governança encontrada! O projeto segue todos os padrões de código.\x1b[0m');
+        process.exit(0);
+    }
+    console.log(`Encontradas ${result.violations.length} violações de governança:\n`);
+    let errorCount = 0;
+    let warnCount = 0;
+    result.violations.forEach((v) => {
+        const isError = v.severity === 'error';
+        if (isError)
+            errorCount++;
+        else
+            warnCount++;
+        const severityTag = isError ? '\x1b[31m[ERRO]\x1b[0m' : '\x1b[33m[AVISO]\x1b[0m';
+        console.log(`${severityTag} ${v.file}:${v.line} (${v.rule})`);
+        console.log(`       => ${v.message}\n`);
+    });
+    console.log(`Resumo: ${errorCount} erros críticos, ${warnCount} avisos de atenção.`);
+    if (errorCount > 0) {
+        console.error('\x1b[31m[FALHA] A validação de governança falhou devido a erros críticos.\x1b[0m');
+        process.exit(1);
+    }
+    else {
+        console.log('\x1b[33m[AVISO] Varredura passou com avisos secundários.\x1b[0m');
+        process.exit(0);
+    }
+});
+// Comando generate crud
+program
+    .command('generate <type> <entityName>')
+    .description('Gera artefatos do DevKit. Tipos suportados: crud')
+    .action((type, entityName) => {
+    if (type !== 'crud') {
+        console.error(`Tipo de geração "${type}" não é suportado. Use "crud".`);
+        process.exit(1);
+    }
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath)) {
+        console.error('Arquivo devstroupe.config.ts não encontrado na raiz. Rode "devstroupe init" primeiro.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        const importedConfig = require(configPath);
+        config = importedConfig.default || importedConfig;
+    }
+    catch (error) {
+        console.error('Erro ao carregar devstroupe.config.ts:', error);
+        process.exit(1);
+    }
+    try {
+        assertValidRelationshipConfig(config);
+    }
+    catch (error) {
+        console.error('Configuração de relacionamentos inválida:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    const entity = config.entities?.find((e) => e.name.toLowerCase() === entityName.toLowerCase());
+    if (!entity) {
+        console.error(`Entidade "${entityName}" não configurada no devstroupe.config.ts.`);
+        process.exit(1);
+    }
+    const backendRoot = path.resolve(process.cwd(), config.backendPath || './backend');
+    const frontendRoot = path.resolve(process.cwd(), config.frontendPath || './frontend');
+    // 1. Gerar Backend (NestJS)
+    if (entity.crud?.generateBackend !== false) {
+        const isMultiTenant = !!config.multiTenant?.enabled;
+        const isTenantScoped = isMultiTenant && (entity.tenantScoped !== false);
+        const isMicroservices = config.backendType === 'microservices';
+        const backendProperties = isMicroservices
+            ? entity.properties
+                .filter((property) => property.type !== 'relationship' || (0, relationships_1.getRelationships)([property])[0].kind !== 'one-to-many')
+                .map((property) => property.type === 'relationship'
+                ? { ...property, type: 'number', name: (0, relationships_1.getRelationships)([property])[0].foreignKey }
+                : property)
+            : entity.properties;
+        let boilerplatesDir = path.resolve(__dirname, 'boilerplates');
+        if (!fs.existsSync(boilerplatesDir)) {
+            boilerplatesDir = path.resolve(__dirname, '../boilerplates');
+        }
+        if (!fs.existsSync(boilerplatesDir)) {
+            boilerplatesDir = path.resolve(__dirname, '../../boilerplates');
+        }
+        const nestTemplateDir = path.join(boilerplatesDir, 'nest-template');
+        if (isMicroservices) {
+            const entityIndex = config.entities.findIndex((e) => e.name.toLowerCase() === entity.name.toLowerCase());
+            const port = 3001 + (entityIndex >= 0 ? entityIndex : 0);
+            // Garantir estrutura do API Gateway
+            const gatewayRoot = path.join(backendRoot, 'api-gateway');
+            if (!fs.existsSync(gatewayRoot) || !fs.existsSync(path.join(gatewayRoot, 'src', 'app.module.ts'))) {
+                console.log(`[Gateway] Inicializando estrutura do API Gateway...`);
+                fs.ensureDirSync(gatewayRoot);
+                fs.copySync(nestTemplateDir, gatewayRoot);
+                const gatewayEnv = `PORT=13000
+DB_HOST=database
+DB_PORT=3306
+DB_USER=root
+DB_PASSWORD=root
+DB_NAME=devstroupe
+JWT_SECRET=devstroupe-secret-key-12345
+`;
+                fs.writeFileSync(path.join(gatewayRoot, '.env'), gatewayEnv, 'utf-8');
+                fs.writeFileSync(path.join(gatewayRoot, '.env.example'), gatewayEnv, 'utf-8');
+                patchLocalDependencies(gatewayRoot, null, boilerplatesDir);
+                try {
+                    console.log(`[Gateway] Instalando dependências em: ${gatewayRoot}...`);
+                    (0, child_process_1.execSync)('npm install', { cwd: gatewayRoot, stdio: 'inherit' });
+                }
+                catch (err) {
+                    console.warn(`[Aviso] Falha ao rodar "npm install" no API Gateway. Instale manualmente.`);
+                }
+            }
+            const msRoot = path.join(backendRoot, 'services', entity.name);
+            console.log(`Gerando Microsserviço para a entidade "${entityName}" em: ${msRoot}...`);
+            if (!fs.existsSync(msRoot) || !fs.existsSync(path.join(msRoot, 'src', 'app.module.ts'))) {
+                console.log(`[Microsserviço] Inicializando estrutura do microsserviço...`);
+                fs.ensureDirSync(msRoot);
+                fs.copySync(nestTemplateDir, msRoot);
+                // Limpa módulos desnecessários
+                fs.removeSync(path.join(msRoot, 'src', 'modules', 'user'));
+                fs.removeSync(path.join(msRoot, 'src', 'modules', 'auth'));
+                // Injeta arquivos específicos de microsserviço
+                fs.writeFileSync(path.join(msRoot, 'src', 'main.ts'), generateMsMainTs(port), 'utf-8');
+                fs.writeFileSync(path.join(msRoot, 'src', 'app.module.ts'), generateMsAppModule(entity.name), 'utf-8');
+                // Injeta env básico no microsserviço
+                const msEnv = `PORT=${port}
+DB_HOST=database
+DB_PORT=3306
+DB_USER=root
+DB_PASSWORD=root
+DB_NAME=devstroupe_${entity.name.toLowerCase()}
+SERVICE_PORT=${port}
+`;
+                fs.writeFileSync(path.join(msRoot, '.env'), msEnv, 'utf-8');
+                fs.writeFileSync(path.join(msRoot, '.env.example'), msEnv, 'utf-8');
+                patchLocalDependencies(msRoot, null, boilerplatesDir);
+                try {
+                    console.log(`[Microsserviço] Instalando dependências em: ${msRoot}...`);
+                    (0, child_process_1.execSync)('npm install', { cwd: msRoot, stdio: 'inherit' });
+                }
+                catch (err) {
+                    console.warn(`[Aviso] Falha ao rodar "npm install" no microsserviço. Instale manualmente.`);
+                }
+            }
+            const modulePath = path.join(msRoot, 'src', 'modules', entity.name);
+            fs.ensureDirSync(path.join(modulePath, 'domain'));
+            fs.ensureDirSync(path.join(modulePath, 'service'));
+            fs.ensureDirSync(path.join(modulePath, 'infra', 'database'));
+            fs.ensureDirSync(path.join(modulePath, 'infra', 'http'));
+            // Domain Entity
+            fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.ts`), (0, cli_templates_1.nestDomainEntityTemplate)(entity.name, backendProperties, isTenantScoped), 'utf-8');
+            // Repository Port
+            fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.repository.port.ts`), (0, cli_templates_1.nestRepositoryPortTemplate)(entity.name), 'utf-8');
+            // DTO
+            fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, backendProperties), 'utf-8');
+            // Controller (TCP)
+            fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.ms.controller.ts`), (0, cli_templates_1.nestMsControllerTemplate)(entity.name), 'utf-8');
+            // ORM Entity
+            fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.orm-entity.ts`), (0, cli_templates_1.nestOrmEntityTemplate)(entity.name, backendProperties, entity.tableName || `${entity.name}s`, isTenantScoped), 'utf-8');
+            // Repository Adapter
+            fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.repository.ts`), (0, cli_templates_1.nestRepositoryAdapterTemplate)(entity.name, backendProperties, isTenantScoped), 'utf-8');
+            // Service
+            fs.writeFileSync(path.join(modulePath, 'service', `${entity.name}.service.ts`), (0, cli_templates_1.nestServiceTemplate)(entity.name), 'utf-8');
+            // Module (TCP)
+            fs.writeFileSync(path.join(modulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestMsModuleTemplate)(entity.name), 'utf-8');
+            console.log(`[Microsserviço] Arquivos do microsserviço "${entityName}" gerados com sucesso.`);
+            if (entity.crud?.generateMigration !== false) {
+                ensureInitialMigrations(msRoot, [entity], new Map([[entity.name, backendProperties]]));
+            }
+            // --- Gerar API Gateway Module ---
+            const gatewayModulePath = path.join(backendRoot, 'api-gateway', 'src', 'modules', entity.name);
+            console.log(`Gerando Módulo Gateway para a entidade "${entityName}" em: ${gatewayModulePath}...`);
+            fs.ensureDirSync(path.join(gatewayModulePath, 'infra', 'http'));
+            // DTO (Gateway)
+            fs.writeFileSync(path.join(gatewayModulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, backendProperties), 'utf-8');
+            // Controller (Gateway)
+            fs.writeFileSync(path.join(gatewayModulePath, 'infra', 'http', `${entity.name}.controller.ts`), (0, cli_templates_1.nestGatewayControllerTemplate)(entity.name), 'utf-8');
+            // Module (Gateway)
+            fs.writeFileSync(path.join(gatewayModulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestGatewayModuleTemplate)(entity.name, port), 'utf-8');
+            // Patch app.module.ts do Gateway
+            patchGatewayAppModule(path.join(backendRoot, 'api-gateway', 'src', 'app.module.ts'), entity.name);
+            console.log(`[Gateway] Módulo Gateway "${entityName}" gerado com sucesso.`);
+        }
+        else {
+            // Monolito
+            console.log(`Gerando arquivos NestJS Monolito para a entidade "${entityName}"...`);
+            const modulePath = path.join(backendRoot, 'src', 'modules', entity.name);
+            fs.ensureDirSync(path.join(modulePath, 'domain'));
+            fs.ensureDirSync(path.join(modulePath, 'service'));
+            fs.ensureDirSync(path.join(modulePath, 'infra', 'database'));
+            fs.ensureDirSync(path.join(modulePath, 'infra', 'http'));
+            // Domain Entity
+            fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.ts`), (0, cli_templates_1.nestDomainEntityTemplate)(entity.name, entity.properties, isTenantScoped), 'utf-8');
+            // Repository Port
+            fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.repository.port.ts`), (0, cli_templates_1.nestRepositoryPortTemplate)(entity.name), 'utf-8');
+            // DTO
+            fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, entity.properties), 'utf-8');
+            // Controller
+            fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.controller.ts`), (0, cli_templates_1.nestControllerTemplate)(entity.name), 'utf-8');
+            // ORM Entity
+            fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.orm-entity.ts`), (0, cli_templates_1.nestOrmEntityTemplate)(entity.name, entity.properties, entity.tableName || `${entity.name}s`, isTenantScoped), 'utf-8');
+            // Repository Adapter
+            fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.repository.ts`), (0, cli_templates_1.nestRepositoryAdapterTemplate)(entity.name, entity.properties, isTenantScoped), 'utf-8');
+            // Service
+            fs.writeFileSync(path.join(modulePath, 'service', `${entity.name}.service.ts`), (0, cli_templates_1.nestServiceTemplate)(entity.name), 'utf-8');
+            // Module
+            fs.writeFileSync(path.join(modulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestModuleTemplate)(entity.name), 'utf-8');
+            console.log(`[NestJS] Módulo Monolito "${entityName}" gerado com sucesso em: ${modulePath}`);
+            patchMonolithAppModule(path.join(backendRoot, 'src', 'app.module.ts'), entity.name);
+            const migrationEntities = (config.entities ?? []).filter((configuredEntity) => configuredEntity.crud?.generateBackend !== false
+                && configuredEntity.crud?.generateMigration !== false);
+            if (migrationEntities.length > 0) {
+                ensureInitialMigrations(backendRoot, migrationEntities);
+            }
+        }
+        // Regerar docker-compose.yml e init.sql para sincronizar portas/bancos
+        generateDockerComposeAndDbInit(process.cwd(), config);
+    }
+    // 2. Gerar Frontend (Angular)
+    if (entity.crud?.generateFrontend !== false) {
+        console.log(`Gerando arquivos Angular para a entidade "${entityName}"...`);
+        const servicePath = path.join(frontendRoot, 'src', 'app', 'services');
+        const modulePath = path.join(frontendRoot, 'src', 'app', 'modules', entity.name);
+        const uiComponentsDir = path.join(frontendRoot, 'src', 'app', 'shared', 'components', 'devkit');
+        // Hook automático: se a pasta de design system local não existir no frontend, inicializa-a primeiro!
+        if (!fs.existsSync(uiComponentsDir)) {
+            console.log('[Autoconfig] Design System local não encontrado. Inicializando automaticamente...');
+            initUi(frontendRoot, config);
+        }
+        const listType = entity.crud?.listType || config.designSystem?.defaultListType || 'table';
+        const formType = entity.crud?.formType || 'page';
+        const filterType = entity.crud?.filterType || 'popover';
+        fs.ensureDirSync(servicePath);
+        fs.ensureDirSync(path.join(modulePath, 'list'));
+        fs.ensureDirSync(path.join(modulePath, 'form'));
+        if (formType === 'dialog') {
+            fs.ensureDirSync(path.join(modulePath, 'form-dialog-handler'));
+        }
+        // Angular Service
+        fs.writeFileSync(path.join(servicePath, `${entity.name}.service.ts`), (0, cli_templates_1.angularServiceTemplate)(entity.name), 'utf-8');
+        // List HTML
+        fs.writeFileSync(path.join(modulePath, 'list', `${entity.name}-list.component.html`), (0, cli_templates_1.angularListHtmlTemplate)(entity.name, entity.properties, listType, formType, filterType), 'utf-8');
+        // List TS
+        fs.writeFileSync(path.join(modulePath, 'list', `${entity.name}-list.component.ts`), (0, cli_templates_1.angularListTsTemplate)(entity.name, entity.properties, listType, formType), 'utf-8');
+        // Form HTML
+        fs.writeFileSync(path.join(modulePath, 'form', `${entity.name}-form.component.html`), (0, cli_templates_1.angularFormHtmlTemplate)(entity.name, entity.properties, config.entities), 'utf-8');
+        // Form TS
+        fs.writeFileSync(path.join(modulePath, 'form', `${entity.name}-form.component.ts`), (0, cli_templates_1.angularFormTsTemplate)(entity.name, entity.properties, config.entities), 'utf-8');
+        if (formType === 'dialog') {
+            fs.writeFileSync(path.join(modulePath, 'form-dialog-handler', `${entity.name}-form-dialog-handler.component.html`), (0, cli_templates_1.angularFormDialogHandlerHtmlTemplate)(entity.name), 'utf-8');
+            fs.writeFileSync(path.join(modulePath, 'form-dialog-handler', `${entity.name}-form-dialog-handler.component.ts`), (0, cli_templates_1.angularFormDialogHandlerTsTemplate)(entity.name), 'utf-8');
+        }
+        console.log(`[Angular] Módulo "${entityName}" gerado com sucesso em: ${modulePath}`);
+        console.log(`\n\x1b[32m[SUCESSO] Scaffolding de CRUD completo para "${entityName}" finalizado!\x1b[0m`);
+        console.log('[Angular] Rotas e navegação serão sincronizadas automaticamente.');
+        updateAppRoutes(frontendRoot, config);
+    }
+});
+// Helper para linkar dependências locais se estiver rodando no monorepo de desenvolvimento
+function patchLocalDependencies(backendDest, frontendDest, boilerplatesDir) {
+    const packagesDir = path.resolve(boilerplatesDir, '../../..');
+    if (!fs.existsSync(packagesDir) || !fs.existsSync(path.join(packagesDir, 'devkit-core'))) {
+        return;
+    }
+    const coreSrc = path.join(packagesDir, 'devkit-core');
+    const nestSrc = path.join(packagesDir, 'devkit-nest');
+    const angularSrc = path.join(packagesDir, 'devkit-angular');
+    const stripDevelopmentDependencies = (packageDir) => {
+        const packagePath = path.join(packageDir, 'package.json');
+        if (!fs.existsSync(packagePath))
+            return;
+        const packageJson = fs.readJsonSync(packagePath);
+        delete packageJson.devDependencies;
+        packageJson.scripts = {};
+        fs.writeJsonSync(packagePath, packageJson, { spaces: 2 });
+    };
+    const copyFilter = (src) => {
+        const relativePath = path.relative(packagesDir, src);
+        const ignoreList = ['node_modules', '.git', '.angular', 'tsconfig.json', 'tsconfig.build.json', 'src', 'tests', 'test'];
+        const parts = relativePath.split(path.sep);
+        if (parts.length > 1) {
+            const subParts = parts.slice(1);
+            if (subParts.some(p => ignoreList.includes(p))) {
+                return false;
+            }
+            const lastPart = subParts[subParts.length - 1];
+            if (lastPart.endsWith('.ts') && !subParts.includes('dist')) {
+                return false;
+            }
+        }
+        return true;
+    };
+    // 1. Preparar e copiar para o backend
+    if (backendDest && fs.existsSync(backendDest)) {
+        const backendLocalPackages = path.join(backendDest, 'local_packages');
+        if (fs.existsSync(coreSrc)) {
+            const coreDest = path.join(backendLocalPackages, 'devkit-core');
+            fs.ensureDirSync(coreDest);
+            fs.copySync(coreSrc, coreDest, { filter: copyFilter });
+            stripDevelopmentDependencies(coreDest);
+        }
+        if (fs.existsSync(nestSrc)) {
+            const nestDest = path.join(backendLocalPackages, 'devkit-nest');
+            fs.ensureDirSync(nestDest);
+            fs.copySync(nestSrc, nestDest, { filter: copyFilter });
+            stripDevelopmentDependencies(nestDest);
+            // Correção de workspace:* para file:../devkit-core
+            const nestPkgPath = path.join(nestDest, 'package.json');
+            if (fs.existsSync(nestPkgPath)) {
+                try {
+                    const nestPkg = fs.readJsonSync(nestPkgPath);
+                    if (nestPkg.dependencies && nestPkg.dependencies['@devstroupe/devkit-core'] === 'workspace:*') {
+                        nestPkg.dependencies['@devstroupe/devkit-core'] = 'file:../devkit-core';
+                        fs.writeJsonSync(nestPkgPath, nestPkg, { spaces: 2 });
+                        console.log('[DevConfig] Ajustado workspace:* para file:../devkit-core no devkit-nest local.');
+                    }
+                }
+                catch (e) {
+                    console.error('[Erro] Falha ao ajustar dependências no devkit-nest local:', e);
+                }
+            }
+        }
+        // Patch Backend package.json
+        const backendPkgPath = path.join(backendDest, 'package.json');
+        if (fs.existsSync(backendPkgPath)) {
+            try {
+                const pkg = fs.readJsonSync(backendPkgPath);
+                const relCore = 'file:local_packages/devkit-core';
+                const relNest = 'file:local_packages/devkit-nest';
+                if (pkg.dependencies['@devstroupe/devkit-core']) {
+                    pkg.dependencies['@devstroupe/devkit-core'] = relCore;
+                }
+                if (pkg.dependencies['@devstroupe/devkit-nest']) {
+                    pkg.dependencies['@devstroupe/devkit-nest'] = relNest;
+                }
+                fs.writeJsonSync(backendPkgPath, pkg, { spaces: 2 });
+                console.log('[DevConfig] Dependências locais de backend vinculadas com sucesso.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao injetar links locais no backend:', err);
+            }
+        }
+        // Patch Backend Dockerfile para injetar "COPY local_packages/ ./local_packages/" antes do npm install e limpar node_modules local após instalação
+        const backendDockerfile = path.join(backendDest, 'Dockerfile');
+        if (fs.existsSync(backendDockerfile)) {
+            try {
+                let content = fs.readFileSync(backendDockerfile, 'utf-8');
+                const targetStr = 'COPY package*.json ./';
+                const replacementStr = 'COPY package*.json ./\nCOPY local_packages/ ./local_packages/';
+                content = content.split(targetStr).join(replacementStr);
+                // Injeta limpeza de node_modules locais após npm install
+                content = content.replace('RUN npm install --only=production', 'RUN npm install --only=production && rm -rf local_packages/*/node_modules');
+                content = content.replace('RUN npm install', 'RUN npm install && rm -rf local_packages/*/node_modules');
+                fs.writeFileSync(backendDockerfile, content, 'utf-8');
+                console.log('[DevConfig] Dockerfile do backend ajustado para incluir dependências locais.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao ajustar Dockerfile do backend:', err);
+            }
+        }
+        // Patch Backend tsconfig.json to prevent duplicate typeorm types in local development
+        const backendTsconfigPath = path.join(backendDest, 'tsconfig.json');
+        if (fs.existsSync(backendTsconfigPath)) {
+            try {
+                const tsconfig = fs.readJsonSync(backendTsconfigPath);
+                tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+                tsconfig.compilerOptions.paths = tsconfig.compilerOptions.paths || {};
+                // Mapeia pacotes que causam problemas de duplicidade de tipo em links locais
+                tsconfig.compilerOptions.paths['typeorm'] = ['node_modules/typeorm'];
+                tsconfig.compilerOptions.paths['@nestjs/common'] = ['node_modules/@nestjs/common'];
+                tsconfig.compilerOptions.paths['@nestjs/core'] = ['node_modules/@nestjs/core'];
+                tsconfig.compilerOptions.paths['@nestjs/swagger'] = ['node_modules/@nestjs/swagger'];
+                fs.writeJsonSync(backendTsconfigPath, tsconfig, { spaces: 2 });
+                console.log('[DevConfig] Mapeamentos de TSConfig do backend configurados para prevenir duplicidade de pacotes.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao atualizar tsconfig.json do backend:', err);
+            }
+        }
+    }
+    // 2. Preparar e copiar para o frontend
+    if (frontendDest && fs.existsSync(frontendDest)) {
+        const frontendLocalPackages = path.join(frontendDest, 'local_packages');
+        if (fs.existsSync(coreSrc)) {
+            const coreDest = path.join(frontendLocalPackages, 'devkit-core');
+            fs.ensureDirSync(coreDest);
+            fs.copySync(coreSrc, coreDest, { filter: copyFilter });
+            stripDevelopmentDependencies(coreDest);
+        }
+        if (fs.existsSync(angularSrc)) {
+            const angularDest = path.join(frontendLocalPackages, 'devkit-angular');
+            fs.ensureDirSync(angularDest);
+            fs.copySync(angularSrc, angularDest, { filter: copyFilter });
+            stripDevelopmentDependencies(angularDest);
+            // Correção de workspace:* para file:../devkit-core
+            const angularPkgPath = path.join(angularDest, 'package.json');
+            if (fs.existsSync(angularPkgPath)) {
+                try {
+                    const angularPkg = fs.readJsonSync(angularPkgPath);
+                    if (angularPkg.dependencies && angularPkg.dependencies['@devstroupe/devkit-core'] === 'workspace:*') {
+                        angularPkg.dependencies['@devstroupe/devkit-core'] = 'file:../devkit-core';
+                        fs.writeJsonSync(angularPkgPath, angularPkg, { spaces: 2 });
+                        console.log('[DevConfig] Ajustado workspace:* para file:../devkit-core no devkit-angular local.');
+                    }
+                }
+                catch (e) {
+                    console.error('[Erro] Falha ao ajustar dependências no devkit-angular local:', e);
+                }
+            }
+        }
+        // Patch Frontend package.json
+        const frontendPkgPath = path.join(frontendDest, 'package.json');
+        if (fs.existsSync(frontendPkgPath)) {
+            try {
+                const pkg = fs.readJsonSync(frontendPkgPath);
+                const relCore = 'file:local_packages/devkit-core';
+                const relAngular = 'file:local_packages/devkit-angular';
+                if (pkg.dependencies['@devstroupe/devkit-core']) {
+                    pkg.dependencies['@devstroupe/devkit-core'] = relCore;
+                }
+                if (pkg.dependencies['@devstroupe/devkit-angular']) {
+                    pkg.dependencies['@devstroupe/devkit-angular'] = relAngular;
+                }
+                fs.writeJsonSync(frontendPkgPath, pkg, { spaces: 2 });
+                console.log('[DevConfig] Dependências locais de frontend vinculadas com sucesso.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao injetar links locais no frontend:', err);
+            }
+        }
+        // Patch Frontend Dockerfile para injetar "COPY local_packages/ ./local_packages/" antes do npm install e limpar node_modules local após instalação
+        const frontendDockerfile = path.join(frontendDest, 'Dockerfile');
+        if (fs.existsSync(frontendDockerfile)) {
+            try {
+                let content = fs.readFileSync(frontendDockerfile, 'utf-8');
+                const targetStr = 'COPY package*.json ./';
+                const replacementStr = 'COPY package*.json ./\nCOPY local_packages/ ./local_packages/';
+                content = content.split(targetStr).join(replacementStr);
+                // Injeta limpeza de node_modules locais após npm install
+                content = content.replace('RUN npm install --legacy-peer-deps', 'RUN npm install --legacy-peer-deps && rm -rf local_packages/*/node_modules');
+                fs.writeFileSync(frontendDockerfile, content, 'utf-8');
+                console.log('[DevConfig] Dockerfile do frontend ajustado para incluir dependências locais.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao ajustar Dockerfile do frontend:', err);
+            }
+        }
+        // Patch Frontend tsconfig.json to prevent duplicate angular types in local development
+        const frontendTsconfigPath = path.join(frontendDest, 'tsconfig.json');
+        if (fs.existsSync(frontendTsconfigPath)) {
+            try {
+                const tsconfig = fs.readJsonSync(frontendTsconfigPath);
+                tsconfig.compilerOptions = tsconfig.compilerOptions || {};
+                tsconfig.compilerOptions.paths = tsconfig.compilerOptions.paths || {};
+                // Mapeia pacotes que causam problemas de duplicidade de tipo em links locais no frontend
+                tsconfig.compilerOptions.paths['@angular/core'] = ['node_modules/@angular/core'];
+                tsconfig.compilerOptions.paths['@angular/core/*'] = ['node_modules/@angular/core/*'];
+                tsconfig.compilerOptions.paths['@angular/common'] = ['node_modules/@angular/common'];
+                tsconfig.compilerOptions.paths['@angular/common/*'] = ['node_modules/@angular/common/*'];
+                tsconfig.compilerOptions.paths['@angular/common/http'] = ['node_modules/@angular/common/http'];
+                tsconfig.compilerOptions.paths['@angular/common/http/*'] = ['node_modules/@angular/common/http/*'];
+                tsconfig.compilerOptions.paths['@angular/router'] = ['node_modules/@angular/router'];
+                tsconfig.compilerOptions.paths['@angular/router/*'] = ['node_modules/@angular/router/*'];
+                tsconfig.compilerOptions.paths['rxjs'] = ['node_modules/rxjs'];
+                tsconfig.compilerOptions.paths['rxjs/*'] = ['node_modules/rxjs/*'];
+                tsconfig.compilerOptions.paths['@devstroupe/devkit-core'] = ['node_modules/@devstroupe/devkit-core'];
+                tsconfig.compilerOptions.paths['@devstroupe/devkit-core/*'] = ['node_modules/@devstroupe/devkit-core/*'];
+                fs.writeJsonSync(frontendTsconfigPath, tsconfig, { spaces: 2 });
+                console.log('[DevConfig] Mapeamentos de TSConfig do frontend configurados para prevenir duplicidade de pacotes.');
+            }
+            catch (err) {
+                console.error('[Erro] Falha ao atualizar tsconfig.json do frontend:', err);
+            }
+        }
+    }
+}
+// ---------------- Helpers para Microsserviços NestJS ----------------
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function kebabToCamel(s) {
+    return s.replace(/-./g, (x) => x[1].toUpperCase());
+}
+function kebabToPascal(s) {
+    return capitalize(kebabToCamel(s));
+}
+function generateMsMainTs(port) {
+    return `import * as fs from 'fs';
+import * as path from 'path';
+
+// Carrega variáveis do arquivo .env manualmente se ele existir
+const envPath = path.resolve(process.cwd(), '.env');
+if (fs.existsSync(envPath)) {
+  const envConfig = fs.readFileSync(envPath, 'utf-8');
+  envConfig.split('\\n').forEach((line) => {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#')) {
+      const [key, ...values] = trimmed.split('=');
+      const val = values.join('=').trim();
+      if (key && val) {
+        process.env[key.trim()] = val.replace(/^['"]|['"]$/g, '');
+      }
+    }
+  });
+}
+
+import { NestFactory } from '@nestjs/core';
+import { Transport, MicroserviceOptions } from '@nestjs/microservices';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const port = Number(process.env.SERVICE_PORT) || ${port};
+  const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
+    transport: Transport.TCP,
+    options: {
+      host: '0.0.0.0',
+      port: port,
+    },
+  });
+  await app.listen();
+  console.log(\`Microsserviço iniciado via TCP na porta \${port}\`);
+}
+bootstrap();
+`;
+}
+function generateMsAppModule(entityName) {
+    const pascalName = kebabToPascal(entityName);
+    return `import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ${pascalName}Module } from './modules/${entityName}/${entityName}.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'mysql',
+      host: process.env.DB_HOST || 'localhost',
+      port: Number(process.env.DB_PORT) || 3306,
+      username: process.env.DB_USER || 'root',
+      password: process.env.DB_PASSWORD || 'root',
+      database: process.env.DB_NAME || 'devstroupe_${entityName}',
+      autoLoadEntities: true,
+      synchronize: false,
+    }),
+    ${pascalName}Module,
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}
+`;
+}
+function patchGatewayAppModule(appModulePath, entityName) {
+    const pascalName = kebabToPascal(entityName);
+    const moduleName = `${pascalName}GatewayModule`;
+    const importPath = `./modules/${entityName}/${entityName}.module`;
+    if (!fs.existsSync(appModulePath)) {
+        console.warn(`[Aviso] Arquivo ${appModulePath} não encontrado para aplicar patch.`);
+        return;
+    }
+    let content = fs.readFileSync(appModulePath, 'utf-8');
+    // Verifica se o import já existe
+    if (content.includes(moduleName)) {
+        return;
+    }
+    // Adiciona a declaração de import no topo
+    const importStatement = `import { ${moduleName} } from '${importPath}';\n`;
+    content = importStatement + content;
+    // Encontra a lista de imports do decorator @Module
+    // Encontra a lista de imports do decorator @Module
+    const moduleDecoratorRegex = /@Module\s*\(\s*\{\s*imports\s*:\s*\[([\s\S]*?)\]/;
+    const match = content.match(moduleDecoratorRegex);
+    if (match) {
+        const currentImports = match[1];
+        // Adiciona o novo módulo no início dos imports
+        const updatedImports = `\n    ${moduleName},${currentImports}`;
+        content = content.replace(currentImports, updatedImports);
+    }
+    fs.writeFileSync(appModulePath, content, 'utf-8');
+    console.log(`[Gateway] app.module.ts patcheado com sucesso para importar ${moduleName}.`);
+}
+function patchMonolithAppModule(appModulePath, entityName) {
+    const pascalName = kebabToPascal(entityName);
+    const moduleName = `${pascalName}Module`;
+    const importPath = `./modules/${entityName}/${entityName}.module`;
+    if (!fs.existsSync(appModulePath)) {
+        console.warn(`[Aviso] Arquivo ${appModulePath} não encontrado para aplicar patch.`);
+        return;
+    }
+    let content = fs.readFileSync(appModulePath, 'utf-8');
+    if (content.includes(`import { ${moduleName} }`))
+        return;
+    const lastImportIndex = content.lastIndexOf('import ');
+    const lastImportEnd = content.indexOf('\n', lastImportIndex);
+    const importStatement = `import { ${moduleName} } from '${importPath}';`;
+    content = `${content.slice(0, lastImportEnd + 1)}${importStatement}\n${content.slice(lastImportEnd + 1)}`;
+    const importsArrayStart = content.indexOf('imports: [');
+    if (importsArrayStart === -1) {
+        console.warn(`[Aviso] Lista imports do @Module não encontrada em ${appModulePath}.`);
+        return;
+    }
+    const insertionPoint = importsArrayStart + 'imports: ['.length;
+    content = `${content.slice(0, insertionPoint)}\n    ${moduleName},${content.slice(insertionPoint)}`;
+    fs.writeFileSync(appModulePath, content, 'utf-8');
+    console.log(`[NestJS] app.module.ts atualizado para importar ${moduleName}.`);
+}
+function generateDockerComposeAndDbInit(projectRoot, config) {
+    const isMicroservices = config.backendType === 'microservices';
+    const projectName = config.projectName || 'devstroupe-project';
+    // 1. db-init/init.sql
+    const dbInitDir = path.join(projectRoot, 'db-init');
+    fs.ensureDirSync(dbInitDir);
+    const dbs = ['devstroupe']; // Banco principal (usado pelo gateway ou monolith)
+    if (isMicroservices && config.entities) {
+        config.entities.forEach((entity) => {
+            dbs.push(`devstroupe_${entity.name.toLowerCase()}`);
+        });
+    }
+    const initSqlContent = dbs.map(db => `CREATE DATABASE IF NOT EXISTS \`${db}\`;`).join('\n') + '\n';
+    fs.writeFileSync(path.join(dbInitDir, 'init.sql'), initSqlContent, 'utf-8');
+    console.log(`[Docker] db-init/init.sql gerado com sucesso.`);
+    // 2. docker-compose.yml
+    let servicesYaml = '';
+    // Database service
+    servicesYaml += `  database:
+    image: mysql:8.0
+    container_name: ${projectName}-database
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+    ports:
+      - "33060:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+      - ./db-init:/docker-entrypoint-initdb.d
+`;
+    if (isMicroservices) {
+        // Gateway service
+        let gatewayEnv = `      DB_HOST: database
+      DB_PORT: 3306
+      DB_USER: root
+      DB_PASSWORD: root
+      DB_NAME: devstroupe
+      JWT_SECRET: devstroupe-secret-key-12345
+`;
+        let gatewayDependsOn = `      - database
+`;
+        // Adiciona variáveis de microsserviços no gateway
+        if (config.entities) {
+            config.entities.forEach((entity, index) => {
+                const port = 3001 + index;
+                const nameUpper = entity.name.toUpperCase();
+                gatewayEnv += `      ${nameUpper}_SERVICE_HOST: ${entity.name}-service
+      ${nameUpper}_SERVICE_PORT: ${port}
+`;
+                gatewayDependsOn += `      - ${entity.name}-service
+`;
+            });
+        }
+        servicesYaml += `\n  api-gateway:
+    build:
+      context: ./backend/api-gateway
+      dockerfile: Dockerfile
+    container_name: ${projectName}-api-gateway
+    restart: always
+    ports:
+      - "13000:13000"
+    environment:
+${gatewayEnv}    depends_on:
+${gatewayDependsOn}`;
+        // Containers de microsserviços
+        if (config.entities) {
+            config.entities.forEach((entity, index) => {
+                const port = 3001 + index;
+                servicesYaml += `\n\n  ${entity.name}-service:
+    build:
+      context: ./backend/services/${entity.name}
+      dockerfile: Dockerfile
+    container_name: ${projectName}-${entity.name}-service
+    restart: always
+    ports:
+      - "${port}0:${port}"
+    environment:
+      DB_HOST: database
+      DB_PORT: 3306
+      DB_USER: root
+      DB_PASSWORD: root
+      DB_NAME: devstroupe_${entity.name.toLowerCase()}
+      SERVICE_PORT: ${port}
+    depends_on:
+      - database
+`;
+            });
+        }
+        // Frontend service (depends on api-gateway)
+        servicesYaml += `\n\n  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    container_name: ${projectName}-frontend
+    restart: always
+    ports:
+      - "14200:80"
+    depends_on:
+      - api-gateway
+`;
+    }
+    else {
+        // Monolith services
+        servicesYaml += `\n  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: ${projectName}-backend
+    restart: always
+    ports:
+      - "13000:13000"
+    environment:
+      DB_HOST: database
+      DB_PORT: 3306
+      DB_USER: root
+      DB_PASSWORD: root
+      DB_NAME: devstroupe
+      JWT_SECRET: devstroupe-secret-key-12345
+    depends_on:
+      - database
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    container_name: ${projectName}-frontend
+    restart: always
+    ports:
+      - "14200:80"
+    depends_on:
+      - backend
+`;
+    }
+    const dockerComposeContent = `version: '3.8'
+
+services:
+${servicesYaml}
+volumes:
+  mysql_data:
+`;
+    fs.writeFileSync(path.join(projectRoot, 'docker-compose.yml'), dockerComposeContent, 'utf-8');
+    console.log(`[Docker] docker-compose.yml regerado com sucesso.`);
+}
+// Comando new-project
+program
+    .command('new-project <projectName>')
+    .description('Cria um novo projeto com frontend Angular e backend NestJS pré-configurados')
+    .option('--microservices', 'Cria o projeto utilizando arquitetura de microsserviços')
+    .action((projectName, options) => {
+    const projectRoot = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(projectRoot) && fs.readdirSync(projectRoot).length > 0) {
+        console.error(`[Erro] O diretório "${projectName}" já existe e não está vazio.`);
+        process.exit(1);
+    }
+    const isMicroservices = !!options.microservices;
+    console.log(`Criando novo projeto "${projectName}" (Modo: ${isMicroservices ? 'Microsserviços' : 'Monólito'}) em: ${projectRoot}...`);
+    // Resolver caminhos de boilerplates
+    let boilerplatesDir = path.resolve(__dirname, 'boilerplates');
+    if (!fs.existsSync(boilerplatesDir)) {
+        boilerplatesDir = path.resolve(__dirname, '../boilerplates');
+    }
+    if (!fs.existsSync(boilerplatesDir)) {
+        boilerplatesDir = path.resolve(__dirname, '../../boilerplates');
+    }
+    const nestTemplateDir = path.join(boilerplatesDir, 'nest-template');
+    const angularTemplateDir = path.join(boilerplatesDir, 'angular-template');
+    if (!fs.existsSync(nestTemplateDir) || !fs.existsSync(angularTemplateDir)) {
+        console.error(`[Erro] Não foi possível localizar os templates de boilerplate em: ${boilerplatesDir}`);
+        process.exit(1);
+    }
+    try {
+        // 1. Criar diretórios de destino
+        fs.ensureDirSync(projectRoot);
+        const frontendDest = path.join(projectRoot, 'frontend');
+        let backendDest;
+        if (isMicroservices) {
+            backendDest = path.join(projectRoot, 'backend', 'api-gateway');
+            fs.ensureDirSync(path.join(projectRoot, 'backend', 'services'));
+        }
+        else {
+            backendDest = path.join(projectRoot, 'backend');
+        }
+        // 2. Copiar boilerplates
+        console.log(`Copiando boilerplate do backend (${isMicroservices ? 'API Gateway' : 'NestJS Monólito'})...`);
+        fs.copySync(nestTemplateDir, backendDest, { filter: createBoilerplateCopyFilter(nestTemplateDir) });
+        console.log('Copiando boilerplate do frontend (Angular)...');
+        fs.copySync(angularTemplateDir, frontendDest, { filter: createBoilerplateCopyFilter(angularTemplateDir) });
+        // 2.1 Criar arquivos .env e .env.example no backend
+        console.log('Gerando arquivos .env e .env.example no backend...');
+        const envContent = `PORT=13000
+DB_HOST=localhost
+DB_PORT=3306
+DB_USER=root
+DB_PASSWORD=root
+DB_NAME=devstroupe
+`;
+        fs.writeFileSync(path.join(backendDest, '.env'), envContent, 'utf-8');
+        fs.writeFileSync(path.join(backendDest, '.env.example'), envContent, 'utf-8');
+        // Patch local dependencies if in monorepo development
+        patchLocalDependencies(backendDest, frontendDest, boilerplatesDir);
+        // 3. Criar devstroupe.config.ts
+        console.log('Gerando arquivo devstroupe.config.ts...');
+        const configPath = path.join(projectRoot, 'devstroupe.config.ts');
+        const designSystemConfig = {
+            provider: 'spartan',
+            spartanStyle: 'vega',
+            spartanTheme: 'neutral',
+            installAllPrimitives: true,
+            includePlayground: true,
+        };
+        const configContent = `export default {
+  projectName: '${projectName}',
+  backendType: '${isMicroservices ? 'microservices' : 'monolith'}',
+  backendPath: './backend',
+  frontendPath: './frontend',
+  designSystem: {
+    provider: '${designSystemConfig.provider}',
+    spartanStyle: '${designSystemConfig.spartanStyle}',
+    spartanTheme: '${designSystemConfig.spartanTheme}',
+    installAllPrimitives: ${designSystemConfig.installAllPrimitives},
+    includePlayground: ${designSystemConfig.includePlayground}
+  },
+  entities: [
+    {
+      name: 'company',
+      label: 'Empresa',
+      tableName: 'companies',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        {
+          name: 'cabins', type: 'relationship', required: false, label: 'Cabines',
+          relation: {
+            target: 'cabin', kind: 'one-to-many', foreignKey: 'company_id',
+            inverseSide: 'company', control: 'table', embedded: true,
+            columns: ['name', 'code', 'is_active'], lookup: { pageSize: 10 }
+          }
+        }
+      ],
+      crud: { generateFrontend: true, generateBackend: true }
+    },
+    {
+      name: 'cabin',
+      label: 'Cabine',
+      tableName: 'cabins',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        { name: 'code', type: 'string', required: false, label: 'Código' },
+        {
+          name: 'company_id', type: 'relationship', required: true, label: 'Empresa',
+          relation: {
+            target: 'company', kind: 'many-to-one', relationName: 'company',
+            inverseSide: 'cabins', control: 'select', displayField: 'name', onDelete: 'CASCADE',
+            lookup: { mode: 'remote', pageSize: 20, minSearchLength: 0 }
+          }
+        },
+        { name: 'is_active', type: 'boolean', required: true, label: 'Ativo', default: true }
+      ],
+      crud: {
+        generateFrontend: true,
+        generateBackend: true
+      }
+    }
+  ]
+};
+`;
+        fs.writeFileSync(configPath, configContent, 'utf-8');
+        // 3.1 Criar docker-compose.yml e init.sql
+        console.log('Gerando docker-compose.yml e base de dados...');
+        const tempConfig = {
+            projectName,
+            backendType: isMicroservices ? 'microservices' : 'monolith',
+            entities: [
+                {
+                    name: 'cabin',
+                    tableName: 'cabins',
+                }
+            ]
+        };
+        generateDockerComposeAndDbInit(projectRoot, tempConfig);
+        // 3.2 Criar Makefile na raiz
+        console.log('Gerando arquivo Makefile na raiz...');
+        const backendServiceName = isMicroservices ? 'api-gateway' : 'backend';
+        const makefileContent = `.PHONY: up down restart build logs ps clean backend-shell frontend-shell db-shell help
+
+DC = docker compose
+
+help:
+	@echo "Comandos disponíveis:"
+	@echo "  make up             Inicia os containers em background"
+	@echo "  make down           Para os containers e mantém os dados"
+	@echo "  make restart        Reinicia os containers"
+	@echo "  make build          Reconstrói as imagens Docker"
+	@echo "  make logs           Exibe os logs em tempo real"
+	@echo "  make ps             Exibe o status dos containers"
+	@echo "  make clean          Para os containers e apaga todos os volumes (reseta o banco)"
+	@echo "  make backend-shell  Abre o terminal sh do container do backend"
+	@echo "  make frontend-shell Abre o terminal sh do container do frontend"
+	@echo "  make db-shell       Abre o cliente mysql no container do banco"
+
+up:
+	\$(DC) up -d
+
+down:
+	\$(DC) down
+
+restart:
+	\$(DC) restart
+
+build:
+	\$(DC) build
+
+logs:
+	\$(DC) logs -f
+
+ps:
+	\$(DC) ps
+
+clean:
+	\$(DC) down -v
+
+backend-shell:
+	\$(DC) exec ${backendServiceName} sh
+
+frontend-shell:
+	\$(DC) exec frontend sh
+
+db-shell:
+	\$(DC) exec database mysql -u root -p
+
+# Evita que argumentos (ex: main, staging) sejam interpretados como target
+%:
+	@:
+`;
+        fs.writeFileSync(path.join(projectRoot, 'Makefile'), makefileContent, 'utf-8');
+        // 4. Instalar dependências automaticamente
+        try {
+            console.log(`Instalando dependências no backend (${isMicroservices ? 'API Gateway' : 'Monólito'})...`);
+            (0, child_process_1.execSync)('npm install', { cwd: backendDest, stdio: 'inherit' });
+        }
+        catch (err) {
+            console.warn('[Aviso] Falha ao rodar "npm install" no backend. Instale as dependências manualmente.');
+        }
+        try {
+            console.log('Instalando dependências no frontend...');
+            (0, child_process_1.execSync)('npm install --legacy-peer-deps', { cwd: frontendDest, stdio: 'inherit' });
+        }
+        catch (err) {
+            console.warn('[Aviso] Falha ao rodar "npm install" no frontend. Instale as dependências manualmente.');
+        }
+        // 5. Inicializar UI no frontend depois do install para disponibilizar @spartan-ng/cli
+        console.log('Inicializando componentes de UI locais...');
+        const generatedConfig = require(configPath).default ?? require(configPath);
+        initUi(frontendDest, generatedConfig);
+        console.log(`\n\x1b[32m[SUCESSO] Projeto "${projectName}" criado com sucesso!\x1b[0m`);
+        console.log(`Para começar:`);
+        console.log(`  1. Entre na pasta do projeto: cd ${projectName}`);
+        console.log(`  2. Desenvolva sua aplicação com o DT-DevKit!`);
+    }
+    catch (err) {
+        console.error('[Erro] Falha ao criar o novo projeto:', err);
+        process.exit(1);
+    }
+});
+// Comando add-ui
+program
+    .command('add-ui <componentName>')
+    .description('Gera um componente ou diretiva de UI local (Spartan ou Customizado DevKit) no frontend')
+    .action((componentName) => {
+    const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath)) {
+        console.error('Arquivo devstroupe.config.ts não encontrado na raiz. Rode "devstroupe init" primeiro.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        const importedConfig = require(configPath);
+        config = importedConfig.default || importedConfig;
+    }
+    catch (error) {
+        console.error('Erro ao carregar devstroupe.config.ts:', error);
+        process.exit(1);
+    }
+    const frontendRoot = path.resolve(process.cwd(), config.frontendPath || './frontend');
+    if (!fs.existsSync(frontendRoot)) {
+        console.error(`Diretório frontend não encontrado em: ${frontendRoot}.`);
+        process.exit(1);
+    }
+    const targetDir = path.join(frontendRoot, 'src', 'app', 'shared', 'components', 'devkit');
+    fs.ensureDirSync(targetDir);
+    const compNameLower = componentName.toLowerCase();
+    const pascalName = kebabToPascal(componentName);
+    // Mapear e autoinstalar dependências do Spartan Brain correspondentes
+    const spartanDeps = {
+        dialog: '@spartan-ng/brain',
+        sheet: '@spartan-ng/brain',
+        tabs: '@spartan-ng/brain',
+        accordion: '@spartan-ng/brain',
+        'alert-dialog': '@spartan-ng/brain',
+        menu: '@spartan-ng/brain',
+        'dropdown-menu': '@spartan-ng/brain'
+    };
+    const depToInstall = spartanDeps[compNameLower];
+    if (depToInstall) {
+        const pkgJsonPath = path.join(frontendRoot, 'package.json');
+        if (fs.existsSync(pkgJsonPath)) {
+            const pkgJson = fs.readJsonSync(pkgJsonPath);
+            const hasDep = (pkgJson.dependencies && pkgJson.dependencies[depToInstall]) ||
+                (pkgJson.devDependencies && pkgJson.devDependencies[depToInstall]);
+            if (!hasDep) {
+                console.log(`[Dep] Instalando dependência necessária do Spartan: ${depToInstall}...`);
+                const workspaceRoot = process.cwd();
+                const isPnpm = fs.existsSync(path.join(workspaceRoot, 'pnpm-lock.yaml'));
+                try {
+                    const { execSync } = require('child_process');
+                    if (isPnpm) {
+                        execSync(`pnpm --dir "${frontendRoot}" add ${depToInstall}`, { stdio: 'inherit' });
+                    }
+                    else {
+                        execSync(`npm --prefix "${frontendRoot}" install ${depToInstall} --legacy-peer-deps`, { stdio: 'inherit' });
+                    }
+                    console.log(`[Dep] ${depToInstall} instalado com sucesso!`);
+                }
+                catch (err) {
+                    console.warn(`[Aviso] Falha ao instalar automaticamente ${depToInstall}. Por favor, instale manualmente.`);
+                }
+            }
+        }
+    }
+    if (compNameLower === 'badge') {
+        const badgeDir = path.join(targetDir, 'ui-badge-helm');
+        fs.ensureDirSync(badgeDir);
+        const bdg = (0, ui_templates_1.devkitBadgeTemplate)();
+        fs.writeFileSync(path.join(badgeDir, 'badge.component.ts'), bdg.ts, 'utf-8');
+        console.log(`[UI] Componente devkit-badge injetado em: ${badgeDir}. O hlmBadge real vem de @spartan-ng/helm/badge.`);
+    }
+    else if (compNameLower === 'avatar') {
+        const avatarDir = path.join(targetDir, 'ui-avatar-helm');
+        fs.ensureDirSync(avatarDir);
+        const avt = (0, ui_templates_1.devkitAvatarTemplate)();
+        fs.writeFileSync(path.join(avatarDir, 'avatar.component.ts'), avt.ts, 'utf-8');
+        console.log(`[UI] Componente devkit-avatar injetado em: ${avatarDir}`);
+    }
+    else if (['dialog', 'sheet', 'tabs', 'accordion', 'alert-dialog', 'menu', 'dropdown-menu'].includes(compNameLower)) {
+        const primitiveName = compNameLower === 'menu' ? 'dropdown-menu' : compNameLower;
+        const style = getCurrentSpartanStyle(frontendRoot, config);
+        runSpartanPrimitiveGenerator(frontendRoot, style, primitiveName);
+        console.log(`[UI] Primitive Spartan real disponível via import "@spartan-ng/helm/${primitiveName}". Nenhum wrapper fake foi gerado.`);
+    }
+    else {
+        // Componente customizado livre!
+        const customDir = path.join(targetDir, componentName);
+        fs.ensureDirSync(customDir);
+        const tsContent = `import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@Component({
+  selector: 'devkit-${componentName}',
+  standalone: true,
+  imports: [CommonModule],
+  templateUrl: './${componentName}.component.html',
+  styleUrls: ['./${componentName}.component.css']
+})
+export class Devkit${pascalName}Component {}
+`;
+        const htmlContent = `<div class="p-4 border border-dashed border-border rounded-lg bg-card text-card-foreground">
+  <p class="text-sm font-medium">Componente Customizado: devkit-${componentName}</p>
+</div>
+`;
+        const cssContent = `:host {
+  display: block;
+}
+`;
+        fs.writeFileSync(path.join(customDir, `${componentName}.component.ts`), tsContent, 'utf-8');
+        fs.writeFileSync(path.join(customDir, `${componentName}.component.html`), htmlContent, 'utf-8');
+        fs.writeFileSync(path.join(customDir, `${componentName}.component.css`), cssContent, 'utf-8');
+        console.log(`[UI] Componente customizado do DevKit "devkit-${componentName}" criado com sucesso em: ${customDir}`);
+    }
+});
+program.parse(process.argv);