parche-cli 0.1.1 → 0.6.0

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

@@ -0,0 +1,276 @@
+// Pack arca.wsfe.condicion-iva-receptor (PHP: afipsdk/afip.php y sus forks)
+// Mismas reglas que el codemod de JS: agrega CondicionIVAReceptorId a cada
+// $afip->ElectronicBilling->CreateVoucher($data) / CreateNextVoucher($data) cuando se puede inferir
+// sin datos del negocio, y marca el resto para que una persona complete el dato.
+// Edita con inserciones de texto mínimas sobre los offsets exactos de php-parser (ver src/php.js).
+import { eolOf, applyEdits, finding } from '../ast.js';
+import { parsePhp, walkPhp, phpLiteral, phpKey } from '../php.js';
+import {
+  PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+  canApplyAtRuntime, PARTIAL_COMMENT, partialAppliedMessage, partialPending, partialLeftMessage,
+} from './arca-rules.js';
+import { emptyContext } from '../context.js';
+
+// En PHP los nombres de método no distinguen mayúsculas: createVoucher también es válido.
+// El inventario usa el nombre oficial, así un mismo método no aparece dos veces.
+const VOUCHER_METHODS = new Map([['createvoucher', 'CreateVoucher'], ['createnextvoucher', 'CreateNextVoucher']]);
+// Claves que cambian la decisión: si se tocan fuera del array literal, no se puede inferir.
+const DECISION_KEYS = new Set(['DocTipo', 'CbteTipo', 'DocNro']);
+const FIELD = 'CondicionIVAReceptorId';
+const HINT_TAIL = 'con la condición frente al IVA del cliente.';
+
+const isLookup = (n) => n && (n.kind === 'propertylookup' || n.kind === 'nullsafepropertylookup');
+const identName = (n) => (n && n.kind === 'identifier' ? n.name : null);
+
+// '...->ElectronicBilling->CreateVoucher(...)' → nombre oficial del método; null si no es.
+function voucherMethod(call) {
+  const what = call.what;
+  if (!isLookup(what)) return null;
+  const method = identName(what.offset);
+  if (!method || !VOUCHER_METHODS.has(method.toLowerCase())) return null;
+  if (!isLookup(what.what) || identName(what.what.offset) !== 'ElectronicBilling') return null;
+  return VOUCHER_METHODS.get(method.toLowerCase());
+}
+
+// if ($data['DocTipo'] == 99) / if ((int) $data['DocTipo'] === 99): el arreglo parcial de Parche
+// (o uno igual escrito a mano). Devuelve el nombre de la variable, o null.
+function partialIfVar(test) {
+  if (!test || test.kind !== 'bin' || (test.type !== '==' && test.type !== '===')) return null;
+  const side = (n) => (n && n.kind === 'cast' ? n.expr : n);
+  const isDocTipo = (n) => n && n.kind === 'offsetlookup' && n.what?.kind === 'variable' && typeof n.what.name === 'string'
+    && n.offset && phpLiteral(n.offset) === 'DocTipo';
+  const [a, b] = [side(test.left), side(test.right)];
+  const lookup = isDocTipo(a) ? a : isDocTipo(b) ? b : null;
+  const other = lookup === a ? b : a;
+  return lookup && phpLiteral(other) === 99 ? lookup.what.name : null;
+}
+
+// Asignaciones por scope: $var = ... y $var['Clave'] = ...
+function collect(ast) {
+  const scopes = new Map();
+  const calls = [];
+  const info = (scope) => {
+    if (!scopes.has(scope)) scopes.set(scope, { assigns: new Map(), offsets: new Map(), partialIfs: new Map() });
+    return scopes.get(scope);
+  };
+  const push = (map, name, value) => map.set(name, [...(map.get(name) || []), value]);
+  walkPhp(ast, (node, scope) => {
+    if (node.kind === 'if') {
+      const v = partialIfVar(node.test);
+      if (v) push(info(scope).partialIfs, v, node);
+    }
+    if (node.kind === 'assign') {
+      const left = node.left;
+      if (left.kind === 'variable' && typeof left.name === 'string') push(info(scope).assigns, left.name, node);
+      else if (left.kind === 'offsetlookup' && left.what && left.what.kind === 'variable' && typeof left.what.name === 'string' && left.offset) {
+        push(info(scope).offsets, left.what.name, { key: phpLiteral(left.offset), node });
+      }
+    }
+    if (node.kind === 'call') {
+      const method = voucherMethod(node);
+      if (method) calls.push({ node, scope, method });
+    }
+  });
+  return { scopes, calls };
+}
+
+// El array con los datos del comprobante: literal en la llamada o $var definida una sola vez,
+// antes de la llamada y en el mismo scope.
+function resolveData(arg, scope, call, scopes) {
+  if (!arg) return { reason: 'la llamada no tiene argumentos' };
+  if (arg.kind === 'array') return { arr: arg };
+  if (arg.kind !== 'variable' || typeof arg.name !== 'string') return { reason: 'no es un array literal ni una variable' };
+  const s = scopes.get(scope) || { assigns: new Map(), offsets: new Map(), partialIfs: new Map() };
+  const defs = s.assigns.get(arg.name) || [];
+  const v = `$${arg.name}`;
+  if (defs.length === 0) {
+    const isParam = (scope.arguments || []).some((a) => a.kind === 'parameter' && (a.name?.name ?? a.name) === arg.name);
+    if (isParam) return { hint: `Los datos del comprobante llegan en \`${v}\` como parámetro: agregá ${FIELD} donde se arma ese array, ${HINT_TAIL}` };
+    return { reason: `${v} no se define en esta función` };
+  }
+  if (defs.length > 1) return { reason: `${v} se asigna más de una vez` };
+  const def = defs[0];
+  // $data = armarComprobante(...) / $this->builder->armar(...) / Builder::armar(...): decir qué función lo arma.
+  if (def.right.kind === 'call') {
+    const what = def.right.what;
+    const fn = what && (what.kind === 'name' ? what.name : identName(what.offset));
+    if (typeof fn === 'string') return { hint: `Los datos del comprobante los arma \`${fn}()\`: agregá ${FIELD} ahí, ${HINT_TAIL}` };
+  }
+  if (def.operator !== '=' || def.right.kind !== 'array') return { reason: `${v} no es un array literal` };
+  if (def.loc.start.offset > call.loc.start.offset) return { reason: `${v} se define después de la llamada` };
+  const offsets = s.offsets.get(arg.name) || [];
+  // $data['CondicionIVAReceptorId'] = ... : migrado, salvo que solo pase dentro del if del arreglo parcial.
+  const fieldSets = offsets.filter((o) => o.key === FIELD);
+  const ifs = s.partialIfs.get(arg.name) || [];
+  const insideIf = (o) => ifs.some((i) => o.node.loc.start.offset >= i.loc.start.offset && o.node.loc.end.offset <= i.loc.end.offset);
+  const partial = fieldSets.length > 0 && fieldSets.every(insideIf);
+  if (fieldSets.length && !partial) return { migrated: true };
+  if (offsets.some((o) => o.key === undefined || DECISION_KEYS.has(o.key))) return { reason: `${v} se completa en varios pasos` };
+  return { arr: def.right, def, name: arg.name, partial };
+}
+
+export default function transform({ source, file, pack, context = emptyContext() }) {
+  const findings = [];
+  const usages = [];
+  if (!ARCA_HINT.test(source)) return { output: null, findings, usages }; // prefiltro (ver el codemod de JS)
+  const caveat = libraryCaveat(context, 'composer');
+  const migrated = alreadyMigratedPrefix(context);
+  let ast;
+  try {
+    ast = parsePhp(source, file);
+  } catch (err) {
+    if (/ElectronicBilling|FECAESolicitar|FECAEDetRequest/.test(source)) {
+      findings.push({ pack: PACK, file, line: err.lineNumber || null, status: 'needs-input',
+        message: `No pude analizar este archivo PHP (${err.message}). Revisá a mano las llamadas a ElectronicBilling.` });
+    }
+    return { output: null, findings, usages };
+  }
+
+  const { scopes, calls } = collect(ast);
+  const edits = [];
+  const edited = new Set(); // el mismo $data en dos llamadas: se inserta una sola vez (ver el codemod de JS)
+  for (const { node: call, scope, method } of calls) {
+    usages.push({ provider: 'arca', op: `ElectronicBilling->${method}`, line: call.loc.start.line });
+    const data = resolveData(call.arguments[0], scope, call, scopes);
+    if (data.migrated) continue;
+    const entries = data.arr ? data.arr.items.filter((it) => it && it.kind === 'entry') : null;
+    if (!entries || entries.some((e) => e.unpack || e.byRef)) {
+      const msg = data.hint || `No pude leer los datos del comprobante (${data.reason || 'el array usa ...$otro o referencias'}). Agregá ${FIELD} a mano, ${HINT_TAIL}`;
+      findings.push(finding(PACK, file, call, migrated ? 'needs-review' : 'needs-input', (migrated || '') + msg));
+      continue;
+    }
+    const byKey = (k) => entries.find((e) => phpKey(e) === k);
+    if (byKey(FIELD) || edited.has(data.arr)) continue; // ya está migrado (o ya lo editamos)
+
+    const d = decideCondition({ docTipo: phpLiteral(byKey('DocTipo')?.value), cbteTipo: phpLiteral(byKey('CbteTipo')?.value) }, pack);
+    const suggestion = `'${FIELD}' => <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}`;
+    if (data.partial) {
+      // Ya tiene el arreglo parcial: no se toca, pero lo que falta se sigue reportando.
+      const pending = partialPending(d, pack, suggestion);
+      findings.push(finding(PACK, file, call, 'needs-input', partialLeftMessage(pending), { suggestion }));
+      continue;
+    }
+    if (d.status === 'needs-input') {
+      // DocTipo no literal y $data en una variable: arreglo parcial con un if después de armar el array.
+      // Con un array dentro de la llamada no hay dónde poner el if, y `null` no sirve: mandarlo antes del 1/12
+      // podría generar un rechazo que hoy no existe (frente B, punto 7).
+      const docTipo = byKey('DocTipo');
+      const partialEdit = data.def && docTipo && phpLiteral(docTipo.value) === undefined
+        && canApplyAtRuntime(d, phpLiteral(byKey('CbteTipo')?.value)) ? insertPartialIf(source, data, entries) : null;
+      if (partialEdit) {
+        edits.push(partialEdit.edit);
+        edited.add(data.arr);
+        findings.push(finding(PACK, file, call, 'needs-review', partialAppliedMessage(partialEdit.read) + (caveat ? ` ${caveat}` : ''),
+          { partial: partialPending(d, pack, suggestion) }));
+        continue;
+      }
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''), { suggestion }));
+      continue;
+    }
+    const anchor = byKey('DocNro') || entries[entries.length - 1];
+    edits.push(...insertAfterEntry(source, entries, anchor, { value: d.code, comment: d.comment }));
+    edited.add(data.arr);
+    // Con afip.php 0.x (WSDL de 2021 sin el campo) 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}` : '')));
+  }
+
+  const soap = soapDetection(source, file, context);
+  if (soap) { findings.push(soap.finding); usages.push(soap.usage); }
+
+  return { output: edits.length ? applyEdits(source, edits) : null, findings, usages };
+}
+
+// Comillas de las claves del array: las que use la mayoría.
+function quoteOf(source, entries) {
+  const keyed = entries.filter((e) => e.key && e.key.kind === 'string');
+  const doubles = keyed.filter((e) => source[e.key.loc.start.offset] === '"').length;
+  return doubles > keyed.length / 2 ? '"' : "'";
+}
+
+// Arreglo parcial en PHP: después de `$data = [...];` agrega
+//   if ((int) $data['DocTipo'] === 99) { $data['CondicionIVAReceptorId'] = 5; }
+// en tres líneas, con la indentación del archivo. Lee DocTipo del array ya armado, así no repite la
+// expresión original (puede ser una llamada). (int) y === : '99' como string también cuenta, como en JS.
+// null si la asignación no termina la línea (dentro de un if, varias sentencias en una línea...).
+function insertPartialIf(source, data, entries) {
+  const eol = eolOf(source);
+  const { def, name } = data;
+  let semi = def.loc.end.offset - 1;
+  if (source[semi] !== ';') {
+    semi = def.loc.end.offset;
+    while (semi < source.length && /[ \t]/.test(source[semi])) semi++;
+    if (source[semi] !== ';') return null;
+  }
+  const nl = source.indexOf('\n', semi);
+  const rest = source.slice(semi + 1, nl === -1 ? source.length : nl);
+  if (nl === -1 || !(rest.trim() === '' || /^\s*(\/\/|#)/.test(rest))) return null;
+  const lineStart = source.lastIndexOf('\n', def.loc.start.offset - 1) + 1;
+  const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
+  // Unidad de indentación: la de las claves del array respecto de la sentencia; si no, la del archivo.
+  const first = entries.find((e) => e.loc.start.line > def.loc.start.line);
+  const entryIndent = first ? source.slice(source.lastIndexOf('\n', first.loc.start.offset - 1) + 1).match(/^[ \t]*/)[0] : '';
+  const unit = entryIndent.startsWith(indent) && entryIndent.length > indent.length ? entryIndent.slice(indent.length)
+    : indent.includes('\t') ? '\t' : '    ';
+  const q = quoteOf(source, entries);
+  const read = `$${name}[${q}DocTipo${q}]`;
+  const text = `${indent}//${PARTIAL_COMMENT}${eol}`
+    + `${indent}if ((int) ${read} === 99) {${eol}`
+    + `${indent}${unit}$${name}[${q}${FIELD}${q}] = 5;${eol}`
+    + `${indent}}${eol}`;
+  return { edit: { offset: nl + 1, text }, read };
+}
+
+// Inserta 'CondicionIVAReceptorId' => N después de `anchor`, copiando el estilo del array:
+// comillas de las claves, indentación, alineación de los =>, coma final y fin de línea.
+export function insertAfterEntry(source, entries, anchor, { value, comment }) {
+  const eol = eolOf(source);
+  const keyed = entries.filter((e) => e.key && e.key.kind === 'string');
+  const q = quoteOf(source, entries);
+  const key = `${q}${FIELD}${q}`;
+
+  const end = anchor.loc.end.offset;
+  let k = end;
+  while (k < source.length && /[ \t]/.test(source[k])) k++;
+  const hasComma = source[k] === ',';
+  const nl = source.indexOf('\n', end);
+  const rest = source.slice(hasComma ? k + 1 : end, nl === -1 ? source.length : nl);
+  const endsLine = nl !== -1 && (rest.trim() === '' || /^\s*(\/\/|#)/.test(rest));
+
+  if (!endsLine) {
+    // Array en una sola línea.
+    return [{ offset: hasComma ? k + 1 : end, text: `${hasComma ? '' : ','} ${key} => ${value} /*${comment} */${hasComma ? ',' : ''}` }];
+  }
+
+  const lineStart = source.lastIndexOf('\n', anchor.loc.start.offset - 1) + 1;
+  const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
+  const { before, after } = arrowSpacing(source, keyed, anchor, key.length);
+  const isLast = anchor === entries[entries.length - 1];
+  const trailing = hasComma || !isLast ? ',' : '';
+  const out = [{ offset: nl + 1, text: `${indent}//${comment}${eol}${indent}${key}${before}=>${after}${value}${trailing}${eol}` }];
+  if (!hasComma) out.push({ offset: end, text: ',' });
+  return out;
+}
+
+// Espacios antes y después del => para la línea nueva. Si las claves del array están alineadas
+// con espacios ('DocTipo'    => 99), se alinea igual; si no, se copia el espaciado del ancla.
+function arrowSpacing(source, keyed, anchor, newKeyLength) {
+  const parts = (e) => {
+    const keyEnd = e.key.loc.end.offset;
+    const arrow = source.indexOf('=>', keyEnd);
+    return {
+      width: arrow - e.key.loc.start.offset,
+      before: source.slice(keyEnd, arrow),
+      after: source.slice(arrow + 2, e.value.loc.start.offset),
+      line: e.loc.start.line,
+    };
+  };
+  const all = keyed.map(parts);
+  const own = anchor.key && anchor.key.kind === 'string' ? parts(anchor) : { before: ' ', after: ' ' };
+  const after = /^[ \t]*$/.test(own.after) && own.after ? own.after : ' ';
+  const multiline = new Set(all.map((p) => p.line)).size === all.length;
+  const aligned = multiline && all.length > 1 && all.every((p) => p.width === all[0].width && /^ +$/.test(p.before))
+    && all.some((p) => p.before.length > 1);
+  if (aligned) return { before: ' '.repeat(Math.max(1, all[0].width - newKeyLength)), after };
+  return { before: /^[ \t]+$/.test(own.before) ? own.before : ' ', after };
+}

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

@@ -1,65 +1,120 @@
-// 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, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
 } from '../ast.js';
+import {
+  PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+  canApplyAtRuntime, PARTIAL_COMMENT, partialAppliedMessage, partialPending, partialLeftMessage,
+} 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' };
+  return decideCondition({
+    docTipo: literalValue(getProp(obj, 'DocTipo')?.value),
+    cbteTipo: literalValue(getProp(obj, 'CbteTipo')?.value),
+  }, pack);
+}
+
+// Un valor que se puede volver a leer sin efectos: docTipo, cliente.docTipo, this.doc?.tipo, datos['DocTipo'].
+// El arreglo parcial repite esa expresión; una llamada o un await no se repiten.
+function isPureRead(node, top = true) {
+  const n = unwrap(node);
+  if (!n) return false;
+  if (n.type === 'Identifier') return n.name !== 'undefined';
+  if (n.type === 'ThisExpression') return !top;
+  if (n.type === 'MemberExpression' || n.type === 'OptionalMemberExpression') {
+    if (n.computed && !['StringLiteral', 'NumericLiteral', 'Literal'].includes(n.property.type)) return false;
+    return isPureRead(n.object, false);
   }
-  const valid = clase ? pack.codes_by_class[clase] : null;
-  return { status: 'needs-input', clase, valid };
+  return false;
 }
 
-export default function transform({ source, file, pack }) {
-  const j = jFor(file);
+// ...(cond ? { CondicionIVAReceptorId: N } : {}): 'partial' si para el otro caso no hay valor (el arreglo
+// parcial de Parche, o uno igual escrito a mano), 'full' si los dos lados ponen el campo.
+function conditionSpread(prop) {
+  if (prop.type !== 'SpreadElement' && prop.type !== 'SpreadProperty') return null;
+  const c = unwrap(prop.argument);
+  if (!c || c.type !== 'ConditionalExpression') return null;
+  const sets = (o) => { const x = unwrap(o); return !!(x && x.type === 'ObjectExpression' && getProp(x, 'CondicionIVAReceptorId')); };
+  if (!sets(c.consequent) && !sets(c.alternate)) return null;
+  return sets(c.consequent) && sets(c.alternate) ? 'full' : 'partial';
+}
+const otherSpread = (obj) => obj.properties.some((p) => (p.type === 'SpreadElement' || p.type === 'SpreadProperty' || p.type === 'ObjectMethod') && !conditionSpread(p));
+
+const textOf = (source, node) => source.slice(offsetAt(source, node.loc.start), offsetAt(source, node.loc.end));
+
+// La clave nueva copia el estilo del objeto: con comillas si la mayoría de las claves las tiene, y las
+// mismas comillas que esas claves. Las del resto del archivo solo desempatan: en un repo real las claves
+// iban con ' y el archivo usaba " en el resto, y la clave nueva salía distinta a sus vecinas.
+function keyTextFor(source, obj) {
+  const props = obj.properties.filter(isPlainProp);
+  const quotedKeys = props.filter(isQuotedKey);
+  if (!props.length || quotedKeys.length < props.length / 2) return 'CondicionIVAReceptorId';
+  const raw = (k) => (k.extra?.raw ?? k.raw ?? source[offsetAt(source, k.loc.start)])[0];
+  const doubles = quotedKeys.filter((p) => raw(p.key) === '"').length;
+  const singles = quotedKeys.length - doubles;
+  const q = doubles === singles ? (detectQuote(source) === 'double' ? '"' : "'") : doubles > singles ? '"' : "'";
+  return `${q}CondicionIVAReceptorId${q}`;
+}
+
+const suggestionFor = (d, pack) => `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}`;
+
+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;
@@ -67,50 +122,104 @@ export default function transform({ source, file, pack }) {
       const decl = resolveBinding(p, arg.name);
       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.'));
+    if (!obj || otherSpread(obj)) {
+      // 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 spreads = obj.properties.map(conditionSpread);
+    if (spreads.includes('full')) return;
 
     const d = decide(obj, pack);
+    const props = obj.properties.filter(isPlainProp);
+    const keyText = keyTextFor(source, obj);
+    const anchor = getProp(obj, 'DocNro') || props[props.length - 1];
+    const isLast = anchor === obj.properties[obj.properties.length - 1];
+    if (spreads.includes('partial')) {
+      // Ya tiene el arreglo parcial: no se toca, pero lo que falta se sigue reportando.
+      const pending = partialPending(d, pack, suggestionFor(d, pack));
+      findings.push(finding(PACK, file, call, 'needs-input', partialLeftMessage(pending), { suggestion: pending.suggestion }));
+      return;
+    }
     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}` }));
+      const docTipo = getProp(obj, 'DocTipo')?.value;
+      const expr = docTipo && anchor && literalValue(docTipo) === undefined && isPureRead(docTipo) ? textOf(source, docTipo) : null;
+      if (expr && !expr.includes('\n') && canApplyAtRuntime(d, literalValue(getProp(obj, 'CbteTipo')?.value))) {
+        // Spread y no `CondicionIVAReceptorId: x === 99 ? 5 : undefined`: con otro DocTipo la clave ni existe,
+        // así el pedido queda idéntico al de hoy sin depender de cómo serialice la librería (decisión D52).
+        edits.push(...insertAfterProp(source, anchor, `...(Number(${expr}) === 99 ? { ${keyText}: 5 } : {})`, PARTIAL_COMMENT, { isLast }));
+        edited.add(obj);
+        changed = true;
+        findings.push(finding(PACK, file, call, 'needs-review', partialAppliedMessage(expr) + (caveat ? ` ${caveat}` : ''),
+          { partial: partialPending(d, pack, suggestionFor(d, pack)) }));
+        return;
+      }
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
+        { suggestion: suggestionFor(d, pack) }));
       return;
     }
 
-    const props = obj.properties.filter(isPlainProp);
-    const quoted = props.length > 0 && props.filter(isQuotedKey).length >= props.length / 2;
-    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));
+    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 +230,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;
-}