Graphify — el mapa, el cerebro y el detective de tu código

Quiero instalar Graphify en este proyecto y dejarlo funcionando bien con Claude Code. Hazlo paso a paso:

1. Verifica que Python 3.10+ esté disponible. Si no, dímelo antes de seguir.
2. Si tengo `uv` instalado, usa `uv tool install graphifyy && graphify install`. Si no, intenta `pipx install graphifyy && graphify install`. Si tampoco, cae en `pip install graphifyy && graphify install`. Avísame cuál usaste.
3. Corre `/graphify .` en la raíz de este proyecto para construir el primer grafo. Mientras corre, explícame qué está haciendo (extracción AST → subagentes Claude para docs → detección de comunidades Leiden).
4. Cuando termine, abre `graphify-out/GRAPH_REPORT.md` y dame:
   - Los 5 god nodes (los archivos con más conexiones).
   - Las 3 comunidades más grandes.
   - Las conexiones sorprendentes que detectó.
5. Crea o actualiza `.graphifyignore` excluyendo `node_modules`, `.next`, `dist`, `build`, `.venv` y cualquier carpeta de assets pesados que detectes en el repo.
6. Corre `graphify hook install` para que el grafo se reconstruya automáticamente cuando haga commits o cambie de rama.

Cuando todo esté listo, confirma que el archivo `graphify-out/AGENTS.md` existe y que la sección de Graphify aparece en `CLAUDE.md`. A partir de aquí, antes de hacer Glob o Grep, lee primero `graphify-out/GRAPH_REPORT.md`.

Agrega esta regla a mi `CLAUDE.md` (créalo si no existe):

## Regla Graphify (lectura obligatoria antes de buscar)

Antes de hacer Glob, Grep o Read sobre múltiples archivos, primero:

1. Verifica que `graphify-out/GRAPH_REPORT.md` exista. Si no, sugiéreme correr `/graphify .` y espera mi confirmación.
2. Si existe, léelo primero. Identifica si la respuesta a mi pregunta ya está ahí (god nodes, comunidades, suggested questions).
3. Si la pregunta es sobre relaciones entre módulos, usa `/graphify query "..."` antes de abrir archivos.
4. Si es sobre cómo se conectan dos cosas, usa `/graphify path "NodeA" "NodeB"`.
5. Solo después, si el grafo no responde, abre archivos.

Esta regla aplica salvo que yo te diga explícitamente "ignora el grafo" o "abre directo el archivo X".

Acabo de recibir una carpeta de un cliente nuevo y necesito entregarle un diagnóstico de su código en menos de una hora. La carpeta está en `./cliente-acme`.

Hazme una auditoría express con Graphify:

1. Corre `/graphify ./cliente-acme --mode deep`. Mientras se construye, no abras archivos a mano.
2. Cuando termine, lee `graphify-out/GRAPH_REPORT.md` completo.
3. Genera un reporte ejecutivo en español que incluya:
   - **Resumen en 3 líneas**: qué hace este código, en qué stack está, qué tan grande es.
   - **God nodes**: los 5 archivos más conectados. Por cada uno, explica en una oración qué hace y por qué es crítico.
   - **Riesgos arquitectónicos**: módulos huérfanos, dependencias circulares, comunidades aisladas que no se conectan a nada.
   - **Deuda técnica visible**: archivos enormes, funciones con muchas dependencias entrantes (acoplamiento alto), comentarios TODO/FIXME que aparezcan en nodos rationale.
   - **Próximos pasos**: 3 movimientos concretos que el cliente debería priorizar.
4. Adjunta al reporte el link relativo a `graphify-out/graph.html` para que el cliente lo abra en su navegador.
5. Estima el tiempo que llevaría refactorizar lo más urgente.

Si encuentras algo que requiera abrir un archivo específico para confirmar, dímelo antes de abrirlo. No quiero quemar tokens leyendo código que el grafo ya respondió.

Llegué a un repositorio que tiene tres años de historia y nadie del equipo original sigue activo. Necesito entenderlo en una tarde para empezar a contribuir mañana.

El repo está en la carpeta actual. Usa Graphify como mi guía de tour:

1. Si no existe `graphify-out/`, corre `/graphify . --mode deep`. Si existe, corre `/graphify . --update` para refrescar archivos cambiados.
2. Lee `GRAPH_REPORT.md` completo y muéstrame:
   - El diagrama mental: cuántos módulos grandes tiene (comunidades), qué hace cada uno en una oración.
   - El "punto de entrada" probable: el archivo más conectado que parezca el bootstrap, server, app o main.
   - 3 funciones críticas que cualquier feature nueva probablemente toque, con su descripción.
3. Usa `/graphify explain "<nombre>"` para los 3 god nodes principales y dame una explicación en lenguaje plano.
4. Construye una ruta de aprendizaje recomendada: si tuviera 4 horas, qué leería primero, qué después, qué dejaría para el final.
5. Dame 5 preguntas que debería hacerle al equipo (si pudiera) basadas en gaps que detectes en el grafo (rationale ausente, conexiones AMBIGUAS, comunidades sospechosamente desconectadas).

