# Riferimento del sistema di strumenti (/it/docs/verdent-for-vscode/advanced-features/tool-reference)
> Riferimento completo del sistema di strumenti di Verdent
### Cosa imparerai [#cosa-imparerai]
Riferimento completo del sistema di strumenti integrato di Verdent, comprese le operazioni sui file, le funzionalità di ricerca, l'esecuzione di comandi e gli strumenti di integrazione.
***
## Panoramica degli strumenti disponibili [#panoramica-degli-strumenti-disponibili]
Verdent for VS Code offre un set completo di strumenti per la manipolazione del codice, la navigazione e l'interazione esterna.
| Strumento | Scopo | Funzionalità principali |
| ------------ | ----------------------------- | ------------------------------------------------------------------------------------------------- |
| `file_read` | Leggere il contenuto dei file | Supporta intervalli di righe per file di grandi dimensioni, funziona con tutti i formati di testo |
| `file_edit` | Modifiche mirate | Sostituisce corrispondenze esatte di testo, sostituzioni multiple, preserva la formattazione |
| `file_write` | Creare o sovrascrivere file | Creazione/sostituzione completa dei file, gestisce contenuti testuali |
| Strumento | Scopo | Funzionalità principali |
| -------------- | ---------------------------------- | -------------------------------------------------------------------------- |
| `glob` | Ricerca di file basata su pattern | Pattern glob (`**/*.ts`), pattern di esclusione, limitazione dei risultati |
| `grep_content` | Ricerca di contenuti con contesto | Supporto per regex, righe di contesto, opzioni case-insensitive |
| `grep_file` | Elencare i file con corrispondenze | Identifica rapidamente i file prima di leggerne il contenuto |
| `list_dir` | Struttura delle directory | Mostra la gerarchia, pattern di esclusione, controllo della profondità |
| Strumento | Scopo | Funzionalità principali |
| ---------------- | ---------------------------------------------- | ------------------------------------------------------------------------------ |
| `bash` | Esecuzione di comandi shell | Configurazione del timeout, descrizioni riassuntive, concatenazione di comandi |
| `spawn_subagent` | Delegare a specialisti | Avvia sottoagenti general, explorer, verifier o code-reviewer |
| `todo_update` | Tenere traccia dell'avanzamento delle attività | Gestisce elenchi di attività, aggiorna lo stato, monitora l'avanzamento |
| Strumento | Scopo | Funzionalità principali |
| ------------ | ------------------------------ | ---------------------------------------------------------------------------- |
| `web_search` | Ricerca su Internet | Esecuzione di query, controllo del numero di risultati, filtro per attualità |
| `web_fetch` | Recuperare e analizzare pagine | Recupera contenuti, estrae informazioni con query |
***
## Funzionalità degli strumenti e casi d'uso [#funzionalità-degli-strumenti-e-casi-duso]
### file\_read [#file_read]
**Funzionalità:**
* Legge il contenuto completo dei file o intervalli di righe specifici
* Essenziale per comprendere il codice prima delle modifiche
* Gestione efficiente di file di grandi dimensioni tramite specifica degli intervalli
**Casi d'uso:**
* Leggere file di configurazione prima di modificarli
* Comprendere i pattern di implementazione esistenti
* Esaminare i file di test per capire la copertura
**Esempio:**
```bash
# Read entire file
file_read("src/components/Button.tsx")
# Read specific range for large files
file_read("package-lock.json", start_line=1, max_lines=50)
```
***
### file\_edit [#file_edit]
**Funzionalità:**
* Sostituzione precisa del testo tramite corrispondenza esatta delle stringhe
* Operazioni di sostituzione multiple con il flag `multiple`
* Preserva la struttura e la formattazione dei file
**Casi d'uso:**
* Aggiornare le implementazioni delle funzioni
* Modificare i valori di configurazione
* Rinominare le variabili tramite refactoring nei file
**Buona pratica:** usalo per modifiche mirate. Per riscritture complete, usa invece `file_write`.
***
### file\_write [#file_write]
**Funzionalità:**
* Crea nuovi file da zero
* Sostituisce completamente il contenuto dei file esistenti
* Gestisce qualsiasi formato basato su testo
**Casi d'uso:**
* Generare nuovi componenti o moduli
* Creare file di configurazione
* Scrivere file di test
**Attenzione:** sovrascrive completamente i file esistenti. Usa `file_edit` per modifiche parziali.
### glob [#glob]
**Funzionalità:**
* Trova file che corrispondono a pattern: `**/*.ts`, `src/**/*.js`
* Filtra per percorso di directory
* Esclude pattern per restringere i risultati
* Controlla il numero di risultati
**Casi d'uso:**
* Trovare tutti i componenti di un progetto
* Individuare i file di test
* Identificare i file di configurazione tra le directory
**Esempi di pattern:**
```bash
**/*.tsx # All TypeScript React files
src/**/*.test.js # All test files in src
**/config.* # All config files anywhere
```
***
### grep\_content [#grep_content]
**Funzionalità:**
* Cerca il contenuto dei file usando pattern regex
* Mostra righe di contesto prima/dopo le corrispondenze (flag `-B`, `-A`)
* Ricerca case-insensitive
* Filtra per tipo di file usando pattern glob
**Casi d'uso:**
* Trovare definizioni di funzioni
* Individuare implementazioni di endpoint API
* Cercare messaggi di errore specifici
* Identificare pattern di sicurezza
**Esempio:**
```bash
# Find authentication-related code
grep_content("auth.*login", glob="**/*.ts")
# Search with context
grep_content("TODO", glob="src/**", context_before=2, context_after=2)
```
***
### grep\_file [#grep_file]
**Funzionalità:**
* Elenca i file contenenti corrispondenze di pattern
* Più veloce di `grep_content` quando ti servono solo le posizioni dei file
* Supporto per pattern regex
* Filtro glob per tipi di file
**Casi d'uso:**
* Identificare quali file necessitano di refactoring
* Trovare i file che importano moduli specifici
* Individuare i file con pattern deprecati
**Buona pratica:** usa prima `grep_file` per identificare i file rilevanti, poi `file_read` per un esame dettagliato.
***
### list\_dir [#list_dir]
**Funzionalità:**
* Mostra la gerarchia delle directory
* Controlla la profondità con il parametro `max_depth`
* Esclude pattern per filtrare l'output
**Casi d'uso:**
* Comprendere la struttura del progetto
* Verificare l'organizzazione delle directory
* Trovare sottodirectory specifiche
### bash [#bash]
**Funzionalità:**
* Esegue comandi shell
* Timeout massimo: 120 secondi (2 minuti, limite fisso)
* Concatena comandi con `&&` per le dipendenze
* Fornisce riepiloghi descrittivi per maggiore chiarezza
**Casi d'uso:**
* Eseguire test
* Compilare progetti
* Installare dipendenze
* Operazioni Git
* Migrazioni di database
**Esempio:**
```bash
# Run tests
bash("npm test", timeout=60000, summary="Run Jest test suite")
# Chain dependent commands
bash("npm install && npm run build", timeout=120000)
```
**Sicurezza:** i comandi vengono eseguiti con i permessi dell'utente. Rivedi i comandi in Manual Accept Mode.
***
### spawn\_subagent [#spawn_subagent]
**Funzionalità:**
* Avvia sottoagenti specializzati con contesti isolati
* Tipi: `explorer`, `verifier`, `code-reviewer`
* Delega attività complesse senza inquinare il contesto principale
* Esecuzione parallela di sottoagenti per maggiore efficienza
**Casi d'uso:**
* **explorer:** cercare pattern in codebase di grandi dimensioni
* **verifier:** validare la logica di implementazione
* **code-reviewer:** valutazione di sicurezza e qualità
**Buona pratica:** delega la ricerca esplorativa al sottoagente Explorer per preservare il contesto della conversazione principale.
***
### todo\_update [#todo_update]
**Funzionalità:**
* Crea e gestisce elenchi di attività
* Aggiorna lo stato delle attività (pending, in\_progress, completed)
* Tiene traccia dell'avanzamento in implementazioni complesse
**Casi d'uso:**
* Suddividere funzionalità in più passaggi
* Monitorare l'avanzamento del refactoring
* Gestire le attività di migrazione
### web\_search [#web_search]
**Funzionalità:**
* Interroga i motori di ricerca su Internet
* Controlla il numero di risultati
* Filtra per attualità (giorni recenti)
**Casi d'uso:**
* Trovare documentazione per API sconosciute
* Ricercare messaggi di errore
* Verificare le migliori pratiche attuali
***
### web\_fetch [#web_fetch]
**Funzionalità:**
* Recupera il contenuto delle pagine web
* Analizza il contenuto con query specifiche
* Estrae informazioni strutturate
**Casi d'uso:**
* Leggere pagine di documentazione
* Analizzare la documentazione API
* Estrarre esempi dai tutorial
***
## Supporto ai formati di file [#supporto-ai-formati-di-file]
Verdent funziona con tutti i formati di file basati su testo tramite i suoi strumenti per le operazioni sui file.
| Categoria | Linguaggi/Estensioni |
| -------------- | --------------------------------------------------- |
| **Web** | JavaScript, TypeScript, HTML, CSS, SCSS, LESS |
| **Backend** | Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Perl |
| **Mobile** | Swift, Kotlin, Dart (Flutter), Objective-C |
| **Funzionale** | Haskell, Scala, Elixir, Clojure, F# |
| **Scripting** | Bash, PowerShell, Zsh, Fish |
| **Dati** | SQL, R, Julia, MATLAB |
| Formato | Esempi comuni |
| -------- | ------------------------------------------------------------- |
| **JSON** | package.json, tsconfig.json, settings.json |
| **YAML** | docker-compose.yml, GitHub Actions, configurazioni Kubernetes |
| **TOML** | Cargo.toml, pyproject.toml |
| **XML** | pom.xml, web.xml, file di configurazione |
| **INI** | .gitconfig, .editorconfig |
| **ENV** | file .env, configurazione dell'ambiente |
| **HCL** | Configurazione Terraform |
| Formato | Casi d'uso |
| -------------------- | ------------------------------------------ |
| **Markdown** | README.md, file di documentazione |
| **HTML** | Template, pagine web |
| **LaTeX** | Documenti scientifici, articoli accademici |
| **reStructuredText** | Documentazione Python |
| **AsciiDoc** | Documentazione tecnica |
### Formati di dati [#formati-di-dati]
| Formato | Descrizione |
| ------------------------ | -------------------------------- |
| **CSV/TSV** | File di dati tabulari |
| **Dati basati su testo** | File di log, dump di dati |
| **JSON/YAML** | Interscambio di dati strutturati |
### File di build e di pacchetto [#file-di-build-e-di-pacchetto]
| File | Scopo |
| -------------------- | ----------------------- |
| **Makefile** | Automazione della build |
| **package.json** | Dipendenze Node.js |
| **requirements.txt** | Pacchetti Python |
| **Gemfile** | Gem Ruby |
| **Cargo.toml** | Pacchetti Rust |
| **build.gradle** | Build Gradle |
| Tipo di formato | Esempi | Modificabilità |
| -------------------- | --------------------------- | ----------------------------- |
| **Immagini** | PNG, JPG, GIF, SVG (binari) | Non modificabili direttamente |
| **Video** | MP4, AVI, MOV | Non modificabili direttamente |
| **Binari compilati** | EXE, DLL, SO | Non modificabili direttamente |
| **Archivi** | ZIP, TAR, GZ | Non modificabili direttamente |
| **Documenti Office** | DOCX, XLSX, PPTX | Non modificabili direttamente |
| **PDF** | File PDF | Non modificabili direttamente |
I file binari possono essere referenziati nel codice ma non possono essere modificati tramite gli strumenti per i file.
***
## Supporto ai linguaggi di programmazione [#supporto-ai-linguaggi-di-programmazione]
Verdent offre un supporto completo per tutti i linguaggi di programmazione e i framework basati su testo.
| Linguaggio/Framework | Livello di supporto | Casi d'uso comuni |
| -------------------- | ------------------- | --------------------------------------------------- |
| JavaScript | Eccellente | Logica frontend, backend Node.js, tooling |
| TypeScript | Eccellente | App web type-safe, progetti su larga scala |
| React | Eccellente | UI basate su componenti, hook, gestione dello stato |
| Vue | Eccellente | Progressive web app, componenti single-file |
| Angular | Eccellente | Applicazioni enterprise, integrazione TypeScript |
| Svelte | Molto buono | Componenti compilati, programmazione reattiva |
| HTML/CSS | Eccellente | Markup, styling, design responsive |
| SCSS/LESS | Eccellente | Styling avanzato, variabili, mixin |
| Linguaggio/Framework | Livello di supporto | Casi d'uso comuni |
| -------------------- | ------------------- | ------------------------------------------------------------ |
| Python | Eccellente | API, elaborazione dati, automazione |
| Django/Flask/FastAPI | Eccellente | Framework web, API REST |
| Node.js/Express | Eccellente | Backend JavaScript, microservizi |
| Java/Spring | Eccellente | Applicazioni enterprise, Spring Boot |
| Go | Eccellente | Servizi ad alte prestazioni, CLI |
| Rust | Molto buono | Programmazione di sistema, codice critico per le prestazioni |
| C/C++ | Molto buono | Sistemi, embedded, motori di gioco |
| C# / .NET | Eccellente | App Windows, servizi web, Unity |
| Ruby/Rails | Molto buono | Applicazioni web, sviluppo rapido |
| PHP | Buono | WordPress, Laravel, app legacy |
| Linguaggio/Framework | Livello di supporto | Casi d'uso comuni |
| -------------------- | ------------------- | ------------------------------- |
| Swift | Eccellente | App native iOS/macOS |
| Kotlin | Eccellente | App native Android |
| Dart/Flutter | Eccellente | App mobili multipiattaforma |
| React Native | Eccellente | App mobili basate su JavaScript |
| Objective-C | Buono | App legacy iOS/macOS |
| Linguaggio | Livello di supporto | Casi d'uso comuni |
| ---------- | ------------------- | -------------------------------------------- |
| Python | Eccellente | NumPy, Pandas, scikit-learn, TensorFlow |
| R | Molto buono | Analisi statistica, visualizzazione dei dati |
| SQL | Eccellente | Query di database, progettazione di schemi |
| Julia | Buono | Calcolo scientifico, analisi numerica |
| Linguaggio | Livello di supporto | Casi d'uso comuni |
| ---------- | ------------------- | ------------------------------------------ |
| C | Molto buono | Programmazione di sistema, embedded |
| C++ | Molto buono | Applicazioni critiche per le prestazioni |
| Rust | Molto buono | Programmazione di sistema memory-safe |
| Go | Eccellente | Sistemi concorrenti, servizi cloud |
| Assembly | Buono | Ottimizzazione di basso livello, debugging |
**Qualità del supporto:** i linguaggi comuni (JavaScript, Python, TypeScript) godono di un supporto più solido grazie all'ampia disponibilità di dati di addestramento. I linguaggi meno comuni o specifici per un dominio possono avere una qualità di supporto ridotta ma restano comunque funzionali.
***
## Limiti d'uso e migliori pratiche [#limiti-duso-e-migliori-pratiche]
### Efficienza di file\_read [#efficienza-di-file_read]
**Migliori pratiche:**
* Usa intervalli di righe per file di oltre 500 righe per evitare il sovraccarico del contesto
* Leggi solo le sezioni rilevanti per l'attività
* Per i file di grandi dimensioni, usa prima `grep_content` per identificare i numeri di riga rilevanti
```bash
# Good: Read specific section
file_read("large-config.json", start_line=100, max_lines=50)
# Less efficient: Read entire large file
file_read("large-config.json") # May consume excessive context
```
***
### Precisione di file\_edit [#precisione-di-file_edit]
**Migliori pratiche:**
* Assicurati che le corrispondenze delle stringhe siano esatte per evitare modifiche fallite
* Per più modifiche simili, usa il flag `multiple=true`
* Verifica i percorsi dei file prima di modificarli
***
### Sicurezza di file\_write [#sicurezza-di-file_write]
**Migliori pratiche:**
* Controlla attentamente i percorsi per evitare sovrascritture accidentali
* Usalo solo per nuovi file o riscritture complete
* Per le modifiche, preferisci `file_edit` per maggiore sicurezza
### Specificità dei pattern glob [#specificità-dei-pattern-glob]
**Migliori pratiche:**
* Usa pattern specifici per restringere l'ambito: `src/**/*.ts` invece di `**/*`
* Escludi le directory con pattern di esclusione: `!**/node_modules/**`
* Limita i risultati per evitare un output eccessivo
```bash
# Good: Specific scope
glob("src/components/**/*.tsx", max_results=50)
# Less efficient: Too broad
glob("**/*") # Returns thousands of results
```
***
### Strategia grep [#strategia-grep]
**Flusso di lavoro consigliato:**
1. Usa `grep_file` per identificare i file rilevanti
2. Leggi i file specifici con `file_read`
3. Usa `grep_content` quando hai bisogno del contesto circostante
**Consigli sulle prestazioni:**
* I pattern regex possono richiedere più tempo delle stringhe letterali
* Le ricerche case-insensitive sono più lente
* Limita le righe di contesto (`-A`, `-B`) a quelle necessarie
### Migliori pratiche per bash [#migliori-pratiche-per-bash]
**Esecuzione sicura dei comandi:**
* Fornisci riepiloghi chiari per le descrizioni dei comandi
* Imposta timeout appropriati per le operazioni di lunga durata
* Concatena i comandi dipendenti con `&&`
* Rivedi attentamente i comandi distruttivi (rm, drop, truncate)
```bash
# Good: Clear summary, reasonable timeout
bash("npm run build", timeout=120000, summary="Build production bundle")
# Good: Chained dependencies
bash("npm install && npm run test", timeout=180000)
```
***
### Considerazioni sulla sicurezza [#considerazioni-sulla-sicurezza]
**Regole di sicurezza fondamentali:**
* I comandi vengono eseguiti con i permessi dell'utente
* Non eseguire mai comandi non attendibili
* Usa Manual Accept Mode per la revisione nelle codebase condivise
* Evita comandi che espongono credenziali o dati sensibili
Rivedi sempre i comandi bash in Manual Accept Mode quando lavori in codebase condivise o ambienti di produzione.
### Efficienza nella delega ai sottoagenti [#efficienza-nella-delega-ai-sottoagenti]
**Quando usare i sottoagenti:**
* **Explorer:** ricerche nella codebase, domande sull'architettura (risparmia il contesto principale)
* **Verifier:** controlli di validazione rapidi (verifica isolata)
* **Code-reviewer:** revisioni di sicurezza e qualità (analisi dettagliata)
* **General:** attività complesse in più passaggi (esecuzione parallela)
**Buona pratica:**
Delega le attività esplorative e di ricerca ai sottoagenti per preservare il contesto della conversazione principale per il lavoro di sviluppo attivo.
***
### Gestione del contesto [#gestione-del-contesto]
**Uso strategico degli strumenti:**
* Leggi i file in modo strategico, solo ciò che serve
* Usa i sottoagenti per la ricerca in background
* Monitora il consumo del contesto durante le sessioni lunghe
* Suddividi le operazioni complesse in passaggi con todo\_update
**Flussi di lavoro efficienti:**
1. **Pianificazione:** usa glob/grep per identificare l'ambito
2. **Lettura:** leggi solo i file/sezioni rilevanti
3. **Esecuzione:** delega ai sottoagenti quando appropriato
4. **Verifica:** controlli rapidi con il sottoagente Verifier
### Limiti sulle dimensioni dei file [#limiti-sulle-dimensioni-dei-file]
**Gestione dei file di grandi dimensioni:**
I file molto grandi (>10.000 righe) dovrebbero essere letti a sezioni per evitare:
* Esaurimento della finestra di contesto
* Tempi di risposta lenti
* Problemi di memoria
Per i file di oltre 500 righe, usa sempre gli intervalli di righe con `file_read` per mantenere prestazioni ottimali.
***
### Timeout predefiniti degli strumenti [#timeout-predefiniti-degli-strumenti]
**Limiti degli strumenti:**
* **Timeout di bash:** 120 secondi (2 minuti) al massimo
* **Operazioni sui file:** nessun limite di dimensione (i file di grandi dimensioni vengono letti automaticamente a blocchi)
* **Gestione dei file di grandi dimensioni:** i file >256KB restituiscono solo i primi 256KB di contenuto
* **Risultati di ricerca:** nessun limite sui risultati di `glob` o `grep_content`
* **Sottoagenti concorrenti:** nessun limite sull'esecuzione parallela
**Configurazione del timeout:**
* Imposta timeout espliciti per le operazioni di lunga durata
* Monitora i processi bloccati
* I comandi che superano il timeout di 2 minuti verranno terminati
***
### Operazioni concorrenti [#operazioni-concorrenti]
**Esecuzione parallela:**
Più sottoagenti possono essere eseguiti in parallelo per operazioni complesse più veloci. L'agente principale gestisce automaticamente il coordinamento.
**Vantaggi in termini di prestazioni:**
* Riduzione del tempo totale di esecuzione per le attività in più passaggi
* Utilizzo efficiente delle risorse
* Orchestrazione automatica delle attività
* Nessun limite sul numero di sottoagenti concorrenti
***
## Vedi anche [#vedi-anche]
Scopri gli agenti specializzati
Controlla l'esecuzione degli strumenti con le modalità