yupana: los 2 "bugs" de duplicados eran falsos positivos MÍOS — detector afinado, 0 reales
El usuario pidió arreglar itstool y la sombra de dbus. Apliqué el reflejo
(`yupana radio` + diff completo antes de tocar) y NINGUNO era un bug: ambos eran
patrones deliberados y documentados que mi detector, demasiado superficial, leyó
mal. Si los "arreglaba" a ciegas rompía dos builds.
· dbus: corpus/dbus (estático) e incoming-kde/dbus (dinámico) NO son redundantes
— qtbase linkea libdbus-1.so dinámicamente para Qt6DBus. El detector comparó
sólo versión+sha+deps, no el BUILD. Borrar la sombra rompía KDE.
· itstool: es un STUB documentado (`[source]=carrier`). El itstool real es
Python con libxml2-bindings ausentes en el lab; este genera un script inline y
sólo PRESTA el tarball de gettext-tiny. Apuntarlo al itstool real rompía
appstream (radio 5) con un source que ni compila acá.
Los 3 *-hello son el mismo patrón carrier; prison/prison-scanner una variante
cross-nombre (misma fuente, WITH_ZXING distinto).
FIX = el detector, no las recetas. Tres señales que le faltaban:
1. huella de BUILD en la firma de sombra (estático≠dinámico ⇒ no redundante).
2. CARRIER: ≤1 receta del grupo construye la fuente ⇒ el resto presta el tarball.
Señal: ¿invoca make/meson/cmake/ninja/cargo? (comentarios strippeados — la
prosa "invocación de meson" de un stub daba falso builder, lo cazó el guardián).
3. variante cross-nombre: ≥2 builders con BUILD distinto = deliberado, no bug.
Resultado: 0 colisiones reales (invariante c se cumple), 4 carrier + 14 variantes
+ 12 sombras justificadas, todas benignas.
Guardián extendido: ancla que el detector agrupa por FUENTE (itstool↔gettext-tiny)
y NO cría lobos (itstool=carrier, dbus=variante deliberada).
LECCIÓN: el reflejo del radio/diff antes de tocar evitó dos borrados destructivos
guiados por un falso positivo de mi propia herramienta. Medir antes de creer, aun
a la propia yupana.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
+62
-22
@@ -44,7 +44,7 @@
|
||||
# Uso: scripts/yupana.py radio <receta> [--json]
|
||||
# scripts/yupana.py estado [--kde] | drenar [--todos] | triaje | frontera <perfil> | objetivo
|
||||
# Como módulo: from yupana import cargar_colas, membresia, dependientes, resolver
|
||||
import glob, json, os, subprocess, sys, tomllib
|
||||
import glob, json, os, re, subprocess, sys, tomllib
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
@@ -245,26 +245,46 @@ def keystones(como_json=False):
|
||||
|
||||
|
||||
def _fuente(f):
|
||||
"""(sha, url, version) de una receta — la identidad de lo que BAJA, no de cómo se llama."""
|
||||
"""(sha, url, version, build_fp) de una receta. Los tres primeros = identidad de lo que BAJA. El
|
||||
cuarto = HUELLA DE BUILD (link, compiler, fases) — porque dos recetas con la MISMA fuente pero
|
||||
build distinto NO son redundantes: son variantes deliberadas (corpus/dbus estático vs
|
||||
incoming-kde/dbus dinámico para Qt6DBus). Ignorar esto hacía que el detector marcara `dbus` como
|
||||
sombra redundante y casi borra una receta load-bearing (2026-07-22)."""
|
||||
try:
|
||||
d = tomllib.load(open(f, "rb"))
|
||||
except Exception:
|
||||
return (None, "", None)
|
||||
return (None, "", None, None, False)
|
||||
s = d.get("source", {})
|
||||
b = d.get("build", {})
|
||||
ph = b.get("phases", {}) or {}
|
||||
build_fp = (b.get("link"), b.get("compiler"),
|
||||
tuple(sorted((k, str(v)) for k, v in ph.items())))
|
||||
# ¿construye la FUENTE descargada, o es un CARRIER (stub/demo que genera todo inline y sólo presta
|
||||
# el tarball)? Señal: invoca un sistema de build. itstool/-hello no ⇒ carrier; su colisión de sha
|
||||
# es esperada, no un error de copiado. (2026-07-22: sin esto el detector marcaba 4 falsos bugs.)
|
||||
blob = "\n".join(str(ph.get(k, "")) for k in ("configure", "compile", "install"))
|
||||
# Strip comentarios shell (`# …` a fin de línea) ANTES de buscar: si no, la prosa de un stub
|
||||
# ("# parsea la invocación de meson") matchea y marca al carrier como builder (falso positivo
|
||||
# que el guardián cazó, 2026-07-22).
|
||||
sin_comentarios = re.sub(r"#.*", "", blob)
|
||||
construye = any(re.search(rx, sin_comentarios) for rx in
|
||||
(r"\bmake\b", r"\bmeson\b", r"\bcmake\b", r"\bninja\b", r"\bcargo\b",
|
||||
r"\./configure", r"\bautogen", r"\bautoreconf"))
|
||||
return (s.get("sha256") or s.get("output_hash"),
|
||||
s.get("tarball") or s.get("url") or s.get("git") or "",
|
||||
d.get("version"))
|
||||
d.get("version"), build_fp, construye)
|
||||
|
||||
|
||||
def _recetas_con_fuente():
|
||||
"""{(cola, nombre): {sha, url, version, deps}} sobre todo el disco."""
|
||||
"""{(cola, nombre): {sha, url, version, build_fp, construye_fuente, deps}} sobre todo el disco."""
|
||||
out = {}
|
||||
for pat, es_incoming in (("recipes/*.toml", False), ("recipes/incoming-*/*.toml", True)):
|
||||
for f in sorted(glob.glob(str(ROOT / pat))):
|
||||
n = os.path.basename(f)[:-5]
|
||||
q = os.path.basename(os.path.dirname(f)) if es_incoming else "corpus"
|
||||
sha, url, ver = _fuente(f)
|
||||
out[(q, n)] = dict(sha=sha, url=url, version=ver, deps=_deps(f))
|
||||
sha, url, ver, build_fp, construye = _fuente(f)
|
||||
out[(q, n)] = dict(sha=sha, url=url, version=ver, build_fp=build_fp,
|
||||
construye_fuente=construye, deps=_deps(f))
|
||||
return out
|
||||
|
||||
|
||||
@@ -287,15 +307,27 @@ def duplicados(como_json=False):
|
||||
for k, r in recs.items():
|
||||
if r["sha"]:
|
||||
por_sha[r["sha"]].append(k)
|
||||
colisiones, variantes = [], []
|
||||
colisiones, variantes, carriers = [], [], []
|
||||
for sha, ks in por_sha.items():
|
||||
nombres = {n for _, n in ks}
|
||||
if len(nombres) < 2:
|
||||
continue
|
||||
familias = {_base(n) for _, n in ks}
|
||||
grupo = dict(sha=sha[:16], nudos=sorted(f"{q}/{n}" for q, n in ks),
|
||||
radio={f"{q}/{n}": len(rev.get((q, n), ())) for q, n in ks})
|
||||
(variantes if len(familias) == 1 else colisiones).append(grupo)
|
||||
builders = [k for k in ks if recs[k]["construye_fuente"]]
|
||||
familias = {_base(n) for _, n in ks}
|
||||
# Clasificación por evidencia, de más benigno a más sospechoso:
|
||||
if len(builders) <= 1:
|
||||
# ≤1 receta construye la fuente ⇒ el resto son CARRIERS que le prestan el tarball. Benigno.
|
||||
grupo["carriers"] = sorted(f"{q}/{n}" for (q, n) in ks
|
||||
if not recs[(q, n)]["construye_fuente"])
|
||||
carriers.append(grupo)
|
||||
elif len(familias) == 1:
|
||||
variantes.append(grupo) # misma familia (zlib/zlib-shared): variante deliberada
|
||||
elif len({recs[k]["build_fp"] for k in builders}) > 1:
|
||||
variantes.append(grupo) # familias distintas pero BUILD distinto: variante cross-nombre
|
||||
else: # ≥2 builders, MISMO build, familias distintas ⇒ sospechoso
|
||||
colisiones.append(grupo)
|
||||
|
||||
# 2) sombras: mismo nombre en >1 cola
|
||||
por_nombre = defaultdict(list)
|
||||
@@ -305,15 +337,18 @@ def duplicados(como_json=False):
|
||||
for n, qs in por_nombre.items():
|
||||
if len(qs) < 2:
|
||||
continue
|
||||
firmas = {(recs[(q, n)]["version"], recs[(q, n)]["sha"],
|
||||
# Redundante SÓLO si coinciden fuente Y BUILD: mismo tarball no basta, dos builds distintos
|
||||
# del mismo source (estático vs dinámico) son variantes deliberadas, no redundancia.
|
||||
firmas = {(recs[(q, n)]["version"], recs[(q, n)]["sha"], recs[(q, n)]["build_fp"],
|
||||
tuple(sorted(recs[(q, n)]["deps"]))) for q in qs}
|
||||
sombras.append(dict(nombre=n, colas=sorted(qs),
|
||||
redundante=len(firmas) == 1, # idénticas ⇒ la sombra no aporta nada
|
||||
redundante=len(firmas) == 1, # idénticas en fuente+build ⇒ una sobra
|
||||
radio={f"{q}/{n}": len(rev.get((q, n), ())) for q in qs}))
|
||||
|
||||
doc = dict(schema="hammer-duplicados/1",
|
||||
doc = dict(schema="hammer-duplicados/2",
|
||||
colisiones_fuente=sorted(colisiones, key=lambda g: -max(g["radio"].values() or [0])),
|
||||
variantes=sorted(variantes, key=lambda g: g["nudos"]),
|
||||
carriers=sorted(carriers, key=lambda g: g["nudos"]),
|
||||
sombras=sorted(sombras, key=lambda s: (not s["redundante"], s["nombre"])))
|
||||
(ROOT / "docs/state/duplicados.json").write_text(
|
||||
json.dumps(doc, indent=1, ensure_ascii=False) + "\n")
|
||||
@@ -321,20 +356,25 @@ def duplicados(como_json=False):
|
||||
if como_json:
|
||||
print(json.dumps(doc, indent=1, ensure_ascii=False))
|
||||
return 0
|
||||
red = [s for s in sombras if s["redundante"]]
|
||||
print(f"== INVARIANTE (c) CANÓNICO — duplicados por evidencia de fuente\n")
|
||||
print(f"⚠ COLISIONES DE FUENTE: {len(colisiones)} (mismo sha, familias distintas — revisá el sha)")
|
||||
print(f"⚠ COLISIONES DE FUENTE REALES: {len(colisiones)} (≥2 recetas construyen el MISMO source,")
|
||||
print(f" mismo build, familias distintas — casi seguro un sha copiado por error)")
|
||||
for g in doc["colisiones_fuente"]:
|
||||
print(f" sha {g['sha']}… {g['nudos']}")
|
||||
print(f" radio: " + " ".join(f"{k.split('/')[-1]}={v}" for k, v in g["radio"].items()))
|
||||
red = [s for s in sombras if s["redundante"]]
|
||||
print(f"\n⚠ SOMBRAS REDUNDANTES: {len(red)} (mismo nombre+versión+sha+deps en 2 colas — una sobra)")
|
||||
if not colisiones:
|
||||
print(" (ninguna — el invariante (c) se cumple)")
|
||||
print(f"\n⚠ SOMBRAS REDUNDANTES: {len(red)} (mismo nombre+fuente+BUILD en 2 colas — una sobra)")
|
||||
for s in red:
|
||||
print(f" {s['nombre']:24} {s['colas']} radio " +
|
||||
" ".join(f"{q}={v}" for (q, _), v in
|
||||
((k.split('/'), v) for k, v in s["radio"].items())))
|
||||
print(f"\n✓ variantes deliberadas (misma fuente, familia OK): {len(variantes)} — no son problema")
|
||||
print(f"✓ sombras justificadas (difieren en versión/deps): {len(sombras)-len(red)}")
|
||||
print(f"\n → docs/state/duplicados.json · el radio ayuda a elegir el canónico (el de mayor radio)")
|
||||
print(f" {s['nombre']:24} {s['colas']}")
|
||||
if not red:
|
||||
print(" (ninguna)")
|
||||
print(f"\n✓ BENIGNOS (no son problema):")
|
||||
print(f" {len(carriers)} grupos CARRIER (stub/demo que presta el tarball: itstool, *-hello)")
|
||||
print(f" {len(variantes)} variantes deliberadas (misma fuente, build/familia distintos: zlib-shared, prison-scanner)")
|
||||
print(f" {len(sombras)-len(red)} sombras justificadas (mismo nombre, build distinto: dbus estático/dinámico)")
|
||||
print(f"\n → docs/state/duplicados.json")
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user