Importante: no abras archivos hasta que el grafo te dé el "qué leer primero". Quiero que el grafo manda, no la curiosidad.

Tengo una pregunta de arquitectura sobre este repo y quiero que el grafo la responda antes de abrir cualquier archivo.

Mi pregunta: **{ESCRIBE TU PREGUNTA AQUÍ — ej. "¿cómo se valida un usuario antes de que llegue al endpoint de pagos?"}**

Por favor:

1. Confirma que `graphify-out/graph.json` existe. Si no, dime exactamente qué correr.
2. Llama a `/graphify query "<mi pregunta literal>"` y muéstrame la respuesta cruda.
3. Si la respuesta menciona archivos o funciones, llama a `/graphify path` entre los nodos relevantes para confirmar que sí se conectan.
4. Resume en 3 viñetas la respuesta final con los archivos específicos involucrados, en orden de ejecución.
5. Solo si todavía queda duda, ahí abrimos archivos. Pero primero el grafo.

Si la pregunta es ambigua, repítemela en otras palabras antes de gastar tokens consultando.

Quiero mover el módulo `{NOMBRE_DEL_MODULO}` a otra ubicación o renombrarlo. Antes de tocar nada, mapea con Graphify quién lo usa.

1. Corre primero `/graphify explain "{NOMBRE_DEL_MODULO}"` para tener el resumen del nodo y sus relaciones inmediatas.
2. Después usa `/graphify query "qué archivos importan, llaman o dependen del módulo {NOMBRE_DEL_MODULO}, directa o indirectamente"` para sacar la lista completa desde el grafo.
3. Para los 3 archivos más sospechosos del paso anterior, confirma con `/graphify path "{NOMBRE_DEL_MODULO}" "<NombreDelArchivo>"` y muéstrame las cadenas exactas.
4. Lista los archivos que importan o dependen de este módulo. Indica si la dependencia es:
   - **Directa** (importa el símbolo): hay que actualizar import path.
   - **Indirecta** (lo usa vía otro módulo): probablemente no hay que tocar.
   - **Inferida** (Claude lo dedujo, confianza < 1.0): revisa antes de mover.
5. Estima el blast radius: cuántos archivos hay que tocar, qué tests podrían fallar, qué documentación apunta a este módulo.
6. Propón un plan de movimiento en pasos:
   - Crear el archivo nuevo.
   - Actualizar imports en N archivos (lista exacta).
   - Borrar el archivo viejo.
   - Correr `/graphify . --update` después para validar que el grafo nuevo coincida con la intención.
7. NO ejecutes ningún cambio todavía. Solo dame el plan.

Cuando yo te diga "adelante", aplicas paso por paso y al final corres el update del grafo.

Tengo una carpeta llena de PDFs y notas de research que quiero convertir en un curso navegable que pueda consultar con Claude después.

La carpeta está en `./mis-papers` (puede contener .pdf, .md, .docx).

1. Corre `/graphify ./mis-papers --mode deep`. Esto activa la extracción profunda y la minería de citas en los PDFs.
2. Cuando termine, dime:
   - Cuántos documentos procesó.
   - Qué temas detectó como comunidades grandes.
   - Qué citas cruzadas encontró entre PDFs (un paper que cita a otro de la carpeta).
3. Genera la versión Obsidian del grafo con `/graphify ./mis-papers --obsidian`. Eso me deja un vault con backlinks listos.
4. Para cada comunidad grande, dame un mini-curso de 5 pasos:
   - Por qué importa este tema (una oración).
   - Qué documento leer primero.
   - Qué documento leer después.
   - Las 3 preguntas que el grafo sugiere para ese tema.
   - Conexiones con otras comunidades.
5. Genera un `README_CURSO.md` en la raíz de `./mis-papers` con la ruta de aprendizaje completa.

Si encuentras PDFs muy pesados que vayan a costar mucho procesar, avísame antes y dame la opción de saltarlos.

Quiero comparar dos versiones del mismo proyecto a nivel arquitectónico, no a nivel de diff de líneas.

Tengo dos checkouts:
- `./version-actual` — donde está el código en producción.
- `./version-rama-X` — donde está el refactor que estoy considerando merger.

1. Corre `/graphify ./version-actual --no-viz` para generar solo `graph.json` y `GRAPH_REPORT.md`. Renómbralos a `graph_actual.json` y `REPORT_actual.md`.
2. Repite con `./version-rama-X` → `graph_rama.json` y `REPORT_rama.md`.
3. Corre `graphify merge-graphs graph_actual.json graph_rama.json` y revisa el output.
4. Dame un diff arquitectónico:
   - Nodos nuevos (módulos, funciones que no existían antes).
   - Nodos eliminados (qué desaparece).
   - Cambios de centralidad: god nodes que dejaron de serlo, nodos que ahora son god.
   - Comunidades que se partieron o se fusionaron.
5. Dame un veredicto en una oración: ¿el refactor mejora el acoplamiento, lo empeora o es neutral?
6. Lista los 5 archivos que cambian más radicalmente para revisión humana antes de aprobar el merge.