codarch 0.1.4 → 0.2.0

package/index.js

@@ -2095,8 +2095,8 @@ var MIGRATION_EXTENSIONS = Object.keys(EXTENSION_LANGUAGE);
 var LANGUAGE_ORDER = ["ts", "js", "rust", "wasm", "node"];
 var RUST_BRIDGE = /#\[\s*(?:napi|wasm_bindgen)(?:\(|\])|\bnapi_derive\b|\bnapi::|\bwasm_bindgen(?:::|\b)|\bwasm-pack\b/;
 var JS_FFI = /\bWebAssembly\s*\.\s*(?:instantiate|compile|Module|Instance)\b|\bprocess\.dlopen\b/;
-function languageForPath(relativePath2) {
-  const lower = relativePath2.toLowerCase();
+function languageForPath(relativePath3) {
+  const lower = relativePath3.toLowerCase();
   const dot = lower.lastIndexOf(".");
   if (dot === -1) return null;
   return EXTENSION_LANGUAGE[lower.slice(dot)] ?? null;
@@ -2519,8 +2519,8 @@ function buildSnapshot(input) {
 }
 function migrationLensFrom(migration) {
   const nodes = {};
-  for (const [relativePath2, node] of migration.nodes) {
-    nodes[fileId(relativePath2)] = node;
+  for (const [relativePath3, node] of migration.nodes) {
+    nodes[fileId(relativePath3)] = node;
   }
   const edges = migration.edges.map((edge) => ({
     fromId: fileId(edge.from),
@@ -2616,17 +2616,17 @@ function walkSourceFiles(fileSystem, options = {}) {
       (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
     );
     for (const entry of entries) {
-      const relativePath2 = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
+      const relativePath3 = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
       const absolutePath = directory.absolutePath === "/" ? `/${entry.name}` : `${directory.absolutePath}/${entry.name}`;
       if (entry.isDirectory) {
-        if (isIgnored(directory.layers, relativePath2, true)) continue;
-        const nested = readGitignore(fileSystem, absolutePath, relativePath2, warnings);
-        const layers = nested ? [...directory.layers, { base: relativePath2, matcher: ignore().add(nested) }] : directory.layers;
-        stack.push({ absolutePath, relativePath: relativePath2, layers });
+        if (isIgnored(directory.layers, relativePath3, true)) continue;
+        const nested = readGitignore(fileSystem, absolutePath, relativePath3, warnings);
+        const layers = nested ? [...directory.layers, { base: relativePath3, matcher: ignore().add(nested) }] : directory.layers;
+        stack.push({ absolutePath, relativePath: relativePath3, layers });
       } else if (entry.isFile) {
-        if (isIgnored(directory.layers, relativePath2, false)) continue;
+        if (isIgnored(directory.layers, relativePath3, false)) continue;
         if (!matchesExtension(entry.name, extensions)) continue;
-        files.push({ absolutePath, relativePath: relativePath2 });
+        files.push({ absolutePath, relativePath: relativePath3 });
       }
     }
   }
@@ -2647,10 +2647,10 @@ function readGitignore(fileSystem, absoluteDirectory, relativeBase, warnings) {
     return null;
   }
 }
-function isIgnored(layers, relativePath2, isDirectory) {
+function isIgnored(layers, relativePath3, isDirectory) {
   let ignored = false;
   for (const layer of layers) {
-    const localPath = layer.base ? relativePath2.slice(layer.base.length + 1) : relativePath2;
+    const localPath = layer.base ? relativePath3.slice(layer.base.length + 1) : relativePath3;
     if (!localPath) continue;
     const probe = isDirectory ? `${localPath}/` : localPath;
     const result = layer.matcher.test(probe);
@@ -2679,14 +2679,21 @@ function analyzeFiles(options) {
   warnings.push(...resolver.warnings);
   const parser = options.parser;
   const parsedFiles = [];
-  const migrationFiles = [];
+  const migrationFiles2 = [];
   const migrationLinks = [];
   const links = [];
   const unresolved = [];
   let externalImports = 0;
   let builtinImports = 0;
   let typeOnlyImports = 0;
+  let processed = 0;
   for (const file of walked.files) {
+    processed += 1;
+    options.onProgress?.({
+      done: processed,
+      total: walked.files.length,
+      current: file.relativePath
+    });
     const language = languageForPath(file.relativePath);
     if (!language) continue;
     if (isNativeLanguage(language)) {
@@ -2694,7 +2701,7 @@ function analyzeFiles(options) {
         relativePath: file.relativePath,
         metrics: { loc: 0, rloc: 0 }
       });
-      migrationFiles.push({
+      migrationFiles2.push({
         relativePath: file.relativePath,
         language,
         loc: 0,
@@ -2720,7 +2727,7 @@ function analyzeFiles(options) {
         relativePath: file.relativePath,
         metrics: { loc: measured.loc, rloc: measured.rloc }
       });
-      migrationFiles.push({
+      migrationFiles2.push({
         relativePath: file.relativePath,
         language,
         loc: measured.loc,
@@ -2790,7 +2797,7 @@ function analyzeFiles(options) {
         unresolvedImports: fileUnresolvedImports
       }
     });
-    migrationFiles.push({
+    migrationFiles2.push({
       relativePath: file.relativePath,
       language,
       loc: parsed.metrics.loc ?? 0,
@@ -2828,10 +2835,10 @@ function analyzeFiles(options) {
       file.metrics.dependencyLevel = metrics.dependencyLevel;
     }
   }
-  for (const file of migrationFiles) {
+  for (const file of migrationFiles2) {
     file.fanIn = graph.metrics.get(file.relativePath)?.fanIn ?? 0;
   }
-  const migration = buildMigration(migrationFiles, migrationLinks);
+  const migration = buildMigration(migrationFiles2, migrationLinks);
   for (const file of parsedFiles) {
     const node = migration.nodes.get(file.relativePath);
     if (!node) continue;
@@ -3180,6 +3187,318 @@ function clamp01(value) {
   return Math.max(0, Math.min(1, value));
 }
 
+// packages/metrics/src/profiles.ts
+var DOMAIN_PROFILES = [
+  {
+    id: "capas",
+    title: "Capas por convenci\xF3n",
+    description: "Tres capas: el dominio no depende de nada, la aplicaci\xF3n no depende de la infraestructura y la infraestructura no depende de la aplicaci\xF3n.",
+    when: "Para repos con src/domain, src/application y src/infra.",
+    layers: [
+      {
+        name: "domain",
+        patterns: [
+          "src/domain/**",
+          "src/core/**",
+          "src/dominio/**",
+          "src/nucleo/**",
+          "domain/**"
+        ]
+      },
+      {
+        name: "application",
+        patterns: [
+          "src/application/**",
+          "src/app/**",
+          "src/use-cases/**",
+          "src/usecases/**",
+          "src/aplicacion/**",
+          "src/casos-de-uso/**",
+          "application/**"
+        ]
+      },
+      {
+        name: "infrastructure",
+        patterns: [
+          "src/infrastructure/**",
+          "src/infra/**",
+          "src/adapters/**",
+          "src/persistence/**",
+          "src/infraestructura/**",
+          "src/adaptadores/**",
+          "infrastructure/**"
+        ]
+      }
+    ],
+    rules: [
+      {
+        type: "forbidden",
+        name: "dominio-sin-capas-exteriores",
+        from: "domain",
+        to: "application",
+        severity: "warn",
+        message: "El dominio no debe depender de la aplicaci\xF3n"
+      },
+      {
+        type: "forbidden",
+        name: "dominio-sin-infraestructura",
+        from: "domain",
+        to: "infrastructure",
+        severity: "warn",
+        message: "El dominio no debe depender de la infraestructura"
+      },
+      {
+        type: "forbidden",
+        name: "aplicacion-sin-infraestructura",
+        from: "application",
+        to: "infrastructure",
+        severity: "warn",
+        message: "La aplicaci\xF3n no debe depender de la infraestructura"
+      }
+    ]
+  },
+  {
+    id: "hexagonal",
+    title: "Ports & adapters",
+    description: "El dominio en el centro, la aplicaci\xF3n con los puertos y los adaptadores por fuera: la aplicaci\xF3n y el dominio no dependen de los adaptadores.",
+    when: "Para repos con puertos (interfaces) en el centro y adaptadores fuera.",
+    layers: [
+      {
+        name: "domain",
+        patterns: [
+          "src/domain/**",
+          "src/core/**",
+          "src/model/**",
+          "src/dominio/**",
+          "src/modelo/**",
+          "domain/**"
+        ]
+      },
+      {
+        name: "application",
+        patterns: [
+          "src/application/**",
+          "src/app/**",
+          "src/use-cases/**",
+          "src/usecases/**",
+          "src/ports/**",
+          "src/puertos/**",
+          "application/**"
+        ]
+      },
+      {
+        name: "adapters",
+        patterns: [
+          "src/adapters/**",
+          "src/infra/**",
+          "src/infrastructure/**",
+          "src/persistence/**",
+          "src/adaptadores/**",
+          "src/infraestructura/**",
+          "adapters/**"
+        ]
+      }
+    ],
+    rules: [
+      {
+        type: "forbidden",
+        name: "dominio-sin-adaptadores",
+        from: "domain",
+        to: "adapters",
+        severity: "warn",
+        message: "El dominio no debe depender de los adaptadores"
+      },
+      {
+        type: "forbidden",
+        name: "aplicacion-sin-adaptadores",
+        from: "application",
+        to: "adapters",
+        severity: "warn",
+        message: "La aplicaci\xF3n habla con los adaptadores por puertos, no directamente"
+      }
+    ]
+  },
+  {
+    id: "onion",
+    title: "Clean Architecture (cebolla)",
+    description: "Cuatro anillos: el dominio en el centro, luego la aplicaci\xF3n, la infraestructura y la presentaci\xF3n fuera. Las dependencias van hacia dentro y el anillo exterior no se importa desde dentro.",
+    when: "Para repos con una capa de presentaci\xF3n o de interfaz propia.",
+    layers: [
+      {
+        name: "domain",
+        patterns: [
+          "src/domain/**",
+          "src/entities/**",
+          "src/value-objects/**",
+          "src/dominio/**",
+          "src/entidades/**",
+          "domain/**"
+        ]
+      },
+      {
+        name: "application",
+        patterns: [
+          "src/application/**",
+          "src/use-cases/**",
+          "src/usecases/**",
+          "src/services/**",
+          "src/aplicacion/**",
+          "src/casos-de-uso/**",
+          "application/**"
+        ]
+      },
+      {
+        name: "infrastructure",
+        patterns: [
+          "src/infrastructure/**",
+          "src/infra/**",
+          "src/persistence/**",
+          "src/repositories/**",
+          "src/infraestructura/**",
+          "infrastructure/**"
+        ]
+      },
+      {
+        name: "presentation",
+        patterns: [
+          "src/presentation/**",
+          "src/ui/**",
+          "src/controllers/**",
+          "src/pages/**",
+          "src/components/**",
+          "src/presentacion/**",
+          "src/interfaz/**",
+          "presentation/**"
+        ]
+      }
+    ],
+    rules: [
+      {
+        type: "forbidden",
+        name: "dominio-sin-capas-exteriores",
+        from: "domain",
+        to: "application",
+        severity: "warn",
+        message: "El dominio no debe depender de la aplicaci\xF3n"
+      },
+      {
+        type: "forbidden",
+        name: "dominio-sin-infraestructura",
+        from: "domain",
+        to: "infrastructure",
+        severity: "warn",
+        message: "El dominio no debe depender de la infraestructura"
+      },
+      {
+        type: "forbidden",
+        name: "dominio-sin-presentacion",
+        from: "domain",
+        to: "presentation",
+        severity: "warn",
+        message: "El dominio no debe depender de la presentaci\xF3n"
+      },
+      {
+        type: "forbidden",
+        name: "aplicacion-sin-infraestructura",
+        from: "application",
+        to: "infrastructure",
+        severity: "warn",
+        message: "La aplicaci\xF3n no debe depender de la infraestructura"
+      },
+      {
+        type: "forbidden",
+        name: "aplicacion-sin-presentacion",
+        from: "application",
+        to: "presentation",
+        severity: "warn",
+        message: "La aplicaci\xF3n no debe depender de la presentaci\xF3n"
+      },
+      {
+        type: "forbidden",
+        name: "infraestructura-sin-presentacion",
+        from: "infrastructure",
+        to: "presentation",
+        severity: "warn",
+        message: "La infraestructura y la presentaci\xF3n se hablan por los puertos, no entre ellas"
+      }
+    ]
+  },
+  {
+    id: "ddd",
+    title: "DDD por carpetas",
+    description: "Las carpetas del dominio driven design: el modelo dentro, los servicios de aplicaci\xF3n y los repositorios en la infraestructura.",
+    when: "Para repos con modelo, servicios y repositorios como carpetas.",
+    layers: [
+      {
+        name: "domain",
+        patterns: [
+          "src/domain/**",
+          "src/model/**",
+          "src/entities/**",
+          "src/value-objects/**",
+          "src/dominio/**",
+          "src/modelo/**",
+          "domain/**"
+        ]
+      },
+      {
+        name: "application",
+        patterns: [
+          "src/application/**",
+          "src/services/**",
+          "src/use-cases/**",
+          "src/aplicacion/**",
+          "src/servicios/**",
+          "application/**"
+        ]
+      },
+      {
+        name: "infrastructure",
+        patterns: [
+          "src/infrastructure/**",
+          "src/repositories/**",
+          "src/persistence/**",
+          "src/infraestructura/**",
+          "src/repositorios/**",
+          "infrastructure/**"
+        ]
+      }
+    ],
+    rules: [
+      {
+        type: "forbidden",
+        name: "dominio-sin-capas-exteriores",
+        from: "domain",
+        to: "application",
+        severity: "warn",
+        message: "El modelo de dominio no debe depender de los servicios"
+      },
+      {
+        type: "forbidden",
+        name: "dominio-sin-infraestructura",
+        from: "domain",
+        to: "infrastructure",
+        severity: "warn",
+        message: "El modelo de dominio no debe depender de los repositorios"
+      },
+      {
+        type: "forbidden",
+        name: "aplicacion-sin-infraestructura",
+        from: "application",
+        to: "infrastructure",
+        severity: "warn",
+        message: "Los servicios hablan con los repositorios por puertos, no directamente"
+      }
+    ]
+  }
+];
+function findDomainProfile(id) {
+  return DOMAIN_PROFILES.find((profile) => profile.id === id);
+}
+function domainProfileIds() {
+  return DOMAIN_PROFILES.map((profile) => profile.id);
+}
+
 // packages/render/src/model.ts
 var RenderError = class extends Error {
   constructor(message) {
@@ -4342,10 +4661,103 @@ function parseRuleConfig(input) {
   if (root.version !== 1) {
     throw new ConfigError("config.version debe ser 1");
   }
-  const layers = parseLayers(root.layers);
+  const own = parseInlineProfiles(root.profiles);
+  const profile = parseProfile(root.profile, own);
+  const profileSeverity = parseProfileSeverity(root.profile_severity);
+  const layers = mergeLayers(profile, parseLayers(root.layers));
   const layerNames = new Set(layers.map((layer) => layer.name));
-  const rules = parseRules(root.rules, layerNames);
-  return { version: 1, layers, rules };
+  const rules = mergeRules(
+    profile,
+    profileSeverity,
+    parseRules(root.rules, layerNames),
+    layerNames
+  );
+  return { version: 1, profile: profile?.id ?? null, layers, rules };
+}
+function parseInlineProfiles(value) {
+  const profiles = /* @__PURE__ */ new Map();
+  if (value === void 0 || value === null) return profiles;
+  if (!Array.isArray(value)) {
+    throw new ConfigError("config.profiles debe ser una lista");
+  }
+  value.forEach((raw, index) => {
+    const entry = asObject(raw, `config.profiles[${index}]`);
+    const id = asString(entry.id, `config.profiles[${index}].id`);
+    const title = asString(entry.title, `config.profiles[${index}].title`);
+    const description = entry.description === void 0 ? "" : asString(entry.description, `config.profiles[${index}].description`);
+    const layers = parseLayers(entry.layers).map((layer) => ({
+      name: layer.name,
+      patterns: layer.patterns
+    }));
+    if (layers.length === 0) {
+      throw new ConfigError(
+        `config.profiles[${index}] necesita al menos una capa`
+      );
+    }
+    const layerNames = new Set(layers.map((layer) => layer.name));
+    const rules = parseRules(entry.rules, layerNames).filter(
+      (rule) => rule.type === "forbidden"
+    );
+    profiles.set(id, {
+      id,
+      title,
+      description,
+      when: `Perfil propio del equipo, definido en ${"el archivo de reglas"}.`,
+      layers,
+      rules
+    });
+  });
+  return profiles;
+}
+function parseProfile(value, own) {
+  if (value === void 0 || value === null) return null;
+  const id = asString(value, "config.profile");
+  const profile = own.get(id) ?? findDomainProfile(id);
+  if (!profile) {
+    const available = [...own.keys(), ...domainProfileIds()].join(", ");
+    throw new ConfigError(
+      `config.profile desconocido: ${id}. Disponibles: ${available}`
+    );
+  }
+  return profile;
+}
+function parseProfileSeverity(value) {
+  if (value === void 0 || value === null) return "warn";
+  if (typeof value !== "string" || !SEVERITIES.has(value)) {
+    throw new ConfigError(
+      "config.profile_severity debe ser info, warn o error"
+    );
+  }
+  return value;
+}
+function mergeLayers(profile, own) {
+  const layers = /* @__PURE__ */ new Map();
+  for (const layer of profile?.layers ?? []) layers.set(layer.name, layer);
+  for (const layer of own) layers.set(layer.name, layer);
+  return [...layers.values()];
+}
+function mergeRules(profile, profileSeverity, own, layerNames) {
+  const rules = /* @__PURE__ */ new Map();
+  for (const rule of profile?.rules ?? []) {
+    rules.set(rule.name, {
+      ...rule,
+      severity: profileSeverity,
+      source: "profile"
+    });
+  }
+  for (const rule of own) {
+    rules.set(rule.name, { ...rule, source: "config" });
+  }
+  for (const rule of rules.values()) {
+    if (rule.type !== "forbidden") continue;
+    if (layerNames.has(rule.from) && layerNames.has(rule.to)) continue;
+    if (rule.source === "profile") {
+      throw new ConfigError(
+        `la regla "${rule.name}" del perfil apunta a una capa que no existe: ${rule.from} \u2192 ${rule.to}`
+      );
+    }
+  }
+  return [...rules.values()];
 }
 function loadRuleConfig(file) {
   let text;
@@ -4512,6 +4924,7 @@ import { minimatch } from "minimatch";
 function emptyRuleReport() {
   return {
     configured: false,
+    profile: null,
     summary: {
       layers: 0,
       rules: 0,
@@ -4548,6 +4961,7 @@ function evaluateRules(base, head, config) {
   resolved.sort(compareViolations);
   return {
     configured: true,
+    profile: config.profile ?? null,
     summary: {
       layers: config.layers.length,
       rules: config.rules.length,
@@ -4603,6 +5017,7 @@ function evaluateForbidden(rule, input, layers, violations) {
       rule: rule.name,
       type: "forbidden",
       severity: rule.severity,
+      source: rule.source ?? "config",
       message: rule.message ?? `${edge.from} no puede depender de ${edge.to}`,
       files: [edge.from, edge.to],
       edge: {
@@ -4627,6 +5042,7 @@ function evaluateThreshold(rule, input, violations) {
       rule: rule.name,
       type: "threshold",
       severity: rule.severity,
+      source: rule.source ?? "config",
       message: rule.message ?? `${file.path}: ${rule.metric} = ${value} (${limit})`,
       files: [file.path],
       metric: {
@@ -4646,6 +5062,7 @@ function evaluateCycles(rule, cycles, violations) {
       rule: rule.name,
       type: "cycles",
       severity: rule.severity,
+      source: rule.source ?? "config",
       message: rule.message ?? cycleMessage(paths),
       files: paths,
       cycle: {
@@ -4692,7 +5109,7 @@ function diffSnapshots(base, head, options = {}) {
     options.rules
   ) : emptyRuleReport();
   return {
-    schemaVersion: "1.0",
+    schemaVersion: "1.2",
     base: summarize(baseIndex),
     head: summarize(headIndex),
     summary: {
@@ -4712,9 +5129,94 @@ function diffSnapshots(base, head, options = {}) {
     files: { added, removed, changed },
     edges: edgeDiff,
     cycles: { introduced: introducedCycles, fixed: fixedCycles },
-    hotspots
+    hotspots,
+    migration: buildMigrationReport(baseIndex, headIndex, top)
   };
 }
+function buildMigrationReport(baseIndex, headIndex, top) {
+  const baseLens = baseIndex.cc.lenses?.migration;
+  const headLens = headIndex.cc.lenses?.migration;
+  if (!baseLens && !headLens) return null;
+  const baseNodes = baseLens?.nodes ?? {};
+  const headNodes = headLens?.nodes ?? {};
+  const changes = [];
+  for (const id of /* @__PURE__ */ new Set([...Object.keys(baseNodes), ...Object.keys(headNodes)])) {
+    const base = baseNodes[id];
+    const head = headNodes[id];
+    if (!base && !head) continue;
+    const reference = head ?? base;
+    const baseDebt = base ? base.debt ?? 0 : null;
+    const headDebt = head ? head.debt ?? 0 : null;
+    const delta = baseDebt === null || headDebt === null ? null : headDebt - baseDebt;
+    if (delta === null || delta === 0) continue;
+    changes.push({
+      id,
+      path: headIndex.paths.get(id) ?? baseIndex.paths.get(id) ?? id,
+      language: reference.language,
+      status: reference.status,
+      base: baseDebt,
+      head: headDebt,
+      delta
+    });
+  }
+  const increased = changes.filter((change) => (change.delta ?? 0) > 0).sort(
+    (left, right) => (right.delta ?? 0) - (left.delta ?? 0) || compareByPath(left, right)
+  );
+  const decreased = changes.filter((change) => (change.delta ?? 0) < 0).sort(
+    (left, right) => (left.delta ?? 0) - (right.delta ?? 0) || compareByPath(left, right)
+  );
+  const topDebt = [];
+  for (const [id, node] of Object.entries(headNodes)) {
+    if (!node.debt) continue;
+    topDebt.push({
+      id,
+      path: headIndex.paths.get(id) ?? id,
+      language: node.language,
+      status: node.status,
+      debt: node.debt,
+      rloc: node.rloc,
+      crossings: node.crossings
+    });
+  }
+  topDebt.sort(
+    (left, right) => right.debt - left.debt || compareByPath(left, right)
+  );
+  const baseSummary = baseLens?.summary;
+  const headSummary = headLens?.summary;
+  return {
+    languages: {
+      base: baseSummary?.languages ?? {},
+      head: headSummary?.languages ?? {}
+    },
+    status: {
+      base: baseSummary?.status ?? emptyStatus(),
+      head: headSummary?.status ?? emptyStatus()
+    },
+    debt: {
+      base: baseSummary?.migrationDebt ?? 0,
+      head: headSummary?.migrationDebt ?? 0,
+      delta: (headSummary?.migrationDebt ?? 0) - (baseSummary?.migrationDebt ?? 0)
+    },
+    crossings: {
+      base: baseSummary?.ffiCrossings ?? 0,
+      head: headSummary?.ffiCrossings ?? 0,
+      delta: (headSummary?.ffiCrossings ?? 0) - (baseSummary?.ffiCrossings ?? 0)
+    },
+    bridgeFiles: {
+      base: baseSummary?.bridgeFiles ?? 0,
+      head: headSummary?.bridgeFiles ?? 0,
+      delta: (headSummary?.bridgeFiles ?? 0) - (baseSummary?.bridgeFiles ?? 0)
+    },
+    files: {
+      increased: increased.slice(0, top),
+      decreased: decreased.slice(0, top)
+    },
+    topDebt: topDebt.slice(0, top)
+  };
+}
+function emptyStatus() {
+  return { js: 0, rust: 0, bridge: 0, native: 0 };
+}
 function indexSnapshot(cc) {
   const paths = /* @__PURE__ */ new Map();
   for (const root of cc.files) {
@@ -4776,7 +5278,7 @@ function difference(present, absent) {
       metrics: sortedMetrics(present.metrics[id])
     });
   }
-  return files.sort(compareFiles);
+  return files.sort(compareByPath);
 }
 function changedFiles(base, head) {
   const changed = [];
@@ -4990,7 +5492,7 @@ function finiteNumber(value) {
 function edgeKey(fromId, toId) {
   return `${fromId}\0${toId}`;
 }
-function compareFiles(left, right) {
+function compareByPath(left, right) {
   return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
 }
 function compareChangedFiles(left, right) {
@@ -5009,6 +5511,209 @@ function compareStrings5(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// packages/metrics/src/suggest.ts
+var ROOT_FOLDERS = /* @__PURE__ */ new Set([
+  "src",
+  "lib",
+  "libs",
+  "source",
+  "app",
+  "apps",
+  "packages",
+  "pkg"
+]);
+function suggestLayers(cc) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const root of cc.files) {
+    walkFiles([root], (entry) => {
+      paths.set(entry.node.id, relativePath2(root, entry.path));
+    });
+  }
+  const edges = cc.lenses?.dependency?.edges ?? [];
+  const groups = /* @__PURE__ */ new Map();
+  let ungrouped = 0;
+  const groupOf = (path7) => {
+    const parts = path7.split("/").filter(Boolean);
+    if (parts.length === 0) return null;
+    const directory = parts.slice(0, -1);
+    if (directory.length === 0) {
+      ungrouped += 1;
+      return null;
+    }
+    if (directory.length === 1 && ROOT_FOLDERS.has(directory[0])) {
+      ungrouped += 1;
+      return null;
+    }
+    const name = directory.slice(0, 2).join("/");
+    let group = groups.get(name);
+    if (!group) {
+      group = {
+        name,
+        pattern: `${name}/**`,
+        files: 0,
+        dependsOn: /* @__PURE__ */ new Set(),
+        usedBy: /* @__PURE__ */ new Set()
+      };
+      groups.set(name, group);
+    }
+    group.files += 1;
+    return group;
+  };
+  for (const path7 of paths.values()) groupOf(path7);
+  const groupEdges = [];
+  for (const edge of edges) {
+    const fromPath = paths.get(edge.fromId);
+    const toPath = paths.get(edge.toId);
+    if (!fromPath || !toPath) continue;
+    const from = groupOf(fromPath);
+    const to = groupOf(toPath);
+    if (!from || !to || from.name === to.name) continue;
+    from.dependsOn.add(to.name);
+    to.usedBy.add(from.name);
+    groupEdges.push({ from, to });
+  }
+  const depthOf = (name, visiting = /* @__PURE__ */ new Set()) => {
+    const group = groups.get(name);
+    if (!group) return 0;
+    if (visiting.has(name)) return 0;
+    visiting.add(name);
+    let depth = 0;
+    for (const dependency of group.dependsOn) {
+      depth = Math.max(depth, depthOf(dependency, visiting) + 1);
+    }
+    visiting.delete(name);
+    return depth;
+  };
+  const layers = [...groups.values()].map((group) => ({
+    name: group.name,
+    patterns: [group.pattern],
+    files: group.files,
+    dependsOn: [...group.dependsOn].sort(),
+    usedBy: [...group.usedBy].sort(),
+    depth: depthOf(group.name)
+  })).sort((left, right) => left.depth - right.depth || left.name.localeCompare(right.name));
+  const rules = [];
+  for (const layer of layers) {
+    for (const outer of layer.usedBy) {
+      rules.push({
+        name: `${slug(layer.name)}-sin-${slug(outer)}`,
+        type: "forbidden",
+        from: layer.name,
+        to: outer,
+        severity: "warn",
+        message: `${layer.name} no debe depender de ${outer}`
+      });
+    }
+  }
+  rules.sort((left, right) => left.name.localeCompare(right.name));
+  const notes = [];
+  if (ungrouped > 0) {
+    notes.push(
+      `${ungrouped} ficheros en la ra\xEDz o sin carpeta: no forman capa (suelen ser puntos de entrada).`
+    );
+  }
+  if (layers.length === 0) {
+    notes.push("No se ha encontrado ninguna carpeta con c\xF3digo.");
+  }
+  if (layers.length === 1) {
+    notes.push(
+      "Solo hay una capa: no se puede deducir una estructura. Prueba con un perfil del cat\xE1logo."
+    );
+  }
+  const fits = matchProfiles(groups, groupEdges);
+  const best = fits.find((fit) => fit.matched >= 2) ?? null;
+  const profile = best ? findDomainProfile(best.id) ?? null : null;
+  const proposedLayers = profile ? profile.layers.map((layer) => {
+    const group = groupForLayer(layer, groups);
+    return {
+      name: layer.name,
+      patterns: [...layer.patterns],
+      files: group?.files ?? 0,
+      dependsOn: [],
+      usedBy: [],
+      depth: 0
+    };
+  }) : layers;
+  const proposedRules = profile ? profile.rules.map((rule) => ({
+    name: rule.name,
+    type: "forbidden",
+    from: rule.from,
+    to: rule.to,
+    severity: "warn",
+    message: rule.message ?? `${rule.from} no debe depender de ${rule.to}`
+  })) : rules;
+  return {
+    detected: layers,
+    layers: proposedLayers,
+    rules: proposedRules,
+    proposal: profile ? "profile" : "deduced",
+    profile: profile?.id ?? null,
+    ungrouped,
+    notes,
+    fits
+  };
+}
+function groupForLayer(layer, groups) {
+  for (const candidate of groups.values()) {
+    if (layer.patterns.some((pattern) => covers(pattern, candidate.name))) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function matchProfiles(groups, groupEdges) {
+  const totalFiles = [...groups.values()].reduce(
+    (sum, group) => sum + group.files,
+    0
+  );
+  return DOMAIN_PROFILES.map((profile) => {
+    const layerOf = /* @__PURE__ */ new Map();
+    for (const layer of profile.layers) {
+      const group = [...groups.values()].find(
+        (candidate) => layer.patterns.some((pattern) => covers(pattern, candidate.name))
+      );
+      if (group) layerOf.set(layer.name, group.name);
+    }
+    const covered = [...layerOf.values()].reduce(
+      (sum, name) => sum + (groups.get(name)?.files ?? 0),
+      0
+    );
+    const broken = [];
+    for (const rule of profile.rules) {
+      const fromGroup = layerOf.get(rule.from);
+      const toGroup = layerOf.get(rule.to);
+      if (!fromGroup || !toGroup) continue;
+      const violates = groupEdges.some(
+        (edge) => edge.from.name === fromGroup && edge.to.name === toGroup
+      );
+      if (violates) broken.push(rule.message ?? `${rule.from} no puede depender de ${rule.to}`);
+    }
+    return {
+      id: profile.id,
+      title: profile.title,
+      matched: layerOf.size,
+      total: profile.layers.length,
+      coverage: totalFiles === 0 ? 0 : Math.round(covered / totalFiles * 100),
+      broken
+    };
+  }).sort(
+    (left, right) => right.matched - left.matched || right.coverage - left.coverage || left.id.localeCompare(right.id)
+  );
+}
+function covers(pattern, name) {
+  const prefix = pattern.endsWith("/**") ? pattern.slice(0, -3) : pattern;
+  return name === prefix || name.startsWith(`${prefix}/`);
+}
+function slug(name) {
+  return name.replaceAll("/", "-");
+}
+function relativePath2(root, fullPath) {
+  if (fullPath === root.name) return "";
+  const prefix = `${root.name}/`;
+  const stripped = fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+  return stripped.replace(/^\/+/, "");
+}
+
 // apps/cli/src/commands/diff.ts
 var numberFormat2 = new Intl.NumberFormat("es-ES");
 function num2(value) {
@@ -5651,7 +6356,11 @@ function runServe(options) {
       if (pathname === "/data/report.json") {
         const report = readReport(state.root);
         if (report === null) {
-          sendError(response, 404, "no hay .codarch/report.json");
+          response.writeHead(204, {
+            "Cache-Control": "no-store",
+            "X-Content-Type-Options": "nosniff"
+          });
+          response.end();
           return;
         }
         sendJson(response, report);
@@ -5881,8 +6590,170 @@ data: ${JSON.stringify(data)}
   }
 }
 
+// apps/cli/src/commands/profiles.ts
+function runProfiles(json) {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          profiles: DOMAIN_PROFILES.map((profile) => ({
+            id: profile.id,
+            title: profile.title,
+            description: profile.description,
+            when: profile.when,
+            layers: profile.layers.map((layer) => ({
+              name: layer.name,
+              patterns: layer.patterns
+            })),
+            rules: profile.rules.map((rule) => ({
+              name: rule.name,
+              from: rule.from,
+              to: rule.to,
+              severity: rule.severity,
+              message: rule.message ?? null
+            }))
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  console.log("");
+  console.log("  CodArch \xB7 perfiles de arquitectura");
+  console.log("");
+  for (const profile of DOMAIN_PROFILES) {
+    console.log(`  ${profile.id} \xB7 ${profile.title}`);
+    console.log(`    ${profile.description}`);
+    console.log(`    para: ${profile.when}`);
+    console.log(
+      `    capas: ${profile.layers.map((layer) => layer.name).join(", ")}`
+    );
+    for (const rule of profile.rules) {
+      console.log(
+        `    \xB7 ${rule.name}: ${rule.from} no puede depender de ${rule.to} (${rule.severity})`
+      );
+    }
+    console.log("");
+  }
+  console.log("  Para usarlo, en .codarch.yml:");
+  console.log("");
+  console.log("    version: 1");
+  console.log("    profile: capas");
+  console.log("");
+  console.log('  Las reglas del perfil entran como aviso: suben a "error" cuando el c\xF3digo est\xE9 listo.');
+  console.log("");
+  return 0;
+}
+
+// apps/cli/src/commands/suggest.ts
+import { stringify as toYaml } from "yaml";
+function runSuggest(options) {
+  if (!options.file) {
+    console.error(
+      "falta la ruta del fichero cc.json\n\n  codarch suggest <fichero.cc.json[.gz]>"
+    );
+    return 1;
+  }
+  let loaded;
+  try {
+    loaded = readJsonFile2(options.file);
+  } catch (error) {
+    console.error(`no se pudo leer ${options.file}: ${error.message}`);
+    return 1;
+  }
+  let suggestion;
+  try {
+    const cc = parseCcJson(loaded.json);
+    suggestion = suggestLayers(cc);
+  } catch (error) {
+    console.error(`no se pudo leer ${options.file}: ${error.message}`);
+    return 1;
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          detected: suggestion.detected,
+          layers: suggestion.layers,
+          rules: suggestion.rules,
+          proposal: suggestion.proposal,
+          profile: suggestion.profile,
+          ungrouped: suggestion.ungrouped,
+          notes: suggestion.notes,
+          fits: suggestion.fits
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  console.log("");
+  console.log("  CodArch \xB7 propuesta de capas");
+  console.log("");
+  if (suggestion.layers.length === 0) {
+    console.log("  No se ha encontrado ninguna carpeta con c\xF3digo.");
+    for (const note of suggestion.notes) console.log(`  ${note}`);
+    console.log("");
+    return 0;
+  }
+  for (const layer of suggestion.detected) {
+    console.log(
+      `  ${layer.name} \xB7 ${layer.files} ficheros \xB7 nivel ${layer.depth}` + (layer.usedBy.length > 0 ? ` \xB7 de aqu\xED dependen: ${layer.usedBy.join(", ")}` : "")
+    );
+  }
+  console.log("");
+  const yaml = toYaml(
+    {
+      version: 1,
+      layers: suggestion.layers.map((layer) => ({
+        name: layer.name,
+        paths: layer.patterns
+      })),
+      rules: suggestion.rules
+    },
+    { lineWidth: 0 }
+  );
+  console.log("  Propuesta para .codarch.yml:");
+  console.log("");
+  console.log(
+    suggestion.proposal === "profile" && suggestion.profile ? `    # Propuesta a partir del perfil "${suggestion.profile}" del cat\xE1logo.` : "    # Propuesta deducida del grafo de dependencias del repo."
+  );
+  console.log(
+    yaml.split("\n").map((line) => `    ${line}`).join("\n").trimEnd()
+  );
+  console.log("");
+  const best = suggestion.fits[0];
+  if (best && best.matched > 0) {
+    console.log("  Encaje con el cat\xE1logo de perfiles:");
+    console.log("");
+    for (const fit of suggestion.fits.filter((entry) => entry.matched > 0)) {
+      console.log(
+        `    ${fit.id.padEnd(12)} ${fit.matched} de ${fit.total} capas \xB7 cubre el ${fit.coverage}% del c\xF3digo`
+      );
+    }
+    console.log("");
+    if (best.broken.length > 0) {
+      console.log(
+        `  Con el perfil "${best.id}", el c\xF3digo incumple hoy ${best.broken.length} ${best.broken.length === 1 ? "regla" : "reglas"}:`
+      );
+      for (const message of best.broken) console.log(`    \xB7 ${message}`);
+      console.log("");
+    }
+  }
+  for (const note of suggestion.notes) console.log(`  ${note}`);
+  console.log("");
+  console.log(
+    '  Las reglas salen como aviso: consultan, no bloquean. Rev\xEDsalas y s\xFAbelas a "error" si encajan.'
+  );
+  console.log("");
+  return 0;
+}
+
 // apps/cli/src/index.ts
-var VERSION = true ? "0.1.4" : "0.0.0";
+var VERSION = true ? "0.2.0" : "0.0.0";
 var USAGE = `
 CodArch \xB7 mapa vivo de la arquitectura de tu software
 
@@ -5892,6 +6763,8 @@ Uso:
   codarch render  <fichero.cc.json[.gz]> [opciones]
   codarch diff    <base.cc.json[.gz]> <head.cc.json[.gz]> [opciones]
   codarch serve   [ruta] [opciones]
+  codarch profiles [--json]
+  codarch suggest <fichero.cc.json[.gz]> [--json]
 
 Opciones de analyze:
   -o, --out <dir>    directorio de salida (por defecto <ruta>/.codarch)
@@ -5933,6 +6806,14 @@ Opciones de serve:
   --no-web          modo API sin servir la app (para Vite u otro frontend)
   -h, --help        esta ayuda
 
+Opciones de profiles:
+  --json            salida machine-readable
+  -h, --help        esta ayuda
+
+Opciones de suggest:
+  --json            salida machine-readable
+  -h, --help        esta ayuda
+
 Ejemplos:
   codarch analyze .
   codarch analyze . -o .codarch --title "Mi proyecto"
@@ -5942,6 +6823,8 @@ Ejemplos:
   codarch diff base.cc.json head.cc.json -o report.json --fail-on cycles
   codarch serve .
   codarch serve . --no-watch
+  codarch profiles
+  codarch suggest .codarch/snapshot.cc.json
 `;
 function parseAnalyze(args) {
   const options = { help: false, ignore: [] };
@@ -6006,6 +6889,30 @@ function parseAnalyze(args) {
   options.root = positional[0] ?? ".";
   return options;
 }
+function parseSuggest(args) {
+  const options = { json: false };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      return 0;
+    } else if (arg.startsWith("-")) {
+      console.error(`opci\xF3n desconocida: ${arg}`);
+      return 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 1) {
+    console.error(`sobra un argumento: ${positional[1]}`);
+    return 1;
+  }
+  options.file = positional[0];
+  return options;
+}
 function parseInspect(args) {
   const options = { json: false, top: 5, help: false };
   const positional = [];
@@ -6301,6 +7208,14 @@ function main(argv) {
     }
     return runServe(parsed);
   }
+  if (command === "profiles") {
+    return runProfiles(rest.includes("--json"));
+  }
+  if (command === "suggest") {
+    const parsed = parseSuggest(rest);
+    if (typeof parsed === "number") return parsed;
+    return runSuggest(parsed);
+  }
   console.error(`comando desconocido: ${command}
 ${USAGE}`);
   return 1;