parche-cli 0.1.1 → 0.6.0

package/src/context.js

@@ -0,0 +1,93 @@
+// Contexto del repo para los packs: lo que un archivo solo no puede saber.
+// Lo arma el motor una vez, antes de correr los packs, y cada transform lo recibe como `context`.
+//
+//   versions:   versión instalada de cada dependencia (de los lockfiles, de node_modules o del rango declarado)
+//   fieldFiles: archivos que ya usan CondicionIVAReceptorId (el repo ya empezó a migrar)
+//   staleWsdl:  WSDL de WSFEv1 del repo que no tienen CondicionIVAReceptorId
+//   arcaLibs:   librerías de ARCA del repo con lo que se sabe de si el campo llega a viajar
+import fs from 'node:fs';
+import path from 'node:path';
+import { findFiles } from './paths.js';
+
+const readJson = (p) => {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+};
+const clean = (v) => String(v || '').replace(/^v/, '');
+
+// Versiones instaladas por ecosistema: lockfiles (en cualquier carpeta) → node_modules de la raíz → rango declarado.
+export function readVersions(root, manifests) {
+  const out = { npm: {}, composer: {} };
+  const set = (eco, name, version, source) => { if (name && version && !out[eco][name]) out[eco][name] = { version: clean(version), source }; };
+  for (const rel of findFiles(root, (n) => n === 'package-lock.json' || n === 'composer.lock')) {
+    const lock = readJson(path.join(root, rel));
+    if (!lock) continue;
+    if (rel.endsWith('composer.lock')) {
+      for (const p of [...(lock.packages || []), ...(lock['packages-dev'] || [])]) set('composer', p.name, p.version, rel);
+    } else {
+      for (const [k, v] of Object.entries(lock.packages || {})) {
+        const m = k.match(/^node_modules\/((?:@[^/]+\/)?[^/]+)$/); // solo las de primer nivel
+        if (m) set('npm', m[1], v.version, rel);
+      }
+      for (const [name, v] of Object.entries(lock.dependencies || {})) set('npm', name, v.version, rel); // lockfile v1
+    }
+  }
+  for (const name of Object.keys(manifests?.npm || {})) {
+    const pkg = readJson(path.join(root, 'node_modules', name, 'package.json'));
+    if (pkg?.version) set('npm', name, pkg.version, 'node_modules');
+  }
+  for (const eco of ['npm', 'composer']) {
+    for (const [name, range] of Object.entries(manifests?.[eco] || {})) {
+      const m = String(range).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+      if (m) set(eco, name, `${m[1]}.${m[2] || 0}.${m[3] || 0}`, 'declarada');
+    }
+  }
+  return out;
+}
+
+// Qué se sabe, por librería, de si CondicionIVAReceptorId llega a ARCA (verificado en su código el 16/10/2026):
+//   afip.js / afip.php ≥ 1.0: mandan JSON a la API de Afip SDK → sí.
+//   0.x: arman el SOAP con un WSDL de 2021 incluido en la librería, sin el campo → no (PHP) o sin confirmar (JS).
+//   fertandil87/afip.php: actualizó su WSDL (lo incluye) → sí.  eesnaola/afip.php: WSDL de 2021 → igual que 0.x.
+const ARCA_LIBS = {
+  npm: { '@afipsdk/afip.js': (v) => (major(v) >= 1 ? 'si' : 'sin-confirmar') },
+  composer: {
+    'afipsdk/afip.php': (v) => (major(v) >= 1 ? 'si' : 'no'),
+    'ivanalemunioz/afip.php': (v) => (major(v) >= 1 ? 'si' : 'no'),
+    'fertandil87/afip.php': () => 'si',
+    'eesnaola/afip.php': () => 'no',
+  },
+};
+const major = (v) => Number(String(v).split('.')[0]);
+
+export function arcaLibraries(versions) {
+  const out = [];
+  for (const [eco, libs] of Object.entries(ARCA_LIBS)) {
+    for (const [name, rule] of Object.entries(libs)) {
+      const v = versions[eco]?.[name];
+      if (v) out.push({ ecosystem: eco, name, version: v.version, source: v.source, travels: rule(v.version) });
+    }
+  }
+  return out;
+}
+
+// files: rutas relativas (con "/") de los archivos que el motor va a recorrer.
+export function buildContext(root, files, manifests) {
+  const versions = readVersions(root, manifests);
+  const fieldFiles = [];
+  for (const rel of files) {
+    try {
+      if (fs.readFileSync(path.join(root, rel), 'utf8').includes('CondicionIVAReceptorId')) fieldFiles.push(rel);
+    } catch { /* archivo ilegible: lo reporta el pack que lo lea */ }
+  }
+  const staleWsdl = findFiles(root, (n) => /\.wsdl$/i.test(n)).filter((rel) => {
+    const text = fs.readFileSync(path.join(root, rel), 'utf8');
+    return /FECAESolicitar|FECAEDetRequest/.test(text) && !text.includes('CondicionIVAReceptorId');
+  });
+  return { versions, fieldFiles, staleWsdl, arcaLibs: arcaLibraries(versions) };
+}
+
+export const emptyContext = () => ({ versions: { npm: {}, composer: {} }, fieldFiles: [], staleWsdl: [], arcaLibs: [] });

