eva4j 1.0.14 → 1.0.16

package/src/commands/create.js

@@ -76,6 +76,7 @@ async function createCommand(projectName, options) {
     console.log(chalk.gray(`    ├── src/main/java/${context.packagePath.replace(/\//g, '.')}`));
     console.log(chalk.gray(`    │   ├── ${context.applicationClassName}.java`));
     console.log(chalk.gray(`    │   └── common/`));
+    console.log(chalk.gray(`    ├── system/`));
     console.log(chalk.gray(`    ├── build.gradle`));
     console.log(chalk.gray(`    └── README.md`));
     

package/src/commands/detach.js

@@ -191,6 +191,7 @@ async function detachCommand(moduleName, options) {
       createdDate: new Date().toISOString().split('T')[0],
       dependencyManagementVersion: defaults.dependencyManagementVersion,
       springCloudVersion: projectConfig.springCloudVersion || defaults.springCloudVersion,
+      springdocVersion: projectConfig.springdocVersion || defaults.springdocVersion,
       gradleVersion: defaults.gradleVersion,
       license: 'MIT',
       description: `Detached microservice: ${newProjectName}`,
@@ -228,15 +229,20 @@ async function detachCommand(moduleName, options) {
     // Step 3: Generate base project using BaseGenerator
     await generateDetachedProject(newProjectDir, detachedContext);
     
+    spinner.text = 'Copying Gradle wrapper...';
+    
+    // Step 4: Copy Gradle wrapper from parent project
+    await copyGradleWrapper(projectDir, newProjectDir);
+    
     spinner.text = 'Copying module files...';
     
-    // Step 4: Copy module directory
+    // Step 5: Copy module directory
     const newModuleDir = path.join(newProjectDir, 'src', 'main', 'java', packagePath, moduleName);
     await fs.copy(moduleDir, newModuleDir);
     
     spinner.text = 'Merging shared components...';
     
-    // Step 5: Merge shared/domain into module/domain
+    // Step 6: Merge shared/domain into module/domain (filtering modulith-only components)
     await mergeSharedComponents(
       sharedDir,
       newModuleDir,
@@ -246,7 +252,7 @@ async function detachCommand(moduleName, options) {
     
     spinner.text = 'Updating package references...';
     
-    // Step 6: Update all imports in module files
+    // Step 7: Update all imports in module files
     await updatePackageReferences(
       newModuleDir,
       packageName,
@@ -255,10 +261,10 @@ async function detachCommand(moduleName, options) {
     
     spinner.text = 'Cleaning up...';
     
-    // Step 7: Remove package-info.java files
+    // Step 8: Remove package-info.java files
     await removePackageInfoFiles(newModuleDir);
     
-    // Step 8: Copy test files if they exist
+    // Step 9: Copy test files if they exist
     const testModuleDir = path.join(projectDir, 'src', 'test', 'java', packagePath, moduleName);
     if (await fs.pathExists(testModuleDir)) {
       const newTestModuleDir = path.join(newProjectDir, 'src', 'test', 'java', packagePath, moduleName);
@@ -266,7 +272,7 @@ async function detachCommand(moduleName, options) {
       await updatePackageReferences(newTestModuleDir, packageName, moduleName);
     }
     
-    // Step 9: Create detached project configuration
+    // Step 10: Create detached project configuration
     const detachedConfigManager = new ConfigManager(newProjectDir);
     await detachedConfigManager.saveProjectConfig({
       ...detachedContext,
@@ -280,8 +286,11 @@ async function detachCommand(moduleName, options) {
     
     spinner.text = 'Copying environment configurations...';
     
-    // Step 10: Copy environment profile files from parent resources
-    await copyEnvironmentProfiles(projectDir, newProjectDir, packageName, moduleName);
+    // Step 11: Copy parameter files from parent (kafka.yaml, urls.yaml, etc.)
+    await copyParameterFiles(projectDir, newProjectDir, packageName, moduleName);
+    
+    // Step 12: Copy domain.yaml specification if it exists
+    await copyDomainYaml(projectDir, newProjectDir, moduleName);
     
     spinner.succeed(chalk.green('✅ Module detached successfully! ✨'));
     
@@ -372,74 +381,43 @@ function transformSharedFileContent(content, packageName, moduleName) {
 }
 
 /**
- * Merge shared components into module structure
+ * Directories that are specific to Spring Modulith (modular monolith)
+ * and should NOT be copied when detaching to a standalone microservice.
+ */
+const MODULITH_ONLY_DIRS = new Set([
+  'eventPublicationConfig',  // Spring Modulith event_publication table
+  'mockEvent',               // In-memory event surrogate for mock mode
+]);
+
+/**
+ * Files specific to Spring Modulith that should be skipped during merge.
+ */
+const MODULITH_ONLY_FILES = new Set([
+  'package-info.java',  // Contains @ApplicationModule(type = OPEN)
+]);
+
+/**
+ * Merge shared components into module structure, filtering out modulith-only components.
  */
 async function mergeSharedComponents(sharedDir, moduleDir, packageName, moduleName) {
-  // Merge shared/domain/* into module/domain/
-  const sharedDomainDir = path.join(sharedDir, 'domain');
-  if (await fs.pathExists(sharedDomainDir)) {
-    const domainEntries = await fs.readdir(sharedDomainDir);
-    for (const entry of domainEntries) {
-      const sourcePath = path.join(sharedDomainDir, entry);
-      const stat = await fs.stat(sourcePath);
-      
-      if (stat.isDirectory()) {
-        // Copy and transform subdirectories (annotations, interfaces, customExceptions, etc.)
-        const destPath = path.join(moduleDir, 'domain', entry);
-        await copyAndTransformDirectory(sourcePath, destPath, packageName, moduleName);
-      } else if (stat.isFile() && entry.endsWith('.java')) {
-        // Copy and transform individual .java files (AuditableEntity.java, etc.)
-        const destPath = path.join(moduleDir, 'domain', entry);
-        if (!(await fs.pathExists(destPath))) {
-          const content = await fs.readFile(sourcePath, 'utf-8');
-          const transformed = transformSharedFileContent(content, packageName, moduleName);
-          await fs.ensureDir(path.dirname(destPath));
-          await fs.writeFile(destPath, transformed, 'utf-8');
-        }
-      }
-    }
-  }
-  
-  // Merge shared/infrastructure/* into module/infrastructure/
-  const sharedInfraDir = path.join(sharedDir, 'infrastructure');
-  if (await fs.pathExists(sharedInfraDir)) {
-    const infraEntries = await fs.readdir(sharedInfraDir);
-    for (const entry of infraEntries) {
-      const sourcePath = path.join(sharedInfraDir, entry);
-      const stat = await fs.stat(sourcePath);
-      
-      if (stat.isDirectory()) {
-        // Copy and transform subdirectories
-        const destPath = path.join(moduleDir, 'infrastructure', entry);
-        await copyAndTransformDirectory(sourcePath, destPath, packageName, moduleName);
-      } else if (stat.isFile() && entry.endsWith('.java')) {
-        // Copy and transform individual .java files
-        const destPath = path.join(moduleDir, 'infrastructure', entry);
-        if (!(await fs.pathExists(destPath))) {
-          const content = await fs.readFile(sourcePath, 'utf-8');
-          const transformed = transformSharedFileContent(content, packageName, moduleName);
-          await fs.ensureDir(path.dirname(destPath));
-          await fs.writeFile(destPath, transformed, 'utf-8');
-        }
-      }
-    }
-  }
-  
-  // Merge shared/application/* into module/application/
-  const sharedApplicationDir = path.join(sharedDir, 'application');
-  if (await fs.pathExists(sharedApplicationDir)) {
-    const applicationEntries = await fs.readdir(sharedApplicationDir);
-    for (const entry of applicationEntries) {
-      const sourcePath = path.join(sharedApplicationDir, entry);
+  const layers = ['domain', 'infrastructure', 'application'];
+
+  for (const layer of layers) {
+    const sharedLayerDir = path.join(sharedDir, layer);
+    if (!(await fs.pathExists(sharedLayerDir))) continue;
+
+    const entries = await fs.readdir(sharedLayerDir);
+    for (const entry of entries) {
+      const sourcePath = path.join(sharedLayerDir, entry);
       const stat = await fs.stat(sourcePath);
-      
+
       if (stat.isDirectory()) {
-        // Copy and transform subdirectories (dtos, events)
-        const destPath = path.join(moduleDir, 'application', entry);
+        if (MODULITH_ONLY_DIRS.has(entry)) continue;
+        const destPath = path.join(moduleDir, layer, entry);
         await copyAndTransformDirectory(sourcePath, destPath, packageName, moduleName);
       } else if (stat.isFile() && entry.endsWith('.java')) {
-        // Copy and transform individual .java files
-        const destPath = path.join(moduleDir, 'application', entry);
+        if (MODULITH_ONLY_FILES.has(entry)) continue;
+        const destPath = path.join(moduleDir, layer, entry);
         if (!(await fs.pathExists(destPath))) {
           const content = await fs.readFile(sourcePath, 'utf-8');
           const transformed = transformSharedFileContent(content, packageName, moduleName);
@@ -605,55 +583,118 @@ async function findPackageInfoFiles(dir) {
 }
 
 /**
- * Copy environment profile files from parent to detached project
+ * Copy Gradle wrapper files from parent project to detached project.
+ * Includes gradlew, gradlew.bat, and gradle/wrapper/ directory.
  */
-async function copyEnvironmentProfiles(parentDir, newProjectDir, packageName, moduleName) {
-  const parentResourcesDir = path.join(parentDir, 'src', 'main', 'resources');
-  const newResourcesDir = path.join(newProjectDir, 'src', 'main', 'resources');
-  
-  // Copy environment profile files
-  const profileFiles = [
-    'application-develop.yaml',
-    'application-local.yaml',
-    'application-production.yaml',
-    'application-test.yaml'
-  ];
-  
-  for (const file of profileFiles) {
-    const sourcePath = path.join(parentResourcesDir, file);
-    if (await fs.pathExists(sourcePath)) {
-      await fs.copy(sourcePath, path.join(newResourcesDir, file));
+async function copyGradleWrapper(parentDir, newProjectDir) {
+  const wrapperFiles = ['gradlew', 'gradlew.bat'];
+  for (const file of wrapperFiles) {
+    const src = path.join(parentDir, file);
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(newProjectDir, file));
     }
   }
-  
-  // Copy parameters folder if it exists
-  const parametersDir = path.join(parentResourcesDir, 'parameters');
-  if (await fs.pathExists(parametersDir)) {
-    await fs.copy(parametersDir, path.join(newResourcesDir, 'parameters'));
-    
-    // Update package references in kafka.yaml files
-    await updateKafkaConfigReferences(newResourcesDir, packageName, moduleName);
+
+  const wrapperDir = path.join(parentDir, 'gradle', 'wrapper');
+  if (await fs.pathExists(wrapperDir)) {
+    await fs.copy(wrapperDir, path.join(newProjectDir, 'gradle', 'wrapper'));
   }
 }
 
 /**
- * Update package references in kafka.yaml files
+ * Copy parameter files (kafka.yaml, urls.yaml, etc.) from parent to detached project.
+ * Updates package references from shared to module name.
+ * Adds missing imports to application-{env}.yaml files.
  */
-async function updateKafkaConfigReferences(resourcesDir, packageName, moduleName) {
+async function copyParameterFiles(parentDir, newProjectDir, packageName, moduleName) {
+  const parentParametersDir = path.join(parentDir, 'src', 'main', 'resources', 'parameters');
+  const newParametersDir = path.join(newProjectDir, 'src', 'main', 'resources', 'parameters');
+
+  if (!(await fs.pathExists(parentParametersDir))) return;
+
+  await fs.copy(parentParametersDir, newParametersDir);
+
+  // Update package references in yaml config files (kafka.yaml, urls.yaml, etc.)
   const environments = ['local', 'develop', 'test', 'production'];
-  
+  const sharedPattern = new RegExp(
+    `${packageName.replace(/\./g, '\\.')}\\.shared\\.infrastructure\\.`,
+    'g'
+  );
+
+  // Base config files that BaseGenerator already imports (db.yaml, cors.yaml)
+  const baseImports = new Set(['db.yaml', 'cors.yaml']);
+
   for (const env of environments) {
-    const kafkaYmlPath = path.join(resourcesDir, 'parameters', env, 'kafka.yaml');
-    
-    if (await fs.pathExists(kafkaYmlPath)) {
-      let content = await fs.readFile(kafkaYmlPath, 'utf-8');
-      
-      // Replace .shared.infrastructure. with .{moduleName}.infrastructure.
-      const pattern = new RegExp(`${packageName}\\.shared\\.infrastructure\\.`, 'g');
-      content = content.replace(pattern, `${packageName}.${moduleName}.infrastructure.`);
-      
-      await fs.writeFile(kafkaYmlPath, content, 'utf-8');
+    const envDir = path.join(newParametersDir, env);
+    if (!(await fs.pathExists(envDir))) continue;
+
+    const files = await fs.readdir(envDir);
+    const extraImports = [];
+
+    for (const file of files) {
+      if (!file.endsWith('.yaml') && !file.endsWith('.yml')) continue;
+
+      // Update package references
+      const filePath = path.join(envDir, file);
+      let content = await fs.readFile(filePath, 'utf-8');
+      if (sharedPattern.test(content)) {
+        content = content.replace(sharedPattern, `${packageName}.${moduleName}.infrastructure.`);
+        await fs.writeFile(filePath, content, 'utf-8');
+      }
+      sharedPattern.lastIndex = 0;
+
+      // Collect extra parameter files that need imports
+      if (!baseImports.has(file)) {
+        extraImports.push(`classpath:parameters/${env}/${file}`);
+      }
     }
+
+    // Add missing imports to application-{env}.yaml
+    if (extraImports.length > 0) {
+      await addMissingImports(newProjectDir, env, extraImports);
+    }
+  }
+}
+
+/**
+ * Add missing classpath imports to an application-{env}.yaml file.
+ */
+async function addMissingImports(projectDir, env, imports) {
+  const appYmlPath = path.join(projectDir, 'src', 'main', 'resources', `application-${env}.yaml`);
+  if (!(await fs.pathExists(appYmlPath))) return;
+
+  let content = await fs.readFile(appYmlPath, 'utf-8');
+
+  const linesToAdd = imports.filter(imp => !content.includes(imp));
+  if (linesToAdd.length === 0) return;
+
+  // Append after existing import entries
+  const importPattern = /(spring:\s*\n\s*config:\s*\n\s*import:\s*\n(?:\s*-\s*"[^"]+"\s*\n)*)/;
+  if (importPattern.test(content)) {
+    const suffix = linesToAdd.map(imp => `      - "${imp}"`).join('\n') + '\n';
+    content = content.replace(importPattern, `$1${suffix}`);
+  }
+
+  await fs.writeFile(appYmlPath, content, 'utf-8');
+}
+
+/**
+ * Copy domain.yaml specification for the module if it exists.
+ * Looks in system/{moduleName}.yaml and domain.yaml at project root.
+ */
+async function copyDomainYaml(parentDir, newProjectDir, moduleName) {
+  // Try system/{moduleName}.yaml first (multi-module system layout)
+  const systemYaml = path.join(parentDir, 'system', `${moduleName}.yaml`);
+  if (await fs.pathExists(systemYaml)) {
+    await fs.ensureDir(path.join(newProjectDir, 'system'));
+    await fs.copy(systemYaml, path.join(newProjectDir, 'system', `${moduleName}.yaml`));
+    return;
+  }
+
+  // Fallback: domain.yaml at project root (single-module layout)
+  const domainYaml = path.join(parentDir, 'domain.yaml');
+  if (await fs.pathExists(domainYaml)) {
+    await fs.copy(domainYaml, path.join(newProjectDir, 'domain.yaml'));
   }
 }
 

package/src/commands/evaluate-system.js

@@ -9,6 +9,7 @@ const ejs = require('ejs');
 const ora = require('ora');
 
 const { validateSystem } = require('../utils/system-validator');
+const { validateDomain } = require('../utils/domain-validator');
 
 // ── Module icon heuristic ────────────────────────────────────────────────────
 
@@ -208,7 +209,7 @@ function buildEventFlows(systemConfig, modulesMap) {
 
 // ── Data extraction ──────────────────────────────────────────────────────────
 
-function extractReportData(systemConfig, validation) {
+function extractReportData(systemConfig, validation, domainValidation) {
   const modulesConfig = systemConfig.modules || [];
   const asyncEvents = (systemConfig.integrations || {}).async || [];
   const syncIntegrations = (systemConfig.integrations || {}).sync || [];
@@ -259,6 +260,7 @@ function extractReportData(systemConfig, validation) {
     endpoints,
     flows,
     validation,
+    domainValidation,
     generatedAt: new Date().toISOString(),
   };
 }
@@ -277,10 +279,11 @@ async function evaluateSystemCommand(type, options = {}) {
   const outputPath = path.resolve(process.cwd(), options.output || './system-report.html');
 
   // ── 1. Read system.yaml ─────────────────────────────────────────────────
-  const systemYamlPath = path.join(process.cwd(), 'system.yaml');
+  const systemYamlPath = path.join(process.cwd(), 'system', 'system.yaml');
   if (!(await fs.pathExists(systemYamlPath))) {
-    console.error(chalk.red('❌ system.yaml not found in current directory'));
+    console.error(chalk.red('❌ system/system.yaml not found'));
     console.error(chalk.gray('Run this command from the root of an eva4j project'));
+    console.error(chalk.gray('Expected location: system/system.yaml'));
     process.exit(1);
   }
 
@@ -289,17 +292,48 @@ async function evaluateSystemCommand(type, options = {}) {
     const content = await fs.readFile(systemYamlPath, 'utf-8');
     systemConfig = yaml.load(content);
   } catch (err) {
-    console.error(chalk.red('❌ Failed to parse system.yaml:'), err.message);
+    console.error(chalk.red('❌ Failed to parse system/system.yaml:'), err.message);
     process.exit(1);
   }
 
-  const spinner = ora('Analyzing system.yaml...').start();
+  const spinner = ora('Analyzing system/system.yaml...').start();
 
-  // ── 2. Run validation ───────────────────────────────────────────────────
-  const validation = validateSystem(systemConfig);
+  // ── 2a. Load domain YAMLs (needed by both system and domain validation) ──
+  const domainConfigs = {};
+  let domainValidation = null;
+  const systemDir = path.join(process.cwd(), 'system');
+  let allFiles;
+  try {
+    allFiles = await fs.readdir(systemDir);
+  } catch {
+    allFiles = [];
+  }
+  const domainFiles = allFiles.filter((f) => f.endsWith('.yaml') && f !== 'system.yaml');
+
+  if (domainFiles.length === 0) {
+    console.warn(chalk.yellow('⚠  No domain YAML files found in system/ (excluding system.yaml). Domain tab will be hidden.'));
+  } else {
+    for (const file of domainFiles) {
+      const moduleName = path.basename(file, '.yaml');
+      try {
+        const content = await fs.readFile(path.join(systemDir, file), 'utf-8');
+        domainConfigs[moduleName] = yaml.load(content) || {};
+      } catch (err) {
+        console.warn(chalk.yellow(`⚠  Could not parse ${file}: ${err.message}`));
+      }
+    }
+  }
+
+  // ── 2b. Run system validation (receives domainConfigs to cross-check) ───
+  const validation = validateSystem(systemConfig, domainConfigs);
+
+  // ── 2c. Run domain validation ───────────────────────────────────────────
+  if (Object.keys(domainConfigs).length > 0) {
+    domainValidation = validateDomain(domainConfigs, systemConfig);
+  }
 
   // ── 3. Extract report data ──────────────────────────────────────────────
-  const reportData = extractReportData(systemConfig, validation);
+  const reportData = extractReportData(systemConfig, validation, domainValidation);
 
   // ── 4. Render HTML ──────────────────────────────────────────────────────
   const templatePath = path.join(__dirname, '../../templates/evaluate/report.html.ejs');
@@ -317,6 +351,16 @@ async function evaluateSystemCommand(type, options = {}) {
   await fs.ensureDir(path.dirname(outputPath));
   await fs.writeFile(outputPath, htmlContent, 'utf-8');
 
+  // ── 5b. Write domain assets ───────────────────────────────────────────────
+  if (domainValidation) {
+    await writeDomainAssets(domainValidation, process.cwd());
+  }
+
+  // ── 5c. Write system-evaluation.md ──────────────────────────────────────
+  const evalMdPath = path.resolve(process.cwd(), 'assets', 'system-evaluation.md');
+  await fs.ensureDir(path.dirname(evalMdPath));
+  await writeSystemEvaluation(validation, systemConfig, evalMdPath);
+
   spinner.succeed(chalk.green('Analysis complete!'));
 
   // ── 6. Print validation summary ─────────────────────────────────────────
@@ -329,6 +373,9 @@ async function evaluateSystemCommand(type, options = {}) {
   console.log(
     `  ${chalk.yellow('🟡 Warnings:')}   ${chalk.yellow.bold(validation.warnings.length)}`
   );
+  console.log(
+    `  ${chalk.cyan('🔵 Info:')}       ${chalk.cyan.bold((validation.info || []).length)}`
+  );
   console.log(
     `  ${chalk.green('🟢 Passed:')}     ${chalk.green.bold(validation.ok.length)}`
   );
@@ -349,6 +396,24 @@ async function evaluateSystemCommand(type, options = {}) {
     console.log();
   }
 
+  if ((validation.info || []).length > 0) {
+    console.log(chalk.cyan('Info:'));
+    validation.info.forEach((i) => console.log(chalk.cyan(`  • ${i}`)));
+    console.log();
+  }
+
+  // ── 6b. Print domain validation summary ────────────────────────────────
+  if (domainValidation) {
+    const ds = domainValidation.summary;
+    console.log(chalk.bold('🏛️  Domain Validation Summary'));
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log(`  ${chalk.red('🔴 Errors:')}     ${chalk.red.bold(ds.errors)}`);
+    console.log(`  ${chalk.yellow('🟡 Warnings:')}   ${chalk.yellow.bold(ds.warnings)}`);
+    console.log(`  ${chalk.blue('🔵 Info:')}       ${chalk.blue.bold(ds.info)}`);
+    console.log(`  ${chalk.green('🟢 OK:')}         ${chalk.green.bold(ds.ok)}`);
+    console.log();
+  }
+
   // ── 7. Start HTTP server ─────────────────────────────────────────────────
   const server = http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -357,6 +422,7 @@ async function evaluateSystemCommand(type, options = {}) {
 
   server.listen(port, () => {
     console.log(chalk.gray(`Report written to: ${outputPath}`));
+    console.log(chalk.gray(`Evaluation written to: assets/system-evaluation.md`));
     console.log();
     console.log(chalk.bold.green(`🌐 Server running at: http://localhost:${port}`));
     console.log(chalk.gray('Open the URL in your browser to view the report'));
@@ -375,10 +441,170 @@ async function evaluateSystemCommand(type, options = {}) {
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+async function writeSystemEvaluation(validation, systemConfig, filePath) {
+  const systemName = (systemConfig.system || {}).name || 'eva4j system';
+  const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+  const scoreLabel = validation.score > 80 ? '🟢 Bueno' : validation.score > 60 ? '🟡 Aceptable' : '🔴 Crítico';
+
+  const lines = [];
+
+  lines.push(`# Evaluación del sistema — ${systemName}`);
+  lines.push('');
+  lines.push(`> Generado: ${now}  `);
+  lines.push(`> Score de calidad: **${validation.score}%** ${scoreLabel}  `);
+  lines.push(`> 🔴 Errores: ${validation.errors.length} | 🟡 Advertencias: ${validation.warnings.length}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  if (validation.errors.length > 0) {
+    lines.push('## 🔴 Errores críticos');
+    lines.push('');
+    for (const e of validation.errors) {
+      lines.push(`- ${e}`);
+    }
+    lines.push('');
+  }
+
+  if (validation.warnings.length > 0) {
+    lines.push('## 🟡 Advertencias');
+    lines.push('');
+    for (const w of validation.warnings) {
+      lines.push(`- ${w}`);
+    }
+    lines.push('');
+  }
+
+  if (validation.errors.length === 0 && validation.warnings.length === 0) {
+    lines.push('## ✅ Sin errores ni advertencias');
+    lines.push('');
+    lines.push('El sistema supera todas las validaciones de errores y advertencias.');
+    lines.push('');
+  }
+
+  await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+}
+
 function toPascalCase(str) {
   return str
     .replace(/[-_ ]+(.)/g, (_, c) => c.toUpperCase())
     .replace(/^(.)/, (c) => c.toUpperCase());
 }
 
+// ── writeDomainAssets ─────────────────────────────────────────────────────────
+async function writeDomainAssets(domainValidation, cwd) {
+  const assetsDir = path.join(cwd, 'assets', 'evaluation');
+  await fs.ensureDir(assetsDir);
+
+  const { categories, diagrams, summary } = domainValidation;
+  const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+
+  // ── 1. Write per-module .mmd files ──────────────────────────────────────
+  if (diagrams) {
+    for (const [moduleName, diagramText] of Object.entries(diagrams)) {
+      if (diagramText) {
+        await fs.writeFile(path.join(assetsDir, `${moduleName}.mmd`), diagramText, 'utf-8');
+      }
+    }
+  }
+
+  // ── 2. Build evaluation.md ──────────────────────────────────────────────
+
+  // Collect all findings grouped by module
+  const byModule = {};
+  for (const cat of categories) {
+    for (const check of cat.checks) {
+      for (const finding of check.findings) {
+        const mod = finding.module || '(sin módulo)';
+        if (!byModule[mod]) byModule[mod] = [];
+        byModule[mod].push({
+          category: `${cat.id} – ${cat.label}`,
+          checkId: check.id,
+          checkLabel: check.label,
+          severity: check.severity,
+          message: finding.message,
+          context: finding.context || '',
+        });
+      }
+    }
+  }
+
+  const SEV_EMOJI = { error: '🔴', warning: '🟡', info: '🔵', ok: '🟢' };
+
+  const lines = [];
+  lines.push(`# Domain Evaluation Report`);
+  lines.push(`> Generated: ${now}`);
+  lines.push('');
+
+  // Summary table
+  lines.push(`## Summary`);
+  lines.push('');
+  lines.push(`| 🔴 Errors | 🟡 Warnings | 🔵 Info | 🟢 OK |`);
+  lines.push(`|-----------|-------------|---------|-------|`);
+  lines.push(`| ${summary.errors} | ${summary.warnings} | ${summary.info} | ${summary.ok} |`);
+  lines.push('');
+
+  const moduleNames = Object.keys(byModule).sort();
+
+  if (moduleNames.length === 0) {
+    lines.push('_No findings detected across all modules._');
+  } else {
+    lines.push(`## Findings by Module`);
+    lines.push('');
+
+    for (const moduleName of moduleNames) {
+      const findings = byModule[moduleName];
+      const errorCount   = findings.filter(f => f.severity === 'error').length;
+      const warningCount = findings.filter(f => f.severity === 'warning').length;
+      const infoCount    = findings.filter(f => f.severity === 'info').length;
+
+      const badges = [
+        errorCount   ? `🔴 ${errorCount} error${errorCount   !== 1 ? 's' : ''}` : null,
+        warningCount ? `🟡 ${warningCount} warning${warningCount !== 1 ? 's' : ''}` : null,
+        infoCount    ? `🔵 ${infoCount} info` : null,
+      ].filter(Boolean).join(' · ');
+
+      lines.push(`### \`${moduleName}\`${badges ? `  <sub>${badges}</sub>` : ''}`);
+      lines.push('');
+
+      if (diagrams && diagrams[moduleName]) {
+        lines.push(`> 📊 Diagram: [${moduleName}.mmd](./${moduleName}.mmd)`);
+        lines.push('');
+      }
+
+      lines.push(`| Severity | Check | Message | Context |`);
+      lines.push(`|----------|-------|---------|---------|`);
+
+      for (const f of findings) {
+        const sev = `${SEV_EMOJI[f.severity] || ''} ${f.severity}`;
+        const checkCell = `**${f.checkId}** ${f.checkLabel}`;
+        const msg = f.message.replace(/\|/g, '\\|');
+        const ctx = f.context.replace(/\|/g, '\\|');
+        lines.push(`| ${sev} | ${checkCell} | ${msg} | ${ctx} |`);
+      }
+      lines.push('');
+    }
+  }
+
+  // Modules with diagrams but no findings
+  if (diagrams) {
+    const cleanModules = Object.keys(diagrams)
+      .filter(m => diagrams[m] && !byModule[m])
+      .sort();
+    if (cleanModules.length > 0) {
+      lines.push(`## Clean Modules (no findings)`);
+      lines.push('');
+      for (const m of cleanModules) {
+        lines.push(`- \`${m}\` — 🟢 no findings · [${m}.mmd](./${m}.mmd)`);
+      }
+      lines.push('');
+    }
+  }
+
+  await fs.writeFile(path.join(assetsDir, 'evaluation.md'), lines.join('\n'), 'utf-8');
+
+  const mmdFiles = diagrams ? Object.keys(diagrams).filter(m => diagrams[m]) : [];
+  console.log(chalk.gray(`  Domain assets → assets/evaluation/  (evaluation.md + ${mmdFiles.length} .mmd files)`));
+}
+
 module.exports = evaluateSystemCommand;