@legios/quartermaster 0.1.11 → 0.1.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,433 @@
1
+ """Las cinco frases de presupuesto tienen que decir los mismos números.
2
+
3
+ 0.1.11 arregló en cinco lugares a la vez el mismo error: `porDia` sale del
4
+ porcentaje de AHORA, que ya tiene adentro lo gastado hoy, y las cinco pantallas
5
+ le restaban lo gastado otra vez. El núcleo pasó a mandar la resta hecha
6
+ (`porDiaHoy` y `restanteMedido`) y las cinco pasaron a leerla.
7
+
8
+ Lo que quedó sin comprobar es que sigan leyéndola. Medido el 2026-09-14, con el
9
+ árbol en `c910137`: se volvió a poner en `bin/qm-indicator` exactamente el doble
10
+ descuento que 0.1.11 había sacado —`porDia` en vez de `porDiaHoy`, la resta a
11
+ mano en vez de `restanteMedido`— y `make gate-dibujo`, `gate-tarjetas` y los 148
12
+ tests quedaron en verde. La regresión que costó una release entera volvía a
13
+ entrar sin que nada se pusiera rojo, porque `test/fixtures/panel.json` no traía
14
+ los campos nuevos: los tres gates que dibujan entraban siempre por la rama de
15
+ respaldo, la del `qm` anterior.
16
+
17
+ Es la misma historia que `gate-duraciones`: una regla escrita en cinco
18
+ comentarios y en ningún lado comprobada. Ahí convivieron dos convenciones
19
+ durante meses; acá el número que se compara es el que dice cuánto podés gastar.
20
+ Y en la primera corrida de verdad este gate encontró que la bandeja de Windows
21
+ contestaba «te queda 0.0 %» donde las otras cuatro decían 0.3.
22
+
23
+ El canon está congelado en test/fixtures/presupuesto.json, sacado corriendo el
24
+ núcleo. Cada implementación se EJECUTA con el mismo JSON y se compara contra esa
25
+ tabla. Las que no tienen intérprete en esta máquina se saltean diciéndolo —
26
+ nunca se dan por buenas en silencio—, y `QM_GATE_EXIGE` convierte el salteo en
27
+ rojo en los jobs cuyo runner sí los trae.
28
+
29
+ Dos cosas que no se comparan letra por letra, y se dicen en la salida en vez de
30
+ esconderlas:
31
+
32
+ - **el separador decimal.** El tablero escribe «16,1» y las otras cuatro
33
+ «16.1». Los números se comparan como números; que el tablero use coma es una
34
+ diferencia de dibujo que hay que decidir, no un rojo que este gate invente.
35
+ - **el respaldo de un `qm` anterior en la barra de macOS.** En las otras
36
+ pantallas el `?? porDia` está adentro de la función que escribe; en Swift
37
+ está en el parseo del JSON, una función más arriba. Ese caso se saltea ahí,
38
+ diciéndolo.
39
+
40
+ La hora de `medidoDesde` la escribe cada pantalla con el reloj de la máquina, así
41
+ que no se compara contra un string congelado: se exige que las pantallas digan
42
+ LA MISMA, que es la invariante que importa. El tablero llegó a decir «11:54 a.
43
+ m.» mientras las otras cuatro decían «11:54».
44
+ """
45
+
46
+ import importlib.machinery
47
+ import importlib.util
48
+ import json
49
+ import os
50
+ import pathlib
51
+ import re
52
+ import shutil
53
+ import subprocess
54
+ import sys
55
+ import tempfile
56
+ from datetime import datetime
57
+
58
+ # La salida va en UTF-8 aunque la consola no lo sea. En el runner de Windows la
59
+ # codepage es cp1252 y el `✓` la rompe con un UnicodeEncodeError: el gate se
60
+ # moría al IMPRIMIR el verde, después de haber comparado bien. Un gate que
61
+ # revienta contando lo que le salió bien es indistinguible de uno que falló.
62
+ for _salida in (sys.stdout, sys.stderr):
63
+ try:
64
+ _salida.reconfigure(encoding="utf-8", errors="replace")
65
+ except (AttributeError, ValueError): # una salida que no es un archivo de texto
66
+ pass
67
+
68
+ RAIZ = pathlib.Path(__file__).resolve().parent.parent
69
+ TABLA = json.loads((RAIZ / "test/fixtures/presupuesto.json").read_text(encoding="utf-8"))
70
+ CASOS = TABLA["casos"]
71
+
72
+ # Lo que devuelve una pantalla para un caso que no le toca contestar.
73
+ SALTEADO = "—"
74
+
75
+
76
+ def bloque(ruta: pathlib.Path, arranque: str, abre: str = "{", cierra: str = "}") -> str:
77
+ """El cuerpo de una función, contando llaves desde su primera línea."""
78
+ texto = ruta.read_text(encoding="utf-8")
79
+ i = texto.index(arranque)
80
+ nivel, j = 0, i
81
+ while True:
82
+ if texto[j] == abre:
83
+ nivel += 1
84
+ elif texto[j] == cierra:
85
+ nivel -= 1
86
+ if nivel == 0:
87
+ return texto[i:j + 1]
88
+ j += 1
89
+
90
+
91
+ # ── cómo se compara ──────────────────────────────────────────────────────
92
+ #
93
+ # El núcleo escribe UN renglón; los que dibujan escriben DOS, y le pegan al
94
+ # primero el nombre de la ventana («· weekly_all») porque la tarjeta muestra
95
+ # tres barras y el número reparte una sola. Ninguna de las dos cosas es una
96
+ # diferencia de lo que se DICE: se normalizan y se compara la frase.
97
+ HORA = re.compile(r"\d{2}:\d{2}")
98
+
99
+
100
+ def frase(renglones, barra) -> str:
101
+ texto = " · ".join(r for r in renglones if r)
102
+ if barra:
103
+ texto = texto.replace(f" · {barra}", "")
104
+ return " ".join(texto.split())
105
+
106
+
107
+ def numeros(texto: str) -> list[float]:
108
+ """Los números de la frase, en orden, con coma o con punto."""
109
+ return [float(n.replace(",", ".")) for n in re.findall(r"\d+[.,]\d", HORA.sub("", texto))]
110
+
111
+
112
+ def rama(texto: str) -> str:
113
+ if "de acá a medianoche" in texto:
114
+ return "reparto"
115
+ if "desde las" in texto:
116
+ return "medido"
117
+ if "hoy" in texto:
118
+ return "hoy"
119
+ return "?"
120
+
121
+
122
+ def sin_campos_nuevos(entrada: dict) -> bool:
123
+ """El JSON de un `qm` anterior a 0.1.11."""
124
+ return entrada.get("porDiaHoy") is None and entrada.get("restanteMedido") is None
125
+
126
+
127
+ # ── las implementaciones ─────────────────────────────────────────────────
128
+ #
129
+ # Todas leen la salida del hijo con encoding="utf-8" explícito. Sin eso Python
130
+ # la decodifica con la codepage de la máquina, que en Windows no es UTF-8: las
131
+ # cinco frases volvían con `é` y `·` rotos y el gate comparaba mojibake contra
132
+ # el canon. Medido en el CI el 2026-09-14, no supuesto.
133
+ def por_typescript() -> list[str]:
134
+ """El núcleo. `frasePresupuesto` come el Presupuesto de adentro, no el JSON,
135
+ así que se le arma uno con los campos que la frase usa. Un caso sin
136
+ `porDiaHoy` es un JSON que el núcleo NUNCA emite —es el de un qm anterior—,
137
+ y ahí no se lo llama: contestar por él sería inventar."""
138
+ entradas = []
139
+ for c in CASOS:
140
+ e = c["entrada"]
141
+ entradas.append(None if sin_campos_nuevos(e) else {
142
+ "estado": e["estado"], "motivo": e.get("motivo"),
143
+ "porDiaHoy": e["porDiaHoy"], "quedaHoy": e["quedaHoy"],
144
+ "gastadoHoy": e["gastadoHoy"], "restanteHoy": e["restanteHoy"],
145
+ "gastadoMedido": e["gastadoMedido"], "restanteMedido": e["restanteMedido"],
146
+ "medidoDesde": e["medidoDesde"],
147
+ })
148
+ guion = (
149
+ "import {frasePresupuesto} from './src/core/presupuesto.ts';"
150
+ f"const cs={json.dumps(entradas)};"
151
+ "console.log(JSON.stringify(cs.map(c=>c===null?null:frasePresupuesto("
152
+ "{...c, medidoDesde: c.medidoDesde===null?null:new Date(c.medidoDesde).getTime()}))));"
153
+ )
154
+ r = subprocess.run(["node", "--experimental-strip-types", "-e", guion],
155
+ cwd=RAIZ, capture_output=True, text=True, encoding="utf-8", timeout=60)
156
+ if r.returncode != 0:
157
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "node falló")
158
+ return [SALTEADO if s is None else s for s in json.loads(r.stdout)]
159
+
160
+
161
+ def por_python() -> list[str]:
162
+ """El indicador de GNOME."""
163
+ spec = importlib.util.spec_from_loader(
164
+ "qmi", importlib.machinery.SourceFileLoader("qmi", str(RAIZ / "bin/qm-indicator")))
165
+ m = importlib.util.module_from_spec(spec)
166
+ spec.loader.exec_module(m)
167
+ return [frase(m.renglones_presupuesto(c["entrada"]), c["entrada"].get("barra")) for c in CASOS]
168
+
169
+
170
+ def por_powershell() -> list[str]:
171
+ """La bandeja de Windows. Con StrictMode, como corre de verdad: leer una
172
+ propiedad que no está es una excepción, y es justo lo que pasa con el JSON
173
+ de un qm anterior."""
174
+ fn = bloque(RAIZ / "bin/qm-tray.ps1", "function RenglonesPresupuesto($pre) {")
175
+ with tempfile.TemporaryDirectory() as d:
176
+ guion, datos, dicho = (pathlib.Path(d) / n for n in ("p.ps1", "casos.json", "dicho.txt"))
177
+ datos.write_text(json.dumps([c["entrada"] for c in CASOS]), encoding="utf-8")
178
+ # Un renglón por caso, a un archivo en UTF-8. Ni JSON ni stdout, y las
179
+ # dos cosas medidas en el CI y no supuestas: el ConvertTo-Json del
180
+ # PowerShell 5.1 envuelve cada arreglo en {value, Count}, y la consola de
181
+ # Windows escribe en la codepage de la máquina, así que el `·` y los
182
+ # acentos volvían rotos.
183
+ guion.write_text(
184
+ "Set-StrictMode -Version Latest\n"
185
+ "$ErrorActionPreference = 'Stop'\n"
186
+ f"{fn}\n"
187
+ f"$casos = Get-Content -Raw -Encoding UTF8 '{datos}' | ConvertFrom-Json\n"
188
+ "$dicho = foreach ($c in $casos) { (RenglonesPresupuesto $c) -join ' · ' }\n"
189
+ f"[System.IO.File]::WriteAllLines('{dicho}', [string[]]$dicho, "
190
+ "(New-Object System.Text.UTF8Encoding $false))\n",
191
+ # Con BOM: el Windows PowerShell 5.1 lee un .ps1 sin BOM en la
192
+ # codepage de la máquina, no en UTF-8, así que el `·` y los acentos
193
+ # del guión —los de la frase, justamente— le llegaban rotos y la
194
+ # bandeja «decía» otra cosa que las demás. Medido en el CI el
195
+ # 2026-09-14. scripts/gate-bandeja.ps1 ya arranca con BOM por esto.
196
+ encoding="utf-8-sig")
197
+ orden = [EXE_PS, "-NoProfile"]
198
+ if sys.platform == "win32":
199
+ # Sólo existe en Windows: en el pwsh de Linux el proceso ni arranca.
200
+ orden += ["-ExecutionPolicy", "Bypass"]
201
+ r = subprocess.run(orden + ["-File", str(guion)],
202
+ capture_output=True, text=True, encoding="utf-8", timeout=120)
203
+ if r.returncode != 0:
204
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "powershell falló")
205
+ lineas = dicho.read_text(encoding="utf-8").splitlines()
206
+ if len(lineas) != len(CASOS):
207
+ raise RuntimeError(f"contestó {len(lineas)} renglones y esperaba {len(CASOS)}")
208
+ return [frase([l], c["entrada"].get("barra")) for l, c in zip(lineas, CASOS)]
209
+
210
+
211
+ def por_tablero() -> list[str]:
212
+ """El tablero web. Dibuja pares clave/valor en HTML, no una frase: de él se
213
+ comparan los números y la rama, que es lo que tiene que coincidir."""
214
+ fn = bloque(RAIZ / "src/render/tablero.html", "function presupuesto(pre) {")
215
+ guion = (
216
+ "const esc = (s) => String(s);\n"
217
+ "const unDecimal = (n) => Number(n).toFixed(1).replace('.', ',');\n"
218
+ f"{fn}\n"
219
+ f"const cs={json.dumps([c['entrada'] for c in CASOS])};\n"
220
+ "console.log(JSON.stringify(cs.map(c=>presupuesto(c))));"
221
+ )
222
+ with tempfile.TemporaryDirectory() as d:
223
+ p = pathlib.Path(d) / "t.mjs"
224
+ p.write_text(guion, encoding="utf-8")
225
+ r = subprocess.run(["node", str(p)], capture_output=True, text=True, encoding="utf-8", timeout=60)
226
+ if r.returncode != 0:
227
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "node falló")
228
+ salidas = []
229
+ for html in json.loads(r.stdout):
230
+ # El globo lleva el JSON adentro de un atributo, con sus propios números.
231
+ limpio = re.sub(r"<[^>]+>", " ", re.sub(r"data-tip='[^']*'", "", html))
232
+ salidas.append(" ".join(limpio.split()))
233
+ return salidas
234
+
235
+
236
+ def por_swift() -> list[str]:
237
+ """La barra de macOS. Su frase no está en una función sino adentro de un
238
+ `switch`, así que se le saca el cuerpo del `case` y se lo envuelve en una:
239
+ `self.presupuesto = …` pasa a ser la salida y los valores del patrón pasan a
240
+ ser parámetros. Es el mismo código con el `switch` de alrededor sacado.
241
+
242
+ El caso del `qm` anterior no entra: en la barra el `?? porDia` está en el
243
+ parseo del JSON, no acá."""
244
+ texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
245
+ i = texto.index("case .reparte(_, let porDiaHoy")
246
+ cuerpo = texto[texto.index(":", i) + 1:texto.index("case .no(let motivo)", i)]
247
+ cuerpo = cuerpo.replace("self.presupuesto", "salida")
248
+ entradas = []
249
+ for c in CASOS:
250
+ e = c["entrada"]
251
+ if sin_campos_nuevos(e):
252
+ entradas.append(None)
253
+ continue
254
+ entradas.append({
255
+ "porDiaHoy": e["porDiaHoy"], "quedaHoy": e["quedaHoy"],
256
+ "gastado": e["gastadoHoy"] if e["cubreElDia"] else e["gastadoMedido"],
257
+ "restante": e["restanteMedido"], "cubreElDia": e["cubreElDia"],
258
+ # El mismo instante que el ISO: la hora que dibuja tiene que ser la
259
+ # misma que dicen las otras pantallas.
260
+ "desde": None if e["medidoDesde"] is None else datetime.fromisoformat(
261
+ e["medidoDesde"].replace("Z", "+00:00")).timestamp(),
262
+ })
263
+ with tempfile.TemporaryDirectory() as d:
264
+ p, datos = pathlib.Path(d) / "b.swift", pathlib.Path(d) / "casos.json"
265
+ datos.write_text(json.dumps([e for e in entradas if e is not None]), encoding="utf-8")
266
+ p.write_text(
267
+ "import Foundation\n"
268
+ "func renglones(_ porDiaHoy: Double, _ quedaHoy: Double, _ gastado: Double?,\n"
269
+ " _ restante: Double?, _ desde: Date?, _ cubreElDia: Bool) -> [String] {\n"
270
+ " var salida: [String] = []\n"
271
+ f"{cuerpo}\n"
272
+ " return salida\n"
273
+ "}\n"
274
+ "struct Caso: Decodable { let porDiaHoy: Double; let quedaHoy: Double\n"
275
+ " let gastado: Double?; let restante: Double?; let desde: Double?\n"
276
+ " let cubreElDia: Bool }\n"
277
+ f'let d = try! Data(contentsOf: URL(fileURLWithPath: "{datos}"))\n'
278
+ "for c in try! JSONDecoder().decode([Caso].self, from: d) {\n"
279
+ " print(renglones(c.porDiaHoy, c.quedaHoy, c.gastado, c.restante,\n"
280
+ " c.desde.map { Date(timeIntervalSince1970: $0) }, c.cubreElDia)\n"
281
+ ' .joined(separator: " · "))\n'
282
+ "}\n", encoding="utf-8")
283
+ r = subprocess.run(["swift", str(p)], capture_output=True, text=True, encoding="utf-8", timeout=300)
284
+ if r.returncode != 0:
285
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "swift falló")
286
+ dichas = iter(r.stdout.strip().split("\n"))
287
+ return [SALTEADO if e is None else next(dichas) for e in entradas]
288
+
289
+
290
+ def redaccion_swift() -> list[str]:
291
+ """Sin swiftc no se puede ejecutar, pero la REDACCIÓN se lee igual: los
292
+ `String(format:)` de la rama `.reparte` tienen que ser los del canon."""
293
+ texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
294
+ i = texto.index("case .reparte(_, let porDiaHoy")
295
+ return re.findall(r'String\(format: "([^"]+)"', texto[i:texto.index("case .no(let motivo)", i)])
296
+
297
+
298
+ def canon_a_formato(esperado: str) -> list[str]:
299
+ """El canon partido en los dos pedazos que la barra escribe por separado, en
300
+ el dialecto de `String(format:)`."""
301
+ partes = esperado.split(" · ")
302
+ fmt = []
303
+ for p in (partes[0], " · ".join(partes[1:])):
304
+ # El orden importa: primero se escapan los `%` que son literales, y
305
+ # recién después se ponen los huecos, que traen `%` propios.
306
+ f = re.sub(r"\d+\.\d", "%.1f", p.replace("%", "%%"))
307
+ fmt.append(f.replace("{desde}", "%@"))
308
+ return fmt
309
+
310
+
311
+ # ── el gate ──────────────────────────────────────────────────────────────
312
+ # En Windows, `powershell` PRIMERO: la bandeja corre con el Windows PowerShell
313
+ # 5.1, que es lo que hay en una máquina sin instalar nada, y es el mismo motivo
314
+ # por el que gate-bandeja.ps1 no va con pwsh. Fuera de Windows el único que hay
315
+ # es pwsh.
316
+ EXE_PS = shutil.which("powershell") or shutil.which("pwsh") or ""
317
+
318
+ def hay(requisito: str | None) -> bool:
319
+ """Si en esta máquina se puede correr esa pantalla.
320
+
321
+ `cairo` no es un binario en el PATH: el indicador de GNOME importa gi y
322
+ cairo al cargarse, así que en el runner de Windows —donde la bandeja SÍ se
323
+ puede correr— importarlo revienta. Eso es una pantalla que no se puede
324
+ comprobar acá, no un gate roto."""
325
+ if requisito is None:
326
+ return True
327
+ if requisito == "cairo":
328
+ try:
329
+ import gi # noqa: F401
330
+ import cairo # noqa: F401
331
+ except Exception: # noqa: BLE001 — sin gi/cairo no hay indicador que correr
332
+ return False
333
+ return True
334
+ return shutil.which(requisito) is not None
335
+
336
+
337
+ IMPLEMENTACIONES = [
338
+ ("TypeScript · el núcleo", por_typescript, "node"),
339
+ ("Python · el indicador de GNOME", por_python, "cairo"),
340
+ ("Swift · la barra de macOS", por_swift, "swift"),
341
+ ("PowerShell · la bandeja", por_powershell, "powershell" if sys.platform == "win32" else "pwsh"),
342
+ ("JavaScript · el tablero", por_tablero, "node"),
343
+ ]
344
+
345
+
346
+ def main() -> int:
347
+ # QM_GATE_EXIGE lista los intérpretes que TIENEN que estar, igual que en
348
+ # gate-duraciones: en una laptop saltear swift y pwsh es lo razonable; en un
349
+ # runner que los trae, saltear en silencio convierte al gate en un adorno.
350
+ exigidos = {x for x in os.environ.get("QM_GATE_EXIGE", "").split(",") if x}
351
+ fallas: list[str] = []
352
+ salteadas: list[str] = []
353
+ corridas: dict[str, list[str]] = {}
354
+
355
+ for nombre, correr, binario in IMPLEMENTACIONES:
356
+ if not hay(binario):
357
+ if binario in exigidos:
358
+ fallas.append(f"falta {binario}, y este job lo exige "
359
+ f"(QM_GATE_EXIGE={','.join(sorted(exigidos))})")
360
+ continue
361
+ falta = "python3-gi y cairo" if binario == "cairo" else binario
362
+ salteadas.append(f"{nombre} (no hay {falta} en esta máquina)")
363
+ continue
364
+ try:
365
+ salida = correr()
366
+ except Exception as e: # noqa: BLE001 — un adaptador roto es un rojo, no un salteo
367
+ fallas.append(f"no pude correr {nombre}: {e}")
368
+ continue
369
+ if len(salida) != len(CASOS):
370
+ fallas.append(f"{nombre} devolvió {len(salida)} frases y esperaba {len(CASOS)}")
371
+ continue
372
+ corridas[nombre] = salida
373
+
374
+ if not corridas and not fallas:
375
+ fallas.append("no se pudo correr NINGUNA pantalla")
376
+
377
+ for i, caso in enumerate(CASOS):
378
+ esperado = caso["esperado"]
379
+ horas: dict[str, str] = {}
380
+ for nombre, salidas in corridas.items():
381
+ dicho = salidas[i]
382
+ if dicho == SALTEADO:
383
+ continue
384
+ hora = HORA.search(dicho)
385
+ if hora:
386
+ horas[nombre] = hora.group(0)
387
+ # El tablero dibuja pares clave/valor: de él se comparan los números
388
+ # y la rama. De los que escriben una frase, la frase entera.
389
+ if "tablero" in nombre:
390
+ if numeros(dicho) != numeros(esperado) or rama(dicho) != rama(esperado):
391
+ fallas.append(f"caso {i + 1} «{caso['nombre']}»\n {nombre}\n"
392
+ f" esperaba {rama(esperado)} {numeros(esperado)}\n"
393
+ f" dijo {rama(dicho)} {numeros(dicho)}")
394
+ continue
395
+ comparable = HORA.sub("{desde}", dicho)
396
+ if comparable != esperado:
397
+ fallas.append(f"caso {i + 1} «{caso['nombre']}»\n {nombre}\n"
398
+ f" esperaba {esperado}\n dijo {comparable}")
399
+ if len(set(horas.values())) > 1:
400
+ fallas.append(f"caso {i + 1}: la hora de medidoDesde no coincide entre pantallas: "
401
+ + ", ".join(f"{n} dice {h}" for n, h in horas.items()))
402
+
403
+ # Sin swiftc la barra no se ejecuta, pero su redacción se lee igual.
404
+ corrio_swift = any("Swift" in n for n in corridas)
405
+ if not corrio_swift:
406
+ dichos = redaccion_swift()
407
+ for f in sorted({f for c in CASOS for f in canon_a_formato(c["esperado"])} - set(dichos)):
408
+ fallas.append("la barra de macOS no escribe esta frase del canon:\n"
409
+ f" {f}\n escribe: " + " | ".join(dichos))
410
+
411
+ if fallas:
412
+ for f in fallas:
413
+ print(f"GATE ROJO: {f}", file=sys.stderr)
414
+ return 1
415
+
416
+ for nombre, salidas in corridas.items():
417
+ salteados = sum(1 for s in salidas if s == SALTEADO)
418
+ cola = f" · {salteados} salteado: el qm anterior no pasa por esta función" if salteados else ""
419
+ print(f" ✓ {nombre}: {len(CASOS) - salteados}/{len(CASOS)}{cola}")
420
+ for s in salteadas:
421
+ print(f" · salteada: {s}")
422
+ if salteadas:
423
+ print(f"presupuesto: {len(CASOS)} casos, coinciden las pantallas que se pudieron correr acá")
424
+ else:
425
+ print(f"presupuesto: {len(CASOS)} casos, las cinco pantallas dicen lo mismo")
426
+ if not corrio_swift:
427
+ print(" · de la barra de macOS se comprobó la redacción, no la ejecución")
428
+ print(" · el tablero escribe los números con coma; se comparan como números")
429
+ return 0
430
+
431
+
432
+ if __name__ == "__main__":
433
+ raise SystemExit(main())
@@ -17,6 +17,19 @@
17
17
  //
