Verum

Verum es un analizador de código determinista y de programa completo. Mapea un código base en una única representación intermedia (símbolos, grafo de llamadas, rutas, flujos de datos) y luego ejecuta un conjunto de análisis sobre ese mapa: código muerto, duplicados, comprobaciones de seguridad basadas en taint, complejidad, nomenclatura e infraestructura (Kubernetes, Dockerfile, Terraform). Es un único binario estático sin paso de compilación ni servidor de lenguaje, por lo que se ejecuta en un checkout recién hecho en una fracción de segundo.

Misma entrada, misma salida. Cada id de símbolo, hallazgo e informe se deriva de un hash estable de la fuente, por lo que dos ejecuciones sobre el mismo árbol producen resultados idénticos byte a byte. Eso hace que Verum sea utilizable como puerta de CI, como línea base contra la que puedes hacer diff, y como capa de hechos en la que las herramientas y agentes pueden confiar.

Lenguajes compatibles: PHP, Rust, JavaScript, TypeScript, Python, Go y Java, además de Kubernetes YAML, Dockerfiles y Terraform.

Example

Related MCP server: Ferret MCP

Install

cargo install verum                 # compile from crates.io
cargo binstall verum                 # or grab the prebuilt binary, no compile
docker run --rm -v "$PWD:/work" ghcr.io/ibmark/verum audit .   # or no install

Los binarios precompilados para Linux (gnu/musl), macOS (x86_64/arm64) y Windows se adjuntan a cada release.

cargo install compila un binario verum en tu PATH (Verum se compila con Rust estable 1.82 o superior). Para compilar desde un checkout en su lugar, usa cargo install --path crates/verum. Para un binario Linux estático que puedes copiar a cualquier lugar:

cargo build --release --target x86_64-unknown-linux-musl

El mismo crate es una biblioteca. Añade verum como dependencia para analizar un árbol en el IR y ejecutar los análisis programáticamente:

use verum::{Atlas, AtlasConfig, Prism, Standard};

let ir = Atlas::new(AtlasConfig { root: ".".into(), ..Default::default() }).build()?;
let result = Prism::analyse(&ir, &Standard::default())?;
println!("score: {}", result.score.overall);

Usage

verum analyse <path>    # map the code into the IR - symbol/call/route counts
verum audit <path>      # map + analyse - findings and a score, no changes
verum clean <path>      # audit + preview the dead-code/duplicate fixes
verum map <path>        # module/symbol graphs, cycles, SPOFs, data flows
verum gate <path>       # exit non-zero if the deploy-gate thresholds fail
verum baseline <path>   # snapshot findings so gate only fails on new ones
verum report <path>     # markdown | json | sarif | a self-contained html report
verum init [path]       # write a default verum.standard.json

audit puntúa el código y lista los hallazgos por severidad. clean informa de las correcciones que aplicaría (símbolos sin llamador, cuerpos duplicados para reasignar) e identifica cada uno por archivo y línea. Se ejecuta solo en modo informe y no modifica tus archivos; trata su salida como una lista de trabajo para aplicar manualmente.

Continuous integration

verum gate <path> sale con código 1 cuando fallan los umbrales de la puerta de despliegue y 0 cuando pasan, por lo que un pipeline puede confiar en el código de salida en lugar de analizar la salida. verum report <path> --format json emite los hallazgos y la puntuación como JSON para un panel o una comprobación personalizada.

# .github/workflows/verum.yml
name: verum
on: [push, pull_request]
jobs:
  gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: IBMark/verum-action@v1   # runs `verum gate .` by default

En un código base existente, toma una instantánea de los hallazgos actuales una vez con verum baseline . y confirma el resultado; entonces la puerta solo falla en hallazgos que son nuevos en relación con esa línea base, por lo que puedes adoptarla sin tener que arreglar primero todo lo que informa.

verum report <path> --format sarif emite SARIF 2.1.0, por lo que los hallazgos aparecen como anotaciones en línea en las solicitudes de extracción y en la pestaña de Seguridad del repositorio:

      - run: verum report . --format sarif --out verum.sarif
      - uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: verum.sarif

Agent / MCP

verum mcp <path> sirve el análisis como un servidor de herramientas MCP sobre stdio, para que un agente pueda consultar el mapa en lugar de hacer grep. Expone el grafo de llamadas (callers_of, callees_of, impact_of), dead_code, duplicates, audit, audit_delta (hallazgos solo en archivos modificados en comparación con una ref de git) y endpoints (qué llamadas HTTP de cliente llegan a qué rutas). El mapa se vuelve a comprobar contra los mtimes del árbol en cada llamada, por lo que las respuestas siguen tus ediciones.

Cualquier cliente compatible con MCP puede conectarse a través de stdio. Por ejemplo, con Claude Code:

claude mcp add verum -- verum mcp /path/to/project

Cross-language

Verum analiza cada lenguaje compatible en un solo IR, por lo que un fetch('/api/users') en un frontend TypeScript se enlaza con el manejador de ruta que lo sirve, incluso cuando ese manejador está en otro lenguaje. La herramienta endpoints de verum mcp informa de las coincidencias, además de las llamadas de frontend que no llegan a ninguna ruta (probablemente 404) y las rutas que ningún cliente llama (posiblemente muertas).

Optional AI layer

verum full puede enviar los hallazgos ambiguos (aquellos que el análisis determinista no puede resolver por sí solo) a un modelo de lenguaje para una decisión de mantener/eliminar/desaprobar. Es neutral respecto al proveedor: habla la API de chat compatible con OpenAI y se configura completamente a través del entorno, por lo que funciona con una API alojada o un ejecutor local (ollama, llama.cpp, vLLM, LM Studio). No se contacta con nada a menos que establezcas un endpoint.

export VERUM_AI_ENDPOINT="http://localhost:11434/v1/chat/completions"
export VERUM_AI_MODEL="qwen2.5-coder"
verum full <path>

Configuration

verum init escribe verum.standard.json (umbrales de análisis, reglas de nomenclatura por lenguaje, la lista blanca de criptografía débil y los límites de la puerta de despliegue). Todo tiene un valor predeterminado razonable, por lo que el archivo es opcional.

How it works

files -> map (mappa) -> IR -> analyse (lumen) -> findings + score
                            -> plan (faber)    -> fix worklist

mappa analiza archivos en paralelo mediante tree-sitter y los fusiona en un solo IR. Los ids son un hash FNV-1a estable de la ruta, lo que los mantiene reproducibles y permite que los archivos se analicen de forma independiente sin un contador compartido. lumen ejecuta los análisis sobre el IR fusionado; faber convierte los hallazgos seguros en una lista concreta de ediciones (solo informe en esta versión).

El espacio de trabajo se divide a lo largo de ese pipeline: verum-nucleus (IR compartido y tipos de hallazgos), verum-mappa (analizadores), verum-lumen (análisis), verum-faber (planificador de correcciones), verum-arbiter (capa de IA opcional) y verum (el binario y la fachada de biblioteca).

License

Con doble licencia bajo cualquiera de

• Apache License, Versión 2.0 (LICENSE-APACHE)

• Licencia MIT (LICENSE-MIT)

a tu elección.