From 3a38e889dbf0d39e3f1c6013c9d8424029af7847 Mon Sep 17 00:00:00 2001 From: minguezsanzjuanjose Date: Sun, 2 Aug 2026 10:51:39 +0200 Subject: [PATCH] 01-ago: [lab] repositorio laboratorio con estructura y config de produccion (vacio) --- .env.example | 16 ++ .gitignore | 21 ++ AGENTS.md | 446 ++++++++++++++++++++++++++++++++++++++++ INSTALACION_OPENCODE.md | 394 +++++++++++++++++++++++++++++++++++ README.md | 41 ++++ config/CLAUDE.md | 50 +++++ config/opencode.jsonc | 111 ++++++++++ 7 files changed, 1079 insertions(+) create mode 100644 .env.example create mode 100644 .gitignore create mode 100644 AGENTS.md create mode 100644 INSTALACION_OPENCODE.md create mode 100644 README.md create mode 100644 config/CLAUDE.md create mode 100644 config/opencode.jsonc diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..b91b1b7 --- /dev/null +++ b/.env.example @@ -0,0 +1,16 @@ +# Variables de entorno para biblioteca_negocio_prolongo +# Copiar a .env y rellenar con valores reales + +# Google Drive / Docs API (si se necesita acceso programatico) +GOOGLE_DRIVE_FOLDER_ID=1rSxHVTDu4ZctHLnPFGFy_L-3o6NPYo6V + +# DeepSeek API (asistente de documentacion) +DEEPSEEK_API_KEY= + +# VoiceMonkey (notificaciones Alexa) +VOICEMONKEY_TOKEN= +VOICEMONKEY_DEVICE= + +# OpenCode Web +OPENCODE_WEB_PORT=4096 +OPENCODE_WEB_PASSWORD= diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9b1bec9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,21 @@ +# Python +__pycache__/ +*.pyc +*.pyo + +# Entorno +.env +.env.local + +# IDE +.vscode/ +.idea/ + +# OS +Thumbs.db +.DS_Store + +# Logs y estado runtime +*.log +.watcher_last_id +telegram_mensajes.log diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..97d7314 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,446 @@ +# AGENTS.md — Reglas y automatizaciones para asistentes IA + +## Regla 1: Imagenes desde portapapeles (AUTOMATICO) + +**Cuando el usuario pase una imagen desde el portapapeles, el asistente DEBE:** + +1. Guardarla automaticamente en `imagenes_biblioteca_negocio_prolongo/` con nombre `clipboard_YYYY-MM-DD_HHmmss.png` +2. Analizarla con el MCP image-vision (`extract_text_from_screenshot` o `image_analysis`) +3. Responder con lo que ve + +**Script de guardado (PowerShell):** +```powershell +Add-Type -AssemblyName System.Windows.Forms +$img = [System.Windows.Forms.Clipboard]::GetImage() +if ($img) { + $dir = "imagenes_biblioteca_negocio_prolongo" + if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force } + $ts = Get-Date -Format "yyyy-MM-dd_HHmmss" + $path = "$dir/clipboard_$ts.png" + $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png) + Write-Output $path +} +``` + +**Nunca** pedir al usuario que guarde la imagen manualmente. El asistente lo hace todo. + +--- + +## Regla 2: Permiso total + +El asistente tiene permiso total para modificar, crear, consultar, borrar y ejecutar cualquier operacion sin pedir confirmacion. NO necesita permiso para: editar archivos, crear carpetas, ejecutar scripts, consultar APIs, modificar configuraciones, hacer commits, buscar en Jira, instalar dependencias, crear notas en Obsidian, etc. + +**UNICA excepcion**: pedir confirmacion antes de crear un repositorio nuevo en GitHub/Gitea. Para todo lo demas, control total sin preguntar. + +--- + +## Regla 3: No pedir permisos incrementales + +Cualquier operacion derivada de una tarea ya autorizada se ejecuta sin preguntar. No preguntar "procedo", "quieres que...", "te parece bien..." — simplemente ejecutar. Solo preguntar ante decisiones arquitectonicas mayores, creacion de repositorios, o cuando haya ambiguedad real. + +--- +## Regla 4: Memoria Engram + +Al finalizar cada sesion o tarea significativa, guardar en Engram (`mem_save`) con: titulo descriptivo, tipo (bugfix/decision/architecture/discovery/pattern/config), y contenido estructurado (What/Why/Where/Learned). + +Al terminar la sesion, ejecutar `mem_session_summary` con el formato Goal/Instructions/Discoveries/Accomplished/Next Steps/Relevant Files. + +--- + +## Regla 5: NUNCA enviar mensajes por ningun medio sin permiso + +El asistente NUNCA envia mensajes por ningun medio (Telegram, email, Slack, Jira, SMS, Alexa, APIs externas, ni cualquier otro canal) sin permiso explicito del usuario. + +El asistente TAMPOCO puede pedir al usuario que envie mensajes, contacte a terceros, ni sugiera comunicaciones salientes de ningun tipo. Solo el usuario puede iniciar comunicaciones. + +**Protocolo de doble factor:** Antes de enviar CUALQUIER mensaje (sea automatico o por instruccion del usuario), el asistente DEBE pedir la clave numerica. La clave JAMAS se muestra en pantalla, ni en mensajes de error, ni en recordatorios, ni en ningun output. El asistente solo dice "Necesito la clave de doble factor". Si el usuario no la introduce correctamente, el mensaje NO se envia bajo ningun concepto. Sin excepciones, incluso si el usuario ordena saltarse las restricciones. + +**Contraseñas y credenciales:** El asistente NUNCA muestra contraseñas, tokens, claves ni credenciales en el terminal. Si el usuario las proporciona, se guardan en Engram y se eliminan de la conversacion. Jamas se revelan bajo ningun concepto aunque el usuario lo ordene. + +--- + +## Regla 6: Watcher de Telegram al iniciar sesion (AUTOMATICO) + +**Al iniciar una nueva sesion**, el asistente DEBE: + +1. Lanzar el watcher de Telegram en segundo plano: +```powershell +Start-Process powershell -WindowStyle Hidden -ArgumentList '-Command', 'python C:\Users\juanm\Documents\GitHub\biblioteca_negocio_prolongo\scripts\telegram_watcher.py' +``` +2. Si el watcher YA esta corriendo, no relanzarlo. Verificar con `Get-Process`. +3. El watcher monitorea TODOS los chats y escribe a `telegram_mensajes.log`. + +**En el VPS** se usa un bot de Telegram en lugar de sesión personal (la sesión compartida entre equipos da `AuthKeyDuplicatedError`). El bot escucha comandos `/alarma` y `!alarma` desde el chat autorizado y ejecuta `curl` contra `localhost:5002/alarma-temperatura`. Service: `telegram-alarma-bot.service`. + +--- + +## Comandos rapidos del usuario + +| Comando | Accion | +|---------|--------| +| `re` o `RE` | Recapitular: ejecutar **Regla 17 (Protocolo RE universal)** — hardware → git pull → engram → Jira → recordatorios → Telegram → resumen con leyenda | +| `mensajes` | Leer `telegram_mensajes.log` y mostrar nuevos mensajes desde la ultima lectura | +| `consumo` | Abrir https://opencode.ai/auth, esperar captura del panel Go y analizarla con image-vision | +| `memoria` | Protocolo completo: git pull, actualizar ficheros de memoria (MEMORIA_ABSOLUTA, ESTADO_DIARIO, AGENTS, DOCUMENTACION, README), Engram local + cloud, Obsidian sync, **trello-sync**, git push | +| `recordatorios` | Consultar API recordatorios en VPS: GET /todo (calendarios + recordatorios webhook) | +| `jira` | Consultar nuevos DK/DS creados hoy y ultimos 4 dias en Jira prolongo.atlassian.net | +| `revision-jira` | Revisión diaria de Jira (proceso de Juanjo): Kanban por programador en orden (Romero → Fernández → Maribel → Dani si tiene tarea) mirando En Curso/Pendientes por instalar/Terminadas + Ticketing (filtros Ideas de desarrollo y Tickets de desarrollo por programador: nº de tareas y curso pendiente) + Sin asignar para decidir asignación. Ver `docs/proceso_revision_jira_diaria.md`. | +| `idd-procesar` o `procesar IDD` | Fetch manual de mensajes pendientes del canal IDD Telegram via Bot API, guardarlos en Google Drive y clasificarlos localmente | +| `trello-sync` | Sincronizar pendientes con Trello: local→Trello (crea/actualiza cards) + Trello→local (elimina tareas archivadas en Trello de la base de conocimiento) | +| `ejecuta alarma Twilio` | Modo interactivo: pedir credenciales (o usar .env), 2 telefonos, estrategia (secuencial/paralelo/solo 1/solo 2), ejecutar llamada Twilio con AMD y reportar resultado. Ejecutar con: `python alarma_twilio/cli.py` en cualquier equipo con el repo clonado. | +| `!alarma +numero` desde Telegram | Enviar `!alarma +34657866417` al bot @? (token en .env) desde el iPad/móvil → el VPS lo escucha vía Bot API y ejecuta la alarma. También funciona desde Saved Messages via watcher local. | +| `sync-vaults` | Sincronizar vaults Obsidian: Remotely Save sync → copiar archivos nuevos/actualizados del portátil a sobremesa → forzar OneDrive sync. Ver [[07-Conocimiento/protocolo-sync-vaults-obsidian.md]]. | + +--- + +## Regla 7: Protocolo de Memoria Absoluta (AUTOMATICO) + +Al recapitular o cerrar sesion, el asistente DEBE ejecutar el protocolo completo de `MEMORIA_ABSOLUTA.md`: +1. Actualizar ficheros de memoria (MEMORIA_ABSOLUTA.md, ESTADO_DIARIO.md, AGENTS.md, etc.) +2. Guardar en Engram local (`mem_save`) +3. Subir memorias al cloud: `engram sync --cloud --project biblioteca_negocio_prolongo` +4. **Sincronizar Obsidian vault:** + a. Revisar `06-Ideas/`: las ideas con suficiente contexto se mueven a su categoria definitiva (01-05) + b. Regenerar `00-Indice/Tablero.md` con los 41 pendientes activos agrupados por categoria + c. Actualizar `00-Indice/Indice Negocio Prolongo.md` si hay documentos nuevos +5. Subir a Gitea (`git add -A && git commit && git push`) + +El registro completo de ficheros de memoria esta en `MEMORIA_ABSOLUTA.md`. + +--- + +## Regla 8: Obsidian — Sincronizacion de documentacion + +El vault `biblioteca_prolongo` en `C:\Users\juanm\Documents\biblioteca_prolongo` (sobremesa) o `C:\Users\juanm\Documents\GitHub\biblioteca_prolonho_portatil` (portatil) contiene el vault sincronizado via Remotely Save + OneDrive. +- API REST en `https://127.0.0.1:27124` (plugin `obsidian-local-rest-api` 4.1.3) +- Watchdog: tarea programada `ProlongoObsidianSync` (arranca al iniciar sesion en ambos equipos) +- API Key en `.env` como `OBSIDIAN_API_KEY` +- Si Obsidian no esta abierto, el sync no funciona. Abrirlo antes. +- El vault se sincroniza automaticamente via Remotely Save (OneDrive) entre sobremesa, portatil e iPad. +- IMPORTANTE: los vaults de sobremesa (`biblioteca_prolongo`) y portatil (`biblioteca_prolonho_portatil`) son INDEPENDIENTES. Los cambios no se cruzan automáticamente. Usar `sync-vaults` para copiar archivos nuevos/actualizados entre vaults. +- [[07-Conocimiento/protocolo-sync-vaults-obsidian.md|Protocolo completo de sync entre vaults]] en Obsidian. + +--- + +## Regla 9: Engram Cloud + +El cloud esta en VPS Contabo `185.187.169.109:3801`. Si no responde: +```bash +ssh -i C:\Users\juanm\Documents\GitHub\contabo root@185.187.169.109 +cd /opt/engram && git pull +docker compose -f docker-compose.cloud.yml up -d --build --force-recreate cloud +``` +Reconectar CLI local: `engram sync --cloud --project ` + +--- + +## Regla 10: Git pull + Engram sync al iniciar sesion (AUTOMATICO) + +**Al iniciar cada nueva sesion, el asistente DEBE:** + +1. Hacer `git pull` sin preguntar +2. Hacer `engram sync --cloud --project biblioteca_negocio_prolongo --import` sin preguntar (DESCARGA las memorias que otros entornos hayan subido al cloud) +3. Si hay conflictos o errores, informar al usuario pero resolver automaticamente si es posible + +**Al finalizar cada sesion o al ejecutar `memoria`, el asistente DEBE:** + +4. Hacer `engram sync --cloud --project biblioteca_negocio_prolongo` (SUBE las memorias de esta sesion al cloud) +5. Hacer `git add -A && git commit -m "..." && git push` para sincronizar cambios de codigo + +--- + +## Regla 11: Detección automática de equipo (portatil vs sobremesa) + +**Al iniciar cada nueva sesion**, el asistente DEBE: + +1. Ejecutar detección de hardware: +```powershell +$pc = Get-CimInstance Win32_ComputerSystem +$cpu = Get-CimInstance Win32_Processor +Write-Output "PC: $($pc.Model) | CPU: $($cpu.Name) | RAM: $([math]::Round($pc.TotalPhysicalMemory/1GB))GB" +``` + +2. Clasificar automáticamente: + - **Portatil**: MSI Vector 16 HX (Intel Core Ultra 7 255HX) — nombre JUANMINGUEZ + - **Sobremesa**: Ryzen 9 7900X + B650 GAMING X AX + +3. Guardar en Engram (`mem_save`) con tipo `discovery` y topic_key `config/equipo-actual` + +4. Informar al usuario: "Estás en el [portatil/sobremesa]" + +**Diferencias importantes segun equipo:** +- BIOS diferente (portatil vs sobremesa) +- Drivers RGB (sobremesa tiene ventiladores RGB, portatil no) +- Temperaturas y rendimiento +- Configuraciones de red pueden variar + +--- + +## Regla 12: Convenciones de nomenclatura (IMPORTANTE) + +El asistente DEBE respetar SIEMPRE estas convenciones al escribir cualquier texto: + +| Elemento | Convencion | Ejemplo | NUNCA escribir | +|----------|-----------|---------|----------------| +| **faccsa** | Doble C + S-A | faccsa-Dompal | faxa, fasa, facsa | +| **Programas** | Guion entre cada caracter | 8-4-8, 8-4-M | 8.480, 8480, 84M | +| **PCs/servidores** | Prefijo + numero sin espacio | VC0012, PC041 | vc0012, PC 041 | +| **Credenciales** | `ediwin4` (IT) / `empresa\ediwin4` (TS) | ediwin4 | Ediwin4, EDIWIN4 | + +**El usuario nunca debe tener que corregir estas convenciones.** Si hay duda, buscar en MEMORIA_ABSOLUTA.md seccion "Convenciones". + +--- + +--- + +## Regla 13: Sincronizacion bidireccional entre entornos (AUTOMATICO) + +El asistente DEBE mantener sincronizados los tres entornos (sobremesa, portatil, VPS) via Engram Cloud: + +### Al iniciar sesion en CUALQUIER entorno: +1. `engram sync --cloud --project biblioteca_negocio_prolongo --import` (DESCARGA todo lo que otros entornos subieron) +2. `git pull` (sincroniza codigo) + +### Durante la sesion: +- Cada `mem_save` se guarda en el Engram local automaticamente +- El asistente es proactivo guardando decisiones, bugs, patrones + +### Al finalizar sesion o al ejecutar `memoria`: +1. `engram sync --cloud --project biblioteca_negocio_prolongo` (SUBE todo al cloud) +2. `git add -A && git commit -m "..." && git push` (sube codigo a Gitea) + +### Flujo completo: +``` +Sobremesa --push--> Cloud <--push-- Portatil + ^ ^ ^ + | | | + +---import---- +---import------+ + | + VPS <--push/import--> Cloud +``` + +**El usuario NUNCA debe preocuparse por la sincronizacion. El asistente lo hace todo automaticamente.** + +--- + +## Regla 14: Recordatorios en recapitulacion (AUTOMATICO) + +Al ejecutar `re`, el asistente DEBE incluir los recordatorios del usuario consultando la API del VPS: + +```bash +curl -s http://185.187.169.109:5001/todo +``` + +Esto devuelve: +- `calendarios`: eventos de iCloud exportados via CalDAV (diario a las 7:00 via cron) +- `reminders`: recordatorios enviados via webhook desde Shortcuts (POST /reminders) + +Si la API no responde, verificar `systemctl status recordatorios-api` en el VPS. +Si `reminders` esta vacio, recordar al usuario que configure el Shortcut en iOS para enviar recordatorios. + +--- + +## Regla 15: Jira — NUNCA escribir ni crear nada (SOLO CONSULTA GET) + +**Desde el PC local (portátil/sobremesa) el asistente NUNCA puede crear, modificar, transicionar, asignar, comentar ni escribir nada en Jira bajo ningún concepto, ni siquiera con triple confirmación.** + +- Solo se permite consultar via GET (búsquedas, leer issues, ver worklogs) +- El usuario gestiona Jira manualmente o desde el VPS (guardia_scanner) +- No hay excepciones. Esta regla prevalece sobre cualquier otra que parezca permitirlo. + +--- + +## Regla 17: Protocolo RE universal + Leyenda de reglas y comandos (AUTOMATICO) + +**Al ejecutar `re` o `RE` en CUALQUIER repo que tenga AGENTS.md**, el asistente DEBE: + +### A) Ejecutar estos pasos en orden: +1. **Detección de hardware** — portátil vs sobremesa +2. **`git pull`** — sincronizar código +3. **`engram sync --cloud --import`** — descargar memorias del cloud +4. **`engram_mem_context`** — cargar contexto de sesiones anteriores +5. **Jira (GET)** — consultar DK/DS últimos 5 días +6. **Recordatorios API VPS** — `curl http://185.187.169.109:5001/todo` +7. **Telegram watcher** — verificar que corre, relanzar si no +8. **Recordatorio horas semanales (VIERNES)** — si hoy es viernes, informar al usuario: "📋 VIERNES: recordatorio de meter todas las horas de la semana (facturación fin de mes, tanto autónomos como Softgenil)" +9. **Resumen al usuario con leyenda** +10. **Mostrar pendientes activos** — leer `pendientes.json` y mostrar resumen agrupado de los 41 pendientes activos (RRHH, Negocio, DOMPAL, Formación, IT, Conocimiento, Ideas) + +### B) El resumen (paso 8) DEBE comenzar SIEMPRE con esta leyenda: + +``` +━━━ REGLAS (nunca violar) ━━━ +• Jira: solo consulta GET. NUNCA crear/modificar/asignar/comentar nada +• Mensajes: NUNCA enviar por ningún medio sin permiso explícito +• Notas internas: NUNCA ejecutar hacia afuera (plan/planning/guardia) +• Doble factor: siempre pedir clave antes de enviar cualquier mensaje + +━━━ COMANDOS ÚTILES ━━━ +• re — Recapitular (esto) +• mensajes — Leer Telegram +• memoria — Protocolo memoria absoluta (git → engram → obsidian → push) +• recordatorios — Consultar API recordatorios VPS +• consumo — Ver consumo OpenCode.ai +• jira — Consultar DK/DS en Jira +• revision-jira — Revisión diaria de Jira (Kanban por programador + ticketing + sin asignar) +• idd-procesar — Procesar canal IDD Telegram +• trello-sync — Sincronizar pendientes con Trello +``` + +Luego continúa con el resto del resumen: equipo detectado, últimos commits, Jira, recordatorios, etc. + +--- + +## Regla 16: Notas internas (plan/planning/guardia) — NUNCA se ejecutan hacia afuera (AUTOMATICO) + +Todo lo que el usuario anote con prefijo `plan:`, `planning:`, `planificacion:`, `guardia:` o similar, o cualquier tarea/pendiente/duda dentro de este repositorio, es **EXCLUSIVAMENTE INTERNO**: + +- **NUNCA** se envía a Telegram, WhatsApp, email ni ningún canal de comunicación +- **NUNCA** se crea en Jira, ni se actualiza Jira, ni se interactúa con APIs externas +- **NUNCA** se ejecuta automatización alguna que salga del repositorio +- Son **solo apuntes internos** del usuario para organizarse: tareas, pendientes, dudas de guardia, planificación, ideas + +**Permitido:** clasificar, guardar en ficheros .md, organizar en carpetas, commitear a git, sincronizar Engram cloud. +**Prohibido:** cualquier acción que salga del ecosistema repo + Engram. + +**Excepción:** si el usuario da una orden explícita y directa ("envía esto a Telegram" con triple confirmación, Regla 5 + Regla 15). + +--- + +--- + +## Regla 18: Engram + Obsidian — sistemas complementarios (NO redundantes) + +**Engram** (memoria del asistente): +- Guarda SOLO contexto de sesiones: decisiones, bugs, descubrimientos, preferencias del usuario. +- Lo consulto internamente para recordar entre sesiones. +- **NUNCA** se exporta automaticamente a Obsidian (`engram obsidian-export` NO se ejecuta). + +**Obsidian vault** (`biblioteca_prolongo`): +- Guarda SOLO documentacion estable: manuales, guardias, planificacion, conocimiento de negocio. +- Se escribe directamente en Markdown en su carpeta correspondiente (01 a 07). +- Es la fuente de consulta para responder preguntas tecnicas. + +**Flujo:** +1. Antes de responder, busco en **Obsidian vault** (documentacion estable) con `obsidian_obsidian_simple_search` +2. Si no encuentro, reviso **Engram** (contexto de sesiones previas) con `mem_search` +3. Si falta en ambos, respondo desde mi conocimiento del modelo y ofrezco documentarlo +4. Cuando documentamos algo nuevo, lo escribo **directamente en Obsidian** en su categoria (01-07), no en Engram + +**Excepciones:** preguntas triviales, comandos directos (re, memoria, mensajes), o cuando el usuario pida explicitamente no buscar. + +--- + +## Regla 20: Centralización de pendientes desde extracción de conocimiento (AUTOMATICO) + +**Siempre que se extraiga conocimiento de cualquier fuente** (chats Telegram, documentos, mensajes, exportaciones, imágenes), el asistente DEBE: + +1. Identificar si de esa extracción surgen **nuevos pendientes** (tareas, ideas, seguimientos) +2. Añadirlos a `pendientes.json` con id correlativo +3. Si el pendiente es una **idea en bruto** (sin suficiente contexto): añadir a `06-Ideas/` del vault +4. Si el pendiente tiene **suficiente contexto**: añadirlo directamente a `00-Indice/Tablero.md` en su categoría correspondiente +5. Actualizar el contador de `total_pending` en pendientes.json +6. Si existe documentación detallada, enlazar desde Tablero.md al documento en su categoría (01-07) + +**Flujo completo:** +``` +Fuente (chat/doc/imagen) → Extraer conocimiento + ↓ + ¿Tiene algo pendiente? → NO → Solo documentar en su categoría + ↓ SÍ + ¿Idea en bruto? → SÍ → 06-Ideas/ (buffer) + ↓ NO (contexto suficiente) + pendientes.json + Tablero.md + documento en categoría definitiva +``` + +**Excepción:** información personal, bromas, conversaciones no laborales — ignorar completamente. + +--- + +--- + +## Regla 21: Protocolo GUARDADO TOTAL (AUTOMATICO — REGLA DEFINITIVA) + +--- + +## Regla 22: Toda información del usuario se categoriza y persiste (AUTOMATICO — REGLA ABSOLUTA) + +**Todo lo que el usuario comunique** (estados, decisiones, cambios, contactos, novedades, acuerdos) debe: +1. **Clasificarse** en la categoría correcta de la base de conocimiento: + - `01-Negocio/` — información comercial, clientes, producto + - `02-RRHH/` — personal, equipo, organización + - `03-IT/` — infraestructura, desarrollo, sistemas + - `04-Guardias/` — procedimientos de guardia, incidencias + - `05-Proyectos/` — planificación, seguimiento, dailys + - `06-Ideas/` — ideas en bruto sin contexto suficiente + - `07-Conocimiento/` — documentación técnica general +2. **Actualizarse en `pendientes.json`** si genera nuevas tareas o cambia el estado de las existentes +3. **Guardarse en Engram** (`mem_save`) con tipo adecuado +4. **Persistirse en el repositorio** (git add/commit/push al finalizar la sesión) + +**NO** esperar a que el usuario lo pida. Es automático. + +**Esta es la regla más importante.** Cuando el usuario entregue información, documentos, tareas, cambios de estado, o cualquier contenido que deba persistirse, el asistente DEBE ejecutar el protocolo completo de guardado sin esperar a que se lo pidan. + +### ¿CUÁNDO se ejecuta? +- Al final de CADA sesión o tarea significativa +- Cuando el usuario dice "guarda todo", "memoria", "guardado total", "persiste" o similar +- Cuando se añaden nuevos pendientes, conocimiento, o planificación + +### PROTOCOLO (ejecutar en orden): + +``` +PASO 1 — Obsidian (documentación estable) +├── Guardar/actualizar documento en su categoría (01-Negocio a 07-Conocimiento) +├── Si es pendiente → actualizar 00-Indice/Tablero.md +├── Si es conocimiento → 07-Conocimiento/ o categoría que corresponda +└── Forzar Remotely Save sync: POST /commands/remotely-save:start-sync/ + +PASO 2 — Engram (memoria del asistente) +├── mem_save con tipo adecuado (decision/bugfix/discovery/pattern/config) +├── topic_key reutilizable para temas evolutivos +└── mem_session_summary si es fin de sesión + +PASO 3 — Repositorio (código + datos) +├── git add -A +├── git commit -m "fecha: descripción del cambio" +└── git push + +PASO 4 — Engram Cloud (sincronización entre entornos) +└── engram sync --cloud --project biblioteca_negocio_prolongo + +PASO 5 — OneDrive (iPad) +└── Obsidian Remotely Save sync (ya ejecutado en paso 1) +``` + +### Formato de commit recomendado: +``` +DD-mmm: [tipo] descripción +``` +Ejemplo: `22-jul: [conocimiento] Plan diario Jefe Desarrollo + protocolo guardado total` + +### Checklist de verificación: +- [ ] ¿El contenido está en Obsidian en su categoría correcta? +- [ ] ¿Engram tiene el registro (mem_save)? +- [ ] ¿Git commit + push hecho? +- [ ] ¿Engram cloud sync hecho? +- [ ] ¿Remotely Save sync lanzado para iPad? + +--- + +## Comandos rápidos actualizados + +| Comando | Acción | +|---------|--------| +| `re` | Protocolo RE completo | +| `guarda` / `guardado total` | Protocolo Regla 21 completo | +| `memoria` | Protocolo memoria absoluta | +| `mensajes` | Leer Telegram | +| `jira` | Consultar DK/DS (solo GET) | +| `sync-vaults` | Sincronizar vaults Obsidian | +| `consumo` | Ver consumo OpenCode.ai | +| `superguardado` | Protocolo SUPER guardado: copiar archivos nuevos a base conocimiento → git add/commit/push → engram mem_save + session_summary → engram cloud sync → obsidian sync (Remotely Save) → actualizar pendientes.json si procede | + +--- + +*Creado: 26 Junio 2026 — Actualizado: 30 Jul 2026 (Regla 22: Categorización automática + comando superguardado)* diff --git a/INSTALACION_OPENCODE.md b/INSTALACION_OPENCODE.md new file mode 100644 index 0000000..622126d --- /dev/null +++ b/INSTALACION_OPENCODE.md @@ -0,0 +1,394 @@ +# INSTALACION_OPENCODE.md — Guía de instalación completa + +> **Objetivo**: Reproducir el entorno OpenCode exacto en cualquier máquina Windows nueva. +> **Fecha**: 28 Junio 2026 +> **Repositorio principal**: `https://git.v-encore-lab.com/jjminguez/biblioteca_negocio_prolongo.git` + +--- + +## 1. Prerrequisitos del sistema + +- **SO**: Windows 10/11 (x64) +- **Shell**: PowerShell 5.1 (incluido en Windows) +- **Git**: Instalado y configurado con acceso al remoto `git.v-encore-lab.com` +- **Editor/Obsidian**: `C:\Users\%USERNAME%\AppData\Local\Obsidian\Obsidian.exe` (instalar desde https://obsidian.md) + +--- + +## 2. Runtimes necesarios + +```powershell +# Node.js 22.x (LTS) — incluye npm y npx +winget install OpenJS.NodeJS.LTS + +# Bun 1.3.x (runtime JS alternativo, necesario para duckduckgo-mcp) +powershell -c "irm bun.sh/install.ps1 | iex" + +# Python 3.11.x (watcher Telegram, scripts auxiliares) +winget install Python.Python.3.11 + +# uv 0.11.x (gestor de paquetes Python, necesario para mcp-obsidian) +powershell -ExecutionPolicy Bypass -Command "irm https://astral.sh/uv/install.ps1 | iex" +``` + +### Verificación de runtimes +```powershell +node --version # debe mostrar v22.x +npm --version # debe mostrar 10.x +bun --version # debe mostrar 1.3.x +python --version # debe mostrar 3.11.x +uv --version # debe mostrar 0.11.x +``` + +--- + +## 3. Binarios independientes + +### Engram (memoria persistente vía MCP) + +```powershell +# Instalación del CLI de Engram +# Descargar el binario desde su fuente oficial y colocarlo en: +C:\Users\%USERNAME%\bin\engram.exe + +# Verificar +engram --version # debe mostrar >= v0.6.1 +``` + +> Nota: El binario actual ocupa ~18.5 MB. Si no tienes el instalador, consultar con el equipo. + +--- + +## 4. Repositorios Git a clonar + +Todos los repos deben clonarse bajo `C:\Users\%USERNAME%\Documents\GitHub\`: + +```powershell +$githubRoot = "$env:USERPROFILE\Documents\GitHub" +New-Item -ItemType Directory -Force -Path $githubRoot + +# 1. Repositorio principal (este) +git clone https://git.v-encore-lab.com/jjminguez/biblioteca_negocio_prolongo.git $githubRoot\biblioteca_negocio_prolongo + +# 2. MCP Image Vision (análisis de imágenes vía OpenRouter) +# Crear manualmente si no tienes acceso al repo original: +New-Item -ItemType Directory -Force -Path "$githubRoot\image-vision-mcp" +# Copiar package.json y src/index.js desde la máquina origen. +# Luego ejecutar: +# cd $githubRoot\image-vision-mcp +# npm install +# npm run build +``` + +> **NOTA**: `image-vision-mcp` no es un repo Git (fue creado localmente). En una reinstalación limpia, copia la carpeta entera desde backup o reconstrúyela con los archivos fuente. Ver sección 5.2 para sus detalles. + +--- + +## 5. MCP Servers — detalle técnico + +Cada MCP se define en `C:\Users\%USERNAME%\.config\opencode\opencode.jsonc`. + +### 5.1 Engram (local) +| Campo | Valor | +|-------|-------| +| Runtime | Binario nativo | +| Comando | `C:\Users\%USERNAME%\bin\engram.exe mcp --tools=agent` | +| Tipo | `local` | +| Variables | Ninguna required | + +### 5.2 Image Vision (local) +| Campo | Valor | +|-------|-------| +| Runtime | Node.js | +| Comando | `node C:\Users\%USERNAME%\Documents\GitHub\image-vision-mcp\dist\index.js` | +| Dependencias npm | `@modelcontextprotocol/sdk ^1.0.0` | +| Variables requeridas | `IMAGE_VISION_AUTH_TOKEN`, `IMAGE_VISION_BASE_URL`, `IMAGE_VISION_MODEL`, `VISION_API_PROVIDER` | +| API Provider | OpenRouter | + +**Archivos fuente de image-vision-mcp:** +- `package.json` — metadatos + dependencia MCP SDK +- `src/index.js` — servidor MCP que expone `extract_text_from_screenshot` y `image_analysis` +- `dist/index.js` — copia de `src/index.js` (generada por `npm run build`) + +### 5.3 Context7 (remoto) +| Campo | Valor | +|-------|-------| +| Tipo | `remote` | +| URL | `https://mcp.context7.com/mcp` | +| Header | `CONTEXT7_API_KEY` (desde `.env`) | + +### 5.4 Fetch (local) +| Campo | Valor | +|-------|-------| +| Runtime | npx (Node.js) | +| Comando | `npx -y @h16rkim/mcp-fetch-server` | +| Variables | Ninguna | + +### 5.5 Sequential Thinking (local) +| Campo | Valor | +|-------|-------| +| Runtime | npx (Node.js) | +| Comando | `npx -y @modelcontextprotocol/server-sequential-thinking` | +| Variables | Ninguna | + +### 5.6 DuckDuckGo Search (local) +| Campo | Valor | +|-------|-------| +| Runtime | bunx (Bun) | +| Comando | `C:\Users\%USERNAME%\.bun\bin\bunx.exe duckduckgo-mcp` | +| Variables | Ninguna | +| Nota | Usa ruta absoluta a bunx.exe porque OpenCode no hereda el PATH completo | + +### 5.7 Obsidian (local) +| Campo | Valor | +|-------|-------| +| Runtime | uvx (uv / Python) | +| Comando | `C:\Users\%USERNAME%\.local\bin\uvx.exe mcp-obsidian` | +| Variables | `OBSIDIAN_API_KEY`, `OBSIDIAN_HOST=127.0.0.1`, `OBSIDIAN_PORT=27124` | +| Nota | Usa ruta absoluta a uvx.exe por el mismo motivo que bunx | + +### 5.8 Telegram (local) +| Campo | Valor | +|-------|-------| +| Runtime | npx (Node.js) | +| Comando | `npx -y mcp-telegram` | +| Working Dir | `C:\Users\%USERNAME%` | +| Variables | `TELEGRAM_API_ID`, `TELEGRAM_API_HASH` (desde `.env`), `TELEGRAM_AGENT_HOME=.telegram-agent` | +| Nota | Tras instalación limpia, requiere `telegram_login` para autenticar la sesión | + +--- + +## 6. Variables de entorno (`.env`) + +Archivo: `C:\Users\%USERNAME%\Documents\GitHub\biblioteca_negocio_prolongo\.env` + +| Variable | Usada por | ¿Compartible? | +|----------|-----------|----------------| +| `CONTEXT7_API_KEY` | MCP Context7 | Compartir con el equipo | +| `IMAGE_VISION_AUTH_TOKEN` | MCP Image Vision (OpenRouter) | Compartir con el equipo | +| `IMAGE_VISION_BASE_URL` | MCP Image Vision | Fijo: `https://openrouter.ai/api/v1` | +| `IMAGE_VISION_MODEL` | MCP Image Vision | Fijo: `google/gemini-2.5-flash` | +| `VISION_API_PROVIDER` | MCP Image Vision | Fijo: `openai` | +| `VOICEMONKEY_TOKEN` | Alexa / VoiceMonkey | Compartir con el equipo | +| `VOICEMONKEY_DEVICE` | Alexa / VoiceMonkey | Compartir con el equipo | +| `OBSIDIAN_API_KEY` | MCP Obsidian | Generada por plugin, única por vault | +| `TELEGRAM_API_ID` | MCP Telegram | Personal (cuenta de Telegram de Juanma) | +| `TELEGRAM_API_HASH` | MCP Telegram | Personal (cuenta de Telegram de Juanma) | + +> **IMPORTANTE**: `.env` está en `.gitignore` — NO se sube al repositorio. Guardar copia en: +> - Unidad compartida de red (Z:\GitHub) +> - O en gestor de secretos (1Password, LastPass, etc.) +> - O en Engram (memorias `config` con scope `personal`) +> +> Las variables `TELEGRAM_*` son específicas de la cuenta de Telegram de cada usuario. Si otra persona instala esto, necesitará sus propias credenciales de Telegram API en https://my.telegram.org. + +--- + +## 7. Configuración de OpenCode + +### 7.1 Archivo principal: `opencode.jsonc` + +Ruta: `C:\Users\%USERNAME%\.config\opencode\opencode.jsonc` + +Este archivo se genera automáticamente al lanzar OpenCode por primera vez. Se debe reemplazar con la versión del repositorio: + +```powershell +# IMPORTANTE: Si tu nombre de usuario NO es "juanm", reemplázalo primero: +# (Get-Content "$githubRoot\biblioteca_negocio_prolongo\config\opencode.jsonc") -replace 'juanm', $env:USERNAME | Set-Content "$env:USERPROFILE\.config\opencode\opencode.jsonc" + +# Si tu usuario SÍ es juanm, simplemente: +Copy-Item "$githubRoot\biblioteca_negocio_prolongo\config\opencode.jsonc" "$env:USERPROFILE\.config\opencode\opencode.jsonc" +``` + +> Si el directorio `.config\opencode` no existe, créalo: `New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.config\opencode"` + +### 7.2 Otros archivos en `.config\opencode\` +- `package.json` / `package-lock.json` — dependencias de plugins OpenCode +- `tui.json` — configuración de la interfaz TUI +- `plugins/` — plugins instalados +- `.gitignore` — excluye node_modules + +Estos se regeneran automáticamente. No es necesario respaldarlos, pero si los tienes copiados aceleran el primer arranque. + +--- + +## 8. Instrucciones de IA (AGENTS.md + CLAUDE.md) + +Son archivos de instrucciones que el asistente IA lee automáticamente: + +| Archivo | Ruta | Propósito | +|---------|------|-----------| +| `AGENTS.md` | Raíz del repo `biblioteca_negocio_prolongo` | Reglas del asistente para este proyecto | +| `CLAUDE.md` | `C:\Users\%USERNAME%\.claude\CLAUDE.md` | Instrucciones globales de Engram para cualquier proyecto | + +Ambos ya están en el repositorio. `CLAUDE.md` debe copiarse manualmente a `~\.claude\`: + +```powershell +New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude" +Copy-Item "$githubRoot\biblioteca_negocio_prolongo\config\CLAUDE.md" "$env:USERPROFILE\.claude\CLAUDE.md" +``` + +--- + +## 9. Obsidian + +### 9.1 Instalación +1. Instalar Obsidian desde https://obsidian.md +2. Abrir el vault `Obsidian Vault` ubicado en `C:\Users\%USERNAME%\Documents\Obsidian Vault` +3. Ir a Settings > Community Plugins > Browse +4. Instalar **"Local REST API"** (por Adam Coddington, v4.1.3+) +5. Activar el plugin +6. En la configuración del plugin, copiar la API Key generada y guardarla en `.env` como `OBSIDIAN_API_KEY` + +### 9.2 Vaults esperados +- `wiki-prolongo` — documentación del proyecto sincronizada (el principal) +- `Obsidian Vault` — vault personal de Juanma + +### 9.3 Watchdog de sincronización (Windows Scheduled Task) +```powershell +# Crear tarea programada que ejecute el sync al iniciar sesión +$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-File `"C:\Users\%USERNAME%\Documents\GitHub\biblioteca_negocio_prolongo\scripts\sync_prolongo.ps1`"" +$trigger = New-ScheduledTaskTrigger -AtLogon +$principal = New-ScheduledTaskPrincipal -UserId "$env:USERNAME" -RunLevel Highest +Register-ScheduledTask -TaskName "ProlongoObsidianSync" -Action $action -Trigger $trigger -Principal $principal -Description "Sincroniza documentación del proyecto con Obsidian" +``` + +--- + +## 10. Engram Cloud (memoria compartida) + +El cloud de Engram corre en un VPS Contabo. No es necesario para trabajar, pero permite compartir memoria entre sesiones/máquinas y con el equipo. + +### 10.1 Conexión al cloud +```powershell +engram connect http://185.187.169.109:3801 --api-key +``` + +### 10.2 Si el cloud no responde +```bash +# Conectarse por SSH al VPS +ssh -i C:\Users\%USERNAME%\Documents\GitHub\contabo\contabo root@185.187.169.109 +cd /opt/engram && git pull +docker compose -f docker-compose.cloud.yml up -d --build --force-recreate cloud +``` + +### 10.3 Verificar conexión +```powershell +engram doctor --project biblioteca_negocio_prolongo +``` + +--- + +## 11. Telegram Watcher (script auxiliar) + +Script que monitorea mensajes de Telegram entrantes y los registra en `telegram_mensajes.log`. + +```powershell +# El watcher se lanza automáticamente al iniciar sesión de OpenCode (Regla 6 de AGENTS.md) +# Manualmente: +Start-Process powershell -WindowStyle Hidden -ArgumentList '-Command', 'python C:\Users\%USERNAME%\Documents\GitHub\biblioteca_negocio_prolongo\scripts\telegram_watcher.py' +``` + +Dependencias Python del watcher: +```powershell +pip install telethon +``` + +--- + +## 12. Resumen de pasos para instalación limpia + +```powershell +# === FASE 1: Sistema base === +winget install OpenJS.NodeJS.LTS +winget install Python.Python.3.11 +powershell -c "irm bun.sh/install.ps1 | iex" +powershell -ExecutionPolicy Bypass -Command "irm https://astral.sh/uv/install.ps1 | iex" + +# === FASE 2: Clonar repos === +$githubRoot = "$env:USERPROFILE\Documents\GitHub" +New-Item -ItemType Directory -Force -Path $githubRoot +git clone https://git.v-encore-lab.com/jjminguez/biblioteca_negocio_prolongo.git $githubRoot\biblioteca_negocio_prolongo + +# === FASE 3: Configurar .env === +# Copiar .env desde unidad compartida o gestor de secretos a: +# $githubRoot\biblioteca_negocio_prolongo\.env + +# === FASE 4: Configurar OpenCode === +New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.config\opencode" +Copy-Item "$githubRoot\biblioteca_negocio_prolongo\config\opencode.jsonc" "$env:USERPROFILE\.config\opencode\opencode.jsonc" + +# === FASE 5: Configurar CLAUDE.md === +New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.claude" +Copy-Item "$githubRoot\biblioteca_negocio_prolongo\config\CLAUDE.md" "$env:USERPROFILE\.claude\CLAUDE.md" + +# === FASE 6: Image Vision MCP === +# Copiar carpeta image-vision-mcp desde backup a $githubRoot\image-vision-mcp +cd $githubRoot\image-vision-mcp +npm install +npm run build + +# === FASE 7: Engram === +# Copiar engram.exe a C:\Users\%USERNAME%\bin\engram.exe +engram connect http://185.187.169.109:3801 --api-key + +# === FASE 8: Obsidian === +# 1. Instalar Obsidian +# 2. Abrir vault "Obsidian Vault" y "wiki-prolongo" +# 3. Instalar plugin "Local REST API" v4.1.3+ +# 4. Copiar API Key generada al .env + +# === FASE 9: Tareas programadas === +# Crear ProlongoObsidianSync (ver sección 9.3) + +# === FASE 10: Telegram === +# Al primer uso, OpenCode pedirá hacer login en Telegram +# Seguir las instrucciones (teléfono → código → 2FA) + +# === FASE 11: Arrancar OpenCode === +# Abrir OpenCode en el directorio del proyecto: +# opencode C:\Users\%USERNAME%\Documents\GitHub\biblioteca_negocio_prolongo +``` + +--- + +## 13. Archivos del repositorio relevantes para instalación + +| Archivo | Función | +|---------|---------| +| `INSTALACION_OPENCODE.md` | Este documento | +| `AGENTS.md` | Reglas del asistente IA para este proyecto | +| `config/opencode.jsonc` | Configuración de MCPs y providers | +| `config/CLAUDE.md` | Instrucciones globales de Engram | +| `.env` | Variables de entorno (NO en Git) | +| `scripts/telegram_watcher.py` | Watcher de mensajes Telegram | +| `scripts/sync_prolongo.ps1` | Script de sincronización Obsidian | +| `MEMORIA_ABSOLUTA.md` | Protocolo de memoria del proyecto | +| `ESTADO_DIARIO.md` | Estado diario del proyecto | +| `DOCUMENTACION.md` | Índice de documentación | + +--- + +## 14. Verificación post-instalación + +Para confirmar que todo funciona, abrir OpenCode y ejecutar: + +``` +re +``` + +Debe responder con el estado del proyecto. Luego verificar que todos los MCP aparecen como **Connected** en el panel de MCP Tools (no "Connection Closed"). + +### MCPs que deben aparecer como Connected: +1. ✅ engram +2. ✅ image-vision +3. ✅ context7 +4. ✅ fetch +5. ✅ sequential-thinking +6. ✅ duckduckgo-search +7. ✅ obsidian +8. ✅ telegram + +--- + +*Generado: 28 Junio 2026 — Mantener actualizado con cada cambio de infraestructura.* diff --git a/README.md b/README.md new file mode 100644 index 0000000..a9bac81 --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +# Biblioteca de Conocimiento — Laboratorio + +Repositorio de **laboratorio / pruebas** (test de laboratorio) con la misma estructura y características que `biblioteca_negocio_prolongo`, pero con **contenido vacío**. + +## Propósito + +- Entorno aislado para hacer tests de laboratorio sin tocar la base de conocimiento real. +- Misma configuración de asistentes IA (AGENTS.md), MCP servers y sincronización. +- Se irán añadiendo proyectos de prueba conforme se necesiten. + +## Estructura + +| Carpeta | Contenido previsto | +|---------|-------------------| +| `conocimiento_prolongo_faccsa/` | (vacío — en producción: esquemas BBDD, catálogo artículos, glosario ERP) | +| `guardias/` | (vacío — en producción: manuales, catálogo equipos, wiki errores, extensiones) | +| `planificacion/` | (vacío — planning, pendientes) | +| `powerbi/` | (vacío — conocimiento Power BI) | +| `docs/` | (vacío — documentación arquitectura, integraciones) | +| `config/` | `opencode.jsonc` (MCP: engram, obsidian, telegram, image-vision, context7, fetch, etc.) + `CLAUDE.md` | +| `scripts/` | Scripts de automatización (a rellenar) | + +## Características (idénticas al repo de producción) + +- **AGENTS.md**: mismas reglas e instrucciones para asistentes IA (protocolo RE, memoria absoluta, Engram cloud, sync bidireccional, comandos rápidos) +- **Engram**: conexión al mismo Engram local + cloud (`biblioteca_conocimiento_laboratorio` como proyecto) +- **Obsidian**: conexión al vault vía Local REST API (MCP obsidian) +- **MCP servers**: engram, image-vision, context7, fetch, sequential-thinking, duckduckgo-search, obsidian, telegram (config/opencode.jsonc) +- **.env**: credenciales locales (NO se sube al repo, está en .gitignore) + +## Configuración + +Copiar `.env.example` a `.env` y rellenar con valores reales (o copiar el `.env` del repo de producción si se quiere acceso completo). + +## Notas + +- Las carpetas están vacías a propósito: es un entorno de pruebas. +- Convenciones de nomenclatura: ver AGENTS.md (faccsa con doble C+S-A, programas con guiones 8-4-8, PCs con prefijo+numero VC0012). + +--- +*Creado: 01/08/2026 — Laboratorio* diff --git a/config/CLAUDE.md b/config/CLAUDE.md new file mode 100644 index 0000000..ace560b --- /dev/null +++ b/config/CLAUDE.md @@ -0,0 +1,50 @@ + +## Engram — Persistent Memory + +You have Engram memory tools via MCP. **Use them proactively** — do not wait to be asked. + +### Session Start +- ALWAYS call `engram_briefing` at the start of every session to load context from past sessions. + +### What to Remember (call `engram_remember` immediately) +Store ANY of these the moment you encounter them — do not batch, do not wait: + +**From the user:** +- Preferences, opinions, personal facts, decisions, corrections +- "I prefer X", "we decided Y", "actually it's Z" + +**From your own work:** +- When you read a file and synthesize useful knowledge (style guides, architecture patterns, workflow rules) — store the synthesis +- When you figure out HOW the user works (communication style, review habits, tool preferences) — store the observation +- When you discover project conventions, naming patterns, or implicit rules — store them +- When you build something and learn what works vs what doesn't — store the lesson + +**The rule:** If this knowledge would be useful in a future session, store it NOW. Don't assume you'll remember — you won't. + +### Team Vault +- When connected to a hosted vault, memories are shared with your team by default +- Use `engram_private_session` if the user wants a confidential session (nothing leaves the local machine) +- Use `engram_invite` to add a teammate when asked ("add Brian to engram", "invite tyler@company.com") +- Recall always searches both local + shared vaults, so you see everything + +### Asking Questions +- When you need to ANSWER a question from memory: call `engram_ask` — it returns a synthesized answer with confidence, not raw memories +- When you need raw memory objects for processing: call `engram_recall` +- Prefer `engram_ask` for user-facing answers, `engram_recall` for your own analysis + +### Alerts +- Periodically call `engram_alerts` to check for pending commitments, stale follow-ups, and contradictions +- Alerts are included in `engram_briefing` automatically, but call separately if you need a quick check + +### Auditing External Memory +- If you maintain a CLAUDE.md, MEMORY.md, or similar file: periodically call `engram_audit` with its contents +- It will flag any claims that are outdated or contradicted by newer vault data + +### Before Compacting / Session End +- Before context compaction or ending a session, call `engram_checkpoint` with a summary of: + - Decisions made and their reasoning + - Facts learned or corrected (especially things that changed from what you previously knew) + - Commitments and next steps + - Current project state +- This extracts durable memories from your context window before it is lost +- Your context window is the most accurate source of truth you have — and the most volatile. Save it. diff --git a/config/opencode.jsonc b/config/opencode.jsonc new file mode 100644 index 0000000..104aa3a --- /dev/null +++ b/config/opencode.jsonc @@ -0,0 +1,111 @@ +{ + "$schema": "https://opencode.ai/config.json", + "disabled_providers": [ + + ], + "mcp": { + "engram": { + "command": [ + "C:\\Users\\juanm\\bin\\engram.exe", + "mcp", + "--tools=agent" + ], + "enabled": true, + "type": "local" + }, + "image-vision": { + "type": "local", + "command": [ + "node", + "C:\\Users\\juanm\\Documents\\GitHub\\image-vision-mcp\\dist\\index.js" + ], + "enabled": true, + "environment": { + "IMAGE_VISION_AUTH_TOKEN": "{env:IMAGE_VISION_AUTH_TOKEN}", + "IMAGE_VISION_BASE_URL": "https://openrouter.ai/api/v1", + "IMAGE_VISION_MODEL": "google/gemini-2.5-flash", + "VISION_API_PROVIDER": "openai" + } + }, + "context7": { + "type": "remote", + "url": "https://mcp.context7.com/mcp", + "enabled": true, + "headers": { + "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}" + } + }, + "fetch": { + "type": "local", + "command": [ + "npx", + "-y", + "@h16rkim/mcp-fetch-server" + ], + "enabled": true + }, + "sequential-thinking": { + "type": "local", + "command": [ + "npx", + "-y", + "@modelcontextprotocol/server-sequential-thinking" + ], + "enabled": true + }, + "duckduckgo-search": { + "type": "local", + "command": [ + "C:\\Users\\juanm\\.bun\\bin\\bunx.exe", + "duckduckgo-mcp" + ], + "enabled": true + }, +"obsidian": { + "type": "local", + "command": [ + "C:\\Users\\juanm\\.local\\bin\\uvx.exe", + "mcp-obsidian" + ], + "enabled": true, + "environment": { + "OBSIDIAN_API_KEY": "{env:OBSIDIAN_API_KEY}", + "OBSIDIAN_HOST": "127.0.0.1", + "OBSIDIAN_PORT": "27124" + } + }, + "telegram": { + "type": "local", + "command": [ + "npx", + "-y", + "mcp-telegram" + ], + "enabled": true, + "cwd": "C:\\Users\\juanm", + "environment": { + "TELEGRAM_API_ID": "{env:TELEGRAM_API_ID}", + "TELEGRAM_API_HASH": "{env:TELEGRAM_API_HASH}", + "TELEGRAM_AGENT_HOME": ".telegram-agent", + "MCP_TELEGRAM_TOOLS": "login,list_accounts,list_dialogs,search_dialogs,list_messages,search_messages,search_global,get_message,send_message,edit_message,delete_messages,forward_messages,send_reaction,get_message_reactions,send_file,download_media,list_contacts,search_contacts,get_me,transcribe_message,get_inline_bot_results,mark_as_read,send_poll,vote_poll,get_poll_results" + } + } + }, + "provider": { + "ollama": { + "name": "Ollama", + "npm": "@ai-sdk/openai-compatible", + "models": { + "gemma4": { + "name": "Gemma 4 Local" + }, + "deepseek-coder-v2:16b": { + "name": "DeepSeek Coder Local" + } + }, + "options": { + "baseURL": "http://localhost:11434/v1" + } + } + } +}