import { auriel } from "@herald/structure";const angels = await loadCouncil(); // Lettre I, Auriel// Trois modules se citent en boucle. if (deps.has(cycle)) {  return new Finding({    angel: "auriel",    severity: "major",    files: cycles,  });} export type Lettre = {  ange: AngelName;  domain: Domain;  body: string;}; await council.gather();report.sign(["auriel", "uriel"]);import { auriel } from "@herald/structure";const angels = await loadCouncil(); // Lettre I, Auriel// Trois modules se citent en boucle. if (deps.has(cycle)) {  return new Finding({    angel: "auriel",    severity: "major",    files: cycles,  });} export type Lettre = {  ange: AngelName;  domain: Domain;  body: string;}; await council.gather();report.sign(["auriel", "uriel"]);

import { uriel } from "@herald/security";const secrets = uriel.detectLeaks(src); // flagged: STRIPE_SECRET// dormant 48 days in config.dev.ts function detectCircularDeps(modules) {  const visited = new Set();  for (const m of modules) {    if (findCycle(m, visited)) {      return cycle;    }  }} const apiKey = process.env.SECRET;// uriel: Lettre II git log --since="48 days" .envimport { uriel } from "@herald/security";const secrets = uriel.detectLeaks(src); // flagged: STRIPE_SECRET// dormant 48 days in config.dev.ts function detectCircularDeps(modules) {  const visited = new Set();  for (const m of modules) {    if (findCycle(m, visited)) {      return cycle;    }  }} const apiKey = process.env.SECRET;// uriel: Lettre II git log --since="48 days" .env

export class Cassiel extends Angel {  domain = "patterns-ia";  detect() {    return this.code      .filter(odeurUniforme)      .map(seven);  }} // Sept fonctions de même odeur.// Variables génériques.// Structure trop régulière. async function* readSource() {  for await (const f of walk(path)) {    yield parseAST(f);  }} const score = compute(findings);export class Cassiel extends Angel {  domain = "patterns-ia";  detect() {    return this.code      .filter(odeurUniforme)      .map(seven);  }} // Sept fonctions de même odeur.// Variables génériques.// Structure trop régulière. async function* readSource() {  for await (const f of walk(path)) {    yield parseAST(f);  }} const score = compute(findings);

await zadkiel.review({  conventions: "strict",  deadCode: true,}); // 83% respecte les conventions.// Le reste tire ailleurs. const report = await council.gather();report.sign(allAngels); // Raziel, Lettre VI// README parle d'une commande// qui n'existe plus. export const verdict = (r: Report) => ({  score: r.score,  ranked: r.findings.sort(bySeverity),}); console.log("Six lettres signées.");await zadkiel.review({  conventions: "strict",  deadCode: true,}); // 83% respecte les conventions.// Le reste tire ailleurs. const report = await council.gather();report.sign(allAngels); // Raziel, Lettre VI// README parle d'une commande// qui n'existe plus. export const verdict = (r: Report) => ({  score: r.score,  ranked: r.findings.sort(bySeverity),}); console.log("Six lettres signées.");

Async

Herald

L’Ange gardien de votre code source, Sans IA et Sans Stockage.

Public ou privé · Analyse en moins de 60 secondes · Aucun code source stocké · Voir la politique de confidentialité

Analyser votre code en illimité, sans IA

Collez un extrait de code ou confiez un dépôt. Chaque faille est soulignée, un rapport noté vous est rendu — sans IA, sans stockage.

Failles & relevés soulignés en direct
Verdict en moins de 60 secondes
Sans IA · sans stockage de votre code

Démo instantanée · aucun compte requis

Ce que Herald regarde

Tout ça, dès l’analyse gratuite

Cinq familles passées au crible à chaque passage — sans IA, sans stockage, et gratuitement. Voici ce que le concile débusque dans chacune.

Sécurité

Vos secrets ne doivent jamais fuiter

Herald relit chaque ligne à la recherche de ce qui ne devrait jamais s’y trouver : clés d’API en clair, mots de passe codés en dur, et toutes les portes laissées ouvertes à l’exécution.

