Présentation

Sachez qui a modifié quoi.
Même quand ce n'est pas humain.

Suivi en temps réel des modifications de code pour l'ère multi-agents.
Un seul binaire. Zéro configuration. Visibilité totale.

curl -fsSL https://0diff.dev/install.sh | sh

Open source · Licence MIT · Construit en Rust · Par ZeroSuite, Inc.

Le problème

Les agents IA écrivent du code sous votre nom.
Personne ne suit qui a modifié quoi.

Vous utilisez Claude Code, Cursor, Copilot, Windsurf ou Devin aux côtés de votre équipe. Ils modifient des fichiers silencieusement, font des commits sous votre identité et introduisent des modifications qui échappent à la revue. Les outils traditionnels comme git diff et git blame n'ont pas été conçus pour ce monde.

« J'avais 100 agents lancés sur un projet Rust complexe. Un agent a refactorisé un module partagé. 4 autres agents ont commencé à échouer silencieusement. Je ne l'ai su qu'au bout de 45 minutes. »

-- Ingénieur senior, équipe systèmes distribués

Le coût

Les modifications non suivies coûtent de l'argent réel.

Les régressions liées aux modifications sont la première source évitable d'incidents de production.

23 %

du temps des développeurs passé à déboguer des modifications non suivies

4,2 h

temps moyen pour identifier la cause première d'une régression liée à une modification

680 K$

coût annuel moyen par équipe pour des incidents évitables liés aux modifications

67 %

des incidents de production remontent à une modification n'ayant pas été vérifiée

La solution

0diff : visibilité en temps réel
sur chaque modification.

Un seul binaire Rust qui surveille votre codebase, calcule des diffs intelligents,
identifie l'auteur de chaque modification (humain ou IA) et enregistre tout.

0diff watch

$ 0diff watch

▶ Watching 847 files across 23 directories...

▶ Git: main branch, 3 contributors tracked

[14:32:05] src/parser.rs +12 -3 (alice on feature/parser)

@@ -45,3 +45,12 @@

- fn parse_expression(&mut self) -> Result<Expr> {

+ fn parse_expression(&mut self, precedence: u8) -> Result<Expr> {

[14:33:41] src/checker.rs +47 -2 (⚡ Claude Agent on fix/enum-collision) [AI AGENT]

+ fn resolve_name_shadowing(&mut self, scope: &Scope) {

Fonctionnalités clés

Tout ce dont vous avez besoin.
Rien de superflu.

Surveillance en temps réel

Monitoring natif inotify/FSEvents. Débouncé. Détection instantanée, zéro surcharge CPU.

Moteur de diff intelligent

Algorithme Myers. Précision ligne par ligne. Filtrage des espaces et commentaires intégré.

Attribution Git

Blame automatique, détection de branche et identification de l'auteur sur chaque modification.

Détection d'agents IA

Identifie Claude, Cursor, Copilot, Windsurf, Devin via les en-têtes de commit, les variables d'environnement et les heuristiques TTY.

Historique consultable

Journal JSON-lines. Recherche par auteur, fichier, date, branche ou agent. Piste d'audit complète.

Binaire unique

Écrit en Rust. Binaire statique d'environ 2 Mo. Pas de runtime, pas de dépendances. Installation avec curl.

Fonctionnalité phare

Conçu pour l'ère du
développement assisté par IA.

Le premier outil de suivi de code conçu pour les codebases humain + IA.

Méthodes de détection

En-têtes de commit Co-Authored-By
Analyse de mots-clés dans les messages de commit
Scan des variables d'environnement
Heuristique de session TTY / non interactive

Agents détectés

Claude Code / Claude Agent
Cursor
GitHub Copilot
Windsurf / Devin

Patterns personnalisables dans .0diff.toml — détectez n'importe quel agent.

Comparaison

Pourquoi ne pas simplement utiliser `git diff` ?

Fonctionnalité	git diff	watchexec	fswatch	0diff
Surveillance en temps réel	--	✓	✓	✓
Moteur de diff intelligent	✓	--	--	✓
Attribution d'auteur	manuel	--	--	auto
Détection d'agents IA	--	--	--	✓
Historique consultable	--	--	--	✓
Notifications (Slack/Discord)	--	--	--	✓
Mode démon en arrière-plan	--	--	--	✓
Binaire unique, zéro dépendance	✓	✓	build	✓

À qui s'adresse 0diff

Conçu pour votre manière de travailler.

Développeurs solo

Utilisent des assistants IA au quotidien. Ont besoin de savoir ce que l'IA a modifié vs ce qu'ils ont écrit.

Équipes dev

Distribuées sur plusieurs fuseaux horaires. Ont besoin de visibilité en temps réel sur les modifications de chacun.

Tech Leads / CTO

Ont besoin de la vue d'ensemble : points chauds, résumés par auteur et alertes sur les fichiers sensibles.

Systèmes critiques

Migrations de BDD, logique d'authentification, code de paiement. Zéro tolérance pour les modifications silencieuses.

Architecture

Léger. Rapide.
Délibérément simple.

Écrit en Rust -- environ 2 400 lignes de code
Pas de runtime asynchrone, pas de frameworks lourds
Algorithme de diff Myers via le crate similar
Surveillance native de fichiers (inotify / FSEvents)
Historique JSON-lines en ajout seul avec rotation
Intégration git via le shell (pas de libgit2)
11 dépendances soigneusement vérifiées
44 tests unitaires, 0 échec

src/

main.rs CLI entry (clap derive)

config.rs .0diff.toml parsing

watcher.rs FS events + debouncer

differ.rs Myers diff engine

filter.rs Whitespace filtering

git.rs Blame, branch, author

agents.rs AI agent detection

history.rs JSON-lines log

output.rs Terminal + JSON output

Release binary: ~2 MB

Dependencies: 11

Tests: 44 passing

Feuille de route

Où nous allons.

v0.1

Fondation -- livré

Watch, diff, log, status, init. Attribution git. Détection d'agents IA. Sortie JSON. Binaire unique.

v0.2

Notifications

Mode démon en arrière-plan. Intégrations Slack / Discord / webhook. Résumés quotidiens.

v0.3

Intelligence

Filtrage des commentaires. Alertes sur fichiers critiques. Détection de collisions multi-agents. Règles de surveillance par fichier.

v1.0

Écosystème

Extension VS Code. Intégration GitHub Actions. CI/CD de release multiplateforme. Homebrew tap.

Arrêtez de deviner.
Commencez à surveiller.

Open source. Gratuit pour toujours. Licence MIT.
Un seul binaire Rust. Zéro configuration.

Installer 0diff Voir sur GitHub 0diff.dev