> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Come funziona Fuxi Code
> Comprendi il ciclo agentico, gli strumenti integrati e come Fuxi Code interagisce con il tuo progetto.
Fuxi Code è un assistente agentico che funziona nel tuo terminale. Sebbene eccella nella programmazione, può aiutarti con qualsiasi cosa tu possa fare dalla riga di comando: scrivere documentazione, eseguire build, cercare file, ricercare argomenti e molto altro.
Questa guida copre l'architettura principale, le capacità integrate e [suggerimenti per lavorare efficacemente](#work-effectively-with-fuxi-code). Per procedure dettagliate, consulta [Flussi di lavoro comuni](/it/common-workflows). Per funzionalità di estensibilità come skills, MCP e hooks, consulta [Estendi Fuxi Code](/it/features-overview).
Il ciclo agentico
Quando dai a Fuxi un compito, lavora attraverso tre fasi: **raccogliere contesto**, **intraprendere azioni** e **verificare i risultati**. Queste fasi si mescolano insieme. Fuxi utilizza strumenti durante tutto il processo, sia cercando file per comprendere il tuo codice, modificando per apportare cambiamenti, o eseguendo test per verificare il suo lavoro.
Il ciclo si adatta a quello che chiedi. Una domanda sulla tua base di codice potrebbe richiedere solo la raccolta di contesto. Una correzione di bug cicla attraverso tutte e tre le fasi ripetutamente. Un refactoring potrebbe comportare una verifica estesa. Fuxi decide cosa richiede ogni passaggio in base a quello che ha imparato dal passaggio precedente, concatenando dozzine di azioni insieme e correggendo il corso lungo il percorso.
Anche tu fai parte di questo ciclo. Puoi interrompere in qualsiasi momento per indirizzare Fuxi in una direzione diversa, fornire contesto aggiuntivo o chiedergli di provare un approccio diverso. Fuxi lavora autonomamente ma rimane reattivo al tuo input.
Il ciclo agentico è alimentato da due componenti: [modelli](#models) che ragionano e [strumenti](#tools) che agiscono. Fuxi Code funge da **harness agentico** intorno a Fuxi: fornisce gli strumenti, la gestione del contesto e l'ambiente di esecuzione che trasformano un modello di linguaggio in un agente di codifica capace.
Modelli
Fuxi Code utilizza i modelli Fuxi per comprendere il tuo codice e ragionare sui compiti. Fuxi può leggere codice in qualsiasi linguaggio, comprendere come i componenti si collegano e capire cosa deve cambiare per raggiungere il tuo obiettivo. Per compiti complessi, suddivide il lavoro in passaggi, li esegue e si adatta in base a quello che impara.
[Sono disponibili più modelli](/it/model-config) con diversi compromessi. Sonnet gestisce bene la maggior parte dei compiti di codifica. Opus fornisce un ragionamento più forte per decisioni architettoniche complesse. Cambia con `/model` durante una sessione o inizia con `fuxi --model `.
Quando questa guida dice "Fuxi sceglie" o "Fuxi decide", è il modello che sta facendo il ragionamento.
Gli strumenti sono ciò che rende Fuxi Code agentico. Senza strumenti, Fuxi può solo rispondere con testo. Con gli strumenti, Fuxi può agire: leggere il tuo codice, modificare file, eseguire comandi, cercare il web e interagire con servizi esterni. Ogni utilizzo di uno strumento restituisce informazioni che si alimentano nel ciclo, informando la decisione successiva di Fuxi.
Gli strumenti integrati generalmente rientrano in cinque categorie, ognuna rappresentante un diverso tipo di agenzia.
| Categoria | Cosa Fuxi può fare |
| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Operazioni su file** | Leggere file, modificare codice, creare nuovi file, rinominare e riorganizzare |
| **Ricerca** | Trovare file per pattern, cercare contenuto con regex, esplorare basi di codice |
| **Esecuzione** | Eseguire comandi shell, avviare server, eseguire test, usare git |
| **Web** | Cercare il web, recuperare documentazione, cercare messaggi di errore |
| **Intelligenza del codice** | Vedere errori di tipo e avvisi dopo le modifiche, saltare alle definizioni, trovare riferimenti (richiede [plugin di intelligenza del codice](/it/discover-plugins#code-intelligence)) |
Queste sono le capacità principali. Fuxi ha anche strumenti per generare subagents, farti domande e altri compiti di orchestrazione. Consulta [Strumenti disponibili per Fuxi](/it/tools-reference) per l'elenco completo.
Fuxi sceglie quali strumenti utilizzare in base al tuo prompt e a quello che impara lungo il percorso. Quando dici "correggi i test falliti", Fuxi potrebbe:
1. Eseguire la suite di test per vedere cosa sta fallendo
2. Leggere l'output dell'errore
3. Cercare i file sorgente rilevanti
4. Leggere quei file per comprendere il codice
5. Modificare i file per correggere il problema
6. Eseguire di nuovo i test per verificare
Ogni utilizzo di uno strumento fornisce a Fuxi nuove informazioni che informano il passaggio successivo. Questo è il ciclo agentico in azione.
**Estensione delle capacità di base:** Gli strumenti integrati sono la fondazione. Puoi estendere quello che Fuxi sa con [skills](/it/skills), connetterti a servizi esterni con [MCP](/it/mcp), automatizzare flussi di lavoro con [hooks](/it/hooks) e delegare compiti a [subagents](/it/sub-agents). Queste estensioni formano un livello sopra il ciclo agentico principale. Consulta [Estendi Fuxi Code](/it/features-overview) per una guida sulla scelta dell'estensione giusta per le tue esigenze.
A cosa Fuxi può accedere
Questa guida si concentra sul terminale. Fuxi Code funziona anche in [VS Code](/it/vs-code), [IDE JetBrains](/it/jetbrains) e altri ambienti.
Quando esegui `fuxi` in una directory, Fuxi Code ottiene accesso a:
* **Il tuo progetto.** File nella tua directory e sottodirectory, più file altrove con la tua autorizzazione.
* **Il tuo terminale.** Qualsiasi comando che potresti eseguire: strumenti di build, git, gestori di pacchetti, utilità di sistema, script. Se puoi farlo dalla riga di comando, Fuxi può farlo anche lui.
* **Il tuo stato git.** Ramo corrente, modifiche non committate e cronologia dei commit recenti.
* **Il tuo [FUXI.md](/it/memory).** Un file markdown dove memorizzi istruzioni specifiche del progetto, convenzioni e contesto che Fuxi dovrebbe conoscere ogni sessione.
* **[Auto memory](/it/memory#auto-memory).** Apprendimenti che Fuxi salva automaticamente mentre lavori, come pattern di progetto e le tue preferenze. Le prime 200 righe o 25KB di MEMORY.md, a seconda di quale viene raggiunto per primo, si caricano all'inizio di ogni sessione.
* **Estensioni che configuri.** [Server MCP](/it/mcp) per servizi esterni, [skills](/it/skills) per flussi di lavoro, [subagents](/it/sub-agents) per lavoro delegato e [Fuxi in Chrome](/it/chrome) per l'interazione del browser.
Poiché Fuxi vede l'intero tuo progetto, può lavorare su di esso. Quando chiedi a Fuxi di "correggere il bug di autenticazione", cerca file rilevanti, legge più file per comprendere il contesto, apporta modifiche coordinate su di essi, esegue test per verificare la correzione e committa le modifiche se lo chiedi. Questo è diverso dagli assistenti di codice inline che vedono solo il file corrente.
Ambienti e interfacce
Il ciclo agentico, gli strumenti e le capacità descritti sopra sono gli stessi ovunque tu usi Fuxi Code. Quello che cambia è dove il codice viene eseguito e come interagisci con esso.
Ambienti di esecuzione
Fuxi Code funziona in tre ambienti, ognuno con diversi compromessi per dove il tuo codice viene eseguito.
| Ambiente | Dove viene eseguito il codice | Caso d'uso |
| ------------------ | ------------------------------------------ | ---------------------------------------------------------------- |
| **Locale** | La tua macchina | Predefinito. Accesso completo ai tuoi file, strumenti e ambiente |
| **Cloud** | VM gestite da Anthropic | Delegare compiti, lavorare su repo che non hai localmente |
| **Remote Control** | La tua macchina, controllata da un browser | Usa l'interfaccia web mantenendo tutto locale |
Interfacce
Puoi accedere a Fuxi Code tramite il terminale, l'[app desktop](/it/desktop), [estensioni IDE](/it/vs-code), [fuxi.ai/code](https://fuxi.ai/code), [Remote Control](/it/remote-control), [Slack](/it/slack) e [pipeline CI/CD](/it/github-actions). L'interfaccia determina come vedi e interagisci con Fuxi, ma il ciclo agentico sottostante è identico. Consulta [Usa Fuxi Code ovunque](/it/overview#use-fuxi-code-everywhere) per l'elenco completo.
Lavora con le sessioni
Fuxi Code salva la tua conversazione localmente mentre lavori. Ogni messaggio, utilizzo di strumento e risultato viene scritto in un file JSONL in testo semplice sotto `~/.fuxi/projects/`, il che consente [il rewind](#undo-changes-with-checkpoints), [la ripresa e il fork](#resume-or-fork-sessions) delle sessioni. Prima che Fuxi apporta modifiche al codice, crea anche uno snapshot dei file interessati in modo da poter ripristinare se necessario. Per i percorsi, la conservazione e come cancellare questi dati, consulta [dati dell'applicazione in `~/.fuxi`](/it/fuxi-directory#application-data).
**Le sessioni sono indipendenti.** Ogni nuova sessione inizia con una finestra di contesto fresca, senza la cronologia della conversazione dalle sessioni precedenti. Fuxi può persistere gli apprendimenti tra le sessioni utilizzando [auto memory](/it/memory#auto-memory) e puoi aggiungere le tue istruzioni persistenti in [FUXI.md](/it/memory).
Lavora tra i rami
Ogni conversazione di Fuxi Code è una sessione legata alla tua directory corrente. Il picker `/resume` mostra sessioni dal worktree corrente per impostazione predefinita, con scorciatoie da tastiera per ampliare l'elenco ad altri worktrees o progetti. Consulta [Gestisci sessioni](/it/sessions#use-the-session-picker) per l'elenco completo delle scorciatoie del picker e come funziona la risoluzione dei nomi.
Fuxi vede i file del tuo ramo corrente. Quando cambi ramo, Fuxi vede i file del nuovo ramo, ma la cronologia della tua conversazione rimane la stessa. Fuxi ricorda quello che hai discusso anche dopo il cambio di ramo.
Poiché le sessioni sono legate alle directory, puoi eseguire sessioni Fuxi parallele utilizzando [git worktrees](/it/worktrees), che creano directory separate per singoli rami.
Riprendi o fai il fork delle sessioni
Riprendere una sessione con `fuxi --continue` o `fuxi --resume` la riapre con lo stesso ID di sessione e aggiunge nuovi messaggi alla conversazione esistente. Fare il fork con `--fork-session` o `/branch` copia la cronologia in un nuovo ID di sessione, lasciando l'originale invariato.
Per i flag di ripresa, il picker `/resume`, la denominazione e cosa succede quando la stessa sessione è aperta in due terminali, consulta [Gestisci sessioni](/it/sessions).
La finestra di contesto
La finestra di contesto di Fuxi contiene la cronologia della tua conversazione, i contenuti dei file, gli output dei comandi, [FUXI.md](/it/memory), [auto memory](/it/memory#auto-memory), le skills caricate e le istruzioni di sistema. Man mano che lavori, il contesto si riempie. Fuxi compatta automaticamente, ma le istruzioni dall'inizio della conversazione possono andare perse. Metti le regole persistenti in FUXI.md ed esegui `/context` per vedere cosa sta usando lo spazio.
Per una procedura interattiva di quello che si carica e quando, consulta [Esplora la finestra di contesto](/it/context-window).
Quando il contesto si riempie
Fuxi Code gestisce il contesto automaticamente mentre ti avvicini al limite. Cancella prima gli output degli strumenti più vecchi, quindi riassume la conversazione se necessario. Le tue richieste e i frammenti di codice chiave vengono preservati; le istruzioni dettagliate dall'inizio della conversazione possono andare perse. Metti le regole persistenti in FUXI.md piuttosto che fare affidamento sulla cronologia della conversazione.
Per controllare cosa viene preservato durante la compattazione, aggiungi una sezione "Compact Instructions" a FUXI.md o esegui `/compact` con un focus (come `/compact focus on the API changes`).
Se un singolo file o output di strumento è così grande che il contesto si riempie immediatamente dopo ogni riassunto, Fuxi Code smette di compattare automaticamente dopo alcuni tentativi e mostra un errore invece di fare un ciclo. Consulta [Auto-compaction stops with a thrashing error](/it/troubleshooting#auto-compaction-stops-with-a-thrashing-error) per i passaggi di recupero.
Esegui `/context` per vedere cosa sta usando lo spazio. Le definizioni degli strumenti MCP vengono differite per impostazione predefinita e caricate su richiesta tramite [ricerca degli strumenti](/it/mcp#scale-with-mcp-tool-search), quindi solo i nomi degli strumenti consumano contesto fino a quando Fuxi utilizza uno strumento specifico. Esegui `/mcp` per controllare i costi per server.
Gestisci il contesto con skills e subagents
Oltre alla compattazione, puoi utilizzare altre funzionalità per controllare cosa viene caricato nel contesto.
[Skills](/it/skills) si caricano su richiesta. Fuxi vede le descrizioni delle skills all'inizio della sessione, ma il contenuto completo si carica solo quando una skill viene utilizzata. Per le skills che invochi manualmente, imposta `disable-model-invocation: true` per mantenere le descrizioni fuori dal contesto fino a quando non ne hai bisogno. Per le skills che non hai scritto, utilizza [`skillOverrides`](/it/skills#override-skill-visibility-from-settings) per fare lo stesso dalle impostazioni.
[Subagents](/it/sub-agents) ottengono il loro contesto fresco, completamente separato dalla tua conversazione principale. Il loro lavoro non gonfia il tuo contesto. Quando finito, restituiscono un riassunto. Questo isolamento è il motivo per cui i subagents aiutano con le sessioni lunghe.
Consulta [costi del contesto](/it/features-overview#understand-context-costs) per quello che ogni funzionalità costa e [riduci l'utilizzo dei token](/it/costs#reduce-token-usage) per suggerimenti sulla gestione del contesto.
Rimani al sicuro con checkpoint e permessi
Fuxi ha due meccanismi di sicurezza: i checkpoint ti permettono di annullare le modifiche ai file e i permessi controllano cosa Fuxi può fare senza chiedere.
Annulla le modifiche con i checkpoint
**Ogni modifica ai file è reversibile.** Prima che Fuxi modifichi qualsiasi file, crea uno snapshot dei contenuti attuali. Se qualcosa va storto, premi `Esc` due volte per tornare a uno stato precedente, o chiedi a Fuxi di annullare.
I checkpoint sono separati da git e rimangono disponibili quando riprendi una conversazione. Coprono solo le modifiche ai file. Le azioni che influenzano i sistemi remoti (database, API, distribuzioni) non possono essere checkpointed, motivo per cui Fuxi chiede prima di eseguire comandi con effetti collaterali esterni.
Controlla cosa Fuxi può fare
Premi `Shift+Tab` per scorrere le modalità di permesso:
* **Manual**: Fuxi chiede prima delle modifiche ai file e dei comandi shell
* **Accept edits**: Fuxi modifica i file ed esegue comandi comuni del file system come `mkdir` e `mv` senza chiedere, chiede ancora per altri comandi
* **Plan**: Fuxi esplora e propone un piano senza modificare i tuoi file sorgente
* **Auto**: Fuxi valuta tutte le azioni con controlli di sicurezza in background
Puoi anche consentire comandi specifici in `.fuxi/settings.json` in modo che Fuxi non chieda ogni volta. Questo è utile per comandi affidabili come `npm test` o `git status`. Le impostazioni possono essere scoped da politiche a livello di organizzazione fino alle preferenze personali. Consulta [Permessi](/it/permissions) per i dettagli.
***
Lavora efficacemente con Fuxi Code
Questi suggerimenti ti aiutano a ottenere risultati migliori da Fuxi Code.
Chiedi aiuto a Fuxi Code
Fuxi Code può insegnarti come usarlo. Fai domande come "come configuro gli hooks?" o "qual è il modo migliore per strutturare il mio FUXI.md?" e Fuxi spiegherà.
I comandi integrati ti guidano anche attraverso la configurazione:
* `/init` ti guida attraverso la creazione di un FUXI.md per il tuo progetto
* `/doctor` esegue un controllo di configurazione che diagnostica i problemi di installazione e configurazione e può risolverli
È una conversazione
Fuxi Code è conversazionale. Non hai bisogno di prompt perfetti. Inizia con quello che vuoi, quindi affina:
```text theme={null}
Correggi il bug di login
```
\[Fuxi indaga, prova qualcosa]
```text theme={null}
Non è del tutto giusto. Il problema è nella gestione della sessione.
```
\[Fuxi adatta l'approccio]
Quando il primo tentativo non è giusto, non ricominciare da capo. Itera.
Interrompi e indirizza
Puoi reindirizzare Fuxi in qualsiasi momento senza aspettare che il turno finisca o ricominciare da capo:
* **Premi `Esc`** per fermare Fuxi immediatamente. La chiamata dello strumento in esecuzione viene annullata e Fuxi attende la tua prossima istruzione.
* **Digita una correzione e premi `Invio`** per inviarla senza fermare lo strumento in esecuzione. Fuxi la legge non appena l'azione corrente si completa e si adatta prima di decidere il suo prossimo passo.
Sii specifico all'inizio
Più preciso è il tuo prompt iniziale, meno correzioni avrai bisogno. Fai riferimento a file specifici, menziona vincoli e indica pattern di esempio.
```text theme={null}
Il flusso di checkout è rotto per gli utenti con carte scadute.
Controlla src/payments/ per il problema, specialmente l'aggiornamento del token.
Scrivi prima un test fallito, poi correggilo.
```
I prompt vaghi funzionano, ma passerai più tempo a indirizzare. I prompt specifici come quello sopra spesso hanno successo al primo tentativo.
Dai a Fuxi qualcosa da verificare
Fuxi funziona meglio quando può verificare il suo lavoro. Includi casi di test, incolla screenshot dell'interfaccia utente prevista o definisci l'output che desideri.
```text theme={null}
Implementa validateEmail. Casi di test: 'user@example.com' → true,
'invalid' → false, 'user@.com' → false. Esegui i test dopo.
```
Per il lavoro visivo, incolla uno screenshot del design e chiedi a Fuxi di confrontare la sua implementazione con esso.
Esplora prima di implementare
Per problemi complessi, separa la ricerca dalla codifica. Utilizza la modalità piano (`Shift+Tab` due volte) per analizzare prima la base di codice:
```text theme={null}
Leggi src/auth/ e comprendi come gestiamo le sessioni.
Quindi crea un piano per aggiungere il supporto OAuth.
```
Rivedi il piano, affinalo attraverso la conversazione, quindi lascia che Fuxi implementi. Questo approccio a due fasi produce risultati migliori rispetto al passare direttamente al codice.
Delega, non dettare
Pensa di delegare a un collega capace. Fornisci contesto e direzione, quindi affida a Fuxi di capire i dettagli:
```text theme={null}
Il flusso di checkout è rotto per gli utenti con carte scadute.
Il codice rilevante è in src/payments/. Puoi indagare e correggerlo?
```
Non hai bisogno di specificare quali file leggere o quali comandi eseguire. Fuxi lo capisce.
Cosa c'è dopo
Aggiungi Skills, connessioni MCP e comandi personalizzati
Guide passo dopo passo per compiti tipici