promptfolio-summarize
Estás construyendo un retrato del usuario humano — la persona que ejecuta este comando es el sujeto a analizar. Su retrato se mostrará en la plataforma promptfolio. No estás resumiendo proyectos, no estás evaluando habilidades de uso de IA, no estás escribiendo una revisión de desempeño. Estás encontrando los momentos en los que esta persona enseña a la IA cómo pensar — sus frases marco — y usándolos para pintar una imagen de quiénes son.
Para hacer esto, analiza su historial de conversaciones con IA (Claude Code, Cursor, Codex, ChatGPT, Gemini CLI, Trae, OpenCode, Antigravity, Windsurf, OpenClaw y cualquier otro agente de codificación encontrado en el sistema) de los últimos 30 días, extrae un mapa de calor de actividad y frases marco que revelen el pensamiento de esta persona, luego construye un retrato en torno a esas frases.
Principio fundamental: encuentra donde el usuario está ENSEÑANDO, no donde está ORDENANDO. "Arregla este error" no te dice nada. "No pienses de esa manera — esto no es un problema de rendimiento, es un problema de psicología del usuario" / "你不要这样想,这不是性能问题,是用户心理问题" te lo dice todo.
Paso 0: Autoactualización
Antes de cualquier otra cosa, ejecuta el autoactualizador para asegurarte de tener los archivos de skill y formatos de datos más recientes:
bash ~/.promptfolio/update-check.sh
- Si la salida es
ACTUALIZADO v...→ dile al usuario: "Skills actualizadas a la v{version}." Luego vuelve a leer este archivo SKILL.md ya que puede haber cambiado, y continúa desde el Paso 1. - Si la salida es
ACTUALIZADO v...→ continúa en silencio. - Si la salida es
SIN_CONEXIÓN v...→ dile al usuario: "No se pudieron comprobar las actualizaciones (sin conexión). Ejecutando con la v{version} local." Continúa normalmente.
Luego continúa con el Paso 1 con normalidad.
Paso 1: Autenticación
Asegúrate de que ~/.promptfolio/config.json exista y tenga un token válido.
1a. Validar token existente (si el config existe):
if [ -f ~/.promptfolio/config.json ]; then
API_TOKEN=$(python3 -c "import json; print(json.load(open('$HOME/.promptfolio/config.json'))['api_token'])")
API_URL=$(python3 -c "import json; print(json.load(open('$HOME/.promptfolio/config.json')).get('api_url','https://promptfolio.club'))")
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -H "Authorization: Bearer $API_TOKEN" "$API_URL/api/profile/me" || true)
echo "HTTP_CODE=$HTTP_CODE"
fi
- Si HTTP 200, procede al Paso 2.
- Si el config falta o HTTP no es 200, ejecuta el script de autenticación del dispositivo:
1b. Ejecutar autorización del dispositivo:
bash "SKILL_DIR/../scripts/device-auth.sh"
Reemplaza SKILL_DIR con el directorio que contiene este archivo SKILL.md. El script maneja todo: solicitar un código de dispositivo, abrir el navegador, sondear hasta que se autorice y guardar ~/.promptfolio/config.json.
IMPORTANTE: DEBES ejecutar el script tal cual. No reimplementes el flujo de autenticación tú mismo. No construyas URLs de autenticación manualmente — deja que el script lo maneje todo.
Si el script falla, dile al usuario que la autorización expiró y que intente de nuevo.
Paso 2: Descubrir Sesiones
Antes de ejecutar cualquier comando, dile al usuario:
Todo el análisis de conversaciones ocurre localmente en tu máquina. No se envía ningún contenido de conversación en bruto a ningún servidor durante el análisis. Solo los resultados estructurados se suben después de tu confirmación explícita.
2a. Detectar herramientas instaladas
Antes de escanear, verifica qué herramientas de codificación de IA tiene realmente instaladas el usuario. Busca sus directorios de configuración/datos:
| Herramienta | Cómo detectarla |
|---|---|
| Claude Code | ~/.claude/projects/ existe |
| Cursor | ~/.cursor/projects/ existe |
| Codex | ~/.codex/ existe |
| OpenClaw | ~/.openclaw/ existe |
| Gemini CLI | ~/.gemini/tmp/ existe (con subdirectorios chats/) |
| Antigravity | ~/Library/Application Support/Antigravity/ o ~/.gemini/antigravity/ existe |
| Windsurf | ~/.codeium/windsurf/, ~/.windsurf/, o ~/Library/Application Support/Windsurf/ existe |
| ChatGPT | ~/Desktop/chatgpt_history/ existe (el usuario debe exportar datos manualmente) |
| Trae | ~/.trae/, ~/.trae-cn/, o directorios de App Support Trae existen (nota: la base de datos está cifrada) |
| OpenCode | ~/.local/share/opencode/opencode.db existe |
Ejecuta una comprobación rápida:
echo "=== Herramientas de IA detectadas ==="
[ -d ~/.claude/projects ] && echo "claude-code"
[ -d ~/.cursor/projects ] && echo "cursor"
[ -d ~/.codex ] && echo "codex"
[ -d ~/.openclaw ] && echo "openclaw"
[ -d ~/.gemini/tmp ] && echo "gemini-cli"
[ -d "$HOME/Library/Application Support/Antigravity" ] || [ -d ~/.gemini/antigravity ] && echo "antigravity"
[ -d ~/.codeium/windsurf ] || [ -d ~/.windsurf ] || [ -d "$HOME/Library/Application Support/Windsurf" ] && echo "windsurf"
[ -d ~/Desktop/chatgpt_history ] && echo "chatgpt"
[ -d "$HOME/Library/Application Support/Trae CN/ModularData/ai-agent" ] || [ -d "$HOME/Library/Application Support/Trae/ModularData/ai-agent" ] && echo "trae"
[ -f "$HOME/.local/share/opencode/opencode.db" ] && echo "opencode"
Luego escanea en busca de otros agentes de codificación que no estén en la lista anterior. Busca directorios con punto en ~/ y directorios de aplicaciones en ~/Library/Application Support/ que parezcan herramientas de codificación de IA (ej. Kiro, Aider, Continue, Copilot Chat, Trae, Roo Code, etc.):
echo "=== Verificando otros agentes de codificación ==="
ls -d ~/.kiro ~/.aider* ~/.continue ~/.roo* 2>/dev/null || true
ls -d "$HOME/Library/Application Support/Kiro" "$HOME/Library/Application Support/Continue" 2>/dev/null || true
Si encuentras algún directorio de herramienta desconocido, mira dentro para ver si contienen registros de conversación (.jsonl, .json, .txt). Si los tienen, inclúyelos — no es necesario preguntar al usuario.
Presenta los resultados: "Detectado: Claude Code, Cursor. También encontrado: Kiro (tiene registros de sesión)."
Establece PF_SOURCES con las herramientas conocidas para el script, y maneja las herramientas desconocidas manualmente en 2b.
2b. Encontrar archivos de sesión
Ejecuta el script de descubrimiento, apuntando solo a las herramientas detectadas:
export PF_SOURCES="claude-code,cursor" # solo las detectadas en 2a
SESSION_LIST=$(bash "SKILL_DIR/scripts/discover-sessions.sh")
export SESSION_LIST
El script escanea ubicaciones conocidas para cada herramienta y filtra los últimos 30 días. Después de ejecutarlo:
- Verifica herramientas con cero sesiones — si una herramienta detectada tiene 0 sesiones, explora su directorio de datos tú mismo para encontrar archivos que el script haya pasado por alto.
- Maneja herramientas desconocidas — para cualquier agente de codificación adicional descubierto en 2a, explora sus directorios de datos, encuentra archivos de registro de conversación (.jsonl, .json, .txt) y agrégalos a
$SESSION_LIST. - Pregunta al usuario si tiene datos de sesión en ubicaciones no estándar o de herramientas que no detectaste.
Si encuentras archivos de sesión adicionales, agrégalos a $SESSION_LIST.
2c. Calcular estadísticas + datos de actividad
Ejecuta el script de estadísticas para calcular estimaciones de tokens y extraer datos del mapa de calor de actividad en una sola pasada:
python3 "SKILL_DIR/scripts/compute-stats.py"
Esto lee $SESSION_LIST y produce:
- stdout: resumen de sesión/token por fuente
_pf_parts/activity.json: datos de actividad por día para la visualización del mapa de calor
2d. Presentar resumen y preguntar al usuario
Presenta un resumen al usuario:
- Total de sesiones encontradas (últimos 30 días), agrupadas por fuente
- Destacados del mapa de calor de actividad: día más activo, última noche, sesión más larga
- Tokens totales estimados (etiquetados como "estimados")
Luego usa la herramienta AskQuestion para preguntar:
- Pregunta: "¿Proceder con el análisis?"
- Opciones:
- "Sí, analizar estas sesiones" — procede al Paso 3
- "No, déjame ajustar" — pregunta al usuario qué cambiar
Paso 3: Analizar Conversaciones
Analizando diferentes formatos
Sesiones de Claude Code (.jsonl en ~/.claude/projects/):
- Cada línea es un objeto JSON de la transcripción de la conversación
- Léelo y analízalo directamente
Sesiones de Cursor — Texto plano (.txt en ~/.cursor/projects/*/agent-transcripts/):
- Bloques alternados de
user:yassistant: - Los mensajes del usuario están envueltos en etiquetas
<user_query>...</user_query> - Los mensajes del asistente pueden incluir secciones
[Thinking] - Analiza dividiendo por los marcadores
user:/assistant:
Sesiones de Cursor — JSONL (.jsonl en ~/.cursor/projects/*/agent-transcripts/{UUID}/):
- Cada línea:
{"role":"user|assistant","message":{"content":[{"type":"text","text":"..."}]}} - Los mensajes del usuario contienen etiquetas
<user_query>en el campo de texto - Analiza JSON y extrae el contenido de texto
Historial de solicitudes de Codex (~/.codex/history.jsonl):
- Cada línea típicamente se ve así:
{"session_id":"...","ts":...,"text":"..."} - Trata
textcomo contenido del mensaje del usuario - Agrupa por
session_idpara reconstruir hilos
Eventos de sesión de Codex (~/.codex/sessions/**/*.jsonl):
- Flujo de eventos con
type+payload - Extrae contenido originado por el usuario donde el rol/tipo indica mensajes del usuario
- Usa
history.jsonlcomo respaldo principal si el análisis de eventos es ambiguo
Sesiones de OpenClaw (~/.openclaw/sessions/*.jsonl y ~/.openclaw/agents/**/*.jsonl):
- OpenClaw almacena metadatos de sesión en
~/.openclaw/sessions.jsony transcripciones por sesión como JSONL. - Analiza cada línea JSONL como un evento; extrae entradas donde el hablante/rol/fuente indica al usuario.
- Si existen múltiples formas de evento, prefiere contenido explícito con
role == "user", luego recurre al texto de carga útil del evento etiquetado como usuario. - Usa
sessions.jsonpara mapear IDs de sesión al contexto del proyecto/espacio de trabajo cuando esté disponible.
Exportación de ChatGPT (conversations*.json):
- El archivo es una matriz de conversaciones, cada una contiene un árbol de
mapping - Extrae nodos donde
message.author.role == "user" - Obtén texto del usuario de
message.content.parts[] - Ordena por
create_timeal reconstruir la cronología
Sesiones de Gemini CLI (.json en ~/.gemini/tmp/*/chats/):
- Cada archivo es una sesión completa:
{"sessionId":"...","messages":[{"type":"user|model","content":[{"text":"..."}],"timestamp":"..."}]} type: "user"= mensaje del usuario,type: "model"= respuesta del asistente- El contenido es una matriz de partes, cada una con un campo
text - Las marcas de tiempo son cadenas ISO 8601
- El nombre del proyecto es el directorio padre bajo
tmp/(ej.~/.gemini/tmp/miproyecto/chats/)
Sesiones de Trae (fork de VS Code de ByteDance — DB cifrada, requiere exportación asistida por el usuario):
- Trae almacena el chat de IA en una base de datos SQLite cifrada (SQLCipher) en
~/Library/Application Support/Trae CN/ModularData/ai-agent/database.db— no se puede leer directamente - Directorio principal:
~/.trae-cn/(CN) o~/.trae/(internacional) - El script de descubrimiento verifica archivos de chat exportados en
~/.trae-cn/chat-export.json,~/.trae/chat-export.json,~/Desktop/trae-chat-export.json,~/Downloads/trae-chat-export.json - Si Trae es detectado pero no se encuentran archivos de exportación (stderr contiene
TRAE_DETECTED_NO_EXPORT), pregunta al usuario conAskUserQuestion:- Explica: "Trae almacena el historial de chat en una base de datos cifrada. Para incluir datos de Trae, puedes exportarlos desde dentro de Trae."
- Opción 1: "Exportar desde Trae" — Dile al usuario que abra Trae, inicie un nuevo chat y envíe este mensaje:
Luego vuelve a ejecutar el script de descubrimiento después de que el usuario confirme que la exportación está hecha.Exporta todo mi historial de chat como un archivo JSON. Guárdalo en ~/.trae-cn/chat-export.json (o ~/.trae/chat-export.json para la versión internacional). El formato JSON debe ser: {"messages": [{"role": "user", "content": "...", "timestamp": "2026-01-01T12:00:00Z"}, {"role": "assistant", "content": "...", "timestamp": "..."}]} Si hay varias sesiones, combina todos los mensajes de todas las sesiones en una sola matriz plana de mensajes, ordenados por timestamp. - Opción 2: "Saltar Trae" — Continúa sin datos de Trae.
- NO intentes descifrar o forzar la base de datos
- El archivo JSON exportado, una vez creado, será recogido automáticamente en ejecuciones futuras
Sesiones de OpenCode (SQLite → JSON extraído):
- El script de descubrimiento extrae sesiones de
~/.local/share/opencode/opencode.dben archivos JSON temporales - Cada archivo extraído:
{"messages":[{"role":"user|assistant","content":"...","timestamp":1234567890}]} - Las marcas de tiempo son enteros Unix epoch (segundos)
- Si los archivos JSON extraídos faltan o están vacíos, recurre a consultar la base de datos directamente:
sqlite3 ~/.local/share/opencode/opencode.db "SELECT data FROM message WHERE session_id='...' ORDER BY time_created"
Antigravity / Windsurf (fuentes experimentales):
- Prefiere archivos de transcripción explícitos (
.jsonl,.json,.txt) cuando estén presentes - Si solo
state.vscdb/ registros están disponibles, trátalos como contexto solo de metadatos - Si el contenido de la conversación legible no se puede extraer de manera segura, pregunta al usuario por una ruta de exportación en lugar de adivinar
Qué analizar
Concéntrate en los mensajes del usuario. Las respuestas del modelo son solo contexto de fondo. Tu objetivo es encontrar frases marco e instancias — momentos en los que el usuario enseña a la IA a pensar, y escenarios en los que el usuario colabora con la IA para resolver problemas a través de correcciones en múltiples turnos.
Para cada sesión, escanea cada mensaje del usuario en busca de:
-
Frases marco — el usuario está definiendo cómo funciona el mundo, no pidiendo a la IA que haga algo:
- Definir esencia: "El verdadero problema aquí es..." / "本质上是……", "La lógica central es..." / "核心逻辑是……"
- Corregir el pensamiento de la IA (no solo su resultado): "No pienses de esa manera" / "你不要这样想", "Esto no es un problema de X, es un problema de Y" / "这不是 X 问题,是 Y 问题"
- Establecer principios: "Un buen X debería..." / "好的 X 应该……", "Nunca..." / "永远不要……"
- Hacer abstracciones o analogías entre dominios
- Expresar juicios estéticos: "Esto es feo" / "太丑了", "Ahora eso está bien" / "这才对", "Esto se siente mal" / "感觉不对"
- Revelar contradicciones entre diferentes sesiones
-
Instancias — estudios de caso de tareas complejas de múltiples turnos donde la dirección del usuario revela su calibre. Piensa: ¿cómo describiría un cazatalentos la trayectoria de esta persona?
- El usuario impulsó una tarea compleja a través de múltiples turnos, tomando decisiones arquitectónicas y de compensación que dieron forma al resultado
- El usuario aplicó experiencia de dominio de la experiencia vivida — peculiaridades de API, restricciones de plataforma, convenciones de la industria
- El gusto y juicio del usuario anularon soluciones técnicamente correctas pero insatisfactorias
...