codarch 0.1.0 → 0.1.1

package/README.md

@@ -42,6 +42,19 @@ codarch diff base.cc.json head.cc.json -o report.json --config .codarch.yml --fa
 Códigos de salida de `diff`: `0` sin bloqueo, `2` política incumplida, `1` error de lectura o
 configuración.
 
+## Lente de migración
+
+`analyze` mide TS/JS, Rust y artefactos `.wasm`/`.node`. El snapshot incluye la lente `migration` y
+las métricas `migrationDebt` (complejidad × consumidores) y `ffiCrossings`.
+
+```bash
+codarch inspect .codarch/snapshot.cc.json --metric migrationDebt --top 10
+codarch render .codarch/snapshot.cc.json --area rloc --color migrationDebt -o migration.html
+```
+
+Rust se mide con un escáner léxico; las aristas napi no se inventan si el glue generado no está en el
+fuente. Ver [`docs/migration.md`](https://github.com/jaminsmoke/codarch/blob/main/docs/migration.md).
+
 ## Reglas
 
 `.codarch.yml` define capas, dependencias prohibidas, umbrales y ciclos. Solo bloquean las

package/index.js

@@ -1544,6 +1544,240 @@ function runGit(cwd, args, maxBuffer) {
   return { ok: true, stdout: result.stdout ?? "", error: "" };
 }
 
+// packages/parsers/src/migration.ts
+var EXTENSION_LANGUAGE = {
+  ".ts": "ts",
+  ".tsx": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".js": "js",
+  ".jsx": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".rs": "rust",
+  ".wasm": "wasm",
+  ".node": "node"
+};
+var MIGRATION_EXTENSIONS = Object.keys(EXTENSION_LANGUAGE);
+var LANGUAGE_ORDER = ["ts", "js", "rust", "wasm", "node"];
+var RUST_BRIDGE = /#\[\s*(?:napi|wasm_bindgen)(?:\(|\])|\bnapi_derive\b|\bnapi::|\bwasm_bindgen(?:::|\b)|\bwasm-pack\b/;
+var JS_FFI = /\bWebAssembly\s*\.\s*(?:instantiate|compile|Module|Instance)\b|\bprocess\.dlopen\b/;
+function languageForPath(relativePath2) {
+  const lower = relativePath2.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  if (dot === -1) return null;
+  return EXTENSION_LANGUAGE[lower.slice(dot)] ?? null;
+}
+function isTsJsLanguage(language) {
+  return language === "ts" || language === "js";
+}
+function isNativeLanguage(language) {
+  return language === "wasm" || language === "node";
+}
+function measureRustSource(source) {
+  if (source.length === 0) return { loc: 0, rloc: 0 };
+  const loc = countPhysicalLines(source);
+  const codeLines = /* @__PURE__ */ new Set();
+  let line = 0;
+  let lineHasCode = false;
+  let blockDepth = 0;
+  let inString = false;
+  let inChar = false;
+  let escaped = false;
+  let rawHashes = -1;
+  const mark = () => {
+    lineHasCode = true;
+  };
+  const newline = () => {
+    if (lineHasCode) codeLines.add(line);
+    line++;
+    lineHasCode = inString || rawHashes >= 0;
+  };
+  for (let index = 0; index < source.length; index++) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (current === "\r") {
+      if (next === "\n") continue;
+      newline();
+      continue;
+    }
+    if (current === "\n") {
+      newline();
+      continue;
+    }
+    if (blockDepth > 0) {
+      if (current === "/" && next === "*") {
+        blockDepth++;
+        index++;
+      } else if (current === "*" && next === "/") {
+        blockDepth--;
+        index++;
+      }
+      continue;
+    }
+    if (rawHashes >= 0) {
+      if (current === '"') {
+        let hashes = 0;
+        while (source[index + 1 + hashes] === "#") hashes++;
+        if (hashes >= rawHashes) {
+          index += rawHashes;
+          rawHashes = -1;
+        }
+      }
+      continue;
+    }
+    if (inString) {
+      mark();
+      if (escaped) escaped = false;
+      else if (current === "\\") escaped = true;
+      else if (current === '"') inString = false;
+      continue;
+    }
+    if (inChar) {
+      mark();
+      if (escaped) escaped = false;
+      else if (current === "\\") escaped = true;
+      else if (current === "'") inChar = false;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      while (index + 1 < source.length && source[index + 1] !== "\n" && source[index + 1] !== "\r") {
+        index++;
+      }
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      blockDepth = 1;
+      index++;
+      continue;
+    }
+    if (current === "r" || current === "b" && next === "r") {
+      let cursor = current === "r" ? index + 1 : index + 2;
+      let hashes = 0;
+      while (source[cursor] === "#") {
+        hashes++;
+        cursor++;
+      }
+      if (source[cursor] === '"') {
+        rawHashes = hashes;
+        index = cursor;
+        mark();
+        continue;
+      }
+    }
+    if (current === '"') {
+      inString = true;
+      mark();
+      continue;
+    }
+    if (current === "'" && isRustCharLiteral(source, index)) {
+      inChar = true;
+      mark();
+      continue;
+    }
+    if (current.trim() !== "") mark();
+  }
+  if (lineHasCode) codeLines.add(line);
+  return { loc, rloc: codeLines.size };
+}
+function rustIsBridge(source) {
+  return RUST_BRIDGE.test(source);
+}
+function jsIsBridge(source, specifiers) {
+  return specifiers.some((specifier) => ffiKindForSpecifier(specifier) !== null) || JS_FFI.test(source);
+}
+function ffiKindForSpecifier(specifier) {
+  const clean = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+  if (clean.endsWith(".wasm")) return "wasm";
+  if (clean.endsWith(".node")) return "native";
+  return null;
+}
+function buildMigration(files, links) {
+  const sortedFiles = [...files].sort(
+    (left, right) => compareStrings2(left.relativePath, right.relativePath)
+  );
+  const sortedLinks = [...links].sort(
+    (left, right) => compareStrings2(left.from, right.from) || compareStrings2(left.to, right.to) || compareStrings2(left.kind, right.kind)
+  );
+  const crossings = /* @__PURE__ */ new Map();
+  for (const link of sortedLinks) {
+    crossings.set(link.from, (crossings.get(link.from) ?? 0) + 1);
+    crossings.set(link.to, (crossings.get(link.to) ?? 0) + 1);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const status = {
+    js: 0,
+    rust: 0,
+    bridge: 0,
+    native: 0
+  };
+  const languageStats = /* @__PURE__ */ new Map();
+  let migrationDebt = 0;
+  let ffiCrossings = 0;
+  for (const file of sortedFiles) {
+    const fileStatus = isNativeLanguage(file.language) ? "native" : file.bridge ? "bridge" : file.language === "rust" ? "rust" : "js";
+    const debt = isTsJsLanguage(file.language) ? (file.maxComplexity + 1) * (1 + file.fanIn) : void 0;
+    const fileCrossings = crossings.get(file.relativePath) ?? 0;
+    nodes.set(file.relativePath, {
+      language: file.language,
+      status: fileStatus,
+      loc: file.loc,
+      rloc: file.rloc,
+      ...debt !== void 0 ? { debt } : {},
+      crossings: fileCrossings
+    });
+    status[fileStatus]++;
+    migrationDebt += debt ?? 0;
+    ffiCrossings += fileCrossings;
+    const stats = languageStats.get(file.language) ?? { files: 0, loc: 0, rloc: 0 };
+    stats.files++;
+    stats.loc += file.loc;
+    stats.rloc += file.rloc;
+    languageStats.set(file.language, stats);
+  }
+  const languages = {};
+  for (const language of LANGUAGE_ORDER) {
+    const stats = languageStats.get(language);
+    if (stats) languages[language] = stats;
+  }
+  return {
+    nodes,
+    edges: sortedLinks,
+    summary: {
+      files: sortedFiles.length,
+      languages,
+      status,
+      bridgeFiles: status.bridge,
+      ffiEdges: sortedLinks.length,
+      ffiCrossings,
+      migrationDebt
+    }
+  };
+}
+function isRustCharLiteral(source, index) {
+  const next = source[index + 1];
+  if (next === void 0 || next === "\n" || next === "\r") return false;
+  if (next === "\\") return true;
+  return source[index + 2] === "'";
+}
+function countPhysicalLines(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 compareStrings2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
 // packages/parsers/src/snapshot.ts
 import { createHash as createHash2 } from "node:crypto";
 var METRIC_DESCRIPTORS = {
@@ -1631,6 +1865,16 @@ var METRIC_DESCRIPTORS = {
     title: "Nivel de dependencia",
     description: "Profundidad en el DAG de dependencias",
     direction: 0
+  },
+  migrationDebt: {
+    title: "Deuda de migraci\xF3n",
+    description: "(maxComplexity + 1) \xD7 (1 + fan-in); 0 si ya es Rust o nativo",
+    direction: -1
+  },
+  ffiCrossings: {
+    title: "Cruces FFI",
+    description: "Aristas WASM/native que tocan el fichero",
+    direction: -1
   }
 };
 var METRIC_ORDER = Object.keys(METRIC_DESCRIPTORS);
@@ -1648,7 +1892,7 @@ var EDGE_DESCRIPTORS = {
 };
 function buildSnapshot(input) {
   const files = [...input.files].sort(
-    (left, right) => compareStrings2(left.relativePath, right.relativePath)
+    (left, right) => compareStrings3(left.relativePath, right.relativePath)
   );
   const rootName = sanitizeNodeName(input.projectName);
   const root = {
@@ -1713,6 +1957,7 @@ function buildSnapshot(input) {
   for (const [path8, metrics] of input.graph.metrics) {
     dependencyNodes[fileId(path8)] = { level: metrics.dependencyLevel };
   }
+  const migrationLens = input.migration ? migrationLensFrom(input.migration) : void 0;
   const lenses = {
     metrics: {
       attributes,
@@ -1727,7 +1972,8 @@ function buildSnapshot(input) {
         weight: "absolute",
         typeOnly: "absolute"
       }
-    }
+    },
+    ...migrationLens ? { migration: migrationLens } : {}
   };
   return {
     meta: {
@@ -1739,6 +1985,24 @@ function buildSnapshot(input) {
     lenses
   };
 }
+function migrationLensFrom(migration) {
+  const nodes = {};
+  for (const [relativePath2, node] of migration.nodes) {
+    nodes[fileId(relativePath2)] = node;
+  }
+  const edges = migration.edges.map((edge) => ({
+    fromId: fileId(edge.from),
+    toId: fileId(edge.to),
+    kind: edge.kind
+  })).sort(
+    (left, right) => compareStrings3(left.fromId, right.fromId) || compareStrings3(left.toId, right.toId) || compareStrings3(left.kind, right.kind)
+  );
+  return {
+    nodes,
+    edges,
+    summary: migration.summary
+  };
+}
 function checksumFor(files, lenses) {
   return createHash2("md5").update(stableStringify({ files, lenses }), "utf8").digest("hex");
 }
@@ -1764,7 +2028,7 @@ 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);
+    return compareStrings3(left.name, right.name);
   });
   for (const child of node.children) sortChildren(child);
 }
@@ -1772,7 +2036,7 @@ function sanitizeNodeName(name) {
   const sanitized = name.replace(/[\\/]/g, "-").trim();
   return sanitized && sanitized !== "." && sanitized !== ".." ? sanitized : "Proyecto";
 }
-function compareStrings2(left, right) {
+function compareStrings3(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
@@ -1881,19 +2145,39 @@ function analyzeRepository(rootInput, options = {}) {
   const projectName = options.projectName ?? readProjectName(root);
   const walked = walkSourceFiles(root, {
     ignore: options.ignore,
-    extensions: options.extensions
+    extensions: options.extensions ?? MIGRATION_EXTENSIONS
   });
   const warnings = [...walked.warnings];
   const resolver = new ImportResolver(root, walked.files);
   warnings.push(...resolver.warnings);
   const parser = new TypeScriptParser();
   const parsedFiles = [];
+  const migrationFiles = [];
+  const migrationLinks = [];
   const links = [];
   const unresolved = [];
   let externalImports = 0;
   let builtinImports = 0;
   let typeOnlyImports = 0;
   for (const file of walked.files) {
+    const language = languageForPath(file.relativePath);
+    if (!language) continue;
+    if (isNativeLanguage(language)) {
+      parsedFiles.push({
+        relativePath: file.relativePath,
+        metrics: { loc: 0, rloc: 0 }
+      });
+      migrationFiles.push({
+        relativePath: file.relativePath,
+        language,
+        loc: 0,
+        rloc: 0,
+        maxComplexity: 0,
+        fanIn: 0,
+        bridge: false
+      });
+      continue;
+    }
     let source;
     try {
       source = fs4.readFileSync(file.absolutePath, "utf8");
@@ -1903,6 +2187,23 @@ function analyzeRepository(rootInput, options = {}) {
       );
       continue;
     }
+    if (language === "rust") {
+      const measured = measureRustSource(source);
+      parsedFiles.push({
+        relativePath: file.relativePath,
+        metrics: { loc: measured.loc, rloc: measured.rloc }
+      });
+      migrationFiles.push({
+        relativePath: file.relativePath,
+        language,
+        loc: measured.loc,
+        rloc: measured.rloc,
+        maxComplexity: 0,
+        fanIn: 0,
+        bridge: rustIsBridge(source)
+      });
+      continue;
+    }
     let parsed;
     try {
       parsed = parser.parse(source, file.relativePath);
@@ -1920,11 +2221,20 @@ function analyzeRepository(rootInput, options = {}) {
       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
-        });
+        const targetLanguage = languageForPath(result.file.relativePath);
+        if (targetLanguage === "wasm" || targetLanguage === "node") {
+          migrationLinks.push({
+            from: file.relativePath,
+            to: result.file.relativePath,
+            kind: targetLanguage === "wasm" ? "wasm" : "native"
+          });
+        } else {
+          links.push({
+            from: file.relativePath,
+            to: result.file.relativePath,
+            typeOnly: imported.typeOnly
+          });
+        }
       } else if (result.kind === "external") {
         if (result.builtin) fileBuiltinImports++;
         else fileExternalImports++;
@@ -1952,6 +2262,18 @@ function analyzeRepository(rootInput, options = {}) {
         unresolvedImports: fileUnresolvedImports
       }
     });
+    migrationFiles.push({
+      relativePath: file.relativePath,
+      language,
+      loc: parsed.metrics.loc ?? 0,
+      rloc: parsed.metrics.rloc ?? 0,
+      maxComplexity: parsed.metrics.maxComplexity ?? 0,
+      fanIn: 0,
+      bridge: jsIsBridge(
+        source,
+        parsed.imports.map((imported) => imported.specifier)
+      )
+    });
   }
   const git = collectGitChurn(
     root,
@@ -1981,6 +2303,16 @@ function analyzeRepository(rootInput, options = {}) {
       file.metrics.dependencyLevel = metrics.dependencyLevel;
     }
   }
+  for (const file of migrationFiles) {
+    file.fanIn = graph.metrics.get(file.relativePath)?.fanIn ?? 0;
+  }
+  const migration = buildMigration(migrationFiles, migrationLinks);
+  for (const file of parsedFiles) {
+    const node = migration.nodes.get(file.relativePath);
+    if (!node) continue;
+    file.metrics.ffiCrossings = node.crossings;
+    if (node.debt !== void 0) file.metrics.migrationDebt = node.debt;
+  }
   if (unresolved.length > 0) {
     warnings.push(
       `${unresolved.length} imports sin resolver; se excluyen del grafo`
@@ -1989,7 +2321,8 @@ function analyzeRepository(rootInput, options = {}) {
   const snapshot = buildSnapshot({
     projectName,
     files: parsedFiles,
-    graph
+    graph,
+    migration
   });
   let folders = 0;
   walkTree(snapshot.files, (entry) => {
@@ -2019,6 +2352,7 @@ function analyzeRepository(rootInput, options = {}) {
       authors: git.authors,
       shallow: git.shallow
     },
+    migration: migration.summary,
     durationMs: Date.now() - started
   };
 }
@@ -2369,9 +2703,9 @@ function cycleMessage(paths) {
   return `Ciclo de ${paths.length} ficheros: ${visible.join(" \u2192 ")}${suffix}`;
 }
 function compareViolations(left, right) {
-  return compareStrings3(left.key, right.key);
+  return compareStrings4(left.key, right.key);
 }
-function compareStrings3(left, right) {
+function compareStrings4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
@@ -2431,7 +2765,7 @@ function indexSnapshot(cc) {
     });
   }
   const nodes = [...paths.keys()].sort(
-    (left, right) => compareStrings4(paths.get(left) ?? left, paths.get(right) ?? right)
+    (left, right) => compareStrings5(paths.get(left) ?? left, paths.get(right) ?? right)
   );
   const metrics = cc.lenses?.metrics?.attributes ?? {};
   const edges = /* @__PURE__ */ new Map();
@@ -2494,7 +2828,7 @@ function changedFiles(base, head) {
     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)) {
+    for (const metric of [...keys].sort(compareStrings5)) {
       const baseValue = finiteNumber(baseValues[metric]);
       const headValue = finiteNumber(headValues[metric]);
       if (baseValue === null && headValue === null) continue;
@@ -2554,10 +2888,10 @@ function cycleGroups(index) {
     reverse.get(edge.toId)?.push(edge.fromId);
   }
   for (const [node, neighbors] of adjacency) {
-    adjacency.set(node, [...new Set(neighbors)].sort(compareStrings4));
+    adjacency.set(node, [...new Set(neighbors)].sort(compareStrings5));
   }
   for (const [node, neighbors] of reverse) {
-    reverse.set(node, [...new Set(neighbors)].sort(compareStrings4));
+    reverse.set(node, [...new Set(neighbors)].sort(compareStrings5));
   }
   const visited = /* @__PURE__ */ new Set();
   const order = [];
@@ -2611,9 +2945,9 @@ function cycleGroups(index) {
       id,
       path: index.paths.get(id) ?? id
     })).sort((left, right) => {
-      return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+      return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
     });
-    const key = [...component].sort(compareStrings4).join("\0");
+    const key = [...component].sort(compareStrings5).join("\0");
     groups.set(key, { key, component: { size: nodes.length, nodes } });
   }
   return groups;
@@ -2680,13 +3014,13 @@ function buildHotspots(base, head, added, changed, metric, top) {
     });
   }
   return hotspots.sort(
-    (left, right) => right.delta - left.delta || right.head - left.head || compareStrings4(left.path, right.path)
+    (left, right) => right.delta - left.delta || right.head - left.head || compareStrings5(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)) {
+  for (const key of Object.keys(values).sort(compareStrings5)) {
     const value = finiteNumber(values[key]);
     if (value !== null) sorted[key] = value;
   }
@@ -2699,21 +3033,21 @@ function edgeKey(fromId, toId) {
   return `${fromId}\0${toId}`;
 }
 function compareFiles(left, right) {
-  return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+  return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
 }
 function compareChangedFiles(left, right) {
-  return compareStrings4(left.path, right.path) || compareStrings4(left.id, right.id);
+  return compareStrings5(left.path, right.path) || compareStrings5(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);
+  return compareStrings5(left.from, right.from) || compareStrings5(left.to, right.to) || compareStrings5(left.fromId, right.fromId) || compareStrings5(left.toId, right.toId);
 }
 function compareCycles(left, right) {
-  return compareStrings4(
+  return compareStrings5(
     left.nodes[0]?.path ?? "",
     right.nodes[0]?.path ?? ""
   ) || left.size - right.size;
 }
-function compareStrings4(left, right) {
+function compareStrings5(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
@@ -3882,6 +4216,17 @@ function runAnalyze(options) {
       )} sin resolver`
     )
   );
+  const migrationLanguages = Object.entries(result.migration.languages).map(([language, stats]) => `${language} ${num(stats?.rloc ?? 0)}`).join(" \xB7 ");
+  lines.push(
+    field(
+      "migraci\xF3n",
+      `${migrationLanguages || "\u2014"} \xB7 ${num(
+        result.migration.bridgeFiles
+      )} puentes \xB7 ${num(result.migration.ffiEdges)} FFI \xB7 deuda ${num(
+        result.migration.migrationDebt
+      )}`
+    )
+  );
   lines.push(field("tiempo", `${num(result.durationMs)} ms`));
   lines.push(
     field(
@@ -4127,6 +4472,12 @@ function truncateLeft(value, max = 78) {
 function shortChecksum(value) {
   return value ? `${value.slice(0, 8)}\u2026` : "\u2014";
 }
+function readMigrationLens(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const lens = value;
+  if (typeof lens.summary !== "object" || lens.summary === null) return null;
+  return lens;
+}
 function runInspect(options) {
   if (!options.file) {
     console.error("falta la ruta del fichero cc.json\n\n  codarch inspect <fichero.cc.json[.gz]>");
@@ -4201,6 +4552,20 @@ function runInspect(options) {
   lines.push(
     field3("aristas", `${num3(stats.edges)} \xB7 leafEdges ${num3(stats.leafEdges)}`)
   );
+  const migration = readMigrationLens(cc.lenses?.migration);
+  if (migration) {
+    const languages = Object.entries(migration.summary.languages).map(([language, entry]) => `${language} ${num3(entry?.rloc ?? 0)}`).join(" \xB7 ");
+    lines.push(
+      field3(
+        "migraci\xF3n",
+        `${languages || "\u2014"} \xB7 ${num3(
+          migration.summary.bridgeFiles
+        )} puentes \xB7 ${num3(migration.summary.ffiEdges)} FFI \xB7 deuda ${num3(
+          migration.summary.migrationDebt
+        )}`
+      )
+    );
+  }
   if (stats.orphanMetricNodes > 0) {
     lines.push(field3("hu\xE9rfanos", `${num3(stats.orphanMetricNodes)} nodos de m\xE9tricas sin fichero`));
   }
@@ -4338,7 +4703,7 @@ function runRender(options) {
 }
 
 // apps/cli/src/index.ts
-var VERSION = true ? "0.1.0" : "0.0.0";
+var VERSION = true ? "0.1.1" : "0.0.0";
 var USAGE = `
 CodArch \xB7 mapa vivo de la arquitectura de tu software
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codarch",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Mapa de arquitectura para equipos y agentes de IA",
   "license": "MIT",
   "type": "module",