package/src/detectors/ai-model-retirements.js

@@ -1,36 +1,51 @@
 // Pack ai.model-retirements — solo detección.
 // Cambiar de modelo cambia el comportamiento del producto, así que Parche avisa y no reescribe.
+//
+// Menos ruido (frente B, 16/10): un ID que aparece en el contexto de una llamada (model: '...', DEFAULT_MODEL)
+// es un uso; si aparece en una lista o un catálogo, se avisa como mención. Y en código de Azure OpenAI no se
+// da por cerrada la Assistants API: la fecha oficial es la de la API de OpenAI.
 const PACK = 'ai.model-retirements';
 
+const MODEL_CONTEXT = /\bmodel(?:Id|Name)?\b\s*[:=(]|["']model["']\s*[:=]|\b(?:DEFAULT|default)_?(?:MODEL|Model)\b|\bmodel\s*\(/i;
+const AZURE = /azure|AzureOpenAI|openai\.azure\.com/i;
+
+// Acepta el formato nuevo ({ date, replacement }) y el viejo (solo la fecha).
+const entry = (v) => (typeof v === 'string' ? { date: v, replacement: null } : v);
+const quoted = (line, id) => line.includes(`'${id}'`) || line.includes(`"${id}"`) || line.includes(`\`${id}\``);
+
 export default function detect({ source, file, pack, today = new Date().toISOString().slice(0, 10) }) {
   const findings = [];
   const usages = [];
   const { retired_models: retired, retirement_floors: floors, retired_endpoints: endpoints } = pack.detect;
+  const azure = AZURE.test(source);
   const lines = source.split('\n');
   lines.forEach((l, i) => {
-    for (const [model, date] of Object.entries(retired)) {
-      if (l.includes(`'${model}'`) || l.includes(`"${model}"`) || l.includes('`' + model + '`')) {
-        const past = date <= today;
-        findings.push({ pack: PACK, file, line: i + 1, status: 'detect-only',
-          message: past
-            ? `El modelo \`${model}\` fue retirado el ${date}: las llamadas ya fallan. Elegí un reemplazo en la página de deprecaciones y corré tus pruebas de prompts.`
-            : `El modelo \`${model}\` se retira el ${date}.` });
-        usages.push({ provider: 'ia', op: `modelo ${model}`, line: i + 1 });
-      }
+    const line = i + 1;
+    const inCall = MODEL_CONTEXT.test(l);
+    for (const [model, raw] of Object.entries(retired)) {
+      if (!quoted(l, model)) continue;
+      const { date, replacement } = entry(raw);
+      const past = date <= today;
+      const repl = replacement ? ` Reemplazo recomendado: \`${replacement}\`.` : '';
+      const when = past ? `fue retirado el ${date}` : `se retira el ${date}`;
+      const message = inCall
+        ? `El modelo \`${model}\` ${when}${past ? ': las llamadas ya fallan' : ''}.${repl} Corré tus pruebas de prompts antes de cambiarlo.`
+        : `Aparece \`${model}\` (${when}) fuera de una llamada: si es una lista o un catálogo de modelos, actualizalo.${repl}`;
+      findings.push({ pack: PACK, file, line, status: 'detect-only', message });
+      usages.push({ provider: 'ia', op: `modelo ${model}`, line });
     }
     for (const [model, date] of Object.entries(floors)) {
-      if (l.includes(model)) {
-        findings.push({ pack: PACK, file, line: i + 1, status: 'detect-only',
-          message: `El modelo \`${model}\` puede retirarse a partir del ${date} (fecha mínima publicada; hay 60 días de aviso). Planificá el reemplazo.` });
-        usages.push({ provider: 'ia', op: `modelo ${model}`, line: i + 1 });
-      }
+      if (!l.includes(model)) continue;
+      findings.push({ pack: PACK, file, line, status: 'detect-only',
+        message: `El modelo \`${model}\` puede retirarse a partir del ${date} (fecha mínima publicada; hay 60 días de aviso). Planificá el reemplazo.` });
+      usages.push({ provider: 'ia', op: `modelo ${model}`, line });
     }
     for (const ep of endpoints) {
-      if (l.includes(ep.pattern)) {
-        findings.push({ pack: PACK, file, line: i + 1, status: 'detect-only',
-          message: `\`${ep.pattern}\` pertenece a la Assistants API de OpenAI, cerrada el ${ep.retired}. Reemplazo: ${ep.replacement_es}.` });
-        usages.push({ provider: 'ia', op: 'OpenAI Assistants API', line: i + 1 });
-      }
+      if (!l.includes(ep.pattern)) continue;
+      findings.push({ pack: PACK, file, line, status: 'detect-only', message: azure && ep.provider === 'openai'
+        ? `\`${ep.pattern}\` es la Assistants API. En Azure OpenAI sigue su propio calendario (el cierre del ${ep.retired} es el de la API de OpenAI): revisá el de Azure.`
+        : `\`${ep.pattern}\` pertenece a la Assistants API de OpenAI, cerrada el ${ep.retired}. Reemplazo: ${ep.replacement_es}.` });
+      usages.push({ provider: 'ia', op: 'OpenAI Assistants API', line });
     }
   });
   return { output: null, findings, usages };

package/src/engine.js

@@ -1,10 +1,14 @@
 // Motor: recorre el repo, arma el inventario de APIs y corre los packs.
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadPacks, transformFor } from './packs.js';
+import { loadPacks, transformFor, languageOf } from './packs.js';
+import { SKIP_DIRS, toPosix } from './paths.js';
+import { scanJs } from './inventory/js-scan.js';
+import { readManifests, buildInventory } from './inventory/index.js';
+import { buildContext } from './context.js';
 
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.parche']);
-const EXT = /\.(m?js|cjs|jsx|ts|tsx)$/;
+// JS/TS y PHP (codemods), WSDL (detección de esquemas viejos) y Python, C#, Java, Go, VB.NET (solo detección).
+const EXT = /\.(m?js|cjs|jsx|ts|tsx|php|wsdl|py|cs|java|go|vb)$/i;
 
 export function listFiles(dir) {
   const out = [];
@@ -22,34 +26,31 @@ export function listFiles(dir) {
   return out.sort((a, b) => (toPosix(a) < toPosix(b) ? -1 : 1));
 }
 
-// Rutas siempre con "/": van al reporte, al cuerpo del PR y al inventario.
-const toPosix = (p) => p.split(path.sep).join('/');
-
-function readDeps(dir) {
-  const pkgPath = path.join(dir, 'package.json');
-  if (!fs.existsSync(pkgPath)) return {};
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  return { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-}
-
 export function run(dir, { write = false, packIds = null, today } = {}) {
   const root = path.resolve(dir);
   const packs = loadPacks().filter((p) => !packIds || packIds.includes(p.id));
-  const deps = readDeps(root);
+  const manifests = readManifests(root);
+  const deps = { ...manifests.npm, ...manifests.composer };
   const files = listFiles(root);
+  const rels = files.map((abs) => toPosix(path.relative(root, abs)));
+  // Lo que un archivo solo no sabe (versiones instaladas, si el repo ya usa el campo, WSDL viejos).
+  const context = buildContext(root, rels, manifests);
   const findings = [];
   const usages = [];
+  const fileScans = []; // inventario de cualquier API (nivel 1), por archivo
   const changed = new Map(); // archivo relativo → [packs]
 
-  for (const abs of files) {
-    const rel = toPosix(path.relative(root, abs));
+  files.forEach((abs, i) => {
+    const rel = rels[i];
     let source = fs.readFileSync(abs, 'utf8');
+    // El inventario se arma sobre el archivo original, antes de que un pack lo modifique.
+    if (languageOf(rel) === 'js') fileScans.push({ file: rel, scan: scanJs(source, rel) });
     for (const pack of packs) {
-      const t = transformFor(pack.id);
+      const t = transformFor(pack.id, rel);
       if (!t) continue;
       let res;
       try {
-        res = t({ source, file: rel, pack, today });
+        res = t({ source, file: rel, pack, today, context });
       } catch (err) {
         findings.push({ pack: pack.id, file: rel, line: null, status: 'needs-input', message: `Parche no pudo procesar este archivo: ${err.message}` });
         continue;
@@ -62,7 +63,7 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
         if (write) fs.writeFileSync(abs, source);
       }
     }
-  }
+  });
 
   const providers = {};
   for (const u of usages) {
@@ -71,15 +72,18 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
     p.ops[u.op] = (p.ops[u.op] || 0) + 1;
     p.files.add(u.file);
   }
+  const generatedAt = new Date().toISOString();
   const inventory = {
-    generated_at: new Date().toISOString(),
-    repo: path.basename(root),
+    ...buildInventory({ repo: path.basename(root), manifests, fileScans, packs }),
+    generatedAt,
+    // Campos anteriores a schemaVersion: lo que reportan los packs. Se mantienen por compatibilidad.
+    generated_at: generatedAt,
     packages: Object.fromEntries(Object.entries(deps).filter(([name]) =>
       packs.some((p) => (p.detect.packages || []).includes(name)))),
     providers: Object.fromEntries(Object.entries(providers).map(([k, v]) => [k, { ...v, files: [...v.files] }])),
     usages,
   };
-  return { root, packs, inventory, findings, changed: [...changed.entries()].map(([file, packIds]) => ({ file, packs: packIds })) };
+  return { root, packs, context, inventory, findings, changed: [...changed.entries()].map(([file, packIds]) => ({ file, packs: packIds })) };
 }
 
 export const STATUS_ORDER = ['blocked', 'needs-input', 'needs-review', 'auto', 'detect-only'];

package/src/git.js

@@ -26,9 +26,32 @@ export function checkoutNewBranch(cwd, name, base) {
   git(cwd, 'checkout', '-b', name);
 }
 
-export function commitAll(cwd, message) {
+// Quién firma los commits de Parche. Nunca una dirección de un dominio que no controlamos: antes era
+// bot@parche.dev, y parche.dev lo tiene registrado otra persona. En orden:
+// 1. PARCHE_GIT_NAME y PARCHE_GIT_EMAIL, si están.
+// 2. La identidad de git de quien lo corre (en su compu, o la que configuró su workflow).
+// 3. En GitHub Actions sin identidad: el bot de Actions, el mismo que abre el PR con el GITHUB_TOKEN.
+// Si no hay ninguna, error: no se inventa un autor.
+export const ACTIONS_BOT = { name: 'github-actions[bot]', email: '41898282+github-actions[bot]@users.noreply.github.com' };
+
+export function commitIdentity(cwd, env = process.env) {
+  if (env.PARCHE_GIT_NAME && env.PARCHE_GIT_EMAIL) return { name: env.PARCHE_GIT_NAME, email: env.PARCHE_GIT_EMAIL };
+  const get = (key) => {
+    try {
+      return execFileSync('git', ['config', key], { cwd, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    } catch { return ''; }
+  };
+  const name = get('user.name');
+  const email = get('user.email');
+  if (name && email) return { name, email };
+  if (env.GITHUB_ACTIONS === 'true') return ACTIONS_BOT;
+  throw new Error('No hay una identidad de git para firmar el commit: configurá `git config user.name` y `git config user.email`, o PARCHE_GIT_NAME y PARCHE_GIT_EMAIL.');
+}
+
+export function commitAll(cwd, message, env = process.env) {
+  const id = commitIdentity(cwd, env);
   git(cwd, 'add', '-A');
-  git(cwd, '-c', 'user.name=Parche', '-c', 'user.email=bot@parche.dev', 'commit', '-q', '-m', message);
+  git(cwd, '-c', `user.name=${id.name}`, '-c', `user.email=${id.email}`, 'commit', '-q', '-m', message);
   return git(cwd, 'rev-parse', '--short', 'HEAD');
 }
 
@@ -36,14 +59,27 @@ export function checkout(cwd, branch) {
   git(cwd, 'checkout', '-q', branch);
 }
 
-export function originUrl(cwd) {
+export function remoteUrl(cwd, remote = 'origin') {
   try {
-    return git(cwd, 'remote', 'get-url', 'origin');
+    return git(cwd, 'remote', 'get-url', remote);
   } catch {
     return null;
   }
 }
 
-export function push(cwd, branch) {
-  git(cwd, 'push', '-u', '--force', 'origin', branch);
+export const originUrl = (cwd) => remoteUrl(cwd, 'origin');
+
+export function push(cwd, branch, remote = 'origin') {
+  git(cwd, 'push', '-u', '--force', remote, branch);
+}
+
+// Descarta lo que Parche escribió en su rama (el árbol estaba limpio antes de empezar; .parche/ está excluido).
+export function discardChanges(cwd) {
+  git(cwd, 'reset', '--hard', '-q');
+}
+
+export function deleteBranch(cwd, name) {
+  try {
+    git(cwd, 'branch', '-D', name);
+  } catch { /* ya no existía */ }
 }

package/src/inventory/index.js

@@ -0,0 +1,133 @@
+// Inventario de cualquier API (nivel 1 del producto): junta las dependencias declaradas, lo que
+// encontró js-scan en cada archivo y lo que reportaron los packs, y arma .parche/inventory.json.
+// El esquema está documentado en docs/inventario.md; si cambia de forma incompatible, sube SCHEMA_VERSION.
+import fs from 'node:fs';
+import path from 'node:path';
+import { classifyPackage, providerForHost } from './known.js';
+import { findFiles } from '../paths.js';
+
+export const SCHEMA_VERSION = 1;
+const KIND_ORDER = { sdk: 0, http: 1, 'ai-model': 2 };
+
+const readJson = (p) => {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+};
+
+// requirements.txt: "paquete==1.2", "paquete>=1", "paquete[extra]"; sin comentarios, -r, -e ni URLs.
+export function parseRequirements(text) {
+  const out = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.replace(/#.*$/, '').trim();
+    if (!line || line.startsWith('-') || /^[a-z]+:\/\//i.test(line)) continue;
+    const m = line.match(/^([A-Za-z0-9][A-Za-z0-9._-]*)(\[[^\]]*\])?\s*(.*)$/);
+    if (m) out[m[1].toLowerCase()] = m[3].trim() || '*';
+  }
+  return out;
+}
+
+const MANIFEST_NAMES = new Set(['package.json', 'composer.json', 'requirements.txt']);
+
+// Todos los manifiestos del repo, no solo los de la raíz: los monorepos (packages/backend/package.json,
+// ms-billing/package.json) declaran ahí sus SDKs. Primero la raíz, después por profundidad.
+export function findManifests(root) {
+  return findFiles(root, (name) => MANIFEST_NAMES.has(name));
+}
+
+// Dependencias declaradas por ecosistema (si un paquete aparece en varios manifiestos, gana el más cercano a la raíz).
+export function readManifests(root) {
+  const deps = { npm: {}, composer: {}, pypi: {} };
+  const files = { npm: [], composer: [], pypi: [] };
+  const merge = (eco, entries, file) => {
+    files[eco].push(file);
+    for (const [name, version] of entries) if (!(name in deps[eco])) deps[eco][name] = version;
+  };
+  for (const rel of findManifests(root)) {
+    const abs = path.join(root, rel);
+    const name = path.posix.basename(rel);
+    if (name === 'package.json') {
+      const pkg = readJson(abs) || {};
+      merge('npm', Object.entries({ ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }), rel);
+    } else if (name === 'composer.json') {
+      const c = readJson(abs) || {};
+      // fuera "php" y las extensiones "ext-*": no son paquetes
+      merge('composer', Object.entries({ ...(c.require || {}), ...(c['require-dev'] || {}) }).filter(([n]) => n.includes('/')), rel);
+    } else {
+      merge('pypi', Object.entries(parseRequirements(fs.readFileSync(abs, 'utf8'))), rel);
+    }
+  }
+  return { ...deps, files };
+}
+
+// fileScans: [{ file, scan }] con el resultado de scanJs; packs: los packs cargados.
+export function buildInventory({ repo, manifests, fileScans, packs }) {
+  const apis = new Map();
+  const add = (id, base) => {
+    if (!apis.has(id)) apis.set(id, { id, ...base, operations: new Map() });
+    return apis.get(id);
+  };
+  const addOp = (api, op, file, line) => {
+    const o = api.operations.get(op) || { op, count: 0, locations: [] };
+    o.count++;
+    o.locations.push({ file, line });
+    api.operations.set(op, o);
+  };
+  const packsFor = (pkg) => packs.filter((p) => (p.detect.packages || []).includes(pkg)).map((p) => p.id);
+
+  // Dependencias declaradas que son SDKs de una API (aunque todavía no se vean usadas).
+  for (const eco of ['npm', 'composer', 'pypi']) {
+    for (const [name, version] of Object.entries(manifests[eco] || {})) {
+      const c = classifyPackage(eco, name);
+      if (!c || c.kind !== 'sdk') continue;
+      add(`${eco}:${name}`, { kind: 'sdk', provider: c.provider, category: c.category, ecosystem: eco, package: name, version,
+        confidence: c.confidence, source: c.source, packs: packsFor(name) });
+    }
+  }
+
+  const unresolved = [];
+  for (const { file, scan } of fileScans) {
+    for (const u of scan.sdk) {
+      let api = apis.get(`npm:${u.pkg}`);
+      if (!api) {
+        const c = classifyPackage('npm', u.pkg);
+        if (!c || c.kind !== 'sdk') continue; // no es el cliente de una API (lodash, react...)
+        api = add(`npm:${u.pkg}`, { kind: 'sdk', provider: c.provider, category: c.category, ecosystem: 'npm', package: u.pkg,
+          version: null, confidence: c.confidence, source: c.source, packs: packsFor(u.pkg) });
+      }
+      addOp(api, u.op, file, u.line);
+    }
+    for (const h of scan.http) {
+      const known = providerForHost(h.host);
+      const api = add(`http:${h.host}`, { kind: 'http', provider: known?.provider || null, category: known?.category || null,
+        host: h.host, confidence: known ? 'alta' : 'media', source: known ? 'curated' : 'usage', packs: [] });
+      addOp(api, `${h.method} ${h.path}`, file, h.line);
+    }
+    for (const m of scan.models) {
+      const api = add(`ai:${m.provider}`, { kind: 'ai-model', provider: m.provider, category: 'ia', confidence: 'alta',
+        source: 'usage', packs: packs.some((p) => p.id === 'ai.model-retirements') ? ['ai.model-retirements'] : [] });
+      addOp(api, m.id, file, m.line);
+    }
+    for (const r of scan.unresolved) unresolved.push({ file, ...r });
+  }
+
+  const list = [...apis.values()].map((api) => {
+    const operations = [...api.operations.values()].sort((a, b) => b.count - a.count || a.op.localeCompare(b.op));
+    // Un SDK detectado por el nombre que además se ve usado deja de ser una corazonada.
+    const confidence = api.source === 'heuristic' && operations.length ? 'media' : api.confidence;
+    return { ...api, confidence, operations };
+  }).sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind]
+    || (a.provider || a.package || a.host || '').localeCompare(b.provider || b.package || b.host || ''));
+
+  const { files: manifestFiles = {}, ...dependencies } = manifests;
+  return { schemaVersion: SCHEMA_VERSION, repo, apis: list, unresolved, dependencies, manifestFiles };
+}
+
+// Nombre corto para mostrar una API en el reporte y en la CLI.
+export function apiLabel(api) {
+  if (api.kind === 'sdk') return api.provider ? `${api.provider} · ${api.package}` : api.package;
+  if (api.kind === 'http') return api.provider ? `${api.provider} · ${api.host}` : api.host;
+  return `${api.provider} · modelos`;
+}