parche-cli 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 Todas las versiones de `parche-cli` (npm) y de la Action `Pepo08/parche@v0`.
 
+## 0.6.2 — 2026-10-18
+
+Pack de IA completo para el apagado de OpenAI del **23/10/2026** (sección "2026-04-22: Legacy GPT model snapshots" de la página oficial, verificada el 18/10).
+
+### Nuevo
+- **Alias `-completions`:** `gpt-3.5-turbo-completions` (reemplazo `gpt-5.6-terra`), `gpt-4-completions`, `gpt-4-0613-completions` y `gpt-4-turbo-completions` (reemplazo `gpt-5.6-sol`).
+- **Modelos fine-tuned:** se avisan los IDs reales (`ft:<modelo base>:<org>:<sufijo>:<id>`, también con `:ckpt-step-…`) de las familias que OpenAI apaga: `ft-gpt-3.5-turbo` y `ft-babbage-002`, `ft-davinci-002` y `ft-o4-mini-2025-04-16` (base de reemplazo `gpt-5.6-terra`), `ft-gpt-4` (`gpt-5.6-sol`) y `ft-gpt-4.1-nano-2025-04-14` (`gpt-5.6-luna`). Se compara el modelo base entero: `ft:gpt-4o-mini-…`, `ft:gpt-4o-…` y `ft:gpt-4.1-…` no son de `gpt-4` y no se avisan (OpenAI los apaga en otra fecha). Como siempre, Parche avisa y no cambia el modelo.
+- El pack cita la guía de fine-tuning de OpenAI como fuente del formato de los IDs. `last_verified`: 2026-10-18 (Anthropic y el resto de OpenAI, revisados contra sus páginas ese día: sin cambios).
+
+## 0.6.1 — 2026-10-18
+
+Lo que encontró el frente de tracción al preparar los PRs con la 0.6.0.
+
+### Arreglado
+- **ARCA en JS: si el objeto recibe el campo después, cuenta como migrado**, igual que en PHP: `voucher.CondicionIVAReceptorId = …`, `voucher['CondicionIVAReceptorId'] = …`, con cast de TS u `Object.assign(voucher, { CondicionIVAReceptorId: … })`. Antes se agregaba el arreglo parcial igual, y era redundante. Una variable con el mismo nombre en otra función no cuenta.
+- **Copias de respaldo:** no se leen ni se editan las carpetas `BAK/`, `backup(s)/`, `old/`, `_old/` y `deprecated/`, ni los archivos `* copy.*`, `* - Copy.*`, `* copia.*`, `*.bak.*`, `*-old.*`, `*_old.*` y `*.old.*`. Tampoco cuentan sus manifiestos ni sus WSDL. El scan y `report.md` dicen qué se saltó.
+- **Windows:** los comandos de git corren con `core.longpaths`. Sin eso, un clon recién hecho con rutas largas daba "Hay cambios sin commitear".
+- **`parche pr --author "Nombre <email>"`** firma con esa identidad sin tocar la configuración de git. `pr` muestra quién firma y, antes de pushear, avisa si el email no es un noreply de GitHub (queda público en el PR).
+- Si solo cambiarían tests o mocks, el texto queda como issue: ya no empieza con "Modifica 1 archivo".
+- La consola ya no repite "No cubre: No cubre…" en los arreglos parciales.
+
 ## 0.6.0 — 2026-10-17
 
 ### Nuevo

package/README.md

@@ -131,13 +131,15 @@ Con el tag, el workflow corre los tests, controla que la versión de `package.js
 |---|---|---|---|---|
 | `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 |
+| `ai.model-retirements` | Anthropic, OpenAI | retiro | varias | solo detección (también modelos fine-tuned de OpenAI, `ft:…`) |
 
 ## Verificación
 
 Antes de commitear, Parche parsea **siempre** cada archivo modificado (JS/TS o PHP): eso no ejecuta nada del repo. Con `--verify`, además corre los tests del repo que correspondan a lo que cambió: `npm test` para JS/TS; para PHP, `composer test` o `vendor/bin/phpunit`. Si no hay tests, queda el chequeo de sintaxis y el PR lo dice. Sin `--verify` (por ejemplo, en un PR a un repo de terceros, donde no se ejecuta su código), el PR dice que Parche no corrió los tests y nombra los workflows del repo que los corren en cada pull request. Si algo falla, no hay PR. El commit lleva la versión del pack que lo generó, para poder rastrear qué regla produjo cada cambio.
 
