parche-cli 0.1.1 → 0.5.1

package/src/codemods/arca-wsfe-condicion-iva.js

@@ -1,65 +1,75 @@
-// Pack arca.wsfe.condicion-iva-receptor
+// Pack arca.wsfe.condicion-iva-receptor (JavaScript/TypeScript, afip.js)
 // Agrega CondicionIVAReceptorId a cada pedido de CAE hecho con afip.js cuando se puede inferir
 // sin datos del negocio, y marca el resto para que una persona complete el dato.
 import {
-  jFor, detectQuote, eolOf, offsetAt, getProp, hasSpread, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
+  jFor, detectQuote, eolOf, offsetAt, applyEdits, getProp, hasSpread, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
 } from '../ast.js';
+import {
+  PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+} from './arca-rules.js';
+import { emptyContext } from '../context.js';
 
-const PACK = 'arca.wsfe.condicion-iva-receptor';
 const VOUCHER_METHODS = new Set(['createVoucher', 'createNextVoucher']);
-const CLASS = {
-  A: new Set([1, 2, 3, 201, 202, 203]),
-  B: new Set([6, 7, 8, 206, 207, 208]),
-  C: new Set([11, 12, 13, 211, 212, 213]),
+const WRAPPERS = new Set(['TSAsExpression', 'TSNonNullExpression', 'TSTypeAssertion', 'TSSatisfiesExpression', 'ParenthesizedExpression']);
+
+// (afip.ElectronicBilling as any) → afip.ElectronicBilling
+const unwrap = (n) => {
+  while (n && WRAPPERS.has(n.type)) n = n.expression;
+  return n;
 };
+const isEBMember = (n) => !!(n && n.type === 'MemberExpression' && !n.computed && n.property.type === 'Identifier' && n.property.name === 'ElectronicBilling');
 
-function classOf(cbteTipo) {
-  for (const [k, set] of Object.entries(CLASS)) if (set.has(cbteTipo)) return k;
-  return null;
+// ¿`node` es `<algo>.ElectronicBilling`? También con casts de TS y con un alias en el mismo scope
+// (`const eb = afip.ElectronicBilling; eb.createVoucher(...)`): los dos aparecieron en repos reales.
+function isElectronicBilling(node, p) {
+  const n = unwrap(node);
+  if (isEBMember(n)) return true;
+  if (n && n.type === 'Identifier') {
+    const decl = resolveBinding(p, n.name);
+    return isEBMember(unwrap(decl && decl.node.init));
+  }
+  return false;
 }
 
-function isVoucherCall(callee) {
-  return (
-    callee.type === 'MemberExpression' &&
-    !callee.computed &&
-    callee.property.type === 'Identifier' &&
-    VOUCHER_METHODS.has(callee.property.name) &&
-    callee.object.type === 'MemberExpression' &&
-    !callee.object.computed &&
-    callee.object.property.name === 'ElectronicBilling'
-  );
+function voucherCallee(p) {
+  const callee = unwrap(p.node.callee);
+  if (!callee || callee.type !== 'MemberExpression' || callee.computed || callee.property.type !== 'Identifier') return null;
+  if (!VOUCHER_METHODS.has(callee.property.name) || !isElectronicBilling(callee.object, p)) return null;
+  return callee;
 }
 
 export function decide(obj, pack) {
-  const docTipo = literalValue(getProp(obj, 'DocTipo')?.value);
-  const cbteTipo = literalValue(getProp(obj, 'CbteTipo')?.value);
-  const clase = typeof cbteTipo === 'number' ? classOf(cbteTipo) : null;
-  if (docTipo === 99) {
-    return { status: 'auto', code: 5, comment: ' parche: 5 = Consumidor Final (DocTipo 99, sin identificar)' };
-  }
-  if (docTipo === 96 && (clase === 'B' || clase === 'C')) {
-    return { status: 'needs-review', code: 5, comment: ' parche: inferido Consumidor Final (DNI + comprobante ' + clase + ') — REVISAR' };
-  }
-  const valid = clase ? pack.codes_by_class[clase] : null;
-  return { status: 'needs-input', clase, valid };
+  return decideCondition({
+    docTipo: literalValue(getProp(obj, 'DocTipo')?.value),
+    cbteTipo: literalValue(getProp(obj, 'CbteTipo')?.value),
+  }, pack);
 }
 
-export default function transform({ source, file, pack }) {
-  const j = jFor(file);
+export default function transform({ source, file, pack, context = emptyContext() }) {
   const findings = [];
   const usages = [];
+  if (!ARCA_HINT.test(source)) return { output: null, findings, usages };
+  const caveat = libraryCaveat(context, 'npm');
+  const migrated = alreadyMigratedPrefix(context);
+  const j = jFor(file);
   let root;
   try {
     root = j(source);
-  } catch {
+  } catch (err) {
+    // Antes se descartaba en silencio: un archivo de ARCA que no parsea es justo el que hay que mirar.
+    findings.push({ pack: PACK, file, line: err.loc?.line || null, status: 'needs-input',
+      message: `No pude analizar este archivo (${err.message.split('\n')[0]}). Revisá a mano las llamadas a ElectronicBilling.` });
     return { output: null, findings, usages };
   }
   let changed = false;
   const edits = [];
+  // Objetos ya editados: el mismo `payload` puede ir a dos llamadas (lo vimos en un repo real). Como se edita
+  // texto y el árbol no se entera, sin esto se insertaba dos veces → clave duplicada y TypeScript no compila.
+  const edited = new Set();
 
-  root.find(j.CallExpression).filter((p) => isVoucherCall(p.node.callee)).forEach((p) => {
+  root.find(j.CallExpression).filter((p) => voucherCallee(p) !== null).forEach((p) => {
     const call = p.node;
-    usages.push({ provider: 'arca', op: `ElectronicBilling.${call.callee.property.name}`, line: call.loc?.start.line });
+    usages.push({ provider: 'arca', op: `ElectronicBilling.${voucherCallee(p).property.name}`, line: call.loc?.start.line });
     const arg = call.arguments[0];
     let obj = null;
     if (arg && arg.type === 'ObjectExpression') obj = arg;
@@ -68,19 +78,16 @@ export default function transform({ source, file, pack }) {
       if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') obj = decl.node.init;
     }
     if (!obj || hasSpread(obj)) {
-      findings.push(finding(PACK, file, call, 'needs-input',
-        'No pude leer los datos del comprobante (no es un objeto literal). Agregá CondicionIVAReceptorId a mano.'));
+      // Si el repo ya usa el campo en otro lado, lo más probable es que el builder ya lo ponga: "revisar".
+      findings.push(finding(PACK, file, call, migrated ? 'needs-review' : 'needs-input', (migrated || '') + unreadableMessage(j, root, p, arg, obj)));
       return;
     }
-    if (getProp(obj, 'CondicionIVAReceptorId')) return; // ya está migrado
+    if (getProp(obj, 'CondicionIVAReceptorId') || edited.has(obj)) return; // ya está migrado (o ya lo editamos)
 
     const d = decide(obj, pack);
     if (d.status === 'needs-input') {
-      const lista = (d.valid || Object.keys(pack.codes).map(Number))
-        .map((c) => `${c} (${pack.codes[String(c)]})`).join(', ');
-      findings.push(finding(PACK, file, call, 'needs-input',
-        `Falta CondicionIVAReceptorId y no se puede inferir sin saber la condición frente al IVA del cliente${d.clase ? ` (comprobante clase ${d.clase})` : ''}.`,
-        { suggestion: `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${lista}` }));
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
+        { suggestion: `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
       return;
     }
 
@@ -89,28 +96,67 @@ export default function transform({ source, file, pack }) {
     const q = detectQuote(source) === 'double' ? '"' : "'";
     const keyText = quoted ? `${q}CondicionIVAReceptorId${q}` : 'CondicionIVAReceptorId';
     const anchor = getProp(obj, 'DocNro') || props[props.length - 1];
-    edits.push(...insertAfterProp(source, anchor, `${keyText}: ${d.code}`, d.comment));
+    const isLast = anchor === obj.properties[obj.properties.length - 1];
+    edits.push(...insertAfterProp(source, anchor, `${keyText}: ${d.code}`, d.comment, { isLast }));
+    edited.add(obj);
     changed = true;
-    findings.push(finding(PACK, file, call, d.status,
-      d.status === 'auto'
-        ? 'Agregado CondicionIVAReceptorId: 5 (Consumidor Final): el comprobante va a un consumidor sin identificar.'
-        : 'Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C). Confirmá que el cliente no sea exento ni no alcanzado.'));
+    // Con librería vieja o WSDL viejo el arreglo no alcanza solo: deja de ser "automático".
+    const status = caveat && d.status === 'auto' ? 'needs-review' : d.status;
+    findings.push(finding(PACK, file, call, status, appliedMessage(d.status) + (caveat ? ` ${caveat}` : '')));
   });
 
-  // Integraciones SOAP propias: solo detección.
-  if (/FECAESolicitar|FECAEDetRequest/.test(source) && !/CondicionIVAReceptorId/.test(source)) {
-    const line = source.split('\n').findIndex((l) => /FECAESolicitar|FECAEDetRequest/.test(l)) + 1;
-    findings.push({ pack: PACK, file, line, status: 'needs-input',
-      message: 'Integración SOAP propia con WSFEv1 sin CondicionIVAReceptorId en el FECAEDetRequest. Hay que agregarlo al XML.' });
-    usages.push({ provider: 'arca', op: 'WSFEv1 SOAP', line });
-  }
+  const soap = soapDetection(source, file, context);
+  if (soap) { findings.push(soap.finding); usages.push(soap.usage); }
 
   return { output: changed ? applyEdits(source, edits) : null, findings, usages };
 }
 
+// Cuando no se puede leer el comprobante, decir DÓNDE hay que agregar el dato: la función que lo arma
+// (y de qué módulo viene) o que llega como parámetro. Lo encontrado en repos reales: payload = buildVoucherPayload(...).
+function unreadableMessage(j, root, p, arg, obj) {
+  const tail = 'con la condición frente al IVA del cliente.';
+  if (obj) return `No pude leer los datos del comprobante (el objeto usa ...spread). Agregá CondicionIVAReceptorId a mano, ${tail}`;
+  if (arg && arg.type === 'Identifier') {
+    const decl = resolveBinding(p, arg.name);
+    let init = decl && decl.node.init;
+    if (init && init.type === 'AwaitExpression') init = init.argument;
+    if (init && init.type === 'CallExpression') {
+      const fn = init.callee.type === 'Identifier' ? init.callee.name
+        : init.callee.type === 'MemberExpression' && !init.callee.computed && init.callee.property.type === 'Identifier' ? init.callee.property.name : null;
+      if (fn) {
+        const from = importSourceOf(j, root, fn);
+        return `Los datos del comprobante los arma \`${fn}()\`${from ? ` (de \`${from}\`)` : ''}: agregá CondicionIVAReceptorId ahí, ${tail}`;
+      }
+    }
+    if (!decl) return `Los datos del comprobante llegan en \`${arg.name}\` desde afuera de esta función: agregá CondicionIVAReceptorId donde se arma ese objeto, ${tail}`;
+  }
+  return `No pude leer los datos del comprobante (no es un objeto literal). Agregá CondicionIVAReceptorId a mano, ${tail}`;
+}
+
+// De qué módulo viene `name`: import estático, require o import() dinámico con desestructuración.
+function importSourceOf(j, root, name) {
+  let src = null;
+  root.find(j.ImportDeclaration).forEach((ip) => {
+    if (ip.node.specifiers.some((s) => s.local && s.local.name === name)) src = ip.node.source.value;
+  });
+  if (src) return src;
+  root.find(j.VariableDeclarator).forEach((vp) => {
+    const { id } = vp.node;
+    let init = vp.node.init;
+    if (!init || id.type !== 'ObjectPattern') return;
+    if (init.type === 'AwaitExpression') init = init.argument;
+    const isImportCall = init.type === 'CallExpression' && (init.callee.type === 'Import' || (init.callee.type === 'Identifier' && init.callee.name === 'require'));
+    const source = init.type === 'ImportExpression' ? init.source : isImportCall ? init.arguments[0] : null;
+    if (!source || typeof source.value !== 'string') return;
+    if (id.properties.some((pr) => pr.value && pr.value.type === 'Identifier' && pr.value.name === name)) src = source.value;
+  });
+  return src;
+}
+
 // Inserta una propiedad nueva después de `prop` tocando solo el texto necesario,
 // para que el diff del PR sea de una línea y respete el formato del cliente.
-export function insertAfterProp(source, prop, text, comment) {
+// Si `prop` es la última y no tenía coma final, la nueva tampoco la lleva.
+export function insertAfterProp(source, prop, text, comment, { isLast = false } = {}) {
   const eol = eolOf(source);
   const end = offsetAt(source, prop.loc.end);
   let k = end;
@@ -121,18 +167,11 @@ export function insertAfterProp(source, prop, text, comment) {
   if (nl !== -1 && rest.trim() === '') {
     const lineStart = offsetAt(source, { line: prop.loc.start.line, column: 0 });
     const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
-    const out = [{ offset: nl + 1, text: `${indent}//${comment}${eol}${indent}${text},${eol}` }];
+    const trailing = hasComma || !isLast ? ',' : '';
+    const out = [{ offset: nl + 1, text: `${indent}//${comment}${eol}${indent}${text}${trailing}${eol}` }];
     if (!hasComma) out.push({ offset: end, text: ',' });
     return out;
   }
   // Objeto en una sola línea.
   return [{ offset: hasComma ? k + 1 : end, text: `${hasComma ? '' : ','} ${text} /*${comment} */${hasComma ? ',' : ''}` }];
 }
-
-function applyEdits(source, edits) {
-  let out = source;
-  for (const e of [...edits].sort((a, b) => b.offset - a.offset)) {
-    out = out.slice(0, e.offset) + e.text + out.slice(e.offset);
-  }
-  return out;
-}

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 */ }
 }