parche-cli 0.7.5 → 0.7.6

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 Los cambios de cada versión de `parche-cli` y de la Action `Pepo08/parche@v0`. En npm están la 0.1.1, la 0.5.1, de la 0.6.0 a la 0.7.0, la 0.7.2, la 0.7.3 y de la 0.7.5 en adelante. La 0.1.0 y de la 0.2.0 a la 0.5.0 no se publicaron en npm; lo que traían está incluido en la 0.5.1. La 0.7.1 y la 0.7.4 tampoco: salieron junto con la 0.7.2 y la 0.7.5. La fecha de cada versión es la del cambio; la de publicación figura en npm y en los [Releases](https://github.com/Pepo08/parche/releases).
 
+## 0.7.6 — 2026-10-25
+
+Tres cosas que frenaban las corridas semanales y las primeras instalaciones. Las dos primeras las encontró el chat de página armando el diseño del resumen semanal, y se confirmaron leyendo el código.
+
+### Arreglos
+- **Un PR de Parche que ya está abierto.** Hasta la 0.7.5, la corrida siguiente pusheaba la rama `parche/<pack>` con `--force` (y pisaba los commits que alguien le hubiera sumado al PR) y pedía otro PR, que GitHub rechaza: la corrida fallaba y los packs que venían después no corrían. Ahora `pr` busca el PR abierto de esa rama. Si el arreglo es el mismo, no lo toca. Si cambió y el PR tiene solo el commit de Parche, actualiza la rama y el PR, sin abrir otro. Si la rama tiene commits de otra persona (con PR abierto o sin él), no la pisa y lo dice. La regla: Parche nunca hace force push sobre un commit que no escribió.
+- **Un pack que falla no corta la corrida.** Si la verificación de un pack falla, o GitHub responde con un error, los packs que siguen corren igual. El resumen del job suma una sección "No se pudo", el registro anota un evento `error` y `pr` termina con error al final.
+- **El `fingerprint` ya no se hereda entre líneas con el mismo texto.** El orden se contaba entre los avisos: cuando se arreglaba uno, el siguiente con el mismo texto de línea se quedaba con su `fingerprint`. En `tienda-demo`, después del arreglo de ARCA, la factura A, que sigue con "falta un dato", salía con el `fingerprint` de otra y, comparando corridas, como resuelta. Ahora el orden se cuenta entre todas las líneas del archivo con ese texto, tengan aviso o no, y dos avisos del mismo pack en una misma línea se distinguen por su orden en esa línea. Con un solo aviso por línea, el `fingerprint` es el mismo que en la 0.7.3, así que los de siempre no cambian.
+- **GitHub no deja que Actions abra PRs.** En los repos personales y las organizaciones nuevas viene apagado "Allow GitHub Actions to create and approve pull requests", y GitHub responde 403 con un mensaje en inglés. Ahora Parche lo explica en castellano: dónde se prende el ajuste (en el repo, o en la organización) o que se use un token de una GitHub App o uno personal. El README y la plantilla del workflow lo dicen.
+
 ## 0.7.5 — 2026-10-24
 
 Mercado Pago: dos cosas del SDK oficial que el pack no tenía en cuenta, verificadas en su código (github.com/mercadopago/sdk-nodejs, 24/10/2026).

package/README.md

@@ -114,7 +114,9 @@ Para que corra todas las semanas, copiá [`templates/github-workflow.yml`](templ
     # dry-run: 'true'                          # opcional: armar las ramas sin abrir PRs
 ```
 
-El workflow necesita `permissions: contents: write` y `pull-requests: write`. Antes de Parche, la plantilla instala las dependencias de tu proyecto para que corran sus tests: `npm ci` si hay `package-lock.json` y `composer install` si hay `composer.json` (Composer viene en los runners de Ubuntu de GitHub). Así anda igual en un repo de Node y en uno de PHP.
+El workflow necesita `permissions: contents: write` y `pull-requests: write`. Además, en el repo (o en la organización, si el repo es de una) tiene que estar prendido **Settings → Actions → General → Workflow permissions → "Allow GitHub Actions to create and approve pull requests"**: viene apagado en los repos personales y las organizaciones nuevas, y sin eso GitHub no deja que la Action abra el PR (Parche te lo dice en la corrida). Con un token de una GitHub App o uno personal (abajo), no hace falta. Antes de Parche, la plantilla instala las dependencias de tu proyecto para que corran sus tests: `npm ci` si hay `package-lock.json` y `composer install` si hay `composer.json` (Composer viene en los runners de Ubuntu de GitHub). Así anda igual en un repo de Node y en uno de PHP.
+
+**Si ya hay un PR de Parche abierto**, la corrida siguiente no abre otro: si el arreglo es el mismo, no lo toca; si cambió (por ejemplo, salió una versión nueva del pack) y el PR tiene solo el commit de Parche, lo actualiza. Si alguien le sumó un commit, Parche no lo pisa: lo deja como está y lo dice en el resumen del job. Si un pack falla (por ejemplo, porque no pasan tus tests), los que siguen corren igual y la corrida termina con error al final.
 
 Lo que no abre un PR también se ve en la corrida: los avisos de solo detección (modelos de IA que se retiran, por ejemplo) y lo que quedó sin PR porque falta un dato de tu negocio aparecen en el **resumen del job** y como **anotaciones** con el archivo y la línea (GitHub muestra las primeras 10; el resumen las tiene todas).
 
@@ -173,7 +175,7 @@ Parche corre en tu máquina o en tu runner. Tu código no sale de ahí, salvo el
 
 | | |
 |---|---|
-| **Red** | `scan`, `fix` y `packs` no usan la red. `pr` llama a `api.github.com` para abrir el PR en tu repo y pushea su rama `parche/<pack>` (con `--force`, así solo reemplaza su propio PR anterior). `diff` y `scan --upgrades` bajan metadatos y paquetes de `registry.npmjs.org`, que ve qué paquetes y versiones consultás. Nada más. |
+| **Red** | `scan`, `fix` y `packs` no usan la red. `pr` llama a `api.github.com` para buscar, abrir o actualizar el PR en tu repo y pushea su rama `parche/<pack>`. La pisa con `--force` solo si todos sus commits son de Parche: si alguien le sumó uno, no la toca y lo dice en la corrida. `diff` y `scan --upgrades` bajan metadatos y paquetes de `registry.npmjs.org`, que ve qué paquetes y versiones consultás. Nada más. |
 | **Telemetría** | Ninguna. `parche feedback` escribe en `.parche/ledger.jsonl` de tu repo y queda ahí. |
 | **Qué ejecuta** | `git` y, solo con `--verify`, los tests de tu repo (`npm test`, `composer test` o `vendor/bin/phpunit`). |
 | **Qué escribe** | Tu working copy (solo `fix` y `pr`), `.parche/` (se agrega a `.git/info/exclude`) y, para `diff` y `--upgrades`, un caché en `~/.parche/cache`. En GitHub Actions, además, la foto de la corrida como artifact de tu workflow (inventario y avisos en JSON, sin código; se apaga con `snapshot: 'false'`). |

package/bin/parche.js

@@ -7,7 +7,8 @@ import { loadPacks } from '../src/packs.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';
+import { parseGithubRemote, githubClient } from '../src/github.js';
+import { publishPr } from '../src/publish.js';
 import { record } from '../src/ledger.js';
 import { apiLabel, noUsesLabel } from '../src/inventory/index.js';
 import { isTestFile } from '../src/paths.js';
@@ -50,6 +51,15 @@ function summary(findings) {
     .filter((k) => c[k]).map((k) => `${LABEL[k]}: ${c[k]}`).join('   ');
 }
 
+// Qué pasó con el PR de cada pack (src/publish.js), en la salida de `pr`.
+const PUBLISHED = {
+  opened: ({ draft, url }) => `PR abierto${draft ? ' (borrador)' : ''}: ${url}`,
+  updated: ({ url }) => `Ya había un PR abierto con solo el commit de Parche; se actualizó con el arreglo de hoy: ${url}`,
+  unchanged: ({ url }) => `Ya hay un PR abierto con este mismo arreglo; no se tocó: ${url}`,
+  kept: ({ branch, url }) => `La rama ${branch} tiene commits de otra persona${url ? ` (${url})` : ''}: Parche no la pisa. `
+    + `Si querés que la rehaga, cerrá el PR y borrá la rama.`,
+};
+
 function ensureLocalDir(root) {
   fs.mkdirSync(path.join(root, '.parche'), { recursive: true });
   const exclude = path.join(root, '.git', 'info', 'exclude');
@@ -234,6 +244,10 @@ async function main() {
     // Para el resumen del job en GitHub Actions: los PRs de esta corrida y lo que quedó sin PR.
     const opened = [];
     const withoutPr = [];
+    // Un pack que falla (la verificación, la API de GitHub) no corta la corrida: los que siguen corren igual, el resumen
+    // del job lo muestra y `pr` termina con error al final (P9, 0.7.6).
+    const failed = [];
+    const client = process.env.GITHUB_TOKEN ? githubClient(process.env.GITHUB_TOKEN) : null;
     for (const pack of packs) {
       const preview = run(root, { write: false, packIds: [pack.id] });
       if (!preview.findings.length) continue;
@@ -278,18 +292,20 @@ async function main() {
         console.log(`  Cuerpo del PR: ${bodyPath}`);
         const target = parseGithubRemote(git.originUrl(root));
         const pushTo = parseGithubRemote(git.remoteUrl(root, pushRemote));
-        let url = null;
-        if (!args['dry-run'] && process.env.GITHUB_TOKEN && target && pushTo) {
-          git.push(root, branch, pushRemote);
-          const head = pushTo.owner !== target.owner ? `${pushTo.owner}:${branch}` : branch;
-          url = await openPullRequest({ token: process.env.GITHUB_TOKEN, ...target, head, base, title, body: fs.readFileSync(bodyPath, 'utf8'), draft });
-          console.log(`  PR abierto${draft ? ' (borrador)' : ''}: ${url}`);
+        let pr = { status: null, url: null };
+        if (!args['dry-run'] && client && target && pushTo) {
+          pr = await publishPr({ root, client, target, pushTo, pushRemote, branch, base, pack, title, body: fs.readFileSync(bodyPath, 'utf8'), draft });
+          console.log(`  ${PUBLISHED[pr.status]({ draft, branch, url: pr.url })}`);
         } else {
           console.log(`  Modo prueba: no se abrió el PR${draft ? ' (iría como borrador por tener ítems para revisar)' : ''}.`);
         }
-        opened.push({ title, url, draft });
-        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 });
+        opened.push({ title, url: pr.url, draft, status: pr.status });
+        record(root, { type: 'pr', pack: pack.id, packVersion: pack.version, branch, sha, url: pr.url, draft, files: changedFiles, findings: c,
+          partial: result.findings.filter((f) => f.partial).length, ...(pr.status && pr.status !== 'opened' ? { existing: pr.status } : {}) });
+      } catch (err) {
+        console.error(`  No se pudo con ${pack.id}: ${err.message.split('\n')[0]}`);
+        failed.push({ pack, message: err.message });
+        record(root, { type: 'error', pack: pack.id, message: err.message.split('\n')[0] });
       } 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);
@@ -306,9 +322,10 @@ async function main() {
       printFindings(detected);
     }
     if (process.env.GITHUB_ACTIONS === 'true') {
-      if (process.env.GITHUB_STEP_SUMMARY) fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, stepSummary({ opened, reportOnly: withoutPr, notices }));
+      if (process.env.GITHUB_STEP_SUMMARY) fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, stepSummary({ opened, reportOnly: withoutPr, notices, failed }));
       for (const line of annotations([...notices, ...withoutPr], workspacePrefix(root, process.env.GITHUB_WORKSPACE))) console.log(line);
     }
+    if (failed.length) throw new Error(failed.map((f) => (failed.length > 1 ? `${f.pack.id}: ${f.message}` : f.message)).join('\n'));
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parche-cli",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Dependabot para APIs: detecta cambios de cualquier API de terceros en tu código (ARCA, Mercado Pago, OpenAI, Anthropic) y abre el PR con el arreglo.",
   "keywords": [
     "api",

package/src/actions.js

@@ -41,18 +41,32 @@ export function annotations(groups, prefix = '') {
   return out;
 }
 
-// El resumen del job: los PRs de esta corrida, lo que quedó sin PR y los avisos de solo detección.
-// opened: [{ title, url, draft }] (url null en modo prueba); reportOnly y notices: grupos { pack, findings }.
-export function stepSummary({ opened = [], reportOnly = [], notices = [] }) {
+// Qué pasó con un PR que ya existía (src/publish.js, P9).
+const EXISTING = {
+  updated: 'ya estaba abierto: se actualizó con el arreglo de hoy',
+  unchanged: 'ya estaba abierto con este mismo arreglo: no se tocó',
+  kept: 'la rama tiene commits de otra persona: Parche no la pisa (si querés que la rehaga, cerrá el PR y borrá la rama)',
+};
+
+// El resumen del job: los PRs de esta corrida, lo que quedó sin PR, los avisos de solo detección y los packs que fallaron.
+// opened: [{ title, url, draft, status }] (url null en modo prueba; status, el de publishPr); reportOnly y notices:
+// grupos { pack, findings }; failed: [{ pack, message }].
+export function stepSummary({ opened = [], reportOnly = [], notices = [], failed = [] }) {
   const lines = ['## Parche', ''];
   if (opened.length) {
     lines.push('### PRs', '');
     for (const o of opened) {
-      const draft = o.draft ? ' · borrador' : '';
-      lines.push(o.url ? `- [${o.title}](${o.url})${draft}` : `- ${o.title}${draft} · modo prueba: no se abrió`);
+      const note = EXISTING[o.status] ? ` · ${EXISTING[o.status]}` : o.draft ? ' · borrador' : '';
+      if (o.url) lines.push(`- [${o.title}](${o.url})${note}`);
+      else lines.push(`- ${o.title}${note}${o.status ? '' : ' · modo prueba: no se abrió'}`);
     }
     lines.push('');
   }
+  if (failed.length) {
+    lines.push('### No se pudo', '');
+    for (const f of failed) lines.push(`- **${f.pack.title}** · ${f.message.split('\n')[0]}`);
+    lines.push('');
+  }
   const section = (title, intro, groups) => {
     if (!groups.length) return;
     lines.push(`### ${title}`, '', intro, '');
@@ -64,7 +78,7 @@ export function stepSummary({ opened = [], reportOnly = [], notices = [] }) {
   };
   section('Sin PR', 'Parche no abre un PR cuando el arreglo depende de un dato de tu negocio o cuando no hay código para cambiar. Esto es lo que encontró y lo que falta.', reportOnly);
   section('Avisos', 'Cambios con fecha que afectan a tu código. Parche no los cambia solo: cambiar de modelo, por ejemplo, cambia cómo responde tu producto.', notices);
-  if (!opened.length && !reportOnly.length && !notices.length) {
+  if (!opened.length && !reportOnly.length && !notices.length && !failed.length) {
     lines.push('Ninguno de los packs verificados tiene cambios que te afecten hoy.', '');
   }
   lines.push('El inventario completo de las APIs del repo: `npx parche-cli scan .`');

package/src/engine.js

@@ -37,13 +37,31 @@ export function listFiles(dir, skipped = []) {
 // Identificador estable de un aviso (P5 de docs/app-vigilancia.md): el pack, el archivo y el texto de la línea, sin el
 // número de línea ni el mensaje. Así una corrida reconoce el mismo aviso de la anterior aunque se muevan las líneas o
 // cambie el texto del pack, y "nuevo", "sigue" y "resuelto" no dependen de la posición. Los espacios y el \r no cuentan
-// (una reindentación o pasar a CRLF no es otro aviso). Si el mismo texto se repite en el archivo, cuenta el orden.
+// (una reindentación o pasar a CRLF no es otro aviso).
+// Si el mismo texto se repite en el archivo, cuenta el orden entre las líneas del archivo con ese texto, tengan aviso o
+// no (P10, 0.7.6). Antes contaba entre los avisos: al arreglarse uno, el siguiente con el mismo texto heredaba su
+// fingerprint, y en tienda-demo la factura A, que sigue con "falta un dato", salía como "resuelta". Dos avisos del mismo
+// pack en la misma línea se distinguen por su orden en esa línea; un aviso sin línea, por su orden en el archivo.
+const normalized = (line) => line.replace(/\s+/g, ' ').trim();
+
 export function fingerprint(finding, source, seen) {
-  const text = finding.line ? (source.split('\n')[finding.line - 1] ?? '').replace(/\s+/g, ' ').trim() : '';
+  const lines = finding.line ? source.split('\n') : [];
+  const text = finding.line ? normalized(lines[finding.line - 1] ?? '') : '';
   const key = [finding.pack, finding.file, text].join('\u0000');
-  const n = (seen.get(key) || 0) + 1;
-  seen.set(key, n);
-  return crypto.createHash('sha256').update(`${key}\u0000${n}`).digest('hex').slice(0, 16);
+  let n;
+  if (finding.line) {
+    n = 0;
+    for (let i = 0; i < finding.line && i < lines.length; i++) if (normalized(lines[i]) === text) n++;
+    n = Math.max(n, 1);
+  }
+  // Cuántos avisos de este pack ya salieron en esta línea (o sin línea, en este archivo).
+  const slot = `${finding.pack}\u0000${finding.file}\u0000${finding.line || ''}`;
+  const k = (seen.get(slot) || 0) + 1;
+  seen.set(slot, k);
+  if (!finding.line) n = k;
+  // Con un solo aviso en la línea, la clave es la misma que en la 0.7.3: no cambian los fingerprint de siempre.
+  const suffix = finding.line && k > 1 ? `\u0000${k}` : '';
+  return crypto.createHash('sha256').update(`${key}\u0000${n}${suffix}`).digest('hex').slice(0, 16);
 }
 
 export function run(dir, { write = false, packIds = null, today } = {}) {
@@ -60,7 +78,7 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
   const usages = [];
   const fileScans = []; // inventario de cualquier API (nivel 1), por archivo
   const changed = new Map(); // archivo relativo → [packs]
-  const seen = new Map(); // para fingerprint(): cuántas veces apareció cada pack + archivo + texto
+  const seen = new Map(); // para fingerprint(): cuántos avisos de cada pack salieron en cada línea
 
   files.forEach((abs, i) => {
     const rel = rels[i];

package/src/git.js

@@ -98,10 +98,37 @@ export function remoteUrl(cwd, remote = 'origin') {
 
 export const originUrl = (cwd) => remoteUrl(cwd, 'origin');
 
+// Con `--force`: reemplaza el commit anterior de Parche en su rama. Quien llama se fija antes que la rama remota no
+// tenga commits de otra persona (src/publish.js, P9).
 export function push(cwd, branch, remote = 'origin') {
   git(cwd, 'push', '-u', '--force', remote, branch);
 }
 
+// El commit de la rama `branch` en `remote`, o null si no existe. No toca las ramas locales.
+export function fetchBranch(cwd, remote, branch) {
+  try {
+    git(cwd, 'fetch', '-q', '--no-tags', remote, `refs/heads/${branch}`);
+    return git(cwd, 'rev-parse', 'FETCH_HEAD');
+  } catch {
+    return null;
+  }
+}
+
+// Los commits de `to` que no están en `from`, con su mensaje completo.
+export function commitsBetween(cwd, from, to) {
+  return git(cwd, 'log', '--format=%H%x00%B%x1e', `${from}..${to}`)
+    .split('\x1e').map((s) => s.trim()).filter(Boolean)
+    .map((s) => { const [sha, ...rest] = s.split('\0'); return { sha, message: rest.join('\0').trim() }; });
+}
+
+// Un identificador del cambio que hace `to` desde donde se separó de `from`, sin contar números de línea ni espacios
+// (`git patch-id`). Dos ramas con el mismo arreglo sobre bases distintas dan el mismo; sin cambios, ''.
+export function patchId(cwd, from, to) {
+  const diff = execFileSync('git', gitArgs(['diff', `${from}...${to}`]), { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (!diff.trim()) return '';
+  return execFileSync('git', gitArgs(['patch-id', '--stable']), { cwd, input: diff, encoding: 'utf8' }).trim().split(/\s+/)[0] || '';
+}
+
 // Descarta lo que Parche escribió en su rama (el árbol estaba limpio antes de empezar). Antes era `reset --hard`, que
 // con un `.parche/` commiteado también borraba el registro de esta corrida; los codemods solo modifican archivos que
 // ya existen, así que alcanza con volver todo, menos `.parche/`, a lo que hay en HEAD.

package/src/github.js

@@ -1,22 +1,51 @@
-// Apertura del PR por la API REST de GitHub (sin dependencias).
+// La API REST de GitHub para los PRs de Parche (sin dependencias).
 export function parseGithubRemote(url) {
   if (!url) return null;
   const m = url.match(/github\.com[:/]([^/]+)\/([^/.]+?)(\.git)?$/);
   return m ? { owner: m[1], repo: m[2] } : null;
 }
 
-export async function openPullRequest({ token, owner, repo, head, base, title, body, draft }) {
-  const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/vnd.github+json',
-      'X-GitHub-Api-Version': '2022-11-28',
-      'Content-Type': 'application/json',
+// GitHub responde 403 con este mensaje cuando el repo (o su organización) tiene apagado "Allow GitHub Actions to create
+// and approve pull requests". Viene apagado en los repos personales y las organizaciones nuevas (docs de GitHub,
+// verificado el 25/10/2026): la primera corrida fallaba con el error en inglés y sin decir dónde se arregla (P8, 0.7.6).
+const ACTIONS_CANNOT_OPEN_PRS = /not permitted to create or approve pull requests/i;
+
+export const ACTIONS_CANNOT_OPEN_PRS_MESSAGE = 'GitHub no deja que GitHub Actions abra PRs en este repo. Prendelo en '
+  + 'Settings → Actions → General → Workflow permissions → "Allow GitHub Actions to create and approve pull requests" '
+  + '(si el repo es de una organización, el ajuste está en la configuración de la organización). O pasale a la Action '
+  + 'un token de una GitHub App o uno personal, con el input `token`. La rama del arreglo ya quedó pusheada: con el '
+  + 'ajuste prendido, la próxima corrida abre el PR.';
+
+export function apiError(status, data) {
+  const message = data?.message || JSON.stringify(data);
+  if (status === 403 && ACTIONS_CANNOT_OPEN_PRS.test(message)) return new Error(ACTIONS_CANNOT_OPEN_PRS_MESSAGE);
+  return new Error(`GitHub respondió ${status}: ${message}`);
+}
+
+// Un cliente con el token de quien corre Parche. `request` es `fetch` (los tests le pasan uno propio, sin red).
+export function githubClient(token, request = fetch) {
+  const call = async (method, route, body) => {
+    const res = await request(`https://api.github.com${route}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw apiError(res.status, data);
+    return data;
+  };
+  return {
+    // El PR abierto cuya rama es `head` ("dueño:rama"), o null.
+    async findOpenPull({ owner, repo, head }) {
+      const list = await call('GET', `/repos/${owner}/${repo}/pulls?state=open&head=${encodeURIComponent(head)}&per_page=1`);
+      return Array.isArray(list) && list.length ? list[0] : null;
     },
-    body: JSON.stringify({ title, head, base, body, draft }),
-  });
-  const data = await res.json();
-  if (!res.ok) throw new Error(`GitHub respondió ${res.status}: ${data.message || JSON.stringify(data)}`);
-  return data.html_url;
+    openPull: ({ owner, repo, head, base, title, body, draft }) => call('POST', `/repos/${owner}/${repo}/pulls`, { title, head, base, body, draft }),
+    updatePull: ({ owner, repo, number, title, body }) => call('PATCH', `/repos/${owner}/${repo}/pulls/${number}`, { title, body }),
+  };
 }

package/src/publish.js

@@ -0,0 +1,31 @@
+// Publica el PR de un pack: lo abre o, si ya hay uno abierto para su rama, lo actualiza sin pisar el trabajo de otros
+// (P9, 0.7.6). Hasta la 0.7.5, `parche pr` pusheaba la rama con --force y pedía otro PR: si alguien le había sumado un
+// commit al PR, se perdía; y GitHub rechazaba el PR repetido, así que con un PR abierto cada corrida semanal fallaba y
+// los packs que venían después no corrían (lo encontró el chat de página el 25/10, F2).
+import * as git from './git.js';
+
+// El commit que escribe Parche: título "Parche: …" y la línea "Pack <id> v<versión>." (bin/parche.js, `commitAll`).
+export const isParcheCommit = (message, pack) => /^Parche: /.test(message) && message.includes(`\nPack ${pack.id} v`);
+
+// status: 'opened' (PR nuevo), 'updated' (el PR abierto tenía solo el commit de Parche y el arreglo cambió),
+// 'unchanged' (mismo arreglo: no se pushea ni se toca) o 'kept' (la rama remota tiene commits de otra persona, con PR
+// abierto o sin él: no se toca). La regla: Parche nunca hace force push sobre un commit que no escribió.
+export async function publishPr({ root, client, target, pushTo, pushRemote, branch, base, pack, title, body, draft }) {
+  const head = pushTo.owner !== target.owner ? `${pushTo.owner}:${branch}` : branch;
+  const existing = await client.findOpenPull({ ...target, head: `${pushTo.owner}:${branch}` });
+  const found = existing ? { url: existing.html_url, number: existing.number } : { url: null, number: null };
+  const remote = git.fetchBranch(root, pushRemote, branch);
+  if (remote) {
+    // Un commit que no es de Parche (de una persona, o el "Update branch" de GitHub) hace que la rama sea de alguien más.
+    const others = git.commitsBetween(root, base, remote).filter((c) => !isParcheCommit(c.message, pack));
+    if (others.length) return { status: 'kept', ...found, others: others.length };
+    if (existing && git.patchId(root, base, remote) === git.patchId(root, base, branch)) return { status: 'unchanged', ...found };
+  }
+  git.push(root, branch, pushRemote);
+  if (!existing) {
+    const pr = await client.openPull({ ...target, head, base, title, body, draft });
+    return { status: 'opened', url: pr.html_url, number: pr.number };
+  }
+  await client.updatePull({ ...target, number: existing.number, title, body });
+  return { status: 'updated', ...found };
+}

package/templates/github-workflow.yml

@@ -9,6 +9,8 @@ on:
   workflow_dispatch:
 
 # Por defecto, solo lectura. La escritura la pide el único job que la necesita.
+# En un repo o una organización nuevos, prendé además Settings → Actions → General → Workflow permissions →
+# "Allow GitHub Actions to create and approve pull requests": viene apagado, y sin eso la Action no puede abrir el PR.
 permissions:
   contents: read