parche-cli 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 Todas las versiones de `parche-cli` (npm) y de la Action `Pepo08/parche@v0`.
 
+## 0.6.0 — 2026-10-17
+
+### Nuevo
+- **ARCA con `DocTipo` en una variable: PR parcial (consumidor final).** Antes se reportaba como "falta un dato" y no se tocaba nada. Ahora Parche aplica la regla 99 → 5 **al ejecutarse** y, con otro `DocTipo`, el pedido sale igual que hoy (la clave ni existe). En JS agrega `...(Number(docTipo) === 99 ? { CondicionIVAReceptorId: 5 } : {})`; en PHP, un `if ((int) $data['DocTipo'] === 99)` después de armar el array, nunca `null`. El PR sale borrador, con "(parcial: consumidor final)" en el título y, en "Lo que este PR NO resuelve", los casos que no cubre con los códigos válidos. No se aplica a facturas A, a expresiones con efectos (llamadas, `await`) ni a arrays de PHP dentro de la llamada. Si se corre de nuevo después del merge, no cambia nada y sigue avisando lo que falta.
+- El ledger registra cuántos arreglos parciales lleva cada PR (`partial`).
+
+### Arreglado
+- ARCA en JS: la clave nueva usa las mismas comillas que las claves del objeto. Antes copiaba las del resto del archivo y, en un repo real con claves `'...'` en un archivo con `"..."`, quedaba distinta a sus vecinas.
+
 ## 0.5.1 — 2026-10-17
 
 Lo que apareció en el primer PR real (lunamarie11/obraya#1).

package/README.md

@@ -129,7 +129,7 @@ Con el tag, el workflow corre los tests, controla que la versión de `package.js
 
 | Pack | Proveedor | Tipo | Fecha límite | Arreglo |
 |---|---|---|---|---|
-| `arca.wsfe.condicion-iva-receptor` | ARCA | rompe | 2026-12-01 | sí, en JS (`afip.js`) y PHP (`afipsdk/afip.php` y forks): consumidor final y DNI B/C |
+| `arca.wsfe.condicion-iva-receptor` | ARCA | rompe | 2026-12-01 | sí, en JS (`afip.js`) y PHP (`afipsdk/afip.php` y forks): consumidor final y DNI B/C; con `DocTipo` en una variable, consumidor final al ejecutarse (PR parcial) |
 | `mercadopago.payments-to-orders` | Mercado Pago | migración | — | sí (creación de pagos en SDK Node v2) |
 | `ai.model-retirements` | Anthropic, OpenAI | retiro | varias | solo detección |
 
@@ -157,6 +157,31 @@ Para `afipsdk/afip.php` y sus forks (`fertandil87/afip.php`, `ivanalemunioz/afip
 
 **Otros lenguajes:** en Python, C#, Java, Go y VB.NET, Parche detecta integraciones SOAP propias y clientes SOAP generados sin el campo (no los reescribe).
 
+## ARCA con `DocTipo` en una variable: PR parcial
+
+Cuando `DocTipo` no es un número fijo (`DocTipo: docTipo`), Parche no puede saber la condición frente al IVA de cada cliente. Lo único que se sabe sin datos del negocio es que **99 (consumidor final sin identificar) va con 5**, así que aplica esa regla **al ejecutarse** y, con cualquier otro `DocTipo`, el pedido sale exactamente igual que hoy:
+
+```js
+    DocNro: docNro,
+    // parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente
+    ...(Number(docTipo) === 99 ? { CondicionIVAReceptorId: 5 } : {}),
+```
+
+```php
+        );
+        // parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente
+        if ((int) $data['DocTipo'] === 99) {
+            $data['CondicionIVAReceptorId'] = 5;
+        }
+```
+
+- El PR sale **borrador**, con "(parcial: consumidor final)" en el título. En "Lo que este PR NO resuelve" dice qué falta: los comprobantes con otro `DocTipo` (CUIT, DNI y otros) siguen sin el campo y desde el 1/12/2026 ARCA los va a rechazar. Ahí también están los códigos válidos para la clase del comprobante.
+- Con otro `DocTipo` la clave ni existe (no queda en `undefined` ni en `null`): el pedido no depende de cómo lo serialice la librería y no aparece un rechazo que hoy no existe.
+- `Number(...)` y `(int)` hacen que `'99'` como texto también cuente.
+- En JS solo se aplica si `DocTipo` se puede releer sin efectos (`docTipo`, `cliente.docTipo`, `this.datos['DocTipo']`), no si es una llamada o un `await`. En PHP se lee del array ya armado, así que sirve cualquier expresión, pero el array tiene que estar en una variable (`$data = [...]`): con el array dentro de la llamada no hay dónde poner el `if`.
+- No se aplica a facturas A ni a otras clases conocidas que no sean B o C.
+- Si se vuelve a correr después del merge, no cambia nada y sigue avisando lo que falta.
+
 ## Límites del MVP
 
 - JS/TS (ESM y CommonJS) y, para ARCA, PHP. Siguen Python y Java.

package/bin/parche.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { run } from '../src/engine.js';
 import { loadPacks } from '../src/packs.js';
-import { scanReport, prBody, counts, LABEL, daysUntil } from '../src/report.js';
+import { scanReport, prBody, counts, LABEL, daysUntil, partialCovers } from '../src/report.js';
 import { verify } from '../src/verify.js';
 import * as git from '../src/git.js';
 import { parseGithubRemote, openPullRequest } from '../src/github.js';
@@ -121,7 +121,10 @@ function printFindings(result) {
     if (!fs2.length) continue;
     const d = pack.deadline ? ` · vence ${pack.deadline} (${daysUntil(pack.deadline)} días)` : '';
     console.log(`\n■ ${pack.title}\n  ${pack.provider} · severidad ${pack.severity}${d}`);
-    for (const f of fs2) console.log(`  ${LABEL[f.status].padEnd(16)} ${f.file}${f.line ? ':' + f.line : ''}  ${f.message}`);
+    for (const f of fs2) {
+      console.log(`  ${LABEL[f.status].padEnd(16)} ${f.file}${f.line ? ':' + f.line : ''}  ${f.message}`);
+      if (f.partial) console.log(`  ${''.padEnd(16)} No cubre: ${f.partial.message}`);
+    }
   }
 }
 
