parche-cli 0.1.1 → 0.6.0

package/src/inventory/js-scan.js

@@ -0,0 +1,235 @@
+// Inventario de un archivo JS/TS: qué SDKs usa (y con qué operaciones), a qué hosts llama por HTTP
+// y qué modelos de IA nombra. Solo lee: usa @babel/parser directo (sin recast, no hay offsets que cuidar).
+//
+// Límite conocido: las variables se siguen por nombre en todo el archivo, sin scopes. Alcanza para el
+// inventario (aviso de nivel 1); un codemod que edita nunca debe apoyarse en esto.
+import { parse } from '@babel/parser';
+import { packageOf, isInternalHost } from './known.js';
+
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+const FETCH_PACKAGES = new Set(['node-fetch', 'cross-fetch', 'isomorphic-fetch', 'undici']);
+const SKIP_KEYS = new Set(['loc', 'start', 'end', 'extra', 'range', 'comments', 'leadingComments', 'trailingComments', 'innerComments', 'tokens']);
+
+// IDs de modelos de IA. Prefijos inequívocos; la serie o1/o3/o4 de OpenAI solo cuenta si el archivo usa OpenAI.
+const MODEL_PATTERNS = [
+  [/^(gpt-(3\.5|4|4\.1|4o|4\.5|5)[\w.-]*|chatgpt-[\w.-]+|text-embedding-[\w-]+|dall-e-[23]|whisper-1|tts-1(-hd)?|gpt-image-[\w.-]+)$/, 'OpenAI'],
+  [/^o[1-9](-(mini|pro|preview|deep-research))?(-\d{4}-\d{2}-\d{2})?$/, 'OpenAI', { needs: 'openai' }],
+  [/^claude-[\w.-]+$/, 'Anthropic'],
+  [/^(gemini|gemma)-[\w.-]+$/, 'Google (Gemini)'],
+  [/^(mistral|mixtral|codestral|pixtral|ministral)-[\w.-]+$/, 'Mistral'],
+  [/^command-(r|a)[\w.-]*$/, 'Cohere'],
+];
+
+function parseJs(source, file) {
+  const lang = /\.tsx$/.test(file) ? ['typescript', 'jsx'] : /\.(ts|mts|cts)$/.test(file) ? ['typescript'] : ['jsx'];
+  const plugins = [...lang, 'decorators-legacy']; // NestJS, Angular, TypeORM
+  return parse(source, {
+    sourceType: 'unambiguous', plugins, errorRecovery: true,
+    allowAwaitOutsideFunction: true, allowReturnOutsideFunction: true, allowImportExportEverywhere: true,
+  });
+}
+
+function walk(node, visit, parent = null) {
+  if (!node || typeof node !== 'object') return;
+  if (Array.isArray(node)) { for (const n of node) walk(n, visit, parent); return; }
+  if (typeof node.type !== 'string') return;
+  visit(node, parent);
+  for (const [k, v] of Object.entries(node)) if (!SKIP_KEYS.has(k)) walk(v, visit, node);
+}
+
+const isRequire = (n) => n && n.type === 'CallExpression' && n.callee.type === 'Identifier' && n.callee.name === 'require'
+  && n.arguments[0] && n.arguments[0].type === 'StringLiteral';
+const propName = (n) => (n.type === 'Identifier' ? n.name : n.type === 'StringLiteral' ? n.value : null);
+
+// a.b.c(...) → { root: 'a', path: ['b', 'c'] }; null si la cadena no es estática.
+function chainOf(node) {
+  const path = [];
+  let cur = node;
+  while (cur && (cur.type === 'MemberExpression' || cur.type === 'OptionalMemberExpression')) {
+    const name = cur.computed ? (cur.property.type === 'StringLiteral' ? cur.property.value : null) : propName(cur.property);
+    if (name === null) return null;
+    path.unshift(name);
+    cur = cur.object;
+  }
+  if (cur && cur.type === 'Identifier') return { root: cur.name, path };
+  // this.afip.ElectronicBilling.createVoucher → raíz "this.afip" (cliente guardado en la clase)
+  if (cur && cur.type === 'ThisExpression' && path.length) return { root: `this.${path[0]}`, path: path.slice(1) };
+  return null;
+}
+
+export function scanJs(source, file) {
+  const result = { sdk: [], http: [], unresolved: [], models: [], imports: new Set() };
+  let ast;
+  try {
+    ast = parseJs(source, file);
+  } catch {
+    return result;
+  }
+  const bindings = new Map(); // nombre → { pkg, kind: 'module'|'named'|'client'|'http', imported?, prefix?, base? }
+  const constants = new Map(); // nombre → string resuelto (para armar URLs)
+  const bind = (name, info) => { if (name) bindings.set(name, info); };
+
+  // Texto estático de una expresión: literales, plantillas y constantes del archivo; '{}' donde no se sabe.
+  const staticText = (expr) => {
+    if (!expr) return null;
+    if (expr.type === 'StringLiteral') return expr.value;
+    if (expr.type === 'TemplateLiteral') {
+      return expr.quasis.map((q, i) => q.value.cooked + (i < expr.expressions.length ? (staticText(expr.expressions[i]) ?? '{}') : '')).join('');
+    }
+    if (expr.type === 'Identifier' && constants.has(expr.name)) return constants.get(expr.name);
+    if (expr.type === 'BinaryExpression' && expr.operator === '+') {
+      const l = staticText(expr.left);
+      const r = staticText(expr.right);
+      return (l ?? '{}') + (r ?? '{}');
+    }
+    return null;
+  };
+  const objProp = (obj, name) => obj && obj.type === 'ObjectExpression'
+    && obj.properties.find((p) => (p.type === 'ObjectProperty' || p.type === 'Property') && !p.computed && propName(p.key) === name);
+  const objString = (obj, name) => { const p = objProp(obj, name); return p ? staticText(p.value) : null; };
+
+  // Instancias: new Stripe(key), twilio(sid, token), new Payment(client), axios.create({ baseURL }).
+  // → binding nuevo, o null si la expresión no crea un cliente de un SDK conocido en el archivo.
+  const instanceBinding = (expr) => {
+    let init = expr;
+    if (init && init.type === 'AwaitExpression') init = init.argument;
+    if (!init || (init.type !== 'NewExpression' && init.type !== 'CallExpression')) return null;
+    if (init.callee.type === 'Identifier' && bindings.has(init.callee.name)) {
+      const b = bindings.get(init.callee.name);
+      if (b.kind === 'named') return { pkg: b.pkg, kind: 'client', prefix: b.imported };
+      return { pkg: b.pkg, kind: 'client', prefix: b.prefix || '' };
+    }
+    const ch = init.callee.type === 'MemberExpression' ? chainOf(init.callee) : null;
+    if (ch && bindings.has(ch.root)) {
+      const b = bindings.get(ch.root);
+      const last = ch.path[ch.path.length - 1];
+      if ((b.pkg === 'axios' && last === 'create') || (b.pkg === 'got' && last === 'extend')) {
+        const cfg = init.arguments[0];
+        return { pkg: b.pkg, kind: 'http', base: objString(cfg, 'baseURL') ?? objString(cfg, 'prefixUrl') };
+      }
+      if (init.type === 'NewExpression') return { pkg: b.pkg, kind: 'client', prefix: [b.prefix, ...ch.path].filter(Boolean).join('.') };
+    }
+    return null;
+  };
+
+  // 1) Imports, require, constantes e instancias (en orden de aparición).
+  walk(ast, (node) => {
+    // Cliente guardado en una clase: `private afip = new Afip(...)` o `this.afip = new Afip(...)` en el constructor.
+    if ((node.type === 'ClassProperty' || node.type === 'PropertyDefinition') && !node.computed && node.key.type === 'Identifier' && node.value) {
+      const b = instanceBinding(node.value);
+      if (b) bind(`this.${node.key.name}`, b);
+      return;
+    }
+    if (node.type === 'AssignmentExpression' && node.left.type === 'MemberExpression' && node.left.object.type === 'ThisExpression'
+      && !node.left.computed && node.left.property.type === 'Identifier') {
+      const b = instanceBinding(node.right);
+      if (b) bind(`this.${node.left.property.name}`, b);
+      return;
+    }
+    if (node.type === 'ImportDeclaration' && node.importKind !== 'type') {
+      const pkg = packageOf(node.source.value);
+      if (!pkg) return;
+      result.imports.add(pkg);
+      for (const s of node.specifiers) {
+        if (s.importKind === 'type') continue;
+        if (s.type === 'ImportSpecifier') bind(s.local.name, { pkg, kind: 'named', imported: propName(s.imported) });
+        else bind(s.local.name, { pkg, kind: 'module' });
+      }
+      return;
+    }
+    if (node.type !== 'VariableDeclarator' || !node.init) return;
+    let init = node.init;
+    if (init.type === 'AwaitExpression') init = init.argument;
+    const id = node.id;
+    // const BASE = 'https://...'
+    if (id.type === 'Identifier' && (init.type === 'StringLiteral' || init.type === 'TemplateLiteral' || init.type === 'BinaryExpression')) {
+      const t = staticText(init);
+      if (t !== null) constants.set(id.name, t);
+      return;
+    }
+    // require('x'), require('x').Y y require('x')(...)
+    if (isRequire(init) || (init.type === 'MemberExpression' && isRequire(init.object)) || (init.type === 'CallExpression' && isRequire(init.callee))) {
+      const req = isRequire(init) ? init : init.type === 'MemberExpression' ? init.object : init.callee;
+      const pkg = packageOf(req.arguments[0].value);
+      if (!pkg) return;
+      result.imports.add(pkg);
+      if (init.type === 'CallExpression' && init !== req) return bind(id.name, { pkg, kind: 'client', prefix: '' });
+      if (init.type === 'MemberExpression') return bind(id.name, { pkg, kind: 'named', imported: propName(init.property) });
+      if (id.type === 'Identifier') return bind(id.name, { pkg, kind: 'module' });
+      if (id.type === 'ObjectPattern') {
+        for (const p of id.properties) {
+          if (p.type === 'ObjectProperty' && p.value.type === 'Identifier') bind(p.value.name, { pkg, kind: 'named', imported: propName(p.key) });
+        }
+      }
+      return;
+    }
+    if (id.type !== 'Identifier') return;
+    const b = instanceBinding(init);
+    if (b) bind(id.name, b);
+  });
+
+  const usesOpenAI = result.imports.has('openai');
+
+  const recordHttp = (client, method, urlExpr, line, base = null) => {
+    let url = staticText(urlExpr);
+    if (url !== null && base && !/^https?:\/\//i.test(url)) url = base.replace(/\/+$/, '') + '/' + url.replace(/^\/+/, '');
+    if (url === null || url.startsWith('{}')) {
+      result.unresolved.push({ kind: 'http', client, line, reason: 'URL dinámica: no se puede saber a qué host va' });
+      return;
+    }
+    const m = url.match(/^https?:\/\/([^/?#{}]+)(\/[^?#]*)?/i);
+    if (!m) return; // ruta relativa: es el backend propio, no una API de terceros
+    // Sin el puerto, también cuando es dinámico: http://localhost:${PORT} → "localhost:" → "localhost".
+    const host = m[1].toLowerCase().replace(/:.*$/, '');
+    if (isInternalHost(host)) return;
+    result.http.push({ client, method: (method || 'GET').toUpperCase(), host, path: (m[2] || '/').replace(/\{\}[^/]*/g, '{}'), line });
+  };
+
+  // 2) Llamadas.
+  walk(ast, (node) => {
+    if (node.type === 'StringLiteral' || (node.type === 'TemplateLiteral' && node.expressions.length === 0)) {
+      const value = node.type === 'StringLiteral' ? node.value : node.quasis[0].value.cooked;
+      for (const [re, provider, opts] of MODEL_PATTERNS) {
+        if (re.test(value) && (!opts || (opts.needs === 'openai' && usesOpenAI))) {
+          result.models.push({ id: value, provider, line: node.loc.start.line });
+          break;
+        }
+      }
+      return;
+    }
+    if (node.type !== 'CallExpression' && node.type !== 'OptionalCallExpression') return;
+    const line = node.loc.start.line;
+    const callee = node.callee;
+    const [a0, a1] = node.arguments;
+
+    // fetch global, o importado de node-fetch / undici / cross-fetch
+    if (callee.type === 'Identifier') {
+      const b = bindings.get(callee.name);
+      if ((!b && callee.name === 'fetch') || (b && FETCH_PACKAGES.has(b.pkg) && (b.kind === 'module' || b.imported === 'fetch'))) {
+        return recordHttp(b ? b.pkg : 'fetch', objString(a1, 'method'), a0, line);
+      }
+      if (b && b.pkg === 'undici' && b.imported === 'request') return recordHttp('undici', objString(a1, 'method'), a0, line);
+      if (b && (b.pkg === 'axios' || b.pkg === 'got') && (b.kind === 'module' || b.kind === 'http')) {
+        if (a0 && a0.type === 'ObjectExpression') return recordHttp(b.pkg, objString(a0, 'method'), objProp(a0, 'url')?.value, line, objString(a0, 'baseURL') ?? b.base);
+        return recordHttp(b.pkg, objString(a1, 'method'), a0, line, b.base);
+      }
+      if (b && b.kind === 'named') result.sdk.push({ pkg: b.pkg, op: b.imported, line });
+      return;
+    }
+    const ch = chainOf(callee);
+    if (!ch || !bindings.has(ch.root)) return;
+    const b = bindings.get(ch.root);
+    const method = ch.path[ch.path.length - 1];
+    if (['axios', 'got', 'ky', 'superagent'].includes(b.pkg) || b.kind === 'http') {
+      if (ch.path.length === 1 && HTTP_METHODS.includes(method)) return recordHttp(b.pkg, method, a0, line, b.base);
+      if (ch.path.length === 1 && method === 'request' && a0 && a0.type === 'ObjectExpression') {
+        return recordHttp(b.pkg, objString(a0, 'method'), objProp(a0, 'url')?.value, line, objString(a0, 'baseURL') ?? b.base);
+      }
+      return;
+    }
+    if (FETCH_PACKAGES.has(b.pkg)) return;
+    const op = [b.kind === 'named' ? b.imported : b.prefix, ...ch.path].filter(Boolean).join('.');
+    if (op) result.sdk.push({ pkg: b.pkg, op, line });
+  });
+  return result;
+}

package/src/inventory/known.js

@@ -0,0 +1,60 @@
+// Qué es cada dependencia y cada host: SDK de una API, cliente HTTP o ninguna de las dos.
+// La fuente de verdad es data/known-sdks.json (datos, no código: se amplía sin tocar esto).
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const KNOWN = JSON.parse(fs.readFileSync(path.join(HERE, '..', '..', 'data', 'known-sdks.json'), 'utf8'));
+
+// Palabras que, en el nombre de un paquete, sugieren que es el cliente de una API.
+const NAME_HINT = /(^|[-_./@])(api|sdk|client)([-_./]|$)/i;
+
+// Clasifica un paquete de un ecosistema (npm, composer, pypi).
+// → { kind: 'sdk', provider, category, confidence, source } | { kind: 'http-client' } | null
+export function classifyPackage(ecosystem, name) {
+  const curated = KNOWN[ecosystem]?.[name];
+  if (curated) return { kind: 'sdk', ...curated, confidence: 'alta', source: 'curated' };
+  // Antes que los prefijos de familias: @aws-sdk/types es de la familia de AWS pero son solo tipos.
+  if (KNOWN.notApis.prefixes.some((p) => isFamily(name, p))) return null;
+  if (ecosystem === 'npm') {
+    for (const [prefix, info] of Object.entries(KNOWN.npmPrefixes)) {
+      if (name.startsWith(prefix)) return { kind: 'sdk', ...info, confidence: 'alta', source: 'curated' };
+    }
+  }
+  if ((KNOWN.httpClients[ecosystem] || []).includes(name)) return { kind: 'http-client' };
+  // Heurística: el nombre dice api/sdk/client. Confianza baja hasta que se vea usado (el inventario la sube).
+  if (NAME_HINT.test(name)) return { kind: 'sdk', provider: null, category: null, confidence: 'baja', source: 'heuristic' };
+  return null;
+}
+
+// ¿`name` es de la familia `p`? "@types/" y "babel-" son prefijos; "pg" es "pg" o "pg-*", pero no "pgsql"
+// (con nombres cortos como "ws", un prefijo suelto se llevaría puesto un "wsfe-sdk").
+function isFamily(name, p) {
+  if (p.endsWith('/') || p.endsWith('-')) return name.startsWith(p);
+  return name === p || name.startsWith(`${p}-`);
+}
+
+// Paquete de un import: 'openai/resources' → 'openai'; '@aws-sdk/client-s3/dist' → '@aws-sdk/client-s3'.
+export function packageOf(spec) {
+  if (!spec || spec.startsWith('.') || spec.startsWith('/') || spec.startsWith('node:')) return null;
+  const parts = spec.split('/');
+  return spec.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+}
+
+// Proveedor de un host, por sufijo: 'sheets.googleapis.com' → Google APIs.
+export function providerForHost(host) {
+  if (!host) return null;
+  const h = host.toLowerCase();
+  for (const [known, info] of Object.entries(KNOWN.hosts)) {
+    if (h === known || h.endsWith(`.${known}`)) return info;
+  }
+  return null;
+}
+
+// Hosts que no son APIs de terceros: la propia máquina o la red local.
+export function isInternalHost(host) {
+  const h = (host || '').toLowerCase();
+  return !h || h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.local') || h.endsWith('.internal')
+    || /^127\./.test(h) || h === '0.0.0.0' || h === '[::1]' || /^10\./.test(h) || /^192\.168\./.test(h);
+}

package/src/packs.js

@@ -3,18 +3,33 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import arca from './codemods/arca-wsfe-condicion-iva.js';
+import arcaPhp from './codemods/arca-wsfe-condicion-iva-php.js';
 import mercadopago from './codemods/mercadopago-payments-to-orders.js';
 import aiModels from './detectors/ai-model-retirements.js';
+import { wsdlDetection, soapOnly } from './codemods/arca-rules.js';
+import { isPhp } from './php.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 export const PACKS_DIR = path.join(HERE, '..', 'packs');
 
+// Una transformación por pack y por lenguaje. Si un pack no tiene versión para un lenguaje,
+// ese pack no corre sobre esos archivos.
 const TRANSFORMS = {
-  'arca.wsfe.condicion-iva-receptor': arca,
-  'mercadopago.payments-to-orders': mercadopago,
-  'ai.model-retirements': aiModels,
+  // js y php: codemod; wsdl: WSDL de WSFEv1 sin el campo; text (Python, C#, Java, Go, VB.NET): solo SOAP propio.
+  'arca.wsfe.condicion-iva-receptor': { js: arca, php: arcaPhp, wsdl: wsdlDetection, text: soapOnly },
+  'mercadopago.payments-to-orders': { js: mercadopago },
+  'ai.model-retirements': { js: aiModels, php: aiModels, text: aiModels }, // detector de texto: sirve para cualquier lenguaje
 };
 
+const TEXT_ONLY = /\.(py|cs|java|go|vb)$/i;
+
+export function languageOf(file) {
+  if (isPhp(file)) return 'php';
+  if (/\.wsdl$/i.test(file)) return 'wsdl';
+  if (TEXT_ONLY.test(file)) return 'text';
+  return 'js';
+}
+
 export const REQUIRED_FIELDS = ['id', 'version', 'provider', 'title', 'kind', 'severity', 'deadline', 'last_verified',
   'summary_es', 'why_es', 'sources', 'detect', 'codemod', 'review_checklist_es'];
 
@@ -34,6 +49,7 @@ export function loadPacks(dir = PACKS_DIR) {
     .sort((a, b) => (a.deadline || '9999').localeCompare(b.deadline || '9999'));
 }
 
-export function transformFor(packId) {
-  return TRANSFORMS[packId] || null;
+export function transformFor(packId, file = 'x.js') {
+  const byLang = TRANSFORMS[packId];
+  return (byLang && byLang[languageOf(file)]) || null;
 }

package/src/paths.js

@@ -0,0 +1,37 @@
+// Rutas y carpetas compartidas por el motor y el inventario.
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Carpetas que no son código del cliente: dependencias instaladas (vendor/ es donde composer instala
+// las de PHP, incluida la propia librería de ARCA), builds y lo que escribe Parche.
+export const SKIP_DIRS = new Set(['node_modules', 'vendor', '.git', 'dist', 'build', 'coverage', '.next', '.parche']);
+
+// Rutas siempre con "/": van al reporte, al cuerpo del PR y al inventario.
+export const toPosix = (p) => p.split(path.sep).join('/');
+
+// Tests, mocks, fixtures y ejemplos: un PR que solo toca eso no le sirve al mantenedor, y la detección
+// por texto en esos archivos es ruido (frente B, 16/10).
+export function isTestFile(file) {
+  return /(^|\/)(__tests__|__mocks__|tests?|specs?|mocks?|fixtures?|examples?)\//i.test(file)
+    || /\.(test|spec|mock)\.[cm]?[jt]sx?$/i.test(file) || /Test\.php$/.test(file);
+}
+
+// Recorre el repo (salteando SKIP_DIRS) y devuelve las rutas relativas, con "/", de los archivos que
+// cumplen `match(nombre)`.
+export function findFiles(root, match) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(path.join(dir, e.name)); }
+      else if (match(e.name)) out.push(toPosix(path.relative(root, path.join(dir, e.name))));
+    }
+  };
+  walk(root);
+  return out.sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b));
+}

