Saltar al contenido
Menú

Producto

Soluciones

Integraciones

Desarrolladores

Idioma

Desarrolladores

Contribuye a ai-memory

101 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

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.