Varnan-Tech/opendirectory

Bot de Actualización de Dependencias

Escanea paquetes desactualizados. Ejecuta una auditoría de seguridad. Obtiene registros de cambios. Resume cambios disruptivos. Abre un PR por grupo de riesgo.

---

Regla crítica: Solo actualiza los paquetes que el comando de outdated del gestor de paquetes realmente reporte. Nunca adivines ni inventes números de versión. Si no se puede obtener un registro de cambios, anota la falta en lugar de inventar contenido.

---

Paso 1: Verificación de Configuración

echo "GEMINI_API_KEY: ${GEMINI_API_KEY:+set}"
echo "GITHUB_TOKEN: ${GITHUB_TOKEN:-no establecido, obtención de registros de cambios limitada a 60/hora}"
gh auth status 2>/dev/null | head -1 || echo "gh: no autenticado"

Si falta GEMINI_API_KEY: Detente. Informa al usuario: "Se requiere GEMINI_API_KEY. Obténla en aistudio.google.com. Agrégala a tu archivo .env."

Si gh no está autenticado: Detente. Informa al usuario: "La CLI de GitHub debe estar autenticada. Ejecuta: gh auth login"

Detectar gestor(es) de paquetes:

ls package.json 2>/dev/null && echo "npm"
ls requirements.txt pyproject.toml 2>/dev/null && echo "pip"
ls Cargo.toml 2>/dev/null && echo "cargo"
ls go.mod 2>/dev/null && echo "go"
ls Gemfile 2>/dev/null && echo "ruby"

Si se encuentran varios, pregunta: "Encontrados [lista]. ¿Cuál debo escanear? (todos / npm / pip / cargo / go / ruby)"

---

Paso 2: Detectar Paquetes Desactualizados

npm:

npm outdated --json --long 2>/dev/null | python3 -c "
import sys, json
data = json.load(sys.stdin)
for name, info in data.items():
    print(json.dumps({'name': name, 'current': info.get('current','?'), 'latest': info.get('latest','?'), 'dep_type': info.get('type','dependencies')}))
"

pip:

pip list --outdated --format=json 2>/dev/null | python3 -c "
import sys, json
for p in json.load(sys.stdin):
    print(json.dumps({'name': p['name'], 'current': p['version'], 'latest': p['latest_version']}))
"

Cargo (Rust):

cargo outdated --format json 2>/dev/null || \
  cargo outdated 2>/dev/null | grep -v "^---" | tail -n +3 | head -30
# Si cargo-outdated no está instalado: cargo install cargo-outdated

Módulos Go:

go list -u -m -json all 2>/dev/null | python3 -c "
import sys, json
decoder = json.JSONDecoder()
buf = sys.stdin.read()
pos = 0
while pos < len(buf):
    try:
        obj, idx = decoder.raw_decode(buf, pos)
        if obj.get('Update'):
            print(json.dumps({'name': obj['Path'], 'current': obj['Version'], 'latest': obj['Update']['Version']}))
        pos += idx
    except: break
"

Ruby (Bundler):

bundle outdated --parseable 2>/dev/null | python3 -c "
import sys
for line in sys.stdin:
    parts = line.strip().split()
    if len(parts) >= 4:
        print('{\"name\":\"' + parts[0] + '\",\"current\":\"' + parts[3].strip('()') + '\",\"latest\":\"' + parts[1] + '\"}')
"

Si todo devuelve vacío: "Todos los paquetes están actualizados." Detente.

Indica el recuento antes de continuar: "Se encontraron X paquetes desactualizados."

---

Paso 3: Clasificar por Nivel de Riesgo

Analiza el incremento de versión (actual → última):

• MAJOR: cambia el primer dígito (1.x.x → 2.x.x)
• MINOR: cambia el segundo dígito (1.2.x → 1.3.x)
• PATCH: cambia el tercer dígito (1.2.3 → 1.2.4)

python3 -c "
def classify(current, latest):
    try:
        c = [int(x) for x in current.lstrip('v').split('.')[:3]]
        l = [int(x) for x in latest.lstrip('v').split('.')[:3]]
        if l[0] > c[0]: return 'major'
        if len(l) > 1 and len(c) > 1 and l[1] > c[1]: return 'minor'
        return 'patch'
    except: return 'unknown'
"

Indica el desglose: "Parche: X paquetes. Menor: Y paquetes. Mayor: Z paquetes."

---

Paso 4: Auditoría de Seguridad

Ejecuta un escaneo CVE antes de crear cualquier PR. Esto determina la urgencia.

npm:

