webscope-mcp 0.2.0__py3-none-any.whl

webscope_adaptadores/proyecto.py

@@ -0,0 +1,62 @@
+"""Configuración del proyecto para los adaptadores: dónde están los módulos del backend y cómo se consulta o escribe en la base.
+
+Se lee la sección `proyecto` del manifiesto (variable WEBSCOPE_MANIFIESTO) y la raíz de WEBSCOPE_RAIZ (o el directorio actual);
+`webscope.py` define ambas al correr un script. Todas las rutas son relativas a la raíz.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+RAIZ = Path(os.environ.get("WEBSCOPE_RAIZ") or Path.cwd())
+DEFECTO = {
+    "modulos": "app/Modules",
+    "carpetas": {"requests": "Requests", "servicios": "Services", "recursos": "Resources"},
+    "sql": "",
+    "tinker": "",
+    "php_db": "DB::connection()",
+    "prefijo_rutas": "",
+    "contenedor": "",
+}
+
+
+def config():
+    """Sección `proyecto` del manifiesto sobre los valores por defecto."""
+    ruta = os.environ.get("WEBSCOPE_MANIFIESTO")
+    propia = json.loads(Path(ruta).read_text()).get("proyecto", {}) if ruta else {}
+    return {**DEFECTO, **propia, "carpetas": {**DEFECTO["carpetas"], **propia.get("carpetas", {})}}
+
+
+def modulo(area_modulo):
+    """Carpeta del módulo `<Area>/<Modulo>` en el backend."""
+    return RAIZ / config()["modulos"] / area_modulo
+
+
+def consulta(sentencia):
+    """Corre una consulta de solo lectura con el script `sql` del proyecto (imprime TSV con cabecera) y devuelve las filas sin cabecera."""
+    if not config()["sql"]:
+        sys.exit("ERR el proyecto no define `sql`: ponlo en la sección `proyecto` del manifiesto (script que imprime TSV con cabecera)")
+    script = RAIZ / config()["sql"]
+    if not script.is_file():
+        sys.exit(f"ERR el script `sql` del manifiesto no existe: {script}")
+    p = subprocess.run([str(script), sentencia], capture_output=True, text=True, cwd=RAIZ)
+    if p.returncode:
+        sys.exit(f"ERR {(p.stdout + p.stderr).strip()[-300:]}")
+    lineas = [l for l in p.stdout.splitlines() if l and not l.startswith(("== ", "("))]
+    return [l.split("\t") for l in lineas[1:]]
+
+
+def reglas_back(php):
+    """Devuelve {campo: {required, nullable, max, unique, in}} leído del rules() de un FormRequest."""
+    cuerpo = php.split("function rules()", 1)[-1].split("function messages", 1)[0]
+    salida = {}
+    for campo, lista, texto in re.findall(r"'(\w+)'\s*=>\s*(?:\[(.*?)\]|'([^']*)')\s*,\s*\n", cuerpo, re.S):
+        reglas = (lista or "") if lista else texto
+        max_ = re.search(r"max:(\d+)", reglas)
+        in_ = re.search(r"(?<![\w])in:([\w,]+)", reglas)
+        salida[campo] = {"required": "required" in reglas, "nullable": "nullable" in reglas,
+                         "max": int(max_.group(1)) if max_ else None, "unique": "unique" in reglas,
+                         "in": in_.group(1).split(",") if in_ else None}
+    return salida

webscope_adaptadores/uso_agentes.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""Uso real de subagentes de un proyecto: por tipo, veces, vueltas (media y máxima), contexto escrito y leído, y modelos.
+
+Uso: python3 -I uso_agentes.py [--raiz <carpeta del proyecto>] [--max-vueltas 40]
+Lee `~/.claude/projects/<raíz>/*/subagents/agent-*.jsonl` y su `.meta.json`. Marca los subagentes que pasan de --max-vueltas,
+que es donde el contexto crece como en una sesión principal.
+"""
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+def carpeta(argv):
+    """Carpeta de transcripts del proyecto pedido o del directorio actual."""
+    raiz = argv[argv.index("--raiz") + 1] if "--raiz" in argv else str(Path.cwd())
+    return Path.home() / ".claude/projects" / re.sub(r"[^A-Za-z0-9]", "-", raiz)
+
+
+def subagente(lineas):
+    """Devuelve (vueltas, escrito, leído, modelos) de un transcript de subagente."""
+    vistos, escrito, leido, modelos = set(), 0, 0, set()
+    for linea in lineas:
+        d = json.loads(linea)
+        m = d.get("message") or {}
+        if d.get("type") != "assistant" or m.get("id") in vistos:
+            continue
+        vistos.add(m.get("id"))
+        u = m.get("usage") or {}
+        escrito += u.get("cache_creation_input_tokens", 0)
+        leido += u.get("cache_read_input_tokens", 0)
+        if m.get("model", "").startswith("claude-"):
+            modelos.add(m["model"].removeprefix("claude-"))
+    return len(vistos), escrito, leido, modelos
+
+
+def informe(filas, tope):
+    """Texto por tipo de agente y lista de subagentes que pasaron el tope de vueltas; filas = [(tipo, descripción, vueltas, escrito, leído, modelos)]."""
+    por = defaultdict(lambda: [0, 0, 0, 0, 0, set()])
+    for tipo, _, n, w, r, mods in filas:
+        t = por[tipo]
+        t[0] += 1
+        t[1] += n
+        t[2] = max(t[2], n)
+        t[3] += w
+        t[4] += r
+        t[5] |= mods
+    total = sum(t[4] for t in por.values()) or 1
+    salida = [f"Subagentes: {len(filas)}, {total // 1_000_000} M leídos. Sigue: dividir por módulo los que pasan de {tope} vueltas."]
+    for tipo, (k, n, mx, w, r, mods) in sorted(por.items(), key=lambda x: -x[1][4]):
+        salida.append(f"tipo {tipo}: {k} veces, vueltas media {n // k} máx {mx}, escrito {w // 1000} k, leído {r // 1000} k "
+                      f"({100 * r // total} %), modelos {','.join(sorted(mods)) or '?'}")
+    for tipo, desc, n, _, r, _ in sorted(filas, key=lambda x: -x[4]):
+        if n > tope:
+            salida.append(f"pasa de {tope} vueltas: {tipo} «{desc[:60]}» {n} vueltas, {r // 1000} k leídos")
+    return "\n".join(salida)
+
+
+if __name__ == "__main__":
+    argv = sys.argv[1:]
+    tope = int(argv[argv.index("--max-vueltas") + 1]) if "--max-vueltas" in argv else 40
+    filas = []
+    for meta in carpeta(argv).glob("*/subagents/agent-*.meta.json"):
+        m = json.loads(meta.read_text())
+        datos = subagente(meta.with_name(meta.name.replace(".meta.json", ".jsonl")).read_text().splitlines())
+        filas.append((m.get("agentType", "?"), m.get("description", ""), *datos))
+    print(informe(filas, tope))

