cc-viewer 1.2.1 → 1.2.2

package/concepts/fr/Tool-executeCode.md

@@ -0,0 +1,33 @@
+# executeCode (mcp__ide__executeCode)
+
+## Définition
+
+Exécute du code Python dans le kernel Jupyter du fichier notebook actuel.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `code` | string | Oui | Code Python à exécuter |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Exécuter du code dans un environnement Jupyter notebook
+- Tester des extraits de code
+- Analyse de données et calculs
+
+**Non adapté pour :**
+- Exécution de code hors environnement Jupyter — utiliser Bash
+- Modifier des fichiers — utiliser Edit ou Write
+
+## Notes
+
+- C'est un outil MCP (Model Context Protocol), fourni par l'intégration IDE
+- Le code s'exécute dans le kernel Jupyter actuel, l'état persiste entre les appels
+- Sauf demande explicite de l'utilisateur, éviter de déclarer des variables ou de modifier l'état du kernel
+- L'état est perdu au redémarrage du kernel
+
+## Signification dans cc-viewer
+
+executeCode est un outil MCP qui apparaît dans le tableau `tools` du journal des requêtes sous le nom `mcp__ide__executeCode`. Ses appels et retours suivent le modèle standard `tool_use` / `tool_result`. L'ajout/suppression d'outils MCP entraîne des changements dans le tableau tools, ce qui peut déclencher la reconstruction du cache.

package/concepts/fr/Tool-getDiagnostics.md

@@ -0,0 +1,32 @@
+# getDiagnostics (mcp__ide__getDiagnostics)
+
+## Définition
+
+Obtient les informations de diagnostic du langage depuis VS Code, incluant les erreurs de syntaxe, erreurs de type, avertissements de lint, etc.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `uri` | string | Non | URI du fichier. Si non fourni, obtient les informations de diagnostic de tous les fichiers |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Vérifier les problèmes sémantiques de syntaxe, types, lint, etc. du code
+- Vérifier si de nouvelles erreurs ont été introduites après l'édition du code
+- Remplacer les commandes Bash pour vérifier la qualité du code
+
+**Non adapté pour :**
+- Exécuter des tests — utiliser Bash
+- Vérifier les erreurs d'exécution — utiliser Bash pour exécuter le code
+
+## Notes
+
+- C'est un outil MCP (Model Context Protocol), fourni par l'intégration IDE
+- Disponible uniquement dans les environnements VS Code / IDE
+- Préférer cet outil aux commandes Bash pour vérifier les problèmes de code
+
+## Signification dans cc-viewer
+
+getDiagnostics est un outil MCP qui apparaît dans le tableau `tools` du journal des requêtes sous le nom `mcp__ide__getDiagnostics`. Ses appels et retours suivent le modèle standard `tool_use` / `tool_result`. L'ajout/suppression d'outils MCP entraîne des changements dans le tableau tools, ce qui peut déclencher la reconstruction du cache.

package/concepts/fr/Tools.md

