Graft : cartographier un dépôt pour les agents de code
Découvrez comment Graft analyse votre dépôt avec tree-sitter et expose une cartographie persistante via MCP, pour éviter de reparcourir sa structure à chaque session.
Ce qu’est une cartographie du code pour les agents de programmation
Une cartographie du code pour les agents de programmation est un index persistant de votre dépôt. L’agent y effectue des recherches au lieu de parcourir le dépôt avec grep depuis le début à chaque nouvelle session. Graft est une implémentation de cette approche. Il analyse votre code avec tree-sitter, écrit un dossier de nœuds Markdown liés ainsi qu’un graphe de connexions par symbole, puis fournit des outils de récupération via MCP (model context protocol, l’interface standard utilisée par les agents de programmation pour appeler des outils externes).
Graft n’est ni un proxy ni une gateway. Rien ne s’interpose entre votre agent et l’API du modèle. La cartographie est un dossier sur le disque que l’agent lit. Cette distinction détermine le problème que vous cherchez à résoudre : une gateway de tokens auto-hébergée mesure et achemine les requêtes que vous envoyez déjà, tandis qu’une cartographie modifie le nombre total de requêtes nécessaires.
Cette technique est antérieure à cet outil et lui survivra. Commencez par apprendre la technique, puis passez aux aspects pratiques.
Pourquoi les agents de codage brûlent leur contexte à redécouvrir la structure
Observez un agent commencer à travailler sur un dépôt qu’il a déjà vu cinquante fois. Il liste les répertoires. Il recherche un symbole avec grep. Il ouvre trois fichiers pour trouver celui qui définit la fonction, puis un quatrième pour savoir qui l’appelle. Rien de tout cela ne fait partie de la tâche. Il s’agit de la phase d’orientation, facturée en tokens d’entrée à chaque session.
La cause est simple. Un modèle n’a pas de mémoire entre les sessions. Tout ce que l’agent a appris sur votre arborescence se trouvait dans une fenêtre de contexte supprimée à la fin de la session. La même phase de découverte recommence donc depuis zéro, et vous la payez de nouveau. Le prompt caching n’accorde une remise que pour un préfixe de prompt identique rencontré au cours des cinq dernières minutes, ou de la dernière heure moyennant un coût supplémentaire. Il ne peut donc pas transférer l’exploration d’hier à la session d’aujourd’hui. Sur un dépôt volumineux, la phase d’orientation coûte plus cher que la modification : dix appels d’outil pour localiser le code, un seul pour le modifier. L’orientation ne représente que la moitié de cette facture, l’édition représentant l’autre moitié. C’est pourquoi une compétence qui oblige l’agent à effectuer la plus petite modification fonctionnelle mérite d’être associée à une carte plutôt que choisie à sa place.
Une carte rompt cette boucle en déplaçant la découverte du modèle vers le disque. Un parseur parcourt une fois le dépôt, enregistre où chaque symbole est défini et quel symbole appelle quel autre, puis maintient cet enregistrement à jour lorsque le code évolue. L’agent pose une question et obtient une réponse avec le fichier et la ligne correspondants. Les explorations répétées deviennent une simple consultation peu coûteuse.
Vous utilisez déjà une version moins avancée de ce système. Un fichier AGENTS.md qui énonce vos conventions évite à l’agent de redéduire vos conventions à chaque fois. Une carte générée lui évite de redéduire votre structure. La différence tient à la personne ou à l’outil qui l’écrit. Vous rédigez vous-même le fichier d’instructions, qui reste donc concis. Un parseur génère la carte, qui peut ainsi couvrir dix mille fichiers. Pour comprendre où le budget est réellement consommé pendant une session, la façon dont Claude Code utilise sa fenêtre de contexte présente le détail.
Ce que Graft construit
Deux artefacts, tous deux placés dans un même dossier graft/ à la racine du dépôt.
Le premier est un graphe de nœuds écrit au format Markdown lié, avec un fichier par nœud. Chaque nœud contient un résumé en anglais courant, un « crux » qui reprend les lignes de logique importantes extraites du code source, les fichiers source exacts avec un hash de contenu, des wikiliens typés vers d’autres nœuds (depends_on, part_of, uses, implements), ainsi qu’une section de notes conservée lors des régénérations. Vous pouvez y consigner le contexte qu’un analyseur ne peut pas déduire.
Le second est graft/.graph/wiring.json, le graphe structurel par symbole extrait par tree-sitter : définitions, références et relations d’appel entre ces éléments.
Cette séparation est importante, car une seule moitié nécessite un modèle. graft build repose entièrement sur tree-sitter et n’appelle jamais de LLM (large language model). Il est donc déterministe et ne coûte rien. graft build --deep ajoute les résumés rédigés et les crux de chaque symbole. Ces éléments nécessitent des appels au modèle, qui sont facturés.
La prise en charge des langages est organisée par niveaux. Le niveau indique dans quelle mesure vous pouvez faire confiance à un graphe d’appels. TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift et R bénéficient d’une résolution inter-fichiers tenant compte de la portée. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix et Lua fournissent les symboles et des relations d’appel génériques. Une relation peut donc reposer sur une correspondance de noms plutôt que sur une référence résolue. Pour obtenir des relations de niveau compilateur, activez --lsp et utilisez un language server tel que rust-analyzer ou gopls.
Installer Graft et figer la version
Graft nécessite Node.js 20 ou une version ultérieure et est distribué sous licence MIT. Au 17 octobre 2026, la version actuelle est 0.23.0, publiée le 15 octobre 2026. La première version publiée, 0.1.0, date de juillet 2026. Considérez donc ce logiciel comme récent. La version 0.22.0, publiée le 14 octobre 2026, a renommé le projet Trail-code : le même code est désormais aussi distribué sous le nom @trailhq/trail-code avec une commande trail, tandis que @nanonets/graft conserve la commande graft.
Ce guide utilise la version 0.21.1, publiée le 29 septembre 2026 et dernière version avant le renommage, car les versions 0.22 et 0.23 ont modifié des commandes utilisées par le guide. À partir de la version 0.22, graft check compare le diff de votre branche avec les connaissances de l’équipe dans le dépôt et renvoie 1 en cas de conflit. La détection de dérive a été déplacée vers graft build --check, et les outils MCP s’appellent trail_* (le serveur répond toujours avec les anciens noms graft_*). Le changelog de la version 0.23.0 indique également que, dans un dépôt configuré avec trail, la carte est déplacée vers .trail/cache/ et que Claude Code n’obtient plus de serveur MCP, tandis que le README décrit toujours graft/ et .mcp.json. Lisez le changelog et exécutez --dry-run avant de modifier la version figée.
npm install -g @nanonets/graft@0.21.1
npm ls -g @nanonets/graftnpm ls -g doit afficher @nanonets/graft@0.21.1. Figez volontairement cette version. Un simple npm install -g @nanonets/graft résout le tag latest au moment de son exécution. Sur un projet qui publie plusieurs versions mineures par mois, vous pouvez ainsi utiliser un outil différent de celui installé par votre collègue la veille. Une version figée conserve les mêmes options CLI et le même format de graphe pour toute l’équipe. Vous effectuez donc la mise à niveau au moment choisi.
Connectez-le ensuite à un dépôt dont vous êtes propriétaire :
cd /path/to/your/repo
graft init --dry-run
graft initgraft init demande à quels agents de programmation vous souhaitez le connecter, puis construit le graphe. Exécutez d’abord --dry-run et lisez la liste des fichiers qu’il prévoit de modifier, car certains peuvent se trouver en dehors du dépôt. graft init est idempotente et n’écrase pas les configurations existantes. Vous pouvez donc l’exécuter une seconde fois sans risque. Pour annuler ces modifications, graft uninstall supprime tous les fichiers et les entrées de configuration écrits par Graft. Cette commande fonctionne en mode simulation tant que vous ne lui passez pas -y.
La même invite contient une case de consentement à la télémétrie. Depuis la version 0.12.0, Graft envoie par défaut un signal d’utilisation anonyme : des compteurs regroupés et des libellés fixes, mais jamais votre code, vos chemins de fichiers ou le nom de votre dépôt. Les événements sont envoyés au maximum une fois par jour. L’événement d’installation fait exception : le hook postinstall de npm le transmet immédiatement à l’émetteur en arrière-plan. Décochez la case pendant graft init, exécutez graft telemetry disable ou définissez DO_NOT_TRACK=1 pour désactiver cette fonction (elle se désactive également automatiquement dans CI). La commande graft telemetry debug affiche le lot qu’elle enverrait, sans l’envoyer.
Dans la version 0.21.1, la configuration prend en charge Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent et Google Antigravity. Hermes Agent est un hôte graft init de premier niveau depuis la version 0.13.0. Dans la version figée, graft init --agents hermes et graft init --agents antigravity sélectionnent ces deux hôtes comme les autres. Grok a été ajouté dans la version 0.13.0 et se sélectionne avec graft init --agents grok. Claude Code bénéficie de l’intégration la plus complète : une entrée de serveur MCP, une statusline indiquant la taille et l’ancienneté du graphe, des hooks post-edit qui reconstruisent le graphe et un fichier de skill sous .claude/. Les autres agents reçoivent un fichier d’instructions ou de règles qui indique l’existence des outils (Hermes Agent et Antigravity lisent tous deux la section AGENTS.md). Grok reçoit également un bloc MCP dans sa propre configuration. Ainsi, « pris en charge » signifie que Graft écrit la configuration nécessaire. Un agent qui ignore son propre fichier de règles ignorera donc aussi la carte. C’est la raison habituelle pour laquelle les agents ignorent les instructions que vous leur écrivez, et le même problème se pose ici.
Ce qui est ajouté au dépôt et ce qui reste hors de git
Après graft init, vous devez trouver les éléments suivants :
graft/: le graphe de nœuds Markdown etgraft/.graph/wiring.json. Il est ajouté à.gitignoreautomatiquement..mcp.json: enregistre le serveur MCP graft afin que Claude Code le démarre..claude/settings.json: est fusionné sur place et ajoute la statusline ainsi que les hooks post-edit.AGENTS.md,GEMINI.md,.github/copilot-instructions.md,.cursor/rules/graft.mdc,.kiro/steering/graft.md,.windsurf/rules/graft.md,.grok/skills/graft/SKILL.mdet.adal/skills/graft/SKILL.md: sections délimitées par des marqueurs, ajoutées aux fichiers correspondant aux agents sélectionnés..grok/config.toml: bloc[mcp_servers.graft]au niveau du dépôt, écrit uniquement lorsque vous sélectionnez Grok.~/.codex/config.toml,~/.codex/hooks.jsonet~/.codex/hooks/graft/graft-hooks.cjs: fichiers écrits à l’échelle de la machine, uniquement lorsque vous sélectionnez Codex et que~/.codex/existe déjà.graft init --no-globalles ignore, etgraft init --no-hooksignore à lui seul le hook shim.
Le graphe est un cache, comme node_modules. Ne le commitez pas. Il est régénéré à partir du code en quelques secondes, il change presque à chaque modification et son commit transforme une correction d’une ligne en un diff de plusieurs centaines de fichiers que personne ne relira. Commitez plutôt les éléments de câblage, notamment AGENTS.md et .mcp.json. Un membre de l’équipe clone le dépôt, exécute graft build et obtient son propre graphe local.
Vérifiez que la règle d’exclusion a bien été ajoutée avant votre premier commit :
grep -n graft .gitignore
git status --shortgrep doit afficher une ligne contenant graft/, et git status --short ne doit rien lister sous graft/. Si des fichiers sous graft/ apparaissent dans cette sortie, l’entrée d’exclusion est absente ou remplacée ailleurs. Corrigez le problème avant de commiter, car git continue de suivre un fichier dès qu’il a été ajouté, et une modification ultérieure de .gitignore ne cessera pas de le suivre.
Si vous préférez enregistrer le serveur MCP manuellement ou le verrouiller sur la même version que celle que vous avez installée, l’entrée est courte :
{
"mcpServers": {
"graft": {
"command": "npx",
"args": ["-y", "@nanonets/graft@0.21.1", "mcp"]
}
}
}Les outils de récupération appelés par votre agent à la place de grep
Graft expose six outils via MCP. graft_find_code renvoie les nœuds classés pour une description de tâche, avec le fichier et la ligne correspondants. graft_file_api renvoie toutes les signatures d’un fichier, sans leur corps. graft_trace_calls parcourt les appelants ou les fonctions appelées sur plusieurs niveaux. graft_find_all renvoie les correspondances d’une expression régulière, regroupées par symbole. graft_repo_map fournit un premier aperçu d’un dépôt inconnu. graft_check_freshness indique si le graphe correspond toujours au code.
Chacun possède un équivalent CLI. C’est ainsi que vous vérifiez ce que votre agent reçoit réellement :
graft map .
graft ask "where do we validate the refresh token"
graft skeleton src/auth/session.ts
graft callers validateRefreshToken
graft callers validateRefreshToken --direction out
graft grep "refresh_token" --jsongraft ask doit afficher les nœuds classés avec des références file:line, et non le contenu des fichiers. C’est tout le mécanisme : l’agent reçoit un pointeur et ouvre un seul fichier, au lieu d’en lire dix pour trouver le bon. graft viz ouvre une visionneuse interactive sur localhost si vous voulez examiner vous-même le graphe. Si graft ask ne renvoie rien d’utile pour une question à laquelle vous pourriez répondre en trente secondes, ne reformulez pas la question pour la relancer. La récupération classée peut échouer, et le fichier de compétences du projet indique que des résultats faibles imposent de passer à graft grep, graft skeleton ou graft callers. Si ces outils ne donnent pas non plus de résultat concluant, vérifiez la dérive (graft check . sur la version figée 0.21.1, graft build --check à partir de la version 0.22) et confirmez le niveau auquel se trouve votre langage, car un graphe obsolète ou des arêtes provenant d’un niveau trop large fera échouer votre agent de la même manière.
Un coût est facile à manquer. Les six définitions d’outils sont injectées dans le prompt système de chaque requête pendant toute la session. Vous payez ce coût, que l’agent utilise la carte ou non. Pour un dépôt suffisamment petit pour tenir dans le contexte, ce coût fixe peut être supérieur à l’exploration qu’il évite.
Que devient le graphe lorsque le code change
La mise à jour structurelle est rapide et automatique. Graft lit votre arbre de travail, et non git. Une modification non commitée et une modification indexée sont donc visibles de la même manière. Chaque requête examine d’abord l’arbre de travail et réanalyse uniquement les fichiers qui ont changé. La documentation de 0.21.1 évalue cette vérification à environ 3 ms lorsqu’aucun fichier n’a changé. Le README actuel parle de quelques dizaines de millisecondes, soit environ 50 ms sur le dépôt du projet. À la fin d’un cycle, la reconstruction ne traite que les fichiers dans lesquels le code a changé. Définissez GRAFT_NO_REFRESH=1 ou transmettez --no-refresh pour obtenir la réponse à partir du graphe enregistré sur le disque, sans réanalyse. Transmettez --no-reuse pour forcer une réanalyse complète à froid. C’est ce qu’il faut faire après la mise à niveau de Graft.
La partie générée par le modèle se comporte différemment. C’est là que les incohérences apparaissent silencieusement. Les résumés et les points clés sont mis en cache. Chaque nœud enregistre le hash de contenu de ses sources. Lorsqu’un fichier source change, le nœud est donc marqué comme obsolète au lieu d’être considéré comme à jour. Ce marqueur n’est utile que si un traitement l’exploite. Lancez l’actualisation avec graft build --deep. Cette opération consomme à nouveau des tokens du modèle.
Rendez l’obsolescence visible :
graft check .
echo $?Avec la version 0.21.1 verrouillée, le code de sortie 0 signifie que le graphe correspond au code, et le code de sortie 1 indique une dérive. À partir de la version 0.22, graft check renvoie plutôt le code 1 en cas de conflit avec un apprentissage d’équipe. Le contrôle de dérive est alors graft build --check. Modifiez donc la commande lorsque vous changez la version verrouillée. Exécutez-la depuis un hook pre-push afin qu’une carte vieille de six mois ne puisse pas répondre avec assurance à propos d’un code réécrit en mars. Le README de 0.21.1 décrit graft check comme un indicateur local de fraîcheur. Le README actuel indique build --check pour la CI. Dans les deux cas, graft/ est ignoré par git. Un checkout CI vierge démarre donc sans graphe, sauf si le job en construit un.
Lisez attentivement les chiffres publiés du benchmark
Le README de la version 0.21.1 mettait en avant « jusqu’à 4 fois moins cher et 3 fois plus rapide, avec une exactitude meilleure ou équivalente ». Le README actuel ne reprend plus cette phrase et affiche des chiffres plus modestes : « Sur 162 exécutions du même agent sur les mêmes tâches : 32 % de coût en moins, 42 % de tokens d’entrée non mis en cache en moins, 60 % de temps en moins et la même proportion de réponses correctes. » Ces chiffres proviennent des benchmarks réalisés par le projet et publiés dans son README. Voici les deux exécutions qu’il détaille.
Les données de ce graphique
[
{
"label": "Controlled sweep",
"run_count": 162,
"token_saving_pct": 42,
"tool_call_saving_pct": 46,
"correctness_pct": 93,
"baseline_correctness_pct": 93
},
{
"label": "SWE-bench Verified",
"run_count": 50,
"token_saving_pct": 23,
"tool_call_saving_pct": 25,
"correctness_pct": 66,
"baseline_correctness_pct": 54
}
]La série contrôlée porte sur 162 exécutions réparties sur deux dépôts, dont Graft lui-même, avec trois essais par tâche. Elle indique 42 % de tokens d’entrée non mis en cache en moins et 46 % d’appels d’outils en moins. L’exécution sur SWE-bench Verified porte sur 50 instances, avec le même modèle dans les deux groupes, et indique une économie plus faible : 23 % de tokens et 25 % d’appels d’outils en moins. Une troisième exécution, portant sur 15 tâches PocketBase, soit dix questions de développeurs et cinq pull requests fusionnées reproduites, a coûté 11.02 dollars américains au total, contre 13.91 pour la référence.
Considérez tout cela comme un benchmark fournisseur. Deux éléments limitent ce qu’il permet de conclure. La série contrôlée inclut le dépôt de Graft, c’est-à-dire le codebase sur lequel ses auteurs ont effectué leurs optimisations. SWE-bench Verified est un jeu de données public composé d’issues provenant de projets Python open source connus. Les outils sont généralement optimisés pour les jeux de données publics, même si ce n’est pas intentionnel. Aucun de ces résultats ne décrit votre monorepo privé, qui possède ses propres conventions de nommage et son propre code mort.
L’exactitude mérite une seconde lecture. Elle n’a pas changé dans la série contrôlée : 93 % avec la map, contre 93 % sans la map. Le passage à 66 %, contre 54 %, apparaît uniquement sur SWE-bench Verified. Un outil qui réduit votre facture de tokens sans dégrader la qualité constitue déjà un bon compromis. En revanche, n’appliquez pas le résultat d’exactitude de SWE-bench aux économies de tokens de la série contrôlée pour présenter les deux comme une seule affirmation.
Mesurez votre propre écart de tokens avant d’en tirer des conclusions
Le seul chiffre qui compte est celui de votre dépôt. Cette méthode prend un après-midi.
Choisissez une tâche que vous pouvez répéter à l’identique. Une question est préférable à une modification, car une modification change le dépôt et la deuxième exécution ne constitue plus la même expérience. « Quel module applique la limite de débit sur la route de connexion ? » est une question adaptée.
Activez la télémétrie et envoyez-la vers votre propre terminal :
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claudeL’exporter de console affiche les enregistrements de métriques au fur et à mesure de leur collecte. Celui qui vous intéresse est claude_code.token.usage, qui contient un attribut type égal à input, output, cacheRead ou cacheCreation. L’orientation apparaît dans input et cacheRead, car c’est là que le contenu des fichiers est transmis. Additionnez ces deux valeurs.
Exécutez la tâche trois fois, chaque fois dans une nouvelle session, avec la map configurée. Supprimez ensuite l’entrée graft de .mcp.json et exécutez-la encore trois fois. Comparez les médianes plutôt que des exécutions isolées, car les exécutions par l’agent varient fortement et une exécution défavorable peut vous faire conclure exactement l’inverse de la réalité. Relevez également le nombre d’appels d’outils : les appels d’outils sont le mécanisme et les tokens l’effet. Une économie de tokens sans baisse du nombre d’appels d’outils signifie qu’un autre facteur a changé.
Soustrayez ensuite les coûts que le benchmark n’affiche pas. graft build --deep consomme des tokens du modèle à chaque actualisation complète. Les six schémas d’outils sont transmis dans chaque requête. Si vos agents s’exécutent sur un serveur que vous louez, définir un plafond strict pour les dépenses des agents transforme cette surprise en budget, et ce que la télémétrie d’un agent de codage signale réellement explique quelles données quittent la machine une fois l’exporter activé.
Quand une carte du code cesse-t-elle d’être utile ?
- Le dépôt tient déjà dans le contexte. Un petit service unique n’a pas besoin de carte, et vous payez quand même les six schémas d’outils à chaque requête. Si votre agent trouve aujourd’hui n’importe quel fichier en un ou deux appels d’outils, n’en utilisez pas.
- Votre langage appartient au niveau généraliste. Les relations d’appel génériques peuvent faire manquer un appelant à
graft callersou en produire un à cause d’une collision de noms. Confirmez avecgraft grepavant de faire confiance au périmètre d’impact. - Le graphe est obsolète sans que personne ne s’en aperçoive. Dans la version 0.21.1,
graft checkse termine avec le code 1 en cas de dérive (à partir de la version 0.22, c’estgraft build --check), ce qui n’est utile que si quelque chose l’exécute. Utilisez un hook pre-push, pas une vérification manuelle. - Le monorepo nécessite un périmètre. Un monorepo géré par un seul dépôt Git n’est pas séparé, mais
graft builddétecte les sous-projets à partir depnpm-workspace.yaml, des workspacespackage.jsonou des fichiersgo.mod,pyproject.tomlouCargo.tomlpropres à chaque package, puis les utilise comme périmètres de classement.graft ask "..." --in services/billing/limite une requête à un seul sous-projet. Le même principe qui conduit à utiliser des fichiers AGENTS.md imbriqués pour chaque package s’applique à la carte. - L’agent ignore le câblage. Observez les appels d’outils pendant une session réelle avant de conclure que la carte est utilisée. Un agent qui exécute encore
grepvous indique qu’il n’a jamais lu le fichier de règles.
FAQ
Dois-je ajouter le dossier graft/ à git ?
Non. graft build ajoute automatiquement graft/ à votre .gitignore, car le graphe est un cache régénérable, comme node_modules. Il change à presque chaque modification. Le versionner masque donc les vraies différences sous des centaines de fichiers générés. Versionnez les éléments qui indiquent aux agents que la carte existe, notamment AGENTS.md et .mcp.json, puis laissez chaque membre de l’équipe exécuter graft build localement. Vérifiez avec grep -n graft .gitignore et git status --short avant votre premier commit, car git continue de suivre un fichier dès qu’il a été ajouté. Modifier .gitignore ensuite ne le retire pas du suivi.
Graft coûte-t-il de l’argent à l’exécution ?
La partie structurelle est gratuite. graft build, graft ask, graft check et les six outils de retrieval MCP utilisent tree-sitter et n’appellent jamais de modèle. graft build --deep est la partie payante. Il génère les résumés en anglais simple et les points essentiels de chaque symbole au moyen d’un LLM. Sa configuration utilise GRAFT_PROVIDER, GRAFT_API_KEY et GRAFT_MODEL, ainsi que GRAFT_BASE_URL pour tout endpoint compatible avec l’API OpenAI. Vous pouvez exécuter Graft uniquement avec la structure et ne dépenser aucun token pour le graphe lui-même.
Quelle économie réelle une carte du code peut-elle apporter sur mon dépôt ?
Personne ne peut le dire sans mesure. Le projet indique 42% de tokens d’entrée non mis en cache en moins lors de sa campagne de 162 exécutions, et 23% de tokens en moins sur SWE-bench Verified. Dans les deux cas, la comparaison porte sur une référence sans carte. Il s’agit de benchmarks du fournisseur. L’un d’eux a été exécuté en partie sur le propre dépôt de Graft, et aucun ne décrit votre code privé. Posez trois fois la même question avec la carte, puis trois fois sans elle. Définissez CLAUDE_CODE_ENABLE_TELEMETRY=1 et OTEL_METRICS_EXPORTER=console, puis comparez la médiane de claude_code.token.usage pour les types input et cacheRead.
Que devient le graphe lorsque je refactorise le code ?
La structure est réanalysée automatiquement. Graft examine l’arbre de travail et ne réanalyse que les fichiers modifiés. Un renommage est donc pris en compte lors de la requête suivante. Lorsqu’aucun fichier n’a changé, cette vérification prend environ 3 ms dans 0.21.1 et quelques dizaines de millisecondes dans la version actuelle. Elle détecte aussi les modifications non validées, car elle lit les fichiers et non l’historique git. Les résumés générés par le modèle sont la partie qui devient obsolète. Chaque nœud conserve un hash du contenu de ses sources. Une source modifiée marque le nœud comme obsolète au lieu de le réécrire. Vérifiez les écarts avec graft check . dans 0.21.1 et graft build --check à partir de 0.22, puis exécutez graft build --deep pour actualiser la partie rédigée.
Quels agents de programmation peuvent utiliser Graft aujourd’hui ?
Dans la version figée 0.21.1, graft init configure Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent et Google Antigravity, soit onze hôtes au total. Le changelog répertorie Hermes Agent comme hôte de premier niveau depuis 0.13.0. hermes et antigravity sont des identifiants --agents ordinaires dans la version figée. Claude Code bénéficie de l’intégration la plus complète : une entrée de serveur MCP dans .mcp.json, une statusline, des hooks post-édition et un fichier de skill dans .claude/. Codex dispose d’une section AGENTS.md et d’entrées à l’échelle de la machine dans ~/.codex/, que graft init --no-global ignore. Grok dispose d’un fichier de skill et d’un bloc MCP dans .grok/config.toml. Hermes Agent et Antigravity lisent la section AGENTS.md. Les autres reçoivent un fichier de règles ou de pilotage. Tout autre client MCP peut utiliser directement le serveur en enregistrant la commande npx -y @nanonets/graft@0.21.1 mcp.