Clés API & tokens en clair
Mots de passe codés en dur
Injection SQL & commande
eval() / Function() dynamiques
XSS via innerHTML
CORS en « * » permissif
Crypto faible (MD5 · SHA-1)
Secrets écrits dans les logs

Dépendances

Vos paquets sont-ils à jour — et sûrs ?

Herald lit votre manifeste (package.json, Cargo.toml, requirements…) et passe chaque dépendance au crible : version, maintenance, vulnérabilités connues, et tout ce que vous traînez sans le savoir.

CVE & avis de sécurité connus
Versions majeures en retard
Paquets non maintenus
Dépendances inutilisées
Imports non déclarés (fantômes)
Doublons de versions
Licences incompatibles
Versions non épinglées

Qualité de code

Du code lisible, que l’on ose toucher

Au-delà des bugs, Herald mesure ce qui rend le code fragile : fonctions interminables, complexité qui explose, conventions ignorées et petits oublis laissés en chemin.

Fonctions trop longues
Complexité cyclomatique élevée
Code dupliqué
Nommage incohérent
console.log oubliés
TODO / FIXME en suspens
Nombres magiques
Imbrication trop profonde

Code mort

Ce qui ne sert plus, Herald le débusque

Imports oubliés, variables jamais lues, fonctions que plus personne n’appelle, branches injoignables : Herald révèle tout ce qui alourdit le dépôt sans rien apporter.

Imports inutilisés
Variables jamais lues
Fonctions jamais appelées
Code après un return
Branches injoignables
Exports orphelins
Paramètres non utilisés
Conditions toujours vraies / fausses

Architecture

Des dépendances qui restent en ordre

Herald cartographie les liens entre vos modules et signale ce qui désorganise l’ensemble : cycles d’import, couches franchies, couplage qui durcit chaque évolution.

Dépendances circulaires
Couches d’architecture violées
Couplage trop fort
Modules « god object »
Imports inter-domaines
Profondeur de dépendance excessive
Points d’entrée multiples
Modules orphelins

Analyse Premium · dès 4,99 € / mois

Le concile va plus loin

De nouvelles familles d’analyse arrivent avec Premium — pour juger la conception, l’héritage et la maturité de votre code, pas seulement ses bugs.

Pro patternsPremium

Un code qui respecte les grands principes

Au-delà des bugs, Herald Premium juge la conception : responsabilités bien séparées, abstractions justes, aucune répétition inutile.

Responsabilité unique (SRP)
Ouvert / fermé (OCP)
Inversion de dépendance
DRY · pas de duplication
KISS · pas de sur-ingénierie
Loi de Déméter

Patterns IA toxiquesPremium

Le code assisté par IA, sous surveillance

Le code généré va vite — parfois trop. Herald repère les dérives propres à l’IA : abstractions inventées, sur-ingénierie et copier-coller massif.

Sur-ingénierie & abstractions prématurées
API hallucinées / inexistantes
Dépendances inventées
Commentaires verbeux inutiles
Copier-coller massif
Code mort généré

Analyse de l’historique GitPremium

Ce que cache votre historique

Herald remonte le fil des commits : secrets oubliés dans le passé, fichiers trop lourds, et l’hygiène générale de vos branches.

Secrets commités dans l’historique
Fichiers binaires trop lourds
Messages de commit vides
Fichiers sensibles (.env)
Branches obsolètes
Commits géants

Rapport téléchargeablePremium

Un rapport à garder et à partager

Le rapport complet, exportable en PDF — note globale, détail par règle et correctifs. À archiver, partager avec l’équipe ou joindre à une revue.

Export PDF complet
Note globale & par catégorie
Correctif détaillé par relevé
Historique de vos analyses
Partage par lien
Prêt pour la revue de code

Code source en localPremium

Le moteur, chez vous comme en CI

Récupérez le binaire et faites tourner le concile sur l’intégralité de votre dépôt — en local, hors-ligne, ou intégré à votre pipeline.

CLI exécutable en local
Analyse hors-ligne complète
Intégration CI/CD
Hook pre-commit
Sortie JSON / SARIF
Badge de build

Découvrir Premium À venir · inclus dans Premium dès 4,99 € / mois

Le manuel

Documentation

L’API, les règles, les conventions de rapport. Tout est consigné, dans l’ordre.

Ouvrir le manuel