npm audit --json 2>/dev/null | python3 -c "
import sys, json
d = json.load(sys.stdin)
vulns = d.get('vulnerabilities', {})
for pkg, info in vulns.items():
    sev = info.get('severity', 'unknown')
    via = [v.get('title','') for v in info.get('via',[]) if isinstance(v, dict)]
    print(f'  [{sev.upper()}] {pkg}: {via[0] if via else \"consulta npm audit\"}')
" 2>/dev/null || echo "No se encontraron vulnerabilidades o npm audit no está disponible"

pip:

pip-audit --format=json 2>/dev/null | python3 -c "
import sys, json
for vuln in json.load(sys.stdin):
    print(f'  [{vuln.get(\"aliases\",[\"\"])[0]}] {vuln[\"name\"]} {vuln[\"version\"]}: {vuln[\"description\"][:80]}')
" 2>/dev/null || echo "pip-audit no instalado. Ejecuta: pip install pip-audit"

Cargo:

cargo audit 2>/dev/null | grep -E "^(ID|Package|Severity|URL)" | head -30 \
  || echo "cargo-audit no instalado. Ejecuta: cargo install cargo-audit"

Regla de escalado: Si una actualización PATCH o MINOR tiene un CVE Crítico o Alto, promuévela a prioridad MAJOR: obtiene su propio PR y los detalles del CVE van en el cuerpo del PR.

Reporta los hallazgos de seguridad antes de continuar:

Auditoría de seguridad: [N] vulnerabilidades encontradas
  [CRÍTICO] lodash 4.17.19: Suplantación de prototipo (CVE-2021-23337)
  [ALTO] axios 0.21.1: Server-Side Request Forgery (CVE-2021-3749)

Si no hay vulnerabilidades: "Auditoría de seguridad: limpia."

---

Paso 5: Obtener Registros de Cambios

Para cada paquete, prueba las fuentes en orden. Detente en la primera que devuelva contenido.

Fuente 1: API de GitHub Releases

Obtén la URL del repositorio desde el registro:

# npm
curl -s "https://registry.npmjs.org/{PAQUETE}/latest" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('repository',{}); print(r.get('url','') if isinstance(r,dict) else str(r))"

# pip
curl -s "https://pypi.org/pypi/{PAQUETE}/json" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('info',{}).get('home_page','') or d.get('info',{}).get('project_urls',{}).get('Source',''))"

Obtén las últimas 5 releases:

AUTH_HEADER=""
[ -n "$GITHUB_TOKEN" ] && AUTH_HEADER="-H \"Authorization: Bearer $GITHUB_TOKEN\""
curl -s $AUTH_HEADER \
  "https://api.github.com/repos/{PROPIETARIO}/{REPO}/releases?per_page=5" \
  | python3 -c "import sys,json; [print(json.dumps({'tag':r.get('tag_name',''),'body':r.get('body','')[:1500]})) for r in json.load(sys.stdin)]"

Conserva solo las releases entre la versión actual y la última.

Fuente 2: README del registro npm (fallback)

curl -s "https://registry.npmjs.org/{PAQUETE}" \
  | python3 -c "import sys,json; print(json.load(sys.stdin).get('readme','')[:3000])"

Fuente 3: Descripción de PyPI (último recurso para pip)

curl -s "https://pypi.org/pypi/{PAQUETE}/json" \
  | python3 -c "import sys,json; print(json.load(sys.stdin).get('info',{}).get('description','')[:2000])"

Si ninguna fuente devuelve contenido: anota "No se encontró registro de cambios" y continúa.

---

Paso 6: Resumir con Gemini

Una solicitud por grupo de riesgo. Incluye los hallazgos de seguridad para cualquier paquete afectado por CVE:

cat > /tmp/deps-summary-request.json << 'ENDJSON'
{
  "system_instruction": {
    "parts": [{
      "text": "Eres un desarrollador que escribe una descripción de PR de GitHub para una actualización de dependencias. Dada una lista de paquetes que se actualizan y su contenido de registro de cambios en bruto, escribe un cuerpo de PR conciso en Markdown. Reglas: Para cada paquete, enumera solo lo que cambió entre la versión ANTERIOR y la NUEVA. Usa viñetas. Marca los cambios disruptivos con un prefijo BREAKING. Marca las correcciones de CVE con un prefijo SECURITY e incluye el ID del CVE. Mantén cada sección de paquete en un máximo de 3 a 5 viñetas. Si no se encontró un registro de cambios para un paquete, escribe 'No hay registro de cambios disponible.' No uses guiones largos. No uses estas palabras: seamless, robust, leverage, transform, innovative. Genera solo el cuerpo del PR en Markdown, sin comentarios."
    }]
  },
  "contents": [{
    "parts": [{
      "text": "PAQUETES_Y_REGISTROS_DE_CAMBIOS_AQUÍ"
    }]
  }],
  "generationConfig": {
    "temperature": 0.2,
    "maxOutputTokens": 2048
  }
}
ENDJSON

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @/tmp/deps-summary-request.json \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['candidates'][0]['content']['parts'][0]['text'])"

