Varnan-Tech/opendirectory

De Descargas npm a Prospectos

Toma una lista de paquetes npm. Obtén 12 semanas de datos de descarga. Calcula la velocidad de crecimiento. Enriquece perfiles de mantenedores. Genera un informe clasificado por paquete en crecimiento con señales de contacto y un mensaje de alcance.

---

Regla crítica: Cada cifra de descarga de paquete en el resultado debe provenir de la respuesta de la API de npm. Cada usuario de GitHub o nombre de usuario de Twitter del mantenedor debe provenir de la respuesta de la API de GitHub, no debe adivinarse a partir del nombre de usuario de npm. Si la API de GitHub no devolvió un campo twitter_username, escribe "no encontrado en GitHub", no inventes uno.

---

Errores Comunes

El agente querrá...	Por qué está mal
Obtener perfiles de GitHub para cada paquete en la lista	El límite de velocidad es de 60 solicitudes/hora sin token. Enriquecer paquetes estables o en declive desperdicia el presupuesto antes de llegar a los que están creciendo. Solo obtén perfiles para paquetes en crecimiento explosivo y en observación.
Clasificar paquetes por descargas semanales brutas	Las descargas brutas favorecen a React y lodash, que no son prospectos. Un paquete que pasa de 1K a 8K/semana es más procesable que React con 50M/semana. La puntuación de velocidad es la señal.
Omitir la codificación de URL para paquetes con ámbito	@org/pkg sin codificar provoca un error 404 de la API de npm. Codifica @ como %40 y / como %2F para cada nombre de paquete con ámbito.
Detener la habilidad cuando se alcanza el límite de velocidad de GitHub	Degrada con gracia. Presenta la tabla de clasificación de velocidad con datos de npm, omite los enriquecimientos restantes de GitHub y agrega una bandera a data_quality_flags. No abortes.
Escribir mensajes de alcance sin nombrar el paquete específico	Los mensajes genéricos como "Vi tu proyecto" quedan sin respuesta. Cada mensaje de alcance debe nombrar el paquete, sus cifras de crecimiento y una conexión específica con el contexto que el usuario proporcionó.
Incluir paquetes por debajo de 500 descargas semanales como prospectos	Por debajo de 500/semana es ruido. El mantenedor aún no tiene una audiencia significativa. Marca como "demasiado temprano" pero no lo presentes como prospecto.

---

Paso 1: Verificación de Configuración

echo "GITHUB_TOKEN: ${GITHUB_TOKEN:-no configurado, se aplica límite de velocidad sin autenticación (60 solicitudes/hora, suficiente para ~10 paquetes)}"

Si GITHUB_TOKEN no está configurado: Continúa. Informa al usuario: "GITHUB_TOKEN no está configurado. El enriquecimiento de GitHub está limitado a ~10 paquetes antes de alcanzar el límite de velocidad. Agrega un token en github.com/settings/tokens (no se necesitan alcances)."

No hay claves requeridas. La API de npm y el registro de npm son completamente públicos y no requieren autenticación.

---

Paso 2: Recopilar Entrada

Recopila de la conversación:

• Uno o más nombres de paquetes npm (sin ámbito como esbuild, o con ámbito como @hono/hono)
• Opcional: una cadena corta de contexto del producto (se usa para personalizar los mensajes de alcance)

Si el usuario proporciona una URL de npmjs.com, extrae solo el nombre del paquete. Conserva el nombre completo con ámbito, incluidos @ y el prefijo de la organización: la codificación se maneja en el Paso 3.

Si no se proporcionan paquetes: Pregunta: "¿Qué paquetes npm te gustaría analizar? Proporciona los tuyos, los de la competencia o una combinación. Ejemplo: esbuild, @hono/hono, zod, valibot"

python3 << 'PYEOF'
import json, sys

packages_raw = "AQUÍ_LOS_PAQUETES"  # separados por comas o nuevas líneas
product_context = "AQUÍ_EL_CONTEXTO"  # opcional, puede ser una cadena vacía

packages = [p.strip() for p in packages_raw.replace("\n", ",").split(",") if p.strip()]
if not packages:
    print("ERROR: No se proporcionaron paquetes.")
    sys.exit(1)

print(f"Paquetes a analizar: {len(packages)}")
for p in packages:
    print(f"  {p}")

