Verum

Verum ist ein deterministischer, ganzheitlicher Code-Analysator. Er bildet eine Codebasis auf eine einzige Zwischendarstellung ab – Symbole, Aufrufgraph, Routen, Datenflüsse – und führt dann eine Reihe von Analysen über diese Abbildung aus: toten Code, Duplikate, Taint-basierte Sicherheitsprüfungen, Komplexität, Namensgebung und Infrastruktur (Kubernetes, Dockerfile, Terraform). Es ist eine einzelne statische Binärdatei ohne Build-Schritt und ohne Language Server, sodass sie auf einem frischen Checkout in einem Bruchteil einer Sekunde läuft.

Gleiche Eingabe, gleiche Ausgabe. Jede Symbol-ID, jeder Befund und jeder Bericht wird aus einem stabilen Hash der Quelle abgeleitet, sodass zwei Läufe auf demselben Baum byte-identische Ergebnisse erzeugen. Das macht Verum als CI-Gate nutzbar, als Baseline, gegen die man diffen kann, und als Faktenebene, auf die sich Tools und Agenten verlassen können.

Unterstützte Sprachen: PHP, Rust, JavaScript, TypeScript, Python, Go und Java, sowie Kubernetes-YAML, Dockerfiles und Terraform.

Beispiel

Related MCP server: Ferret MCP

Installation

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

Vorgefertigte Binärdateien für Linux (gnu/musl), macOS (x86_64/arm64) und Windows sind an jede Version angehängt.

cargo install erstellt eine verum-Binärdatei in deinem PATH (Verum baut mit stabilem Rust 1.82 oder neuer). Um stattdessen aus einem Checkout zu bauen, verwende cargo install --path crates/verum. Für eine statische Linux-Binärdatei, die du überallhin kopieren kannst:

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

Dieselbe Crate ist auch eine Bibliothek. Füge verum als Abhängigkeit hinzu, um einen Baum in das IR zu parsen und die Analysen programmatisch auszuführen:

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);

Verwendung

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 bewertet den Code und listet Befunde nach Schweregrad auf. clean meldet die Korrekturen, die es anwenden würde – Symbole ohne Aufrufer, doppelte Körper zum Neuzuordnen – und identifiziert jedes einzelne nach Datei und Zeile. Es läuft nur als Bericht und verändert deine Dateien nicht; behandle seine Ausgabe als Arbeitsliste, die du von Hand abarbeitest.

Kontinuierliche Integration

verum gate <path> beendet sich mit 1, wenn die Deploy-Gate-Schwellenwerte nicht erreicht werden, und mit 0, wenn sie erreicht werden, sodass eine Pipeline sich auf den Exit-Code verlassen kann, statt die Ausgabe zu parsen. verum report <path> --format json gibt die Befunde und die Bewertung als JSON für ein Dashboard oder eine eigene Prüfung aus.

# .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

Bei einer bestehenden Codebasis kannst du die aktuellen Befunde einmal mit verum baseline . als Schnappschuss speichern und das Ergebnis committen; das Gate schlägt dann nur bei Befunden fehl, die neu relativ zu dieser Baseline sind, sodass du es übernehmen kannst, ohne zuerst alles zu beheben, was es meldet.

verum report <path> --format sarif erzeugt SARIF 2.1.0, sodass Befunde als Inline-Pull-Request-Anmerkungen und im Sicherheits-Tab des Repositorys erscheinen:

      - 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> stellt die Analyse als MCP-Toolserver über stdio bereit, sodass ein Agent die Abbildung abfragen kann, statt zu greppen. Er stellt den Aufrufgraph (callers_of, callees_of, impact_of), dead_code, duplicates, audit, audit_delta (nur Befunde in Dateien, die gegenüber einem git-Ref geändert wurden) und endpoints (welche Client-HTTP-Aufrufe welche Routen treffen) bereit. Die Abbildung wird bei jedem Aufruf gegen die mtimes des Baums geprüft, sodass die Antworten deine Änderungen nachvollziehen.

Jeder MCP-fähige Client kann sich über stdio verbinden. Zum Beispiel mit Claude Code:

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

Sprachübergreifend

Verum parst jede unterstützte Sprache in ein einziges IR, sodass ein fetch('/api/users') in einem TypeScript-Frontend mit dem Routen-Handler verknüpft wird, der es bedient – selbst wenn dieser Handler in einer anderen Sprache geschrieben ist. Das endpoints-Tool von verum mcp meldet die Übereinstimmungen sowie Frontend-Aufrufe, die keine Route treffen (wahrscheinlich 404s), und Routen, die kein Client aufruft (möglicherweise tot).

Optionale KI-Ebene

verum full kann die mehrdeutigen Befunde – diejenigen, die die deterministische Analyse nicht allein auflösen kann – an ein Sprachmodell senden, um eine Behalten/Löschen/Verwerfen- Entscheidung zu treffen. Es ist anbieterneutral: Es spricht die OpenAI-kompatible Chat-API und wird vollständig über die Umgebung konfiguriert, sodass es mit einer gehosteten API oder einem lokalen Runner (ollama, llama.cpp, vLLM, LM Studio) funktioniert. Es wird nichts kontaktiert, außer du setzt einen Endpunkt.

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

Konfiguration

verum init schreibt verum.standard.json – Analyse-Schwellenwerte, sprachspezifische Namensregeln, die Weak-Crypto-Allowlist und die Deploy-Gate-Grenzen. Alles hat einen sinnvollen Standardwert, sodass die Datei optional ist.

So funktioniert es

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

mappa parst Dateien parallel über tree-sitter und führt sie zu einem einzigen IR zusammen. IDs sind ein stabiler FNV-1a-Hash des Pfads, was sie reproduzierbar macht und es erlaubt, Dateien unabhängig ohne gemeinsamen Zähler zu parsen. lumen führt die Analysen über dem zusammengeführten IR aus; faber wandelt die sicheren Befunde in eine konkrete Liste von Änderungen um (in dieser Version nur als Bericht).

Der Workspace ist entlang dieser Pipeline aufgeteilt: verum-nucleus (gemeinsames IR und Befund- typen), verum-mappa (Parser), verum-lumen (Analysen), verum-faber (Fix- Planer), verum-arbiter (optionale KI-Ebene) und verum (die Binärdatei und die Bibliotheks-Fassade).

Lizenz

Dual-lizenziert unter einer der folgenden Lizenzen:

• Apache License, Version 2.0 (LICENSE-APACHE)

• MIT License (LICENSE-MIT)

nach deiner Wahl.