-**Quién firma el commit:** `PARCHE_GIT_NAME` y `PARCHE_GIT_EMAIL` si están; si no, tu identidad de git (`user.name` y `user.email`, también la que configure tu workflow); en GitHub Actions sin identidad, `github-actions[bot]`, el mismo que abre el PR. Si no hay ninguna, `parche pr` frena antes de tocar el repo.
+**Quién firma el commit:** `--author "Nombre <email>"` si lo pasás; si no, `PARCHE_GIT_NAME` y `PARCHE_GIT_EMAIL` si están; si no, tu identidad de git (`user.name` y `user.email`, también la que configure tu workflow); en GitHub Actions sin identidad, `github-actions[bot]`, el mismo que abre el PR. Si no hay ninguna, `parche pr` frena antes de tocar el repo. Antes de pushear, si el email no es un noreply de GitHub, avisa: va a quedar público en el commit del PR.
+
+**Copias de respaldo:** Parche no lee ni edita carpetas `BAK/`, `backup/`, `old/`, `_old/` y `deprecated/`, ni archivos como `factura copy.php`, `factura - Copy.js`, `factura.bak.php` o `factura-old.php`. El scan dice cuáles saltó, por si alguno es código que corre.
 
 ## ARCA en PHP
 

package/bin/parche.js

@@ -22,9 +22,10 @@ Uso:
   parche diff <paquete> --from <v> --to <v> [--json] [--all]
                                        Qué cambia en la API de un paquete de npm entre dos versiones
   parche fix <dir> [--pack <id>]       Aplica los arreglos en el código
-  parche pr <dir> [--pack <id>] [--dry-run] [--verify] [--push-remote <remote>]
+  parche pr <dir> [--pack <id>] [--dry-run] [--verify] [--push-remote <remote>] [--author "Nombre <email>"]
                                        Rama + commit + PR por cada cambio. Con --push-remote,
-                                       pushea a ese remote (tu fork) y abre el PR contra origin
+                                       pushea a ese remote (tu fork) y abre el PR contra origin.
+                                       Con --author, firma con esa identidad y no con la de git
   parche feedback <dir> --pack <id> --outcome merged|edited|rejected [--note "..."]
 `;
 
@@ -115,6 +116,13 @@ function printDiff(d, { all = false } = {}) {
   }
 }
 
+// Lo que no se revisó por ser copia de respaldo: se dice, no se oculta.
+function printSkipped(skipped = []) {
+  if (!skipped.length) return;
+  const shown = skipped.slice(0, 8).join(', ');
+  console.log(`\nNo revisé ${skipped.length} copia(s) de respaldo: ${shown}${skipped.length > 8 ? ` y ${skipped.length - 8} más` : ''}. Si alguna es código que corre, renombrala o movela.`);
+}
+
 function printFindings(result) {
   for (const pack of result.packs) {
     const fs2 = result.findings.filter((f) => f.pack === pack.id);
@@ -123,7 +131,8 @@ function printFindings(result) {
     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}`);
-      if (f.partial) console.log(`  ${''.padEnd(16)} No cubre: ${f.partial.message}`);
+      // partial.message ya empieza con "No cubre…": sin prefijo (antes salía "No cubre: No cubre").
+      if (f.partial) console.log(`  ${''.padEnd(16)} ${f.partial.message}`);
     }
   }
 }