with open("/tmp/npl-input.json", "w") as f:
    json.dump({"packages": packages, "product_context": product_context}, f)
PYEOF

---

Paso 3: Obtener Datos de Descarga de 12 Semanas

Usa el script independiente si está disponible: maneja los Pasos 3, 4 y 5 en una sola llamada, por lo que no necesitas ejecutar los bloques de código en línea a continuación.

# Verifica si el script existe
ls scripts/fetch.py 2>/dev/null && echo "script disponible" || echo "script no encontrado"

Si el script está disponible, ejecútalo directamente y salta al Paso 6:

python3 scripts/fetch.py AQUÍ_LOS_PAQUETES --context "AQUÍ_EL_CONTEXTO" --output /tmp/npl-script-out.json

Luego carga la salida en el formato enriquecido que espera el Paso 6:

python3 << 'PYEOF'
import json

out = json.load(open("/tmp/npl-script-out.json"))
# La salida del script tiene un arreglo results: se divide en scored y enriched para los Pasos 6-8
enriched = [r for r in out["results"] if "profile" in r]
scored = out["results"]
json.dump(scored, open("/tmp/npl-scored.json", "w"), indent=2)
json.dump(enriched, open("/tmp/npl-enriched.json", "w"), indent=2)
json.dump({"packages": [r["package"] for r in scored], "product_context": out.get("product_context", "")},
          open("/tmp/npl-input.json", "w"), indent=2)
print(f"Cargados {len(scored)} paquetes | {out['breakout_count']} en crecimiento explosivo | {out['watching_count']} en observación")
PYEOF

Si el script no está disponible, ejecuta el código en línea a continuación.

Obtén datos de descarga diaria para cada paquete desde la API de Descargas de npm. Agrega en bloques semanales.

python3 << 'PYEOF'
import json, urllib.request, sys, time
from datetime import datetime, timedelta, timezone
from collections import defaultdict
import urllib.parse

data = json.load(open("/tmp/npl-input.json"))
packages = data["packages"]

end_date = datetime.now(tz=timezone.utc)
start_date = end_date - timedelta(weeks=13)  # semana extra como margen para semanas parciales
start_str = start_date.strftime("%Y-%m-%d")
end_str = end_date.strftime("%Y-%m-%d")

results = []
failed = []

for pkg in packages:
    # Codificar URL para paquetes con ámbito: @ -> %40, / -> %2F
    encoded = pkg.replace("@", "%40").replace("/", "%2F")
    url = f"https://api.npmjs.org/downloads/range/{start_str}:{end_str}/{encoded}"

    try:
        req = urllib.request.Request(url, headers={"User-Agent": "npm-downloads-to-leads/1.0"})
        with urllib.request.urlopen(req, timeout=20) as resp:
            raw = json.loads(resp.read())

        # Agregar diario a semanal por semana ISO
        weekly = defaultdict(int)
        for entry in raw.get("downloads", []):
            day = datetime.strptime(entry["day"], "%Y-%m-%d")
            week_key = day.isocalendar()[:2]  # (año, número_de_semana)
            weekly[week_key] += entry["downloads"]

        weeks = [v for k, v in sorted(weekly.items())]
        # Tomar los últimos 12 bloques semanales completos
        weeks = weeks[-12:]

        results.append({
            "package": pkg,
            "weeks": weeks,
            "total_weeks": len(weeks),
            "current_weekly": weeks[-1] if weeks else 0,
            "status": "ok"
        })
        print(f"  {pkg}: {len(weeks)} semanas, última semana {weeks[-1]:,} descargas")

    except urllib.error.HTTPError as e:
        if e.code == 404:
            failed.append(pkg)
            results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": "not_found"})
            print(f"  {pkg}: NO ENCONTRADO (404) -- se omitirá")
        else:
            failed.append(pkg)
            results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": f"error_{e.code}"})
            print(f"  {pkg}: error HTTP {e.code}")
    except Exception as e:
        failed.append(pkg)
        results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": f"error"})
        print(f"  {pkg}: falló la obtención ({e})")

    time.sleep(0.2)  # limitación de velocidad suave

json.dump(results, open("/tmp/npl-download-data.json", "w"), indent=2)
print(f"\nObtención completa. Correctos: {len(results) - len(failed)} | Fallidos/No encontrados: {len(failed)}")
if failed:
    print(f"Omitidos: {', '.join(failed)}")
