codarch 0.0.0-stage → 0.1.0

package/index.js

@@ -0,0 +1,4687 @@
+#!/usr/bin/env node
+
+// apps/cli/src/commands/analyze.ts
+import fs7 from "node:fs";
+import path5 from "node:path";
+
+// packages/parsers/src/ts/parser.ts
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "generator_function_declaration",
+  "generator_function"
+]);
+var DECISION_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_case",
+  "catch_clause",
+  "ternary_expression",
+  "conditional_expression"
+]);
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set(["&&", "||", "??"]);
+var TypeScriptParser = class {
+  name = "typescript";
+  extensions = EXTENSIONS;
+  tsParser = new Parser();
+  tsxParser = new Parser();
+  constructor() {
+    this.tsParser.setLanguage(TypeScript.typescript);
+    this.tsxParser.setLanguage(TypeScript.tsx);
+  }
+  parse(source, filePath) {
+    const parser = usesTsxGrammar(filePath) ? this.tsxParser : this.tsParser;
+    const root = parser.parse(source).rootNode;
+    return {
+      metrics: measureSource(source, root),
+      imports: collectImports(root)
+    };
+  }
+};
+function usesTsxGrammar(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.endsWith(".tsx") || lower.endsWith(".jsx") || lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs");
+}
+function measureSource(source, root) {
+  const codeLines = /* @__PURE__ */ new Set();
+  const stack = [root];
+  let functions = 0;
+  let maxComplexity = 0;
+  let maxFunctionLength = 0;
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "comment" || node.type === "hash_bang_line") continue;
+    if (node.childCount === 0) {
+      if (node.text.trim() !== "") {
+        for (let row = node.startPosition.row; row <= node.endPosition.row; row++) {
+          codeLines.add(row);
+        }
+      }
+      continue;
+    }
+    if (FUNCTION_TYPES.has(node.type)) {
+      functions++;
+      const complexity = functionComplexity(node);
+      const length = node.endPosition.row - node.startPosition.row + 1;
+      if (complexity > maxComplexity) maxComplexity = complexity;
+      if (length > maxFunctionLength) maxFunctionLength = length;
+    }
+    for (const child of node.children) stack.push(child);
+  }
+  return {
+    loc: countLines(source),
+    rloc: codeLines.size,
+    functions,
+    maxComplexity,
+    maxFunctionLength
+  };
+}
+function functionComplexity(fn) {
+  let complexity = 1;
+  const body = fn.childForFieldName("body") ?? fn;
+  const stack = [];
+  for (const child of body.children) stack.push(child);
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (FUNCTION_TYPES.has(node.type)) continue;
+    if (DECISION_TYPES.has(node.type)) complexity++;
+    if (node.type === "binary_expression" || node.type === "augmented_assignment_expression") {
+      const operator = node.childForFieldName("operator")?.text;
+      if (operator && LOGICAL_OPERATORS.has(operator)) complexity++;
+    }
+    for (const child of node.children) stack.push(child);
+  }
+  return complexity;
+}
+function countLines(source) {
+  if (source.length === 0) return 0;
+  let lines = 1;
+  for (let index = 0; index < source.length; index++) {
+    const code = source.charCodeAt(index);
+    if (code === 10) {
+      lines++;
+    } else if (code === 13 && source.charCodeAt(index + 1) !== 10) {
+      lines++;
+    }
+  }
+  const last = source.charCodeAt(source.length - 1);
+  return last === 10 || last === 13 ? lines - 1 : lines;
+}
+function collectImports(root) {
+  const imports = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "import_statement") {
+      const source = findImportSource(node);
+      const specifier = source ? stringLiteralValue(source) : null;
+      if (specifier !== null) {
+        const isRequire = node.namedChildren.some(
+          (child) => child.type === "import_require_clause"
+        );
+        imports.push({
+          specifier,
+          kind: isRequire ? "require" : "static",
+          typeOnly: node.children.some((child) => child.type === "type"),
+          line: node.startPosition.row + 1
+        });
+      }
+    } else if (node.type === "export_statement") {
+      const source = node.childForFieldName("source");
+      const specifier = source ? stringLiteralValue(source) : null;
+      if (specifier !== null) {
+        imports.push({
+          specifier,
+          kind: "export",
+          typeOnly: node.children.some((child) => child.type === "type"),
+          line: node.startPosition.row + 1
+        });
+      }
+    } else if (node.type === "call_expression") {
+      const kind = callImportKind(node);
+      if (kind) {
+        const argumentsNode = node.childForFieldName("arguments");
+        const first = argumentsNode?.namedChildren[0];
+        const specifier = first ? stringLiteralValue(first) : null;
+        if (specifier !== null) {
+          imports.push({
+            specifier,
+            kind,
+            typeOnly: false,
+            line: node.startPosition.row + 1
+          });
+        }
+      }
+    }
+    for (let index = node.children.length - 1; index >= 0; index--) {
+      stack.push(node.children[index]);
+    }
+  }
+  return imports;
+}
+function findImportSource(node) {
+  const direct = node.childForFieldName("source");
+  if (direct) return direct;
+  const clause = node.namedChildren.find(
+    (child) => child.type === "import_require_clause"
+  );
+  return clause?.childForFieldName("source") ?? null;
+}
+function callImportKind(node) {
+  const fn = node.childForFieldName("function");
+  if (!fn) return null;
+  if (fn.type === "import") return "dynamic";
+  if (fn.type === "identifier" && fn.text === "require") return "require";
+  return null;
+}
+function stringLiteralValue(node) {
+  if (node.type === "string") {
+    return decodeStringBody(node.text.slice(1, -1));
+  }
+  if (node.type === "template_string") {
+    const hasSubstitution = node.namedChildren.some(
+      (child) => child.type === "template_substitution"
+    );
+    if (!hasSubstitution) return decodeStringBody(node.text.slice(1, -1));
+  }
+  return null;
+}
+function decodeStringBody(body) {
+  return body.replace(
+    /\\(u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|x([0-9a-fA-F]{2})|([\s\S]))/g,
+    (_match, _escaped, braced, four, two, character) => {
+      if (braced) return String.fromCodePoint(Number.parseInt(braced, 16));
+      if (four) return String.fromCharCode(Number.parseInt(four, 16));
+      if (two) return String.fromCharCode(Number.parseInt(two, 16));
+      switch (character) {
+        case "n":
+          return "\n";
+        case "r":
+          return "\r";
+        case "t":
+          return "	";
+        case "b":
+          return "\b";
+        case "f":
+          return "\f";
+        case "v":
+          return "\v";
+        case "0":
+          return "\0";
+        default:
+          return character;
+      }
+    }
+  );
+}
+
+// packages/parsers/src/resolve.ts
+import fs from "node:fs";
+import path from "node:path";
+import { builtinModules } from "node:module";
+import ts from "typescript";
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".d.ts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+var PACKAGE_MAIN_FIELDS = ["types", "module", "main"];
+var WORKSPACE_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".codarch",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  "out",
+  "target"
+]);
+var MAX_WORKSPACE_DEPTH = 8;
+var MAX_RESOLVE_DEPTH = 8;
+var BUILTINS = new Set(
+  builtinModules.flatMap((name) => [name, `node:${name}`])
+);
+var ImportResolver = class {
+  warnings = [];
+  root;
+  byPath = /* @__PURE__ */ new Map();
+  packageJsonCache = /* @__PURE__ */ new Map();
+  configCache = /* @__PURE__ */ new Map();
+  workspaces;
+  constructor(rootInput, files) {
+    this.root = path.resolve(rootInput);
+    for (const file of files) this.byPath.set(pathKey(file.absolutePath), file);
+    this.workspaces = discoverWorkspaces(this.root, this.warnings);
+  }
+  resolve(importerPath, specifier) {
+    if (BUILTINS.has(specifier) || specifier.startsWith("node:")) {
+      return { kind: "external", specifier, builtin: true };
+    }
+    if (specifier.startsWith(".") || specifier.startsWith("/")) {
+      const base = specifier.startsWith("/") ? path.resolve(this.root, `.${specifier}`) : path.resolve(path.dirname(path.resolve(importerPath)), specifier);
+      const file = this.resolveAsFileOrDirectory(base);
+      return file ? { kind: "internal", file } : { kind: "unresolved", specifier, reason: "no se encontr\xF3 el fichero" };
+    }
+    const config = this.configFor(path.dirname(path.resolve(importerPath)));
+    if (config) {
+      const alias = matchAlias(config.aliases, specifier);
+      if (alias) {
+        for (const target of alias.targets) {
+          const file = this.resolveAsFileOrDirectory(target);
+          if (file) return { kind: "internal", file };
+        }
+        return {
+          kind: "unresolved",
+          specifier,
+          reason: "alias de tsconfig sin fichero fuente"
+        };
+      }
+    }
+    const workspace = this.matchWorkspace(specifier);
+    if (workspace) {
+      const file = this.resolveWorkspace(workspace, specifier);
+      return file ? { kind: "internal", file } : {
+        kind: "unresolved",
+        specifier,
+        reason: "paquete del workspace sin fichero fuente"
+      };
+    }
+    return { kind: "external", specifier, builtin: false };
+  }
+  matchWorkspace(specifier) {
+    for (const workspace of this.workspaces) {
+      if (specifier === workspace.name || specifier.startsWith(`${workspace.name}/`)) {
+        return workspace;
+      }
+    }
+    return null;
+  }
+  resolveWorkspace(workspace, specifier) {
+    const subpath = specifier === workspace.name ? "." : `./${specifier.slice(workspace.name.length + 1)}`;
+    for (const target of packageExportTargets(workspace.json.exports, subpath)) {
+      const file = this.resolveAsFileOrDirectory(
+        path.resolve(workspace.dir, target)
+      );
+      if (file) return file;
+    }
+    if (subpath === ".") {
+      for (const field5 of PACKAGE_MAIN_FIELDS) {
+        const value = workspace.json[field5];
+        if (typeof value !== "string") continue;
+        const file = this.resolveAsFileOrDirectory(
+          path.resolve(workspace.dir, value)
+        );
+        if (file) return file;
+      }
+      for (const fallback of [
+        "src/index.ts",
+        "src/index.tsx",
+        "index.ts",
+        "index.tsx"
+      ]) {
+        const file = this.resolveAsFileOrDirectory(
+          path.resolve(workspace.dir, fallback)
+        );
+        if (file) return file;
+      }
+    } else {
+      const file = this.resolveAsFileOrDirectory(
+        path.resolve(workspace.dir, subpath.slice(2))
+      );
+      if (file) return file;
+    }
+    return null;
+  }
+  resolveAsFileOrDirectory(base, depth = 0) {
+    if (depth > MAX_RESOLVE_DEPTH) return null;
+    for (const candidate of fileCandidates(base)) {
+      const file = this.byPath.get(pathKey(candidate));
+      if (file) return file;
+    }
+    const pkg = this.readPackageJson(base);
+    if (pkg) {
+      for (const field5 of PACKAGE_MAIN_FIELDS) {
+        const value = pkg[field5];
+        if (typeof value !== "string") continue;
+        const file = this.resolveAsFileOrDirectory(
+          path.resolve(base, value),
+          depth + 1
+        );
+        if (file) return file;
+      }
+      for (const target of packageExportTargets(pkg.exports, ".")) {
+        const file = this.resolveAsFileOrDirectory(
+          path.resolve(base, target),
+          depth + 1
+        );
+        if (file) return file;
+      }
+    }
+    for (const candidate of indexCandidates(base)) {
+      const file = this.byPath.get(pathKey(candidate));
+      if (file) return file;
+    }
+    return null;
+  }
+  readPackageJson(directory) {
+    const key = pathKey(directory);
+    if (this.packageJsonCache.has(key)) {
+      return this.packageJsonCache.get(key) ?? null;
+    }
+    const json = readJsonFile(path.join(directory, "package.json"), this.warnings);
+    this.packageJsonCache.set(key, json);
+    return json;
+  }
+  configFor(startDirectory) {
+    const visited = [];
+    let directory = path.resolve(startDirectory);
+    while (true) {
+      const key = pathKey(directory);
+      const cached = this.configCache.get(key);
+      if (cached !== void 0) {
+        for (const visitedKey of visited) this.configCache.set(visitedKey, cached);
+        return cached;
+      }
+      visited.push(key);
+      const configPath = findTsConfig(directory);
+      if (configPath) {
+        const loaded = loadTsConfig(configPath, this.warnings);
+        for (const visitedKey of visited) this.configCache.set(visitedKey, loaded);
+        return loaded;
+      }
+      if (key === pathKey(this.root)) break;
+      const parent = path.dirname(directory);
+      if (parent === directory || !isWithin(this.root, parent)) break;
+      directory = parent;
+    }
+    for (const visitedKey of visited) this.configCache.set(visitedKey, null);
+    return null;
+  }
+};
+function pathKey(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function fileCandidates(base) {
+  const lower = base.toLowerCase();
+  if (lower.endsWith(".js")) {
+    const stem = base.slice(0, -3);
+    return [`${stem}.ts`, `${stem}.tsx`, `${stem}.d.ts`, base];
+  }
+  if (lower.endsWith(".jsx")) {
+    const stem = base.slice(0, -4);
+    return [`${stem}.tsx`, `${stem}.d.ts`, base];
+  }
+  if (lower.endsWith(".mjs")) {
+    return [`${base.slice(0, -4)}.mts`, base];
+  }
+  if (lower.endsWith(".cjs")) {
+    return [`${base.slice(0, -4)}.cts`, base];
+  }
+  if (path.extname(base) !== "") return [base];
+  return [
+    base,
+    ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
+  ];
+}
+function indexCandidates(directory) {
+  return SOURCE_EXTENSIONS.map(
+    (extension) => path.join(directory, `index${extension}`)
+  );
+}
+function findTsConfig(directory) {
+  for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const candidate = path.join(directory, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function loadTsConfig(configPath, warnings) {
+  const read = ts.readConfigFile(configPath, ts.sys.readFile);
+  if (read.error || read.config === void 0) {
+    warnings.push(
+      `no se pudo leer ${configPath}: ${read.error?.messageText ?? "configuraci\xF3n vac\xEDa"}`
+    );
+    return null;
+  }
+  const parsed = ts.parseJsonConfigFileContent(
+    read.config,
+    ts.sys,
+    path.dirname(configPath),
+    void 0,
+    configPath
+  );
+  const configDirectory = path.dirname(configPath);
+  const baseUrl = path.resolve(configDirectory, parsed.options.baseUrl ?? ".");
+  const paths = parsed.options.paths ?? {};
+  const aliases = [];
+  for (const [pattern, targets] of Object.entries(paths)) {
+    if (!Array.isArray(targets)) continue;
+    const star = pattern.indexOf("*");
+    const prefix = star === -1 ? pattern : pattern.slice(0, star);
+    const suffix = star === -1 ? "" : pattern.slice(star + 1);
+    const resolvedTargets = targets.filter((target) => typeof target === "string").map((target) => path.resolve(baseUrl, target));
+    if (resolvedTargets.length > 0) {
+      aliases.push({
+        prefix,
+        suffix,
+        wildcard: star !== -1,
+        targets: resolvedTargets
+      });
+    }
+  }
+  aliases.sort((left, right) => {
+    if (left.wildcard !== right.wildcard) return left.wildcard ? 1 : -1;
+    if (right.prefix.length !== left.prefix.length) {
+      return right.prefix.length - left.prefix.length;
+    }
+    return right.suffix.length - left.suffix.length;
+  });
+  return { configPath, baseUrl, aliases };
+}
+function matchAlias(aliases, specifier) {
+  for (const alias of aliases) {
+    if (!alias.wildcard) {
+      if (specifier === alias.prefix) return { targets: alias.targets };
+      continue;
+    }
+    if (specifier.startsWith(alias.prefix) && specifier.endsWith(alias.suffix) && specifier.length >= alias.prefix.length + alias.suffix.length) {
+      const wildcard = specifier.slice(
+        alias.prefix.length,
+        specifier.length - alias.suffix.length
+      );
+      return {
+        targets: alias.targets.map(
+          (target) => target.includes("*") ? target.replace(/\*/g, wildcard) : target
+        )
+      };
+    }
+  }
+  return null;
+}
+function packageExportTargets(exportsField, subpath) {
+  if (typeof exportsField === "string") {
+    return subpath === "." ? [exportsField] : [];
+  }
+  if (Array.isArray(exportsField)) {
+    return unique(
+      exportsField.flatMap((value) => packageExportTargets(value, subpath))
+    );
+  }
+  if (!isRecord(exportsField)) return [];
+  const keys = Object.keys(exportsField);
+  if (keys.length === 0) return [];
+  const usesSubpaths = keys.some(
+    (key) => key === "." || key.startsWith("./")
+  );
+  if (!usesSubpaths) {
+    return subpath === "." ? conditionTargets(exportsField) : [];
+  }
+  if (exportsField[subpath] !== void 0) {
+    return conditionTargets(exportsField[subpath]);
+  }
+  const wildcardKeys = keys.filter((key) => key.includes("*")).sort((left, right) => right.length - left.length);
+  for (const key of wildcardKeys) {
+    const wildcard = matchWildcardKey(key, subpath);
+    if (wildcard === null) continue;
+    return conditionTargets(exportsField[key]).map(
+      (target) => target.replace(/\*/g, wildcard)
+    );
+  }
+  return [];
+}
+function conditionTargets(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    return unique(value.flatMap((item) => conditionTargets(item)));
+  }
+  if (!isRecord(value)) return [];
+  const preferred = ["types", "import", "module", "default", "node", "require"];
+  const targets = [];
+  for (const key of preferred) {
+    if (key in value) targets.push(...conditionTargets(value[key]));
+  }
+  return unique(targets);
+}
+function matchWildcardKey(pattern, subpath) {
+  const star = pattern.indexOf("*");
+  if (star === -1) return null;
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix) || subpath.length < prefix.length + suffix.length) {
+    return null;
+  }
+  return subpath.slice(prefix.length, subpath.length - suffix.length);
+}
+function discoverWorkspaces(root, warnings) {
+  const rootJson = readJsonFile(path.join(root, "package.json"), warnings);
+  if (!rootJson) return [];
+  const patterns = workspacePatterns(rootJson.workspaces);
+  if (patterns.length === 0) return [];
+  const byName = /* @__PURE__ */ new Map();
+  const stack = [
+    { directory: root, relative: "", depth: 0 }
+  ];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current.relative !== "" && patterns.some((pattern) => pattern.test(current.relative))) {
+      const json = readJsonFile(
+        path.join(current.directory, "package.json"),
+        warnings
+      );
+      if (json && typeof json.name === "string") {
+        const existing = byName.get(json.name);
+        if (existing) {
+          warnings.push(
+            `workspace duplicado "${json.name}": ${path.relative(root, existing.dir)} y ${path.relative(root, current.directory)}`
+          );
+        } else {
+          byName.set(json.name, {
+            name: json.name,
+            dir: current.directory,
+            json
+          });
+        }
+      }
+    }
+    if (current.depth >= MAX_WORKSPACE_DEPTH) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(current.directory, { withFileTypes: true });
+    } catch (error) {
+      warnings.push(
+        `no se pudo leer ${current.relative || "."}: ${error.message}`
+      );
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      if (WORKSPACE_SKIP_DIRS.has(entry.name)) continue;
+      stack.push({
+        directory: path.join(current.directory, entry.name),
+        relative: current.relative ? `${current.relative}/${entry.name}` : entry.name,
+        depth: current.depth + 1
+      });
+    }
+  }
+  return [...byName.values()].sort(
+    (left, right) => left.dir < right.dir ? -1 : left.dir > right.dir ? 1 : 0
+  );
+}
+function workspacePatterns(value) {
+  const raw = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.packages) ? value.packages : [];
+  return raw.filter((item) => typeof item === "string").map(
+    (pattern) => globToRegExp(
+      pattern.replace(/\\/g, "/").replace(/\/+$/, "").replace(/\/package\.json$/, "")
+    )
+  );
+}
+function globToRegExp(glob) {
+  let source = "^";
+  for (let index = 0; index < glob.length; index++) {
+    const character = glob[index];
+    if (character === "*") {
+      if (glob[index + 1] === "*") {
+        index++;
+        if (glob[index + 1] === "/") {
+          index++;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (character === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(character);
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readJsonFile(file, warnings) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      warnings.push(`no se pudo leer ${file}: ${error.message}`);
+    }
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
+    return isRecord(parsed) ? parsed : null;
+  } catch (error) {
+    warnings.push(`JSON inv\xE1lido en ${file}: ${error.message}`);
+    return null;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// packages/parsers/src/graph.ts
+function buildGraph(files, links) {
+  const nodes = [...new Set(files)].sort(compareStrings);
+  const nodeSet = new Set(nodes);
+  const edgesByKey = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    if (!nodeSet.has(link.from) || !nodeSet.has(link.to)) continue;
+    const key = `${link.from}\0${link.to}`;
+    const existing = edgesByKey.get(key);
+    if (existing) {
+      existing.weight++;
+      if (link.typeOnly) existing.typeOnly++;
+    } else {
+      edgesByKey.set(key, {
+        from: link.from,
+        to: link.to,
+        weight: 1,
+        typeOnly: link.typeOnly ? 1 : 0
+      });
+    }
+  }
+  const edges = [...edgesByKey.values()].sort(
+    (left, right) => compareStrings(left.from, right.from) || compareStrings(left.to, right.to)
+  ).map((edge) => ({ ...edge, isCyclic: false }));
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    adjacency.set(node, []);
+    reverse.set(node, []);
+  }
+  for (const edge of edges) {
+    adjacency.get(edge.from)?.push(edge.to);
+    reverse.get(edge.to)?.push(edge.from);
+  }
+  for (const neighbors of adjacency.values()) neighbors.sort(compareStrings);
+  for (const neighbors of reverse.values()) neighbors.sort(compareStrings);
+  const components = stronglyConnectedComponents(nodes, adjacency, reverse);
+  const componentOf = /* @__PURE__ */ new Map();
+  components.forEach((component, index) => {
+    for (const node of component) componentOf.set(node, index);
+  });
+  const selfLoops = new Set(
+    edges.filter((edge) => edge.from === edge.to).map((edge) => edge.from)
+  );
+  const cycleComponents = /* @__PURE__ */ new Set();
+  components.forEach((component, index) => {
+    if (component.length > 1 || component.length === 1 && selfLoops.has(component[0])) {
+      cycleComponents.add(index);
+    }
+  });
+  const levels = componentLevels(components, edges, componentOf);
+  for (const edge of edges) {
+    const fromComponent = componentOf.get(edge.from);
+    const toComponent = componentOf.get(edge.to);
+    edge.isCyclic = fromComponent !== void 0 && fromComponent === toComponent && cycleComponents.has(fromComponent);
+  }
+  const metrics = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const component = componentOf.get(node);
+    if (component === void 0) continue;
+    metrics.set(node, {
+      fanIn: reverse.get(node)?.length ?? 0,
+      fanOut: adjacency.get(node)?.length ?? 0,
+      inCycle: cycleComponents.has(component) ? 1 : 0,
+      cycleSize: cycleComponents.has(component) ? components[component]?.length ?? 0 : 0,
+      dependencyLevel: levels[component] ?? 0
+    });
+  }
+  return {
+    edges,
+    metrics,
+    cycles: components.filter((_, index) => cycleComponents.has(index))
+  };
+}
+function stronglyConnectedComponents(nodes, adjacency, reverse) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of nodes) {
+    if (visited.has(start)) continue;
+    visited.add(start);
+    const stack = [{ node: start, neighbors: adjacency.get(start) ?? [], index: 0 }];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (frame.index < frame.neighbors.length) {
+        const next = frame.neighbors[frame.index++];
+        if (!visited.has(next)) {
+          visited.add(next);
+          stack.push({
+            node: next,
+            neighbors: adjacency.get(next) ?? [],
+            index: 0
+          });
+        }
+      } else {
+        order.push(frame.node);
+        stack.pop();
+      }
+    }
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  const components = [];
+  for (let index = order.length - 1; index >= 0; index--) {
+    const start = order[index];
+    if (assigned.has(start)) continue;
+    const component = [];
+    const stack = [start];
+    assigned.add(start);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      component.push(node);
+      for (const previous of reverse.get(node) ?? []) {
+        if (!assigned.has(previous)) {
+          assigned.add(previous);
+          stack.push(previous);
+        }
+      }
+    }
+    component.sort(compareStrings);
+    components.push(component);
+  }
+  components.sort(
+    (left, right) => compareStrings(left[0], right[0])
+  );
+  return components;
+}
+function componentLevels(components, edges, componentOf) {
+  const condensation = /* @__PURE__ */ new Map();
+  const indegree = new Array(components.length).fill(0);
+  for (const edge of edges) {
+    const from = componentOf.get(edge.from);
+    const to = componentOf.get(edge.to);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    const neighbors = condensation.get(from) ?? /* @__PURE__ */ new Set();
+    if (!neighbors.has(to)) {
+      neighbors.add(to);
+      condensation.set(from, neighbors);
+      indegree[to] = (indegree[to] ?? 0) + 1;
+    }
+  }
+  const levels = new Array(components.length).fill(0);
+  const queue = [];
+  for (let index = 0; index < components.length; index++) {
+    if (indegree[index] === 0) queue.push(index);
+  }
+  let cursor = 0;
+  while (cursor < queue.length) {
+    const current = queue[cursor++];
+    const neighbors = [...condensation.get(current) ?? []].sort(
+      (left, right) => left - right
+    );
+    for (const next of neighbors) {
+      levels[next] = Math.max(levels[next] ?? 0, (levels[current] ?? 0) + 1);
+      indegree[next] = (indegree[next] ?? 0) - 1;
+      if (indegree[next] === 0) queue.push(next);
+    }
+  }
+  return levels;
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// packages/parsers/src/analyze.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+
+// packages/schema/src/errors.ts
+var CcJsonError = class extends Error {
+  path;
+  constructor(message, path8) {
+    super(`${message} (en ${path8})`);
+    this.name = "CcJsonError";
+    this.path = path8;
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(value, path8) {
+  if (!isRecord2(value)) throw new CcJsonError("se esperaba un objeto", path8);
+  return value;
+}
+function requireString(value, path8, field5) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path8);
+  }
+  return value;
+}
+
+// packages/schema/src/identity.ts
+import { createHash } from "node:crypto";
+var ID_LENGTH = 16;
+function normalizeName(name) {
+  return name.normalize("NFC");
+}
+function pathSegments(path8) {
+  const segments = [];
+  for (const raw of path8.replace(/\\/g, "/").split("/")) {
+    const segment = normalizeName(raw);
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments;
+}
+function canonicalPath(segments) {
+  return `/${segments.map(normalizeName).join("/")}`;
+}
+function idFromCanonicalPath(path8, type = "File") {
+  const canonical = path8.startsWith("/") ? path8 : `/${path8}`;
+  return createHash("sha256").update(type + canonical, "utf8").digest("hex").slice(0, ID_LENGTH);
+}
+function nodeId(type, segments) {
+  return idFromCanonicalPath(canonicalPath(segments), type);
+}
+function fileId(path8) {
+  return nodeId("File", pathSegments(path8));
+}
+function folderId(path8) {
+  return nodeId("Folder", pathSegments(path8));
+}
+
+// packages/schema/src/legacy.ts
+var MAX_DEPTH = 512;
+function isLegacyCcJson(input) {
+  if (!isRecord2(input) || "files" in input) return false;
+  if ("data" in input) {
+    if (!isRecord2(input.data) || "files" in input.data) return false;
+    return "nodes" in input.data || typeof input.data.apiVersion === "string" && input.data.apiVersion.startsWith("1");
+  }
+  return "nodes" in input || typeof input.apiVersion === "string" && input.apiVersion.startsWith("1");
+}
+function normalizeLegacyCcJson(input) {
+  const outer = requireRecord(input, "$");
+  const wrapped = "data" in outer;
+  const payload = wrapped ? requireRecord(outer.data, "$.data") : outer;
+  const base = wrapped ? "$.data" : "$";
+  const version = payload.apiVersion;
+  if (version !== void 0) {
+    if (typeof version !== "string" || !/^1(?:\.|$)/.test(version)) {
+      throw new CcJsonError(`apiVersion "${String(version)}" no es 1.x`, `${base}.apiVersion`);
+    }
+  }
+  const nodesPath = `${base}.nodes`;
+  const nodesRaw = payload.nodes;
+  if (!Array.isArray(nodesRaw)) {
+    throw new CcJsonError('"nodes" debe ser un array', nodesPath);
+  }
+  if (nodesRaw.length === 0) {
+    throw new CcJsonError("el \xE1rbol est\xE1 vac\xEDo", nodesPath);
+  }
+  const roots = nodesRaw.map(
+    (node, index) => requireRecord(node, `${nodesPath}[${index}]`)
+  );
+  const rootNames = roots.map(
+    (root, index) => readNodeName(root.name, `${nodesPath}[${index}].name`)
+  );
+  const multipleRoots = roots.length > 1;
+  let syntheticName;
+  let treeRoot;
+  if (multipleRoots) {
+    syntheticName = rootNames.includes("root") ? "merged-root" : "root";
+    while (rootNames.includes(syntheticName)) syntheticName = `${syntheticName}_`;
+    treeRoot = {
+      name: syntheticName,
+      type: "Folder",
+      attributes: {},
+      children: roots
+    };
+  } else {
+    treeRoot = roots[0];
+  }
+  const metrics = {};
+  const built = [];
+  const ids = /* @__PURE__ */ new Map();
+  const buildNode = (value, parentPath, path8, depth) => {
+    if (depth > MAX_DEPTH) {
+      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path8);
+    }
+    const raw = requireRecord(value, path8);
+    const name = readNodeName(raw.name, `${path8}.name`);
+    const type = raw.type;
+    if (type !== "File" && type !== "Folder") {
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path8}.type`);
+    }
+    const fullPath = [...parentPath, name];
+    const id = nodeId(type, fullPath.slice(1));
+    const previous = ids.get(id);
+    if (previous !== void 0) {
+      throw new CcJsonError(
+        `id duplicado "${id}" para "${previous}" y "${fullPath.join("/")}"`,
+        `${path8}.name`
+      );
+    }
+    ids.set(id, fullPath.join("/"));
+    built.push({ id, name, fullPath: fullPath.join("/") });
+    const node = { id, name, type };
+    const attributes = readMetrics(raw.attributes, `${path8}.attributes`);
+    if (attributes) metrics[id] = attributes;
+    const contentHash = readOptionalString(raw.checksum) ?? readOptionalString(raw.contentHash);
+    if (contentHash) node.contentHash = contentHash;
+    const link = readOptionalString(raw.link);
+    if (link) node.link = link;
+    if (raw.children !== void 0) {
+      if (!Array.isArray(raw.children)) {
+        throw new CcJsonError('"children" debe ser un array', `${path8}.children`);
+      }
+      if (type === "File" && raw.children.length > 0) {
+        throw new CcJsonError("un fichero no puede tener hijos", `${path8}.children`);
+      }
+      if (type === "Folder" && raw.children.length > 0) {
+        node.children = raw.children.map(
+          (child, index) => buildNode(child, fullPath, `${path8}.children[${index}]`, depth + 1)
+        );
+      }
+    }
+    return node;
+  };
+  const files = [buildNode(treeRoot, [], multipleRoots ? "$.roots" : `${nodesPath}[0]`, 0)];
+  const pathIndex = buildPathIndex(built, multipleRoots);
+  const stripNames = /* @__PURE__ */ new Set(["root", ...rootNames]);
+  if (syntheticName) stripNames.add(syntheticName);
+  const edges = [];
+  const edgesRaw = payload.edges;
+  if (edgesRaw !== void 0) {
+    if (!Array.isArray(edgesRaw)) {
+      throw new CcJsonError('"edges" debe ser un array', `${base}.edges`);
+    }
+    edgesRaw.forEach((edge, index) => {
+      const path8 = `${base}.edges[${index}]`;
+      const raw = requireRecord(edge, path8);
+      const fromName = requireString(raw.fromNodeName, `${path8}.fromNodeName`, "fromNodeName");
+      const toName = requireString(raw.toNodeName, `${path8}.toNodeName`, "toNodeName");
+      const normalized = {
+        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path8}.fromNodeName`),
+        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path8}.toNodeName`)
+      };
+      const attributes = readMetrics(raw.attributes, `${path8}.attributes`);
+      if (attributes) normalized.attributes = attributes;
+      if (typeof raw.isCyclic === "boolean") normalized.isCyclic = raw.isCyclic;
+      if (typeof raw.isPointingUpwards === "boolean") {
+        normalized.isPointingUpwards = raw.isPointingUpwards;
+      }
+      edges.push(normalized);
+    });
+  }
+  const types = readAttributeTypes(payload.attributeTypes, `${base}.attributeTypes`);
+  const descriptorSections = readDescriptors(
+    payload.attributeDescriptors,
+    `${base}.attributeDescriptors`
+  );
+  const nodeMetricNames = new Set(Object.values(metrics).flatMap((row) => Object.keys(row)));
+  const edgeMetricNames = new Set(
+    edges.flatMap((edge) => Object.keys(edge.attributes ?? {}))
+  );
+  let nodeDescriptors = descriptorSections.nodes;
+  let edgeDescriptors = descriptorSections.edges;
+  if (descriptorSections.flat) {
+    const nodes = {};
+    const edgeMap = {};
+    for (const [name, descriptor] of Object.entries(descriptorSections.flat)) {
+      if (nodeMetricNames.has(name) || !edgeMetricNames.has(name)) nodes[name] = descriptor;
+      if (edgeMetricNames.has(name)) edgeMap[name] = descriptor;
+    }
+    if (Object.keys(nodes).length > 0) nodeDescriptors = nodes;
+    if (Object.keys(edgeMap).length > 0) edgeDescriptors = edgeMap;
+  }
+  const lenses = {};
+  const metricsLens = { attributes: metrics };
+  if (types.nodes && Object.keys(types.nodes).length > 0) {
+    metricsLens.attributeTypes = types.nodes;
+  }
+  if (nodeDescriptors && Object.keys(nodeDescriptors).length > 0) {
+    metricsLens.attributeDescriptors = nodeDescriptors;
+  }
+  if (Object.keys(metrics).length > 0 || metricsLens.attributeTypes !== void 0 || metricsLens.attributeDescriptors !== void 0) {
+    lenses.metrics = metricsLens;
+  }
+  const dependency = {};
+  if (edges.length > 0) dependency.edges = edges;
+  if (types.edges && Object.keys(types.edges).length > 0) {
+    dependency.attributeTypes = types.edges;
+  }
+  if (edgeDescriptors && Object.keys(edgeDescriptors).length > 0) {
+    dependency.attributeDescriptors = edgeDescriptors;
+  }
+  if (Object.keys(dependency).length > 0) lenses.dependency = dependency;
+  const meta = { apiVersion: "2.0" };
+  const projectName = readOptionalString(payload.projectName);
+  if (projectName) meta.projectName = projectName;
+  const commitHash = readOptionalString(payload.commitHash);
+  if (commitHash) meta.commitHash = commitHash;
+  return {
+    meta,
+    files,
+    ...Object.keys(lenses).length > 0 ? { lenses } : {}
+  };
+}
+function buildPathIndex(built, multipleRoots) {
+  const index = /* @__PURE__ */ new Map();
+  const add = (key, id) => {
+    if (key !== "" && !index.has(key)) index.set(key, id);
+  };
+  for (const node of built) add(node.fullPath, node.id);
+  for (const node of built) {
+    const segments = node.fullPath.split("/");
+    if (segments.length > 1) add(segments.slice(1).join("/"), node.id);
+    const relative = segments.slice(multipleRoots ? 2 : 1).join("/");
+    if (relative !== "") {
+      add(relative, node.id);
+      add(`root/${relative}`, node.id);
+    } else if (segments.length === 1) {
+      add("root", node.id);
+    }
+  }
+  const nameCounts = /* @__PURE__ */ new Map();
+  for (const node of built) nameCounts.set(node.name, (nameCounts.get(node.name) ?? 0) + 1);
+  for (const node of built) {
+    if (nameCounts.get(node.name) === 1) add(node.name, node.id);
+  }
+  return index;
+}
+function resolveEndpoint(endpoint, index, stripNames, path8) {
+  const segments = canonicalSegments(endpoint);
+  if (segments.length === 0) {
+    throw new CcJsonError("extremo de arista vac\xEDo", path8);
+  }
+  const candidates = [segments.join("/")];
+  if (segments.length > 1 && stripNames.has(segments[0])) {
+    candidates.push(segments.slice(1).join("/"));
+  }
+  for (const candidate of candidates) {
+    const id = index.get(candidate);
+    if (id) return id;
+  }
+  const bare = index.get(segments[segments.length - 1]);
+  if (bare) return bare;
+  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path8);
+}
+function canonicalSegments(value) {
+  const result = [];
+  for (const raw of value.replace(/\\/g, "/").split("/")) {
+    const segment = raw.normalize("NFC");
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      result.pop();
+      continue;
+    }
+    result.push(segment);
+  }
+  return result;
+}
+function readNodeName(value, path8) {
+  const name = normalizeName(requireString(value, path8, "name"));
+  if (name === "." || name === "..") {
+    throw new CcJsonError('el nombre no puede ser "." ni ".."', path8);
+  }
+  if (name.includes("/")) {
+    throw new CcJsonError('el nombre no puede contener "/"', path8);
+  }
+  return name;
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readMetrics(value, path8) {
+  if (value === void 0) return void 0;
+  const raw = requireRecord(value, path8);
+  const out = {};
+  for (const [metric, metricValue] of Object.entries(raw)) {
+    if (typeof metricValue !== "number" || !Number.isFinite(metricValue)) {
+      throw new CcJsonError(
+        `la m\xE9trica "${metric}" debe ser un n\xFAmero finito`,
+        `${path8}["${metric}"]`
+      );
+    }
+    out[metric] = metricValue;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function readAttributeTypes(value, path8) {
+  if (value === void 0) return {};
+  const raw = requireRecord(value, path8);
+  if ("nodes" in raw || "edges" in raw) {
+    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path8}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path8}.edges`);
+    return {
+      ...nodes2 && Object.keys(nodes2).length > 0 ? { nodes: nodes2 } : {},
+      ...edges && Object.keys(edges).length > 0 ? { edges } : {}
+    };
+  }
+  const nodes = readTypeMap(raw, path8);
+  return Object.keys(nodes).length > 0 ? { nodes } : {};
+}
+function readTypeMap(value, path8) {
+  const raw = requireRecord(value, path8);
+  const out = {};
+  for (const [metric, type] of Object.entries(raw)) {
+    if (type !== "absolute" && type !== "relative") {
+      throw new CcJsonError(
+        `el tipo de "${metric}" debe ser "absolute" o "relative"`,
+        `${path8}["${metric}"]`
+      );
+    }
+    out[metric] = type;
+  }
+  return out;
+}
+function readDescriptors(value, path8) {
+  if (value === void 0) return {};
+  const raw = requireRecord(value, path8);
+  if ("nodes" in raw || "edges" in raw) {
+    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path8}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path8}.edges`);
+    return {
+      ...nodes && Object.keys(nodes).length > 0 ? { nodes } : {},
+      ...edges && Object.keys(edges).length > 0 ? { edges } : {}
+    };
+  }
+  const flat = readDescriptorMap(raw, path8);
+  return Object.keys(flat).length > 0 ? { flat } : {};
+}
+function readDescriptorMap(value, path8) {
+  const raw = requireRecord(value, path8);
+  const out = {};
+  for (const [metric, descriptor] of Object.entries(raw)) {
+    const record = requireRecord(descriptor, `${path8}["${metric}"]`);
+    if (record.direction !== void 0 && typeof record.direction !== "number") {
+      throw new CcJsonError(
+        `"direction" de "${metric}" debe ser un n\xFAmero`,
+        `${path8}["${metric}"].direction`
+      );
+    }
+    out[metric] = record;
+  }
+  return out;
+}
+
+// packages/schema/src/parse.ts
+var MAX_DEPTH2 = 512;
+function parseCcJson(input) {
+  if (!isRecord2(input)) throw new CcJsonError("se esperaba un objeto", "$");
+  if (isLegacyCcJson(input)) return normalizeLegacyCcJson(input);
+  const metaRaw = requireRecord(input.meta, "$.meta");
+  const apiVersion = requireString(metaRaw.apiVersion, "$.meta.apiVersion", "apiVersion");
+  if (!apiVersion.startsWith("2.")) {
+    throw new CcJsonError(
+      `apiVersion "${apiVersion}" no soportada (se espera 2.x)`,
+      "$.meta.apiVersion"
+    );
+  }
+  const filesRaw = input.files;
+  if (filesRaw === void 0) throw new CcJsonError('falta "files"', "$");
+  const roots = Array.isArray(filesRaw) ? filesRaw : [filesRaw];
+  if (roots.length === 0) throw new CcJsonError("el \xE1rbol est\xE1 vac\xEDo", "$.files");
+  const ids = /* @__PURE__ */ new Set();
+  const validateNode = (value, path8, depth) => {
+    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path8);
+    const raw = requireRecord(value, path8);
+    const id = requireString(raw.id, `${path8}.id`, "id");
+    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path8}.id`);
+    ids.add(id);
+    const name = requireString(raw.name, `${path8}.name`, "name");
+    const type = raw.type;
+    if (type !== "File" && type !== "Folder") {
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path8}.type`);
+    }
+    const node = { id, name, type };
+    if (typeof raw.contentHash === "string") node.contentHash = raw.contentHash;
+    if (typeof raw.link === "string") node.link = raw.link;
+    if (raw.children !== void 0) {
+      if (!Array.isArray(raw.children)) {
+        throw new CcJsonError('"children" debe ser un array', `${path8}.children`);
+      }
+      node.children = raw.children.map(
+        (child, index) => validateNode(child, `${path8}.children[${index}]`, depth + 1)
+      );
+    }
+    return node;
+  };
+  const files = roots.map((root, index) => validateNode(root, `$.files[${index}]`, 0));
+  const lensesRaw = input.lenses;
+  if (lensesRaw !== void 0) {
+    const lenses = requireRecord(lensesRaw, "$.lenses");
+    if (lenses.metrics !== void 0) {
+      const metrics = requireRecord(lenses.metrics, "$.lenses.metrics");
+      const attributes = requireRecord(metrics.attributes, "$.lenses.metrics.attributes");
+      for (const [nodeId2, values] of Object.entries(attributes)) {
+        const row = requireRecord(values, `$.lenses.metrics.attributes["${nodeId2}"]`);
+        for (const [metric, value] of Object.entries(row)) {
+          if (typeof value !== "number" || !Number.isFinite(value)) {
+            throw new CcJsonError(
+              `la m\xE9trica "${metric}" debe ser un n\xFAmero finito`,
+              `$.lenses.metrics.attributes["${nodeId2}"].${metric}`
+            );
+          }
+        }
+      }
+    }
+    if (lenses.dependency !== void 0) {
+      const dependency = requireRecord(lenses.dependency, "$.lenses.dependency");
+      if (dependency.edges !== void 0) {
+        if (!Array.isArray(dependency.edges)) {
+          throw new CcJsonError('"edges" debe ser un array', "$.lenses.dependency.edges");
+        }
+        dependency.edges.forEach((edge, index) => {
+          const path8 = `$.lenses.dependency.edges[${index}]`;
+          const raw = requireRecord(edge, path8);
+          requireString(raw.fromId, `${path8}.fromId`, "fromId");
+          requireString(raw.toId, `${path8}.toId`, "toId");
+        });
+      }
+    }
+  }
+  const meta = { ...metaRaw, apiVersion };
+  return {
+    meta,
+    files,
+    ...lensesRaw !== void 0 ? { lenses: lensesRaw } : {}
+  };
+}
+
+// packages/schema/src/tree.ts
+function walkTree(roots, visit) {
+  const stack = roots.map((node) => ({ node, path: node.name, depth: 0 })).reverse();
+  while (stack.length > 0) {
+    const entry = stack.pop();
+    visit(entry);
+    const children = entry.node.children;
+    if (!children || children.length === 0) continue;
+    for (let index = children.length - 1; index >= 0; index--) {
+      const child = children[index];
+      stack.push({
+        node: child,
+        path: `${entry.path}/${child.name}`,
+        depth: entry.depth + 1
+      });
+    }
+  }
+}
+function walkFiles(roots, visit) {
+  walkTree(roots, (entry) => {
+    if (entry.node.type === "File") visit(entry);
+  });
+}
+function pathById(roots) {
+  const map = /* @__PURE__ */ new Map();
+  walkTree(roots, (entry) => map.set(entry.node.id, entry.path));
+  return map;
+}
+
+// packages/schema/src/stats.ts
+function getStats(cc) {
+  let files = 0;
+  let folders = 0;
+  let maxDepth = 0;
+  walkTree(cc.files, (entry) => {
+    maxDepth = Math.max(maxDepth, entry.depth);
+    if (entry.node.type === "File") files++;
+    else folders++;
+  });
+  const coverage = /* @__PURE__ */ new Map();
+  const attributes = cc.lenses?.metrics?.attributes ?? {};
+  for (const values of Object.values(attributes)) {
+    for (const metric of Object.keys(values)) {
+      coverage.set(metric, (coverage.get(metric) ?? 0) + 1);
+    }
+  }
+  const knownIds = new Set(pathById(cc.files).keys());
+  let orphanMetricNodes = 0;
+  for (const id of Object.keys(attributes)) {
+    if (!knownIds.has(id)) orphanMetricNodes++;
+  }
+  const dependency = cc.lenses?.dependency;
+  return {
+    files,
+    folders,
+    maxDepth,
+    lenses: Object.keys(cc.lenses ?? {}),
+    metricNames: coverage.size,
+    metricCoverage: [...coverage.entries()].map(([name, count]) => ({ name, files: count })).sort((a, b) => b.files - a.files || a.name.localeCompare(b.name)),
+    edges: dependency?.edges?.length ?? 0,
+    leafEdges: dependency?.leafEdges?.length ?? 0,
+    orphanMetricNodes
+  };
+}
+function topByMetric(cc, metric, limit = 10) {
+  const attributes = cc.lenses?.metrics?.attributes ?? {};
+  const paths = pathById(cc.files);
+  const ranked = [];
+  for (const [id, values] of Object.entries(attributes)) {
+    const value = values[metric];
+    const path8 = paths.get(id);
+    if (value === void 0 || path8 === void 0) continue;
+    ranked.push({ id, path: path8, value });
+  }
+  ranked.sort((a, b) => b.value - a.value || a.path.localeCompare(b.path));
+  return ranked.slice(0, limit);
+}
+function defaultMetric(stats) {
+  if (stats.metricCoverage.some((metric) => metric.name === "rloc")) return "rloc";
+  return stats.metricCoverage[0]?.name;
+}
+
+// packages/parsers/src/git.ts
+import { spawnSync } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var COMMIT_PREFIX = "__CODARCH_COMMIT__";
+var DEFAULT_MAX_BUFFER = 128 * 1024 * 1024;
+var EMPTY = {
+  metrics: /* @__PURE__ */ new Map(),
+  commits: 0,
+  authors: 0,
+  shallow: false,
+  enabled: false,
+  warnings: []
+};
+function collectGitChurn(rootInput, files, options = {}) {
+  if (options.enabled === false || files.length === 0) {
+    return { ...EMPTY, metrics: /* @__PURE__ */ new Map() };
+  }
+  const root = realPath(rootInput);
+  const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+  const warnings = [];
+  const topLevel = runGit(root, ["rev-parse", "--show-toplevel"], maxBuffer);
+  if (!topLevel.ok) {
+    return {
+      ...EMPTY,
+      metrics: /* @__PURE__ */ new Map(),
+      warnings: [`no hay historial git utilizable: ${topLevel.error}`]
+    };
+  }
+  const repoRoot = realPath(topLevel.stdout.trim());
+  const shallowResult = runGit(
+    repoRoot,
+    ["rev-parse", "--is-shallow-repository"],
+    maxBuffer
+  );
+  const shallow = shallowResult.ok && shallowResult.stdout.trim().toLowerCase() === "true";
+  if (shallow) {
+    warnings.push(
+      "el repositorio es shallow: el churn puede estar incompleto"
+    );
+  }
+  const log = runGit(
+    repoRoot,
+    [
+      "-c",
+      "core.quotePath=false",
+      "log",
+      "--no-merges",
+      "--numstat",
+      `--format=${COMMIT_PREFIX}%H%x09%ae`
+    ],
+    maxBuffer
+  );
+  if (!log.ok) {
+    return {
+      ...EMPTY,
+      shallow,
+      warnings: [...warnings, `no se pudo leer git log: ${log.error}`]
+    };
+  }
+  const wanted = new Set(files);
+  const commitsByFile = /* @__PURE__ */ new Map();
+  const authorsByFile = /* @__PURE__ */ new Map();
+  const authors = /* @__PURE__ */ new Set();
+  let commits = 0;
+  let currentAuthor = "";
+  let touched = /* @__PURE__ */ new Set();
+  const flushCommit = () => {
+    if (!currentAuthor || touched.size === 0) return;
+    commits++;
+    authors.add(currentAuthor);
+    for (const file of touched) {
+      commitsByFile.set(file, (commitsByFile.get(file) ?? 0) + 1);
+      let fileAuthors = authorsByFile.get(file);
+      if (!fileAuthors) {
+        fileAuthors = /* @__PURE__ */ new Set();
+        authorsByFile.set(file, fileAuthors);
+      }
+      fileAuthors.add(currentAuthor);
+    }
+    touched = /* @__PURE__ */ new Set();
+    currentAuthor = "";
+  };
+  for (const rawLine of log.stdout.split(/\r?\n/)) {
+    if (rawLine.startsWith(COMMIT_PREFIX)) {
+      flushCommit();
+      const fields2 = rawLine.slice(COMMIT_PREFIX.length).split("	");
+      const author = fields2[1]?.trim() ?? "";
+      currentAuthor = author || "(sin autor)";
+      continue;
+    }
+    if (!currentAuthor || rawLine === "") continue;
+    const fields = rawLine.split("	");
+    if (fields.length < 3) continue;
+    const gitPath = fields.slice(2).join("	");
+    if (!gitPath) continue;
+    const relative = path2.relative(root, path2.resolve(repoRoot, gitPath));
+    if (relative === "" || relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+      continue;
+    }
+    const normalized = relative.split(path2.sep).join("/");
+    if (!wanted.has(normalized)) continue;
+    touched.add(normalized);
+  }
+  flushCommit();
+  const metrics = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    metrics.set(file, {
+      commits: commitsByFile.get(file) ?? 0,
+      authors: authorsByFile.get(file)?.size ?? 0
+    });
+  }
+  return {
+    metrics,
+    commits,
+    authors: authors.size,
+    shallow,
+    enabled: true,
+    warnings
+  };
+}
+function realPath(input) {
+  const resolved = path2.resolve(input);
+  try {
+    return fs2.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function runGit(cwd, args, maxBuffer) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer,
+    windowsHide: true
+  });
+  if (result.error) {
+    return { ok: false, stdout: "", error: result.error.message };
+  }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      stdout: result.stdout ?? "",
+      error: (result.stderr ?? "").trim() || `git exited with ${result.status}`
+    };
+  }
+  return { ok: true, stdout: result.stdout ?? "", error: "" };
+}
+
+// packages/parsers/src/snapshot.ts
+import { createHash as createHash2 } from "node:crypto";
+var METRIC_DESCRIPTORS = {
+  loc: {
+    title: "L\xEDneas",
+    description: "L\xEDneas f\xEDsicas del fichero",
+    direction: -1
+  },
+  rloc: {
+    title: "L\xEDneas de c\xF3digo",
+    description: "L\xEDneas con al menos un token de c\xF3digo",
+    direction: -1
+  },
+  functions: {
+    title: "Funciones",
+    description: "Funciones, m\xE9todos y arrows implementados",
+    direction: 0
+  },
+  maxComplexity: {
+    title: "Complejidad m\xE1x.",
+    description: "Complejidad ciclom\xE1tica de la funci\xF3n m\xE1s compleja",
+    direction: -1
+  },
+  maxFunctionLength: {
+    title: "Funci\xF3n m\xE1s larga",
+    description: "L\xEDneas de la funci\xF3n m\xE1s larga",
+    direction: -1
+  },
+  number_of_commits: {
+    title: "Commits",
+    description: "Commits que tocaron el fichero",
+    direction: -1
+  },
+  number_of_authors: {
+    title: "Autores",
+    description: "Autores \xFAnicos que tocaron el fichero",
+    direction: 0
+  },
+  imports: {
+    title: "Imports",
+    description: "Imports y reexports declarados",
+    direction: 0
+  },
+  externalImports: {
+    title: "Imports externos",
+    description: "Paquetes fuera del proyecto, sin builtins de Node",
+    direction: -1
+  },
+  builtinImports: {
+    title: "Builtins",
+    description: "M\xF3dulos nativos de Node",
+    direction: 0
+  },
+  typeOnlyImports: {
+    title: "Imports type-only",
+    description: "Imports que solo existen en tipos",
+    direction: 0
+  },
+  unresolvedImports: {
+    title: "Imports sin resolver",
+    description: "Specifiers internos que no apuntan a un fichero analizado",
+    direction: -1
+  },
+  fanIn: {
+    title: "Fan-in",
+    description: "Ficheros que importan a este",
+    direction: 1
+  },
+  fanOut: {
+    title: "Fan-out",
+    description: "Ficheros importados por este",
+    direction: -1
+  },
+  inCycle: {
+    title: "En ciclo",
+    description: "Pertenece a un ciclo de dependencias",
+    direction: -1
+  },
+  cycleSize: {
+    title: "Tama\xF1o del ciclo",
+    description: "Ficheros en su componente c\xEDclico",
+    direction: -1
+  },
+  dependencyLevel: {
+    title: "Nivel de dependencia",
+    description: "Profundidad en el DAG de dependencias",
+    direction: 0
+  }
+};
+var METRIC_ORDER = Object.keys(METRIC_DESCRIPTORS);
+var EDGE_DESCRIPTORS = {
+  weight: {
+    title: "Peso",
+    description: "N\xFAmero de imports entre los dos ficheros",
+    direction: 0
+  },
+  typeOnly: {
+    title: "Type-only",
+    description: "Imports de solo tipos",
+    direction: 0
+  }
+};
+function buildSnapshot(input) {
+  const files = [...input.files].sort(
+    (left, right) => compareStrings2(left.relativePath, right.relativePath)
+  );
+  const rootName = sanitizeNodeName(input.projectName);
+  const root = {
+    id: folderId(""),
+    name: rootName,
+    type: "Folder",
+    children: []
+  };
+  const folders = /* @__PURE__ */ new Map([["", root]]);
+  const attributes = {};
+  const metricNames = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const segments = file.relativePath.split("/");
+    const fileName = segments.pop();
+    if (!fileName) continue;
+    let parentPath = "";
+    let parent = root;
+    for (const segment of segments) {
+      const folderPath = parentPath ? `${parentPath}/${segment}` : segment;
+      let folder = folders.get(folderPath);
+      if (!folder) {
+        folder = {
+          id: folderId(folderPath),
+          name: segment,
+          type: "Folder",
+          children: []
+        };
+        folders.set(folderPath, folder);
+        parent.children?.push(folder);
+      }
+      parent = folder;
+      parentPath = folderPath;
+    }
+    const node = {
+      id: fileId(file.relativePath),
+      name: fileName,
+      type: "File"
+    };
+    parent.children?.push(node);
+    attributes[node.id] = { ...file.metrics };
+    for (const metric of Object.keys(file.metrics)) metricNames.add(metric);
+  }
+  sortChildren(root);
+  const presentMetrics = METRIC_ORDER.filter((metric) => metricNames.has(metric));
+  for (const metric of metricNames) {
+    if (!presentMetrics.includes(metric)) presentMetrics.push(metric);
+  }
+  const descriptors = {};
+  const attributeTypes = {};
+  for (const metric of presentMetrics) {
+    const descriptor = METRIC_DESCRIPTORS[metric];
+    if (descriptor) descriptors[metric] = descriptor;
+    attributeTypes[metric] = "absolute";
+  }
+  const edges = input.graph.edges.map((edge) => ({
+    fromId: fileId(edge.from),
+    toId: fileId(edge.to),
+    attributes: { weight: edge.weight, typeOnly: edge.typeOnly },
+    isCyclic: edge.isCyclic
+  }));
+  const dependencyNodes = {};
+  for (const [path8, metrics] of input.graph.metrics) {
+    dependencyNodes[fileId(path8)] = { level: metrics.dependencyLevel };
+  }
+  const lenses = {
+    metrics: {
+      attributes,
+      attributeDescriptors: descriptors,
+      attributeTypes
+    },
+    dependency: {
+      edges,
+      nodes: dependencyNodes,
+      attributeDescriptors: EDGE_DESCRIPTORS,
+      attributeTypes: {
+        weight: "absolute",
+        typeOnly: "absolute"
+      }
+    }
+  };
+  return {
+    meta: {
+      projectName: input.projectName,
+      apiVersion: "2.0",
+      checksum: checksumFor([root], lenses)
+    },
+    files: [root],
+    lenses
+  };
+}
+function checksumFor(files, lenses) {
+  return createHash2("md5").update(stableStringify({ files, lenses }), "utf8").digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+  }
+  return "null";
+}
+function sortChildren(node) {
+  if (!node.children) return;
+  node.children.sort((left, right) => {
+    if (left.type !== right.type) return left.type === "Folder" ? -1 : 1;
+    return compareStrings2(left.name, right.name);
+  });
+  for (const child of node.children) sortChildren(child);
+}
+function sanitizeNodeName(name) {
+  const sanitized = name.replace(/[\\/]/g, "-").trim();
+  return sanitized && sanitized !== "." && sanitized !== ".." ? sanitized : "Proyecto";
+}
+function compareStrings2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// packages/parsers/src/walk.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import ignore from "ignore";
+var DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+var ALWAYS_IGNORED = [".git", "node_modules", ".codarch"];
+function walkSourceFiles(rootInput, options = {}) {
+  const root = path3.resolve(rootInput);
+  const stat = fs3.statSync(root);
+  if (!stat.isDirectory()) {
+    throw new Error(`no es un directorio: ${rootInput}`);
+  }
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const warnings = [];
+  const files = [];
+  const rootMatcher = ignore().add(ALWAYS_IGNORED);
+  for (const pattern of options.ignore ?? []) rootMatcher.add(pattern);
+  const rootGitignore = readGitignore(root, "", warnings);
+  if (rootGitignore) rootMatcher.add(rootGitignore);
+  const initialLayers = [{ base: "", matcher: rootMatcher }];
+  const stack = [
+    { absolutePath: root, relativePath: "", layers: initialLayers }
+  ];
+  while (stack.length > 0) {
+    const directory = stack.pop();
+    let entries;
+    try {
+      entries = fs3.readdirSync(directory.absolutePath, { withFileTypes: true });
+    } catch (error) {
+      warnings.push(
+        `no se pudo leer ${directory.relativePath || "."}: ${error.message}`
+      );
+      continue;
+    }
+    entries.sort(
+      (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
+    );
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const relativePath2 = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
+      const absolutePath = path3.join(directory.absolutePath, entry.name);
+      if (entry.isDirectory()) {
+        if (isIgnored(directory.layers, relativePath2, true)) continue;
+        const nested = readGitignore(absolutePath, relativePath2, warnings);
+        const layers = nested ? [...directory.layers, { base: relativePath2, matcher: ignore().add(nested) }] : directory.layers;
+        stack.push({ absolutePath, relativePath: relativePath2, layers });
+      } else if (entry.isFile()) {
+        if (isIgnored(directory.layers, relativePath2, false)) continue;
+        if (!matchesExtension(entry.name, extensions)) continue;
+        files.push({ absolutePath, relativePath: relativePath2 });
+      }
+    }
+  }
+  files.sort(
+    (left, right) => left.relativePath < right.relativePath ? -1 : left.relativePath > right.relativePath ? 1 : 0
+  );
+  warnings.sort();
+  return { files, warnings };
+}
+function readGitignore(directory, relativeBase, warnings) {
+  const file = path3.join(directory, ".gitignore");
+  try {
+    return fs3.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      warnings.push(
+        `no se pudo leer ${relativeBase ? `${relativeBase}/` : ""}.gitignore: ${error.message}`
+      );
+    }
+    return null;
+  }
+}
+function isIgnored(layers, relativePath2, isDirectory) {
+  let ignored = false;
+  for (const layer of layers) {
+    const localPath = layer.base ? relativePath2.slice(layer.base.length + 1) : relativePath2;
+    if (!localPath) continue;
+    const probe = isDirectory ? `${localPath}/` : localPath;
+    const result = layer.matcher.test(probe);
+    if (result.ignored) ignored = true;
+    else if (result.unignored) ignored = false;
+  }
+  return ignored;
+}
+function matchesExtension(name, extensions) {
+  const lower = name.toLowerCase();
+  return extensions.some((extension) => lower.endsWith(extension));
+}
+
+// packages/parsers/src/analyze.ts
+function analyzeRepository(rootInput, options = {}) {
+  const started = Date.now();
+  const root = path4.resolve(rootInput);
+  const projectName = options.projectName ?? readProjectName(root);
+  const walked = walkSourceFiles(root, {
+    ignore: options.ignore,
+    extensions: options.extensions
+  });
+  const warnings = [...walked.warnings];
+  const resolver = new ImportResolver(root, walked.files);
+  warnings.push(...resolver.warnings);
+  const parser = new TypeScriptParser();
+  const parsedFiles = [];
+  const links = [];
+  const unresolved = [];
+  let externalImports = 0;
+  let builtinImports = 0;
+  let typeOnlyImports = 0;
+  for (const file of walked.files) {
+    let source;
+    try {
+      source = fs4.readFileSync(file.absolutePath, "utf8");
+    } catch (error) {
+      warnings.push(
+        `no se pudo leer ${file.relativePath}: ${error.message}`
+      );
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = parser.parse(source, file.relativePath);
+    } catch (error) {
+      warnings.push(
+        `no se pudo analizar ${file.relativePath}: ${error.message}`
+      );
+      continue;
+    }
+    let fileExternalImports = 0;
+    let fileBuiltinImports = 0;
+    let fileTypeOnlyImports = 0;
+    let fileUnresolvedImports = 0;
+    for (const imported of parsed.imports) {
+      if (imported.typeOnly) fileTypeOnlyImports++;
+      const result = resolver.resolve(file.absolutePath, imported.specifier);
+      if (result.kind === "internal") {
+        links.push({
+          from: file.relativePath,
+          to: result.file.relativePath,
+          typeOnly: imported.typeOnly
+        });
+      } else if (result.kind === "external") {
+        if (result.builtin) fileBuiltinImports++;
+        else fileExternalImports++;
+      } else {
+        fileUnresolvedImports++;
+        unresolved.push({
+          file: file.relativePath,
+          line: imported.line,
+          specifier: imported.specifier,
+          reason: result.reason
+        });
+      }
+    }
+    externalImports += fileExternalImports;
+    builtinImports += fileBuiltinImports;
+    typeOnlyImports += fileTypeOnlyImports;
+    parsedFiles.push({
+      relativePath: file.relativePath,
+      metrics: {
+        ...parsed.metrics,
+        imports: parsed.imports.length,
+        externalImports: fileExternalImports,
+        builtinImports: fileBuiltinImports,
+        typeOnlyImports: fileTypeOnlyImports,
+        unresolvedImports: fileUnresolvedImports
+      }
+    });
+  }
+  const git = collectGitChurn(
+    root,
+    parsedFiles.map((file) => file.relativePath),
+    { enabled: options.git !== false }
+  );
+  warnings.push(...git.warnings);
+  if (git.enabled) {
+    for (const file of parsedFiles) {
+      const churn = git.metrics.get(file.relativePath);
+      if (!churn) continue;
+      file.metrics.number_of_commits = churn.commits;
+      file.metrics.number_of_authors = churn.authors;
+    }
+  }
+  const graph = buildGraph(
+    parsedFiles.map((file) => file.relativePath),
+    links
+  );
+  for (const file of parsedFiles) {
+    const metrics = graph.metrics.get(file.relativePath);
+    if (metrics) {
+      file.metrics.fanIn = metrics.fanIn;
+      file.metrics.fanOut = metrics.fanOut;
+      file.metrics.inCycle = metrics.inCycle;
+      file.metrics.cycleSize = metrics.cycleSize;
+      file.metrics.dependencyLevel = metrics.dependencyLevel;
+    }
+  }
+  if (unresolved.length > 0) {
+    warnings.push(
+      `${unresolved.length} imports sin resolver; se excluyen del grafo`
+    );
+  }
+  const snapshot = buildSnapshot({
+    projectName,
+    files: parsedFiles,
+    graph
+  });
+  let folders = 0;
+  walkTree(snapshot.files, (entry) => {
+    if (entry.node.type === "Folder" && entry.depth > 0) folders++;
+  });
+  const metricNames = /* @__PURE__ */ new Set();
+  for (const file of parsedFiles) {
+    for (const metric of Object.keys(file.metrics)) metricNames.add(metric);
+  }
+  warnings.sort();
+  return {
+    snapshot,
+    files: parsedFiles.length,
+    folders,
+    edges: graph.edges.length,
+    cycles: graph.cycles,
+    metricNames: [...metricNames].sort(),
+    warnings,
+    unresolved,
+    externalImports,
+    builtinImports,
+    typeOnlyImports,
+    unresolvedImports: unresolved.length,
+    git: {
+      enabled: git.enabled,
+      commits: git.commits,
+      authors: git.authors,
+      shallow: git.shallow
+    },
+    durationMs: Date.now() - started
+  };
+}
+function readProjectName(root) {
+  try {
+    const text = fs4.readFileSync(path4.join(root, "package.json"), "utf8");
+    const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.name === "string") {
+      const name = parsed.name.trim();
+      if (name) return name;
+    }
+  } catch {
+  }
+  return path4.basename(root) || "Proyecto";
+}
+
+// packages/metrics/src/config.ts
+import fs5 from "node:fs";
+import { parse as parseYaml } from "yaml";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var SEVERITIES = /* @__PURE__ */ new Set(["info", "warn", "error"]);
+function parseRuleConfig(input) {
+  const root = asObject(input, "config");
+  if (root.version !== 1) {
+    throw new ConfigError("config.version debe ser 1");
+  }
+  const layers = parseLayers(root.layers);
+  const layerNames = new Set(layers.map((layer) => layer.name));
+  const rules = parseRules(root.rules, layerNames);
+  return { version: 1, layers, rules };
+}
+function loadRuleConfig(file) {
+  let text;
+  try {
+    text = fs5.readFileSync(file, "utf8");
+  } catch (error) {
+    throw new ConfigError(
+      `no se pudo leer ${file}: ${error.message}`
+    );
+  }
+  let value;
+  try {
+    value = parseYaml(text);
+  } catch (error) {
+    throw new ConfigError(
+      `YAML inv\xE1lido en ${file}: ${error.message}`
+    );
+  }
+  try {
+    return parseRuleConfig(value);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw new ConfigError(`${file}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function parseLayers(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new ConfigError("config.layers debe ser una lista");
+  }
+  const layers = [];
+  const names = /* @__PURE__ */ new Set();
+  value.forEach((raw, index) => {
+    const layer = asObject(raw, `config.layers[${index}]`);
+    const name = asString(layer.name, `config.layers[${index}].name`);
+    if (names.has(name)) {
+      throw new ConfigError(`capa duplicada: ${name}`);
+    }
+    names.add(name);
+    if (layer.patterns !== void 0 && layer.paths !== void 0) {
+      throw new ConfigError(
+        `config.layers[${index}] no puede tener patterns y paths a la vez`
+      );
+    }
+    const rawPatterns = layer.patterns ?? layer.paths;
+    if (!Array.isArray(rawPatterns) || rawPatterns.length === 0) {
+      throw new ConfigError(
+        `config.layers[${index}].patterns debe ser una lista no vac\xEDa`
+      );
+    }
+    const patterns = rawPatterns.map((rawPattern, patternIndex) => {
+      const pattern = asString(
+        rawPattern,
+        `config.layers[${index}].patterns[${patternIndex}]`
+      ).replaceAll("\\", "/").replace(/^\.\//, "");
+      if (pattern.startsWith("/") || /^[A-Za-z]:\//.test(pattern)) {
+        throw new ConfigError(
+          `el patr\xF3n "${pattern}" debe ser relativo al root del proyecto`
+        );
+      }
+      return pattern;
+    });
+    layers.push({ name, patterns });
+  });
+  return layers;
+}
+function parseRules(value, layerNames) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new ConfigError("config.rules debe ser una lista");
+  }
+  const rules = [];
+  const names = /* @__PURE__ */ new Set();
+  value.forEach((raw, index) => {
+    const rule = asObject(raw, `config.rules[${index}]`);
+    const name = asString(rule.name, `config.rules[${index}].name`);
+    if (names.has(name)) {
+      throw new ConfigError(`regla duplicada: ${name}`);
+    }
+    names.add(name);
+    const type = asString(rule.type, `config.rules[${index}].type`);
+    const severity = parseSeverity(
+      rule.severity,
+      `config.rules[${index}].severity`
+    );
+    const message = rule.message === void 0 ? void 0 : asString(rule.message, `config.rules[${index}].message`);
+    if (type === "forbidden") {
+      const from = asString(rule.from, `config.rules[${index}].from`);
+      const to = asString(rule.to, `config.rules[${index}].to`);
+      if (!layerNames.has(from)) {
+        throw new ConfigError(
+          `config.rules[${index}].from apunta a una capa inexistente: ${from}`
+        );
+      }
+      if (!layerNames.has(to)) {
+        throw new ConfigError(
+          `config.rules[${index}].to apunta a una capa inexistente: ${to}`
+        );
+      }
+      rules.push({ type, name, from, to, severity, message });
+      return;
+    }
+    if (type === "threshold") {
+      const metric = asString(
+        rule.metric,
+        `config.rules[${index}].metric`
+      );
+      const min = optionalNumber(rule.min, `config.rules[${index}].min`);
+      const max = optionalNumber(rule.max, `config.rules[${index}].max`);
+      if (min === void 0 && max === void 0) {
+        throw new ConfigError(
+          `config.rules[${index}] necesita min o max`
+        );
+      }
+      if (min !== void 0 && max !== void 0 && min > max) {
+        throw new ConfigError(
+          `config.rules[${index}]: min no puede ser mayor que max`
+        );
+      }
+      rules.push({ type, name, metric, min, max, severity, message });
+      return;
+    }
+    if (type === "cycles") {
+      rules.push({ type, name, severity, message });
+      return;
+    }
+    throw new ConfigError(
+      `config.rules[${index}].type desconocido: ${type}`
+    );
+  });
+  return rules;
+}
+function parseSeverity(value, path8) {
+  if (value === void 0) return "error";
+  if (typeof value !== "string" || !SEVERITIES.has(value)) {
+    throw new ConfigError(`${path8} debe ser info, warn o error`);
+  }
+  return value;
+}
+function optionalNumber(value, path8) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new ConfigError(`${path8} debe ser un n\xFAmero`);
+  }
+  return value;
+}
+function asObject(value, path8) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(`${path8} debe ser un objeto`);
+  }
+  return value;
+}
+function asString(value, path8) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ConfigError(`${path8} debe ser un texto no vac\xEDo`);
+  }
+  return value.trim();
+}
+
+// packages/metrics/src/rules.ts
+import { minimatch } from "minimatch";
+function emptyRuleReport() {
+  return {
+    configured: false,
+    summary: {
+      layers: 0,
+      rules: 0,
+      introduced: 0,
+      existing: 0,
+      resolved: 0,
+      introducedErrors: 0,
+      introducedWarnings: 0
+    },
+    violations: { introduced: [], existing: [], resolved: [] }
+  };
+}
+function evaluateRules(base, head, config) {
+  const baseViolations = evaluateInput(base, config);
+  const headViolations = evaluateInput(head, config);
+  const baseByKey = new Map(
+    baseViolations.map((violation) => [violation.key, violation])
+  );
+  const headByKey = new Map(
+    headViolations.map((violation) => [violation.key, violation])
+  );
+  const introduced = [];
+  const existing = [];
+  const resolved = [];
+  for (const [key, violation] of headByKey) {
+    if (baseByKey.has(key)) existing.push(violation);
+    else introduced.push(violation);
+  }
+  for (const [key, violation] of baseByKey) {
+    if (!headByKey.has(key)) resolved.push(violation);
+  }
+  introduced.sort(compareViolations);
+  existing.sort(compareViolations);
+  resolved.sort(compareViolations);
+  return {
+    configured: true,
+    summary: {
+      layers: config.layers.length,
+      rules: config.rules.length,
+      introduced: introduced.length,
+      existing: existing.length,
+      resolved: resolved.length,
+      introducedErrors: introduced.filter(
+        (violation) => violation.severity === "error"
+      ).length,
+      introducedWarnings: introduced.filter(
+        (violation) => violation.severity === "warn"
+      ).length
+    },
+    violations: { introduced, existing, resolved }
+  };
+}
+function evaluateInput(input, config) {
+  const layers = layerIndex(input.files, config.layers);
+  const violations = [];
+  for (const rule of config.rules) {
+    if (rule.type === "forbidden") {
+      evaluateForbidden(rule, input, layers, violations);
+    } else if (rule.type === "threshold") {
+      evaluateThreshold(rule, input, violations);
+    } else {
+      evaluateCycles(rule, input.cycles, violations);
+    }
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const violation of violations) byKey.set(violation.key, violation);
+  return [...byKey.values()].sort(compareViolations);
+}
+function layerIndex(files, layers) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const layer of layers) {
+      if (layer.patterns.some(
+        (pattern) => minimatch(file.path, pattern, { dot: true })
+      )) {
+        index.set(file.id, layer.name);
+        break;
+      }
+    }
+  }
+  return index;
+}
+function evaluateForbidden(rule, input, layers, violations) {
+  for (const edge of input.edges) {
+    if (layers.get(edge.fromId) !== rule.from) continue;
+    if (layers.get(edge.toId) !== rule.to) continue;
+    violations.push({
+      key: `forbidden:${rule.name}:${edge.fromId}->${edge.toId}`,
+      rule: rule.name,
+      type: "forbidden",
+      severity: rule.severity,
+      message: rule.message ?? `${edge.from} no puede depender de ${edge.to}`,
+      files: [edge.from, edge.to],
+      edge: {
+        fromId: edge.fromId,
+        toId: edge.toId,
+        from: edge.from,
+        to: edge.to
+      }
+    });
+  }
+}
+function evaluateThreshold(rule, input, violations) {
+  for (const file of input.files) {
+    const value = file.metrics[rule.metric];
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    const tooHigh = rule.max !== void 0 && value > rule.max;
+    const tooLow = rule.min !== void 0 && value < rule.min;
+    if (!tooHigh && !tooLow) continue;
+    const limit = tooHigh && rule.max !== void 0 ? `m\xE1ximo ${rule.max}` : `m\xEDnimo ${rule.min}`;
+    violations.push({
+      key: `threshold:${rule.name}:${file.id}`,
+      rule: rule.name,
+      type: "threshold",
+      severity: rule.severity,
+      message: rule.message ?? `${file.path}: ${rule.metric} = ${value} (${limit})`,
+      files: [file.path],
+      metric: {
+        name: rule.metric,
+        value,
+        ...rule.min !== void 0 ? { min: rule.min } : {},
+        ...rule.max !== void 0 ? { max: rule.max } : {}
+      }
+    });
+  }
+}
+function evaluateCycles(rule, cycles, violations) {
+  for (const cycle of cycles) {
+    const paths = cycle.nodes.map((node) => node.path);
+    violations.push({
+      key: `cycles:${rule.name}:${cycle.nodes.map((node) => node.id).sort().join("|")}`,
+      rule: rule.name,
+      type: "cycles",
+      severity: rule.severity,
+      message: rule.message ?? cycleMessage(paths),
+      files: paths,
+      cycle: {
+        size: cycle.size,
+        nodes: cycle.nodes.map((node) => ({ ...node }))
+      }
+    });
+  }
+}
+function cycleMessage(paths) {
+  const visible = paths.slice(0, 6);
+  const suffix = paths.length > visible.length ? " \u2192 \u2026" : "";
+  return `Ciclo de ${paths.length} ficheros: ${visible.join(" \u2192 ")}${suffix}`;
+}
+function compareViolations(left, right) {
+  return compareStrings3(left.key, right.key);
+}
+function compareStrings3(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// packages/metrics/src/diff.ts
+function diffSnapshots(base, head, options = {}) {
+  const top = Math.max(1, Math.floor(options.top ?? 10));
+  const baseIndex = indexSnapshot(base);
+  const headIndex = indexSnapshot(head);
+  const added = difference(headIndex, baseIndex);
+  const removed = difference(baseIndex, headIndex);
+  const changed = changedFiles(baseIndex, headIndex);
+  const edgeDiff = diffEdges(baseIndex, headIndex);
+  const baseCycles = cycleGroups(baseIndex);
+  const headCycles = cycleGroups(headIndex);
+  const introducedCycles = cycleDifference(headCycles, baseCycles);
+  const fixedCycles = cycleDifference(baseCycles, headCycles);
+  const hotspotMetric = chooseHotspotMetric(
+    baseIndex,
+    headIndex,
+    options.hotspotMetric
+  );
+  const hotspots = hotspotMetric ? buildHotspots(baseIndex, headIndex, added, changed, hotspotMetric, top) : [];
+  const rules = options.rules ? evaluateRules(
+    ruleInput(baseIndex, [...baseCycles.values()].map((group) => group.component)),
+    ruleInput(headIndex, [...headCycles.values()].map((group) => group.component)),
+    options.rules
+  ) : emptyRuleReport();
+  return {
+    schemaVersion: "1.0",
+    base: summarize(baseIndex),
+    head: summarize(headIndex),
+    summary: {
+      addedFiles: added.length,
+      removedFiles: removed.length,
+      changedFiles: changed.length,
+      addedEdges: edgeDiff.added.length,
+      removedEdges: edgeDiff.removed.length,
+      cyclicEdgesAdded: edgeDiff.cyclicAdded.length,
+      cyclicEdgesRemoved: edgeDiff.cyclicRemoved.length,
+      introducedCycles: introducedCycles.length,
+      fixedCycles: fixedCycles.length,
+      hotspots: hotspots.length
+    },
+    hotspotMetric,
+    rules,
+    files: { added, removed, changed },
+    edges: edgeDiff,
+    cycles: { introduced: introducedCycles, fixed: fixedCycles },
+    hotspots
+  };
+}
+function indexSnapshot(cc) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const root of cc.files) {
+    walkFiles([root], (entry) => {
+      paths.set(entry.node.id, relativePath(root, entry.path, entry.node));
+    });
+  }
+  const nodes = [...paths.keys()].sort(
+    (left, right) => compareStrings4(paths.get(left) ?? left, paths.get(right) ?? right)
+  );
+  const metrics = cc.lenses?.metrics?.attributes ?? {};
+  const edges = /* @__PURE__ */ new Map();
+  for (const edge of cc.lenses?.dependency?.edges ?? []) {
+    const key = edgeKey(edge.fromId, edge.toId);
+    const weight = finiteNumber(edge.attributes?.weight) ?? 1;
+    const typeOnly = finiteNumber(edge.attributes?.typeOnly) ?? 0;
+    const existing = edges.get(key);
+    if (existing) {
+      existing.weight += weight;
+      existing.typeOnly += typeOnly;
+      existing.isCyclic = existing.isCyclic || edge.isCyclic === true;
+    } else {
+      edges.set(key, {
+        fromId: edge.fromId,
+        toId: edge.toId,
+        weight,
+        typeOnly,
+        isCyclic: edge.isCyclic === true
+      });
+    }
+  }
+  return { cc, paths, nodes, metrics, edges };
+}
+function relativePath(root, fullPath, leaf) {
+  if (fullPath === root.name) return leaf.name;
+  const prefix = `${root.name}/`;
+  return fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+}
+function summarize(index) {
+  let folders = 0;
+  walkTree(index.cc.files, (entry) => {
+    if (entry.node.type === "Folder" && entry.depth > 0) folders++;
+  });
+  return {
+    projectName: index.cc.meta.projectName ?? "",
+    checksum: index.cc.meta.checksum ?? "",
+    files: index.paths.size,
+    folders,
+    edges: index.edges.size
+  };
+}
+function difference(present, absent) {
+  const files = [];
+  for (const [id, path8] of present.paths) {
+    if (absent.paths.has(id)) continue;
+    files.push({
+      id,
+      path: path8,
+      metrics: sortedMetrics(present.metrics[id])
+    });
+  }
+  return files.sort(compareFiles);
+}
+function changedFiles(base, head) {
+  const changed = [];
+  for (const [id, path8] of head.paths) {
+    if (!base.paths.has(id)) continue;
+    const baseValues = base.metrics[id] ?? {};
+    const headValues = head.metrics[id] ?? {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(baseValues), ...Object.keys(headValues)]);
+    const changes = [];
+    for (const metric of [...keys].sort(compareStrings4)) {
+      const baseValue = finiteNumber(baseValues[metric]);
+      const headValue = finiteNumber(headValues[metric]);
+      if (baseValue === null && headValue === null) continue;
+      if (baseValue !== null && headValue !== null && baseValue === headValue) {
+        continue;
+      }
+      changes.push({
+        metric,
+        base: baseValue,
+        head: headValue,
+        delta: baseValue !== null && headValue !== null ? headValue - baseValue : null
+      });
+    }
+    if (changes.length > 0) changed.push({ id, path: path8, changes });
+  }
+  return changed.sort(compareChangedFiles);
+}
+function diffEdges(base, head) {
+  const added = [];
+  const removed = [];
+  for (const [key, edge] of head.edges) {
+    if (!base.edges.has(key)) added.push(edgeChange(head, edge));
+  }
+  for (const [key, edge] of base.edges) {
+    if (!head.edges.has(key)) removed.push(edgeChange(base, edge));
+  }
+  added.sort(compareEdgeChanges);
+  removed.sort(compareEdgeChanges);
+  return {
+    added,
+    removed,
+    cyclicAdded: added.filter((edge) => edge.isCyclic),
+    cyclicRemoved: removed.filter((edge) => edge.isCyclic)
+  };
+}
+function edgeChange(index, edge) {
+  return {
+    fromId: edge.fromId,
+    toId: edge.toId,
+    from: index.paths.get(edge.fromId) ?? edge.fromId,
+    to: index.paths.get(edge.toId) ?? edge.toId,
+    weight: edge.weight,
+    typeOnly: edge.typeOnly,
+    isCyclic: edge.isCyclic
+  };
+}
+function cycleGroups(index) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const node of index.nodes) {
+    adjacency.set(node, []);
+    reverse.set(node, []);
+  }
+  for (const edge of index.edges.values()) {
+    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) continue;
+    adjacency.get(edge.fromId)?.push(edge.toId);
+    reverse.get(edge.toId)?.push(edge.fromId);
+  }
+  for (const [node, neighbors] of adjacency) {
+    adjacency.set(node, [...new Set(neighbors)].sort(compareStrings4));
+  }
+  for (const [node, neighbors] of reverse) {
+    reverse.set(node, [...new Set(neighbors)].sort(compareStrings4));
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of index.nodes) {
+    if (visited.has(start)) continue;
+    visited.add(start);
+    const stack = [
+      { node: start, neighbors: adjacency.get(start) ?? [], next: 0 }
+    ];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (frame.next < frame.neighbors.length) {
+        const next = frame.neighbors[frame.next];
+        frame.next++;
+        if (!visited.has(next)) {
+          visited.add(next);
+          stack.push({
+            node: next,
+            neighbors: adjacency.get(next) ?? [],
+            next: 0
+          });
+        }
+      } else {
+        order.push(frame.node);
+        stack.pop();
+      }
+    }
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  for (let position = order.length - 1; position >= 0; position--) {
+    const start = order[position];
+    if (assigned.has(start)) continue;
+    assigned.add(start);
+    const component = [];
+    const stack = [start];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      component.push(node);
+      for (const next of reverse.get(node) ?? []) {
+        if (assigned.has(next)) continue;
+        assigned.add(next);
+        stack.push(next);
+      }
+    }
+    const hasSelfLoop = component.some(
+      (node) => (adjacency.get(node) ?? []).includes(node)
+    );
+    if (component.length < 2 && !hasSelfLoop) continue;
+    const nodes = component.map((id) => ({
+      id,
+      path: index.paths.get(id) ?? id
+    })).sort((left, right) => {
+      return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+    });
+    const key = [...component].sort(compareStrings4).join("\0");
+    groups.set(key, { key, component: { size: nodes.length, nodes } });
+  }
+  return groups;
+}
+function cycleDifference(present, absent) {
+  const cycles = [];
+  for (const [key, group] of present) {
+    if (!absent.has(key)) cycles.push(group.component);
+  }
+  return cycles.sort(compareCycles);
+}
+function ruleInput(index, cycles) {
+  const files = index.nodes.map((id) => ({
+    id,
+    path: index.paths.get(id) ?? id,
+    metrics: sortedMetrics(index.metrics[id])
+  }));
+  const edges = [];
+  for (const edge of index.edges.values()) {
+    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) {
+      continue;
+    }
+    edges.push({
+      fromId: edge.fromId,
+      toId: edge.toId,
+      from: index.paths.get(edge.fromId) ?? edge.fromId,
+      to: index.paths.get(edge.toId) ?? edge.toId
+    });
+  }
+  return { files, edges, cycles };
+}
+function chooseHotspotMetric(base, head, requested) {
+  if (requested) return requested;
+  for (const metric of ["maxComplexity", "rloc"]) {
+    if (hasMetric(base, metric) || hasMetric(head, metric)) return metric;
+  }
+  return null;
+}
+function hasMetric(index, metric) {
+  for (const values of Object.values(index.metrics)) {
+    if (finiteNumber(values[metric]) !== null) return true;
+  }
+  return false;
+}
+function buildHotspots(base, head, added, changed, metric, top) {
+  const addedIds = new Set(added.map((file) => file.id));
+  const candidates = [...added, ...changed];
+  const hotspots = [];
+  for (const file of candidates) {
+    const baseValue = finiteNumber(base.metrics[file.id]?.[metric]);
+    const headValue = finiteNumber(head.metrics[file.id]?.[metric]);
+    if (headValue === null) continue;
+    const before = baseValue ?? 0;
+    const delta = headValue - before;
+    if (delta <= 0) continue;
+    hotspots.push({
+      id: file.id,
+      path: file.path,
+      metric,
+      base: before,
+      head: headValue,
+      delta,
+      change: addedIds.has(file.id) ? "added" : "changed"
+    });
+  }
+  return hotspots.sort(
+    (left, right) => right.delta - left.delta || right.head - left.head || compareStrings4(left.path, right.path)
+  ).slice(0, top);
+}
+function sortedMetrics(values) {
+  const sorted = {};
+  if (!values) return sorted;
+  for (const key of Object.keys(values).sort(compareStrings4)) {
+    const value = finiteNumber(values[key]);
+    if (value !== null) sorted[key] = value;
+  }
+  return sorted;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function edgeKey(fromId, toId) {
+  return `${fromId}\0${toId}`;
+}
+function compareFiles(left, right) {
+  return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+}
+function compareChangedFiles(left, right) {
+  return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+}
+function compareEdgeChanges(left, right) {
+  return compareStrings4(left.from, right.from) || compareStrings4(left.to, right.to) || compareStrings4(left.fromId, right.fromId) || compareStrings4(left.toId, right.toId);
+}
+function compareCycles(left, right) {
+  return compareStrings4(
+    left.nodes[0]?.path ?? "",
+    right.nodes[0]?.path ?? ""
+  ) || left.size - right.size;
+}
+function compareStrings4(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// packages/metrics/src/risk.ts
+var COMPLEXITY_METRIC_CANDIDATES = [
+  "maxComplexity",
+  "max_complexity_per_function",
+  "complexity",
+  "logic_complexity",
+  "sonar_cognitive_complexity"
+];
+var CHURN_METRIC_CANDIDATES = [
+  "number_of_commits",
+  "number_of_authors",
+  "number_of_renames"
+];
+var RISK_WEIGHTS = {
+  complexity: 0.5,
+  churn: 0.32,
+  size: 0.18
+};
+var RISK_GAMMA = 1.7;
+function riskScores(files) {
+  const complexityP95 = percentile(
+    files.map((file) => file.complexity).filter((value) => value > 0),
+    0.95
+  );
+  const churnP95 = percentile(
+    files.map((file) => file.churn).filter((value) => value > 0),
+    0.95
+  );
+  const sizeP95 = percentile(
+    files.map((file) => file.size).filter((value) => value > 0),
+    0.95
+  );
+  const complexityWeight = complexityP95 > 0 ? RISK_WEIGHTS.complexity : 0;
+  const churnWeight = churnP95 > 0 ? RISK_WEIGHTS.churn : 0;
+  const sizeWeight = sizeP95 > 0 ? RISK_WEIGHTS.size : 0;
+  const totalWeight = complexityWeight + churnWeight + sizeWeight;
+  if (totalWeight === 0) return files.map(() => 0);
+  return files.map((file) => {
+    const raw = (complexityWeight * norm(file.complexity, complexityP95) + churnWeight * norm(file.churn, churnP95) + sizeWeight * norm(file.size, sizeP95)) / totalWeight;
+    return Math.pow(clamp01(raw), RISK_GAMMA);
+  });
+}
+function firstMetric(available, candidates) {
+  const set = available instanceof Set ? available : new Set(available);
+  for (const candidate of candidates) {
+    if (set.has(candidate)) return candidate;
+  }
+  return null;
+}
+function norm(value, p95) {
+  return p95 > 0 ? clamp01(value / p95) : 0;
+}
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor((sorted.length - 1) * p))
+  );
+  return sorted[index] ?? 0;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+
+// packages/render/src/model.ts
+var RenderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RenderError";
+  }
+};
+var PALETTE = [
+  "#b9c4d0",
+  "#c9b8a8",
+  "#a9bfae",
+  "#c4b6c9",
+  "#c9c2a6",
+  "#d5d2ca",
+  "#c2c8d0",
+  "#d6c6bd",
+  "#b7c6c2",
+  "#cbbfb0",
+  "#bcc3b9",
+  "#cfc6c9"
+];
+var CURATED_METRICS = [
+  "rloc",
+  "maxComplexity",
+  "max_complexity_per_function",
+  "complexity",
+  "functions",
+  "number_of_functions",
+  "maxFunctionLength",
+  "loc",
+  "imports",
+  "externalImports",
+  "builtinImports",
+  "typeOnlyImports",
+  "unresolvedImports",
+  "fanIn",
+  "fanOut",
+  "inCycle",
+  "cycleSize",
+  "dependencyLevel",
+  "number_of_commits",
+  "number_of_authors",
+  "incoming_dependencies",
+  "outgoing_dependencies"
+];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valueOf(values, key) {
+  if (!key || !values) return void 0;
+  const value = values[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function percentile2(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor((sorted.length - 1) * p))
+  );
+  return sorted[index] ?? 0;
+}
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function sectionForPath(path8) {
+  const folders = path8.split("/").filter(Boolean).slice(0, -1);
+  if (folders.length === 0) return "(ra\xEDz)";
+  if (folders.length === 1) return folders[0];
+  return folders.slice(0, 3).join("/");
+}
+function asEdges(value) {
+  if (!Array.isArray(value)) return [];
+  const edges = [];
+  for (const item of value) {
+    if (!isRecord3(item)) continue;
+    if (typeof item.fromId !== "string" || typeof item.toId !== "string") continue;
+    edges.push({
+      fromId: item.fromId,
+      toId: item.toId,
+      ...item.isCyclic === true ? { isCyclic: true } : {}
+    });
+  }
+  return edges;
+}
+function metricTitle(attributes, key) {
+  const descriptor = attributes?.[key];
+  if (isRecord3(descriptor) && typeof descriptor.title === "string" && descriptor.title) {
+    return descriptor.title;
+  }
+  return key;
+}
+function metricDirection(attributes, key) {
+  const descriptor = attributes?.[key];
+  if (isRecord3(descriptor) && typeof descriptor.direction === "number") {
+    return descriptor.direction;
+  }
+  return 0;
+}
+function buildRenderModel(cc, options = {}) {
+  const stats = getStats(cc);
+  const coverage = new Set(stats.metricCoverage.map((entry) => entry.name));
+  const attributes = cc.lenses?.metrics?.attributes ?? {};
+  const descriptors = cc.lenses?.metrics?.attributeDescriptors;
+  let areaMetric;
+  if (options.areaMetric) {
+    if (!coverage.has(options.areaMetric)) {
+      throw new RenderError(
+        `la m\xE9trica de \xE1rea "${options.areaMetric}" no existe en este cc.json`
+      );
+    }
+    areaMetric = options.areaMetric;
+  } else {
+    areaMetric = defaultMetric(stats) ?? null;
+  }
+  const complexityKey = firstMetric(coverage, COMPLEXITY_METRIC_CANDIDATES);
+  const churnKey = firstMetric(coverage, CHURN_METRIC_CANDIDATES);
+  const metricKeys = [];
+  const addMetric = (key) => {
+    if (key && coverage.has(key) && !metricKeys.includes(key)) metricKeys.push(key);
+  };
+  for (const key of CURATED_METRICS) addMetric(key);
+  addMetric(areaMetric);
+  addMetric(complexityKey);
+  addMetric(churnKey);
+  if (options.color && options.color !== "risk" && options.color !== "structure") {
+    addMetric(options.color);
+  }
+  const singleRoot = cc.files.length === 1 && cc.files[0]?.type === "Folder" ? cc.files[0] : null;
+  const prefix = singleRoot ? `${singleRoot.name}/` : "";
+  const rootName = singleRoot?.name ?? "";
+  const warnings = [];
+  const files = [];
+  const fileIndexById = /* @__PURE__ */ new Map();
+  walkFiles(cc.files, (entry) => {
+    const fullPath = entry.path;
+    const path8 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+    const values = attributes[entry.node.id];
+    const rawArea = valueOf(values, areaMetric);
+    const index = files.length;
+    fileIndexById.set(entry.node.id, index);
+    files.push({
+      index,
+      nodeId: entry.node.id,
+      path: path8,
+      name: entry.node.name,
+      section: -1,
+      area: Math.max(1, rawArea ?? 0),
+      actualArea: rawArea ?? 0,
+      risk: 0,
+      complexity: valueOf(values, complexityKey) ?? 0,
+      churn: valueOf(values, churnKey) ?? 0,
+      values: []
+    });
+  });
+  if (areaMetric && files.length > 0) {
+    const missing = files.filter((file) => file.actualArea === 0).length;
+    if (missing > 0) {
+      warnings.push(
+        `${missing} ficheros sin "${areaMetric}"; se dibujan con \xE1rea m\xEDnima para no desaparecer`
+      );
+    }
+    if (!options.areaMetric && areaMetric !== "rloc") {
+      warnings.push(`"rloc" no est\xE1 presente; se usa "${areaMetric}" como \xE1rea`);
+    }
+  }
+  const risks = riskScores(
+    files.map((file) => ({
+      complexity: file.complexity,
+      churn: file.churn,
+      size: file.actualArea
+    }))
+  );
+  for (const [index, file] of files.entries()) {
+    file.risk = risks[index] ?? 0;
+  }
+  const sectionAccumulator = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const key = sectionForPath(file.path);
+    const current = sectionAccumulator.get(key) ?? { files: 0, area: 0 };
+    current.files++;
+    current.area += file.actualArea;
+    sectionAccumulator.set(key, current);
+  }
+  const sections = [...sectionAccumulator.entries()].map(([key, value]) => ({
+    key,
+    label: key,
+    files: value.files,
+    area: value.area,
+    color: PALETTE[hashString(key) % PALETTE.length]
+  })).sort((a, b) => b.area - a.area || a.key.localeCompare(b.key));
+  const sectionIndex = new Map(sections.map((section, index) => [section.key, index]));
+  for (const file of files) {
+    file.section = sectionIndex.get(sectionForPath(file.path)) ?? 0;
+  }
+  const metrics = metricKeys.map((key) => {
+    const present = files.map((file) => valueOf(attributes[file.nodeId], key)).filter((value) => value !== void 0);
+    const min = present.length > 0 ? Math.min(...present) : 0;
+    const actualMax = present.length > 0 ? Math.max(...present) : 0;
+    const p95 = percentile2(present, 0.95);
+    const skewed = min >= 0 && p95 > 0 && actualMax > p95 * 4;
+    const max = skewed ? actualMax : p95 > 0 ? p95 : actualMax;
+    return {
+      key,
+      title: metricTitle(descriptors, key),
+      direction: metricDirection(descriptors, key),
+      min,
+      max,
+      actualMax,
+      p95,
+      mode: skewed ? "log" : "linear",
+      coverage: present.length
+    };
+  });
+  for (const file of files) {
+    const values = attributes[file.nodeId];
+    file.values = metrics.map((metric) => valueOf(values, metric.key) ?? null);
+  }
+  const roots = buildRoots(cc, singleRoot, fileIndexById, files);
+  const folderCount = countFolders(roots);
+  const dependency = cc.lenses?.dependency;
+  const leafEdges = asEdges(dependency?.leafEdges);
+  const rawEdges = leafEdges.length > 0 ? leafEdges : asEdges(dependency?.edges);
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  const n = files.length;
+  for (const edge of rawEdges) {
+    const from = fileIndexById.get(edge.fromId);
+    const to = fileIndexById.get(edge.toId);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    const key = from * n + to;
+    if (edgeSet.has(key)) continue;
+    edgeSet.add(key);
+    edges.push({ from, to });
+    if (edges.length >= 2e4) {
+      warnings.push("se han limitado las dependencias a 20.000 aristas");
+      break;
+    }
+  }
+  edges.sort((a, b) => a.from - b.from || a.to - b.to);
+  const flaggedEdges = /* @__PURE__ */ new Set();
+  for (const edge of rawEdges) {
+    if (edge.isCyclic !== true) continue;
+    const from = fileIndexById.get(edge.fromId);
+    const to = fileIndexById.get(edge.toId);
+    if (from === void 0 || to === void 0) continue;
+    flaggedEdges.add(from * n + to);
+  }
+  const cycleSet = /* @__PURE__ */ new Set();
+  const cycles = [];
+  for (const edge of edges) {
+    const key = edge.from * n + edge.to;
+    const backward = edgeSet.has(edge.to * n + edge.from);
+    if (backward || flaggedEdges.has(key)) {
+      if (!cycleSet.has(key)) {
+        cycleSet.add(key);
+        cycles.push(edge);
+      }
+    }
+  }
+  cycles.sort((a, b) => a.from - b.from || a.to - b.to);
+  if (rawEdges.length === 0) {
+    warnings.push("este cc.json no trae una lente de dependencias utilizable");
+  }
+  const totalArea = files.reduce((sum, file) => sum + file.actualArea, 0);
+  const hotspotCount = files.filter((file) => file.risk >= 0.66).length;
+  let initialLens = "risk";
+  let initialMetric = null;
+  if (options.color === "structure") {
+    initialLens = "structure";
+  } else if (options.color && options.color !== "risk") {
+    if (!coverage.has(options.color)) {
+      throw new RenderError(`la m\xE9trica de color "${options.color}" no existe en este cc.json`);
+    }
+    initialLens = "metric";
+    initialMetric = options.color;
+  }
+  const defaultSelection = pickDefaultSelection(files, initialLens, initialMetric, metrics);
+  const project = cc.meta.projectName || options.title || "Proyecto sin nombre";
+  return {
+    meta: {
+      project,
+      title: options.title || project,
+      commit: cc.meta.commitHash || "",
+      checksum: cc.meta.checksum || "",
+      apiVersion: cc.meta.apiVersion,
+      rootName
+    },
+    files,
+    sections,
+    metrics,
+    edges,
+    cycles,
+    roots,
+    areaMetric,
+    areaTitle: areaMetric ? metricTitle(descriptors, areaMetric) : "\xC1rea",
+    totalArea,
+    fileCount: files.length,
+    folderCount,
+    hotspotCount,
+    defaultSelection,
+    initialLens,
+    initialMetric,
+    warnings
+  };
+}
+function buildRoots(cc, singleRoot, fileIndexById, files) {
+  const build = (node, path8) => {
+    if (node.type === "File") {
+      const index = fileIndexById.get(node.id);
+      const file = index === void 0 ? void 0 : files[index];
+      return {
+        kind: "file",
+        key: `f:${index ?? -1}`,
+        name: node.name,
+        path: path8,
+        value: file?.area ?? 1,
+        fileCount: 1,
+        section: file?.section ?? 0,
+        fileIndex: index
+      };
+    }
+    const children = (node.children ?? []).map(
+      (child) => build(child, path8 ? `${path8}/${child.name}` : child.name)
+    );
+    const folder = {
+      kind: "folder",
+      key: `d:${path8}`,
+      name: node.name,
+      path: path8,
+      value: children.reduce((sum, child) => sum + child.value, 0) || 1,
+      fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),
+      section: -1,
+      children
+    };
+    while (folder.children?.length === 1 && folder.children[0]?.kind === "folder") {
+      const only = folder.children[0];
+      folder.name = `${folder.name}/${only.name}`;
+      folder.path = only.path;
+      folder.key = `d:${only.path}`;
+      folder.value = only.value;
+      folder.fileCount = only.fileCount;
+      folder.children = only.children;
+    }
+    return folder;
+  };
+  if (singleRoot) {
+    return (singleRoot.children ?? []).map((child) => build(child, child.name));
+  }
+  return cc.files.map((root) => build(root, root.name));
+}
+function countFolders(nodes) {
+  let count = 0;
+  const stack = [...nodes];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.kind === "folder") count++;
+    if (node.children) stack.push(...node.children);
+  }
+  return count;
+}
+function pickDefaultSelection(files, lens, metric, metrics) {
+  if (files.length === 0) return null;
+  if (lens === "metric" && metric) {
+    const index = metrics.findIndex((entry) => entry.key === metric);
+    if (index >= 0) {
+      let best = null;
+      for (const file of files) {
+        const value = file.values[index];
+        if (value === null || value === void 0) continue;
+        if (!best || value > (best.values[index] ?? -Infinity)) best = file;
+      }
+      if (best) return best.index;
+    }
+  }
+  if (lens === "structure") {
+    return files.reduce(
+      (best, file) => file.actualArea > best.actualArea ? file : best
+    ).index;
+  }
+  return files.reduce((best, file) => file.risk > best.risk ? file : best).index;
+}
+
+// packages/render/src/html.ts
+import { readFileSync } from "node:fs";
+
+// packages/render/src/color.ts
+var RISK_STOPS = [
+  [0, "#ebe7df"],
+  [0.35, "#e9cd98"],
+  [0.65, "#d68a54"],
+  [1, "#a42e2c"]
+];
+var METRIC_STOPS = [
+  [0, "#ebe7df"],
+  [0.5, "#b9c9cf"],
+  [1, "#355b6b"]
+];
+var RISK_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #e9cd98 35%, #d68a54 65%, #a42e2c 100%)";
+var METRIC_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #b9c9cf 50%, #355b6b 100%)";
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function rgbToHex(rgb) {
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+function mix(a, b, t) {
+  const from = hexToRgb(a);
+  const to = hexToRgb(b);
+  return rgbToHex([
+    Math.round(from[0] + (to[0] - from[0]) * t),
+    Math.round(from[1] + (to[1] - from[1]) * t),
+    Math.round(from[2] + (to[2] - from[2]) * t)
+  ]);
+}
+function ramp(stops, t) {
+  const value = clamp012(t);
+  for (let index = 0; index < stops.length - 1; index++) {
+    const from = stops[index];
+    const to = stops[index + 1];
+    if (value <= to[0]) {
+      const span2 = to[0] - from[0] || 1;
+      return mix(from[1], to[1], (value - from[0]) / span2);
+    }
+  }
+  return stops[stops.length - 1][1];
+}
+function riskColor(risk) {
+  return ramp(RISK_STOPS, risk);
+}
+function metricColor(value, metric) {
+  if (value === null) return METRIC_STOPS[0][1];
+  let t;
+  if (metric.mode === "log") {
+    const span2 = Math.max(1e-9, metric.max - metric.min);
+    t = Math.log1p(Math.max(0, value - metric.min)) / Math.log1p(span2);
+  } else {
+    const span2 = metric.max - metric.min;
+    t = span2 > 0 ? (value - metric.min) / span2 : 0;
+  }
+  return ramp(METRIC_STOPS, t);
+}
+function inkFor(color) {
+  const [r, g, b] = hexToRgb(color);
+  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+  return luminance > 0.52 ? "#1a1a1a" : "#f7f5f1";
+}
+function colorForFile(lens, risk, section, value, metric) {
+  if (lens === "structure") return section?.color ?? "#ddd8cf";
+  if (lens === "risk" || !metric) return riskColor(risk);
+  return metricColor(value, metric);
+}
+
+// packages/layouts/src/squarify.ts
+function squarify(items, rect) {
+  if (rect.w <= 0 || rect.h <= 0) return [];
+  const usable = items.filter(
+    (item) => Number.isFinite(item.value) && item.value > 0
+  );
+  const total = usable.reduce((sum, item) => sum + item.value, 0);
+  if (usable.length === 0 || total <= 0) return [];
+  const sorted = usable.map((item, index2) => ({ item, index: index2 })).sort((a, b) => b.item.value - a.item.value || a.index - b.index).map(({ item }) => item);
+  const scale = rect.w * rect.h / total;
+  const placed = [];
+  let x = rect.x;
+  let y = rect.y;
+  let w = rect.w;
+  let h = rect.h;
+  let row = [];
+  const area = (item) => item.value * scale;
+  function worst(candidate, side) {
+    let sum = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    for (const item of candidate) {
+      const value = area(item);
+      sum += value;
+      if (value > max) max = value;
+      if (value < min) min = value;
+    }
+    if (sum <= 0 || side <= 0) return Infinity;
+    return Math.max(
+      side * side * max / (sum * sum),
+      sum * sum / (side * side * min)
+    );
+  }
+  function place(current, horizontal) {
+    if (current.length === 0) return;
+    const sum = current.reduce((acc, item) => acc + area(item), 0);
+    if (sum <= 0) return;
+    if (horizontal) {
+      if (w <= 0) return;
+      const thickness = sum / w;
+      if (!Number.isFinite(thickness) || thickness <= 0) return;
+      let position = x;
+      for (const item of current) {
+        const length = area(item) / thickness;
+        placed.push({ item, x: position, y, w: length, h: thickness });
+        position += length;
+      }
+      y += thickness;
+      h -= thickness;
+    } else {
+      if (h <= 0) return;
+      const thickness = sum / h;
+      if (!Number.isFinite(thickness) || thickness <= 0) return;
+      let position = y;
+      for (const item of current) {
+        const length = area(item) / thickness;
+        placed.push({ item, x, y: position, w: thickness, h: length });
+        position += length;
+      }
+      x += thickness;
+      w -= thickness;
+    }
+  }
+  let index = 0;
+  while (index < sorted.length) {
+    const horizontal = w >= h;
+    const side = horizontal ? w : h;
+    const next = sorted[index];
+    if (row.length === 0) {
+      row.push(next);
+      index++;
+      continue;
+    }
+    if (worst([...row, next], side) <= worst(row, side)) {
+      row.push(next);
+      index++;
+    } else {
+      place(row, horizontal);
+      row = [];
+    }
+  }
+  if (row.length > 0) place(row, w >= h);
+  return placed;
+}
+
+// packages/render/src/layout.ts
+var VIEW_WIDTH = 1400;
+var VIEW_HEIGHT = 900;
+var VIEW_PADDING = 8;
+var MAX_DEPTH3 = 12;
+function layoutMap(roots) {
+  const rect = {
+    x: VIEW_PADDING,
+    y: VIEW_PADDING,
+    w: VIEW_WIDTH - VIEW_PADDING * 2,
+    h: VIEW_HEIGHT - VIEW_PADDING * 2
+  };
+  return layoutChildren(roots, rect, 0);
+}
+function layoutChildren(nodes, rect, depth) {
+  if (nodes.length === 0 || rect.w < 2 || rect.h < 2) return [];
+  const items = nodes.map((node) => ({
+    key: node.key,
+    value: Math.max(1, node.value),
+    node
+  }));
+  return squarify(items, rect).map(
+    (placed) => layoutNode(placed.item.node, {
+      x: placed.x,
+      y: placed.y,
+      w: placed.w,
+      h: placed.h
+    }, depth)
+  );
+}
+function layoutNode(node, rect, depth) {
+  if (node.kind === "file" || !node.children || node.children.length === 0) {
+    return { node, rect, headerHeight: 0, children: [] };
+  }
+  let headerHeight = 0;
+  if (rect.w >= 30 && rect.h >= 32) {
+    headerHeight = rect.h >= 62 ? 17 : 13;
+  }
+  const inner = {
+    x: rect.x + 1,
+    y: rect.y + headerHeight + 1,
+    w: Math.max(0, rect.w - 2),
+    h: Math.max(0, rect.h - headerHeight - 2)
+  };
+  const children = depth < MAX_DEPTH3 && inner.w >= 1 && inner.h >= 1 ? layoutChildren(node.children, inner, depth + 1) : [];
+  return { node, rect, headerHeight, children };
+}
+
+// packages/render/src/svg.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttr(value) {
+  return escapeHtml(value);
+}
+function formatInt(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  return Math.round(value).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+function formatCompact(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  const absolute = Math.abs(value);
+  if (absolute >= 1e6) {
+    return `${(value / 1e6).toFixed(1).replace(".0", "").replace(".", ",")}M`;
+  }
+  if (absolute >= 1e3) {
+    return `${(value / 1e3).toFixed(1).replace(".0", "").replace(".", ",")}k`;
+  }
+  return formatInt(value);
+}
+function coord(value) {
+  const rounded = Math.round(value);
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function span(value) {
+  return String(Math.max(1, Math.round(value)));
+}
+function truncate(value, maxWidth, fontSize) {
+  const maxChars = Math.floor(maxWidth / (fontSize * 0.56));
+  if (maxChars <= 0) return "";
+  if (value.length <= maxChars) return value;
+  if (maxChars === 1) return "\u2026";
+  return `${value.slice(0, maxChars - 1)}\u2026`;
+}
+function labelFor(nodeName, rect, out, ink) {
+  if (rect.w < 44 || rect.h < 13) return;
+  const available = rect.w - 8;
+  const dot = nodeName.lastIndexOf(".");
+  const twoLines = rect.h >= 27 && rect.w >= 64 && dot > 0 && dot < nodeName.length - 1;
+  if (twoLines) {
+    const base = truncate(nodeName.slice(0, dot), available, 12.5);
+    const extension = truncate(nodeName.slice(dot), available, 10);
+    if (base) {
+      out.push(
+        `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 12)}" fill="${ink}">${escapeHtml(base)}</text>`
+      );
+    }
+    if (extension) {
+      out.push(
+        `<text class="b" x="${coord(rect.x + 4)}" y="${coord(rect.y + 22.5)}" fill="${ink}">${escapeHtml(extension)}</text>`
+      );
+    }
+    return;
+  }
+  const label = truncate(nodeName, available, 12.5);
+  if (!label) return;
+  out.push(
+    `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 13)}" fill="${ink}">${escapeHtml(label)}</text>`
+  );
+}
+function renderPlaced(placed, out, model, metricIndex, metric) {
+  const node = placed.node;
+  const rect = placed.rect;
+  if (node.kind === "file") {
+    const index = node.fileIndex;
+    if (index === void 0) return;
+    const file = model.files[index];
+    if (!file) return;
+    const value = metricIndex >= 0 ? file.values[metricIndex] ?? null : null;
+    const fill = colorForFile(
+      model.initialLens,
+      file.risk,
+      model.sections[file.section],
+      value,
+      metric
+    );
+    const ink = inkFor(fill);
+    out.push(
+      `<rect data-i="${index}" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}" fill="${fill}"/>`
+    );
+    labelFor(file.name, rect, out, ink);
+    return;
+  }
+  const folder = node;
+  out.push(
+    `<g class="folder" data-nm="${escapeAttr(folder.name)}" data-n="${folder.fileCount}" data-a="${coord(folder.value)}">`
+  );
+  out.push(
+    `<rect class="fr" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}"/>`
+  );
+  if (placed.headerHeight >= 13 && rect.w >= 30) {
+    const headerHeight = placed.headerHeight;
+    out.push(
+      `<rect class="fh" x="${coord(rect.x + 1)}" y="${coord(rect.y + 1)}" width="${span(rect.w - 2)}" height="${span(headerHeight - 1)}"/>`
+    );
+    const count = formatCompact(folder.value);
+    const showCount = rect.w >= 86;
+    const countWidth = showCount ? count.length * 5.8 + 12 : 0;
+    const name = truncate(folder.name, Math.max(8, rect.w - 12 - countWidth), 11.5);
+    if (name) {
+      out.push(
+        `<text class="ft" x="${coord(rect.x + 6)}" y="${coord(rect.y + headerHeight / 2 + 4)}">${escapeHtml(name)}</text>`
+      );
+    }
+    if (showCount) {
+      out.push(
+        `<text class="fn" x="${coord(rect.x + rect.w - 6)}" y="${coord(rect.y + headerHeight / 2 + 3.6)}">${escapeHtml(count)}</text>`
+      );
+    }
+  }
+  for (const child of placed.children) {
+    renderPlaced(child, out, model, metricIndex, metric);
+  }
+  out.push("</g>");
+}
+function renderSvg(model) {
+  const metricIndex = model.initialMetric ? model.metrics.findIndex((metric2) => metric2.key === model.initialMetric) : -1;
+  const metric = metricIndex >= 0 ? model.metrics[metricIndex] : void 0;
+  const out = [];
+  out.push(
+    `<svg id="map" viewBox="0 0 ${VIEW_WIDTH} ${VIEW_HEIGHT}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Mapa de arquitectura de ${escapeAttr(model.meta.project)}">`
+  );
+  out.push(
+    `<rect class="canvas" x="0" y="0" width="${VIEW_WIDTH}" height="${VIEW_HEIGHT}"/>`
+  );
+  out.push(`<g id="cells">`);
+  for (const placed of layoutMap(model.roots)) {
+    renderPlaced(placed, out, model, metricIndex, metric);
+  }
+  out.push(`</g><g id="edges"></g></svg>`);
+  return out.join("");
+}
+
+// packages/render/src/html.ts
+var STYLES = readFileSync(new URL("./styles.css", import.meta.url), "utf8");
+var CLIENT = readFileSync(new URL("./client.js", import.meta.url), "utf8").replace(
+  /<\/script/gi,
+  "<\\/script"
+);
+function round(value, digits = 2) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function jsonForScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function serialise(model) {
+  const directoryIndex = /* @__PURE__ */ new Map();
+  const directories = [];
+  const fileRows = model.files.map((file) => {
+    const slash = file.path.lastIndexOf("/");
+    const directory = slash >= 0 ? file.path.slice(0, slash) : "";
+    let dirIndex = -1;
+    if (directory) {
+      const known = directoryIndex.get(directory);
+      if (known === void 0) {
+        dirIndex = directories.length;
+        directoryIndex.set(directory, dirIndex);
+        directories.push(directory);
+      } else {
+        dirIndex = known;
+      }
+    }
+    const name = slash >= 0 ? file.path.slice(slash + 1) : file.path;
+    return [
+      dirIndex,
+      name,
+      file.section,
+      round(file.area, 1),
+      round(file.actualArea, 1),
+      round(file.risk, 4),
+      round(file.complexity, 1),
+      round(file.churn, 1),
+      ...file.values.map((value) => value === null ? null : round(value, 2))
+    ];
+  });
+  return {
+    v: 1,
+    meta: {
+      project: model.meta.project,
+      commit: model.meta.commit,
+      checksum: model.meta.checksum,
+      api: model.meta.apiVersion,
+      root: model.meta.rootName
+    },
+    area: {
+      key: model.areaMetric,
+      title: model.areaTitle,
+      total: round(model.totalArea, 1)
+    },
+    lens: model.initialLens,
+    metric: model.initialMetric,
+    metrics: model.metrics.map((metric) => ({
+      key: metric.key,
+      title: metric.title,
+      min: round(metric.min, 2),
+      max: round(metric.max, 2),
+      mode: metric.mode,
+      dir: metric.direction,
+      coverage: metric.coverage
+    })),
+    sections: model.sections.map((section) => ({
+      key: section.key,
+      color: section.color,
+      files: section.files,
+      area: round(section.area, 1)
+    })),
+    dirs: directories,
+    files: fileRows,
+    edges: model.edges.flatMap((edge) => [edge.from, edge.to]),
+    cycles: model.cycles.flatMap((edge) => [edge.from, edge.to]),
+    hot: model.hotspotCount,
+    default: model.defaultSelection,
+    fileCount: model.fileCount,
+    folderCount: model.folderCount,
+    totalArea: round(model.totalArea, 1)
+  };
+}
+function renderLensButtons(model) {
+  const lenses = [
+    { id: "structure", label: "Estructura" },
+    { id: "risk", label: "Riesgo" }
+  ];
+  if (model.metrics.length > 0) lenses.push({ id: "metric", label: "M\xE9trica" });
+  return lenses.map(
+    (lens) => `<button type="button" class="lens" role="tab" data-lens="${lens.id}" aria-selected="${String(
+      model.initialLens === lens.id
+    )}">${lens.label}</button>`
+  ).join("");
+}
+function renderFindings(model) {
+  const chips = [];
+  if (model.hotspotCount > 0) {
+    chips.push(
+      `<button type="button" class="finding" data-focus="hotspot"><i class="dot info"></i><b>${formatInt(
+        model.hotspotCount
+      )}</b> hotspots</button>`
+    );
+  }
+  if (model.cycles.length > 0) {
+    chips.push(
+      `<button type="button" class="finding" data-focus="cycle"><i class="dot warn"></i><b>${formatInt(
+        model.cycles.length
+      )}</b> aristas c\xEDclicas</button>`
+    );
+  }
+  chips.push(
+    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
+      model.fileCount
+    )}</b> ficheros</span>`
+  );
+  chips.push(
+    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
+      model.edges.length
+    )}</b> dependencias</span>`
+  );
+  return `${chips.join("")}<span class="spacer"></span><span id="search-status" class="search-status" aria-live="polite"></span><span class="run-meta">${escapeHtml(
+    model.areaTitle
+  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 cc.json ${escapeHtml(
+    model.meta.apiVersion
+  )}</span>`;
+}
+function metricByKey(model, key) {
+  return key ? model.metrics.find((metric) => metric.key === key) : void 0;
+}
+function renderLegend(model) {
+  if (model.initialLens === "structure") {
+    const items = model.sections.slice(0, 6).map(
+      (section) => `<span><i style="background:${section.color}"></i>${escapeHtml(section.key)}</span>`
+    ).join("");
+    return `<span>Carpeta</span><span class="sws">${items}</span>`;
+  }
+  if (model.initialLens === "metric" && model.initialMetric) {
+    const metric = metricByKey(model, model.initialMetric);
+    if (metric) {
+      const direction = metric.direction === -1 ? " \xB7 menos es mejor" : metric.direction === 1 ? " \xB7 m\xE1s es mejor" : "";
+      return `<span>${escapeHtml(metric.title)}${direction}</span><span class="mono">${escapeHtml(
+        formatCompact(metric.min)
+      )}</span><span class="bar" style="background:${METRIC_GRADIENT}"></span><span class="mono">${escapeHtml(
+        formatCompact(metric.max)
+      )}</span>`;
+    }
+  }
+  return `<span>Riesgo (0\u2013100)</span><span class="mono">0</span><span class="bar" style="background:${RISK_GRADIENT}"></span><span class="mono">100</span>`;
+}
+function renderMetricOptions(model) {
+  return model.metrics.map(
+    (metric) => `<option value="${escapeAttr(metric.key)}"${metric.key === model.initialMetric ? " selected" : ""}>${escapeHtml(metric.title)}</option>`
+  ).join("");
+}
+function renderInspectorSummary(model) {
+  const hotspots = [...model.files].sort((a, b) => b.risk - a.risk || a.path.localeCompare(b.path)).slice(0, 5);
+  return `<div class="summary">
+  <div class="sub">Proyecto</div>
+  <div class="big">${formatInt(model.fileCount)}</div>
+  <div class="sub">ficheros \xB7 ${formatInt(model.folderCount)} carpetas</div>
+  <p>${formatInt(model.totalArea)} de ${escapeHtml(
+    model.areaTitle.toLowerCase()
+  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 ${formatInt(
+    model.hotspotCount
+  )} hotspots.</p>
+  <h4>Mayor riesgo</h4>
+  <ul class="deps">${hotspots.map(
+    (file) => `<li data-file="${file.index}"><i class="sw" style="background:${riskColor(
+      file.risk
+    )}"></i><span>${escapeHtml(file.path)}</span><em>${Math.round(
+      file.risk * 100
+    )}</em></li>`
+  ).join("")}</ul>
+  <p>Selecciona un bloque para ver sus m\xE9tricas y sus dependencias. Clic en la cabecera de una carpeta para enfocarla.</p>
+</div>`;
+}
+function renderHtml(model) {
+  const project = escapeHtml(model.meta.project);
+  const title = escapeHtml(model.meta.title);
+  const commit = model.meta.commit ? model.meta.commit.slice(0, 7) : "";
+  const checksum = model.meta.checksum ? model.meta.checksum.slice(0, 8) : "";
+  const badge = commit || checksum || `cc.json ${model.meta.apiVersion}`;
+  const payload = jsonForScript(serialise(model));
+  const metricPicker = model.metrics.length > 0 ? `<label class="metric-pick" id="metric-pick"${model.initialLens === "metric" ? "" : " hidden"}><span>M\xE9trica</span><select id="metric-select">${renderMetricOptions(
+    model
+  )}</select></label>` : "";
+  const crumbs = model.meta.rootName ? `${project} <span class="sep">/</span> ${escapeHtml(model.meta.rootName)}` : project;
+  return `<!doctype html>
+<html lang="es">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light">
+<meta name="generator" content="CodArch">
+<title>CodArch \xB7 ${title}</title>
+<style>${STYLES}</style>
+</head>
+<body>
+<div class="app">
+  <header>
+    <div class="brand">CodArch</div>
+    <div class="repo">
+      <b>${title}</b>
+      ${model.meta.rootName && model.meta.rootName !== model.meta.project ? `<span>${escapeHtml(model.meta.rootName)}</span>` : ""}
+      <span class="commit">${escapeHtml(badge)}</span>
+    </div>
+    <div class="spacer"></div>
+    <nav class="lenses" role="tablist" aria-label="Lentes">${renderLensButtons(model)}</nav>
+    ${metricPicker}
+    <label class="search">
+      <svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true">
+        <circle cx="7" cy="7" r="4.5" stroke="#8d877d" stroke-width="1.4"/>
+        <path d="M10.5 10.5 14 14" stroke="#8d877d" stroke-width="1.4"/>
+      </svg>
+      <input id="q" type="search" placeholder="Buscar fichero\u2026" autocomplete="off" aria-label="Buscar fichero">
+    </label>
+  </header>
+
+  <div class="findings">${renderFindings(model)}</div>
+
+  <main class="map-wrap">
+    <div class="map" id="map">${renderSvg(model)}</div>
+    <div class="tooltip" id="tooltip"></div>
+  </main>
+
+  <aside id="inspector">${renderInspectorSummary(model)}</aside>
+
+  <footer>
+    <span class="crumbs" id="crumbs">${crumbs}</span>
+    <span class="hint">clic para fijar \xB7 esc para limpiar</span>
+    <span class="legend" id="legend">${renderLegend(model)}</span>
+  </footer>
+</div>
+<script id="codarch-data" type="application/json">${payload}</script>
+<script>${CLIENT}</script>
+</body>
+</html>`;
+}
+
+// apps/cli/src/io.ts
+import fs6 from "node:fs";
+import zlib from "node:zlib";
+function readJsonFile2(file) {
+  const buffer = fs6.readFileSync(file);
+  const isGzip = buffer.length > 2 && buffer[0] === 31 && buffer[1] === 139;
+  const raw = isGzip ? zlib.gunzipSync(buffer) : buffer;
+  const text = raw.toString("utf8");
+  try {
+    return { json: JSON.parse(text), bytes: buffer.length };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`no es JSON v\xE1lido: ${message}`);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// apps/cli/src/commands/analyze.ts
+var numberFormat = new Intl.NumberFormat("es-ES");
+function num(value) {
+  return numberFormat.format(value);
+}
+function field(label, value) {
+  return `  ${label.padEnd(12)} ${value}`;
+}
+function runAnalyze(options) {
+  const root = options.root ?? ".";
+  let result;
+  try {
+    result = analyzeRepository(root, {
+      ignore: options.ignore,
+      projectName: options.projectName,
+      git: options.git
+    });
+  } catch (error) {
+    console.error(`no se pudo analizar ${root}: ${error.message}`);
+    return 1;
+  }
+  let cc;
+  try {
+    cc = parseCcJson(result.snapshot);
+  } catch (error) {
+    if (error instanceof CcJsonError) {
+      console.error(`el snapshot generado no es cc.json v\xE1lido: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+  const outDirectory = path5.resolve(
+    options.out ?? path5.join(path5.resolve(root), ".codarch")
+  );
+  const snapshotPath = path5.join(outDirectory, "snapshot.cc.json");
+  const mapPath = path5.join(outDirectory, "map.html");
+  try {
+    fs7.mkdirSync(outDirectory, { recursive: true });
+    fs7.writeFileSync(
+      snapshotPath,
+      `${JSON.stringify(cc, null, 2)}
+`,
+      "utf8"
+    );
+  } catch (error) {
+    console.error(
+      `no se pudo escribir ${snapshotPath}: ${error.message}`
+    );
+    return 1;
+  }
+  let mapBytes = 0;
+  let mapError = null;
+  if (result.files > 0) {
+    try {
+      const model = buildRenderModel(cc, {
+        areaMetric: "rloc",
+        color: "risk",
+        title: options.title
+      });
+      const html = renderHtml(model);
+      fs7.writeFileSync(mapPath, html, "utf8");
+      mapBytes = Buffer.byteLength(html, "utf8");
+    } catch (error) {
+      mapError = error instanceof RenderError ? error.message : error.message;
+    }
+  } else {
+    mapError = "no hay ficheros TypeScript/JavaScript que dibujar";
+  }
+  const snapshotBytes = Buffer.byteLength(
+    fs7.readFileSync(snapshotPath),
+    "utf8"
+  );
+  const lines = [];
+  lines.push("");
+  lines.push("  CodArch \xB7 an\xE1lisis");
+  lines.push("");
+  lines.push(field("ra\xEDz", path5.resolve(root)));
+  lines.push(field("snapshot", `${snapshotPath} (${formatBytes(snapshotBytes)})`));
+  if (mapError) {
+    lines.push(field("mapa", `omitido (${mapError})`));
+  } else {
+    lines.push(field("mapa", `${mapPath} (${formatBytes(mapBytes)})`));
+  }
+  lines.push(
+    field(
+      "estructura",
+      `${num(result.files)} ficheros \xB7 ${num(result.folders)} carpetas \xB7 ${num(
+        result.edges
+      )} aristas \xB7 ${num(result.cycles.length)} ciclos`
+    )
+  );
+  lines.push(
+    field(
+      "imports",
+      `${num(result.externalImports)} externos \xB7 ${num(
+        result.builtinImports
+      )} builtins \xB7 ${num(result.typeOnlyImports)} type-only \xB7 ${num(
+        result.unresolvedImports
+      )} sin resolver`
+    )
+  );
+  lines.push(field("tiempo", `${num(result.durationMs)} ms`));
+  lines.push(
+    field(
+      "historial",
+      result.git.enabled ? `${num(result.git.commits)} commits \xB7 ${num(
+        result.git.authors
+      )} autores${result.git.shallow ? " \xB7 shallow" : ""}` : "sin git; se omite churn"
+    )
+  );
+  for (const warning of result.warnings.slice(0, 10)) {
+    lines.push(field("aviso", warning));
+  }
+  if (result.warnings.length > 10) {
+    lines.push(field("aviso", `y ${num(result.warnings.length - 10)} m\xE1s`));
+  }
+  for (const issue of result.unresolved.slice(0, 5)) {
+    lines.push(
+      field(
+        "sin resolver",
+        `${issue.file}:${issue.line} ${issue.specifier} (${issue.reason})`
+      )
+    );
+  }
+  if (result.unresolved.length > 5) {
+    lines.push(
+      field("sin resolver", `y ${num(result.unresolved.length - 5)} m\xE1s`)
+    );
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
+}
+
+// apps/cli/src/commands/diff.ts
+import fs8 from "node:fs";
+import path6 from "node:path";
+var numberFormat2 = new Intl.NumberFormat("es-ES");
+function num2(value) {
+  return numberFormat2.format(value);
+}
+function field2(label, value) {
+  return `  ${label.padEnd(12)} ${value}`;
+}
+function signed(value) {
+  if (value === 0) return "0";
+  return value > 0 ? `+${num2(value)}` : num2(value);
+}
+function runDiff(options) {
+  if (!options.base || !options.head) {
+    console.error(
+      "faltan los dos snapshots\n\n  codarch diff <base.cc.json> <head.cc.json> [-o report.json]"
+    );
+    return 1;
+  }
+  const base = loadSnapshot(options.base);
+  if (!base) return 1;
+  const head = loadSnapshot(options.head);
+  if (!head) return 1;
+  let rules;
+  let configPath;
+  try {
+    if (!options.noConfig) {
+      configPath = options.config ?? defaultConfigPath();
+      if (configPath) rules = loadRuleConfig(configPath);
+    }
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(`configuraci\xF3n inv\xE1lida: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+  let report;
+  try {
+    report = diffSnapshots(base, head, {
+      top: options.top,
+      hotspotMetric: options.hotspotMetric,
+      rules
+    });
+  } catch (error) {
+    console.error(`no se pudo comparar: ${error.message}`);
+    return 1;
+  }
+  const outPath = path6.resolve(options.out ?? "report.json");
+  let reportBytes = 0;
+  try {
+    fs8.mkdirSync(path6.dirname(outPath), { recursive: true });
+    const text = `${JSON.stringify(report, null, 2)}
+`;
+    fs8.writeFileSync(outPath, text, "utf8");
+    reportBytes = Buffer.byteLength(text, "utf8");
+  } catch (error) {
+    console.error(
+      `no se pudo escribir ${outPath}: ${error.message}`
+    );
+    return 1;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("  CodArch \xB7 diff");
+  lines.push("");
+  lines.push(field2("base", `${options.base} (${report.base.checksum || "sin checksum"})`));
+  lines.push(field2("head", `${options.head} (${report.head.checksum || "sin checksum"})`));
+  lines.push(
+    field2(
+      "ficheros",
+      `${signed(report.summary.addedFiles)} \xB7 ${signed(
+        -report.summary.removedFiles
+      )} \xB7 ~${num2(report.summary.changedFiles)}`
+    )
+  );
+  lines.push(
+    field2(
+      "aristas",
+      `${signed(report.summary.addedEdges)} \xB7 ${signed(
+        -report.summary.removedEdges
+      )} \xB7 ${num2(report.summary.cyclicEdgesAdded)} c\xEDclicas nuevas`
+    )
+  );
+  lines.push(
+    field2(
+      "ciclos",
+      `${signed(report.summary.introducedCycles)} nuevos \xB7 ${signed(
+        -report.summary.fixedCycles
+      )} resueltos`
+    )
+  );
+  lines.push(
+    field2(
+      "hotspots",
+      report.hotspotMetric ? `${num2(report.summary.hotspots)} (${report.hotspotMetric})` : "sin m\xE9trica de complejidad ni tama\xF1o"
+    )
+  );
+  lines.push(
+    field2(
+      "reglas",
+      report.rules.configured ? `${num2(report.rules.summary.layers)} capas \xB7 ${num2(
+        report.rules.summary.rules
+      )} reglas \xB7 ${num2(report.rules.summary.introduced)} nuevas \xB7 ${num2(
+        report.rules.summary.existing
+      )} existentes${configPath ? ` (${configPath})` : ""}` : "sin configuraci\xF3n"
+    )
+  );
+  lines.push(field2("reporte", `${outPath} (${formatBytes(reportBytes)})`));
+  lines.push("");
+  if (report.cycles.introduced.length === 0) {
+    lines.push("  Sin ciclos nuevos.");
+  } else {
+    lines.push("  Ciclos nuevos:");
+    for (const cycle of report.cycles.introduced.slice(0, 5)) {
+      lines.push(
+        `    \u2717 ${cycle.nodes.map((node) => node.path).join(" \u2192 ")}`
+      );
+    }
+    if (report.cycles.introduced.length > 5) {
+      lines.push(
+        `    \u2026 y ${num2(report.cycles.introduced.length - 5)} m\xE1s`
+      );
+    }
+  }
+  if (report.hotspots.length > 0) {
+    lines.push("");
+    lines.push(`  Hotspots (${report.hotspotMetric}):`);
+    for (const hotspot of report.hotspots.slice(0, 5)) {
+      lines.push(
+        `    \u25CF ${hotspot.path}  ${num2(hotspot.base)} \u2192 ${num2(
+          hotspot.head
+        )} (${signed(hotspot.delta)})`
+      );
+    }
+    if (report.hotspots.length > 5) {
+      lines.push(`    \u2026 y ${num2(report.hotspots.length - 5)} m\xE1s`);
+    }
+  }
+  if (report.rules.violations.introduced.length > 0) {
+    lines.push("");
+    lines.push("  Violaciones nuevas:");
+    for (const violation of report.rules.violations.introduced.slice(0, 5)) {
+      const icon = violation.severity === "error" ? "\u2717" : violation.severity === "warn" ? "!" : "\xB7";
+      lines.push(`    ${icon} [${violation.rule}] ${violation.message}`);
+    }
+    if (report.rules.violations.introduced.length > 5) {
+      lines.push(
+        `    \u2026 y ${num2(report.rules.violations.introduced.length - 5)} m\xE1s`
+      );
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+  const failOn = options.failOn ?? "none";
+  const cyclesFailed = (failOn === "cycles" || failOn === "any") && report.summary.introducedCycles > 0;
+  const hotspotsFailed = (failOn === "hotspots" || failOn === "any") && report.summary.hotspots > 0;
+  const violationsFailed = (failOn === "violations" || failOn === "any") && report.rules.summary.introducedErrors > 0;
+  if (cyclesFailed || hotspotsFailed || violationsFailed) {
+    console.error(
+      `  gate fallido: ${[
+        cyclesFailed ? "ciclos nuevos" : "",
+        hotspotsFailed ? "hotspots" : "",
+        violationsFailed ? "violaciones nuevas" : ""
+      ].filter(Boolean).join(" + ")}`
+    );
+    return 2;
+  }
+  return 0;
+}
+function loadSnapshot(file) {
+  let loaded;
+  try {
+    loaded = readJsonFile2(file);
+  } catch (error) {
+    console.error(`no se pudo leer ${file}: ${error.message}`);
+    return null;
+  }
+  try {
+    return parseCcJson(loaded.json);
+  } catch (error) {
+    if (error instanceof CcJsonError) {
+      console.error(`cc.json inv\xE1lido en ${file}: ${error.message}`);
+      return null;
+    }
+    throw error;
+  }
+}
+function defaultConfigPath() {
+  for (const file of [".codarch.yml", ".codarch.yaml"]) {
+    if (fs8.existsSync(file)) return file;
+  }
+  return void 0;
+}
+
+// apps/cli/src/commands/inspect.ts
+var numberFormat3 = new Intl.NumberFormat("es-ES");
+function num3(value) {
+  return numberFormat3.format(value);
+}
+function field3(label, value) {
+  return `  ${label.padEnd(12)} ${value}`;
+}
+function truncateLeft(value, max = 78) {
+  if (value.length <= max) return value;
+  return `\u2026${value.slice(value.length - max + 1)}`;
+}
+function shortChecksum(value) {
+  return value ? `${value.slice(0, 8)}\u2026` : "\u2014";
+}
+function runInspect(options) {
+  if (!options.file) {
+    console.error("falta la ruta del fichero cc.json\n\n  codarch inspect <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 cc;
+  try {
+    cc = parseCcJson(loaded.json);
+  } catch (error) {
+    if (error instanceof CcJsonError) {
+      console.error(`cc.json inv\xE1lido: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+  const stats = getStats(cc);
+  const metric = options.metric ?? defaultMetric(stats);
+  const top = metric ? topByMetric(cc, metric, options.top) : [];
+  const rootPrefix = cc.files.length === 1 ? `${cc.files[0]?.name}/` : "";
+  const displayPath = (path8) => rootPrefix && path8.startsWith(rootPrefix) ? path8.slice(rootPrefix.length) : path8;
+  if (options.metric && !stats.metricCoverage.some((entry) => entry.name === options.metric)) {
+    console.error(`la m\xE9trica "${options.metric}" no existe en este fichero`);
+    return 1;
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          file: options.file,
+          meta: cc.meta,
+          stats,
+          metric: metric ?? null,
+          top
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("  CodArch \xB7 inspecci\xF3n");
+  lines.push("");
+  lines.push(field3("fichero", `${options.file} (${formatBytes(loaded.bytes)})`));
+  lines.push(field3("formato", `cc.json ${cc.meta.apiVersion}`));
+  lines.push(field3("proyecto", cc.meta.projectName || "(sin nombre)"));
+  lines.push(field3("checksum", shortChecksum(cc.meta.checksum)));
+  lines.push(field3("commit", cc.meta.commitHash || "\u2014"));
+  lines.push("");
+  lines.push(
+    field3(
+      "estructura",
+      `${num3(stats.files)} ficheros \xB7 ${num3(stats.folders)} carpetas \xB7 profundidad ${stats.maxDepth}`
+    )
+  );
+  lines.push(field3("lentes", stats.lenses.length ? stats.lenses.join(" \xB7 ") : "ninguna"));
+  const coverage = metric ? stats.metricCoverage.find((entry) => entry.name === metric) : void 0;
+  lines.push(
+    field3(
+      "m\xE9tricas",
+      `${num3(stats.metricNames)} distintas` + (coverage ? ` \xB7 ${metric} en ${num3(coverage.files)} ficheros` : "")
+    )
+  );
+  lines.push(
+    field3("aristas", `${num3(stats.edges)} \xB7 leafEdges ${num3(stats.leafEdges)}`)
+  );
+  if (stats.orphanMetricNodes > 0) {
+    lines.push(field3("hu\xE9rfanos", `${num3(stats.orphanMetricNodes)} nodos de m\xE9tricas sin fichero`));
+  }
+  if (metric && top.length > 0) {
+    lines.push("");
+    lines.push(`  Top ${top.length} por ${metric}`);
+    const width = Math.max(...top.map((entry) => num3(entry.value).length));
+    for (const entry of top) {
+      lines.push(`    ${num3(entry.value).padStart(width)}  ${truncateLeft(displayPath(entry.path))}`);
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
+}
+
+// apps/cli/src/commands/render.ts
+import fs9 from "node:fs";
+import path7 from "node:path";
+function defaultOutputPath(input) {
+  const lower = input.toLowerCase();
+  const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
+  for (const suffix of suffixes) {
+    if (lower.endsWith(suffix)) return `${input.slice(0, -suffix.length)}.html`;
+  }
+  return `${input}.html`;
+}
+function defaultProjectName(input) {
+  let name = path7.basename(input.replace(/\\/g, "/"));
+  const lower = name.toLowerCase();
+  const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
+  for (const suffix of suffixes) {
+    if (lower.endsWith(suffix)) {
+      name = name.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return name || "Proyecto sin nombre";
+}
+var numberFormat4 = new Intl.NumberFormat("es-ES");
+function num4(value) {
+  return numberFormat4.format(value);
+}
+function field4(label, value) {
+  return `  ${label.padEnd(12)} ${value}`;
+}
+function runRender(options) {
+  if (!options.file) {
+    console.error(
+      "falta la ruta del fichero cc.json\n\n  codarch render <fichero.cc.json[.gz]> [-o mapa.html]"
+    );
+    return 1;
+  }
+  let loaded;
+  try {
+    loaded = readJsonFile2(options.file);
+  } catch (error) {
+    console.error(`no se pudo leer ${options.file}: ${error.message}`);
+    return 1;
+  }
+  let cc;
+  try {
+    cc = parseCcJson(loaded.json);
+  } catch (error) {
+    if (error instanceof CcJsonError) {
+      console.error(`cc.json inv\xE1lido: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+  const started = Date.now();
+  let model;
+  try {
+    model = buildRenderModel(cc, {
+      areaMetric: options.area,
+      color: options.color,
+      title: options.title ?? (cc.meta.projectName ? void 0 : defaultProjectName(options.file))
+    });
+  } catch (error) {
+    if (error instanceof RenderError) {
+      console.error(`no se pudo construir el mapa: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+  let html;
+  try {
+    html = renderHtml(model);
+  } catch (error) {
+    console.error(`no se pudo generar el HTML: ${error.message}`);
+    return 1;
+  }
+  const elapsed = Date.now() - started;
+  const out = options.out ?? defaultOutputPath(options.file);
+  try {
+    fs9.mkdirSync(path7.dirname(path7.resolve(out)), { recursive: true });
+    fs9.writeFileSync(out, html, "utf8");
+  } catch (error) {
+    console.error(`no se pudo escribir ${out}: ${error.message}`);
+    return 1;
+  }
+  const bytes = Buffer.byteLength(html, "utf8");
+  const lens = model.initialLens === "structure" ? "estructura" : model.initialLens === "risk" ? "riesgo" : model.initialMetric ?? "m\xE9trica";
+  const lines = [];
+  lines.push("");
+  lines.push("  CodArch \xB7 mapa");
+  lines.push("");
+  lines.push(field4("fichero", `${options.file} (${formatBytes(loaded.bytes)})`));
+  lines.push(field4("salida", `${out} (${formatBytes(bytes)})`));
+  lines.push(
+    field4(
+      "estructura",
+      `${num4(model.fileCount)} ficheros \xB7 ${num4(model.folderCount)} carpetas \xB7 ${num4(
+        model.metrics.length
+      )} m\xE9tricas`
+    )
+  );
+  lines.push(
+    field4("\xE1rea", `${model.areaMetric ?? "(sin m\xE9trica)"} \xB7 ${num4(model.totalArea)} en total`)
+  );
+  lines.push(field4("color", `${lens} \xB7 ${num4(model.hotspotCount)} hotspots`));
+  lines.push(
+    field4(
+      "dependencias",
+      `${num4(model.edges.length)} aristas \xB7 ${num4(model.cycles.length)} c\xEDclicas`
+    )
+  );
+  lines.push(field4("tiempo", `${num4(elapsed)} ms`));
+  for (const warning of model.warnings) {
+    lines.push(field4("aviso", warning));
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
+}
+
+// apps/cli/src/index.ts
+var VERSION = true ? "0.1.0" : "0.0.0";
+var USAGE = `
+CodArch \xB7 mapa vivo de la arquitectura de tu software
+
+Uso:
+  codarch analyze [ruta] [opciones]
+  codarch inspect <fichero.cc.json[.gz]> [opciones]
+  codarch render  <fichero.cc.json[.gz]> [opciones]
+  codarch diff    <base.cc.json[.gz]> <head.cc.json[.gz]> [opciones]
+
+Opciones de analyze:
+  -o, --out <dir>    directorio de salida (por defecto <ruta>/.codarch)
+  --ignore <patr\xF3n>  excluir rutas (repetible)
+  --project <nombre> nombre del proyecto en el snapshot
+  --title <texto>    t\xEDtulo del mapa
+  --no-git           no leer churn del historial git
+  -h, --help         esta ayuda
+  -v, --version      versi\xF3n
+
+Opciones de inspect:
+  --json            salida machine-readable
+  --top <n>         n\xFAmero de ficheros en el ranking (por defecto 5)
+  --metric <nombre> m\xE9trica del ranking (por defecto rloc)
+  -h, --help        esta ayuda
+  -v, --version     versi\xF3n
+
+Opciones de render:
+  -o, --out <html>  fichero de salida (por defecto, junto al cc.json)
+  --area <m\xE9trica>  m\xE9trica que decide el \xE1rea (por defecto rloc)
+  --color <modo>    risk | structure | <m\xE9trica> (por defecto risk)
+  --title <texto>   t\xEDtulo del proyecto en el mapa
+  -h, --help        esta ayuda
+
+Opciones de diff:
+  -o, --out <file>  reporte JSON (por defecto report.json)
+  --top <n>         hotspots en el reporte (por defecto 10)
+  --hotspot-metric <m\xE9trica>  por defecto maxComplexity, luego rloc
+  --config <file>   reglas YAML (por defecto .codarch.yml si existe)
+  --no-config       no cargar reglas
+  --fail-on <modo>  none | cycles | violations | hotspots | any (por defecto none)
+  -h, --help        esta ayuda
+
+Ejemplos:
+  codarch analyze .
+  codarch analyze . -o .codarch --title "Mi proyecto"
+  codarch inspect samples/codecharta_visualization.cc.json.gz
+  codarch render samples/codecharta_visualization.cc.json.gz
+  codarch render mapa.cc.json -o mapa.html --area rloc --color maxComplexity
+  codarch diff base.cc.json head.cc.json -o report.json --fail-on cycles
+`;
+function parseAnalyze(args) {
+  const options = { help: false, ignore: [] };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--out" || arg === "-o") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--out necesita una ruta");
+        return 1;
+      }
+      options.out = value;
+    } else if (arg.startsWith("--out=")) {
+      options.out = arg.slice("--out=".length);
+    } else if (arg === "--ignore") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--ignore necesita un patr\xF3n");
+        return 1;
+      }
+      options.ignore?.push(value);
+    } else if (arg.startsWith("--ignore=")) {
+      options.ignore?.push(arg.slice("--ignore=".length));
+    } else if (arg === "--project") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--project necesita un nombre");
+        return 1;
+      }
+      options.projectName = value;
+    } else if (arg.startsWith("--project=")) {
+      options.projectName = arg.slice("--project=".length);
+    } else if (arg === "--title") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--title necesita un texto");
+        return 1;
+      }
+      options.title = value;
+    } else if (arg.startsWith("--title=")) {
+      options.title = arg.slice("--title=".length);
+    } else if (arg === "--no-git") {
+      options.git = false;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      return 0;
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      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.root = positional[0] ?? ".";
+  return options;
+}
+function parseInspect(args) {
+  const options = { json: false, top: 5, help: false };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--top") {
+      const value = args[++index];
+      const parsed = Number(value);
+      if (!value || !Number.isInteger(parsed) || parsed < 1) {
+        console.error("--top necesita un entero positivo");
+        return 1;
+      }
+      options.top = parsed;
+    } else if (arg.startsWith("--top=")) {
+      const parsed = Number(arg.slice("--top=".length));
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        console.error("--top necesita un entero positivo");
+        return 1;
+      }
+      options.top = parsed;
+    } else if (arg === "--metric") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--metric necesita un nombre");
+        return 1;
+      }
+      options.metric = value;
+    } else if (arg.startsWith("--metric=")) {
+      options.metric = arg.slice("--metric=".length);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      return 0;
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      return 0;
+    } else if (arg.startsWith("-")) {
+      console.error(`opci\xF3n desconocida: ${arg}`);
+      return 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  options.file = positional[0];
+  return options;
+}
+function parseRender(args) {
+  const options = { help: false };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--out" || arg === "-o") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--out necesita una ruta");
+        return 1;
+      }
+      options.out = value;
+    } else if (arg.startsWith("--out=")) {
+      options.out = arg.slice("--out=".length);
+    } else if (arg === "--area") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--area necesita un nombre de m\xE9trica");
+        return 1;
+      }
+      options.area = value;
+    } else if (arg.startsWith("--area=")) {
+      options.area = arg.slice("--area=".length);
+    } else if (arg === "--color") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--color necesita risk, structure o una m\xE9trica");
+        return 1;
+      }
+      options.color = value;
+    } else if (arg.startsWith("--color=")) {
+      options.color = arg.slice("--color=".length);
+    } else if (arg === "--title") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--title necesita un texto");
+        return 1;
+      }
+      options.title = value;
+    } else if (arg.startsWith("--title=")) {
+      options.title = arg.slice("--title=".length);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      return 0;
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      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 parseDiff(args) {
+  const options = { help: false, top: 10, failOn: "none" };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--out" || arg === "-o") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--out necesita una ruta");
+        return 1;
+      }
+      options.out = value;
+    } else if (arg.startsWith("--out=")) {
+      options.out = arg.slice("--out=".length);
+    } else if (arg === "--top") {
+      const value = args[++index];
+      const parsed = Number(value);
+      if (!value || !Number.isInteger(parsed) || parsed < 1) {
+        console.error("--top necesita un entero positivo");
+        return 1;
+      }
+      options.top = parsed;
+    } else if (arg.startsWith("--top=")) {
+      const parsed = Number(arg.slice("--top=".length));
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        console.error("--top necesita un entero positivo");
+        return 1;
+      }
+      options.top = parsed;
+    } else if (arg === "--hotspot-metric") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--hotspot-metric necesita un nombre");
+        return 1;
+      }
+      options.hotspotMetric = value;
+    } else if (arg.startsWith("--hotspot-metric=")) {
+      options.hotspotMetric = arg.slice("--hotspot-metric=".length);
+    } else if (arg === "--config") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--config necesita una ruta");
+        return 1;
+      }
+      options.config = value;
+    } else if (arg.startsWith("--config=")) {
+      options.config = arg.slice("--config=".length);
+    } else if (arg === "--no-config") {
+      options.noConfig = true;
+    } else if (arg === "--fail-on") {
+      const value = args[++index];
+      if (!isFailOn(value)) {
+        console.error(
+          "--fail-on necesita none, cycles, violations, hotspots o any"
+        );
+        return 1;
+      }
+      options.failOn = value;
+    } else if (arg.startsWith("--fail-on=")) {
+      const value = arg.slice("--fail-on=".length);
+      if (!isFailOn(value)) {
+        console.error(
+          "--fail-on necesita none, cycles, violations, hotspots o any"
+        );
+        return 1;
+      }
+      options.failOn = value;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      return 0;
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      return 0;
+    } else if (arg.startsWith("-")) {
+      console.error(`opci\xF3n desconocida: ${arg}`);
+      return 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length !== 2) {
+    console.error("diff necesita exactamente dos snapshots: base y head");
+    return 1;
+  }
+  options.base = positional[0];
+  options.head = positional[1];
+  return options;
+}
+function isFailOn(value) {
+  return value === "none" || value === "cycles" || value === "violations" || value === "hotspots" || value === "any";
+}
+function main(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    return 0;
+  }
+  if (command === "analyze") {
+    const parsed = parseAnalyze(rest);
+    if (typeof parsed === "number") return parsed;
+    return runAnalyze(parsed);
+  }
+  if (command === "inspect") {
+    const parsed = parseInspect(rest);
+    if (typeof parsed === "number") return parsed;
+    return runInspect(parsed);
+  }
+  if (command === "render") {
+    const parsed = parseRender(rest);
+    if (typeof parsed === "number") return parsed;
+    return runRender(parsed);
+  }
+  if (command === "diff") {
+    const parsed = parseDiff(rest);
+    if (typeof parsed === "number") return parsed;
+    return runDiff(parsed);
+  }
+  console.error(`comando desconocido: ${command}
+${USAGE}`);
+  return 1;
+}
+process.exitCode = main(process.argv.slice(2));