@@ -204,7 +207,9 @@ async function main() {
       const preview = run(root, { write: false, packIds: [pack.id] });
       if (!preview.findings.length) continue;
       const branch = `parche/${pack.id}`;
-      const title = `Parche: ${pack.title}`;
+      // Un arreglo parcial lo dice en el título: "(parcial: consumidor final)".
+      const covers = partialCovers(preview.findings);
+      const title = `Parche: ${pack.title}${covers.length ? ` (parcial: ${covers.join(', ')})` : ''}`;
       git.checkoutNewBranch(root, branch, base);
       let keepBranch = false;
       try {
@@ -246,7 +251,8 @@ async function main() {
         } else {
           console.log(`  Modo prueba: no se abrió el PR${draft ? ' (iría como borrador por tener ítems para revisar)' : ''}.`);
         }
-        record(root, { type: 'pr', pack: pack.id, packVersion: pack.version, branch, sha, url, draft, files: changedFiles, findings: c });
+        record(root, { type: 'pr', pack: pack.id, packVersion: pack.version, branch, sha, url, draft, files: changedFiles, findings: c,
+          partial: result.findings.filter((f) => f.partial).length });
       } finally {
         // Pase lo que pase, se vuelve a la rama base; la rama de Parche solo queda si tiene un commit.
         git.checkout(root, base);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parche-cli",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Dependabot para APIs: detecta cambios de APIs de terceros en tu código y abre el PR con el arreglo.",
   "keywords": [
     "api",

package/src/codemods/arca-rules.js

@@ -48,6 +48,37 @@ export function appliedMessage(status) {
     : 'Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C). Confirmá que el cliente no sea exento ni no alcanzado.';
 }
 
+// Arreglo parcial "en tiempo de ejecución" (punto 7 del frente B, 16/10): si DocTipo no es un literal
+// (DocTipo: docTipo), la regla 99 → 5 se aplica al ejecutarse y, con otro DocTipo, el pedido sale igual que hoy.
+// No inventa nada: Consumidor Final es el único caso que no depende de datos del negocio. No se aplica si el
+// comprobante es clase A o de otra clase conocida (99 con factura A no existe).
+export const PARTIAL = 'consumidor final';
+export const PARTIAL_COMMENT = ' parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente';
+
+export function canApplyAtRuntime(decision, cbteTipo) {
+  return decision.status === 'needs-input' && (cbteTipo === undefined || decision.clase === 'B' || decision.clase === 'C');
+}
+
+const dmy = (iso) => iso.split('-').map(Number).reverse().join('/');
+
+export function partialAppliedMessage(docTipoText) {
+  return `Arreglo parcial (${PARTIAL}): CondicionIVAReceptorId: 5 solo cuando \`${docTipoText}\` vale 99 al ejecutarse. Con otro DocTipo el pedido sale igual que hoy, sin el campo.`;
+}
+
+// Lo que el arreglo parcial NO cubre: va en el cuerpo del PR como "lo que este PR no resuelve".
+export function partialPending(decision, pack, suggestion) {
+  return {
+    covers: PARTIAL,
+    message: `No cubre los comprobantes con DocTipo distinto de 99 (CUIT, DNI y otros): siguen sin CondicionIVAReceptorId y desde el ${dmy(pack.deadline)} ARCA los va a rechazar. Falta la condición frente al IVA de cada cliente${decision.clase ? ` (comprobante clase ${decision.clase})` : ''}.`,
+    suggestion,
+  };
+}
+
+// En un scan posterior (el PR parcial ya se mergeó): lo que falta se sigue reportando.
+export function partialLeftMessage(pending) {
+  return `Tiene el arreglo parcial de Parche (solo DocTipo 99 → 5). ${pending.message}`;
+}
+
 // "El repo ya usa CondicionIVAReceptorId en otro lado": prefijo para bajar a "revisar" lo que no se pudo leer
 // (en repos ya migrados, el objeto suele salir de un builder que sí pone el campo).
 export function alreadyMigratedPrefix(context) {

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

@@ -7,6 +7,7 @@ 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';
 
@@ -31,16 +32,33 @@ function voucherMethod(call) {
   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() });
+    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);
@@ -62,7 +80,7 @@ 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() };
+  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) {
@@ -81,9 +99,14 @@ function resolveData(arg, scope, call, scopes) {
   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) || [];
-  if (offsets.some((o) => o.key === FIELD)) return { migrated: true };
+  // $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 };
+  return { arr: def.right, def, name: arg.name, partial };
 }
 
 export default function transform({ source, file, pack, context = emptyContext() }) {
@@ -120,9 +143,28 @@ export default function transform({ source, file, pack, context = emptyContext()
     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') {
-      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
-        { suggestion: `'${FIELD}' => <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+      // 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];
@@ -139,13 +181,52 @@ export default function transform({ source, file, pack, context = emptyContext()
   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 doubles = keyed.filter((e) => source[e.key.loc.start.offset] === '"').length;
-  const q = doubles > keyed.length / 2 ? '"' : "'";
+  const q = quoteOf(source, entries);
   const key = `${q}${FIELD}${q}`;
 
   const end = anchor.loc.end.offset;

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

@@ -2,10 +2,11 @@
 // 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, applyEdits, 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';
 
@@ -45,6 +46,50 @@ export function decide(obj, pack) {
   }, 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);
+  }
+  return false;
+}
+
+// ...(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 = [];
@@ -77,26 +122,44 @@ export default function transform({ source, file, pack, context = emptyContext()
       const decl = resolveBinding(p, arg.name);
       if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') obj = decl.node.init;
     }
-    if (!obj || hasSpread(obj)) {
+    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') || 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 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: `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+        { 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];
-    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;

package/src/report.js

@@ -83,6 +83,7 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
     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('');
   }
@@ -92,6 +93,11 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
   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);
@@ -102,12 +108,20 @@ export function prBody({ pack, findings, changed, verification }, today = new Da
   // 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 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('', asIssue ? '### Lo que hay que resolver (necesita una persona)' : '### Lo que este PR NO resuelve (necesita una persona)', '');
     for (const f of pending) {