PYEOF

Si todos los paquetes devuelven 404 o errores: Detente. Dile al usuario: "No se pudieron obtener datos de descarga. Verifica que los nombres de los paquetes sean correctos y existan en npmjs.com. Los paquetes con ámbito deben incluir el nombre completo: @org/package."

---

Paso 4: Calcular Puntuaciones de Velocidad

Sin llamada a API. Python puro. Calcula la puntuación de velocidad, la tasa de crecimiento y clasifica cada paquete.

python3 << 'PYEOF'
import json

raw_results = json.load(open("/tmp/npl-download-data.json"))
scored = []

for item in raw_results:
    pkg = item["package"]
    weeks = item["weeks"]
    status = item["status"]

    if status != "ok" or len(weeks) < 4:
        scored.append({**item, "velocity_score": 0, "growth_pct": 0, "tier": "insufficient_data",
                       "recent_4_avg": 0, "prior_4_avg": 0})
        continue

    recent_4 = sum(weeks[-4:]) / 4
    prior_4 = sum(weeks[-8:-4]) / max(len(weeks) - 4, 1) if len(weeks) >= 8 else sum(weeks[:4]) / max(len(weeks[:4]), 1)
    recent_2 = sum(weeks[-2:]) / 2
    mid_2 = sum(weeks[-4:-2]) / 2 if len(weeks) >= 4 else recent_2

    growth_ratio = recent_4 / max(prior_4, 1)
    acceleration = recent_2 / max(mid_2, 1)
    growth_pct = round((growth_ratio - 1) * 100, 1)

    # Factor de punto óptimo: 500-500K descargas semanales
    if recent_4 < 500:
        noise_factor = max(recent_4 / 500, 0.1)
    elif recent_4 > 500_000:
        noise_factor = max(500_000 / recent_4, 0.1)
    else:
        noise_factor = 1.0

    velocity_score = round(growth_ratio * acceleration * noise_factor * 100, 1)

    # Clasificar
    if velocity_score > 80 and 500 < recent_4 < 500_000 and growth_ratio >= 1.5:
        tier = "breakout"
    elif velocity_score > 40 and recent_4 >= 500 and growth_ratio >= 1.2:
        tier = "watching"
    elif recent_4 < 500:
        tier = "too_early"
    elif recent_4 >= 500_000:
        tier = "established"
    else:
        tier = "steady"

    scored.append({
        **item,
        "velocity_score": velocity_score,
        "growth_pct": growth_pct,
        "recent_4_avg": round(recent_4),
        "prior_4_avg": round(prior_4),
        "tier": tier
    })

# Ordenar por velocity_score descendente
scored.sort(key=lambda x: x["velocity_score"], reverse=True)

json.dump(scored, open("/tmp/npl-scored.json", "w"), indent=2)

breakout = [p for p in scored if p["tier"] == "breakout"]
watching = [p for p in scored if p["tier"] == "watching"]
too_early = [p for p in scored if p["tier"] == "too_early"]

print(f"Puntuación de velocidad completa:")
print(f"  EN CRECIMIENTO EXPLOSIVO: {len(breakout)}")
print(f"  EN OBSERVACIÓN: {len(watching)}")
print(f"  ESTABLE/ESTABLECIDO: {len([p for p in scored if p['tier'] in ('steady','established')])}")
print(f"  DEMASIADO TEMPRANO (<500/semana): {len(too_early)}")
print()
for p in scored[:10]:
    print(f"  {p['tier'].upper():12} {p['package']:30} score={p['velocity_score']:6.1f}  "
          f"{p['recent_4_avg']:>8,}/sem  crecimiento={p['growth_pct']:+.0f}%")

# Detener si no hay nada que valga la pena analizar
if not breakout and not watching:
    all_too_early = all(p["tier"] in ("too_early", "insufficient_data") for p in scored)
    if all_too_early:
        print("\nERROR: Todos los paquetes están por debajo del umbral de 500 descargas semanales para un análisis de velocidad confiable.")
        print("Prueba con paquetes que tengan más adopción por parte de la comunidad.")
        import sys; sys.exit(1)
PYEOF

Si todos los paquetes están por debajo de 500/semana: Detente con el mensaje anterior.

---

Paso 5: Obtener Perfiles de Mantenedores