package/src/php.js

@@ -0,0 +1,52 @@
+// Lectura de PHP con php-parser (glayzzle).
+// A diferencia de recast, php-parser lee el texto original: loc.start.offset y loc.end.offset son
+// posiciones exactas en el archivo del cliente, también con CRLF, tabs y acentos (lo cubren los tests).
+// Por eso acá se edita con esos offsets y no con offsetAt(), que corrige las particularidades de recast.
+import PhpParser from 'php-parser';
+
+const engine = new PhpParser.Engine({
+  parser: { php8: true, suppressErrors: false, extractDoc: false },
+  ast: { withPositions: true, withSource: false },
+});
+
+export function parsePhp(source, file = 'archivo.php') {
+  return engine.parseCode(source, file);
+}
+
+const SCOPE_KINDS = new Set(['function', 'method', 'closure', 'arrowfunc']);
+
+// Recorre el AST y llama visit(node, scope), donde scope es la función, el método, la closure
+// o el programa que contiene al nodo (en PHP las variables no cruzan esos límites).
+export function walkPhp(node, visit, scope = node) {
+  if (!node || typeof node !== 'object') return;
+  if (Array.isArray(node)) {
+    for (const n of node) walkPhp(n, visit, scope);
+    return;
+  }
+  if (!node.kind) return;
+  visit(node, scope);
+  const inner = SCOPE_KINDS.has(node.kind) ? node : scope;
+  for (const [k, v] of Object.entries(node)) {
+    if (k === 'loc' || k === 'leadingComments' || k === 'trailingComments') continue;
+    walkPhp(v, visit, inner);
+  }
+}
+
+// Valor de un literal: número (también '99' entre comillas, que PHP convierte), string o booleano.
+// undefined si no es un literal (constante, variable, llamada...).
+export function phpLiteral(node) {
+  if (!node) return undefined;
+  if (node.kind === 'number') return Number(node.value);
+  if (node.kind === 'string') return /^-?\d+$/.test(node.value) ? Number(node.value) : node.value;
+  if (node.kind === 'boolean') return node.value;
+  return undefined;
+}
+
+// Clave de un elemento de array si es un string literal ('DocTipo' => ...); null si no.
+export function phpKey(entry) {
+  return entry && entry.key && entry.key.kind === 'string' ? entry.key.value : null;
+}
+
+export function isPhp(file) {
+  return /\.php$/i.test(file);
+}

