> ## 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.
# Riferimento degli strumenti
> Riferimento completo per gli strumenti che Fuxi Code può utilizzare, inclusi i requisiti di autorizzazione e il comportamento per strumento.
Fuxi Code ha accesso a un set di strumenti integrati che lo aiutano a comprendere e modificare la tua codebase. I nomi degli strumenti sono le stringhe esatte che utilizzi nelle [regole di autorizzazione specifiche dello strumento](/it/permissions#tool-specific-permission-rules), [elenchi di strumenti subagent](/it/sub-agents), e [hook matchers](/it/hooks). Per disabilitare completamente uno strumento, aggiungi il suo nome all'array `deny` nelle tue [impostazioni di autorizzazione](/it/permissions#tool-specific-permission-rules).
Per aggiungere strumenti personalizzati, connetti un [server MCP](/it/mcp). Per estendere Fuxi con flussi di lavoro basati su prompt riutilizzabili, scrivi una [skill](/it/skills), che viene eseguita attraverso lo strumento `Skill` esistente piuttosto che aggiungere una nuova voce di strumento.
La colonna Autorizzazione richiesta mostra se lo strumento richiede un prompt nella modalità di autorizzazione predefinita per i percorsi all'interno della directory di lavoro. Gli strumenti di accesso ai file contrassegnati No, inclusi `Read`, `Grep`, e `Glob`, richiedono comunque un prompt per i percorsi al di fuori della [directory di lavoro e directory aggiuntive](/it/permissions#working-directories). `Bash` è contrassegnato Sì ma esegue un set integrato di [comandi di sola lettura](/it/permissions#read-only-commands) senza richiedere un prompt.
| Strumento | Descrizione | Autorizzazione Richiesta |
| :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------- |
| `Agent` | Genera un [subagent](/it/sub-agents) con la propria finestra di contesto per gestire un'attività. Vedi [comportamento dello strumento Agent](#agent-tool-behavior) | No |
| `Artifact` | Pubblica un file HTML o Markdown come [artifact](/it/artifacts): una pagina privata e interattiva su fuxi.ai. Sui piani Team ed Enterprise, puoi condividerlo all'interno della tua organizzazione. {/* plan-availability: feature=artifacts plans=pro,max,team,enterprise providers=anthropic */}Richiede un piano Pro, Max, Team, o Enterprise e autenticazione `/login`; vedi [Disponibilità](/it/artifacts#availability) | Sì |
| `AskUserQuestion` | Pone domande a scelta multipla per raccogliere requisiti o chiarire ambiguità. {/* min-version: 2.1.200 */}Le domande rimangono aperte finché non rispondi: non c'è timeout di inattività per impostazione predefinita. Per fare in modo che una finestra di dialogo inattiva continui automaticamente, imposta l'impostazione [`askUserQuestionTimeout`](/it/settings#available-settings) su `60s`, `5m`, o `10m`, sia nel tuo `settings.json` utente che dalla riga **Question auto-continue timeout** in `/config`. Una volta trascorso il tempo di inattività scelto senza input, la finestra di dialogo si chiude da sola: invia tutte le opzioni che hai già selezionato e comunica a Fuxi che potresti essere lontano dalla tastiera, quindi Fuxi procede secondo il suo giudizio e può ripetere la domanda in seguito. Un conto alla rovescia appare negli ultimi 20 secondi. Qualsiasi pressione di tasto riavvia il timer, così come una finestra focalizzata su terminali che segnalano il focus. Il timeout si applica solo alle domande a scelta multipla di `AskUserQuestion`; i prompt di autorizzazione, inclusa l'approvazione del piano, non si risolvono mai automaticamente in caso di inattività. Nelle versioni v2.1.198 e v2.1.199, la finestra di dialogo continuava automaticamente dopo 60 secondi di inattività per impostazione predefinita, e [`FUXI_AFK_TIMEOUT_MS`](/it/env-vars#variables) era l'unico modo per modificare questo comportamento | No |
| `Bash` | Esegue comandi shell nel tuo ambiente. Vedi [comportamento dello strumento Bash](#bash-tool-behavior) | Sì |
| `CronCreate` | Pianifica un prompt ricorrente o una tantum all'interno della sessione corrente. Le attività hanno ambito di sessione e vengono ripristinate su `--resume` o `--continue` se non scadute. Vedi [attività pianificate](/it/scheduled-tasks) | No |
| `CronDelete` | Annulla un'attività pianificata per ID | No |
| `CronList` | Elenca tutte le attività pianificate nella sessione | No |
| `Edit` | Effettua modifiche mirate a file specifici. Vedi [comportamento dello strumento Edit](#edit-tool-behavior) | Sì |
| `EnterPlanMode` | Passa a Plan Mode per progettare un approccio prima di codificare | No |
| `EnterWorktree` | Crea un [git worktree](/it/worktrees) isolato e vi accede. Passa un `path` per accedere a un worktree esistente invece di crearne uno nuovo. {/* min-version: 2.1.203 */}Al primo accesso, la destinazione può essere un worktree del repository corrente o, in uno spazio di lavoro multi-repository, di un repository annidato al suo interno. Prima della v2.1.203, un worktree di un repository annidato veniva rifiutato. Da una sessione worktree, o da un subagent con una directory di lavoro fissata come [`isolation: worktree`](/it/sub-agents#supported-frontmatter-fields), è disponibile solo il modulo `path` e la destinazione deve trovarsi sotto `.fuxi/worktrees/` del repository della sessione | No |
| `ExitPlanMode` | Presenta un piano per l'approvazione ed esce da Plan Mode | Sì |
| `ExitWorktree` | Esce da una sessione worktree e ritorna alla directory originale. Non disponibile per i subagent che già vengono eseguiti nella propria directory di lavoro, come con [`isolation: worktree`](/it/sub-agents#supported-frontmatter-fields) | No |
| `Glob` | Trova file in base alla corrispondenza di pattern. Vedi [comportamento dello strumento Glob](#glob-tool-behavior) | No |
| `Grep` | Cerca pattern nei contenuti dei file. Vedi [comportamento dello strumento Grep](#grep-tool-behavior) | No |
| `ListMcpResourcesTool` | Elenca le risorse esposte dai [server MCP](/it/mcp) connessi | No |
| `LSP` | Intelligenza del codice tramite language server: salta alle definizioni, trova riferimenti, segnala errori di tipo e avvisi. Vedi [comportamento dello strumento LSP](#lsp-tool-behavior) | No |
| `Monitor` | Esegue un comando in background e restituisce ogni riga di output a Fuxi, in modo che possa reagire alle voci di log, ai cambiamenti di file, o allo stato sottoposto a polling durante la conversazione. Può anche aprire un WebSocket e trattare ogni messaggio in arrivo come un evento. Vedi [strumento Monitor](#monitor-tool) | Sì |
| `NotebookEdit` | Modifica le celle del notebook Jupyter. Vedi [comportamento dello strumento NotebookEdit](#notebookedit-tool-behavior) | Sì |
| `PowerShell` | Esegue comandi PowerShell nativamente. Vedi [strumento PowerShell](#powershell-tool) per la disponibilità | Sì |
| `PushNotification` | Invia una notifica desktop e una push su telefono quando [Remote Control](/it/remote-control) è connesso, in modo che un'attività di lunga durata o un'[attività pianificata](/it/scheduled-tasks) possa raggiungerti quando ti allontani. {/* plan-availability: feature=push-notifications providers=anthropic */}La consegna push viene eseguita attraverso l'infrastruttura ospitata da Anthropic, che non è accessibile da Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry | No |
| `Read` | Legge il contenuto dei file. Vedi [comportamento dello strumento Read](#read-tool-behavior) | No |
| `ReadMcpResourceTool` | Legge una risorsa MCP specifica per URI | No |
| `RemoteTrigger` | Crea, aggiorna, esegue ed elenca [Routine](/it/routines) su fuxi.ai. Supporta il comando `/schedule`. {/* plan-availability: feature=routines plans=pro,max,team,enterprise providers=anthropic */}Le Routine vivono su fuxi.ai e richiedono un piano Pro, Max, Team, o Enterprise, quindi questo strumento non è accessibile da Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry | No |
| `ReportFindings` | Segnala i risultati della revisione del codice come un elenco strutturato, con un file, un riepilogo e uno scenario di errore per ogni risultato, in modo che Fuxi Code possa renderli invece di stamparli come testo. Fuxi lo chiama quando le istruzioni di revisione del codice attive lo dicono. {/* min-version: 2.1.196 */}Richiede Fuxi Code v2.1.196 o successivo. {/* min-version: 2.1.199 */}A partire da v2.1.199, un risultato può anche portare uno slug `category` opzionale, come `correctness` o `test-coverage`, mostrato accanto alla posizione del file nell'elenco renderizzato | No |
| `ScheduleWakeup` | Riprogramma l'iterazione successiva di un [`/loop` auto-paced](/it/scheduled-tasks#let-fuxi-choose-the-interval). Fuxi lo chiama alla fine di ogni iterazione per scegliere quando viene eseguita la successiva, tra un minuto e un'ora; non lo chiami direttamente. Per terminare il loop invece, Fuxi lo chiama con `stop: true`, che annulla il wakeup in sospeso. {/* min-version: 2.1.202 */}Il campo `stop` richiede Fuxi Code v2.1.202 o successivo. Il wakeup in sospeso appare in `session_crons` in [Stop hook input](/it/hooks#stop-input). {/* plan-availability: feature=loop-dynamic providers=anthropic */}Non disponibile su Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry, dove un prompt `/loop` senza intervallo viene eseguito secondo una pianificazione fissa | No |
| `SendMessage` | Invia un messaggio a un [team di agenti](/it/agent-teams) compagno, o [riprende un subagent](/it/sub-agents#resume-subagents) per il suo ID agente o nome. I subagent interrotti si riprendono automaticamente in background. I messaggi del protocollo team strutturato richiedono team di agenti. Un ricevente non tratta mai un messaggio da un altro agente come il tuo consenso o approvazione. {/* min-version: 2.1.198 */}A partire da v2.1.198, un subagent tratta un messaggio dall'agente che lo ha lanciato come normale direzione di attività piuttosto che come richiesta tra pari. {/* min-version: 2.1.199 */}A partire da v2.1.199, un invio a un nome che ora si risolve in un agente diverso da quello precedente nella conversazione viene rifiutato invece di essere consegnato; vedi [Riprendi subagent](/it/sub-agents#resume-subagents) | No |
| `SendUserFile` | Invia file dalla sessione a te con una didascalia opzionale, in modo che un report generato, un diagramma, uno screenshot, o un artefatto costruito raggiunga il tuo dispositivo invece di essere solo menzionato nella trascrizione. {/* min-version: 2.1.196 */}A partire da v2.1.196, l'input opzionale `display` controlla la presentazione: `render` apre il file inline nel client, `attach` mostra solo una scheda di download, e quando non impostato il client decide in base al tipo di file. Disponibile quando un client [Remote Control](/it/remote-control) è connesso o la sessione viene eseguita in un ambiente cloud gestito come [Fuxi Code sul web](/it/fuxi-code-on-the-web). La consegna viene eseguita attraverso l'infrastruttura ospitata da Anthropic, quindi lo strumento non è disponibile su Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry | No |
| `ShareOnboardingGuide` | {/* plan-availability: feature=onboarding-guide-share plans=pro,max,team,enterprise providers=anthropic */}Carica `ONBOARDING.md` e restituisce un link di condivisione che i compagni di team possono aprire in Fuxi Code. Chiamato da `/team-onboarding` dopo che la guida è stata scritta. Disponibile per gli abbonati di fuxi.ai su piani Pro, Max, Team, ed Enterprise | Sì |
| `Skill` | Esegue una [skill](/it/skills#control-who-invokes-a-skill) all'interno della conversazione principale | Sì |
| `TaskCreate` | Crea una nuova attività nell'elenco delle attività | No |
| `TaskGet` | Recupera i dettagli completi per un'attività specifica | No |
| `TaskList` | Elenca tutte le attività con il loro stato attuale | No |
| `TaskOutput` | Recupera l'output da un'attività in background. Deprecato a favore di `Read` sul percorso del file di output dell'attività. {/* min-version: 2.1.203 */}Quando nessuna attività corrisponde all'ID, l'errore elenca gli agenti background in esecuzione per ID e descrizione. Prima della v2.1.203, l'errore nominava solo l'ID mancante | No |
| `TaskStop` | Termina un'attività in background in esecuzione per ID. {/* min-version: 2.1.198 */}Accetta anche un [compagno di team di agenti](/it/agent-teams) o un agente background denominato per ID agente o nome. Prima della v2.1.198, accettava solo un ID di attività in background. {/* min-version: 2.1.203 */}Quando nessuna attività corrisponde all'ID, l'errore elenca gli agenti background in esecuzione per ID e descrizione, inclusi gli agenti che un altro agente ha generato. Prima della v2.1.203, l'errore elencava i compagni di team in esecuzione e gli agenti denominati ma non gli agenti background generati da un altro agente, quindi non potevano essere identificati o interrotti dalla conversazione principale | No |
| `TaskUpdate` | Aggiorna lo stato dell'attività, le dipendenze, i dettagli, o elimina le attività | No |
| `TodoWrite` | {/* min-version: 2.1.142 */}Gestisce l'elenco di controllo delle attività della sessione. Disabilitato per impostazione predefinita a partire da v2.1.142 a favore di `TaskCreate`, `TaskGet`, `TaskList`, e `TaskUpdate`. Imposta `FUXI_CODE_ENABLE_TASKS=0` per riabilitare | No |
| `ToolSearch` | Cerca e carica strumenti differiti quando [tool search](/it/mcp#scale-with-mcp-tool-search) è abilitato | No |
| `WaitForMcpServers` | Attende uno o più [server MCP](/it/mcp) che sono ancora in fase di connessione in background, in modo che una richiesta possa utilizzare i loro strumenti senza riavviare la sessione. Fuxi lo chiama quando un server necessario non è ancora connesso. Appare solo quando [tool search](/it/mcp#scale-with-mcp-tool-search) è disabilitato, poiché `ToolSearch` gestisce l'attesa quando è abilitato | No |
| `WebFetch` | Recupera il contenuto da un URL specificato. Vedi [comportamento dello strumento WebFetch](#webfetch-tool-behavior) | Sì |
| `WebSearch` | Esegue ricerche web. Vedi [comportamento dello strumento WebSearch](#websearch-tool-behavior) | Sì |
| `Workflow` | Esegue un [flusso di lavoro dinamico](/it/workflows): uno script che orchestra molti subagent in background e restituisce un risultato consolidato | Sì |
| `Write` | Crea o sovrascrivi file. Vedi [comportamento dello strumento Write](#write-tool-behavior) | Sì |
Per la maggior parte, Fuxi decide quando utilizzare questi strumenti e non è necessario nominarli tu stesso quando interagisci con Fuxi. Fai riferimento ai nomi degli strumenti direttamente quando definisci autorizzazioni e altre configurazioni:
* in [`permissions.allow` e `permissions.deny`](/it/settings#available-settings) nelle impostazioni, e nell'interfaccia `/permissions`
* nei flag CLI [`--allowedTools` e `--disallowedTools`](/it/cli-reference)
* nelle opzioni [`allowedTools` e `disallowedTools`](/it/agent-sdk/permissions#allow-and-deny-rules) dell'Agent SDK
* nel frontmatter `tools` o `disallowedTools` di un [subagent](/it/sub-agents#supported-frontmatter-fields)
* nel frontmatter [`allowed-tools`](/it/skills#frontmatter-reference) di una skill
* nella condizione [`if`](/it/hooks-guide#filter-by-tool-name-and-arguments-with-the-if-field) di un hook
Tutti questi accettano lo stesso formato di regola, `ToolName(specifier)`. Lo specifier dipende dallo strumento, e diversi strumenti condividono un formato:
| Formato di regola | Si applica a | Dettagli |
| :----------------------------- | :------------------------ | :-------------------------------------------------------------------------------- |
| `Bash(npm run *)` | Bash, Monitor | [Corrispondenza di pattern di comando](/it/permissions#bash) |
| `PowerShell(Get-ChildItem *)` | PowerShell | [Corrispondenza di pattern di comando](/it/permissions#powershell) |
| `Read(~/secrets/**)` | Read, Grep, Glob, LSP | [Corrispondenza di pattern di percorso](/it/permissions#read-and-edit) |
| `Edit(/src/**)` | Edit, Write, NotebookEdit | [Corrispondenza di pattern di percorso](/it/permissions#read-and-edit) |
| `Skill(deploy *)` | Skill | [Corrispondenza di nome skill](/it/skills#restrict-fuxi%E2%80%99s-skill-access) |
| `Agent(Explore)` | Agent | [Corrispondenza di tipo subagent](/it/permissions#agent-subagents) |
| `WebFetch(domain:example.com)` | WebFetch | [Corrispondenza di dominio](/it/permissions#webfetch) |
| `WebSearch` | WebSearch | Nessuno specifier; consenti o nega lo strumento nel suo insieme |
Gli strumenti non elencati qui, come `ExitPlanMode` o `ShareOnboardingGuide`, accettano solo il nome dello strumento nudo senza specifier.
Una regola di autorizzazione `Edit(...)` concede anche accesso in lettura allo stesso percorso, quindi non hai bisogno di una regola `Read(...)` corrispondente.
I campi `matcher` degli hook utilizzano nomi di strumenti nudi, non il formato tra parentesi. Vedi [matcher patterns](/it/hooks#matcher-patterns) per le regole di corrispondenza. Per i nomi di campo che ogni strumento passa a `tool_input` negli hook, vedi il [riferimento di input PreToolUse](/it/hooks#pretooluse-input).
Lo strumento Agent genera un subagent in una finestra di contesto separata. Il subagent lavora attraverso il suo compito autonomamente, quindi restituisce un singolo risultato di testo alla conversazione principale. Il genitore non vede le chiamate di strumento intermedie o gli output del subagent, solo quel risultato finale.
Per limitare quanti turni un subagent esegue, imposta `maxTurns` nella [definizione del subagent](/it/sub-agents#supported-frontmatter-fields).
Lo stesso strumento Agent avvia anche [subagent biforcati](/it/sub-agents#fork-the-current-conversation) quando la modalità fork è abilitata. Un fork eredita la conversazione principale completa invece di iniziare da zero, viene sempre eseguito in background, e comunque fa emergere i prompt di autorizzazione nel tuo terminale. Il resto di questa sezione descrive i subagent denominati.
Quali strumenti un subagent denominato può utilizzare dipende dai campi `tools` e `disallowedTools` nella [definizione del subagent](/it/sub-agents):
* **Nessun campo impostato**: il subagent eredita ogni strumento disponibile al genitore.
* **Solo `tools`**: il subagent ottiene solo gli strumenti elencati.
* **Solo `disallowedTools`**: il subagent ottiene ogni strumento del genitore tranne quelli elencati.
* **Entrambi impostati**: `disallowedTools` ha la precedenza. Uno strumento elencato in entrambi viene rimosso.
L'avvio del subagent non richiede di per sé l'autorizzazione. Fuxi Code controlla le chiamate di strumento del subagent rispetto alle tue regole di autorizzazione mentre viene eseguito.
{/* min-version: 2.1.198 */}A partire dalla v2.1.198, i subagent vengono eseguiti in background per impostazione predefinita; Fuxi ne esegue uno in primo piano quando ha bisogno del risultato prima di continuare.
* **Subagent in primo piano** mostrano gli stessi prompt di autorizzazione che vedresti nella conversazione principale, nel momento in cui ogni chiamata di strumento accade.
* **Subagent in background** {/* min-version: 2.1.186 */}fanno emergere i prompt di autorizzazione nella tua sessione principale a partire dalla v2.1.186. Il prompt indica quale subagent sta chiedendo, e premere Esc nega quella singola chiamata di strumento senza fermare il subagent. Prima della v2.1.186, i subagent in background negavano automaticamente qualsiasi chiamata di strumento che altrimenti richiederebbe un prompt e continuavano senza quello strumento.
Per limitare cosa un subagent può raggiungere in primo luogo, restringi il suo campo `tools`, lascia Bash fuori dall'elenco, o imposta regole di negazione nelle tue impostazioni, come descritto in [Controlla le capacità del subagent](/it/sub-agents#control-subagent-capabilities). Per ulteriori informazioni sulla scelta tra primo piano e background, vedi [Esegui subagent in primo piano o background](/it/sub-agents#run-subagents-in-foreground-or-background).
Lo strumento Bash esegue ogni comando in un processo separato con il seguente comportamento di persistenza:
* Quando Fuxi esegue `cd` nella sessione principale, la nuova directory di lavoro viene mantenuta nei comandi Bash successivi finché rimane all'interno della directory del progetto o di una [directory di lavoro aggiuntiva](/it/permissions#working-directories) che hai aggiunto con `--add-dir`, `/add-dir`, o `additionalDirectories` nelle impostazioni. Le sessioni subagent non mantengono mai i cambiamenti della directory di lavoro.
* Se `cd` finisce al di fuori di quelle directory, Fuxi Code ripristina la directory del progetto e aggiunge `Shell cwd was reset to ` al risultato dello strumento.
* Per disabilitare questo mantenimento in modo che ogni comando Bash inizi nella directory del progetto, imposta `FUXI_BASH_MAINTAIN_PROJECT_WORKING_DIR=1`.
* Le variabili di ambiente non persistono. Un `export` in un comando non sarà disponibile nel successivo.
* Gli alias e le funzioni shell definiti nel tuo file di avvio della shell sono disponibili. All'inizio della sessione, Fuxi Code esegue `~/.zshrc`, `~/.bashrc`, o `~/.profile` a seconda della tua shell, acquisisce gli alias, le funzioni e le opzioni della shell risultanti, e le applica a ogni comando Bash.
Attiva il tuo virtualenv o ambiente conda prima di avviare Fuxi Code. Per fare in modo che le variabili di ambiente persistano tra i comandi Bash, imposta [`FUXI_ENV_FILE`](/it/env-vars) su uno script shell prima di avviare Fuxi Code, oppure utilizza un [hook SessionStart](/it/hooks#persist-environment-variables) per popolarlo dinamicamente.
Due limiti vincolano ogni comando:
* **Timeout**: due minuti per impostazione predefinita. Fuxi può richiedere fino a 10 minuti per comando con il parametro `timeout`. Sostituisci il valore predefinito e il limite massimo con [`BASH_DEFAULT_TIMEOUT_MS` e `BASH_MAX_TIMEOUT_MS`](/it/env-vars).
* **Lunghezza dell'output**: 30.000 caratteri per impostazione predefinita. Quando un comando produce più di quello, Fuxi Code salva l'output completo in un file nella directory della sessione e fornisce a Fuxi il percorso del file più un'anteprima breve dall'inizio. Fuxi legge o cerca quel file quando ha bisogno del resto. Aumenta il limite con [`BASH_MAX_OUTPUT_LENGTH`](/it/env-vars), fino a un limite massimo fisso di 150.000 caratteri.
Per processi di lunga durata come server di sviluppo o build di watch, Fuxi può impostare `run_in_background: true` per avviare il comando come attività in background e continuare a lavorare mentre viene eseguito. Elenca e interrompi le attività in background con `/tasks`.
Lo strumento Edit esegue la sostituzione di stringhe esatte. Prende un `old_string` e un `new_string` e sostituisce il primo con il secondo. Non utilizza regex o corrispondenza fuzzy.
Tre controlli devono passare affinché un'edit si applichi:
* **Lettura prima dell'edit**: Fuxi deve aver letto il file nella conversazione corrente, e il file non deve essere cambiato su disco da quella lettura. Questo controllo viene eseguito per primo, prima di qualsiasi corrispondenza di stringhe.
* **Corrispondenza**: `old_string` deve apparire nel file esattamente come scritto. Una singola differenza di carattere di spazio o indentazione è sufficiente per mancare.
* **Unicità**: `old_string` deve apparire esattamente una volta. Quando appare più di una volta, Fuxi fornisce una stringa più lunga con abbastanza contesto circostante per individuare un'occorrenza, o imposta `replace_all: true` per sostituirle tutte.
Visualizzare un file con Bash soddisfa anche il requisito di lettura prima dell'edit quando il comando è `cat`, `head`, `tail`, `sed -n 'X,Yp'`, `grep`, `egrep`, o `fgrep` su un singolo file senza pipe o reindirizzamenti. L'output con pipe e altri comandi Bash non contano, e Fuxi deve utilizzare Read prima di modificare in quei casi.
Questo influisce solo sull'idoneità dell'edit, non sulle autorizzazioni. Le [regole di negazione Read e Edit](/it/permissions#tool-specific-permission-rules) si applicano anche ai comandi di file che Fuxi Code riconosce in Bash, come `cat`, `head`, `tail`, `sed`, e `grep`, ma non ai sottoprocessi arbitrari che leggono o scrivono file indirettamente, come uno script Python o Node che apre file da solo. L'insieme di comandi riconosciuti per le regole di negazione non è lo stesso dell'elenco di lettura prima dell'edit sopra: ad esempio, `egrep` e `fgrep` contano per la lettura prima dell'edit ma non vengono controllati rispetto alle regole di negazione Read. Per l'applicazione a livello di sistema operativo che copre ogni processo, [abilita la sandbox](/it/sandboxing).
Lo strumento Glob trova file per pattern di nome. Supporta la sintassi glob standard incluso `**` per la corrispondenza ricorsiva di directory:
* `**/*.js` corrisponde a tutti i file `.js` a qualsiasi profondità
* `src/**/*.ts` corrisponde a tutti i file `.ts` sotto `src/`
* `*.{json,yaml}` corrisponde ai file `.json` e `.yaml` nella directory corrente
I risultati sono ordinati per tempo di modifica e limitati a 100 file. Se il limite viene raggiunto, Fuxi vede un flag di troncamento nel risultato e può restringere il pattern.
Glob non rispetta `.gitignore` per impostazione predefinita, quindi trova file gitignored insieme a quelli tracciati. Questo differisce da [Grep](#grep-tool-behavior), che salta i file gitignored. Per fare in modo che Glob rispetti `.gitignore`, imposta `FUXI_CODE_GLOB_NO_IGNORE=false` prima di avviare Fuxi Code.
Lo strumento Grep cerca pattern nei contenuti dei file. Dove [Glob](#glob-tool-behavior) trova file per nome, Grep trova righe dentro di loro.
Grep è costruito su [ripgrep](https://github.com/BurntSushi/ripgrep) e utilizza la sintassi regex di ripgrep, non grep POSIX. I pattern che includono metacaratteri regex hanno bisogno di escape. Ad esempio, trovare `interface{}` nel codice Go richiede il pattern `interface\{\}`.
Tre modalità di output controllano cosa viene restituito:
* `files_with_matches`: solo percorsi di file, nessun contenuto di riga. Questo è il valore predefinito.
* `content`: righe corrispondenti con file e numero di riga.
* `count`: conteggio delle corrispondenze per file.
Fuxi può limitare i risultati per file con il parametro `glob`, come `**/*.tsx`, o per linguaggio con il parametro `type`, come `py` o `rust`. Per impostazione predefinita, i pattern corrispondono all'interno di una singola riga. Fuxi può impostare `multiline: true` per corrispondere attraverso i confini di riga.
Grep rispetta `.gitignore`, quindi i file gitignored vengono saltati. Per cercare un file gitignored, Fuxi passa il suo percorso direttamente.
Lo strumento LSP fornisce a Fuxi intelligenza del codice da un language server in esecuzione. Dopo ogni modifica di file, segnala automaticamente errori di tipo e avvisi in modo che Fuxi possa correggere i problemi senza un passaggio di compilazione separato. Fuxi può anche chiamarlo direttamente per navigare il codice:
* Salta alla definizione di un simbolo
* Trova tutti i riferimenti a un simbolo
* Ottieni informazioni sul tipo in una posizione
* Elenca i simboli in un file
* Cerca un simbolo per nome in tutto il workspace
* Trova implementazioni di un'interfaccia
* Traccia gerarchie di chiamate
Lo strumento è inattivo finché non installi un [plugin di intelligenza del codice](/it/discover-plugins#code-intelligence) per il tuo linguaggio. Il plugin raggruppa la configurazione del language server, e installi il binario del server separatamente.
Lo strumento Monitor consente a Fuxi di osservare qualcosa in background e reagire quando cambia, senza mettere in pausa la conversazione. Chiedi a Fuxi di:
* Monitorare un file di log e segnalare gli errori man mano che appaiono
* Eseguire il polling di una PR o di un lavoro CI e segnalare quando il suo stato cambia
* Osservare una directory per i cambiamenti di file
* Tracciare l'output da qualsiasi script di lunga durata che gli indichi
* Connettersi a un feed WebSocket e segnalare ogni messaggio man mano che arriva
Per la maggior parte dei monitoraggi, Fuxi scrive un piccolo script, lo esegue in background e riceve ogni riga di output man mano che arriva. Per un server che già invia eventi, Fuxi può aprire una [fonte WebSocket](#websocket-source) invece di eseguire uno script.
Continui a lavorare nella stessa sessione e Fuxi interviene quando un evento si verifica. Interrompi un monitor chiedendo a Fuxi di annullarlo o terminando la sessione.
Quando Monitor esegue un comando, utilizza le stesse [regole di autorizzazione di Bash](/it/permissions#tool-specific-permission-rules), quindi i pattern `allow` e `deny` che hai impostato per Bash si applicano anche qui. La [fonte WebSocket](#websocket-source) ha il suo proprio prompt di approvazione.
Lo strumento non è disponibile su Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry. Non è disponibile nemmeno quando `DISABLE_TELEMETRY` o `FUXI_CODE_DISABLE_NONESSENTIAL_TRAFFIC` è impostato.
I plugin possono dichiarare monitor che si avviano automaticamente quando il plugin è attivo, invece di chiedere a Fuxi di avviarli. Vedi [plugin monitors](/it/plugins-reference#monitors).
Fonte WebSocket
La fonte WebSocket richiede Fuxi Code v2.1.195 o successivo.
Quando un server già invia eventi su un WebSocket, Fuxi può connettersi direttamente ad esso invece di scrivere uno script di polling. Ogni tipo di attività del socket diventa un evento o termina il monitoraggio:
* **Messaggi di testo**: ognuno diventa un evento, anche quando il messaggio si estende su più righe.
* **Messaggi binari**: non vengono passati. Fuxi riceve una riga segnaposto come `[binary frame, 512 bytes]` invece.
* **Messaggi più grandi di 1 MiB**: il monitoraggio termina, quindi sottoscrivi un feed filtrato dove esiste.
* **Chiusura del socket**: il monitoraggio termina e Fuxi riceve il codice di chiusura.
Un monitoraggio WebSocket accetta un input `ws` al posto di `command`, e una singola chiamata Monitor non può combinare i due. L'input `ws` ha due campi:
| Campo | Obbligatorio | Descrizione |
| :---------- | :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url` | Sì | L'endpoint a cui connettersi. Deve essere un URL `ws://` o `wss://` senza credenziali incorporate o spazi, utilizzando solo caratteri ASCII |
| `protocols` | No | Nomi di sottoprotocollo WebSocket da offrire durante l'handshake. Ogni voce deve essere un token di sottoprotocollo valido e l'elenco non può contenere duplicati |
Gli input `timeout_ms` e `persistent` si comportano allo stesso modo di come si comportano per un comando: il monitoraggio termina alla scadenza a meno che `persistent` non sia impostato, e `TaskStop` lo annulla anticipatamente.
L'apertura di un WebSocket richiede l'approvazione e il prompt non offre un'opzione per saltare i prompt futuri per lo stesso host.
Fuxi Code nega gli URL che puntano a un indirizzo privato, link-local o cloud-metadata, inclusi i nomi host che si risolvono in uno. Nega anche gli host in `sandbox.network.deniedDomains` e quando [`allowManagedDomainsOnly`](/it/settings#sandbox-settings) è impostato nelle impostazioni gestite, qualsiasi host al di fuori dell'elenco di autorizzazione gestito.
NotebookEdit modifica un notebook Jupyter una cella alla volta, puntando alle celle per il loro `cell_id`. Non esegue la sostituzione di stringhe attraverso il notebook come fa [Edit](#edit-tool-behavior) sui file semplici.
Tre modalità di edit controllano cosa accade alla cella target:
* `replace`: sovrascrivi la sorgente della cella. Questo è il valore predefinito.
* `insert`: aggiungi una nuova cella dopo la target. Senza `cell_id`, la nuova cella va all'inizio del notebook. Richiede `cell_type` impostato a `code` o `markdown`.
* `delete`: rimuovi la cella target.
Le regole di autorizzazione utilizzano il formato di percorso `Edit(...)`. Una regola come `Edit(notebooks/**)` copre le chiamate NotebookEdit su file in quella directory.
Lo strumento PowerShell consente a Fuxi di eseguire comandi PowerShell nativamente. Su Windows, questo significa che i comandi vengono eseguiti in PowerShell invece di essere instradati attraverso Git Bash. La disponibilità dello strumento dipende dalla tua piattaforma:
* **Windows senza Git Bash**: lo strumento è abilitato automaticamente.
* **Windows con Git Bash installato**: lo strumento è in rollout progressivo.
* **Linux, macOS e WSL**: lo strumento è opt-in.
Imposta `FUXI_CODE_USE_POWERSHELL_TOOL=1` nel tuo ambiente o in `settings.json`:
```json theme={null}
{
"env": {
"FUXI_CODE_USE_POWERSHELL_TOOL": "1"
}
}
```
Su Windows, imposta la variabile a `0` per rinunciare al rollout. Su Linux, macOS e WSL, lo strumento richiede PowerShell 7 o successivo: installa `pwsh` e assicurati che sia nel tuo `PATH`.
Su Windows, Fuxi Code rileva automaticamente `pwsh.exe` per PowerShell 7+ con un fallback a `powershell.exe` per PowerShell 5.1. Quando lo strumento è abilitato, Fuxi tratta PowerShell come la shell primaria. Lo strumento Bash rimane disponibile per gli script POSIX quando Git Bash è installato.
Fuxi Code avvia PowerShell con `-ExecutionPolicy Bypass` solo a livello di processo, quindi gli script `.ps1` e le importazioni di moduli funzionano sulle installazioni Windows predefinite senza modificare la policy della macchina. Il bypass a livello di processo non sostituisce la Group Policy `MachinePolicy` o `UserPolicy`, quindi i blocchi aziendali rimangono in vigore. Per rispettare la policy di esecuzione effettiva della macchina, imposta `FUXI_CODE_POWERSHELL_RESPECT_EXECUTION_POLICY=1`.
Selezione della shell nelle impostazioni, negli hook e nelle skill
Tre impostazioni aggiuntive controllano dove viene utilizzato PowerShell:
* `"defaultShell": "powershell"` in [`settings.json`](/it/settings#available-settings): instrada i comandi interattivi `!` attraverso PowerShell. Richiede che lo strumento PowerShell sia abilitato.
* `"shell": "powershell"` su singoli [hook di comando](/it/hooks#command-hook-fields): esegue quell'hook in PowerShell. Gli hook avviano PowerShell direttamente, quindi funziona indipendentemente da `FUXI_CODE_USE_POWERSHELL_TOOL`.
* `shell: powershell` nel [frontmatter della skill](/it/skills#frontmatter-reference): esegue i blocchi `` !`command` `` in PowerShell. Richiede che lo strumento PowerShell sia abilitato.
Lo stesso comportamento di ripristino della directory di lavoro della sessione principale descritto nella sezione dello strumento Bash si applica ai comandi PowerShell, inclusa la variabile di ambiente `FUXI_BASH_MAINTAIN_PROJECT_WORKING_DIR`.
{/* min-version: 2.1.196 */}A partire dalla v2.1.196, lo strumento PowerShell corrisponde alla gestione dei codici di uscita di ricerca e diff dello strumento Bash. Il codice di uscita 1 da `grep`, `egrep`, `fgrep` e `git grep` significa nessuna corrispondenza, e il codice di uscita 1 da `git diff` significa che esistono differenze, quindi questi risultati non vengono segnalati a Fuxi come errori di comando.
Limitazioni dell'anteprima
Lo strumento PowerShell ha le seguenti limitazioni note durante l'anteprima:
* I profili PowerShell non vengono caricati
* Su Windows, il sandboxing non è supportato
Lo strumento Read prende un percorso di file e restituisce i contenuti con numeri di riga. Fuxi è istruito a passare sempre percorsi assoluti.
Per impostazione predefinita, Read restituisce il file dall'inizio. Quando una lettura dell'intero file supera il limite di token, Read restituisce la prima pagina con un avviso `PARTIAL view` che dice a Fuxi quanto del file ha ricevuto e come leggere di più con `offset` e `limit`. Una lettura che passa un `offset` o `limit` esplicito e supera ancora il limite di token restituisce un errore.
Read gestisce diversi tipi di file oltre al testo semplice:
* **Immagini**: PNG, JPG e altri formati di immagine vengono restituiti come contenuto visivo che Fuxi può vedere, non come byte grezzi. Fuxi Code ridimensiona e ricomprime le immagini grandi per adattarsi ai limiti di dimensione dell'immagine del modello prima di inviarle, quindi Fuxi potrebbe vedere una versione ridotta di uno screenshot grande. {/* min-version: 2.1.196 */}A partire dalla v2.1.196, un'immagine che è ancora più grande di 500KB dopo quel ridimensionamento viene ricodificata come JPEG a qualità ridotta con le sue dimensioni in pixel invariate. Se Fuxi perde dettagli a livello di pixel fine in un'immagine grande, chiedigli di ritagliare prima la regione di interesse, ad esempio con ImageMagick tramite Bash.
* **PDF**: Fuxi legge file `.pdf` brevi nel loro insieme. Per i PDF più lunghi di 10 pagine, legge in intervalli con un parametro `pages`, come `"1-5"`, fino a 20 pagine alla volta.
* **Notebook Jupyter**: i file `.ipynb` restituiscono tutte le celle con i loro output, inclusi codice, markdown e visualizzazioni.
Read legge solo file, non directory. Fuxi utilizza `ls` tramite lo strumento Bash per elencare i contenuti della directory.
WebFetch prende un URL e un prompt che descrive cosa estrarre. Recupera la pagina, converte la risposta in Markdown quando il server restituisce HTML, ed esegue il prompt contro il contenuto utilizzando un modello piccolo e veloce. Per la maggior parte dei recuperi, Fuxi riceve la risposta di quel modello, non la pagina grezza. Il passaggio di conversione non è configurabile.
Questo rende WebFetch lossy per progettazione. Il prompt di estrazione determina cosa raggiunge Fuxi, quindi un risultato che dice che una pagina non menziona qualcosa potrebbe significare solo che il prompt non l'ha chiesto. Chiedi a Fuxi di recuperare di nuovo con un prompt più specifico, o utilizza `curl` tramite Bash per la pagina non elaborata.
Alcuni comportamenti modellano la risposta che Fuxi riceve:
* Gli URL HTTP vengono automaticamente aggiornati a HTTPS.
* Le pagine grandi vengono troncate a un limite di caratteri fisso prima dell'elaborazione.
* Le risposte vengono memorizzate nella cache per 15 minuti, quindi i recuperi ripetuti dello stesso URL vengono restituiti rapidamente.
* Quando un URL reindirizza a un host diverso, WebFetch restituisce un risultato di testo che nomina l'URL originale e il target di reindirizzamento invece di seguirlo. Fuxi quindi recupera il nuovo URL con una seconda chiamata WebFetch.
Nelle modalità di autorizzazione predefinita e `acceptEdits`, WebFetch richiede la prima volta che raggiunge un nuovo dominio, ad eccezione di un insieme integrato di domini di documentazione preapprovati che vengono recuperati senza un prompt. Per consentire un altro dominio in anticipo senza un prompt, aggiungi una regola di autorizzazione come `WebFetch(domain:example.com)`. Le modalità di autorizzazione `auto` e `bypassPermissions` [permission modes](/it/permissions#permission-modes) saltano completamente il prompt.
Una regola esplicita `WebFetch(domain:...)` in `deny`, `ask`, o `allow` ha la precedenza rispetto all'insieme preapprovato, quindi puoi bloccare un dominio preapprovato o richiedere un prompt per esso.
WebFetch imposta un'intestazione `User-Agent` che inizia con `Fuxi-User`, e un'intestazione `Accept` che preferisce Markdown a HTML in modo che i server che supportano la negoziazione dei contenuti possano restituire Markdown direttamente.
Configuri le regole di rete [sandbox](/it/sandboxing) separatamente, quindi un dominio che vuoi che un processo in sandbox raggiunga ha ancora bisogno di una regola di autorizzazione sandbox esplicita.
WebSearch esegue una query rispetto al backend di [web search](https://platform.fuxi.com/docs/en/agents-and-tools/tool-use/web-search-tool) di Anthropic e restituisce titoli e URL dei risultati. Non recupera le pagine dei risultati. Per leggere una pagina che Fuxi trova nei risultati di ricerca, segue con [WebFetch](#webfetch-tool-behavior).
Lo strumento può emettere fino a otto ricerche backend per chiamata, affinando la ricerca internamente prima di restituire i risultati. Fuxi può limitare i risultati con `allowed_domains` per includere solo determinati host, o `blocked_domains` per escluderli. I due elenchi non possono essere combinati in una singola chiamata.
Il backend di ricerca non è configurabile. Per cercare con un provider diverso, aggiungi un [server MCP](/it/mcp) che espone uno strumento di ricerca.
Le regole di autorizzazione WebSearch non accettano specifier. Una voce `WebSearch` nuda in `allow` o `deny` è l'unica forma.
WebSearch è disponibile sull'API Fuxi, [Fuxi Platform on AWS](/it/fuxi-platform-on-aws), e Microsoft Foundry. Su Google Cloud's Agent Platform funziona con i modelli Fuxi 4 e versioni successive, inclusi Opus, Sonnet, e Haiku. Amazon Bedrock non espone lo strumento di web search lato server.
Lo strumento Write crea un nuovo file o sovrascrivi uno esistente con il contenuto completo fornito. Non aggiunge o unisce.
Se il percorso target esiste già, Fuxi deve aver letto quel file almeno una volta nella conversazione corrente prima di sovrascriverlo. Una Write a un file esistente non letto fallisce con un errore. Questo vincolo non si applica ai nuovi file.
Visualizzare il file con Bash soddisfa anche questo requisito secondo le stesse regole descritte in [comportamento dello strumento Edit](#edit-tool-behavior).
Per modifiche parziali a un file esistente, Fuxi utilizza Edit invece di Write.
Il tuo set esatto di strumenti dipende dal tuo provider, dalla piattaforma e dalle impostazioni. Per verificare cosa è caricato in una sessione in esecuzione, chiedi direttamente a Fuxi:
```text theme={null}
What tools do you have access to?
```
Fuxi fornisce un riepilogo conversazionale. Per i nomi esatti degli strumenti MCP, esegui `/mcp`.
Lo [strumento advisor](/it/advisor) è uno [strumento server](https://platform.fuxi.com/docs/en/agents-and-tools/tool-use/advisor-tool) che l'API esegue, piuttosto che uno strumento che Fuxi Code implementa. Non ha un nome che puoi referenziare nelle regole di autorizzazione o nei matcher degli hook.
Vedi anche
* [Server MCP](/it/mcp): aggiungi strumenti personalizzati connettendo server esterni
* [Autorizzazioni](/it/permissions): sistema di autorizzazione, sintassi delle regole, e pattern specifici dello strumento
* [Subagent](/it/sub-agents): configura l'accesso agli strumenti per i subagent
* [Hooks](/it/hooks-guide): esegui comandi personalizzati prima o dopo l'esecuzione dello strumento