> ## 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.
# Usa Fuxi Code in VS Code
> Installa e configura l'estensione Fuxi Code per VS Code. Ottieni assistenza di codifica con IA con diff inline, @-mention, revisione del piano e scorciatoie da tastiera.
L'estensione VS Code fornisce un'interfaccia grafica nativa per Fuxi Code, integrata direttamente nel vostro IDE. Questo è il modo consigliato per utilizzare Fuxi Code in VS Code.
Con l'estensione, potete rivedere e modificare i piani di Fuxi prima di accettarli, accettare automaticamente le modifiche mentre vengono apportate, @-mention file con intervalli di righe specifici dalla vostra selezione, accedere alla cronologia delle conversazioni e aprire più conversazioni in schede o finestre separate.
Prerequisiti
Prima di installare, assicurati di avere:
* VS Code 1.98.0 o superiore
* Un account Anthropic: qualsiasi abbonamento Fuxi a pagamento (Pro, Max, Team o Enterprise) o un account Fuxi Console funziona, e non è richiesta alcuna chiave API. Accederai [con questo account](/it/authentication#log-in-to-fuxi-code) quando aprirai l'estensione per la prima volta. Se accedi a Fuxi tramite un provider di terze parti come Amazon Bedrock o Google Cloud's Agent Platform, consulta [Usa provider di terze parti](#use-third-party-providers) per le istruzioni di configurazione.
L'estensione include la propria copia della CLI (interfaccia della riga di comando) per il pannello di chat. Per eseguire `fuxi` nel terminale integrato di VS Code, hai anche bisogno dell'[installazione CLI standalone](/it/setup). Consulta [Estensione VS Code vs. Fuxi Code CLI](#vs-code-extension-vs-fuxi-code-cli) per i dettagli.
Installa l'estensione
Fai clic sul link per il tuo IDE per installare direttamente:
* [Installa per VS Code](vscode:extension/anthropic.fuxi-code)
* [Installa per Cursor](cursor:extension/anthropic.fuxi-code)
Oppure in VS Code, premi `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) per aprire la visualizzazione Estensioni, cerca "Fuxi Code" e fai clic su **Installa**.
L'estensione si installa anche in altri fork di VS Code come Devin Desktop o Kiro. Cerca "Fuxi Code" nella visualizzazione Estensioni dell'editor, oppure installa dal [registro Open VSX](https://open-vsx.org/extension/Anthropic/fuxi-code). Se il tuo editor non riesce a installare l'estensione, [installa la CLI](/it/quickstart) ed esegui `fuxi` nel suo terminale integrato. La CLI funziona in qualsiasi terminale.
Se l'estensione non appare dopo l'installazione, riavvia VS Code o esegui "Developer: Reload Window" dalla Tavolozza dei comandi.
Inizia
Una volta installata, puoi iniziare a utilizzare Fuxi Code tramite l'interfaccia VS Code:
In tutto VS Code, l'icona Spark indica Fuxi Code: 
Il modo più veloce per aprire Fuxi è fare clic sull'icona Spark nella **Barra degli strumenti dell'editor** (angolo in alto a destra dell'editor). L'icona appare solo quando hai un file aperto.
Altri modi per aprire Fuxi Code:
* **Barra attività**: fai clic sull'icona Spark nella barra laterale sinistra per aprire l'elenco delle sessioni. Fai clic su qualsiasi sessione per aprirla come scheda dell'editor completa, o avvia una nuova. Questa icona è sempre visibile nella Barra attività.
* **Tavolozza dei comandi**: `Cmd+Shift+P` (Mac) o `Ctrl+Shift+P` (Windows/Linux), digita "Fuxi Code" e seleziona un'opzione come "Apri in Nuova Scheda"
* **Barra di stato**: fai clic su **✱ Fuxi Code** nell'angolo in basso a destra della finestra. Funziona anche quando nessun file è aperto.
Puoi trascinare il pannello Fuxi per riposizionarlo ovunque in VS Code. Consulta [Personalizza il tuo flusso di lavoro](#customize-your-workflow) per i dettagli.
La prima volta che apri il pannello, appare una schermata di accesso. Fai clic su **Accedi** e completa l'autorizzazione nel tuo browser.
Se vedi **Non connesso · Esegui /login** in seguito, l'estensione riaprirà automaticamente la schermata di accesso. Se non appare, ricarica la finestra dalla Tavolozza dei comandi con **Developer: Reload Window**.
Se hai `ANTHROPIC_API_KEY` impostato nella tua shell ma vedi ancora il prompt di accesso, VS Code potrebbe non aver ereditato l'ambiente della tua shell. Avvia VS Code da un terminale con `code .` in modo che erediti le tue variabili di ambiente, oppure accedi con il tuo account Fuxi.
Dopo aver effettuato l'accesso, appare una checklist **Impara Fuxi Code**. Completa ogni elemento facendo clic su **Mostrami**, oppure chiudila con la X. Per riaprirla in seguito, deseleziona **Nascondi onboarding** nelle impostazioni di VS Code in Estensioni → Fuxi Code.
Chiedi a Fuxi di aiutarti con il tuo codice o i tuoi file, che si tratti di spiegare come funziona qualcosa, eseguire il debug di un problema o apportare modifiche.
Fuxi vede automaticamente il testo selezionato. Premi `Option+K` (Mac) / `Alt+K` (Windows/Linux) per inserire anche un riferimento @-mention (come `@file.ts#5-10`) nel tuo prompt.
Ecco un esempio di domanda su una riga particolare in un file:
Quando Fuxi vuole modificare un file, mostra un confronto affiancato dell'originale e delle modifiche proposte, quindi chiede il permesso. Puoi accettare, rifiutare o dire a Fuxi cosa fare invece. Se modifichi il contenuto proposto direttamente nella visualizzazione diff prima di accettare, Fuxi viene informato che l'hai modificato in modo che non assuma che il file corrisponda alla sua proposta originale.
Per altre idee su cosa puoi fare con Fuxi Code, consulta [Flussi di lavoro comuni](/it/common-workflows).
Esegui "Fuxi Code: Open Walkthrough" dalla Tavolozza dei comandi per una visita guidata delle nozioni di base.
Usa la casella dei prompt
La casella dei prompt supporta diverse funzioni:
* **Modalità di permesso**: fai clic sull'indicatore di modalità in fondo alla casella dei prompt per cambiare modalità, oppure imposta il valore predefinito nelle impostazioni di VS Code in `fuxiCode.initialPermissionMode`. Consulta [modalità di permesso](/it/permission-modes#switch-permission-modes) per ogni modalità che l'indicatore offre.
* **Manual**: Fuxi chiede il permesso prima di modifiche ai file e della maggior parte dei comandi shell.
* **Plan**: Fuxi descrive cosa farà e attende l'approvazione prima di apportare modifiche. VS Code apre automaticamente il piano come documento Markdown completo dove puoi aggiungere commenti inline per fornire feedback prima che Fuxi inizi.
* **Edit automatically**: Fuxi apporta modifiche senza chiedere.
* **Command menu**: fai clic su `/` o digita `/` per aprire il menu dei comandi. Le opzioni includono l'allegato di file, il cambio di modelli, l'attivazione del pensiero esteso, la visualizzazione dell'utilizzo del piano (`/usage`) e l'avvio di una sessione [Remote Control](/it/remote-control) (`/remote-control`). La sezione Customize fornisce accesso ai server MCP, hooks, memoria, autorizzazioni e plugin. Gli elementi con un'icona del terminale si aprono nel terminale integrato.
* {/* min-version: 2.1.203 */}La sezione Settings include **Enable Remote Control for all sessions**, che imposta [`remoteControlAtStartup`](/it/settings#available-settings) in modo che [ogni nuova sessione interattiva si connetta automaticamente a Remote Control](/it/remote-control#enable-remote-control-for-all-sessions). Richiede Fuxi Code v2.1.203 o successivo.
* **Context indicator**: la casella dei prompt mostra quanto della finestra di contesto di Fuxi stai utilizzando. Fuxi si compatta automaticamente quando necessario, oppure puoi eseguire `/compact` manualmente.
* **Extended thinking**: consente a Fuxi di dedicare più tempo al ragionamento su problemi complessi. Attivalo tramite il menu dei comandi (`/`). Il ragionamento di Fuxi appare nella conversazione come blocchi compressi: fai clic su un blocco per leggerlo, oppure premi `Ctrl+O` per espandere o comprimere ogni blocco di pensiero nella sessione. Consulta [Extended thinking](/it/model-config#extended-thinking) per i dettagli.
* **Multi-line input**: premi `Shift+Enter` per aggiungere una nuova riga senza inviare. Funziona anche nell'input di testo libero "Other" dei dialoghi delle domande.
Reference files and folders
Usa @-mention per dare a Fuxi il contesto su file o cartelle specifiche. Quando digiti `@` seguito da un nome di file o cartella, Fuxi legge quel contenuto e può rispondere a domande su di esso o apportare modifiche. Fuxi Code supporta la corrispondenza fuzzy, quindi puoi digitare nomi parziali per trovare quello che ti serve:
```text theme={null}
> Explain the logic in @auth (fuzzy matches auth.js, AuthService.ts, etc.)
> What's in @src/components/ (include a trailing slash for folders)
```
Per i PDF di grandi dimensioni, puoi chiedere a Fuxi di leggere pagine specifiche invece dell'intero file: una singola pagina, un intervallo come pagine 1-10, o un intervallo aperto come pagina 3 in poi.
Quando selezioni il testo nell'editor, Fuxi può vedere il tuo codice evidenziato automaticamente. Il piè di pagina della casella dei prompt mostra quante righe sono selezionate. Premi `Option+K` (Mac) / `Alt+K` (Windows/Linux) per inserire un @-mention con il percorso del file e i numeri di riga (ad es. `@app.ts#5-10`). Fai clic sull'indicatore di selezione per attivare/disattivare se Fuxi può vedere il tuo testo evidenziato - l'icona occhio-barra significa che la selezione è nascosta a Fuxi.
Puoi anche tenere premuto `Shift` mentre trascini i file nella casella dei prompt per aggiungerli come allegati. Fai clic sulla X su qualsiasi allegato per rimuoverlo dal contesto.
Resume past conversations
Fai clic sul pulsante **Session history** in cima al pannello Fuxi Code per accedere alla cronologia delle conversazioni. Puoi cercare per parola chiave o sfogliare per tempo (Today, Yesterday, Last 7 days, ecc.). Fai clic su qualsiasi conversazione per riprenderla con la cronologia completa dei messaggi. Le nuove sessioni ricevono titoli generati dall'IA in base al tuo primo messaggio. Passa il mouse su una sessione per rivelare le azioni di rinomina e rimozione: rinomina per darle un titolo descrittivo, o rimuovi per eliminarla dall'elenco. Per ulteriori informazioni sulla ripresa delle sessioni, consulta [Manage sessions](/it/sessions).
Resume cloud sessions from Fuxi.ai
Se utilizzi [Fuxi Code on the web](/it/fuxi-code-on-the-web), puoi riprendere quelle sessioni remote direttamente in VS Code. Ciò richiede l'accesso con **Fuxi.ai Subscription**, non Anthropic Console.
Fai clic sul pulsante **Session history** in cima al pannello Fuxi Code.
La finestra di dialogo mostra due schede: Local e Remote. Fai clic su **Remote** per vedere le sessioni da fuxi.ai.
Sfoglia o cerca le tue sessioni remote. Fai clic su qualsiasi sessione per scaricarla e continuare la conversazione localmente.
Solo le sessioni web avviate con un repository GitHub appaiono nella scheda Remote. La ripresa carica la cronologia della conversazione localmente; le modifiche non vengono sincronizzate di nuovo a fuxi.ai.
Check account and usage
Esegui `/usage` dal menu dei comandi per aprire la finestra di dialogo Account & usage. Mostra il tuo account con accesso effettuato, il piano e le barre di utilizzo per la sessione corrente e la settimana con quanto tempo rimane prima che ogni limite si ripristini.
La finestra di dialogo suddivide anche ciò che contribuisce ai tuoi limiti di piano. Evidenzia i comportamenti che rappresentano il 10% o più dell'utilizzo recente, come i mancati accessi alla cache, il contesto lungo e le sessioni pesanti di subagent o altamente parallele, ciascuno con un suggerimento per ridurlo. Le tabelle di attribuzione mostrano quanto utilizzo è provenuto da ogni skill, subagent, plugin e server MCP. Richiede Fuxi Code v2.1.174 o successivo.
Utilizza l'interruttore Day e Week per passare tra le ultime 24 ore e gli ultimi 7 giorni. Le cifre sono approssimative e calcolate dalle sessioni locali su questa macchina, quindi l'utilizzo da altri dispositivi o da fuxi.ai non è incluso. Per ulteriori informazioni sul tracciamento e la riduzione dell'utilizzo, consulta [Track your costs](/it/costs#track-your-costs).
Personalizza il tuo flusso di lavoro
Una volta che sei operativo, puoi riposizionare il pannello Fuxi, eseguire più sessioni o passare alla modalità terminale.
Scegli dove vive Fuxi
Puoi trascinare il pannello Fuxi per riposizionarlo ovunque in VS Code. Afferra la scheda o la barra del titolo del pannello e trascinalo a:
* **Barra laterale secondaria**: il lato destro della finestra. Mantiene Fuxi visibile mentre codifichi.
* **Barra laterale primaria**: la barra laterale sinistra con icone per Explorer, Search, ecc.
* **Area dell'editor**: apre Fuxi come scheda insieme ai tuoi file. Utile per attività secondarie.
Usa la barra laterale per la tua sessione Fuxi principale e apri schede aggiuntive per attività secondarie. Fuxi ricorda la tua posizione preferita. L'icona dell'elenco delle sessioni della Barra attività è separata dal pannello Fuxi: l'elenco delle sessioni è sempre visibile nella Barra attività, mentre l'icona del pannello Fuxi appare lì solo quando il pannello è ancorato alla barra laterale sinistra.
Esegui più conversazioni
Usa **Apri in Nuova Scheda** o **Apri in Nuova Finestra** dalla Tavolozza dei comandi per avviare conversazioni aggiuntive. Ogni conversazione mantiene la propria cronologia e contesto, permettendoti di lavorare su diversi compiti in parallelo.
Quando usi le schede, un piccolo punto colorato sull'icona spark indica lo stato: blu significa che una richiesta di permesso è in sospeso, arancione significa che Fuxi ha finito mentre la scheda era nascosta.
Passa alla modalità terminale
Per impostazione predefinita, l'estensione apre un pannello di chat grafico. Se preferisci l'interfaccia in stile CLI, apri l'[impostazione Use Terminal](vscode://settings/fuxiCode.useTerminal) e seleziona la casella.
Puoi anche aprire le impostazioni di VS Code (`Cmd+,` su Mac o `Ctrl+,` su Windows/Linux), vai a Estensioni → Fuxi Code e seleziona **Use Terminal**.
Gestisci i plugin
L'estensione VS Code include un'interfaccia grafica per installare e gestire i [plugin](/it/plugins). Digita `/plugins` nella casella dei prompt per aprire l'interfaccia **Gestisci plugin**.
Installa i plugin
La finestra di dialogo del plugin mostra due schede: **Plugin** e **Marketplaces**.
Nella scheda Plugin:
* I **plugin installati** appaiono in cima con interruttori per abilitarli o disabilitarli
* I **plugin disponibili** dai tuoi marketplace configurati appaiono sotto
* Cerca per filtrare i plugin per nome o descrizione
* Fai clic su **Installa** su qualsiasi plugin disponibile
Quando installi un plugin, scegli l'ambito di installazione:
* **Installa per te**: disponibile in tutti i tuoi progetti (ambito utente)
* **Installa per questo progetto**: condiviso con i collaboratori del progetto (ambito progetto)
* **Installa localmente**: solo per te, solo in questo repository (ambito locale)
Gestisci i marketplace
Passa alla scheda **Marketplaces** per aggiungere o rimuovere fonti di plugin:
* Inserisci un repository GitHub, URL o percorso locale per aggiungere un nuovo marketplace
* Fai clic sull'icona di aggiornamento per aggiornare l'elenco dei plugin di un marketplace
* Fai clic sull'icona del cestino per rimuovere un marketplace
Dopo aver apportato modifiche, un banner ti chiede di riavviare Fuxi Code per applicare gli aggiornamenti.
La gestione dei plugin in VS Code utilizza gli stessi comandi CLI sotto il cofano. I plugin e i marketplace che configuri nell'estensione sono disponibili anche nella CLI e viceversa.
Per ulteriori informazioni sul sistema dei plugin, consulta [Plugins](/it/plugins) e [Plugin marketplaces](/it/plugin-marketplaces).
Automatizza le attività del browser con Chrome
Connetti Fuxi al tuo browser Chrome per testare app web, eseguire il debug con i log della console e automatizzare i flussi di lavoro del browser senza lasciare VS Code. Ciò richiede l'[estensione Fuxi in Chrome](https://chromewebstore.google.com/detail/fuxi/fcoeoabgfenejglbffodgkkbkcdhcgfn) versione 1.0.36 o superiore.
Digita `@browser` nella casella dei prompt seguito da quello che vuoi che Fuxi faccia:
```text theme={null}
@browser go to localhost:3000 and check the console for errors
```
Puoi anche aprire il menu degli allegati per selezionare strumenti specifici del browser come aprire una nuova scheda o leggere il contenuto della pagina.
Fuxi apre nuove schede per le attività del browser e condivide lo stato di accesso del tuo browser, quindi può accedere a qualsiasi sito a cui sei già connesso.
Per le istruzioni di configurazione, l'elenco completo delle funzionalità e la risoluzione dei problemi, consulta [Usa Fuxi Code con Chrome](/it/chrome).
Comandi e scorciatoie da tastiera di VS Code
Apri la Tavolozza dei comandi (`Cmd+Shift+P` su Mac o `Ctrl+Shift+P` su Windows/Linux) e digita "Fuxi Code" per vedere tutti i comandi VS Code disponibili per l'estensione Fuxi Code.
Alcune scorciatoie dipendono da quale pannello è "focalizzato" (riceve input da tastiera). Quando il tuo cursore è in un file di codice, l'editor è focalizzato. Quando il tuo cursore è nella casella dei prompt di Fuxi, Fuxi è focalizzato. Usa `Cmd+Esc` / `Ctrl+Esc` per alternare tra loro.
Questi sono comandi VS Code per controllare l'estensione. Non tutti i comandi Fuxi Code incorporati sono disponibili nell'estensione. Consulta [Estensione VS Code vs. Fuxi Code CLI](#vs-code-extension-vs-fuxi-code-cli) per i dettagli.
| Comando | Scorciatoia | Descrizione |
| -------------------------- | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Focus Input | `Cmd+Esc` (Mac) / `Ctrl+Esc` (Windows/Linux) | Alterna lo stato attivo tra editor e Fuxi |
| Open in Side Bar | - | Apri Fuxi nella barra laterale sinistra |
| Open in Terminal | - | Apri Fuxi in modalità terminale |
| Open in New Tab | `Cmd+Shift+Esc` (Mac) / `Ctrl+Shift+Esc` (Windows/Linux) | Apri una nuova conversazione come scheda dell'editor |
| Open in New Window | - | Apri una nuova conversazione in una finestra separata |
| New Conversation | `Cmd+N` (Mac) / `Ctrl+N` (Windows/Linux) | Avvia una nuova conversazione. Richiede che Fuxi sia focalizzato e `enableNewConversationShortcut` impostato su `true` |
| Reopen Closed Session | `Cmd+Shift+T` (Mac) / `Ctrl+Shift+T` (Windows/Linux) | Riapri la scheda della sessione Fuxi chiusa più di recente. Ricade al normale riapertura dell'editor chiuso di VS Code quando l'ultima scheda chiusa non era una sessione Fuxi. Disabilita con `enableReopenClosedSessionShortcut` |
| Insert @-Mention Reference | `Option+K` (Mac) / `Alt+K` (Windows/Linux) | Inserisci un riferimento al file corrente e alla selezione (richiede che l'editor sia focalizzato) |
| Show Logs | - | Visualizza i log di debug dell'estensione |
| Logout | - | Esci dal tuo account Anthropic |
L'estensione registra un gestore URI in `vscode://anthropic.fuxi-code/open`. Usalo per aprire una nuova scheda Fuxi Code dal tuo strumento: un alias shell, un bookmarklet del browser o qualsiasi script che possa aprire un URL. Se VS Code non è già in esecuzione, l'apertura dell'URL lo avvia prima. Se VS Code è già in esecuzione, l'URL si apre nella finestra attualmente focalizzata.
Richiama il gestore con l'opener URL del tuo sistema operativo.
```bash theme={null}
open "vscode://anthropic.fuxi-code/open"
```
```bash theme={null}
xdg-open "vscode://anthropic.fuxi-code/open"
```
In PowerShell:
```powershell theme={null}
Start-Process "vscode://anthropic.fuxi-code/open"
```
In `cmd.exe`, `start` tratta il suo primo argomento tra virgolette come titolo della finestra, quindi passa un titolo vuoto prima dell'URL:
```cmd theme={null}
start "" "vscode://anthropic.fuxi-code/open"
```
Il gestore accetta due parametri di query facoltativi:
| Parametro | Descrizione |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `prompt` | Testo per pre-compilare nella casella dei prompt. Deve essere codificato in URL. Il prompt è pre-compilato ma non inviato automaticamente. |
| `session` | Un ID di sessione da riprendere invece di avviare una nuova conversazione. La sessione deve appartenere all'area di lavoro attualmente aperta in VS Code. Se la sessione non viene trovata, viene avviata una conversazione nuova. Se la sessione è già aperta in una scheda, quella scheda viene focalizzata. Per acquisire un ID di sessione a livello di programmazione, consulta [Continua conversazioni](/it/headless#continue-conversations). |
Ad esempio, per aprire una scheda pre-compilata con "review my changes":
```text theme={null}
vscode://anthropic.fuxi-code/open?prompt=review%20my%20changes
```
Per avviare una sessione terminale invece di una scheda VS Code, usa il gestore `fuxi-cli://` della CLI. Consulta [Avvia sessioni dai link](/it/deep-links).
L'estensione ha due tipi di impostazioni:
* **Impostazioni dell'estensione** in VS Code: controllano il comportamento dell'estensione all'interno di VS Code. Apri con `Cmd+,` (Mac) o `Ctrl+,` (Windows/Linux), quindi vai a Estensioni → Fuxi Code. Puoi anche digitare `/` e selezionare **General Config** per aprire le impostazioni.
* **Impostazioni Fuxi Code** in `~/.fuxi/settings.json`: condivise tra l'estensione e la CLI. Usa per comandi consentiti, variabili di ambiente, hooks e server MCP. Consulta [Impostazioni](/it/settings) per i dettagli.
Aggiungi `"$schema": "https://json.schemastore.org/fuxi-code-settings.json"` al tuo `settings.json` per ottenere l'autocompletamento e la convalida inline per tutte le impostazioni disponibili direttamente in VS Code.
Impostazioni dell'estensione
| Impostazione | Predefinito | Descrizione |
| ----------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `useTerminal` | `false` | Avvia Fuxi in modalità terminale invece di pannello grafico |
| `initialPermissionMode` | `default` | Controlla i prompt di approvazione per le nuove conversazioni: `default`, `plan`, `acceptEdits`, o `bypassPermissions`. {/* min-version: 2.1.200 */}`manual` è un alias per `default` e seleziona la modalità etichettata **Manual** nell'indicatore di modalità. Richiede Fuxi Code v2.1.200 o successivo. Consulta [modalità di permesso](/it/permission-modes). |
| `preferredLocation` | `panel` | Dove Fuxi si apre: `sidebar` (destra) o `panel` (nuova scheda) |
| `autosave` | `true` | Salva automaticamente i file prima che Fuxi li legga o scriva |
| `useCtrlEnterToSend` | `false` | Usa Ctrl/Cmd+Enter invece di Enter per inviare i prompt |
| `enableNewConversationShortcut` | `false` | Abilita Cmd/Ctrl+N per avviare una nuova conversazione |
| `enableReopenClosedSessionShortcut` | `true` | Usa Cmd/Ctrl+Shift+T per riaprire la scheda della sessione Fuxi chiusa più di recente. Quando l'ultima scheda chiusa non era una sessione Fuxi, la scorciatoia esegue il comando di riapertura dell'editor chiuso normale di VS Code. |
| `hideOnboarding` | `false` | Nascondi la checklist di onboarding (icona del berretto di laurea) |
| `respectGitIgnore` | `true` | Escludi i modelli .gitignore dalle ricerche di file |
| `usePythonEnvironment` | `true` | Attiva l'ambiente Python dell'area di lavoro quando esegui Fuxi. Richiede l'estensione Python. |
| `environmentVariables` | `[]` | Imposta le variabili di ambiente per il processo Fuxi. Usa invece le impostazioni Fuxi Code per la configurazione condivisa. |
| `disableLoginPrompt` | `false` | Salta i prompt di autenticazione (per configurazioni di provider di terze parti) |
| `allowDangerouslySkipPermissions` | `false` | Aggiunge Bypass permissions al selettore di modalità. Usalo solo in sandbox senza accesso a Internet. |
| `fuxiProcessWrapper` | - | Eseguibile utilizzato per avviare il processo Fuxi. Il percorso del binario in bundle viene passato come argomento quando presente. Impostalo su un binario `fuxi` installato separatamente se la build dell'estensione non ne include uno per la tua piattaforma. |
Estensione VS Code vs. Fuxi Code CLI
Fuxi Code è disponibile sia come estensione VS Code (pannello grafico) che come CLI (interfaccia della riga di comando nel terminale). Alcune funzioni sono disponibili solo nella CLI. Se hai bisogno di una funzione solo CLI, esegui `fuxi` nel terminale integrato di VS Code. Questo richiede l'[installazione CLI standalone](/it/setup): l'estensione non aggiunge `fuxi` al tuo PATH. Vedi [Esegui CLI in VS Code](#run-cli-in-vs-code).
| Funzione | CLI | Estensione VS Code |
| ----------------------------- | --------------------- | --------------------------------------------------------------------------------------------------- |
| Comandi e skills | [Tutti](/it/commands) | Sottoinsieme (digita `/` per vedere quelli disponibili) |
| Configurazione del server MCP | Sì | Parziale (aggiungi server tramite CLI; gestisci i server esistenti con `/mcp` nel pannello di chat) |
| Checkpoint | Sì | Sì |
| Scorciatoia bash `!` | Sì | No |
| Completamento scheda | Sì | No |
Riavvolgi con i checkpoint
L'estensione VS Code supporta i checkpoint, che tracciano le modifiche ai file di Fuxi e ti permettono di riavvolgere a uno stato precedente. Passa il mouse su qualsiasi messaggio per rivelare il pulsante di riavvolgimento, quindi scegli tra tre opzioni:
* **Crea un ramo di conversazione da qui**: avvia un nuovo ramo di conversazione da questo messaggio mantenendo intatte tutte le modifiche al codice
* **Riavvolgi il codice a qui**: ripristina le modifiche ai file a questo punto della conversazione mantenendo la cronologia completa della conversazione
* **Crea un ramo di conversazione e riavvolgi il codice**: avvia un nuovo ramo di conversazione e ripristina le modifiche ai file a questo punto
Per i dettagli completi su come funzionano i checkpoint e le loro limitazioni, consulta [Checkpointing](/it/checkpointing).
Esegui CLI in VS Code
Per utilizzare la CLI mentre rimani in VS Code, apri il terminale integrato (`` Ctrl+` `` su Windows/Linux o `` Cmd+` `` su Mac) ed esegui `fuxi`. La CLI si integra automaticamente con il tuo IDE per funzioni come la visualizzazione dei diff e la condivisione dei diagnostici.
L'installazione dell'estensione non mette `fuxi` sul tuo PATH della shell. L'estensione raggruppa una copia privata della CLI per il suo pannello di chat, ma digitare `fuxi` in un terminale richiede l'[installazione CLI standalone](/it/setup). Esegui l'installazione una volta e i comandi su questa pagina, inclusi `fuxi mcp add` e `fuxi --resume`, funzionano in qualsiasi terminale. Se `fuxi` non viene ancora trovato dopo l'installazione, [verifica il tuo PATH](/it/troubleshoot-install#verify-your-path).
Se utilizzi un terminale esterno, esegui `/ide` all'interno di Fuxi Code per collegarlo a VS Code.
Passa tra l'estensione e la CLI
L'estensione e la CLI condividono la stessa cronologia delle conversazioni. Per continuare una conversazione dell'estensione nella CLI, esegui `fuxi --resume` nel terminale. Questo apre un selettore interattivo dove puoi cercare e selezionare la tua conversazione.
Includi l'output del terminale nei prompt
Fai riferimento all'output del terminale nei tuoi prompt usando `@terminal:name` dove `name` è il titolo del terminale. Questo consente a Fuxi di vedere l'output dei comandi, i messaggi di errore o i log senza copia-incolla.
Monitora i processi in background
Quando Fuxi esegue comandi di lunga durata, l'estensione mostra l'avanzamento nella barra di stato. Tuttavia, la visibilità per le attività in background è limitata rispetto alla CLI. Per una migliore visibilità, chiedi a Fuxi di emettere il comando in modo da poterlo eseguire nel terminale integrato di VS Code.
I server MCP (Model Context Protocol) danno a Fuxi accesso a strumenti esterni, database e API.
Per aggiungere un server MCP, apri il terminale integrato (`` Ctrl+` `` o `` Cmd+` ``) ed esegui `fuxi mcp add`. L'esempio seguente aggiunge il server MCP remoto di GitHub, che si autentica con un [token di accesso personale](https://github.com/settings/personal-access-tokens) passato come intestazione:
```bash theme={null}
fuxi mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer YOUR_GITHUB_PAT"
```
Una volta configurato, chiedi a Fuxi di utilizzare gli strumenti (ad es. "Review PR #456").
Per gestire i server MCP senza lasciare VS Code, digita `/mcp` nel pannello di chat. La finestra di dialogo di gestione MCP ti consente di abilitare o disabilitare i server, riconnetterti a un server e gestire l'autenticazione OAuth. Consulta la [documentazione MCP](/it/mcp) per i server disponibili.
Lavora con git
Fuxi Code si integra con git per aiutare con i flussi di lavoro di controllo della versione direttamente in VS Code. Chiedi a Fuxi di eseguire il commit delle modifiche, creare pull request o lavorare tra i rami.
Crea commit e pull request
Fuxi può mettere in stage le modifiche, scrivere messaggi di commit e creare pull request in base al tuo lavoro:
```text theme={null}
> commit my changes with a descriptive message
> create a pr for this feature
> summarize the changes I've made to the auth module
```
Quando crei pull request, Fuxi genera descrizioni in base alle modifiche effettive del codice e può aggiungere contesto su test o decisioni di implementazione.
Usa git worktrees per attività parallele
Usa il flag `--worktree` (`-w`) per avviare Fuxi in un worktree isolato con i suoi file e ramo:
```bash theme={null}
fuxi --worktree feature-auth
```
Ogni worktree mantiene uno stato di file indipendente mentre condivide la cronologia di git. Ciò impedisce alle istanze di Fuxi di interferire l'una con l'altra quando lavorano su diversi compiti. Per ulteriori dettagli, consulta [Esegui sessioni parallele con Git worktrees](/it/worktrees).
Usa provider di terze parti
Per impostazione predefinita, Fuxi Code si connette direttamente all'API di Anthropic. Se la tua organizzazione utilizza Amazon Bedrock, Google Cloud's Agent Platform o Microsoft Foundry per accedere a Fuxi, configura l'estensione per utilizzare il tuo provider:
Apri l'[impostazione Disable Login Prompt](vscode://settings/fuxiCode.disableLoginPrompt) e seleziona la casella.
Puoi anche aprire le impostazioni di VS Code (`Cmd+,` su Mac o `Ctrl+,` su Windows/Linux), cercare "Fuxi Code login" e selezionare **Disable Login Prompt**.
Segui la guida di configurazione per il tuo provider:
* [Fuxi Code su Amazon Bedrock](/it/amazon-bedrock)
* [Fuxi Code su Google Cloud's Agent Platform](/it/google-vertex-ai)
* [Fuxi Code su Microsoft Foundry](/it/microsoft-foundry)
Queste guide coprono la configurazione del tuo provider in `~/.fuxi/settings.json`, che garantisce che le tue impostazioni siano condivise tra l'estensione VS Code e la CLI.
Sicurezza e privacy
Il tuo codice rimane privato. Fuxi Code elabora il tuo codice per fornire assistenza ma non lo utilizza per addestrare i modelli. Per i dettagli sulla gestione dei dati e su come rinunciare alla registrazione, consulta [Dati e privacy](/it/data-usage).
Con le autorizzazioni di auto-edit abilitate, Fuxi Code può modificare i file di configurazione di VS Code (come `settings.json` o `tasks.json`) che VS Code potrebbe eseguire automaticamente. Per ridurre il rischio quando si lavora con codice non attendibile:
* Abilita la [Modalità limitata di VS Code](https://code.visualstudio.com/docs/editor/workspace-trust#_restricted-mode) per gli spazi di lavoro non attendibili
* Usa la modalità di approvazione manuale invece di auto-accept per le modifiche
* Rivedi attentamente le modifiche prima di accettarle
Il server IDE MCP incorporato
Quando l'estensione è attiva, esegue un server MCP locale a cui la CLI si connette automaticamente. Questo è il modo in cui la CLI apre i diff nel visualizzatore diff nativo di VS Code, legge la tua selezione corrente per i riferimenti `@` e — quando stai lavorando in un notebook Jupyter — chiede a VS Code di eseguire le celle.
Il server è denominato `ide` ed è nascosto da `/mcp` perché non c'è nulla da configurare. Se la tua organizzazione utilizza un hook `PreToolUse` per consentire gli strumenti MCP, tuttavia, dovrai sapere che esiste.
**Selezione e contesto del file aperto.** Mentre è connesso, la CLI include la tua selezione dell'editor corrente e il percorso del file attivo come contesto su ogni prompt che invii. La trascrizione mostra una riga `⧉ Selected N lines from ` quando ciò accade. Per escludere un file sensibile come `.env`, aggiungi una [regola di negazione `Read`](/it/permissions#read-and-edit) per il suo percorso. Una regola di negazione corrispondente impedisce sia il testo selezionato che l'avviso del file aperto per quel file di raggiungere Fuxi.
**Trasporto e autenticazione.** Il server si associa a `127.0.0.1` su una porta alta casuale e non è raggiungibile da altre macchine. Ogni attivazione dell'estensione genera un token di autenticazione casuale fresco che la CLI deve presentare per connettersi. Il token viene scritto in un file di blocco in `~/.fuxi/ide/` con autorizzazioni `0600` in una directory `0700`, quindi solo l'utente che esegue VS Code può leggerlo.
**Strumenti esposti al modello.** Il server ospita una dozzina di strumenti, ma solo due sono visibili al modello. Il resto è RPC interno che la CLI utilizza per la sua stessa UI — apertura di diff, lettura di selezioni, salvataggio di file — e viene filtrato prima che l'elenco degli strumenti raggiunga Fuxi.
| Nome dello strumento (come visto dagli hook) | Cosa fa | Scrive? |
| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `mcp__ide__getDiagnostics` | Restituisce i diagnostici del language server — gli errori e gli avvisi nel pannello Problemi di VS Code. Facoltativamente limitato a un file. | No |
| `mcp__ide__executeCode` | Esegue il codice Python nel kernel del notebook Jupyter attivo. Consulta il flusso di conferma di seguito. | Sì |
**L'esecuzione di Jupyter chiede sempre prima.** `mcp__ide__executeCode` non può eseguire nulla silenziosamente. Ad ogni chiamata, il codice viene inserito come una nuova cella alla fine del notebook attivo, VS Code lo scorre in vista e una Quick Pick nativa ti chiede di **Eseguire** o **Annullare**. L'annullamento — o la chiusura della selezione con `Esc` — restituisce un errore a Fuxi e nulla viene eseguito. Lo strumento rifiuta anche completamente quando non c'è un notebook attivo, quando l'estensione Jupyter (`ms-toolsai.jupyter`) non è installata, o quando il kernel non è Python.
La conferma Quick Pick è separata dagli hook `PreToolUse`. Una voce di elenco consentiti per `mcp__ide__executeCode` consente a Fuxi di *proporre* l'esecuzione di una cella; la Quick Pick all'interno di VS Code è quello che le consente di *effettivamente* eseguirla.
Risolvi i problemi comuni
L'estensione non si installa
* Assicurati di avere una versione compatibile di VS Code (1.98.0 o successiva)
* Verifica che VS Code abbia il permesso di installare estensioni
* Prova a installare direttamente dal [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=anthropic.fuxi-code)
L'icona Spark non è visibile
L'icona Spark appare nella **Barra degli strumenti dell'editor** (in alto a destra dell'editor) quando hai un file aperto. Se non la vedi:
1. **Apri un file**: L'icona richiede che un file sia aperto. Avere solo una cartella aperta non è sufficiente.
2. **Controlla la versione di VS Code**: Richiede 1.98.0 o superiore (Aiuto → Informazioni)
3. **Riavvia VS Code**: Esegui "Developer: Reload Window" dalla Tavolozza dei comandi
4. **Disabilita le estensioni in conflitto**: Disabilita temporaneamente altre estensioni AI (Cline, Continue, ecc.)
5. **Controlla l'affidabilità dell'area di lavoro**: L'estensione non funziona in Modalità limitata
In alternativa, fai clic su "✱ Fuxi Code" nella **Barra di stato** (angolo in basso a destra). Funziona anche senza un file aperto. Puoi anche usare la **Tavolozza dei comandi** (`Cmd+Shift+P` / `Ctrl+Shift+P`) e digitare "Fuxi Code".
Cmd+Esc non fa nulla su macOS
Su macOS Tahoe e versioni successive, la scorciatoia di sistema Game Overlay è associata a `Cmd+Esc` per impostazione predefinita e intercetta la pressione del tasto prima che raggiunga VS Code. Per liberare la scorciatoia:
1. Apri Impostazioni di sistema
2. Vai a Tastiera, quindi Scorciatoie da tastiera, quindi Controller di gioco
3. Deseleziona la casella di controllo Game Overlay
In alternativa, riassegna l'estensione a un tasto diverso: apri l'editor [Scorciatoie da tastiera](https://code.visualstudio.com/docs/configure/keybindings) di VS Code (`Cmd+K Cmd+S`), cerca `Fuxi Code: Focus input` e assegna una nuova associazione.
Fuxi Code non risponde mai
Se Fuxi Code non risponde ai tuoi prompt:
1. **Controlla la tua connessione Internet**: Assicurati di avere una connessione Internet stabile
2. **Avvia una nuova conversazione**: Prova ad avviare una conversazione nuova per vedere se il problema persiste
3. **Prova la CLI**: Esegui `fuxi` dal terminale per vedere se ottieni messaggi di errore più dettagliati
Se i problemi persistono, [apri un problema su GitHub](https://github.com/anthropics/fuxi-code/issues) con i dettagli dell'errore.
Disinstalla l'estensione
Per disinstallare l'estensione Fuxi Code:
1. Apri la visualizzazione Estensioni (`Cmd+Shift+X` su Mac o `Ctrl+Shift+X` su Windows/Linux)
2. Cerca "Fuxi Code"
3. Fai clic su **Disinstalla**
L'esecuzione di `fuxi` in un terminale integrato di VS Code reinstalla automaticamente l'estensione. Per mantenerla disinstallata, disattiva **Auto-install IDE extension** in `/config`, oppure imposta [`autoInstallIdeExtension`](/it/settings#global-config-settings) su `false`. Puoi anche impostare la variabile di ambiente [`FUXI_CODE_IDE_SKIP_AUTO_INSTALL`](/it/env-vars) su `1`.
Per rimuovere anche i dati dell'estensione e ripristinare tutte le impostazioni, elimina la directory di archiviazione dell'estensione per la tua piattaforma.
Su macOS:
```bash theme={null}
rm -rf ~/Library/"Application Support"/Code/User/globalStorage/anthropic.fuxi-code
```
Su Linux:
```bash theme={null}
rm -rf ~/.config/Code/User/globalStorage/anthropic.fuxi-code
```
Su Windows, in PowerShell:
```powershell theme={null}
Remove-Item -Recurse -Force "$env:APPDATA\Code\User\globalStorage\anthropic.fuxi-code"
```
Per ulteriore aiuto, consulta la [guida alla risoluzione dei problemi](/it/troubleshooting).
Passaggi successivi
Ora che hai Fuxi Code configurato in VS Code:
* [Esplora i flussi di lavoro comuni](/it/common-workflows) per ottenere il massimo da Fuxi Code
* [Configura i server MCP](/it/mcp) per estendere le capacità di Fuxi con strumenti esterni. Aggiungi i server usando la CLI, quindi gestiscili con `/mcp` nel pannello di chat.
* [Configura le impostazioni di Fuxi Code](/it/settings) per personalizzare i comandi consentiti, gli hooks e altro. Queste impostazioni sono condivise tra l'estensione e la CLI.