Saltar al contenido
Menú

Producto

Soluciones

Integraciones

Desarrolladores

Idioma

Desarrolladores

Contribuye a ai-memory

140 personas han aportado código hasta ahora. Esta página te lleva de una idea al issue correcto, al crate correcto y a un pull request que pasa la revisión a la primera.

Elige por dónde entrar

Cada una lleva a la página exacta en GitHub.

Diagrama: una contribución pasa por seis etapas, de un issue a una rama, a los checks locales, a un pull request y a la revisión, y sale en la siguiente versión.
De la idea a la versión. Las correcciones salen en el siguiente patch, y las funciones aditivas en la siguiente minor.

Ponlo a compilar

La compilación es autocontenida. Ninguno de estos comandos necesita una variable de entorno.

  1. Clona y compila

    Hace falta Rust 1.95, fijado en rust-toolchain.toml junto con rustfmt y clippy, así que rustup instala el toolchain correcto en la primera compilación. SQLite va incluido y libgit2 va vendorizado. Necesitas un toolchain de C estándar y nada más.

    entorno de desarrollo
    git clone https://github.com/akitaonrails/ai-memory
    cd ai-memory
    cargo build --workspace
    cargo test --workspace --all-targets
    
  2. Usa el ciclo del día a día

    cargo t necesita nextest: cargo install cargo-nextest --locked. Se salta los módulos llamados slow o stress, que el hook de pre-push y el CI siguen ejecutando.

    mientras trabajas
    cargo t                        # todo menos el nivel lento, ~20 s en caliente
    cargo t -p ai-memory-store     # un crate: compila solo sus binarios de test
    cargo t -E 'test(/purge/)'     # un tema (compila todo, ejecuta un subconjunto)
    
  3. Instala el hook de pre-push

    Una vez por clon. Solo toca su propio bloque en .git/hooks/pre-push. En una rama con trabajo en curso, git push --no-verify se lo salta.

    una vez por clon
    scripts/install-git-hooks.sh
    
  4. Pasa los checks antes de hacer push

    El CI exige los cinco. Sin nextest, cargo test --workspace --all-targets equivale a cargo tf. Si te falta el último: cargo install cargo-deny cargo-audit.

    checks obligatorios
    cargo fmt --all -- --check
    git diff --check
    cargo clippy --workspace --all-targets -- -D warnings
    cargo tf                            # todos los tests (alias: cargo nextest run -P full)
    cargo deny check                    # política de dependencias
    
  5. Comprueba quién dicen tus commits que eres

    Usa un email verificado en tu cuenta de GitHub o su dirección noreply. El historial de main nunca se reescribe para corregir la autoría.

    autoría de los commits
    git log --format='%h %an <%ae>' "$(git merge-base HEAD origin/main)"..HEAD
    

Reglas básicas y el listón de aceptación

AGENTS.md es el archivo de reglas canónico, para personas y para agentes de programación. CONTRIBUTING.md lo condensa en esto.

Cómo se espera que llegue el trabajo

  • El changelog es un requisito de merge

    Cada cambio de cara al usuario añade una entrada bajo [Unreleased] en el mismo pull request. Los revisores tratan una entrada ausente como bloqueante. Los refactors y los cambios que solo tocan tests están exentos.

  • Tests antes de dar algo por “hecho”

    El trabajo cuenta como hecho cuando tiene tests, sobre todo los parsers, la derivación de ID y los cálculos de retención.

  • Sin código muerto ni funciones a medias

    Los stubs se documentan en el comentario del módulo, con el hito que los va a terminar.

  • No te salgas del cambio

    No refactorices código que el hito actual no necesita.

  • Los comentarios explican el porqué

    Un comentario que repite la línea de arriba se elimina.

Invariantes que un pull request no puede romper

  • Todas las escrituras a SQLite pasan por el único actor escritor, WriterHandle.
  • La configuración se lee una vez al arrancar. Ningún std::env::var fuera de Config::load.
  • Las escrituras de archivos son atómicas: tmp, rename, fsync. Nunca sobre el propio archivo.
  • Cada página de la wiki lleva el espacio de nombres (workspace_id, project_id).
  • La CLI es un cliente HTTP ligero. Nunca abre el archivo SQLite ni el directorio de la wiki.

La lista completa, con el bug que evita cada uno, está en AGENTS.md

Cómo se mantiene el listón alto

La IA escribe la mayor parte del código. Una persona lo lee todo y nada se fusiona sin comprobarlo. Cada regla de aquí abajo existe porque algo salió mal alguna vez.

Diagrama: un bucle de cuatro etapas. Un error se convierte en una regla escrita, la regla recibe un test que intenta romperla, y el test se ejecuta como requisito en cada pull request. Una persona está en el centro y decide.
Nada de esto existía el primer día. Cada regla se añadió después de un error real, y cada una se revisa en cada pull request.
  • Las reglas nacen de errores

    Cada invariante indica el bug que la causó y el código que lo evita. Una regla que nadie puede rastrear hasta un fallo se elimina.

  • Cada pull request se audita

    Lo que dice un pull request se contrasta con el código, los checks se vuelven a ejecutar, y solo se fusiona lo verificado. Las checklists de auditoría son públicas.

  • Una persona decide

    La IA hace la mayor parte de la escritura. El mantenedor lee, corrige y convierte lo que salió mal en la siguiente regla.

Lee las checklists de auditoría

Dos modelos, una misma checklist de auditoría