@@ -171,11 +180,12 @@ async function main() {
     fs.writeFileSync(path.join(root, '.parche', 'inventory.json'), JSON.stringify(result.inventory, null, 2));
     fs.writeFileSync(path.join(root, '.parche', 'report.md'), scanReport({ ...result, changed: [], upgrades }));
     record(root, { type: 'scan', findings: counts(result.findings) });
-    if (args.json) { console.log(JSON.stringify({ inventory: result.inventory, findings: result.findings }, null, 2)); return 0; }
+    if (args.json) { console.log(JSON.stringify({ inventory: result.inventory, findings: result.findings, skipped: result.skipped }, null, 2)); return 0; }
     console.log(`Parche · scan de ${path.basename(root)}\n`);
     printInventory(result.inventory);
     if (upgrades) printUpgrades(upgrades);
     printFindings(result);
+    printSkipped(result.skipped);
     const s = summary(result.findings);
     console.log(s ? `\n${s}` : '\nNinguno de los packs verificados tiene cambios que te afecten hoy.');
     console.log(`Reporte: ${path.join(root, '.parche', 'report.md')}`);
@@ -197,7 +207,13 @@ async function main() {
     if (!git.isRepo(root)) throw new Error('`parche pr` necesita un repositorio git.');
     if (!git.isClean(root)) throw new Error('Hay cambios sin commitear. Commiteá o guardá (stash) antes de correr `parche pr`.');
     // Quién firma el commit se resuelve antes de escribir nada: si falla al commitear, el repo quedaría sucio.
-    git.commitIdentity(root);
+    const env = args.author !== undefined ? { ...process.env, ...git.parseAuthor(args.author) } : process.env;
+    const identity = git.commitIdentity(root, env);
+    console.log(`Firma los commits: ${identity.name} <${identity.email}>`);
+    // El email queda público en el PR: si no es un noreply de GitHub, se avisa antes de pushear (frente B, punto 20).
+    if (!args['dry-run'] && process.env.GITHUB_TOKEN && process.env.GITHUB_ACTIONS !== 'true' && !git.isNoreply(identity.email)) {
+      console.warn(`Ojo: ${identity.email} va a quedar público en el commit del PR. Si preferís no mostrarlo, usá --author "Nombre <usuario@users.noreply.github.com>".`);
+    }
     ensureLocalDir(root);
     const base = git.currentBranch(root);
     const packs = loadPacks().filter((p) => p.codemod && (!packIds || packIds.includes(p.id)));
@@ -225,8 +241,10 @@ async function main() {
           git.discardChanges(root);
           throw new Error(`La verificación falló para ${pack.id}; no se abre el PR y el repo queda como estaba.\n${JSON.stringify(verification, null, 2)}`);
         }
-        fs.writeFileSync(bodyPath, prBody({ pack, findings: result.findings, changed: result.changed, verification }));
-        if (!changedFiles.length || changedFiles.every(isTestFile)) {
+        // Si solo cambiarían tests o mocks no hay PR: el texto queda como issue, sin "Modifica 1 archivo" (frente B, punto 20).
+        const reportOnly = !changedFiles.length || changedFiles.every(isTestFile);
+        fs.writeFileSync(bodyPath, prBody({ pack, findings: result.findings, changed: reportOnly ? [] : result.changed, verification: reportOnly ? null : verification }));
+        if (reportOnly) {
           const why = changedFiles.length ? 'solo cambiaría tests o mocks: no se abre un PR' : 'sin cambios de código';
           git.discardChanges(root);
           console.log(`  ${summary(result.findings)}`);
@@ -235,7 +253,7 @@ async function main() {
           continue;
         }
         const draft = !!(c['needs-review'] || c['needs-input'] || c.blocked);
-        const sha = git.commitAll(root, `${title}\n\n${pack.summary_es}\nPack ${pack.id} v${pack.version}.`);
+        const sha = git.commitAll(root, `${title}\n\n${pack.summary_es}\nPack ${pack.id} v${pack.version}.`, env);
         keepBranch = true;
         console.log(`  Rama ${branch} · commit ${sha} · ${changedFiles.length} archivo(s)${verification ? ` · verificación ${verification.ok ? 'OK' : 'FALLÓ'}` : ''}`);
         console.log(`  ${summary(result.findings)}`);

package/package.json

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

package/packs/ai.model-retirements.json

@@ -1,17 +1,18 @@
 {
   "id": "ai.model-retirements",
-  "version": "2026.10.16",
+  "version": "2026.10.18",
   "provider": "Modelos de IA",
   "title": "Modelos y endpoints de IA retirados o por retirarse",
   "kind": "retirement",
   "severity": "high",
   "deadline": null,
-  "last_verified": "2026-10-16",
+  "last_verified": "2026-10-18",
   "summary_es": "Tu código usa modelos o APIs de IA que ya no responden o tienen fecha de retiro.",
   "why_es": "Los proveedores de modelos retiran IDs de modelo y endpoints con algunas semanas o meses de aviso. Después de la fecha, las llamadas fallan. Parche no reemplaza el modelo automáticamente porque cambiar de modelo cambia el comportamiento: te avisa, te dice la fecha y el reemplazo que recomienda el proveedor.",
   "sources": [
     { "title": "Anthropic: Model deprecations", "url": "https://platform.claude.com/docs/en/about-claude/model-deprecations" },
-    { "title": "OpenAI: Deprecations", "url": "https://developers.openai.com/api/docs/deprecations" }
+    { "title": "OpenAI: Deprecations", "url": "https://developers.openai.com/api/docs/deprecations" },
+    { "title": "OpenAI: Supervised fine-tuning (formato de los IDs ft:)", "url": "https://developers.openai.com/api/docs/guides/supervised-fine-tuning" }
   ],
   "detect": {
     "packages": ["@anthropic-ai/sdk", "openai"],
@@ -45,11 +46,15 @@
       "o3-pro-2025-06-10": { "date": "2026-12-11", "replacement": "gpt-5.6-sol (reasoning.mode: pro)" },
       "gpt-3.5-turbo": { "date": "2026-10-23", "replacement": "gpt-5.6-terra" },
       "gpt-3.5-turbo-0125": { "date": "2026-10-23", "replacement": "gpt-5.6-terra" },
+      "gpt-3.5-turbo-completions": { "date": "2026-10-23", "replacement": "gpt-5.6-terra" },
       "gpt-4": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
       "gpt-4-0613": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
+      "gpt-4-completions": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
+      "gpt-4-0613-completions": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
       "gpt-4-1106-preview": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
       "gpt-4-turbo": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
       "gpt-4-turbo-2024-04-09": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
+      "gpt-4-turbo-completions": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
       "gpt-4.1-nano": { "date": "2026-10-23", "replacement": "gpt-5.6-luna" },
       "gpt-4.1-nano-2025-04-14": { "date": "2026-10-23", "replacement": "gpt-5.6-luna" },
       "gpt-4o-2024-05-13": { "date": "2026-10-23", "replacement": "gpt-5.6-sol" },
@@ -77,6 +82,14 @@
       "chatgpt-4o-latest": { "date": "2026-02-17", "replacement": "gpt-5.1-chat-latest" },
       "codex-mini-latest": { "date": "2026-02-12", "replacement": "gpt-5-codex-mini" }
     },
+    "retired_fine_tunes": {
+      "ft-gpt-3.5-turbo": { "date": "2026-10-23", "replacement": "gpt-5.6-terra", "bases": ["gpt-3.5-turbo", "gpt-3.5-turbo-0125", "gpt-3.5-turbo-1106", "gpt-3.5-turbo-0613"] },
+      "ft-gpt-4": { "date": "2026-10-23", "replacement": "gpt-5.6-sol", "bases": ["gpt-4", "gpt-4-0613"] },
+      "ft-gpt-4.1-nano-2025-04-14": { "date": "2026-10-23", "replacement": "gpt-5.6-luna", "bases": ["gpt-4.1-nano-2025-04-14", "gpt-4.1-nano"] },
+      "ft-o4-mini-2025-04-16": { "date": "2026-10-23", "replacement": "gpt-5.6-terra", "bases": ["o4-mini-2025-04-16", "o4-mini"] },
+      "ft-babbage-002": { "date": "2026-10-23", "replacement": "gpt-5.6-terra", "bases": ["babbage-002"] },
+      "ft-davinci-002": { "date": "2026-10-23", "replacement": "gpt-5.6-terra", "bases": ["davinci-002"] }
+    },
     "retirement_floors": {
       "claude-haiku-4-5-20251001": "2026-10-15",
       "claude-opus-4-5-20251101": "2026-11-24"

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

@@ -74,6 +74,32 @@ const otherSpread = (obj) => obj.properties.some((p) => (p.type === 'SpreadEleme
 
 const textOf = (source, node) => source.slice(offsetAt(source, node.loc.start), offsetAt(source, node.loc.end));
 
+// Nombre de la propiedad de un acceso: voucher.Campo o voucher['Campo'].
+const memberName = (m) => (!m.computed && m.property.type === 'Identifier' ? m.property.name
+  : m.computed && (m.property.type === 'StringLiteral' || m.property.type === 'Literal') ? m.property.value : null);
+
+// ¿El objeto de la variable `name` (declarada en `decl`) recibe el campo después de armarse?
+// voucher.CondicionIVAReceptorId = …, voucher['CondicionIVAReceptorId'] = …, (voucher as any).CondicionIVAReceptorId = …
+// u Object.assign(voucher, { CondicionIVAReceptorId: … }). Cuenta como migrado, igual que en PHP
+// (frente B, punto 18: tometh04/vibook-services lo asigna en un if y Parche agregaba el arreglo parcial igual).
+// Solo cuenta si es la misma variable: otra con el mismo nombre en otra función no.
+function fieldAssignedLater(j, root, decl, name) {
+  const same = (p) => resolveBinding(p, name)?.node === decl.node;
+  const isVar = (n) => { const x = unwrap(n); return !!(x && x.type === 'Identifier' && x.name === name); };
+  const assigned = root.find(j.AssignmentExpression).filter((p) => {
+    const left = unwrap(p.node.left);
+    return left && left.type === 'MemberExpression' && isVar(left.object) && memberName(left) === 'CondicionIVAReceptorId' && same(p);
+  }).size() > 0;
+  if (assigned) return true;
+  return root.find(j.CallExpression).filter((p) => {
+    const c = unwrap(p.node.callee);
+    const isAssign = c && c.type === 'MemberExpression' && !c.computed && c.object.type === 'Identifier' && c.object.name === 'Object'
+      && c.property.type === 'Identifier' && c.property.name === 'assign';
+    if (!isAssign || !isVar(p.node.arguments[0]) || !same(p)) return false;
+    return p.node.arguments.slice(1).some((a) => { const o = unwrap(a); return o && o.type === 'ObjectExpression' && !!getProp(o, 'CondicionIVAReceptorId'); });
+  }).size() > 0;
+}
+
 // 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.
@@ -117,10 +143,11 @@ export default function transform({ source, file, pack, context = emptyContext()
     usages.push({ provider: 'arca', op: `ElectronicBilling.${voucherCallee(p).property.name}`, line: call.loc?.start.line });
     const arg = call.arguments[0];
     let obj = null;
+    let binding = null;
     if (arg && arg.type === 'ObjectExpression') obj = arg;
     else if (arg && arg.type === 'Identifier') {
       const decl = resolveBinding(p, arg.name);
-      if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') obj = decl.node.init;
+      if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') { obj = decl.node.init; binding = decl; }
     }
     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".
@@ -128,6 +155,7 @@ export default function transform({ source, file, pack, context = emptyContext()
       return;
     }
     if (getProp(obj, 'CondicionIVAReceptorId') || edited.has(obj)) return; // ya está migrado (o ya lo editamos)
+    if (binding && fieldAssignedLater(j, root, binding, arg.name)) return; // lo completa después: también migrado
     const spreads = obj.properties.map(conditionSpread);
     if (spreads.includes('full')) return;
 

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

@@ -8,6 +8,10 @@ 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;
+// Modelos fine-tuned de OpenAI: el ID real es `ft:<modelo base>:<org>:<sufijo>:<id>` (guía de fine-tuning).
+// Se compara el modelo base entero, hasta el `:`, contra `bases` del pack: nunca un prefijo, porque
+// `ft:gpt-4o-mini-2024-07-18:...` no es un fine-tuned de `gpt-4` y se apaga en otra fecha.
+const FINE_TUNE = /["'`]ft:([\w.-]+):/g;
 
 // Acepta el formato nuevo ({ date, replacement }) y el viejo (solo la fecha).
 const entry = (v) => (typeof v === 'string' ? { date: v, replacement: null } : v);
@@ -17,6 +21,8 @@ export default function detect({ source, file, pack, today = new Date().toISOStr
   const findings = [];
   const usages = [];
   const { retired_models: retired, retirement_floors: floors, retired_endpoints: endpoints } = pack.detect;
+  const fineTunes = new Map();
+  for (const [name, e] of Object.entries(pack.detect.retired_fine_tunes || {})) for (const b of e.bases) fineTunes.set(b, { name, ...e });
   const azure = AZURE.test(source);
   const lines = source.split('\n');
   lines.forEach((l, i) => {
@@ -34,6 +40,18 @@ export default function detect({ source, file, pack, today = new Date().toISOStr
       findings.push({ pack: PACK, file, line, status: 'detect-only', message });
       usages.push({ provider: 'ia', op: `modelo ${model}`, line });
     }
+    for (const [, base] of l.matchAll(FINE_TUNE)) {
+      const ft = fineTunes.get(base);
+      if (!ft) continue;
+      const past = ft.date <= today;
+      const when = past ? `fue retirado el ${ft.date}` : `se retira el ${ft.date}`;
+      const repl = `OpenAI recomienda como modelo base de reemplazo \`${ft.replacement}\`; el modelo fine-tuned no se migra solo.`;
+      const message = inCall
+        ? `El modelo fine-tuned sobre \`${base}\` (\`${ft.name}\`) ${when}${past ? ': las llamadas ya fallan' : ''}. ${repl} Corré tus pruebas de prompts antes de cambiarlo.`
+        : `Aparece un modelo fine-tuned sobre \`${base}\` (\`${ft.name}\`, ${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 fine-tuned ${base}`, line });
+    }
     for (const [model, date] of Object.entries(floors)) {
       if (!l.includes(model)) continue;
       findings.push({ pack: PACK, file, line, status: 'detect-only',

package/src/engine.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadPacks, transformFor, languageOf } from './packs.js';
-import { SKIP_DIRS, toPosix } from './paths.js';
+import { SKIP_DIRS, toPosix, isBackupDir, isBackupFile } from './paths.js';
 import { scanJs } from './inventory/js-scan.js';
 import { readManifests, buildInventory } from './inventory/index.js';
 import { buildContext } from './context.js';
@@ -10,18 +10,25 @@ import { buildContext } from './context.js';
 // 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) {
+// Archivos que el motor lee. Las copias de respaldo (BAK/, "x copy.php"…) no se leen ni se editan:
+// van a `skipped`, con "/", para decir en el reporte qué se ignoró.
+export function listFiles(dir, skipped = []) {
   const out = [];
   const walk = (d) => {
     for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const rel = () => toPosix(path.relative(dir, path.join(d, e.name)));
       if (e.isDirectory()) {
-        if (!SKIP_DIRS.has(e.name)) walk(path.join(d, e.name));
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (isBackupDir(e.name)) { skipped.push(`${rel()}/`); continue; }
+        walk(path.join(d, e.name));
       } else if (EXT.test(e.name) && !/\.d\.ts$/.test(e.name)) {
-        out.push(path.join(d, e.name));
+        if (isBackupFile(e.name)) skipped.push(rel());
+        else out.push(path.join(d, e.name));
       }
     }
   };
   walk(dir);
+  skipped.sort();
   // Mismo orden en Windows y en Linux: se ordena por la ruta con "/".
   return out.sort((a, b) => (toPosix(a) < toPosix(b) ? -1 : 1));
 }
@@ -31,7 +38,8 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
   const packs = loadPacks().filter((p) => !packIds || packIds.includes(p.id));
   const manifests = readManifests(root);
   const deps = { ...manifests.npm, ...manifests.composer };
-  const files = listFiles(root);
+  const skipped = [];
+  const files = listFiles(root, skipped);
   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);
@@ -83,7 +91,7 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
     providers: Object.fromEntries(Object.entries(providers).map(([k, v]) => [k, { ...v, files: [...v.files] }])),
     usages,
   };
-  return { root, packs, context, inventory, findings, changed: [...changed.entries()].map(([file, packIds]) => ({ file, packs: packIds })) };
+  return { root, packs, context, inventory, findings, skipped, 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

@@ -1,6 +1,9 @@
 import { execFileSync } from 'node:child_process';
 
-const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+// En Windows, sin core.longpaths, git ve modificado un archivo con ruta de más de 260 caracteres, y `parche pr`
+// frenaba con "Hay cambios sin commitear" en un clon recién hecho (frente B, punto 20).
+export const gitArgs = (args, platform = process.platform) => (platform === 'win32' ? ['-c', 'core.longpaths=true', ...args] : args);
+const git = (cwd, ...args) => execFileSync('git', gitArgs(args), { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 
 export function isRepo(cwd) {
   try {
@@ -48,6 +51,17 @@ export function commitIdentity(cwd, env = process.env) {
   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.');
 }
 
+// --author "Nombre <email>": quién firma, sin tocar la configuración de git de la máquina (frente B, punto 20:
+// la identidad global de la compu era otra persona con un mail personal).
+export function parseAuthor(text) {
+  const m = /^\s*(.+?)\s*<([^<>\s]+@[^<>\s]+)>\s*$/.exec(typeof text === 'string' ? text : '');
+  if (!m) throw new Error('--author tiene que ser "Nombre <email>", por ejemplo --author "Ana Pérez <ana@users.noreply.github.com>".');
+  return { PARCHE_GIT_NAME: m[1], PARCHE_GIT_EMAIL: m[2] };
+}
+
+// El email del commit queda público en el PR: si no es un noreply de GitHub, `parche pr` avisa antes de pushear.
+export const isNoreply = (email) => /@users\.noreply\.github\.com$/i.test(email || '');
+
 export function commitAll(cwd, message, env = process.env) {
   const id = commitIdentity(cwd, env);
   git(cwd, 'add', '-A');

package/src/paths.js

@@ -16,9 +16,19 @@ export function isTestFile(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) {
+// Copias de respaldo: no es el código que corre. Un PR sobre BAK/ o sobre "factura copy.php" no le sirve al
+// mantenedor (frente B, 17/10: axel-tecnosoul/facturador ya usaba el campo en los archivos vigentes).
+// Carpetas BAK, backup(s), old, _old y deprecated; archivos "x copy.php", "x - Copy.js", "x copia.php",
+// "x.bak.php", "x-old.js", "x_old.php" y "x.old.php". No cuentan "deep_copy.js" ni "gold.js".
+const BACKUP_DIR = /^(bak|backups?|old|_old|deprecated)$/i;
+export const isBackupDir = (name) => BACKUP_DIR.test(name);
+export function isBackupFile(name) {
+  return /\s(-\s)?(copy|copia)(\s\(?\d+\)?)?\.[^.]+$/i.test(name) || /\.bak\.[^.]+$/i.test(name) || /[-_.]old\.[^.]+$/i.test(name);
+}
+
+// Recorre el repo (salteando SKIP_DIRS y las copias de respaldo) y devuelve las rutas relativas, con "/",
+// de los archivos que cumplen `match(nombre)`. Lo salteado por ser respaldo va a `skipped`, si se pasa.
+export function findFiles(root, match, skipped = null) {
   const out = [];
   const walk = (dir) => {
     let entries;
@@ -28,8 +38,15 @@ export function findFiles(root, match) {
       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))));
+      const rel = () => toPosix(path.relative(root, path.join(dir, e.name)));
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (isBackupDir(e.name)) { skipped?.push(`${rel()}/`); continue; }
+        walk(path.join(dir, e.name));
+      } else if (match(e.name)) {
+        if (isBackupFile(e.name)) skipped?.push(rel());
+        else out.push(rel());
+      }
     }
   };
   walk(root);

package/src/report.js

@@ -53,7 +53,7 @@ function upgradesSection(upgrades) {
   return out;
 }
 
-export function scanReport({ inventory, findings, packs, changed, upgrades = null }, today = new Date()) {
+export function scanReport({ inventory, findings, packs, changed, upgrades = null, skipped = [] }, today = new Date()) {
   const out = [];
   out.push(`# Parche — reporte de \`${inventory.repo}\``, '');
   out.push('## APIs que usa este repo', '');
@@ -73,6 +73,10 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
     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 (skipped.length) {
+    out.push('**Copias de respaldo que no se revisaron** (si alguna es código que corre, renombrala o movela):', '',
+      ...skipped.map((s) => `- \`${s}\``), '');
+  }
   if (upgrades) out.push(...upgradesSection(upgrades));
   for (const pack of packs) {
     const fs = findings.filter((f) => f.pack === pack.id);