---

Paso 7: Crear PRs

Un PR por grupo de riesgo no vacío. Un PR por paquete para actualizaciones mayores (se requiere revisión individual).

1. Crear rama:

BRANCH="deps/{RIESGO}-updates-$(date +%Y%m%d)"
git checkout -b "$BRANCH"

2. Actualizar archivo de paquete:

npm:

npm install {paquete}@{versión_última} --save-exact
# devDependencies:
npm install {paquete}@{versión_última} --save-dev --save-exact

pip:

python3 -c "
import re, sys
pkg, version, filename = sys.argv[1], sys.argv[2], sys.argv[3]
with open(filename) as f: content = f.read()
pattern = rf'^{re.escape(pkg)}[>=<!\s].*$'
new_content = re.sub(pattern, f'{pkg}=={version}', content, flags=re.MULTILINE|re.IGNORECASE)
if new_content == content: new_content = content + f'\n{pkg}=={version}'
open(filename, 'w').write(new_content)
" "{PAQUETE}" "{ÚLTIMO}" "requirements.txt"

Cargo:

# Edita el campo de versión en Cargo.toml para el paquete, luego:
cargo update {paquete}

Go:

go get {módulo}@{versión_última}
go mod tidy

Ruby:

bundle update {nombre_gema}

3. Confirmar (commit):

git add -A
git commit -m "chore(deps): actualizar dependencias {RIESGO} $(date +%Y-%m-%d)"

4. Crear PR:

cat > /tmp/dep-pr-body-{RIESGO}.md << 'ENDMD'
CUERPO_DEL_PR_DE_GEMINI
ENDMD

gh pr create \
  --title "chore(deps): actualizar dependencias {RIESGO}" \
  --body-file /tmp/dep-pr-body-{RIESGO}.md \
  --label "dependencies" \
  --base main

Las actualizaciones mayores obtienen la etiqueta dependencies,breaking-change. Las actualizaciones que corrigen CVE obtienen la etiqueta dependencies,security.

Después de cada PR, vuelve a main: git checkout main

---

Paso 8: Modo de Diagnóstico

Desencadenante: Si algún comando de instalación falla a mitad de la ejecución, entra en Modo de Diagnóstico en lugar de detenerte.

Detecta el tipo de falla:

Patrón de error	Causa probable	Solución sugerida
peer dep conflict	Incompatibilidad de dependencias pares	Muestra el par conflictivo, sugiere el indicador --legacy-peer-deps o degradar
ERESOLVE	Conflicto de resolución npm	Ejecuta npm install --legacy-peer-deps solo para el paquete afectado
version not found	La versión no existe en el registro	Verifica el registro con npm view {pkg} versions
python requires	Incompatibilidad de versión de Python	Indica la versión de Python requerida, omite el paquete
cargo E0463	Incompatibilidad de edición de Rust	Marcar para revisión manual

Presenta un resumen de diagnóstico:

Instalación fallida para {paquete}: {tipo de error}
Causa probable: {explicación}
Solución sugerida: {comando o acción específica}
Paquetes restantes: continuando con {N} que tuvieron éxito.

No detengas toda la ejecución cuando falle un paquete. Continúa con los paquetes que tengan éxito.

---

Paso 9: Resumen de Salida

## Resumen de Actualización de Dependencias: [AAAA-MM-DD]

### Seguridad
[CRÍTICO] lodash: CVE-2021-23337 corregido en 4.17.21: PR #42
[ALTO] axios: CVE-2021-3749 corregido en 0.21.4: PR #42

| Nivel de Riesgo | Paquetes | PR |
|-----------------|----------|-----|
| Parche | lodash 4.17.19→4.17.21, axios 0.21.1→0.21.4 | #42 |
| Menor | express 4.17.1→4.18.2 | #43 |
| Mayor | react 17.0.2→18.2.0 | #44 |

PRs abiertos: 3

Paquetes sin registro de cambios: some-obscure-pkg (sin repositorio GitHub en el registro)
Fallos de instalación: ninguno

Próxima acción: Revisa los PRs de actualizaciones mayores individualmente antes de fusionar.