Un experimento pequeño con ai-jail, el sandbox al que se le puede entregar una ejecución con --yolo. La misma checklist de security-audit, ejecutada por dos modelos sobre el mismo commit, y después comparada.

  • El objetivo

    ai-jail ejecuta un agente de programación con IA dentro de un sandbox del sistema operativo: bubblewrap con Landlock y seccomp en Linux, sandbox-exec en macOS. Es una capa, no un sustituto de una máquina desechable cuando el código es hostil.

    aijail.io
  • La primera ejecución

    Genesys Pi, manejado a través de OpenCode, primero hizo trabajo de implementación normal en ai-jail y lo fusionó. Después ejecutó la checklist de security-audit del repositorio público de checklists contra la v2.3.0.

    La publicación sobre las checklists
  • La segunda ejecución

    Claude Fable 5.1 ejecutó la misma checklist sobre el mismo commit sin leer el primer informe. Una vez corregida su lista, volvió a derivar desde el código fuente cada pista compartida y escribió la comparación.

  1. Encontrado por ambos11
  2. Solo Genesys Pi11
  3. Solo Claude Fable 5.13
Todas las severidades tal como las indicó cada informe. Ambos informes reprodujeron por su cuenta los mismos dos hallazgos High.
  • Los mismos dos High

    Metadatos de worktree falsificados daban acceso de lectura y escritura a un directorio del host, y entradas de entorno duplicadas se colaban por encima del secreto fantasma. Cada modelo reprodujo ambos hallazgos sin ayuda del otro.

  • Genesys Pi llegó más lejos

    Once hallazgos a los que solo él llegó, entre ellos toda la superficie de macOS y los límites de recursos del proxy, con severidades mejor calibradas. Fable había descartado un bug real y dejado otros dos sin resolver hasta la verificación cruzada.

  • Fable encontró el descuido más grave

    Dos vías de escape de solo pruebas en el binario de release, leídas desde el entorno, estaban justo en la ruta que protegen las credenciales fantasma. Además, ejecutó los exploits en los puntos donde el otro informe solo había razonado sobre ellos.

Los tres informes, en el repositorio de ai-jail

Un mapa del código

En el binario van diez crates. Cada uno tiene una responsabilidad y una API tipada, y no hay dependencias circulares.

Diagrama: los crates en cuatro niveles. El crate cli está arriba. Debajo están hooks, mcp, web, consolidate y workstream. Debajo de esos están store, wiki y llm. El crate core es la base de todo.
Nombres de los crates sin el prefijo ai-memory-. Todo depende de core, y solo el crate cli depende de todo.
CrateQué vive ahí
ai-memory-coreTipos de dominio, errores e ids. Sin IO.
ai-memory-storeSQLite, el actor escritor, el pool de lectores y los cálculos de decaimiento.
ai-memory-wikiEscrituras atómicas de markdown, el file watcher y git.
ai-memory-mcpEl transporte MCP, el enrutador de herramientas y las rutas de administración.
ai-memory-hooksLos esquemas de payload de los hooks, el saneador y el endpoint /hook.
ai-memory-llmLa frontera de autenticación de proveedores y los traits de LLM y embedder.
ai-memory-consolidateIngesta, lint, barrido y el pipeline de auto-improve.
ai-memory-webEl navegador /web de solo lectura y las rutas JSON de /api/v1.
ai-memory-workstreamLectores de solo lectura de transcripciones nativas y los adaptadores de lanzamiento detrás de ai-memory run.
ai-memory-cliEl binario ai-memory y sus subcomandos HTTP ligeros.

Fuera de crates/

DirectorioQué vive ahí
companions/ai-memory-importer, un paquete independiente fuera del workspace raíz. Compílalo con --manifest-path.
hooks/Paquetes de hooks de ciclo de vida, una carpeta por agente, en shell y nativos.
evals/El harness de benchmarks. Es miembro del workspace y nunca se distribuye.
docs/Guías de arquitectura, decisiones de diseño, instalación, despliegue y uso.
tests/Smoke tests de extremo a extremo, tests de shell de los hooks y fixtures.

Los tests de integración viven en tests/suite/ dentro de cada crate. Los helpers compartidos entre crates van en crates/ai-memory-test-support, que nunca se distribuye.

Cómo se revisan los pull requests

Las revisiones siguen la plantilla del pull request, así que rellenarla con honestidad es la mayor parte del trabajo.

  • La plantilla es la checklist

    Pregunta qué cambió, por qué, un plan de pruebas con los checks marcados, la autoría de los commits, el impacto en la versión y la entrada del changelog.

  • Di qué tipo de versión es

    Marca patch, minor o major. Una corrección archivada bajo “Added” puede subir la versión equivocada, así que pon la entrada del changelog bajo el encabezado correcto.

  • Los cambios incompatibles esperan a una major

    Señálalos en la descripción. Reciben la etiqueta breaking-change y se programan, así que no frenan las versiones patch y minor.

  • El CI es rápido en cada merge

    Un merge depende de los jobs rápidos de Linux. Las partes de macOS y Windows corren con una etiqueta, cada noche o a mano, y siempre antes de una versión.

  • Las correcciones salen primero

    Una corrección de bug sale en la siguiente versión patch y no se retiene por trabajo de funciones. Un harness o un proveedor nuevo sale en la siguiente minor.

Un pull request de harness ejecuta este check más corto, registra la versión de la CLI contra la que se probó e incluye una pasada manual contra el harness real.

de managed-harness-contributions.md
cargo fmt --check
git diff --check
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings

Pruébalo antes de cambiarlo.

Úsalo en tus propios proyectos durante un día. El bug que encuentres es tu primer issue.