18
18
  // Todo por la API, sin clonar: winget-pkgs son cientos de miles de archivos y
19
19
  // un clone en cada release sería minutos de runner para tocar cuatro YAML.
20
+ //
21
+ // UN SOLO PR MIENTRAS EL PAQUETE NO ESTÉ EN EL CATÁLOGO. Hasta el 2026-09-14
22
+ // cada release abría su propio «New package»: seis PRs abiertos a la vez, de
23
+ // 0.1.6 a 0.1.11, esperando al mismo moderador, con el primero validado desde
24
+ // el día anterior. Un paquete nuevo lo aprueba a mano un moderador voluntario,
25
+ // y seis envíos del mismo paquete son ruido en el repo de otro y un motivo para
26
+ // cerrarlos. Ahora, si hay un PR abierto de este paquete —de la versión que
27
+ // sea—, la release NUEVA se empuja a esa rama y se le cambia el título: el
28
+ // moderador ve un solo envío, siempre con la última versión. Una vez que el
29
+ // paquete está en el catálogo, cada versión va en su PR, que es lo normal ahí.
30
+ //
31
+ // --en-seco ¿el token llega a la org y al fork? No toca nada.
32
+ // --plan además dice qué haría con esta versión. Tampoco toca nada.
20
33
 
21
34
  import { readdirSync, readFileSync } from 'node:fs';