webscope_adaptadores/uso_webscope.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Cuánto de leer y buscar pasa por webscope en las sesiones de Claude Code de un proyecto, y qué se hace en su lugar.
+
+Uso: python3 -I uso_webscope.py [--raiz <carpeta del proyecto>] [--desde AAAA-MM-DD]
+Lee `~/.claude/projects/<raíz>*/*.jsonl` (sesión principal, sin subagentes) y cuenta solo las sesiones donde webscope
+estaba disponible. Lecturas: Read, cat, sed -n, head, tail; búsquedas: grep, rg. Las imágenes no cuentan.
+"""
+import collections
+import json
+import re
+import sys
+from pathlib import Path
+
+SHELL = r"\s*(?:cd [^&;]+(?:&&|;)\s*)?"
+IMAGENES = (".png", ".jpg", ".jpeg", ".gif", ".webp")
+
+
+def clase(nombre, entrada):
+    """Devuelve (grupo, tipo) de una llamada: grupo «leer» o «buscar», o None si no es ninguno de los dos."""
+    if nombre.startswith(("mcp__webscope__", "mcp__escueto__")):
+        corto = nombre.split("__")[-1]
+        return ({"leer": "leer", "buscar": "buscar"}.get(corto), f"webscope {corto}")
+    cmd = entrada.get("command", "") if nombre == "Bash" else ""
+    if nombre == "Read" and not entrada.get("file_path", "").lower().endswith(IMAGENES):
+        return "leer", "Read " + ("rango" if entrada.get("offset") or entrada.get("limit") else "entero")
+    if re.match(SHELL + r"sed -n", cmd):
+        return "leer", "sed -n"
+    if re.match(SHELL + r"(cat|head|tail) ", cmd):
+        return "leer", re.match(SHELL + r"(\w+)", cmd)[1]
+    if re.match(SHELL + r"(grep|rg) ", cmd):
+        return "buscar", "grep"
+    return None, None
+
+
+def contar(lineas, desde=""):
+    """Llamadas por (grupo, tipo) de una sesión desde la fecha `desde` (AAAA-MM-DD) y si webscope estaba disponible
+    en ella con alguna línea en esas fechas."""
+    cuenta, disponible, reciente = collections.Counter(), False, not desde
+    for linea in lineas:
+        if "mcp__webscope__" in linea or "mcp__escueto__" in linea:
+            disponible = True
+        try:
+            d = json.loads(linea)
+        except ValueError:
+            continue
+        if d.get("timestamp", "")[:10] >= desde:
+            reciente = True
+        elif desde:
+            continue
+        if d.get("type") != "assistant" or d.get("isSidechain"):
+            continue
+        for b in (d.get("message") or {}).get("content") or []:
+            if isinstance(b, dict) and b.get("type") == "tool_use":
+                grupo, tipo = clase(b.get("name", ""), b.get("input") or {})
+                if grupo:
+                    cuenta[(grupo, tipo)] += 1
+    return cuenta, disponible and reciente
+
+
+def informe(cuenta, sesiones):
+    """Texto con el % por webscope de leer y de buscar y los tipos de llamada que lo sustituyeron."""
+    salida = [f"Sesiones con webscope disponible: {sesiones}. Sigue: lo que más se hace fuera de webscope es lo que falta cubrir."]
+    for grupo in ("leer", "buscar"):
+        total = sum(n for (g, _), n in cuenta.items() if g == grupo)
+        propio = sum(n for (g, t), n in cuenta.items() if g == grupo and t.startswith("webscope"))
+        if total:
+            otros = sorted(((n, t) for (g, t), n in cuenta.items() if g == grupo and not t.startswith("webscope")), reverse=True)
+            salida.append(f"{grupo}: {propio} de {total} por webscope ({100 * propio // total} %); fuera: "
+                          + ", ".join(f"{t} {n}" for n, t in otros[:5]))
+    return "\n".join(salida)
+
+
+if __name__ == "__main__":
+    argv = sys.argv[1:]
+    raiz = argv[argv.index("--raiz") + 1] if "--raiz" in argv else str(Path.cwd())
+    desde = argv[argv.index("--desde") + 1] if "--desde" in argv else ""
+    prefijo = re.sub(r"[^A-Za-z0-9]", "-", raiz)
+    total, sesiones = collections.Counter(), 0
+    for carpeta in (Path.home() / ".claude/projects").glob(prefijo + "*"):
+        for archivo in carpeta.glob("*.jsonl"):
+            cuenta, disponible = contar(archivo.read_text(errors="ignore").splitlines(), desde)
+            if disponible:
+                total += cuenta
+                sesiones += 1
+    print(informe(total, sesiones))

webscope_adaptadores/vue_ts.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Mapa de un módulo de un frontend Vue 3 + TypeScript: rutas, vistas, llamadas HTTP, composables y stores.
+
+Uso: python3 -I vue_ts.py <carpeta-de-módulos> <módulo> [--receta] [--recorrido]
+`<módulo>` es una subcadena de la ruta relativa (p. ej. `configs/templates`). Con `--receta` añade los pasos para revisarlo
+en el navegador. Con `--recorrido` cambia la lista de llamadas por lo que se puede pulsar: acciones con su `v-if` y permiso,
+enlaces, pestañas con su componente y API, campos de formulario y estados. Con `--cobertura <captura>` cuenta qué llamadas
+del módulo aparecen en una captura de `e2e_chrome --guardar` y lista las que faltan. Cachea el índice en `~/.cache/webscope/` y lo rehace solo si cambió algún archivo.
+"""
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+RUTA = re.compile(r"path:\s*['\"]([^'\"]+)['\"]")
+NOMBRE = re.compile(r"name:\s*['\"]([^'\"]+)['\"]")
+VISTA = re.compile(r"import\(['\"]([^'\"]+\.vue)['\"]\)")
+HTTP = re.compile(r"\b(?:axios|http|api)\.(get|post|put|patch|delete)(?:<[^>]*>)?\(\s*([`'\"])(.+?)\2")
+ETIQUETA = re.compile(r"<([A-Za-z][\w-]*)((?:\s+[^\s=>/\"']+(?:=(?:\"[^\"]*\"|'[^']*'))?)*)\s*/?>([^<]*)")
+ATRIBUTO = re.compile(r"([^\s=>/\"']+)(?:=(?:\"([^\"]*)\"|'([^']*)'))?")
+IMPORTA = re.compile(r"import\s+(\w+)\s+from\s+['\"]([^'\"]+\.vue)['\"]")
+COMPOSABLE = re.compile(r"from\s+['\"]([^'\"]*/composables/\w+)['\"]")
+ESTADO = re.compile(r"^\s*([A-Z][A-Z_]+):", re.M)
+
+
+def indexar(base):
+    """Devuelve {módulo: {rutas, llamadas, composables, stores}} recorriendo `base`; el módulo es su carpeta de primer nivel con subcarpeta."""
+    mapa = {}
+    for f in sorted(base.rglob("*")):
+        if f.suffix not in (".ts", ".vue") or "node_modules" in f.parts:
+            continue
+        rel = f.relative_to(base)
+        modulo = "/".join(rel.parts[:2]) if len(rel.parts) > 2 else rel.parts[0]
+        m = mapa.setdefault(modulo, {"rutas": [], "llamadas": [], "composables": [], "stores": []})
+        texto = f.read_text(errors="ignore")
+        if f.name.endswith("Routes.ts"):
+            bloques = texto.split("{")
+            previas = bloques[0].count("\n")
+            for bloque in bloques[1:]:
+                p, n, v = RUTA.search(bloque), NOMBRE.search(bloque), VISTA.search(bloque)
+                if p:
+                    m["rutas"].append({"path": p.group(1), "name": n and n.group(1), "vista": v and v.group(1),
+                                       "en": f"{rel}:{previas + 1 + bloque[:p.start()].count(chr(10))}"})
+                previas += bloque.count("\n")
+        if "composables" in rel.parts:
+            m["composables"].append(str(rel))
+        if "stores" in rel.parts:
+            m["stores"].append(str(rel))
+        for i, linea in enumerate(texto.splitlines(), 1):
+            for metodo, _, url in HTTP.findall(linea):
+                m["llamadas"].append(f"{metodo.upper()} {url}  {rel}:{i}")
+    return mapa
+
+
+def cargado(base):
+    """Índice de `base` desde la caché, rehecho si cambió el tamaño o la fecha de algún archivo."""
+    firma = hashlib.md5(("v2" + "".join(f"{f}{f.stat().st_mtime_ns}{f.stat().st_size}" for f in sorted(base.rglob("*.[tv][su]*"))
+                                if "node_modules" not in f.parts)).encode()).hexdigest()
+    caché = Path.home() / ".cache/webscope" / (hashlib.md5(str(base).encode()).hexdigest() + ".json")
+    if caché.exists():
+        datos = json.loads(caché.read_text())
+        if datos["firma"] == firma:
+            return datos["mapa"]
+    mapa = indexar(base)
+    caché.parent.mkdir(parents=True, exist_ok=True)
+    caché.write_text(json.dumps({"firma": firma, "mapa": mapa}))
+    return mapa
+
+
+def relativo(base, archivo, spec):
+    """Ruta de un import (`@/…` o relativo a `archivo`) relativa a `base`, o None si cae fuera."""
+    if spec.startswith("@/"):
+        destino = base.parent / spec[2:]
+    elif spec.startswith("."):
+        destino = archivo.parent / spec
+    else:
+        return None
+    try:
+        return str(destino.resolve().relative_to(base.resolve()))
+    except ValueError:
+        return None
+
+
+def resumen(base, archivo, texto, por_api):
+    """`useX: GET×3 POST` por cada composable que importa `texto` y hace llamadas HTTP."""
+    partes = []
+    for spec in dict.fromkeys(COMPOSABLE.findall(texto)):
+        rel = relativo(base, archivo, spec)
+        metodos = por_api.get(f"{rel}.ts", []) if rel else []
+        if metodos:
+            cuenta = {m: metodos.count(m) for m in dict.fromkeys(metodos)}
+            partes.append(Path(spec).name + ": " + " ".join(m + (f"×{n}" if n > 1 else "") for m, n in cuenta.items()))
+    return "; ".join(partes)
+
+
+def recorrido(base, mapa, modulo):
+    """Acciones con su condición, permisos, enlaces, pestañas con su componente y API, campos y estados de los archivos de `modulo`."""
+    # shortcut: no hereda el v-if de un <template> padre, un v-window anidado cierra la pestaña y los imports con llaves no dan ruta; mejorar si el recorrido en vivo falla por eso.
+    por_api = {}
+    for m in mapa.values():
+        for c in m["llamadas"]:
+            por_api.setdefault(c.rsplit("  ", 1)[1].rsplit(":", 1)[0], []).append(c.split()[0])
+    salida = []
+    for f in sorted((base / modulo).rglob("*")):
+        rel = f.relative_to(base)
+        if f.suffix == ".ts" and "Status" in f.name:
+            estados = list(dict.fromkeys(ESTADO.findall(f.read_text(errors="ignore"))))
+            if estados:
+                salida.append(f"estados {' '.join(estados)}  {rel}")
+        if f.suffix != ".vue":
+            continue
+        texto = f.read_text(errors="ignore")
+        ini, fin = texto.find("<template"), texto.rfind("</template>")
+        if ini < 0:
+            continue
+        plantilla = texto[ini:fin]
+        importa = {n: relativo(base, f, s) for n, s in IMPORTA.findall(texto)}
+        cierres = [c.start() for c in re.finditer(r"</v-window>", plantilla)]
+        lineas, campos, pestaña = [], [], None
+        for t in ETIQUETA.finditer(plantilla):
+            nombre, n = t.group(1), texto.count("\n", 0, ini + t.start()) + 1
+            atributos = list(ATRIBUTO.finditer(t.group(2)))
+            a = {x.group(1): x.group(2) if x.group(2) is not None else (x.group(3) or "") for x in atributos}
+            clic = next((v for k, v in a.items() if k.split(".")[0] in ("@click", "v-on:click")), None)
+            if pestaña and any(pestaña["desde"] < c < t.start() for c in cierres):
+                pestaña = None
+            if nombre == "v-window-item":
+                pestaña = {"desde": t.start(), "linea": n, "valor": a.get("value") or a.get(":value"), "comps": []}
+                lineas.append(pestaña)
+            elif pestaña and nombre[0].isupper():
+                pestaña["comps"].append(nombre)
+            if clic:
+                etiqueta = a.get(":title") or a.get("title") or a.get("icon") or t.group(3).strip()
+                lineas.append(f"accion {n} {clic}" + (f" si {a['v-if']}" if "v-if" in a else "") + (f" «{etiqueta}»" if etiqueta else ""))
+            lineas += [f"permiso {texto.count(chr(10), 0, ini + t.start(2) + x.start()) + 1} {k}={a[k]}" for x in atributos
+                       if "can(" in a[(k := x.group(1))] and not (clic and k == "v-if")]
+            if nombre == "AppLink":
+                lineas.append(f"enlace {n} {a.get(':to') or a.get('to')}")
+            if ":label" in a or "label" in a:
+                valor = a.get(":label") or a["label"]
+                i18n = re.search(r"\$?\bt\(\s*['\"]([^'\"]+)", valor)
+                clave = (i18n.group(1) if i18n else valor).split(".")[-1]
+                campos.append((n, clave + ("*" if "required" in a or "required" in a.get(":rules", "") else "")))
+        if campos:
+            lineas.append(f"campos {campos[0][0]} " + ", ".join(c for _, c in campos))
+        api = resumen(base, f, texto, por_api)
+        if lineas or api:
+            salida.append(f"### {rel}" + (f" [{api}]" if api else ""))
+        for linea in lineas:
+            if isinstance(linea, dict):
+                comps = []
+                for c in dict.fromkeys(linea["comps"]):
+                    destino = base / importa[c] if importa.get(c) else None
+                    api = resumen(base, destino, destino.read_text(errors="ignore"), por_api) if destino and destino.exists() else ""
+                    comps.append(c + (f" {importa[c]}" if destino else "") + (f" [{api}]" if api else ""))
+                linea = f"tab {linea['linea']} {linea['valor']} -> " + ", ".join(comps)
+            salida.append(linea)
+    return salida
+
+
+def patron(url):
+    """Regex de una URL del front: `${x}` vale un segmento y una `/` final admite el resto."""
+    cuerpo = "[^/]+".join(re.escape(p) for p in re.split(r"\$\{[^}]*\}", url))
+    return re.compile(cuerpo + (".+" if url.endswith("/") else "") + "$")
+
+
+def cobertura(mapa, filtro, captura):
+    """Llamadas del mapa de los módulos con `filtro` que aparecen en una captura (`método estado ruta ...` por línea)."""
+    hechas = [(p[0], p[2].split("?")[0]) for p in (l.split() for l in Path(captura).read_text().splitlines()) if len(p) > 2]
+    llamadas = [c.split()[:2] for n, m in mapa.items() if filtro in n for c in m["llamadas"]]
+    faltan = [f"{m} {u}" for m, u in llamadas if not any(h == m and patron(u).match(r) for h, r in hechas)]
+    return "\n".join([f"cobertura {len(llamadas) - len(faltan)}/{len(llamadas)} de «{filtro}» en {captura}. Sigue: ejercer las que faltan."]
+                     + [f"falta {f}" for f in faltan])
+
+
+def mostrar(mapa, filtro, receta, base=None):
+    """Texto con los módulos cuyo nombre contiene `filtro`; con `base`, el recorrido en lugar de la lista de llamadas."""
+    salida = [f"Frontend de «{filtro}»: rutas (pantallas), api (llamadas al backend), composables y stores. Sigue: mapa_back."]
+    for nombre, m in mapa.items():
+        if filtro not in nombre:
+            continue
+        salida.append(f"## {nombre}")
+        salida += [f"ruta {r['path']} ({r['name']}) -> {r['vista']}  {r['en']}" for r in m["rutas"]]
+        if base:
+            for g in sorted(Path(".claude/webscope/recorridos").glob(f"{nombre.replace('/', '-')}*.json")):
+                salida.append(f"recorrido guardado {g} ({len(json.loads(g.read_text()))} pasos): repítelo antes de explorar "
+                              f"con e2e_chrome --repetir {g.stem}")
+            salida.append(f"api total {len(m['llamadas'])} (cobertura = ejercidas / total)")
+            salida += recorrido(base, mapa, nombre)
+            continue
+        salida += [f"api {c}" for c in m["llamadas"]]
+        salida += [f"composable {c}" for c in m["composables"]] + [f"store {s}" for s in m["stores"]]
+        if receta:
+            sin_param = [r["path"] for r in m["rutas"] if ":" not in r["path"]]
+            salida.append("receta: correr(e2e_chrome, " + " ".join(sin_param) + ") da el JavaScript; pégalo en UNA llamada a "
+                          "javascript_tool, sin capturas ni esperas aparte. Captura solo si el JSON marca un problema.")
+    return "\n".join(salida) if len(salida) > 1 else f"sin módulo que contenga «{filtro}»"
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        sys.exit(__doc__)
+    base = Path(sys.argv[1]).resolve()
+    if "--cobertura" in sys.argv:
+        sys.exit(print(cobertura(cargado(base), sys.argv[2], sys.argv[sys.argv.index("--cobertura") + 1])))
+    print(mostrar(cargado(base), sys.argv[2], "--receta" in sys.argv, base if "--recorrido" in sys.argv else None))