@@ -0,0 +1,73 @@
+# Vue d'ensemble des outils Claude Code
+
+Claude Code fournit au modèle un ensemble d'outils intégrés via le mécanisme tool_use de l'API Anthropic. Chaque requête MainAgent inclut les définitions complètes en JSON Schema de ces outils dans le tableau `tools`, et le modèle les invoque via des content blocks `tool_use` dans la réponse.
+
+Voici l'index classifié de tous les outils.
+
+## Système d'Agents
+
+| Outil | Utilité |
+|-------|---------|
+| [Task](Tool-Task.md) | Lancer un sous-agent (SubAgent) pour gérer des tâches complexes multi-étapes |
+| [TaskOutput](Tool-TaskOutput.md) | Obtenir la sortie des tâches en arrière-plan |
+| [TaskStop](Tool-TaskStop.md) | Arrêter une tâche en arrière-plan en cours d'exécution |
+| [TaskCreate](Tool-TaskCreate.md) | Créer une entrée dans la liste de tâches structurée |
+| [TaskGet](Tool-TaskGet.md) | Obtenir les détails d'une tâche |
+| [TaskUpdate](Tool-TaskUpdate.md) | Mettre à jour le statut, les dépendances, etc. d'une tâche |
+| [TaskList](Tool-TaskList.md) | Lister toutes les tâches |
+
+## Opérations sur les fichiers
+
+| Outil | Utilité |
+|-------|---------|
+| [Read](Tool-Read.md) | Lire le contenu de fichiers (supporte texte, images, PDF, Jupyter notebook) |
+| [Edit](Tool-Edit.md) | Éditer des fichiers par remplacement exact de chaînes |
+| [Write](Tool-Write.md) | Écrire ou écraser des fichiers |
+| [NotebookEdit](Tool-NotebookEdit.md) | Éditer des cellules de Jupyter notebook |
+
+## Recherche
+
+| Outil | Utilité |
+|-------|---------|
+| [Glob](Tool-Glob.md) | Rechercher des fichiers par correspondance de motifs de noms |
+| [Grep](Tool-Grep.md) | Recherche de contenu de fichiers basée sur ripgrep |
+
+## Terminal
+
+| Outil | Utilité |
+|-------|---------|
+| [Bash](Tool-Bash.md) | Exécuter des commandes shell |
+
+## Web
+
+| Outil | Utilité |
+|-------|---------|
+| [WebFetch](Tool-WebFetch.md) | Récupérer du contenu web et le traiter avec l'IA |
+| [WebSearch](Tool-WebSearch.md) | Requêtes sur les moteurs de recherche |
+
+## Planification et interaction
+
+| Outil | Utilité |
+|-------|---------|
+| [EnterPlanMode](Tool-EnterPlanMode.md) | Entrer en mode planification pour concevoir un plan d'implémentation |
+| [ExitPlanMode](Tool-ExitPlanMode.md) | Quitter le mode planification et soumettre le plan pour approbation de l'utilisateur |
+| [AskUserQuestion](Tool-AskUserQuestion.md) | Poser des questions à l'utilisateur pour obtenir des clarifications ou des décisions |
+
+## Extensions
+
+| Outil | Utilité |
+|-------|---------|
+| [Skill](Tool-Skill.md) | Exécuter une compétence (slash command) |
+
+## Intégration IDE
+
+| Outil | Utilité |
+|-------|---------|
+| [getDiagnostics](Tool-getDiagnostics.md) | Obtenir les informations de diagnostic du langage de VS Code |
+| [executeCode](Tool-executeCode.md) | Exécuter du code dans le kernel Jupyter |
+
+## Signification dans cc-viewer
+
+Les appels d'outils sont l'une des données observables les plus importantes dans les journaux de requêtes de Claude Code. Le tableau `tools` de chaque requête MainAgent définit l'ensemble des outils disponibles pour le modèle, tandis que les content blocks `tool_use` / `tool_result` dans la réponse enregistrent les appels réels aux outils et leurs retours. cc-viewer analyse ces données pour reconstruire la chaîne complète d'appels d'outils dans le Chat Mode.
+
+Les changements dans les définitions d'outils (comme l'ajout/suppression d'outils par connexion/déconnexion de MCP server) déclenchent la reconstruction du cache, voir [CacheRebuild](CacheRebuild.md).

package/concepts/fr/TranslateContextPollution.md