Solo para paquetes en crecimiento explosivo y en observación. Obtén metadatos del registro de npm, luego perfiles de usuario de GitHub.

python3 << 'PYEOF'
import json, urllib.request, re, os, time

scored = json.load(open("/tmp/npl-scored.json"))
token = os.environ.get("GITHUB_TOKEN", "")

gh_headers = {"Accept": "application/vnd.github+json", "User-Agent": "npm-downloads-to-leads/1.0"}
if token:
    gh_headers["Authorization"] = f"Bearer {token}"

target_packages = [p for p in scored if p["tier"] in ("breakout", "watching")]
print(f"Obteniendo perfiles para {len(target_packages)} paquetes (crecimiento explosivo + en observación)...")

gh_rate_remaining = 999
enriched = []

for item in target_packages:
    pkg = item["package"]
    profile = {"package": pkg, "npm_maintainers": [], "description": "", "keywords": [],
               "github_owner": None, "github_repo": None, "github_users": [], "npm_homepage": ""}

    # --- registro npm ---
    encoded = pkg.replace("@", "%40").replace("/", "%2F")
    reg_url = f"https://registry.npmjs.org/{encoded}"
    try:
        req = urllib.request.Request(reg_url, headers={"User-Agent": "npm-downloads-to-leads/1.0"})
        with urllib.request.urlopen(req, timeout=20) as resp:
            reg = json.loads(resp.read())

        profile["description"] = reg.get("description", "")
        profile["keywords"] = (reg.get("keywords") or [])[:6]
        profile["npm_homepage"] = reg.get("homepage", "")
        profile["npm_maintainers"] = [m.get("name", "") for m in reg.get("maintainers", []) if m.get("name")]

        # Extraer propietario de GitHub de la URL del repositorio
        repo_field = reg.get("repository") or {}
        if isinstance(repo_field, dict):
            repo_url = repo_field.get("url", "")
        else:
            repo_url = str(repo_field)
        gh_match = re.search(r"github\.com[/:]([^/]+)/([^/.]+)", repo_url)
        if gh_match:
            profile["github_owner"] = gh_match.group(1)
            profile["github_repo"] = gh_match.group(2).rstrip(".git")

        print(f"  {pkg}: registro OK | mantenedores={profile['npm_maintainers'][:3]} | "
              f"github_owner={profile['github_owner']}")
    except Exception as e:
        print(f"  {pkg}: falló la obtención del registro ({e})")

    time.sleep(0.1)

    # --- perfiles de usuario de GitHub ---
    candidates = []
    if profile["github_owner"]:
        candidates.append(profile["github_owner"])
    # También probar nombres de usuario de mantenedores npm (a menudo coinciden con GitHub)
    for m in profile["npm_maintainers"][:2]:
        if m and m not in candidates:
            candidates.append(m)

    for username in candidates[:3]:
        if gh_rate_remaining <= 5:
            print(f"  Límite de velocidad de GitHub bajo ({gh_rate_remaining} restantes) -- omitiendo {username}")
            break

        gh_url = f"https://api.github.com/users/{username}"
        req = urllib.request.Request(gh_url, headers=gh_headers)
        try:
            with urllib.request.urlopen(req, timeout=15) as resp:
                gh_rate_remaining = int(resp.headers.get("X-RateLimit-Remaining", 0))
                user_data = json.loads(resp.read())

            gh_profile = {
                "login": user_data.get("login", ""),
                "name": user_data.get("name") or "",
                "twitter_username": user_data.get("twitter_username") or "",
                "bio": user_data.get("bio") or "",
                "location": user_data.get("location") or "",
                "html_url": user_data.get("html_url", ""),
                "public_repos": user_data.get("public_repos", 0),
                "followers": user_data.get("followers", 0)
            }
            profile["github_users"].append(gh_profile)
            print(f"    GitHub: {username} -> seguidores={gh_profile['followers']} twitter={gh_profile['twitter_username']}")

        except urllib.error.HTTPError as e:
            if e.code == 404:
                print(f"    GitHub: {username} no encontrado (404)")
            elif e.code == 403:
                print(f"    GitHub: límite de velocidad alcanzado (403) -- degradando")
                gh_rate_remaining = 0
                break
            else:
                print(f"    GitHub: {username} error HTTP {e.code}")
        except Exception as e:
            print(f"    GitHub: {username} falló ({e})")

        time.sleep(0.15)

    enriched.append({
        **item,
        "profile": profile
    })
    print()