webscope_adaptadores/web/chequeo-ui.js

@@ -0,0 +1,45 @@
+/* Chequeo de UI para pegar en `javascript_tool` (Claude in Chrome) o `page.evaluate`: devuelve solo los problemas, una línea cada uno. */
+(() => {
+  const problemas = [];
+  const visible = (el) => {
+    const r = el.getBoundingClientRect();
+    const s = getComputedStyle(el);
+    return r.width > 0 && r.height > 0 && s.visibility !== 'hidden' && s.display !== 'none' && s.opacity !== '0' &&
+      !el.closest('.v-overlay:not(.v-overlay--active)');
+  };
+  const corto = (t) => t.replace(/\s+/g, ' ').trim().slice(0, 40);
+  const hojas = [...document.body.querySelectorAll('*')].filter((el) => visible(el) && ![...el.children].some(visible) && corto(el.textContent || ''));
+
+  if (document.documentElement.scrollWidth > innerWidth + 1) {
+    problemas.push(`DESBORDE: scroll horizontal (${document.documentElement.scrollWidth}px en ${innerWidth}px)`);
+  }
+  for (const el of document.querySelectorAll('[class*="chip"],[class*="badge"]')) {
+    if (visible(el) && !/underlay|overlay/.test(String(el.className)) && !corto(el.textContent || '') && !el.querySelector('svg,img,i,[class*="icon"]')) {
+      problemas.push(`CHIP VACÍO: <${el.tagName.toLowerCase()} class="${String(el.className).slice(0, 40)}">`);
+    }
+  }
+  for (const el of hojas) {
+    const t = corto(el.textContent);
+    if (/^[a-z][a-z0-9_-]*(\.[a-z0-9_-]+){1,}$/i.test(t) && !/\.(com|org|net|io|co|png|jpg|svg|pdf)$/i.test(t)) problemas.push(`CLAVE SIN TRADUCIR: "${t}"`);
+    if (/^(undefined|null|NaN|\[object Object\]|Invalid Date)$/.test(t)) problemas.push(`VALOR CRUDO: "${t}"`);
+  }
+  const caja = hojas.slice(0, 400).map((el) => [el, el.getBoundingClientRect()]);
+  for (let i = 0; i < caja.length; i++) {
+    for (let j = i + 1; j < caja.length; j++) {
+      const [a, ra] = caja[i];
+      const [b, rb] = caja[j];
+      if (a.contains(b) || b.contains(a) || corto(a.textContent) === corto(b.textContent)) continue;
+      const w = Math.min(ra.right, rb.right) - Math.max(ra.left, rb.left);
+      const h = Math.min(ra.bottom, rb.bottom) - Math.max(ra.top, rb.top);
+      if (w > 2 && h > 2 && (w * h) / Math.min(ra.width * ra.height, rb.width * rb.height) > 0.3) {
+        problemas.push(`SOLAPA: "${corto(a.textContent)}" con "${corto(b.textContent)}"`);
+      }
+    }
+  }
+  for (const el of document.querySelectorAll('button,a[href],[role="button"]')) {
+    if (visible(el) && !corto(el.textContent || '') && !el.getAttribute('aria-label') && !el.getAttribute('title')) {
+      problemas.push(`BOTÓN SIN NOMBRE: <${el.tagName.toLowerCase()} class="${String(el.className).slice(0, 40)}">`);
+    }
+  }
+  return problemas.length ? problemas.slice(0, 30) : ['OK: sin problemas'];
+})();