@@ -0,0 +1,46 @@
+# Pollution de contexte de l'API de traduction
+
+## Contexte
+
+CC-Viewer intègre une fonctionnalité de traduction (`POST /api/translate`) alimentée par l'API Messages d'Anthropic. Dans l'implémentation initiale, les requêtes de traduction réutilisaient les identifiants d'authentification mis en cache de la session Claude Code — incluant les en-têtes `x-api-key` et `authorization`. Cela a provoqué un problème subtil mais grave : les résultats de traduction renvoyaient fréquemment du contenu sans rapport.
+
+## Cause profonde
+
+### Différence fondamentale entre les deux méthodes d'authentification
+
+L'API Anthropic prend en charge deux méthodes d'authentification :
+
+| Méthode | En-tête | Source typique | Caractéristiques |
+|---------|---------|----------------|------------------|
+| Clé API | `x-api-key: sk-ant-...` | Variable d'environnement / Console | Sans état, chaque requête est indépendante |
+| Jeton OAuth | `authorization: Bearer sessionToken` | Connexion par abonnement Claude Code | Lié à la session, le serveur maintient l'association de contexte |
+
+La différence clé : **les clés API sont sans état** — chaque requête est complètement indépendante ; tandis que **les jetons de session OAuth sont avec état** — le serveur Anthropic associe les requêtes utilisant le même jeton au même contexte de session.
+
+### Chaîne de pollution
+
+Lorsque Claude Code utilise la connexion OAuth par abonnement, le flux d'authentification se présente ainsi :
+
+```
+Conversation principale Claude Code ──(authorization: Bearer sessionToken)──→ Anthropic API
+                                                                                ↑
+Requête de traduction CC-Viewer ──(authorization: Bearer sessionToken)──→ Anthropic API
+```
+
+Étant donné que les requêtes de traduction réutilisaient le même jeton de session, le serveur Anthropic pouvait associer les requêtes de traduction au contexte de la conversation principale de Claude Code. Cela entraîne :
+
+1. **Les résultats de traduction sont influencés par le contexte de la conversation principale** : Le prompt système de la requête de traduction est « vous êtes un traducteur », mais le contexte serveur contient toujours l'historique de conversation de Claude Code, ce qui peut interférer avec le modèle
+2. **La conversation principale est perturbée par les requêtes de traduction** : Le contenu des requêtes de traduction (fragments de texte d'interface) peut être injecté dans le contexte de la conversation principale, provoquant des déviations dans les réponses de Claude Code
+3. **Comportement imprévisible** : La pollution de contexte étant un comportement côté serveur, le client ne peut ni la détecter ni la contrôler
+
+## Leçons retenues
+
+- **Les jetons de session OAuth ne sont pas « juste une autre clé API »** — ils portent un état côté serveur, les réutiliser signifie partager le contexte
+- **Les appels de services internes doivent utiliser une authentification indépendante et sans état** pour éviter toute association avec les sessions utilisateur
+
+## Références
+
+- [Anthropic API Authentication Docs](https://docs.anthropic.com/en/api/getting-started)
+- [Claude Code Authentication](https://support.claude.com/en/articles/12304248-managing-api-key-environment-variables-in-claude-code)
+- [Anthropic Bans Subscription OAuth in Third-Party Apps](https://winbuzzer.com/2026/02/19/anthropic-bans-claude-subscription-oauth-in-third-party-apps-xcxwbn/)
+- [Claude Code Authentication: API Keys, Subscriptions, and SSO](https://developertoolkit.ai/en/claude-code/quick-start/authentication/)

package/concepts/it/BodyDiffJSON.md

@@ -0,0 +1,32 @@
+# Body Diff JSON (confronto incrementale del corpo della richiesta)
+
+## Contesto
+
+Il MainAgent di Claude Code utilizza un meccanismo di invio del contesto completo: ogni richiesta include l'intera cronologia della conversazione, il system prompt, le definizioni degli strumenti, ecc. Ciò significa che, man mano che la conversazione procede, il corpo della richiesta diventa sempre più grande, rendendo difficile individuare rapidamente "cosa è stato aggiunto in questo turno" esaminando il Body grezzo.
+
+Body Diff JSON è stato creato proprio per risolvere questo problema: confronta automaticamente i body di due richieste MainAgent consecutive, estraendo la parte incrementale, permettendoti di vedere a colpo d'occhio il contenuto effettivamente aggiunto in questa richiesta.
+
+## Come funziona
+
+1. **Identificazione delle richieste MainAgent consecutive**: la richiesta corrente deve essere di tipo MainAgent e deve esistere una richiesta MainAgent precedente
+2. **Confronto campo per campo**: vengono esaminati tutti i campi di primo livello del corpo della richiesta, saltando le proprietà interne con prefisso `_`
+3. **Estrazione intelligente delle differenze**:
+   - Campi aggiunti: mostrati direttamente
+   - Campi rimossi: non mostrati (generalmente non influenzano la comprensione)
+   - Campi modificati: viene mostrato il valore corrente
+   - Trattamento speciale dell'array `messages`: vengono mostrati solo i messaggi aggiunti (poiché in una conversazione normale i messaggi vengono accodati e il prefisso rimane invariato)
+4. **Rilevamento della riduzione del corpo**: se il corpo della richiesta corrente è più piccolo del precedente, significa che si è verificato un troncamento del contesto o un reset della sessione; in tal caso viene mostrato un messaggio informativo anziché il diff
+
+## Scenari tipici
+
+In un turno di conversazione normale, il Body Diff JSON contiene solitamente solo:
+- `messages`: 1~2 messaggi aggiunti (l'input dell'utente + la risposta dell'assistente del turno precedente)
+
+Se nel diff compaiono modifiche a campi come `system`, `tools`, `model`, significa che in questo turno si è verificata una modifica della configurazione, che spesso è anche la causa della ricostruzione della cache.
+
+## Modalità d'uso
+
+- Il Body Diff JSON viene mostrato nel pannello dei dettagli della richiesta MainAgent
+- Clicca sul titolo per espandere/comprimere
+- Supporta due modalità di visualizzazione, JSON e Text, oltre alla copia con un clic
+- In alto a sinistra, in **CC-Viewer → Impostazioni globali**, puoi impostare "Espandi Body Diff JSON per impostazione predefinita"

package/concepts/it/CacheRebuild.md

@@ -0,0 +1,40 @@
+# Cache Rebuild (ricostruzione della cache)
+
+## Contesto
+
+Il meccanismo di prompt caching di Anthropic concatena in sequenza system → tools → messages (fino al cache breakpoint) della richiesta come chiave di cache. Quando la chiave di cache corrisponde esattamente alla richiesta precedente, l'API restituisce `cache_read_input_tokens` (cache hit); quando la chiave di cache cambia, l'API ricrea la cache, restituendo un gran numero di `cache_creation_input_tokens`, ovvero una ricostruzione della cache.
+
+La ricostruzione della cache comporta costi aggiuntivi di token (il prezzo della cache creation è superiore a quello della cache read), pertanto identificare la causa della ricostruzione ha un valore diretto per l'ottimizzazione dei costi.
+
+## Classificazione delle cause di ricostruzione della cache
+
+cc-viewer confronta i body di due richieste MainAgent consecutive per determinare con precisione la causa della ricostruzione della cache:
+
+| reason | Significato | Metodo di determinazione |
+|--------|------|----------|
+| `ttl` | Cache scaduta | Sono trascorsi più di 5 minuti dall'ultima richiesta MainAgent |
+| `system_change` | Modifica del system prompt | `JSON.stringify(prev.system) !== JSON.stringify(curr.system)` |
+| `tools_change` | Modifica delle definizioni degli strumenti | `JSON.stringify(prev.tools) !== JSON.stringify(curr.tools)` |
+| `model_change` | Cambio di modello | `prev.model !== curr.model` |
+| `msg_truncated` | Stack dei messaggi troncato | Il numero di messaggi della richiesta corrente è inferiore a quello della richiesta precedente, solitamente causato dal troncamento per overflow della finestra di contesto |
+| `msg_modified` | Modifica dei messaggi storici | Il contenuto dei messaggi prefisso non è coerente (durante l'accodamento normale il prefisso dovrebbe essere identico) |
+| `key_change` | Modifica di chiave sconosciuta | Fallback quando nessuna delle condizioni precedenti corrisponde |
+
+## Priorità di determinazione
+
+1. Prima si controlla l'intervallo di tempo — se supera i 5 minuti, si determina direttamente `ttl`, senza confronto del body
+2. Poi si controllano in sequenza model, system, tools, messages
+3. Una richiesta può corrispondere a più cause contemporaneamente (es. cambio di modello + modifica del system prompt); in tal caso l'array `reasons` contiene tutti gli elementi corrispondenti e il tooltip li mostra su righe separate
+
+## Scenari comuni
+
+- **`ttl`**: l'utente ha interrotto le operazioni per più di 5 minuti e poi ha ripreso, la cache è scaduta naturalmente
+- **`system_change`**: Claude Code ha aggiornato il system prompt (es. caricamento di un nuovo CLAUDE.md, modifica delle project instructions)
+- **`tools_change`**: la connessione/disconnessione di un MCP server ha causato una modifica della lista degli strumenti disponibili
+- **`model_change`**: l'utente ha cambiato modello tramite il comando `/model`
+- **`msg_truncated`**: una conversazione troppo lunga ha attivato la gestione della finestra di contesto, Claude Code ha troncato i messaggi precedenti
+- **`msg_modified`**: Claude Code ha modificato i messaggi storici (es. `/compact` ha sostituito i messaggi originali con un riepilogo compresso)
+
+## Visualizzazione in cc-viewer
+
+Nella lista delle richieste, le richieste con ricostruzione della cache mostrano un indicatore a punto rosso nella riga cache. Passando il mouse viene mostrato un tooltip con la descrizione specifica della causa della ricostruzione (supporto per 18 lingue).

package/concepts/it/MainAgent.md

@@ -0,0 +1,30 @@
+# MainAgent
+
+## Definizione
+
+MainAgent è la catena di richieste principale di Claude Code quando non è in modalità agent team. Ogni interazione dell'utente con Claude Code genera una serie di richieste API, tra cui le richieste MainAgent costituiscono la catena di conversazione principale — trasportano il system prompt completo, le definizioni degli strumenti e la cronologia dei messaggi.
+
+## Metodo di identificazione
+
+In cc-viewer, MainAgent è identificato tramite `req.mainAgent === true`, contrassegnato automaticamente da `interceptor.js` al momento della cattura della richiesta.
+
+Condizioni di determinazione (tutte devono essere soddisfatte):
+- Il corpo della richiesta contiene il campo `system` (system prompt)
+- Il corpo della richiesta contiene l'array `tools` (definizioni degli strumenti)
+- Il system prompt contiene il testo caratteristico "Claude Code"
+
+## Differenze rispetto al SubAgent
+
+| Caratteristica | MainAgent | SubAgent |
+|------|-----------|----------|
+| system prompt | Prompt principale completo di Claude Code | Prompt semplificato specifico per il task |
+| Array tools | Contiene tutti gli strumenti disponibili | Solitamente contiene solo i pochi strumenti necessari per il task |
+| Cronologia messaggi | Accumula il contesto completo della conversazione | Contiene solo i messaggi relativi al sotto-task |
+| Comportamento cache | Ha prompt caching (TTL di 5 minuti) | Solitamente senza cache o con cache ridotta |
+
+## Significato in cc-viewer
+
+- **Tracciamento della cache**: lo stato del prompt caching delle richieste MainAgent influisce direttamente sui costi. Monitorando il rapporto tra `cache_creation_input_tokens` e `cache_read_input_tokens`, è possibile valutare il tasso di cache hit
+- **Analisi della perdita di cache**: quando una richiesta MainAgent presenta un'elevata cache creation (anziché cache read), significa che la cache è stata persa e ricostruita; cc-viewer contrassegna queste richieste con un indicatore a punto rosso
+- **Analisi della catena principale**: la sequenza delle richieste MainAgent riflette l'intero processo di interazione dell'utente con Claude Code, ed è il dato fondamentale per l'analisi del comportamento della sessione
+- **Ricostruzione della sessione**: cc-viewer ricostruisce la vista della conversazione (Chat Mode) attraverso la cronologia dei messaggi delle richieste MainAgent

package/concepts/it/Tool-AskUserQuestion.md

@@ -0,0 +1,54 @@
+# AskUserQuestion
+
+## Definizione
+
+Pone domande all'utente durante l'esecuzione, per ottenere chiarimenti, verificare ipotesi o richiedere decisioni.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `questions` | array | Sì | Lista di domande (1-4 domande) |
+| `answers` | object | No | Risposte raccolte dall'utente |
+| `annotations` | object | No | Annotazioni per ogni domanda (es. note per l'anteprima delle selezioni) |
+| `metadata` | object | No | Metadati per tracciamento e analisi |
+
+Ogni oggetto `question`:
+
+| Campo | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `question` | string | Sì | Testo completo della domanda, deve terminare con un punto interrogativo |
+| `header` | string | Sì | Etichetta breve (massimo 12 caratteri), visualizzata come chip |
+| `options` | array | Sì | 2-4 opzioni |
+| `multiSelect` | boolean | Sì | Se è consentita la selezione multipla |
+
+Ogni oggetto `option`:
+
+| Campo | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `label` | string | Sì | Testo visualizzato dell'opzione (1-5 parole) |
+| `description` | string | Sì | Descrizione dell'opzione |
+| `markdown` | string | No | Contenuto di anteprima (per il confronto visivo di layout ASCII, frammenti di codice, ecc.) |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Raccogliere preferenze o requisiti dell'utente
+- Chiarire istruzioni ambigue
+- Ottenere decisioni durante l'implementazione
+- Offrire all'utente scelte di direzione
+
+**Non adatto per:**
+- Chiedere "il piano va bene?" — usare ExitPlanMode
+
+## Note
+
+- L'utente può sempre selezionare "Other" per fornire un input personalizzato
+- L'opzione consigliata va messa per prima, con "(Recommended)" alla fine della label
+- L'anteprima `markdown` è supportata solo per domande a selezione singola
+- Le opzioni con `markdown` passano a un layout affiancato
+- In modalità pianificazione, viene usato per chiarire i requisiti prima di definire il piano
+
+## Significato in cc-viewer
+
+La chiamata AskUserQuestion appare nei log delle richieste come content block `tool_use`, contenente la definizione delle domande e delle opzioni. Le risposte dell'utente compaiono nella cronologia dei messaggi delle richieste successive.

package/concepts/it/Tool-Bash.md

@@ -0,0 +1,47 @@
+# Bash
+
+## Definizione
+
+Esegue comandi shell, con supporto opzionale per il timeout. La directory di lavoro persiste tra i comandi, ma lo stato della shell (variabili d'ambiente, ecc.) non persiste.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `command` | string | Sì | Il comando bash da eseguire |
+| `description` | string | No | Breve descrizione del comando |
+| `timeout` | number | No | Timeout in millisecondi, massimo 600000, predefinito 120000 |
+| `run_in_background` | boolean | No | Se eseguire in background |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Operazioni git (commit, push, branch, ecc.)
+- Comandi di gestione pacchetti npm/yarn
+- Operazioni docker
+- Comandi di compilazione e build
+- Elencare il contenuto delle directory (`ls`)
+- Altri comandi di sistema che richiedono l'esecuzione shell
+
+**Non adatto per:**
+- Leggere file — usare Read
+- Cercare nomi di file — usare Glob
+- Cercare contenuto di file — usare Grep
+- Modificare file — usare Edit
+- Scrivere file — usare Write
+- Mostrare informazioni all'utente — scrivere direttamente nel testo della risposta
+- Processi a lunga esecuzione (dev server, modalità watch) — consigliare all'utente di eseguirli manualmente
+
+## Note
+
+- I percorsi con spazi devono essere racchiusi tra virgolette doppie
+- L'output oltre 30000 caratteri viene troncato
+- I comandi in background ottengono i risultati tramite TaskOutput
+- Usare preferibilmente percorsi assoluti, evitare `cd`
+- I comandi indipendenti possono essere chiamati in parallelo con più Bash
+- I comandi con dipendenze vanno concatenati con `&&`
+- L'ambiente shell viene inizializzato dal profilo dell'utente (bash o zsh)
+
+## Significato in cc-viewer
+
+Le chiamate Bash appaiono nei log delle richieste come coppie di content block `tool_use` (contenente il comando) e `tool_result` (contenente l'output). L'output dell'esecuzione del comando può essere usato per analizzare il comportamento operativo del modello.

package/concepts/it/Tool-Edit.md

@@ -0,0 +1,38 @@
+# Edit
+
+## Definizione
+
+Modifica file tramite sostituzione esatta di stringhe. Sostituisce `old_string` con `new_string` nel file.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `file_path` | string | Sì | Percorso assoluto del file da modificare |
+| `old_string` | string | Sì | Testo originale da sostituire |
+| `new_string` | string | Sì | Nuovo testo sostitutivo (deve essere diverso da old_string) |
+| `replace_all` | boolean | No | Se sostituire tutte le occorrenze, predefinito `false` |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Modificare sezioni specifiche di codice in file esistenti
+- Correggere bug, aggiornare la logica
+- Rinominare variabili (con `replace_all: true`)
+- Qualsiasi scenario che richieda la modifica precisa del contenuto di un file
+
+**Non adatto per:**
+- Creare nuovi file — usare Write
+- Riscritture su larga scala — potrebbe essere necessario Write per sovrascrivere l'intero file
+
+## Note
+
+- Prima dell'uso è necessario aver letto il file tramite Read, altrimenti si verifica un errore
+- `old_string` deve essere unico nel file, altrimenti la modifica fallisce. Se non è unico, fornire più contesto per renderlo unico, oppure usare `replace_all`
+- Quando si modifica il testo, mantenere l'indentazione originale (tab/spazi), non includere il prefisso del numero di riga dall'output di Read
+- Preferire la modifica dei file esistenti anziché crearne di nuovi
+- `new_string` deve essere diverso da `old_string`
+
+## Significato in cc-viewer
+
+Le chiamate Edit appaiono nei log delle richieste come content block `tool_use`, il cui `input` contiene `old_string` e `new_string`, utili per tracciare quali modifiche il modello ha apportato ai file.

package/concepts/it/Tool-EnterPlanMode.md

@@ -0,0 +1,43 @@
+# EnterPlanMode
+
+## Definizione
+
+Passa Claude Code alla modalità pianificazione, utilizzata per esplorare il codebase e progettare un piano prima dell'implementazione.
+
+## Parametri
+
+Nessun parametro.
+
+## Scenari d'uso
+
+**Adatto per:**
+- Implementazione di nuove funzionalità — richiede decisioni architetturali
+- Esistono più approcci possibili — richiede la scelta dell'utente
+- Le modifiche al codice influenzano il comportamento o la struttura esistente
+- Modifiche multi-file — potenzialmente coinvolgono 2-3 o più file
+- Requisiti poco chiari — necessario esplorare prima di comprendere l'ambito
+- Le preferenze dell'utente sono importanti — l'implementazione può avere più direzioni ragionevoli
+
+**Non adatto per:**
+- Correzioni di una o poche righe (errori di battitura, bug evidenti)
+- L'utente ha fornito istruzioni molto specifiche
+- Task puramente di ricerca/esplorazione — usare Task (tipo Explore)
+
+## Comportamento in modalità pianificazione
+
+Dopo l'ingresso in modalità pianificazione, Claude Code:
+1. Usa gli strumenti Glob, Grep, Read per esplorare in profondità il codebase
+2. Comprende i pattern e l'architettura esistenti
+3. Progetta il piano di implementazione
+4. Sottopone il piano all'approvazione dell'utente
+5. Se necessario, usa AskUserQuestion per chiarimenti
+6. Quando il piano è pronto, esce tramite ExitPlanMode
+
+## Note
+
+- Questo strumento richiede il consenso dell'utente per entrare in modalità pianificazione
+- In caso di dubbio sulla necessità di pianificare, preferire la pianificazione — allinearsi in anticipo è meglio che rifare il lavoro
+
+## Significato in cc-viewer
+
+La chiamata EnterPlanMode appare nei log delle richieste come content block `tool_use`. Le richieste successive all'ingresso in modalità pianificazione sono tipicamente dominate da chiamate a strumenti esplorativi (Glob, Grep, Read), fino alla chiamata di ExitPlanMode.

package/concepts/it/Tool-ExitPlanMode.md

@@ -0,0 +1,39 @@
+# ExitPlanMode
+
+## Definizione
+
+Esce dalla modalità pianificazione e sottopone il piano all'approvazione dell'utente. Il contenuto del piano viene letto dal file di piano scritto in precedenza.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `allowedPrompts` | array | No | Lista di descrizioni dei permessi necessari per implementare il piano |
+
+Ogni elemento nell'array `allowedPrompts`:
+
+| Campo | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `tool` | enum | Sì | Lo strumento applicabile, attualmente supporta solo `Bash` |
+| `prompt` | string | Sì | Descrizione semantica dell'operazione (es. "run tests", "install dependencies") |
+
+## Scenari d'uso
+
+**Adatto per:**
+- In modalità pianificazione, il piano è completato e pronto per l'approvazione dell'utente
+- Solo per task di implementazione che richiedono la scrittura di codice
+
+**Non adatto per:**
+- Task puramente di ricerca/esplorazione — non è necessario uscire dalla modalità pianificazione
+- Voler chiedere all'utente "il piano va bene?" — questa è esattamente la funzione di questo strumento, non usare AskUserQuestion per chiederlo
+
+## Note
+
+- Questo strumento non accetta il contenuto del piano come parametro — lo legge dal file di piano scritto in precedenza
+- L'utente vedrà il contenuto del file di piano per l'approvazione
+- Non usare AskUserQuestion per chiedere "il piano va bene?" prima di chiamare questo strumento, sarebbe ridondante
+- Non menzionare il "piano" nelle domande, poiché l'utente non può vedere il contenuto del piano prima di ExitPlanMode
+
+## Significato in cc-viewer
+
+La chiamata ExitPlanMode segna la fine della fase di pianificazione. Nei log delle richieste, le richieste successive a questa chiamata passano tipicamente a operazioni di implementazione (Edit, Write, Bash, ecc.).

package/concepts/it/Tool-Glob.md

@@ -0,0 +1,34 @@
+# Glob
+
+## Definizione
+
+Strumento veloce di corrispondenza per pattern di nomi file, supporta codebase di qualsiasi dimensione. Restituisce i percorsi dei file corrispondenti ordinati per data di modifica.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `pattern` | string | Sì | Pattern glob (es. `**/*.js`, `src/**/*.ts`) |
+| `path` | string | No | Directory di ricerca, predefinita la directory di lavoro corrente. Non passare "undefined" o "null" |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Cercare file per pattern di nome file
+- Trovare tutti i file di un tipo specifico (es. tutti i file `.tsx`)
+- Localizzare file quando si cerca una definizione di classe specifica (es. `class Foo`)
+- È possibile lanciare più chiamate Glob in parallelo in un singolo messaggio
+
+**Non adatto per:**
+- Cercare contenuto di file — usare Grep
+- Esplorazione aperta che richiede più cicli di ricerca — usare Task (tipo Explore)
+
+## Note
+
+- Supporta la sintassi glob standard: `*` corrisponde a un livello, `**` a più livelli, `{}` per selezione multipla
+- I risultati sono ordinati per data di modifica
+- Più consigliato rispetto al comando `find` di Bash
+
+## Significato in cc-viewer
+
+Le chiamate Glob appaiono nei log delle richieste come coppie di content block `tool_use` / `tool_result`. Il `tool_result` contiene la lista dei percorsi dei file corrispondenti.

package/concepts/it/Tool-Grep.md

@@ -0,0 +1,47 @@
+# Grep
+
+## Definizione
+
+Potente strumento di ricerca nel contenuto basato su ripgrep. Supporta espressioni regolari, filtro per tipo di file e diverse modalità di output.
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `pattern` | string | Sì | Pattern di ricerca con espressione regolare |
+| `path` | string | No | Percorso di ricerca (file o directory), predefinita la directory di lavoro corrente |
+| `glob` | string | No | Filtro per nome file (es. `*.js`, `*.{ts,tsx}`) |
+| `type` | string | No | Filtro per tipo di file (es. `js`, `py`, `rust`), più efficiente di glob |
+| `output_mode` | enum | No | Modalità di output: `files_with_matches` (predefinita), `content`, `count` |
+| `-i` | boolean | No | Ricerca senza distinzione maiuscole/minuscole |
+| `-n` | boolean | No | Mostra numeri di riga (solo modalità content), predefinito true |
+| `-A` | number | No | Numero di righe da mostrare dopo la corrispondenza |
+| `-B` | number | No | Numero di righe da mostrare prima della corrispondenza |
+| `-C` / `context` | number | No | Numero di righe da mostrare prima e dopo la corrispondenza |
+| `head_limit` | number | No | Limita il numero di voci nell'output, predefinito 0 (illimitato) |
+| `offset` | number | No | Salta i primi N risultati |
+| `multiline` | boolean | No | Abilita la modalità di corrispondenza multiriga, predefinito false |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Cercare stringhe o pattern specifici nel codebase
+- Trovare dove vengono usate funzioni/variabili
+- Filtrare i risultati di ricerca per tipo di file
+- Contare il numero di corrispondenze
+
+**Non adatto per:**
+- Cercare file per nome — usare Glob
+- Esplorazione aperta che richiede più cicli di ricerca — usare Task (tipo Explore)
+
+## Note
+
+- Usa la sintassi ripgrep (non grep), i caratteri speciali come le parentesi graffe devono essere escapati
+- La modalità `files_with_matches` restituisce solo i percorsi dei file, la più efficiente
+- La modalità `content` restituisce il contenuto delle righe corrispondenti, supporta righe di contesto
+- La corrispondenza multiriga richiede l'impostazione `multiline: true`
+- Usare sempre lo strumento Grep anziché i comandi `grep` o `rg` in Bash
+
+## Significato in cc-viewer
+
+Le chiamate Grep appaiono nei log delle richieste come coppie di content block `tool_use` / `tool_result`. Il `tool_result` contiene i risultati della ricerca.

package/concepts/it/Tool-NotebookEdit.md

@@ -0,0 +1,33 @@
+# NotebookEdit
+
+## Definizione
+
+Sostituisce, inserisce o elimina celle specifiche in un Jupyter notebook (file .ipynb).
+
+## Parametri
+
+| Parametro | Tipo | Obbligatorio | Descrizione |
+|------|------|------|------|
+| `notebook_path` | string | Sì | Percorso assoluto del file notebook |
+| `new_source` | string | Sì | Nuovo contenuto della cella |
+| `cell_id` | string | No | ID della cella da modificare. In modalità inserimento, la nuova cella viene inserita dopo questo ID |
+| `cell_type` | enum | No | Tipo di cella: `code` o `markdown`. Obbligatorio in modalità inserimento |
+| `edit_mode` | enum | No | Modalità di modifica: `replace` (predefinita), `insert`, `delete` |
+
+## Scenari d'uso
+
+**Adatto per:**
+- Modificare celle di codice o markdown in un Jupyter notebook
+- Aggiungere nuove celle a un notebook
+- Eliminare celle da un notebook
+
+## Note
+
+- `cell_number` è indicizzato a partire da 0
+- La modalità `insert` inserisce una nuova cella nella posizione specificata
+- La modalità `delete` elimina la cella nella posizione specificata
+- Il percorso deve essere assoluto
+
+## Significato in cc-viewer
+
+Le chiamate NotebookEdit appaiono nei log delle richieste come content block `tool_use`, che registrano le operazioni specifiche di modifica sul notebook.