package/src/report.js

@@ -1,5 +1,7 @@
 // Reporte del scan y cuerpo del PR, en castellano.
-const LABEL = {
+import { apiLabel } from './inventory/index.js';
+
+const LABEL ={
   auto: '✅ automático',
   'needs-review': '👀 revisar',
   'needs-input': '✋ falta un dato',
@@ -26,16 +28,52 @@ export function counts(findings) {
   return c;
 }
 
-export function scanReport({ inventory, findings, packs, changed }, today = new Date()) {
+function upgradesSection(upgrades) {
+  const out = ['## Versiones nuevas de tus SDKs de npm', '',
+    'Comparación de la API pública (tipos `.d.ts`) entre la versión instalada y la última publicada, cruzada con lo que usa este repo. Solo avisa: no cambia código.', '',
+    '| SDK | Instalada → última | Resultado |', '|---|---|---|'];
+  const STATUS = {
+    afectado: (r) => `⚠ ${r.affected.length} operación(es) del repo cambian o desaparecen`,
+    'sin-impacto': (r) => `✓ lo que usás no cambia (${r.totalChanges} cambios en el SDK)`,
+    'al-dia': () => '✓ al día',
+    'sin-verificar': () => '? tus operaciones no aparecen en los tipos instalados',
+  };
+  for (const r of upgrades) {
+    const res = STATUS[r.status] ? STATUS[r.status](r) : `— ${r.error || 'sin versión instalada'}`;
+    out.push(`| \`${r.package}\` | ${r.installed ? `${r.installed} → ${r.latest}` : '—'} | ${res} |`);
+  }
+  out.push('');
+  for (const r of upgrades.filter((x) => x.status === 'afectado')) {
+    out.push(`### \`${r.package}\` ${r.installed} → ${r.latest}`, '');
+    for (const a of r.affected) {
+      out.push(`- \`${a.op}\` (${a.locations.map((l) => `\`${l.file}:${l.line}\``).join(', ')}): ${a.changes.map((c) => c.message).join(' ')}`);
+    }
+    out.push('');
+  }
+  return out;
+}
+
+export function scanReport({ inventory, findings, packs, changed, upgrades = null }, today = new Date()) {
   const out = [];
   out.push(`# Parche — reporte de \`${inventory.repo}\``, '');
   out.push('## APIs que usa este repo', '');
-  const pk = Object.entries(inventory.packages);
-  if (pk.length) out.push(...pk.map(([n, v]) => `- \`${n}\` ${v}`), '');
-  for (const [prov, p] of Object.entries(inventory.providers)) {
-    out.push(`- **${prov}**: ${p.callSites} usos en ${p.files.length} archivo(s) — ${Object.entries(p.ops).map(([o, n]) => `${o} ×${n}`).join(', ')}`);
+  out.push('Todas las APIs de terceros que se encontraron en el código, tengan pack de Parche o no.', '');
+  if (inventory.apis.length) {
+    const KIND = { sdk: 'SDK', http: 'HTTP directo', 'ai-model': 'Modelos de IA' };
+    out.push('| Tipo | API | Rubro | Confianza | Operaciones (usos) | Pack |', '|---|---|---|---|---|---|');
+    for (const api of inventory.apis) {
+      const ops = api.operations.map((o) => `\`${o.op}\` ×${o.count}`).join(', ') || 'declarada, sin usos encontrados';
+      out.push(`| ${KIND[api.kind]} | ${apiLabel(api)} | ${api.category || '—'} | ${api.confidence} | ${ops} | ${api.packs.length ? 'sí' : '—'} |`);
+    }
+    out.push('');
+  } else {
+    out.push('No se encontraron APIs de terceros.', '');
   }
-  out.push('');
+  if (inventory.unresolved.length) {
+    out.push('**Llamadas HTTP con URL dinámica** (no se puede saber a qué host van):', '',
+      ...inventory.unresolved.map((u) => `- \`${u.file}:${u.line}\` (${u.client})`), '');
+  }
+  if (upgrades) out.push(...upgradesSection(upgrades));
   for (const pack of packs) {
     const fs = findings.filter((f) => f.pack === pack.id);
     if (!fs.length) continue;
@@ -45,6 +83,7 @@ export function scanReport({ inventory, findings, packs, changed }, today = new
     for (const f of fs) {
       out.push(`- ${LABEL[f.status]} \`${f.file}${f.line ? `:${f.line}` : ''}\` — ${f.message}`);
       if (f.suggestion) out.push(`  - Sugerido: \`${f.suggestion}\``);
+      if (f.partial) out.push(`  - ${LABEL['needs-input']} ${f.partial.message}`, `  - Cuando tengas el dato: \`${f.partial.suggestion}\``);
     }
     out.push('');
   }
@@ -54,6 +93,11 @@ export function scanReport({ inventory, findings, packs, changed }, today = new
   return out.join('\n');
 }
 
+// Si algún arreglo es parcial, qué casos cubre ("consumidor final"): va en el título y arriba del cuerpo del PR.
+export function partialCovers(findings) {
+  return [...new Set(findings.filter((f) => f.partial).map((f) => f.partial.covers))];
+}
+
 export function prBody({ pack, findings, changed, verification }, today = new Date()) {
   const fs = findings.filter((f) => f.pack === pack.id);
   const c = counts(fs);
@@ -61,28 +105,51 @@ export function prBody({ pack, findings, changed, verification }, today = new Da
   out.push(`## ${pack.title}`, '');
   out.push(`> **${pack.provider}** · severidad ${SEVERITY[pack.severity]} · fecha límite: ${deadlineText(pack, today)}`, '');
   out.push('### Qué cambió', '', pack.why_es, '');
-  out.push('### Qué hace este PR', '');
+  // Sin cambios de código el texto se usa como issue: los títulos no pueden hablar de "este PR".
+  const asIssue = !changed.length;
+  out.push(asIssue ? '### Qué encontró Parche' : '### Qué hace este PR', '');
+  const covers = partialCovers(fs);
+  if (covers.length && !asIssue) {
+    out.push(`> **Este PR es parcial (${covers.join(', ')}).** Arregla solo esos casos, sin inventar datos: el resto del pedido sale igual que hoy. Lo que no cubre está en "Lo que este PR NO resuelve" y hay que completarlo antes de la fecha límite.`, '');
+  }
   const applied = fs.filter((f) => f.status === 'auto' || f.status === 'needs-review');
   out.push(changed.length
     ? `Modifica ${changed.length} archivo(s): ${changed.map((x) => `\`${x.file}\``).join(', ')}.`
-    : 'No modifica archivos: solo reporta lo que hay que resolver a mano.', '');
+    : 'No hay un arreglo automático seguro: esto es lo que hay que resolver a mano.', '');
   for (const f of applied) out.push(`- ${LABEL[f.status]} \`${f.file}:${f.line}\` — ${f.message}`);
-  const pending = fs.filter((f) => f.status === 'needs-input' || f.status === 'blocked');
+  // Lo que falta: los hallazgos sin arreglo y, de cada arreglo parcial, la parte que no cubre.
+  const pending = [
+    ...fs.filter((f) => f.status === 'needs-input' || f.status === 'blocked'),
+    ...fs.filter((f) => f.partial).map((f) => ({ ...f, status: 'needs-input', message: f.partial.message, suggestion: f.partial.suggestion })),
+  ];
   if (pending.length) {
-    out.push('', '### Lo que este PR NO resuelve (necesita una persona)', '');
+    out.push('', asIssue ? '### Lo que hay que resolver (necesita una persona)' : '### Lo que este PR NO resuelve (necesita una persona)', '');
     for (const f of pending) {
       out.push(`- ${LABEL[f.status]} \`${f.file}:${f.line}\` — ${f.message}`);
       if (f.suggestion) out.push(`  - Agregá: \`${f.suggestion}\``);
     }
   }
-  out.push('', '### Verificación', '');
-  if (verification) {
-    out.push(`- Sintaxis de los archivos modificados: ${verification.parse.ok ? '✅ OK' : '❌ ' + verification.parse.errors.join('; ')}`);
-    if (verification.tests) out.push(`- Tests del repo (\`npm test\`): ${verification.tests.ok ? '✅ pasan' : verification.tests.skipped ? '— no hay script de test' : '❌ fallan'}`);
-  } else {
-    out.push('- Sin verificar (corré `parche pr --verify`).');
+  // Un issue no cambia código: no hay verificación que mostrar (antes decía "Sin verificar").
+  if (!asIssue) {
+    out.push('', '### Verificación', '');
+    if (verification) {
+      out.push(`- Sintaxis de los archivos modificados: ${verification.parse.ok ? '✅ OK' : '❌ ' + verification.parse.errors.join('; ')}`);
+      const t = verification.tests;
+      if (t?.notRun) {
+        // Lo que escribió a mano el frente B en el primer PR real (obraya), ahora lo dice Parche.
+        out.push(t.ci.length
+          ? `- Tests del repo: Parche no los corrió; los corre el CI de este repo (${t.ci.map((w) => `\`${w}\``).join(', ')}) en este PR.`
+          : '- Tests del repo: Parche no los corrió (sin `--verify` no ejecuta código del repo). Corrélos antes de mergear.');
+      } else if (t) {
+        out.push(t.skipped
+          ? '- Tests del repo: — no hay tests para correr; se validó la sintaxis de los archivos modificados.'
+          : `- Tests del repo (${t.commands.map((c) => `\`${c}\``).join(' y ')}): ${t.ok ? '✅ pasan' : '❌ fallan'}`);
+      }
+    } else {
+      out.push('- Sin verificar (corré `parche pr --verify`).');
+    }
   }
-  out.push('', '### Checklist antes de mergear', '', ...pack.review_checklist_es.map((x) => `- [ ] ${x}`), '');
+  out.push('', asIssue ? '### Checklist' : '### Checklist antes de mergear', '', ...pack.review_checklist_es.map((x) => `- [ ] ${x}`), '');
   out.push('### Fuentes', '', ...pack.sources.map((s) => `- [${s.title}](${s.url})`), '');
   out.push(`<sub>Pack \`${pack.id}\` v${pack.version}, verificado el ${pack.last_verified}. Resumen: ${Object.entries(c).map(([k, v]) => `${LABEL[k]} ${v}`).join(' · ')}. ¿Este PR te sirvió? Mergealo, editalo o cerralo: Parche aprende de cada resultado.</sub>`, '');
   return out.join('\n');