parche-cli 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joaquín González
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,96 @@
-# Temporary Holding Version
+# Parche — Dependabot para APIs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![CI](https://github.com/Pepo08/parche/actions/workflows/ci.yml/badge.svg)](https://github.com/Pepo08/parche/actions/workflows/ci.yml)
+
+Parche lee tu código, arma un inventario de qué APIs de terceros usás (Mercado Pago, ARCA, modelos de IA…) y lo cruza contra una base de **cambios de API verificados**. Cuando un proveedor cambia algo que te afecta, Parche abre un PR con el arreglo, explica qué cambió y por qué, y marca lo que necesita una persona. Ningún PR sale sin pasar la verificación.
+
+```
+$ parche scan .
+APIs encontradas:
+  mercadopago   4 usos en 4 archivo(s)  [Payment.create, Payment.get]
+  arca          3 usos en 1 archivo(s)  [ElectronicBilling.createNextVoucher]
+  ia            2 usos en 1 archivo(s)  [modelo claude-3-5-haiku-20241022, OpenAI Assistants API]
+
+■ Condición frente al IVA del receptor obligatoria en WSFEv1
+  ARCA (ex AFIP) · severidad critical · vence 2026-12-01 (47 días)
+  ✅ automático     src/facturacion.js:14  Agregado CondicionIVAReceptorId: 5 (Consumidor Final)…
+  👀 revisar       src/facturacion.js:56  Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C)…
+  ✋ falta un dato  src/facturacion.js:62  Falta CondicionIVAReceptorId y no se puede inferir… (comprobante clase A).
+…
+✅ automático: 5   👀 revisar: 8   ✋ falta un dato: 1   ⛔ bloqueado: 1   🔎 detectado: 2
+```
+
+## Por qué packs y no "un LLM que arregla todo"
+
+Ya hay varios prototipos que le piden a un modelo que lea un changelog y escriba el fix. El problema es que el modelo solo sabe lo que aprendió en su entrenamiento, y una migración de pagos o de facturación no admite "casi bien". Parche separa las dos cosas:
+
+- **El pack es dato, no prompt.** Cada cambio de API es un JSON versionado con fuente, fecha límite, reglas de detección, mapeo de campos, casos bloqueados y checklist de revisión (ver `packs/`). Un LLM puede ayudar a *redactar* un pack a partir de un changelog, pero una persona lo verifica antes de publicarlo.
+- **El arreglo es determinístico.** Los codemods trabajan sobre el AST, respetan el formato del cliente (el diff de ARCA es de 2 líneas por factura) y son idempotentes.
+- **Lo que no se puede inferir, no se inventa.** Si falta un dato del negocio (¿este cliente con CUIT es Responsable Inscripto o Monotributo?), el PR lo dice y muestra los valores válidos.
+- **Cada PR mergeado, editado o rechazado vuelve como señal** (`.parche/ledger.jsonl`, `parche feedback`). Eso es lo que hace que la base mejore con el uso.
+
+## Uso
+
+Requiere Node 22 o más nuevo. El paquete de npm se llama `parche-cli`; si lo instalás (`npm i -g parche-cli`), el comando es `parche`.
+
+```bash
+npx parche-cli packs                 # cambios que Parche conoce
+npx parche-cli scan .                # inventario + qué te afecta (.parche/report.md)
+npx parche-cli fix .                 # aplica los arreglos en tu working copy
+npx parche-cli pr . --verify         # una rama + commit + PR por cambio
+npx parche-cli feedback . --pack <id> --outcome merged|edited|rejected
+```
+
+`parche pr` abre el PR por la API de GitHub si hay `GITHUB_TOKEN` y un remote `origin` en github.com; si no (o con `--dry-run`), deja la rama, el commit y el cuerpo del PR en `.parche/pr-<pack>.md`. Si hay ítems para revisar, el PR se abre como borrador.
+
+### En GitHub Actions
+
+Para que corra todas las semanas, copiá [`templates/github-workflow.yml`](templates/github-workflow.yml) a `.github/workflows/parche.yml`. El paso clave es:
+
+```yaml
+- uses: Pepo08/parche@v0
+  with:
+    verify: 'true'     # corre tu npm test antes de abrir cada PR
+    # pack: arca.wsfe.condicion-iva-receptor   # opcional: un solo pack
+    # dry-run: 'true'                          # opcional: armar las ramas sin abrir PRs
+```
+
+El workflow necesita `permissions: contents: write` y `pull-requests: write`.
+
+### Desarrollo
+
+```bash
+npm install
+npm test                         # 13 tests; el CI los corre en Linux y Windows
+bash demo.sh                     # demo completa sobre examples/tienda-demo
+```
+
+## Estados de cada hallazgo
+
+| Estado | Qué significa |
+|---|---|
+| ✅ automático | El arreglo es seguro y queda aplicado. |
+| 👀 revisar | Se aplicó, pero hay una decisión que confirmar (va en el PR, que sale como borrador). |
+| ✋ falta un dato | No se puede arreglar sin información del negocio. El PR dice qué agregar y con qué valores. |
+| ⛔ bloqueado | Migrarlo rompería algo (ej. `application_fee` en Orders). No se toca. |
+| 🔎 detectado | Solo aviso: cambiarlo cambia el comportamiento (ej. modelo de IA retirado). |
+
+## Packs incluidos
+
+| Pack | Proveedor | Tipo | Fecha límite | Arreglo |
+|---|---|---|---|---|
+| `arca.wsfe.condicion-iva-receptor` | ARCA | rompe | 2026-12-01 | sí (consumidor final y DNI B/C) |
+| `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 |
+
+## Verificación
+
+Antes de commitear, `--verify` parsea cada archivo modificado (JS/TS) y corre el `npm test` del repo. 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.
+
+## Límites del MVP
+
+- Solo Node.js (JS/TS, ESM y CommonJS). Siguen PHP (la mayoría de los sistemas de facturación locales), Python y Java.
+- ARCA: cubre `@afipsdk/afip.js`. Las integraciones SOAP propias se detectan pero no se reescriben.
+- Mercado Pago: migra la creación de pagos con el SDK v2. Las consultas, capturas y reembolsos de pagos existentes se dejan a propósito en Payments API, como indica la guía oficial.
+- Se distribuye como CLI (`npx parche-cli`) + GitHub Action (`Pepo08/parche@v0`). La GitHub App (instalación en un click, PRs automáticos al publicarse un pack nuevo) es el próximo paso.
+- La capa de LLM (redactar packs desde changelogs y resolver casos "falta un dato" leyendo el modelo de datos del cliente) todavía no está incluida; cuando entre, va a pasar por la misma verificación.

package/bin/parche.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+// Parche — Dependabot para APIs.
+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 { verify } from '../src/verify.js';
+import * as git from '../src/git.js';
+import { parseGithubRemote, openPullRequest } from '../src/github.js';
+import { record } from '../src/ledger.js';
+
+const HELP = `parche — Dependabot para APIs
+
+Uso:
+  parche packs                         Lista los cambios de API que Parche conoce
+  parche scan <dir> [--json]           Inventario de APIs + qué te afecta
+  parche fix <dir> [--pack <id>]       Aplica los arreglos en el código
+  parche pr <dir> [--pack <id>] [--dry-run] [--verify]
+                                       Rama + commit + PR por cada cambio
+  parche feedback <dir> --pack <id> --outcome merged|edited|rejected [--note "..."]
+`;
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('--')) { args[key] = next; i++; } else args[key] = true;
+    } else args._.push(a);
+  }
+  return args;
+}
+
+function summary(findings) {
+  const c = counts(findings);
+  return ['auto', 'needs-review', 'needs-input', 'blocked', 'detect-only']
+    .filter((k) => c[k]).map((k) => `${LABEL[k]}: ${c[k]}`).join('   ');
+}
+
+function ensureLocalDir(root) {
+  fs.mkdirSync(path.join(root, '.parche'), { recursive: true });
+  const exclude = path.join(root, '.git', 'info', 'exclude');
+  if (fs.existsSync(path.dirname(exclude))) {
+    const cur = fs.existsSync(exclude) ? fs.readFileSync(exclude, 'utf8') : '';
+    if (!cur.includes('.parche/')) fs.appendFileSync(exclude, '\n.parche/\n');
+  }
+}
+
+function printFindings(result) {
+  for (const pack of result.packs) {
+    const fs2 = result.findings.filter((f) => f.pack === pack.id);
+    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}`);
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const [cmd, dirArg] = args._;
+  if (!cmd || args.help) { console.log(HELP); return 0; }
+
+  if (cmd === 'packs') {
+    for (const p of loadPacks()) {
+      console.log(`${p.id.padEnd(36)} ${p.provider.padEnd(16)} ${p.kind.padEnd(10)} ${p.severity.padEnd(9)} ${p.deadline || '—'}  ${p.codemod ? 'con arreglo' : 'solo detección'}`);
+    }
+    return 0;
+  }
+
+  const root = path.resolve(dirArg || '.');
+  if (!fs.existsSync(root)) throw new Error(`No existe ${root}`);
+  const packIds = args.pack ? [args.pack] : null;
+
+  if (cmd === 'scan') {
+    const result = run(root, { write: false, packIds });
+    ensureLocalDir(root);
+    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: [] }));
+    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; }
+    console.log(`Parche · scan de ${path.basename(root)}\n`);
+    console.log('APIs encontradas:');
+    for (const [prov, p] of Object.entries(result.inventory.providers)) {
+      console.log(`  ${prov.padEnd(12)} ${String(p.callSites).padStart(2)} usos en ${p.files.length} archivo(s)  [${Object.keys(p.ops).join(', ')}]`);
+    }
+    printFindings(result);
+    console.log(`\n${summary(result.findings)}`);
+    console.log(`Reporte: ${path.join(root, '.parche', 'report.md')}`);
+    return 0;
+  }
+
+  if (cmd === 'fix') {
+    const result = run(root, { write: true, packIds });
+    ensureLocalDir(root);
+    fs.writeFileSync(path.join(root, '.parche', 'report.md'), scanReport(result));
+    record(root, { type: 'fix', packs: packIds, changed: result.changed.map((c) => c.file) });
+    console.log(result.changed.length ? 'Archivos modificados:' : 'Nada para modificar.');
+    for (const c of result.changed) console.log(`  ${c.file}  (${c.packs.join(', ')})`);
+    console.log(`\n${summary(result.findings)}`);
+    return 0;
+  }
+
+  if (cmd === 'pr') {
+    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`.');
+    ensureLocalDir(root);
+    const base = git.currentBranch(root);
+    const packs = loadPacks().filter((p) => p.codemod && (!packIds || packIds.includes(p.id)));
+    for (const pack of packs) {
+      const preview = run(root, { write: false, packIds: [pack.id] });
+      if (!preview.findings.length) continue;
+      const branch = `parche/${pack.id}`;
+      git.checkoutNewBranch(root, branch, base);
+      const result = run(root, { write: true, packIds: [pack.id] });
+      const changedFiles = result.changed.map((c) => c.file);
+      const verification = args.verify || args['dry-run'] ? verify(root, changedFiles, { runTests: !!args.verify }) : null;
+      if (verification && !verification.ok) {
+        git.checkout(root, base);
+        throw new Error(`La verificación falló para ${pack.id}; no se abre el PR.\n${JSON.stringify(verification, null, 2)}`);
+      }
+      const body = prBody({ pack, findings: result.findings, changed: result.changed, verification });
+      const bodyPath = path.join(root, '.parche', `pr-${pack.id}.md`);
+      fs.writeFileSync(bodyPath, body);
+      const c = counts(result.findings);
+      const draft = !!(c['needs-review'] || c['needs-input'] || c.blocked);
+      const title = `Parche: ${pack.title}`;
+      console.log(`\n■ ${title}`);
+      if (!changedFiles.length) {
+        console.log('  Sin cambios de código: queda como issue/reporte (ver cuerpo del PR).');
+        git.checkout(root, base);
+        record(root, { type: 'report-only', pack: pack.id, findings: c });
+        continue;
+      }
+      const sha = git.commitAll(root, `${title}\n\n${pack.summary_es}\nPack ${pack.id} v${pack.version}.`);
+      console.log(`  Rama ${branch} · commit ${sha} · ${changedFiles.length} archivo(s)${verification ? ` · verificación ${verification.ok ? 'OK' : 'FALLÓ'}` : ''}`);
+      console.log(`  ${summary(result.findings)}`);
+      console.log(`  Cuerpo del PR: ${bodyPath}`);
+      const remote = parseGithubRemote(git.originUrl(root));
+      let url = null;
+      if (!args['dry-run'] && process.env.GITHUB_TOKEN && remote) {
+        git.push(root, branch);
+        url = await openPullRequest({ token: process.env.GITHUB_TOKEN, ...remote, head: branch, base, title, body, draft });
+        console.log(`  PR abierto${draft ? ' (borrador)' : ''}: ${url}`);
+      } 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 });
+      git.checkout(root, base);
+    }
+    return 0;
+  }
+
+  if (cmd === 'feedback') {
+    if (!args.pack || !['merged', 'edited', 'rejected'].includes(args.outcome)) throw new Error('Uso: parche feedback <dir> --pack <id> --outcome merged|edited|rejected');
+    record(root, { type: 'feedback', pack: args.pack, outcome: args.outcome, note: args.note || null });
+    console.log(`Registrado: ${args.pack} → ${args.outcome}. Gracias, esto mejora el pack para todos.`);
+    return 0;
+  }
+
+  console.log(HELP);
+  return 1;
+}
+
+main().then((code) => process.exit(code)).catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "parche-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Dependabot para APIs: detecta cambios de APIs de terceros en tu código y abre el PR con el arreglo.",
+  "keywords": [
+    "api",
+    "migration",
+    "codemod",
+    "dependabot",
+    "arca",
+    "afip",
+    "wsfe",
+    "mercadopago",
+    "github-action"
+  ],
+  "homepage": "https://github.com/Pepo08/parche#readme",
+  "bugs": "https://github.com/Pepo08/parche/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pepo08/parche.git"
+  },
+  "author": "Joaquín González",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "parche": "bin/parche.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "packs",
+    "templates"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "demo": "bash demo.sh"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.0",
+    "jscodeshift": "^17.3.0"
+  }
+}

package/packs/ai.model-retirements.json

@@ -0,0 +1,44 @@
+{
+  "id": "ai.model-retirements",
+  "version": "2026.10.15",
+  "provider": "Modelos de IA",
+  "title": "Modelos y endpoints de IA retirados o por retirarse",
+  "kind": "retirement",
+  "severity": "high",
+  "deadline": null,
+  "last_verified": "2026-10-15",
+  "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 y te dice a qué migrar.",
+  "sources": [
+    { "title": "Anthropic: Model deprecations", "url": "https://platform.claude.com/docs/en/about-claude/model-deprecations" },
+    { "title": "OpenAI Assistants API: cierre el 26/08/2026", "url": "https://dev.to/mr_manushukla/openai-assistants-api-shuts-down-26-august-2026-a-3-week-migration-sprint-plan-596b" }
+  ],
+  "detect": {
+    "packages": ["@anthropic-ai/sdk", "openai"],
+    "retired_models": {
+      "claude-3-opus-20240229": "2026-01-05",
+      "claude-3-7-sonnet-20250219": "2026-02-19",
+      "claude-3-5-haiku-20241022": "2026-02-19",
+      "claude-3-haiku-20240307": "2026-04-20",
+      "claude-sonnet-4-20250514": "2026-06-15",
+      "claude-opus-4-20250514": "2026-06-15",
+      "claude-opus-4-1-20250805": "2026-08-05"
+    },
+    "retirement_floors": {
+      "claude-sonnet-4-5-20250929": "2026-09-29",
+      "claude-haiku-4-5-20251001": "2026-10-15",
+      "claude-opus-4-5-20251101": "2026-11-24"
+    },
+    "retired_endpoints": [
+      { "pattern": ".beta.assistants", "retired": "2026-08-26", "replacement_es": "Responses API + Conversations API" },
+      { "pattern": ".beta.threads", "retired": "2026-08-26", "replacement_es": "Responses API + Conversations API" },
+      { "pattern": "/v1/assistants", "retired": "2026-08-26", "replacement_es": "Responses API + Conversations API" }
+    ]
+  },
+  "codemod": null,
+  "review_checklist_es": [
+    "Elegir el modelo de reemplazo según la página de deprecaciones del proveedor.",
+    "Correr tus evals o pruebas de regresión de prompts antes de cambiar de modelo.",
+    "Revisar parámetros que cambian entre generaciones de modelos."
+  ]
+}

package/packs/arca.wsfe.condicion-iva-receptor.json

@@ -0,0 +1,49 @@
+{
+  "id": "arca.wsfe.condicion-iva-receptor",
+  "version": "2026.10.15",
+  "provider": "ARCA (ex AFIP)",
+  "title": "Condición frente al IVA del receptor obligatoria en WSFEv1",
+  "kind": "breaking",
+  "severity": "critical",
+  "deadline": "2026-12-01",
+  "last_verified": "2026-10-15",
+  "summary_es": "Desde el 1/12/2026 ARCA rechaza automáticamente las solicitudes de CAE que no informen CondicionIVAReceptorId.",
+  "why_es": "La RG 5616/2024 hizo obligatorio informar la condición frente al IVA del receptor en cada comprobante electrónico. El manual del desarrollador de WSFEv1 (v4.8) fija el 1 de diciembre de 2026 como fecha desde la cual el campo es obligatorio: si viaja vacío, nulo o no viaja, el pedido de CAE se rechaza y no se puede facturar.",
+  "sources": [
+    { "title": "VATupdate: Argentina makes recipient VAT status mandatory (WSFEv1 v4.8)", "url": "https://www.vatupdate.com/2026/09/09/argentina-makes-recipient-vat-status-mandatory-in-electronic-invoices/" },
+    { "title": "iProfesional: ARCA rechazará facturas sin la condición del cliente frente al IVA", "url": "https://www.iprofesional.com/impuestos/464104-nuevo-requisito-arca-puede-trabar-emision-facturas" },
+    { "title": "Tabla de códigos de FEParamGetCondicionIvaReceptor", "url": "https://app.spomsolutions.com/blog/condicion-iva-receptor-rg-5616" }
+  ],
+  "detect": {
+    "packages": ["@afipsdk/afip.js", "afip.js"],
+    "calls": ["ElectronicBilling.createVoucher", "ElectronicBilling.createNextVoucher"],
+    "raw_markers": ["FECAESolicitar", "FECAEDetRequest"],
+    "field": "CondicionIVAReceptorId"
+  },
+  "codes": {
+    "1": "IVA Responsable Inscripto",
+    "4": "IVA Sujeto Exento",
+    "5": "Consumidor Final",
+    "6": "Responsable Monotributo",
+    "7": "Sujeto No Categorizado",
+    "8": "Proveedor del Exterior",
+    "9": "Cliente del Exterior",
+    "10": "IVA Liberado – Ley N° 19.640",
+    "13": "Monotributista Social",
+    "15": "IVA No Alcanzado",
+    "16": "Monotributo Trabajador Independiente Promovido"
+  },
+  "codes_by_class": {
+    "A": [1, 6, 13, 16],
+    "B": [4, 5, 7, 8, 9, 10, 15],
+    "C": [1, 4, 5, 6, 7, 8, 9, 10, 13, 15, 16]
+  },
+  "codes_note_es": "Validá los códigos contra FEParamGetCondicionIvaReceptor en homologación antes de pasar a producción.",
+  "codemod": "arca-wsfe-condicion-iva",
+  "review_checklist_es": [
+    "Probar la emisión en homologación (wsfehomo) con cada tipo de comprobante que emitís.",
+    "Confirmar que cada cliente con CUIT tiene guardada su condición frente al IVA y que se envía en cada CAE.",
+    "Pedir la condición frente al IVA en el alta de clientes nuevos.",
+    "Validar los códigos con FEParamGetCondicionIvaReceptor (la tabla puede cambiar)."
+  ]
+}

package/packs/mercadopago.payments-to-orders.json

@@ -0,0 +1,57 @@
+{
+  "id": "mercadopago.payments-to-orders",
+  "version": "2026.10.15",
+  "provider": "Mercado Pago",
+  "title": "Migración de creación de pagos: Payments API → Orders API",
+  "kind": "migration",
+  "severity": "medium",
+  "deadline": null,
+  "last_verified": "2026-10-15",
+  "summary_es": "Mercado Pago dejó de sumar features a Payments API; Orders API es la integración nueva para Checkout API.",
+  "why_es": "Payments API sigue funcionando pero solo recibe correcciones de seguridad y estabilidad. Orders API unifica el procesamiento online, trae varias transacciones por orden, captura dedicada, 3DS 2.0 nativo y errores consolidados. Los pagos ya creados se siguen consultando, capturando, cancelando y reembolsando por la API con la que se crearon, así que Parche migra solo la creación y deja el resto marcado para revisión.",
+  "sources": [
+    { "title": "Mercado Pago: Cómo migrar de Payments API a Orders API", "url": "https://www.mercadopago.com.ar/developers/es/docs/checkout-api-orders/resources/migrate-payments-to-orders" },
+    { "title": "SDK Node.js de Mercado Pago (clase Order)", "url": "https://www.npmjs.com/package/mercadopago" }
+  ],
+  "detect": {
+    "packages": ["mercadopago"],
+    "calls": ["Payment.create", "Payment.get", "Payment.search", "Payment.cancel", "Payment.capture", "PaymentRefund"],
+    "raw_markers": ["api.mercadopago.com/v1/payments"],
+    "legacy_v1": ["mercadopago.configure(", "mercadopago.payment.create(", "mercadopago.payment.save("]
+  },
+  "status_map": {
+    "approved": "processed",
+    "rejected": "failed",
+    "cancelled": "canceled",
+    "pending": "action_required",
+    "in_process": "processing",
+    "authorized": "action_required",
+    "in_mediation": "charged_back",
+    "refunded": "refunded",
+    "charged_back": "charged_back"
+  },
+  "status_detail_map": {
+    "cc_rejected_bad_filled_card_number": "bad_filled_card_data",
+    "cc_rejected_bad_filled_date": "bad_filled_card_data",
+    "cc_rejected_bad_filled_security_code": "bad_filled_card_data",
+    "cc_rejected_call_for_authorize": "required_call_for_authorize",
+    "cc_rejected_card_disabled": "card_disabled",
+    "cc_rejected_duplicated_payment": "processing_error",
+    "cc_rejected_high_risk": "high_risk",
+    "cc_rejected_insufficient_amount": "insufficient_amount",
+    "cc_rejected_invalid_installments": "invalid_installments",
+    "cc_rejected_max_attempts": "max_attempts_exceeded",
+    "cc_rejected_other_reason": "rejected_by_issuer",
+    "pending_waiting_transfer": "waiting_transfer"
+  },
+  "codemod": "mercadopago-payments-to-orders",
+  "review_checklist_es": [
+    "Configurar el webhook con el tópico `orders` en Tus integraciones y mantener `payment` en paralelo durante la transición.",
+    "Enviar `X-Idempotency-Key` en todas las escrituras (crear, capturar, cancelar, reembolsar).",
+    "Manejar `status` y `status_detail` a nivel orden y a nivel transacción.",
+    "Persistir también `transactions.payments[].id` (los reembolsos parciales lo necesitan).",
+    "En sandbox, el email del pagador tiene que ser test@testuser.com.",
+    "Si usás captura manual: la ventana de captura es de 5 días y Orders solo soporta captura total.",
+    "Pagos creados con Payments API se siguen consultando y reembolsando por Payments API."
+  ]
+}