@neurocode-ai/web 1.18.8

package/src/content/docs/it/models.mdx

@@ -0,0 +1,222 @@
+---
+title: Modelli
+description: Configurare un provider LLM e un modello.
+---
+
+OpenCode usa [AI SDK](https://ai-sdk.dev/) e [Models.dev](https://models.dev) per supportare **75+ provider LLM** e supporta anche l'esecuzione di modelli locali.
+
+---
+
+## Provider
+
+I provider piu popolari sono precaricati per impostazione predefinita. Se hai aggiunto le credenziali di un provider tramite il comando `/connect`, saranno disponibili quando avvii OpenCode.
+
+[Scopri di piu](/docs/providers) sui provider.
+
+---
+
+## Seleziona un modello
+
+Dopo aver configurato il provider, puoi selezionare il modello che vuoi digitando:
+
+```bash frame="none"
+/models
+```
+
+---
+
+## Modelli consigliati
+
+Esistono moltissimi modelli, e ne escono di nuovi ogni settimana.
+
+:::tip
+Valuta di usare uno dei modelli che consigliamo.
+:::
+
+Tuttavia, solo alcuni sono davvero bravi sia a generare codice sia a chiamare strumenti.
+
+Ecco alcuni modelli che funzionano bene con OpenCode, in nessun ordine particolare. (Non e una lista esaustiva e potrebbe non essere aggiornata):
+
+- GPT 5.2
+- GPT 5.1 Codex
+- Claude Opus 4.5
+- Claude Sonnet 4.5
+- Minimax M2.1
+- Gemini 3 Pro
+
+---
+
+## Imposta un predefinito
+
+Per impostarne uno come modello predefinito, puoi impostare la chiave `model` nella config di OpenCode.
+
+```json title="opencode.json" {3}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "lmstudio/google/gemma-3n-e4b"
+}
+```
+
+Qui l'ID completo e `provider_id/model_id`. Per esempio, se usi [OpenCode Zen](/docs/zen), useresti `opencode/gpt-5.1-codex` per GPT 5.1 Codex.
+
+Se hai configurato un [provider personalizzato](/docs/providers#custom), `provider_id` e la chiave nella sezione `provider` della config e `model_id` e la chiave in `provider.models`.
+
+---
+
+## Configurazione modelli
+
+Puoi configurare globalmente le opzioni di un modello tramite la config.
+
+```jsonc title="opencode.jsonc" {7-12,19-24}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "options": {
+            "reasoningEffort": "high",
+            "textVerbosity": "low",
+            "reasoningSummary": "auto",
+            "include": ["reasoning.encrypted_content"],
+          },
+        },
+      },
+    },
+    "anthropic": {
+      "models": {
+        "claude-sonnet-4-5-20250929": {
+          "options": {
+            "thinking": {
+              "type": "enabled",
+              "budgetTokens": 16000,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Qui stiamo configurando impostazioni globali per due modelli integrati: `gpt-5` quando viene usato tramite il provider `openai` e `claude-sonnet-4-20250514` quando viene usato tramite il provider `anthropic`.
+I nomi di provider e modelli integrati si trovano su [Models.dev](https://models.dev).
+
+Puoi anche configurare queste opzioni per gli agenti che usi. La config dell'agente sovrascrive le opzioni globali definite qui. [Scopri di piu](/docs/agents/#additional).
+
+Puoi anche definire varianti personalizzate che estendono quelle integrate. Le varianti ti permettono di configurare impostazioni diverse per lo stesso modello senza creare voci duplicate:
+
+```jsonc title="opencode.jsonc" {6-21}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "opencode": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "high": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+            "low": {
+              "reasoningEffort": "low",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+---
+
+## Varianti
+
+Molti modelli supportano piu varianti con configurazioni diverse. OpenCode include varianti predefinite integrate per i provider piu comuni.
+
+### Varianti integrate
+
+OpenCode include varianti predefinite per molti provider:
+
+**Anthropic**:
+
+- `high` - High thinking budget (default)
+- `max` - Maximum thinking budget
+
+**OpenAI**:
+
+Varies by model but roughly:
+
+- `none` - No reasoning
+- `minimal` - Minimal reasoning effort
+- `low` - Low reasoning effort
+- `medium` - Medium reasoning effort
+- `high` - High reasoning effort
+- `xhigh` - Extra high reasoning effort
+
+**Google**:
+
+- `low` - Lower effort/token budget
+- `high` - Higher effort/token budget
+
+:::tip
+Questa lista non e completa. Anche molti altri provider hanno default integrati.
+:::
+
+### Varianti personalizzate
+
+Puoi sovrascrivere varianti esistenti o aggiungerne di tue:
+
+```jsonc title="opencode.jsonc" {7-18}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "thinking": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+            },
+            "fast": {
+              "disabled": true,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+### Ciclare tra varianti
+
+Usa il keybind `variant_cycle` per passare rapidamente tra le varianti. [Scopri di piu](/docs/keybinds).
+
+---
+
+## Caricamento modelli
+
+Quando OpenCode si avvia, controlla i modelli in questo ordine di priorita:
+
+1. Il flag da riga di comando `--model` o `-m`. Il formato e lo stesso della config: `provider_id/model_id`.
+
+2. La lista dei modelli nella config di OpenCode.
+
+   ```json title="opencode.json"
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "model": "anthropic/claude-sonnet-4-20250514"
+   }
+   ```
+
+   Qui il formato e `provider/model`.
+
+3. L'ultimo modello usato.
+
+4. Il primo modello in base a una priorita interna.

package/src/content/docs/it/network.mdx

@@ -0,0 +1,57 @@
+---
+title: Rete
+description: Configura proxy e certificati personalizzati.
+---
+
+OpenCode supporta le variabili d'ambiente standard per i proxy e certificati personalizzati per ambienti di rete enterprise.
+
+---
+
+## Proxy
+
+OpenCode rispetta le variabili d'ambiente standard dei proxy.
+
+```bash
+# HTTPS proxy (recommended)
+export HTTPS_PROXY=https://proxy.example.com:8080
+
+# HTTP proxy (if HTTPS not available)
+export HTTP_PROXY=http://proxy.example.com:8080
+
+# Bypass proxy for local server (required)
+export NO_PROXY=localhost,127.0.0.1
+```
+
+:::caution
+La TUI comunica con un server HTTP locale. Devi bypassare il proxy per questa connessione per evitare loop di instradamento.
+:::
+
+Puoi configurare porta e hostname del server usando i [flag della CLI](/docs/cli#run).
+
+---
+
+### Autenticazione
+
+Se il proxy richiede autenticazione basic, includi le credenziali nell'URL.
+
+```bash
+export HTTPS_PROXY=http://username:password@proxy.example.com:8080
+```
+
+:::caution
+Evita di hardcodare le password. Usa variabili d'ambiente o un archivio sicuro per le credenziali.
+:::
+
+Per proxy che richiedono autenticazioni avanzate come NTLM o Kerberos, valuta l'uso di un LLM Gateway che supporti il tuo metodo di autenticazione.
+
+---
+
+## Certificati personalizzati
+
+Se la tua organizzazione usa CA personalizzate per connessioni HTTPS, configura OpenCode in modo che si fidi di esse.
+
+```bash
+export NODE_EXTRA_CA_CERTS=/path/to/ca-cert.pem
+```
+
+Questo funziona sia per connessioni tramite proxy sia per l'accesso diretto alle API.

package/src/content/docs/it/permissions.mdx

@@ -0,0 +1,235 @@
+---
+title: Permessi
+description: Controlla quali azioni richiedono approvazione prima di essere eseguite.
+---
+
+OpenCode usa la configurazione `permission` per decidere se una determinata azione deve essere eseguita automaticamente, se deve chiederti conferma o se deve essere bloccata.
+
+A partire da `v1.1.1`, la vecchia configurazione booleana `tools` e' deprecata ed e' stata incorporata in `permission`. La vecchia configurazione `tools` e' ancora supportata per retrocompatibilita'.
+
+---
+
+## Azioni
+
+Ogni regola di permesso si risolve in uno tra:
+
+- `"allow"` — esegui senza approvazione
+- `"ask"` — chiedi approvazione
+- `"deny"` — blocca l'azione
+
+---
+
+## Configurazione
+
+Puoi impostare i permessi globalmente (con `*`) e sovrascrivere quelli di strumenti specifici.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "*": "ask",
+    "bash": "allow",
+    "edit": "deny"
+  }
+}
+```
+
+Puoi anche impostare tutti i permessi in una sola volta:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": "allow"
+}
+```
+
+---
+
+## Regole granulari (sintassi a oggetto)
+
+Per la maggior parte dei permessi, puoi usare un oggetto per applicare azioni diverse in base all'input dello strumento.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "npm *": "allow",
+      "rm *": "deny",
+      "grep *": "allow"
+    },
+    "edit": {
+      "*": "deny",
+      "packages/web/src/content/docs/*.mdx": "allow"
+    }
+  }
+}
+```
+
+Le regole vengono valutate per corrispondenza di pattern e **vince l'ultima regola che corrisponde**. Un pattern comune e' mettere prima la regola jolly `"*"` e poi regole piu' specifiche.
+
+### Wildcard
+
+I pattern dei permessi usano un semplice matching con wildcard:
+
+- `*` corrisponde a zero o piu' caratteri qualsiasi
+- `?` corrisponde esattamente a un carattere
+- Tutti gli altri caratteri corrispondono letteralmente
+
+### Espansione della home directory
+
+Puoi usare `~` o `$HOME` all'inizio di un pattern per riferirti alla tua home directory. Questo e' particolarmente utile per le regole [`external_directory`](#external-directories).
+
+- `~/projects/*` -> `/Users/username/projects/*`
+- `$HOME/projects/*` -> `/Users/username/projects/*`
+- `~` -> `/Users/username`
+
+### Directory esterne
+
+Usa `external_directory` per consentire chiamate a strumenti che toccano percorsi al di fuori della directory di lavoro da cui e' stato avviato OpenCode. Si applica a qualsiasi strumento che accetta un path come input (ad esempio `read`, `edit`, `glob`, `grep` e molti comandi `bash`).
+
+L'espansione della home (come `~/...`) influisce solo su come viene scritto un pattern. Non rende un percorso esterno parte della workspace corrente, quindi i path fuori dalla directory di lavoro devono comunque essere consentiti tramite `external_directory`.
+
+Per esempio, questo consente l'accesso a tutto sotto `~/projects/personal/`:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    }
+  }
+}
+```
+
+Qualsiasi directory consentita qui eredita gli stessi default della workspace corrente. Dato che [`read` di default e' `allow`](#defaults), anche le letture sono consentite per le voci sotto `external_directory` a meno di sovrascritture. Aggiungi regole esplicite quando uno strumento deve essere limitato su questi path, ad esempio bloccando le modifiche ma lasciando consentite le letture:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    },
+    "edit": {
+      "~/projects/personal/**": "deny"
+    }
+  }
+}
+```
+
+Mantieni l'elenco limitato a percorsi fidati e aggiungi regole extra di allow/deny quando serve per altri strumenti (ad esempio `bash`).
+
+---
+
+## Permessi disponibili
+
+I permessi di OpenCode sono indicizzati per nome dello strumento, piu' un paio di guardrail di sicurezza:
+
+- `read` — lettura di un file (corrisponde al percorso del file)
+- `edit` — tutte le modifiche ai file (include `edit`, `write`, `patch`)
+- `glob` — ricerca file tramite glob (corrisponde al pattern glob)
+- `grep` — ricerca nel contenuto (corrisponde al pattern regex)
+- `bash` — esecuzione comandi di shell (corrisponde a comandi parsati come `git status --porcelain`)
+- `task` — avvio subagenti (corrisponde al tipo di subagente)
+- `skill` — caricamento di una skill (corrisponde al nome della skill)
+- `lsp` — esecuzione query LSP (attualmente non granulare)
+- `webfetch` — fetch di un URL (corrisponde all'URL)
+- `websearch` — ricerca web (corrisponde alla query)
+- `external_directory` — si attiva quando uno strumento tocca percorsi fuori dalla working directory del progetto
+- `doom_loop` — si attiva quando la stessa chiamata a uno strumento si ripete 3 volte con input identico
+
+---
+
+## Default
+
+Se non specifichi nulla, OpenCode parte da default permissivi:
+
+- La maggior parte dei permessi di default e' `"allow"`.
+- `doom_loop` ed `external_directory` di default sono `"ask"`.
+- `read` e' `"allow"`, ma i file `.env` sono negati di default:
+
+```json title="opencode.json"
+{
+  "permission": {
+    "read": {
+      "*": "allow",
+      "*.env": "deny",
+      "*.env.*": "deny",
+      "*.env.example": "allow"
+    }
+  }
+}
+```
+
+---
+
+## Cosa fa "Ask"
+
+Quando OpenCode chiede approvazione, la UI offre tre esiti:
+
+- `once` — approva solo questa richiesta
+- `always` — approva richieste future che corrispondono ai pattern suggeriti (per il resto della sessione corrente di OpenCode)
+- `reject` — nega la richiesta
+
+L'insieme di pattern che `always` approverebbe e' fornito dallo strumento (ad esempio, le approvazioni per bash in genere mettono in whitelist un prefisso di comando sicuro come `git status*`).
+
+---
+
+## Agenti
+
+Puoi sovrascrivere i permessi per agente. I permessi dell'agente vengono uniti alla configurazione globale e le regole dell'agente hanno precedenza. [Scopri di piu'](/docs/agents#permissions) sui permessi degli agenti.
+
+:::note
+Fai riferimento alla sezione [Regole granulari (sintassi a oggetto)](#granular-rules-object-syntax) per esempi piu' dettagliati di pattern matching.
+:::
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "git commit *": "deny",
+      "git push *": "deny",
+      "grep *": "allow"
+    }
+  },
+  "agent": {
+    "build": {
+      "permission": {
+        "bash": {
+          "*": "ask",
+          "git *": "allow",
+          "git commit *": "ask",
+          "git push *": "deny",
+          "grep *": "allow"
+        }
+      }
+    }
+  }
+}
+```
+
+Puoi anche configurare i permessi dell'agente in Markdown:
+
+```markdown title="~/.config/opencode/agents/review.md"
+---
+description: Code review without edits
+mode: subagent
+permission:
+  edit: deny
+  bash: ask
+  webfetch: deny
+---
+
+Only analyze code and suggest changes.
+```
+
+:::tip
+Usa il pattern matching per comandi con argomenti. `"grep *"` consente `grep pattern file.txt`, mentre `"grep"` da solo lo bloccherebbe. Comandi come `git status` funzionano per il comportamento di default ma richiedono un permesso esplicito (come `"git status *"`) quando vengono passati argomenti.
+:::