@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.
- package/README.md +24 -5
- package/bin/qm +21 -2
- package/bin/qm-indicator +235 -8
- package/bin/qm-tray.ps1 +6 -1
- package/dist/adapters/barra.js +142 -31
- package/dist/adapters/barra.js.map +1 -1
- package/extension/quartermaster@legios/extension.js +257 -0
- package/extension/quartermaster@legios/metadata.json +8 -0
- package/extension/quartermaster@legios/stylesheet.css +10 -0
- package/package.json +2 -1
- package/scripts/gate-presupuesto.py +433 -0
- package/scripts/mandar-pr-winget.mjs +106 -21
|
@@ -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
|
|
40
|
-
const
|
|
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:
|
|
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
|
-
|
|
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
|
-
'- [
|
|
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:
|
|
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`);
|