json.dump(enriched, open("/tmp/npl-enriched.json", "w"), indent=2)
print(f"Enriquecimiento de perfil completo. {len(enriched)} paquetes procesados.")

# Registrar banderas de calidad
flags = []
if gh_rate_remaining <= 5:
    flags.append("github_rate_limit_exhausted")
if any(p["profile"]["github_users"] == [] for p in enriched if p["tier"] == "breakout"):
    flags.append("breakout_packages_without_github_follow")

if flags:
    json.dump(flags, open("/tmp/npl-data-quality-flags.json", "w"))
    print(f"Banderas de calidad de datos: {flags}")
PYEOF

Consejo sobre el presupuesto de la API: El límite de velocidad sin autenticación de GitHub es de 60 solicitudes por hora, suficiente para aproximadamente 10 paquetes (3 solicitudes de perfil cada uno). Con GITHUB_TOKEN, el límite es de 5000 solicitudes por hora, suficiente para cualquier lista de paquetes. Verifica la configuración de tu token en el Paso 1.

---

Paso 6: Generar Informe de Prospectos

Solo para paquetes en crecimiento explosivo. Compila un informe breve para cada uno.

python3 << 'PYEOF'
import json

enriched = json.load(open("/tmp/npl-enriched.json"))
input_data = json.load(open("/tmp/npl-input.json"))
product_context = input_data.get("product_context", "")

breakout = [p for p in enriched if p["tier"] == "breakout"]

if not breakout:
    print("No se encontraron paquetes en crecimiento explosivo.")
    print(f"En observación: {len([p for p in enriched if p['tier'] == 'watching'])}")
    print("Pasa al Paso 8 para generar un informe de paquetes en observación.")
    import sys; sys.exit(0)

print(f"Generando informes para {len(breakout)} paquetes en crecimiento explosivo...")
print(f"\n{'='*70}")
print(f"{'INFORME DE PROSPECCIÓN DE PAQUETES npm':^70}")
print(f"{'='*70}")

for i, item in enumerate(breakout, 1):
    p = item["package"]
    profile = item["profile"]

    print(f"\n{'─'*70}")
    print(f"  #{i}  {p}")
    print(f"{'─'*70}")
    print(f"  Descripción:     {profile['description'][:100]}")
    print(f"  Crecimiento:     {item['growth_pct']:+.0f}% (promedio 4 semanas: {item['recent_4_avg']:,} -> {item['current_weekly']:,}/sem)")
    print(f"  Puntuación:      {item['velocity_score']}")
    print(f"  Palabras clave:  {', '.join(profile['keywords'][:5])}")
    print(f"  Página de inicio: {profile['npm_homepage'][:60]}")

    print(f"\n  -- MANTENEDORES npm --")
    for m in profile['npm_maintainers'][:4]:
        print(f"    • {m}")

    print(f"\n  -- SEÑALES DE GITHUB --")
    for gh in profile["github_users"][:3]:
        name = gh["name"] or gh["login"]
        tw = gh.get("twitter_username", "") or "no encontrado en GitHub"
        print(f"    Usuario: {gh['login']} ({name})")
        print(f"    URL:     {gh['html_url']}")
        print(f"    Twitter: {tw}")
        print(f"    Seguidores: {gh['followers']} | Repos: {gh['public_repos']}")
        if gh.get("bio"):
            print(f"    Bio:     {gh['bio'][:100]}")
        if gh.get("location"):
            print(f"    Ubicación: {gh['location']}")

    # --- Mensaje de alcance ---
    if profile["github_users"]:
        gh = profile["github_users"][0]
        name = gh["name"] or gh["login"]
    else:
        name = profile["npm_maintainers"][0] if profile["npm_maintainers"] else "allí"

    growth_num = f"{item['growth_pct']:+.0f}%"
    weekly_num = f"{item['current_weekly']:,}"

    msg = f"Hola {name},\n\n"
    msg += f"He estado siguiendo {p}, que ha crecido {growth_num} en las últimas semanas "
    msg += f"a {weekly_num} descargas semanales."
    if product_context:
        msg += f" Creo que hay una fuerte alineación con {product_context}."
    msg += "\n\n"
    msg += f"Me encantaría aprender más sobre tu trabajo y ver si hay formas de colaborar. "
    msg += f"¿Estarías abierto a una charla rápida?"

    print(f"\n  -- MENSAJE DE ALCANCE SUGERIDO --")
    for line in msg.split("\n"):
        print(f"    {line}")
    print(f"  {'─'*70}")

