Graft: mappa del codebase per agenti di coding
Graft analizza il repository con tree-sitter e crea una mappa interrogabile via MCP, così l’agente non deve riscoprire la stessa struttura a ogni sessione.
Che cos’è una mappa del codebase per gli agenti di programmazione
Una mappa del codebase per gli agenti di programmazione è un indice persistente del repository che l’agente consulta, invece di esplorarlo da zero con grep a ogni nuova sessione. Graft è un’implementazione di questo approccio. Analizza il codice con tree-sitter, scrive una cartella di nodi Markdown collegati e un grafo dei collegamenti tra i simboli, quindi fornisce strumenti di recupero tramite MCP (model context protocol, l’interfaccia standard usata dagli agenti di programmazione per chiamare strumenti esterni).
Graft non è un proxy e non è un gateway. Tra l’agente e l’API del modello non viene inserito alcun componente. La mappa è una cartella su disco che l’agente legge. Questa distinzione determina quale problema stai risolvendo: un gateway self-hosted per i token misura e instrada le richieste che già invii, mentre una mappa modifica il numero complessivo di richieste necessarie.
La tecnica è precedente a questo strumento e continuerà a essere utile anche dopo. Impara prima la tecnica, poi i dettagli operativi.
Perché gli agenti di coding consumano contesto per riscoprire la struttura
Osservate un agente che inizia a lavorare su un repository già analizzato cinquanta volte. Elenca le directory. Cerca un simbolo con grep. Apre tre file per trovare quello che definisce la funzione, poi un quarto per capire chi la chiama. Nulla di tutto questo fa parte dell'attività. È orientamento, pagato in token di input a ogni sessione.
La causa è semplice. Un modello non conserva memoria tra le sessioni. Tutto ciò che l'agente ha appreso sulla struttura del progetto viveva in una finestra di contesto che viene scartata al termine della sessione. La stessa analisi esplorativa riparte quindi da zero e viene pagata di nuovo. Il prompt caching applica uno sconto soltanto a un prefisso identico del prompt rilevato negli ultimi cinque minuti, oppure nell'ultima ora a un costo aggiuntivo, quindi non può trasferire l'esplorazione di ieri alla sessione di oggi. In un repository di grandi dimensioni, la fase di orientamento costa più della modifica: dieci chiamate agli strumenti per individuare il codice e una per modificarlo. L'orientamento rappresenta soltanto una metà di quel costo e la modifica l'altra; per questo una skill che impone all'agente di applicare la modifica minima funzionante si abbina a una mappa invece di essere scelta al suo posto.
Una mappa interrompe questo ciclo spostando l'analisi esplorativa dal modello al disco. Un parser attraversa il repository una volta, registra dove viene definito ogni simbolo e quale simbolo chiama quale altro, quindi mantiene aggiornato il record al variare del codice. L'agente pone una domanda e riceve una risposta con file e riga. L'esplorazione ripetuta diventa una semplice ricerca.
Già utilizzate una versione più limitata di questo approccio. Un file AGENTS.md che descrive le vostre convenzioni impedisce all'agente di ricostruirle a ogni sessione. Una mappa generata gli impedisce di ricostruire ogni volta la struttura. La differenza riguarda chi la scrive. Il file di istruzioni viene scritto manualmente, quindi rimane piccolo. Un parser genera la mappa, che può coprire diecimila file. Per capire dove viene effettivamente utilizzato il budget durante una sessione, come Claude Code utilizza la propria finestra di contesto illustra la ripartizione.
Cosa costruisce effettivamente Graft
Due artefatti, entrambi nella cartella graft/ alla radice del repository.
Il primo è un grafo di nodi scritto come markdown collegato, con un file per ogni nodo. Ogni nodo contiene un riepilogo in linguaggio semplice, un «crux» con le righe di logica importanti estratte dal codice sorgente, i file sorgente esatti con un hash del contenuto, wikilink tipizzati verso altri nodi (depends_on, part_of, uses, implements) e una sezione di note che viene mantenuta durante la rigenerazione, così puoi registrare il contesto che un parser non è in grado di dedurre.
Il secondo è graft/.graph/wiring.json, il grafo strutturale per simbolo estratto da tree-sitter: definizioni, riferimenti e archi di chiamata tra questi elementi.
La separazione è importante perché solo una delle due parti richiede un modello. graft build usa esclusivamente tree-sitter e non chiama mai un LLM (large language model), quindi è deterministico e non ha costi. graft build --deep aggiunge i riepiloghi scritti e i crux per ogni simbolo; queste operazioni chiamano il modello e sono a pagamento.
Il supporto dei linguaggi è organizzato per livelli, e il livello indica quanto puoi considerare affidabile un grafo delle chiamate. TypeScript, JavaScript, Python, Go, Java, Kotlin, PHP, Swift e R supportano la risoluzione tra file basata sull'ambito. Rust, C, C++, C#, Ruby, Scala, Elixir, Solidity, OCaml, Zig, Dart, Clojure, Nix e Lua forniscono i simboli e archi di chiamata generici. In questo caso, un arco può derivare da una corrispondenza del nome anziché da un riferimento risolto. Gli archi a livello di compilatore sono opzionali tramite --lsp e un language server come rust-analyzer o gopls.
Installare Graft e bloccare la versione
Graft richiede Node.js 20 o versioni successive ed è distribuito con licenza MIT. Al 17 ottobre 2026 la release corrente è la 0.23.0, pubblicata il 15 ottobre 2026, mentre la prima versione pubblicata, la 0.1.0, è datata luglio 2026. Consideratelo software ancora giovane. La release 0.22.0, pubblicata il 14 ottobre 2026, ha rinominato il progetto in Trail-code: lo stesso codice viene ora distribuito anche come @trailhq/trail-code con un comando trail, mentre @nanonets/graft mantiene il comando graft.
Questa guida blocca la versione 0.21.1, pubblicata il 29 settembre 2026 e ultima release prima della ridenominazione, perché le versioni 0.22 e 0.23 hanno modificato i comandi utilizzati dalla guida. Dalla versione 0.22, graft check confronta le differenze del branch con gli apprendimenti del team presenti nel repository e restituisce 1 in caso di conflitto; il rilevamento delle divergenze è stato spostato in graft build --check e gli strumenti MCP si chiamano trail_*, anche se il server continua a rispondere con i vecchi nomi graft_*. Il changelog della versione 0.23.0 indica inoltre che, in un repository configurato con trail, la mappa viene spostata in .trail/cache/ e Claude Code non riceve più un server MCP, mentre il README descrive ancora graft/ e .mcp.json. Leggete il changelog ed eseguite --dry-run prima di modificare il blocco della versione.
npm install -g @nanonets/graft@0.21.1
npm ls -g @nanonets/graftnpm ls -g dovrebbe stampare @nanonets/graft@0.21.1. Bloccate intenzionalmente questa versione. Un semplice npm install -g @nanonets/graft risolve il tag latest nel momento in cui lo eseguite; in un progetto che pubblica diverse release minori ogni mese, questo significa usare uno strumento diverso martedì rispetto a quello installato dal collega lunedì. Una versione bloccata mantiene uguali per tutti i flag della CLI e il formato del grafo, così potete aggiornare quando lo decidete voi.
Quindi collegatelo a un repository di vostra proprietà:
cd /path/to/your/repo
graft init --dry-run
graft initgraft init chiede con quali agenti di programmazione configurare l'integrazione, quindi crea il grafo. Eseguite prima --dry-run e leggete l'elenco dei file che prevede di modificare, perché alcuni possono trovarsi fuori dal repository. graft init è idempotente e non sovrascrive le configurazioni esistenti, quindi eseguirlo una seconda volta è sicuro. Per annullare le modifiche, graft uninstall rimuove ogni file e voce di configurazione scritti da Graft; il comando esegue una simulazione finché non passate -y.
Lo stesso prompt include una casella per la telemetria. Dalla release 0.12.0 Graft invia per impostazione predefinita un ping anonimo di utilizzo: conteggi raggruppati e etichette fisse, mai il codice, i percorsi dei file o il nome del repository. Gli eventi vengono inviati al massimo una volta al giorno, con un'eccezione: l'evento di installazione, che l'hook postinstall di npm consegna immediatamente al processo di invio in background. Deselezionate la casella durante graft init, eseguite graft telemetry disable oppure impostate DO_NOT_TRACK=1 per disabilitare la telemetria; questa viene disabilitata automaticamente anche in CI. graft telemetry debug stampa il batch che verrebbe inviato senza trasmetterlo.
Nella versione 0.21.1 l'integrazione supporta Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent e Google Antigravity. Hermes Agent è un host graft init di primo livello dalla release 0.13.0 e, nella versione bloccata, graft init --agents hermes e graft init --agents antigravity selezionano questi due host come qualsiasi altro. Grok è supportato dalla release 0.13.0 e viene selezionato con graft init --agents grok. Claude Code offre l'integrazione più completa: una voce per un server MCP, una statusline che mostra le dimensioni e l'obsolescenza del grafo, hook post-edit che ricostruiscono il grafo e un file skill in .claude/. Agli altri agenti viene fornito un file di istruzioni o di regole che indica la disponibilità degli strumenti; Hermes Agent e Antigravity leggono entrambi la sezione AGENTS.md. Grok riceve inoltre un blocco MCP nella propria configurazione. Di conseguenza, "supportato" significa che Graft scrive la configurazione necessaria; se un agente ignora il proprio file di regole, ignorerà anche la mappa. Questo è il motivo ordinario per cui gli agenti ignorano le istruzioni che scrivete per loro, e vale anche in questo caso.
Cosa viene scritto nel repository e cosa resta fuori da git
Dopo graft init, troverai questi elementi:
graft/: il grafo dei nodi Markdown egraft/.graph/wiring.json. Viene aggiunto a.gitignoreautomaticamente..mcp.json: registra il server MCP graft, in modo che Claude Code lo avvii..claude/settings.json: viene integrato nella posizione prevista e aggiunge la statusline e gli hook 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.mde.adal/skills/graft/SKILL.md: sezioni delimitate da marker, aggiunte ai file corrispondenti agli agenti selezionati..grok/config.toml: un blocco[mcp_servers.graft]a livello di repository, scritto solo quando selezioni Grok.~/.codex/config.toml,~/.codex/hooks.jsone~/.codex/hooks/graft/graft-hooks.cjs: file a livello di macchina, scritti solo quando selezioni Codex e~/.codex/esiste già.graft init --no-globalli omette, mentregraft init --no-hooksomette autonomamente lo shim dell'hook.
Il grafo è una cache, come node_modules. Non eseguirne il commit. Viene rigenerato dal codice in pochi secondi, cambia dopo quasi ogni modifica e inserirlo nel repository trasforma una correzione di una riga in un diff di diverse centinaia di file che nessun revisore leggerà. Esegui invece il commit dei file di configurazione, inclusi AGENTS.md e .mcp.json. Un collega clona il repository, esegue graft build e ottiene il proprio grafo locale.
Verifica che la regola di esclusione sia stata aggiunta prima del primo commit:
grep -n graft .gitignore
git status --shortgrep dovrebbe stampare una riga contenente graft/, mentre git status --short non dovrebbe elencare nulla sotto graft/. Se nell'output compaiono file sotto graft/, significa che la voce di esclusione manca o è stata sovrascritta altrove. Correggi il problema prima del commit, perché git continua a tenere traccia di un file dopo che è stato aggiunto e una successiva modifica a .gitignore non lo rimuoverà dall'indice.
Se preferisci registrare manualmente il server MCP o fissarlo alla stessa versione installata, la voce è breve:
{
"mcpServers": {
"graft": {
"command": "npx",
"args": ["-y", "@nanonets/graft@0.21.1", "mcp"]
}
}
}Gli strumenti di recupero che l'agente usa al posto di grep
Graft espone sei strumenti tramite MCP. graft_find_code restituisce i nodi ordinati per rilevanza per la descrizione di un'attività, con file e riga. graft_file_api restituisce tutte le signature presenti in un file senza i corpi delle funzioni. graft_trace_calls percorre i chiamanti o i chiamati per diversi livelli. graft_find_all restituisce le corrispondenze delle espressioni regolari raggruppate per simbolo. graft_repo_map fornisce una prima panoramica di un repository non ancora conosciuto. graft_check_freshness segnala se il grafo corrisponde ancora al codice.
Ognuno dispone di un equivalente CLI. È così possibile verificare che cosa venga effettivamente fornito all'agente:
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 dovrebbe stampare i nodi ordinati per rilevanza con riferimenti file:line, invece del contenuto dei file. Questo è l'intero meccanismo: l'agente riceve un riferimento e apre un file, invece di leggerne dieci per trovare quello corretto. graft viz apre un visualizzatore interattivo su localhost se vuoi esaminare direttamente il grafo. Se graft ask non restituisce nulla di utile per una domanda a cui potresti rispondere in trenta secondi, non riformulare la domanda per riprovare. Il recupero ordinato per rilevanza può non trovare il risultato corretto e il file skill del progetto indica che i risultati deboli richiedono il passaggio a graft grep, graft skeleton o graft callers. Se anche questi strumenti non bastano, verifica la presenza di drift (graft check . sulla versione fissata 0.21.1, graft build --check dalla versione 0.22 in poi) e conferma il tier a cui appartiene il tuo linguaggio, perché un grafo obsoleto o gli archi di un tier troppo ampio faranno fallire l'agente nello stesso modo.
C'è un costo facile da trascurare. Le definizioni dei sei strumenti vengono inserite nel prompt di sistema di ogni richiesta per l'intera sessione. Questo costo si applica anche se l'agente non usa la mappa. In un repository abbastanza piccolo da entrare nel contesto, il costo fisso può essere superiore al lavoro di esplorazione risparmiato.
Cosa accade al grafo quando cambia il codice
L'aggiornamento strutturale è rapido e automatico. Graft legge il working tree, non git, quindi vede allo stesso modo una modifica non sottoposta a commit e una modifica messa in staging. Ogni query esegue prima lo stat del working tree e analizza di nuovo soltanto i file modificati. La documentazione 0.21.1 indica per questo controllo circa 3 ms quando non è cambiato nulla; il README attuale parla di alcune decine di millisecondi, circa 50 ms nel repository del progetto. Una ricostruzione alla fine del turno tocca soltanto i file in cui è cambiato il codice. Imposta GRAFT_NO_REFRESH=1 o passa --no-refresh per rispondere usando il grafo su disco senza analizzare di nuovo i file. Passa --no-reuse per forzare una nuova analisi completa a freddo, come richiesto dopo l'aggiornamento di Graft.
La parte scritta dal modello si comporta in modo diverso ed è quella che può smettere di funzionare senza segnali evidenti. I riepiloghi e i punti chiave vengono memorizzati nella cache. Ogni nodo registra un hash del contenuto delle proprie origini; quando cambia un file sorgente, il nodo viene contrassegnato come obsoleto invece di essere considerato aggiornato. Questo flag è utile soltanto se qualcosa lo gestisce. Esegui l'aggiornamento con graft build --deep, che consuma nuovamente token del modello.
Rendi visibile l'obsolescenza:
graft check .
echo $?Nella versione bloccata 0.21.1, il codice di uscita 0 indica che il grafo corrisponde al codice, mentre il codice di uscita 1 indica una divergenza. Dalla versione 0.22 in poi, graft check restituisce 1 in caso di conflitto con un apprendimento del team; il controllo della divergenza è invece graft build --check. Modifica quindi il comando quando aggiorni la versione bloccata. Eseguilo da un hook pre-push, in modo che una mappa vecchia di sei mesi non possa fornire risposte sicure su codice riscritto a marzo. Il README della versione 0.21.1 descrive graft check come un indicatore locale di aggiornamento, mentre il README attuale indica build --check per la CI. In ogni caso, graft/ è escluso da git, quindi un checkout CI nuovo non contiene alcun grafo, a meno che il job non ne costruisca uno.
Leggi con attenzione i numeri pubblicati nei benchmark
Il README della versione 0.21.1 riportava in apertura: "fino a 4x meno costoso e 3x più veloce, con correttezza migliore o invariata". Il README attuale ha rimosso quella frase e presenta numeri più contenuti: "Su 162 esecuzioni dello stesso agente sulle stesse attività: costo ridotto del 32%, 42% in meno di token di input non memorizzati nella cache, tempo ridotto del 60% e la stessa percentuale di risposte corrette." Questi dati provengono dai benchmark del progetto, pubblicati nel README. Di seguito sono riportate per intero le due esecuzioni descritte.
I dati alla base di questo grafico
[
{
"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 valutazione controllata comprende 162 esecuzioni su due repository, uno dei quali è Graft stesso, con tre prove per attività. Riporta 42% in meno di token di input non memorizzati nella cache e 46% in meno di chiamate agli strumenti. L'esecuzione su SWE-bench Verified comprende 50 istanze con lo stesso modello in entrambi i gruppi e riporta un risparmio inferiore: 23% dei token e 25% delle chiamate agli strumenti. Una terza esecuzione su 15 attività di PocketBase, dieci domande di sviluppatori e cinque pull request unite e riprodotte, è costata complessivamente 11.02 dollari statunitensi, contro i 13.91 della baseline.
Considera tutti questi dati come benchmark del fornitore. Due aspetti ne limitano l'utilità. La valutazione controllata include il repository di Graft, cioè il codebase rispetto al quale gli autori hanno ottimizzato lo strumento. SWE-bench Verified è un dataset pubblico di issue provenienti da noti progetti Python open source, e gli strumenti vengono ottimizzati proprio per i dataset pubblici, indipendentemente dalle intenzioni. Nessuno dei due benchmark descrive il tuo monorepo privato, che ha convenzioni di denominazione proprie e anche codice morto.
La correttezza richiede un'analisi separata. Nella valutazione controllata non è cambiata: 93% con la mappa, contro 93% senza. Il passaggio a 66% da 54% appare soltanto su SWE-bench Verified. Uno strumento che riduce la spesa per i token mantenendo invariata la qualità rappresenta comunque un buon compromesso. Non trasferire però il risultato di correttezza di SWE-bench al risultato sui token della valutazione controllata, citandoli entrambi come un'unica affermazione.
Misura la differenza effettiva di token nel tuo repository prima di trarre conclusioni
L'unico numero rilevante è quello del tuo repository. Questo metodo richiede un pomeriggio.
Scegli un'attività che puoi ripetere esattamente. Una domanda è preferibile a una modifica, perché una modifica cambia il repository e la seconda esecuzione non costituisce più lo stesso esperimento. «Quale modulo applica il rate limiting alla route di login?» ha la forma corretta.
Attiva la telemetria e inviala al tuo terminale:
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
claudeL'exporter della console stampa i record delle metriche mentre vengono raccolti. Quello che ti interessa è claude_code.token.usage, che contiene un attributo type con valore input, output, cacheRead o cacheCreation. L'orientamento compare in input e cacheRead, perché è lì che finiscono i contenuti dei file. Somma questi due valori.
Esegui l'attività 3 volte, ogni volta in una sessione nuova, con la mappa collegata. Rimuovi quindi la voce graft da .mcp.json ed esegui l'attività altre 3 volte. Confronta le mediane invece delle singole esecuzioni, perché le esecuzioni dell'agent possono variare molto e un'esecuzione sfavorevole può indicare il risultato opposto a quello reale. Registra anche il numero di chiamate agli strumenti: le chiamate agli strumenti sono il meccanismo, mentre i token sono l'effetto; quindi, se i token diminuiscono senza una riduzione delle chiamate agli strumenti, è cambiato qualcos'altro.
Sottrai quindi i costi che il benchmark non mostra. graft build --deep consuma token del modello a ogni refresh completo. I 6 schemi degli strumenti vengono inclusi in ogni richiesta. Se gli agent vengono eseguiti su un server che noleggi, impostare un limite massimo rigido per la spesa degli agent trasforma un costo imprevisto in un budget, mentre che cosa rileva realmente la telemetria di un coding agent descrive quali dati escono dalla macchina dopo l'attivazione dell'exporter.
Quando una mappa del codebase smette di essere utile?
- Il repository entra già nel contesto. Un singolo servizio di piccole dimensioni non ha bisogno di una mappa, e per ogni richiesta sostieni comunque il costo di sei schemi di strumenti. Se oggi l'agente trova qualsiasi file con una o due chiamate agli strumenti, salta la mappa.
- Il linguaggio rientra nel livello generico. I collegamenti generici tra chiamate possono far sì che
graft callersnon trovi un chiamante oppure ne produca uno a causa di una collisione di nomi. Verifica congraft grepprima di considerare attendibile l'ampiezza dell'impatto. - Il grafo è diventato obsoleto senza che nessuno se ne accorgesse. In 0.21.1
graft checktermina con il codice 1 in caso di divergenze; dalla versione 0.22 in poi lo fagraft build --check. Questo è utile solo se qualcosa lo esegue. Usa un hook pre-push, non affidarti a un controllo manuale. - Il monorepo richiede un ambito più ristretto. Un monorepo gestito da un singolo repository Git non viene suddiviso, ma
graft buildrileva i sottoprogetti dapnpm-workspace.yaml, dagli workspacepackage.jsonoppure dai valorigo.mod,pyproject.tomloCargo.tomlspecifici dei pacchetti e li usa come ambiti per l'ordinamento.graft ask "..." --in services/billing/restringe una query a un solo sottoprogetto. Lo stesso criterio che porta a usare file AGENTS.md annidati per ogni pacchetto si applica anche alla mappa. - L'agente ignora i collegamenti tra i componenti. Osserva le chiamate agli strumenti in una sessione reale prima di concludere che la mappa venga utilizzata. Se l'agente continua a eseguire
grep, significa che non ha mai letto il file delle regole.
FAQ
Devo eseguire il commit della directory graft/ in git?
No. graft build aggiunge automaticamente graft/ al tuo .gitignore, perché il grafo è una cache rigenerabile come node_modules. Cambia a quasi ogni modifica, quindi eseguirne il commit nasconde le differenze reali sotto centinaia di file generati. Esegui il commit della configurazione che comunica agli agenti l'esistenza della mappa, inclusi AGENTS.md e .mcp.json, e lascia che ogni collaboratore esegua localmente graft build. Verifica con grep -n graft .gitignore e git status --short prima del primo commit, perché git continua a tenere traccia di un file dopo che è stato aggiunto e modificare successivamente .gitignore non ne interrompe il tracciamento.
Graft richiede un pagamento per essere eseguito?
La parte strutturale no. graft build, graft ask, graft check e i sei strumenti MCP di recupero eseguono operazioni tree-sitter senza mai chiamare un modello. graft build --deep è la parte a pagamento: scrive i riepiloghi in inglese semplice e i punti chiave per ogni simbolo tramite un LLM, configurato con GRAFT_PROVIDER, GRAFT_API_KEY e GRAFT_MODEL, oltre a GRAFT_BASE_URL per qualsiasi endpoint compatibile con OpenAI. Puoi eseguire Graft utilizzando soltanto la struttura, senza spendere alcun token per il grafo.
Quanto può far risparmiare effettivamente una mappa del codice nel mio repository?
Non è possibile dirlo senza effettuare misurazioni. Il progetto riporta 42% di token di input non memorizzati nella cache in meno nella propria analisi di 162 esecuzioni e 23% di token in meno su SWE-bench Verified, in entrambi i casi rispetto a una baseline senza mappa. Si tratta di benchmark del fornitore; uno è stato eseguito in parte sul repository di Graft e nessuno dei due descrive il tuo codice privato. Esegui tre volte una stessa domanda ripetibile con la mappa e tre volte senza, impostando CLAUDE_CODE_ENABLE_TELEMETRY=1 e OTEL_METRICS_EXPORTER=console, quindi confronta la mediana di claude_code.token.usage per i tipi input e cacheRead.
Cosa succede al grafo quando eseguo un refactoring?
La struttura viene analizzata nuovamente automaticamente. Graft esamina l'albero di lavoro e rianalizza soltanto i file modificati, quindi un rinominamento viene rilevato alla query successiva. Quando non è cambiato nulla, questo controllo richiede circa 3 ms nella versione 0.21.1 e alcune decine di millisecondi nella release corrente; rileva anche le modifiche non sottoposte a commit perché legge i file invece della cronologia git. I riepiloghi scritti dal modello diventano obsoleti: ogni nodo memorizza un hash del contenuto delle proprie sorgenti e una sorgente modificata contrassegna il nodo come obsoleto invece di riscriverlo. Controlla la presenza di modifiche non riflesse (graft check . nella versione 0.21.1, graft build --check dalla 0.22 in poi), quindi esegui graft build --deep per aggiornare la parte scritta.
Quali agenti di coding possono usare Graft oggi?
Nella versione bloccata 0.21.1, graft init configura Claude Code, Cursor, Codex, GitHub Copilot, Google Gemini, Kiro, Windsurf, Grok (xAI), AdaL, Hermes Agent e Google Antigravity, per un totale di undici host. Il changelog indica Hermes Agent come host di prima classe dalla versione 0.13.0, mentre hermes e antigravity sono normali identificativi --agents nella release bloccata. Claude Code riceve la configurazione più completa: una voce per il server MCP in .mcp.json, una statusline, hook post-edit e un file skill in .claude/. Codex riceve una sezione AGENTS.md e voci a livello di sistema in ~/.codex/, che graft init --no-global esclude. Grok riceve un file skill e un blocco MCP in .grok/config.toml. Hermes Agent e Antigravity leggono la sezione AGENTS.md, mentre gli altri ricevono un file di regole o di steering. Qualsiasi altro client MCP può usare direttamente il server registrando il comando npx -y @nanonets/graft@0.21.1 mcp.