22
35
  import { join } from 'node:path';
@@ -27,17 +40,20 @@ const DIR = process.env.DIR;
27
40
  const ARRIBA = process.env.UPSTREAM ?? 'microsoft/winget-pkgs';
28
41
  const FORK = process.env.FORK ?? 'legiosai/winget-pkgs';
29
42
  const SECO = process.argv.includes('--en-seco');
43
+ const PLAN = process.argv.includes('--plan');
30
44
 
31
45
  // DIR sólo hace falta cuando de verdad se va a mandar algo: --en-seco existe
32
46
  // para poder preguntar «¿este token llega a la organización?» sin haber armado
33
47
  // los manifests, que es lo que hay que poder contestar ANTES de tirar un tag.
34
- for (const [k, v] of Object.entries({ GITHUB_TOKEN: TOKEN, V, ...(SECO ? {} : { DIR }) })) {
48
+ for (const [k, v] of Object.entries({ GITHUB_TOKEN: TOKEN, V, ...(SECO || PLAN ? {} : { DIR }) })) {
35
49
  if (!v) { console.error(`falta ${k}`); process.exit(2); }
36
50
  }
37
51
 
38
52
  const [ORG] = FORK.split('/');
39
- const RAMA = `Legios.Quartermaster-${V}`;
40
- const RUTA = `manifests/l/Legios/Quartermaster/${V}`;
53
+ const PAQUETE = 'Legios.Quartermaster';
54
+ const PREFIJO_RAMA = `${PAQUETE}-`;
55
+ const RUTA_PAQUETE = 'manifests/l/Legios/Quartermaster';
56
+ const RUTA = `${RUTA_PAQUETE}/${V}`;
41
57
 
42
58
  async function api(metodo, ruta, cuerpo) {
43
59
  const r = await fetch(`https://api.github.com/${ruta}`, {
@@ -85,6 +101,7 @@ if (!org.ok) {
85
101
  // ── el fork de la org ─────────────────────────────────────────────────
86
102
  let fork = await api('GET', `repos/${FORK}`);
87
103
  if (!fork.ok) {
104
+ if (PLAN) { console.log(`· --plan: ${FORK} no existe; se forkearía ${ARRIBA} y se abriría un PR nuevo`); process.exit(0); }
88
105
  console.log(`· ${FORK} no existe: forkeando ${ARRIBA} a la organización`);
89
106
  const hecho = await api('POST', `repos/${ARRIBA}/forks`, {
90
107
  organization: ORG, default_branch_only: true,
@@ -104,6 +121,55 @@ if (!fork.datos.permissions?.push) {
104
121
  const base = fork.datos.default_branch;
105
122
  console.log(`· fork: ${FORK} (rama base ${base})`);
106
123
 
124
+ if (SECO) { console.log('· --en-seco: hasta acá llego'); process.exit(0); }
125
+
126
+ // ── qué corresponde: PR nuevo, o el que ya está abierto ───────────────
127
+ // En el catálogo = ya hay una carpeta del paquete en winget-pkgs.
128
+ const catalogo = await api('GET', `repos/${ARRIBA}/contents/${RUTA_PAQUETE}`);
129
+ const enCatalogo = catalogo.ok;
130
+
131
+ /** El PR abierto de este paquete desde el fork, de la versión que sea, o null. */
132
+ async function prAbierto() {
133
+ // Se buscan las ramas del fork y no con la búsqueda de GitHub: el índice de
134
+ // búsqueda tarda minutos en enterarse de un PR cerrado, y acá eso sería
135
+ // empujarle una versión a un PR que ya no existe.
136
+ const ramas = [];
137
+ for (let pagina = 1; pagina <= 10; pagina++) {
138
+ const r = await api('GET', `repos/${FORK}/branches?per_page=100&page=${pagina}`);
139
+ if (!r.ok) morir(`no pude listar las ramas de ${FORK}`, r);
140
+ ramas.push(...r.datos.map((b) => b.name).filter((n) => n.startsWith(PREFIJO_RAMA)));
141
+ if (r.datos.length < 100) break;
142
+ }
143
+ // La más nueva primero: si por algo quedaran dos, se usa la de la última versión.
144
+ ramas.sort((a, b) => b.localeCompare(a, 'en', { numeric: true }));
145
+ for (const rama of ramas) {
146
+ const ps = await api('GET', `repos/${ARRIBA}/pulls?head=${ORG}:${rama}&state=open`);
147
+ if (ps.ok && ps.datos.length > 0) return ps.datos[0];
148
+ }
149
+ return null;
150
+ }
151
+
152
+ // Con el paquete en el catálogo cada versión va en su propio PR; mientras no,
153
+ // se reusa el que esté abierto.
154
+ const abierto = enCatalogo
155
+ ? (await api('GET', `repos/${ARRIBA}/pulls?head=${ORG}:${PREFIJO_RAMA}${V}&state=open`)).datos?.[0] ?? null
156
+ : await prAbierto();
157
+ const RAMA = abierto?.head.ref ?? `${PREFIJO_RAMA}${V}`;
158
+ const titulo = `${enCatalogo ? 'New version' : 'New package'}: ${PAQUETE} version ${V}`;
159
+
160
+ console.log(`· ${PAQUETE} ${enCatalogo ? 'ya está' : 'todavía no está'} en el catálogo de ${ARRIBA}`);
161
+ console.log(abierto
162
+ ? `· PR abierto: #${abierto.number} (${abierto.title}), rama ${RAMA}`
163
+ : '· no hay un PR abierto de este paquete');
164
+
165
+ if (PLAN) {
166
+ console.log(abierto
167
+ ? `· --plan: se empujaría ${V} a ${ORG}:${RAMA} y #${abierto.number} pasaría a llamarse «${titulo}»`
168
+ : `· --plan: se abriría un PR nuevo «${titulo}» desde ${ORG}:${RAMA}`);
169
+ process.exit(0);
170
+ }
171
+
172
+ // ── la rama con los cuatro manifests ──────────────────────────────────
107
173
  // Ponerlo al día con Microsoft antes de ramificar. Sin esto el fork se queda
108
174
  // donde quedó la release anterior y el PR arrastra la diferencia.
109
175
  const aldia = await api('POST', `repos/${FORK}/merge-upstream`, { branch: base });
@@ -111,9 +177,6 @@ console.log(aldia.ok
111
177
  ? `· ${base} al día con ${ARRIBA}: ${aldia.datos.merge_type}`
112
178
  : `· no pude sincronizar ${base} (HTTP ${aldia.estado}); sigo igual`);
113
179
 
114
- if (SECO) { console.log('· --en-seco: hasta acá llego'); process.exit(0); }
115
-
116
- // ── la rama con los cuatro manifests ──────────────────────────────────
117
180
  const ref = await api('GET', `repos/${FORK}/git/ref/heads/${base}`);
118
181
  if (!ref.ok) morir(`no pude leer ${base} del fork`, ref);
119
182
  const shaBase = ref.datos.object.sha;
@@ -131,34 +194,29 @@ for (const f of archivos) {
131
194
  console.log(` · ${f}`);
132
195
  }
133
196
 
197
+ // El árbol sale de la base, no de la rama: si la rama era de otra versión, la
198
+ // carpeta vieja desaparece y el PR queda tocando UN solo manifest, que es lo que
199
+ // pide la checklist de winget-pkgs.
134
200
  const tree = await api('POST', `repos/${FORK}/git/trees`, { base_tree: shaBase, tree: arbol });
135
201
  if (!tree.ok) morir('no pude armar el árbol', tree);
136
202
 
137
203
  const commit = await api('POST', `repos/${FORK}/git/commits`, {
138
- message: `New package: Legios.Quartermaster version ${V}`,
139
- tree: tree.datos.sha, parents: [shaBase],
204
+ message: titulo, tree: tree.datos.sha, parents: [shaBase],
140
205
  });
141
206
  if (!commit.ok) morir('no pude armar el commit', commit);
142
207
 
143
- // force: un rerun del job tiene que poder repetirse sin dejar la rama a medias.
208
+ // force: un rerun del job tiene que poder repetirse sin dejar la rama a medias,
209
+ // y empujar una versión nueva a la rama de otra reemplaza su contenido.
144
210
  let rama = await api('PATCH', `repos/${FORK}/git/refs/heads/${RAMA}`, { sha: commit.datos.sha, force: true });
145
211
  if (!rama.ok) rama = await api('POST', `repos/${FORK}/git/refs`, { ref: `refs/heads/${RAMA}`, sha: commit.datos.sha });
146
212
  if (!rama.ok) morir(`no pude dejar la rama ${RAMA}`, rama);
147
213
  console.log(`· rama ${ORG}:${RAMA} en ${commit.datos.sha.slice(0, 10)}`);
148
214
 
149
215
  // ── el PR ─────────────────────────────────────────────────────────────
150
- // Si ya hay uno abierto con esta misma cabeza, el push de arriba ya lo
151
- // actualizó: abrir otro sería ruido en el repo de otro.
152
- const abiertos = await api('GET', `repos/${ARRIBA}/pulls?head=${ORG}:${RAMA}&state=open`);
153
- if (abiertos.ok && abiertos.datos.length > 0) {
154
- console.log(`::notice::winget: el PR ya estaba abierto y se actualizó: ${abiertos.datos[0].html_url}`);
155
- process.exit(0);
156
- }
157
-
158
216
  const cuerpo = [
159
217
  '## 📖 Description',
160
218
  '',
161
- `New package: **Legios.Quartermaster** version ${V} — a CLI that reports how much`,
219
+ `${enCatalogo ? 'New version' : 'New package'}: **${PAQUETE}** version ${V} — a CLI that reports how much`,
162
220
  'quota is left across every Claude Code profile on the machine, plus Codex and',
163
221
  'opencode. MIT, source at https://github.com/legiosai/quartermaster',
164
222
  '',
@@ -170,9 +228,14 @@ const cuerpo = [
170
228
  ' inno`, `Scope: user`). The Node dependency\'s MSI does, so a machine without',
171
229
  ' Node will see one UAC prompt that is not ours.',
172
230
  '',
231
+ ...(enCatalogo ? [] : [
232
+ 'While this package is waiting for its first review, new releases are pushed',
233
+ 'to this same PR instead of opening another one.',
234
+ '',
235
+ ]),
173
236
  '## ✅ Checklist',
174
237
  '',
175
- '- [ ] Signed the [Contributor License Agreement](https://cla.opensource.microsoft.com)',
238
+ '- [x] Signed the [Contributor License Agreement](https://cla.opensource.microsoft.com)',
176
239
  '',
177
240
  '## 📦 Manifest Checklist',
178
241
  '',
@@ -181,9 +244,31 @@ const cuerpo = [
181
244
  '- [ ] Tested manifest locally with `winget install --manifest <path>`',
182
245
  ].join('\n');
183
246
 
247
+ if (abierto) {
248
+ const antes = abierto.title;
249
+ const cambio = await api('PATCH', `repos/${ARRIBA}/pulls/${abierto.number}`, { title: titulo, body: cuerpo });
250
+ if (!cambio.ok) morir(`empujé ${V} pero no pude renombrar #${abierto.number}`, cambio);
251
+ if (antes !== titulo) {
252
+ // Una línea para el moderador: el PR que estaba mirando cambió de versión.
253
+ await api('POST', `repos/${ARRIBA}/issues/${abierto.number}/comments`, {
254
+ body: `Updated to ${PAQUETE} ${V} (was: “${antes}”). Pushing new releases here instead of opening a new PR.`,
255
+ });
256
+ }
257
+ console.log(`::notice::winget: ${V} empujada al PR que ya estaba abierto — ${abierto.html_url}`);
258
+ process.exit(0);
259
+ }
260
+
184
261
  const pr = await api('POST', `repos/${ARRIBA}/pulls`, {
185
- title: `New package: Legios.Quartermaster version ${V}`,
186
- head: `${ORG}:${RAMA}`, base, body: cuerpo, maintainer_can_modify: true,
262
+ title: titulo, head: `${ORG}:${RAMA}`, base, body: cuerpo, maintainer_can_modify: true,
187
263
  });
188
264
  if (!pr.ok) morir('no pude abrir el PR', pr);
189
265
  console.log(`::notice::winget: PR abierto — ${pr.datos.html_url}`);
266
+
267
+ // El bot del CLA marca cada PR nuevo con Needs-CLA aunque la cuenta ya haya
268
+ // firmado, y no la saca hasta que se le contesta en ESE PR. Pasó en los cinco
269
+ // PRs después del primero. El token es de la cuenta que firmó, así que la
270
+ // respuesta la puede dar el job.
271
+ const cla = await api('POST', `repos/${ARRIBA}/issues/${pr.datos.number}/comments`, {
272
+ body: '@microsoft-github-policy-service agree company="Legios"',
273
+ });
274
+ console.log(cla.ok ? '· CLA: respondido en el PR' : `· CLA: no pude comentar (HTTP ${cla.estado}); hay que hacerlo a mano`);