---

Paso 7: Datos de Paquetes en Observación

Los paquetes en observación no son prospectos inmediatos, pero pueden convertirse en la próxima semana. Se muestran de forma más compacta.

python3 << 'PYEOF'
import json

enriched = json.load(open("/tmp/npl-enriched.json"))
watching = [p for p in enriched if p["tier"] == "watching"]

if not watching:
    print("No hay paquetes en observación.")
    import sys; sys.exit(0)

print(f"\n{'='*70}")
print(f"{'PAQUETES EN OBSERVACIÓN (posibles futuros prospectos)':^70}")
print(f"{'='*70}")

for item in watching:
    p = item["package"]
    profile = item["profile"]
    print(f"\n  {p}")
    print(f"    Crecimiento:   {item['growth_pct']:+.0f}% | Puntuación: {item['velocity_score']}")
    print(f"    Descargas:     {item['recent_4_avg']:,}/semana (última: {item['current_weekly']:,})")
    print(f"    Mantenedores:  {', '.join(profile['npm_maintainers'][:3])}")
    if profile["github_users"]:
        tw = profile["github_users"][0].get("twitter_username", "") or "no encontrado en GitHub"
        print(f"    Señal de Twitter: {tw}")

---

Paso 8: Resumen y Próximos Pasos

Siempre resume de esta manera. Incluye una tabla de clasificación, banderas de calidad y sugerencia de seguimiento.

python3 << 'PYEOF'
import json

scored = json.load(open("/tmp/npl-scored.json"))
enriched = json.load(open("/tmp/npl-enriched.json"))

try:
    flags = json.load(open("/tmp/npl-data-quality-flags.json"))
except FileNotFoundError:
    flags = []

breakout = [p for p in scored if p["tier"] == "breakout"]
watching = [p for p in scored if p["tier"] == "watching"]
steady = [p for p in scored if p["tier"] in ("steady", "established")]
too_early = [p for p in scored if p["tier"] == "too_early"]
insufficient = [p for p in scored if p["tier"] == "insufficient_data"]

print(f"\n{'='*70}")
print(f"{'RESUMEN':^70}")
print(f"{'='*70}")
print(f"  Crecimiento explosivo:  {len(breakout)}")
print(f"  En observación:         {len(watching)}")
print(f"  Estable/Establecido:    {len(steady)}")
print(f"  Demasiado temprano:     {len(too_early)}")
print(f"  Datos insuficientes:    {len(insufficient)}")
print()

if flags:
    print(f"  Banderas de calidad de datos:")
    for f in flags:
        print(f"    ⚠️  {f}")
    print()

print(f"  Tabla de clasificación de velocidad (top 10):")
print(f"  {'Paquete':<30} {'Velocidad':<10} {'Crecimiento':<12} {'Semanal':<10} {'Nivel':<15}")
print(f"  {'─'*30} {'─'*10} {'─'*12} {'─'*10} {'─'*15}")
for p in scored[:10]:
    print(f"  {p['package']:<30} {p['velocity_score']:<10.1f} {p['growth_pct']:+.0f}%{'':<9} {p['current_weekly']:<10,} {p['tier']:<15}")

print(f"\n  {'─'*70}")
print(f"  Próximos pasos sugeridos:")
if breakout:
    print(f"    • Ejecutar campaña de alcance para los {len(breakout)} prospectos en crecimiento explosivo usando los mensajes anteriores")
if watching:
    print(f"    • Monitorear los {len(watching)} paquetes en observación — reprogramar análisis en 2 semanas")
print(f"    • Agregar más paquetes para un alcance más amplio descomponiendo repositorios de GitHub competidores")
print(f"    • Configurar GITHUB_TOKEN para un enriquecimiento completo en el próximo análisis")
PYEOF

---

Variables de entorno:

• GITHUB_TOKEN (opcional, pero recomendado) — Token de acceso personal de GitHub. Establécelo en tu archivo .env o variable de entorno del agente. Crea uno en github.com/settings/tokens (no se necesitan alcances de repositorio).