webscope_adaptadores/web/e2e-rutas.js

@@ -0,0 +1,124 @@
+/* Cuerpo del e2e en Chrome: recorre RUTAS dentro de la app con el router (sin recargar, sin captura) y devuelve un JSON corto por ruta.
+ * `adaptadores/e2e_chrome.py` antepone `const RUTAS=[...]` y `const chequeo=...` y lo entrega listo para pegar en `javascript_tool`. */
+(async () => {
+  const enrutador = () => document.querySelector('#app')?.__vue_app__?.config.globalProperties.$router;
+  const est = window.__e2e || (window.__e2e = { red: [], consola: [], pendientes: 0 });
+  if (!est.listo) {
+    est.listo = true;
+    est.detalle = [];
+    const SECRETO = /pass|token|secret|clave|authorization|api[_-]?key/i;
+    const forma = (v, d = 0) => {
+      if (Array.isArray(v)) return { n: v.length, claves: v[0] && typeof v[0] === 'object' ? Object.keys(v[0]) : undefined };
+      if (v && typeof v === 'object') {
+        if (d > 1) return Object.keys(v);
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, SECRETO.test(k) ? '***' : forma(x, d + 1)]));
+      }
+      return typeof v === 'string' ? v.slice(0, 60) : v;
+    };
+    const resumen = (texto) => {
+      if (texto == null || texto === '') return null;
+      if (typeof texto !== 'string') return String(texto).slice(0, 40);
+      try { const s = JSON.stringify(forma(JSON.parse(texto))); return JSON.parse(s.length > 700 ? JSON.stringify(s.slice(0, 700)) : s); } catch { return texto.slice(0, 120); }
+    };
+    const rutaDe = (url) => String(url).replace(/^https?:\/\/[^/]+/, '').split('?')[0].slice(0, 70);
+    const fin = (estado, url, metodo, cuerpo, respuesta, t0) => {
+      est.pendientes--;
+      est.red.push([estado, rutaDe(url)]);
+      if (String(url).includes('/api/')) {
+        const d = { m: metodo, u: rutaDe(url), s: estado, ms: Math.round(performance.now() - t0), q: typeof cuerpo === 'string' ? resumen(cuerpo) : cuerpo ? '[binario]' : null, r: resumen(respuesta) };
+        // La primera escritura tras pulsar guardar lleva los campos del formulario: {etiqueta: [antes, después, visto]}.
+        if (metodo !== 'GET' && est.formPend) { d.f = est.formPend; est.formPend = null; }
+        est.detalle.push(d);
+      }
+    };
+    const f0 = window.fetch;
+    window.fetch = async (...a) => {
+      est.pendientes++;
+      const url = a[0]?.url || a[0];
+      const metodo = String(a[1]?.method || a[0]?.method || 'GET').toUpperCase();
+      const t0 = performance.now();
+      try { const r = await f0(...a); fin(r.status, url, metodo, a[1]?.body, await r.clone().text(), t0); return r; } catch (e) { fin('ERR', url, metodo, a[1]?.body, null, t0); throw e; }
+    };
+    const abrir = XMLHttpRequest.prototype.open;
+    const enviar = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function (m, u) { this._u = u; this._m = String(m).toUpperCase(); return abrir.apply(this, arguments); };
+    XMLHttpRequest.prototype.send = function (cuerpo) {
+      est.pendientes++;
+      const t0 = performance.now();
+      this.addEventListener('loadend', () => fin(this.status || 'ERR', this._u, this._m, cuerpo, this.responseType === 'json' ? JSON.stringify(this.response) : this.responseType === '' || this.responseType === 'text' ? this.responseText : '[binario]', t0));
+      return enviar.apply(this, arguments);
+    };
+    const err = console.error;
+    console.error = (...a) => { est.consola.push(a.map(String).join(' ').slice(0, 120)); err(...a); };
+    addEventListener('error', (e) => est.consola.push(String(e.message).slice(0, 120)));
+  }
+
+  est.chequeo ||= chequeo;
+  // El recorrido queda en la página como `window.__e2e.run(rutas)`: las llamadas siguientes no repiten este código.
+  est.run ||= async (RUTAS) => {
+    const estable = async () => {
+      let ultimo = performance.now();
+      const obs = new MutationObserver(() => { ultimo = performance.now(); });
+      obs.observe(document.body, { childList: true, subtree: true, characterData: true });
+      const limite = performance.now() + 8000;
+      while (performance.now() < limite) {
+        await new Promise((r) => setTimeout(r, 100));
+        if (est.pendientes <= 0 && performance.now() - ultimo > 500) break;
+      }
+      obs.disconnect();
+      return performance.now() < limite;
+    };
+
+    // Una línea por tipo de problema: «TIPO xN: primer ejemplo».
+    const resumir = (lineas) => {
+      const tipos = {};
+      for (const l of lineas) {
+        const k = l.split(':')[0];
+        (tipos[k] ||= { n: 0, ej: l.slice(k.length + 2, 90) }).n++;
+      }
+      return Object.entries(tipos).map(([k, v]) => (k === 'OK' ? 'OK' : `${k} x${v.n}: ${v.ej}`));
+    };
+
+    // El avance se guarda en sessionStorage: si la página se recarga a mitad (p. ej. Vite en desarrollo), repetir la llamada continúa.
+    const clave = 'e2e-webscope';
+    let guardado = null;
+    try { guardado = JSON.parse(sessionStorage.getItem(clave) || 'null'); } catch { /* sin almacenamiento */ }
+    if (!guardado || guardado.rutas !== RUTAS.join()) guardado = { rutas: RUTAS.join(), informe: [], enCurso: null };
+    const informe = guardado.informe;
+    const guardar = () => { try { sessionStorage.setItem(clave, JSON.stringify(guardado)); } catch { /* sin almacenamiento */ } };
+    for (const ruta of RUTAS) {
+      if (informe.some((i) => i.ruta === ruta)) continue;
+      const recargo = guardado.enCurso === ruta;
+      est.red.length = 0;
+      est.consola.length = 0;
+      const t0 = performance.now();
+      guardado.enCurso = ruta;
+      guardar();
+      if (!recargo) {
+        try { await enrutador().push(ruta); } catch (e) { informe.push({ ruta, error: String(e).slice(0, 100) }); guardado.enCurso = null; guardar(); continue; }
+      }
+      const quieta = await estable();
+      informe.push({
+        ruta,
+        en: location.pathname,
+        ms: Math.round(performance.now() - t0),
+        ...(recargo ? { recargoLaPagina: true } : {}),
+        ...(quieta ? {} : { sinEstabilizar: true }),
+        titulo: (document.querySelector('h1,h2,.v-toolbar-title')?.textContent || '').trim().slice(0, 40),
+        filas: document.querySelectorAll('tbody tr').length,
+        llamadas: est.red.length,
+        malas: est.red.filter(([s]) => s === 'ERR' || s >= 400),
+        consola: est.consola.slice(0, 5),
+        ui: resumir(est.chequeo()),
+      });
+      guardado.enCurso = null;
+      guardar();
+    }
+    try { sessionStorage.removeItem(clave); } catch { /* sin almacenamiento */ }
+    return JSON.stringify(informe);
+  };
+
+  if (RUTAS.length === 0) return JSON.stringify('capturando: haz el flujo y pide --detalle');
+  if (!enrutador()) return JSON.stringify({ error: 'sin router Vue en #app: abre primero una pantalla de la app' });
+  return await est.run(RUTAS);
+})()