Assistente IA¶

Un assistente dentro l'editor che pilota l'agente IA da riga di comando che hai già installato: spiegare, rifattorizzare, correggere, scrivere test, riassumere, tradurre e conversare, con ogni modifica proposta mostrata come un diff revisionabile che applichi di proposito.

Porta il tuo agente¶

L'assistente non ti chiede una chiave API e non ti fa accedere a nulla. Esegue invece come aiutante un agente IA da riga di comando installato localmente e riversa il suo output nell'editor. L'autenticazione, il tuo abbonamento e la scelta del modello appartengono tutti a quello strumento.

Oggi: Claude Code (claude) e Codex CLI (codex). Installane uno e accedi una volta (così che claude o codex funzioni da un terminale); l'editor lo rileva automaticamente. Viene offerto anche Gemini, ma la sua integrazione da riga di comando non è ancora verificata.
Il rilevamento è automatico e non blocca. L'editor sonda l'agente in secondo piano subito dopo l'avvio: la finestra non lo aspetta mai. Mentre la sonda gira, Visualizza → Chat IA è brevemente disattivato con un suggerimento Rilevamento del motore IA in corso…; qualche secondo dopo o si attiva (agente trovato) o resta in grigio con un suggerimento che ti dice che cosa installare.

L'agente è un programma separato che installi tu

L'editor non include né scarica alcun agente IA, e non invia da solo il tuo testo da nessuna parte: è l'agente da riga di comando che hai installato a fare la richiesta con il proprio account e la propria connessione di rete. Se l'agente non è installato o non ha eseguito l'accesso, le funzionalità IA restano semplicemente disattivate e nient'altro nell'editor ne risente.

Requisiti¶

L'assistente ha un requisito irrinunciabile: un agente IA da riga di comando supportato, installato e con l'accesso eseguito, nel PATH del tuo sistema.

Installa un agente supportato. Oggi è Claude Code (claude) oppure Codex CLI (codex).
Esegui l'accesso una volta. Avvia l'agente da un terminale e completa il suo accesso, così che poi funzioni senza interazione. L'editor non chiede né memorizza mai una chiave API: il tuo abbonamento e il tuo accesso vivono interamente in quello strumento.
Assicurati che sia nel tuo PATH. Se l'editor non riesce a eseguirlo, Visualizza → Chat IA appare in grigio con un suggerimento esplicativo.

Il pannello Chat IA¶

Non c'è un menu IA di primo livello: tutto vive in un unico pannello inferiore, attivabile da Visualizza → Chat IA. Se il pannello era aperto l'ultima volta che hai chiuso l'editor, si riapre al prossimo avvio (una volta rilevato il motore).

Dall'alto in basso, il pannello mostra:

un elenco a discesa Motore (la tua scelta viene ricordata tra le sessioni) e la casella Consenti modifiche ai file (vedi più sotto);
una riga di stato: il motore rilevato e la sua versione, una nota di sonda/avanzamento, oppure il suggerimento «installa ed esegui l'accesso». Dopo la prima risposta nomina anche il modello che l'agente ha davvero usato, ad es. Engine: Claude (2.1.200) · claude-sonnet-5 — vale un'occhiata, perché il modello decide quanto ti costa ogni esecuzione (vedi Scegliere il modello);
una sottile barra di attività con un pulsante Ferma mentre l'agente lavora;
la console: l'intera conversazione in un'unica vista;
una riga di suggerimenti che elenca i comandi disponibili come collegamenti cliccabili.

La console¶

La conversazione funziona come un terminale: la cronologia sopra, e tu digiti in fondo, dopo il prompt ›.

Invio invia; Shift+Invio inserisce un ritorno a capo, quindi le richieste su più righe funzionano.
Fare clic o digitare in un punto qualsiasi della cronologia riporta il cursore al prompt: la cronologia si può selezionare e copiare, ma mai modificare.
Esc annulla la richiesta in corso; quando non c'è nulla in esecuzione, cancella ciò che hai digitato dopo ›. Esc funziona con il fuoco in qualsiasi punto del pannello.
Ctrl+A seleziona solo la domanda che stai componendo, così che ciò che digiti dopo la sostituisca; senza nulla digitato, seleziona invece l'intera trascrizione, pronta da copiare.
Su e Giù richiamano ciò che hai chiesto prima, come fa una shell. Su sulla prima riga di ciò che stai digitando torna indietro tra le domande precedenti; Giù riavanza, e superare la più recente ti restituisce la riga a metà da cui eri partito. Dentro una richiesta su più righe si spostano semplicemente tra le sue righe, e non appena modifichi una domanda richiamata essa diventa la tua nuova bozza. La cronologia è per pannello e non viene conservata tra le sessioni.
Mentre una risposta arriva a flusso, la vista la segue se sei in fondo; scorri in su per leggere e resta ferma. Quando la risposta è completa, la vista la colloca di proposito: una risposta breve scorre fino in fondo così la vedi insieme al prompt sotto, mentre una lunga allinea la sua intestazione Assistente con la parte alta del pannello, così puoi leggere dall'inizio.
Il Markdown di ogni risposta viene reso per conto proprio, quindi gli elenchi numerati partono da 1 ogni volta invece di proseguire la numerazione della risposta precedente.

Comandi¶

Digita un comando al prompt, oppure fai clic su di esso nella riga di suggerimenti (i comandi che prendono un argomento ricevono uno spazio finale e aspettano che tu completi la riga):

Comando	Che cosa fa	Risultato
`.explain`	Spiega il codice selezionato	risposta nella chat
`.summarize`	Riassume il testo selezionato	risposta nella chat
`.refactor <how>`	Rifattorizza secondo le istruzioni (ad es. `.refactor extract a helper`)	modifica revisionabile
`.fix`	Corregge il codice selezionato	modifica revisionabile
`.tests`	Scrive test unitari per la selezione	modifica revisionabile
`.translate <language>`	Traduce la selezione (ad es. `.translate German`)	modifica revisionabile
`.model <id>`	Fissa il modello che questo editor richiede (vedi Scegliere il modello)	risposta immediata, senza eseguire l'agente

Qualsiasi altra cosa tu digiti viene trattata con naturalezza:

Il testo semplice è una domanda libera all'agente, inviata insieme a ciò che hai sullo schermo (vedi più sotto).
Una riga che inizia con / è uno dei comandi dell'agente stesso (come l'/help di Claude) e viene inoltrata esattamente come digitata: non le viene aggiunto nulla dell'editor, e non serve alcun consenso perché non viene inviato nulla di tuo. Questo vale per i motori il cui insieme di comandi è stato verificato —oggi Claude—; sugli altri, una riga con / viene trattata come una domanda normale.
Un .parola non riconosciuto non è un errore: viene inoltrato come richiesta.

Non ogni comando da riga di comando qui significa la stessa cosa che nel terminale dell'agente: alcuni richiedono una sessione interattiva che le esecuzioni dell'editor non hanno, alcuni riguardano conversazioni che l'editor già gestisce per conto suo, e alcuni —come /model— semplicemente non possono sopravvivere a una singola richiesta. Quando ne invii uno di quelli, l'editor lo inoltra comunque e aggiunge una breve nota che dice perché potrebbe non fare quello che ti aspetti. Vedrai ogni nota una volta per sessione.

Il /model dell'agente non può durare: usa .model

Ogni domanda esegue l'agente da capo, e un'esecuzione nuova parte sempre dal modello che la tua riga di comando è configurata per usare. /model … risponde «Modello impostato su … solo per questa sessione», ma quella sessione finisce nello stesso istante della risposta: la domanda successiva —anche una che prosegue la stessa conversazione— torna al modello configurato. Usa invece .model <id>; è un comando dell'editor stesso e fissa il modello per ogni domanda successiva. Vedi Scegliere il modello.

La corrispondenza non distingue maiuscole e minuscole, e la riga di suggerimenti si restringe mentre digiti (.r → .refactor …).

Selezione o intero documento¶

I comandi agiscono sulla selezione corrente. Senza selezione operano sull'intero documento; e poiché questo invia il file completo all'agente, l'editor chiede prima: Inviare l'intero documento «…» a Claude? Ti viene chiesto una volta per documento per sessione dell'editor; rifiutare annulla l'invio e conserva ciò che avevi digitato. La domanda si può disattivare in Preferenze → Assistente IA, con l'opzione Chiedi prima di inviare un intero documento al motore IA; con essa disattivata, l'intero documento viene inviato senza chiedere.

Che cosa sa l'assistente del tuo documento¶

L'agente legge i file da disco. Lasciato a sé, quindi, risponderebbe alle domande su un file che hai modificato ma non salvato usando il testo vecchio, e non vedrebbe affatto un buffer senza titolo. Per questo una domanda libera gli racconta che cosa hai davvero aperto:

Salvato e senza modifiche in sospeso — l'assistente si limita a nominare il file e lascia che l'agente lo legga. Nulla esce dall'editor, quindi non viene chiesto nulla.
Con modifiche non salvate, o un documento mai salvato — il testo corrente viene inviato insieme alla tua domanda. I documenti piccoli viaggiano nella domanda stessa; quelli più grandi vengono scritti in una copia temporanea verso cui l'agente viene puntato. La copia viene eliminata appena lo scambio termina.
Con una cartella aperta — ogni altro documento aperto con modifiche non salvate viene incluso allo stesso modo, così l'agente vede il progetto come lo vedi tu e non come è stato salvato l'ultima volta.

Poiché questo manda del testo fuori, l'editor chiede prima —una volta per documento per sessione dell'editor, e una sola volta per l'intera richiesta anche quando sono coinvolti più documenti—: Il contenuto attuale, non salvato, di questi documenti verrà inviato a Claude: …. Continuare? Rifiutare abbandona la richiesta e conserva ciò che avevi digitato.

Una selezione ha comunque la precedenza come ciò a cui stai puntando: viene inviata come Selezione rilevante insieme al documento, non al suo posto.

Nella modalità di sola lettura predefinita all'agente viene anche detto che non può cambiare il tuo documento e che una modifica va proposta tramite i comandi .refactor, .fix, .tests e .translate, che invece ti mostrano un diff.

Esaminare e applicare le modifiche¶

I comandi di modifica non riscrivono mai il tuo testo in silenzio. Quando l'agente finisce, si apre una finestra di revisione con un gruppo di modifiche selezionabile e colorato per ogni modifica: righe rimosse in rosso, righe aggiunte in verde.

deseleziona le modifiche che non vuoi;
Applica sostituisce la selezione (o l'intero documento, nel caso senza selezione) con le sole modifiche accettate;
Scarta lascia il buffer esattamente com'era.

Le modifiche applicate sono modifiche comuni, quindi Ctrl+Z le annulla come qualsiasi altra cosa. Lo stile di fine riga del tuo file (CRLF/LF) viene conservato. Se l'agente rifiuta di fare una modifica, la sua spiegazione compare come una normale risposta di chat invece che come un diff fasullo.

Se hai continuato a lavorare mentre l'agente operava, l'editor non innesta mai una modifica obsoleta sopra il tuo testo più recente. Ciò che fa invece dipende da che cosa riesce ancora a stabilire con certezza:

quello che hai digitato ha spostato il bersaglio ma lo ha lasciato intatto → la modifica viene applicata dove il testo si trova adesso;
il comando copriva l'intero documento e il documento nel frattempo è cambiato → la proposta viene confrontata con il tuo testo attuale e tu esamini quel diff, così la risposta non va sprecata;
il testo originale è sparito, oppure ora compare più volte → l'editor si tira indietro invece di indovinare, e ti dice di eseguire di nuovo il comando.

I colori del diff seguono il tuo tema di colori: i temi possono definire colori dedicati di Testo aggiunto nel diff / Testo rimosso nel diff (modificabili in Preferenze → Colorazione della sintassi → Temi), e senza di essi l'editor sceglie valori predefiniti leggibili per interfacce chiare e scure.

Conversazioni¶

Le domande libere formano una conversazione continua: l'agente ricorda le tue domande e risposte precedenti. C'è una conversazione per cartella aperta (o per file, quando non c'è alcuna cartella aperta), così progetti senza relazione non condividono contesto. I comandi di modifica (.refactor, .fix, …) girano di proposito una volta sola e non contaminano il contesto della chat. Le conversazioni non vengono conservate: riavviare l'editor ne inizia di nuove.

Sia Claude sia Codex proseguono le conversazioni. Codex dà da sé un nome a ogni conversazione e lo annuncia all'inizio; le domande successive la riprendono da lì. Se un'esecuzione di Codex termina senza averne annunciato uno, la chat mostra [impossibile proseguire la conversazione — il motore non ha comunicato alcun ID di sessione; il prossimo messaggio ne avvierà una nuova]: la risposta che hai ricevuto resta valida, ma la tua domanda successiva avvia una conversazione nuova, senza il contesto precedente.

Una conversazione sopravvive anche a ciò che va storto. Fermare una risposta la conserva, così una domanda che hai interrotto si può semplicemente riprendere: chiedi «prosegui con l'ultimo compito» e l'agente sa ancora che cosa stava facendo, anche se lo hai fermato prima che dicesse una parola. Un guasto isolato (un limite di frequenza, una connessione caduta) non getta via la cronologia; solo un secondo guasto di fila avvia una conversazione nuova.

Fermare un'esecuzione¶

Mentre l'agente lavora compare una barra di attività con un pulsante Ferma: fai clic su di esso (o premi Esc in qualsiasi punto del pannello) per annullare. Tutto ciò che era arrivato a flusso fino a quel momento resta nella trascrizione, l'esecuzione viene marcata [Annullata] e non viene applicata alcuna modifica. La conversazione viene conservata, così la tua domanda successiva la prosegue (vedi Conversazioni). Premere Invio a metà esecuzione non accoda nulla; la riga di stato ti ricorda che l'agente sta ancora lavorando.

Lasciare che l'agente modifichi i file¶

Per impostazione predefinita l'assistente è in sola lettura: ogni esecuzione avvia l'agente con i suoi strumenti di modifica dei file, l'accesso alla shell e i sottoagenti disattivati, così le modifiche ti raggiungono solo come proposte revisionabili. Per i motori con flag di permesso verificati questo è un blocco rigido imposto dall'agente stesso, comunque sia configurata la tua riga di comando:

Claude gira con i suoi strumenti di modifica dei file, l'accesso alla shell e i sottoagenti disattivati.
Codex gira nella sua sandbox in sola lettura (-s read-only). La sandbox funziona in modo diverso: non disattiva i comandi della shell, li confina — Codex può ancora eseguire comandi per guardarsi intorno, ma questi non possono scrivere nulla. Per ora l'editor chiede anche a Codex, in modo esplicito, di restare in sola lettura.

La sola lettura non è garantita per ogni motore

Il blocco rigido si affida ai flag di permesso del motore stesso. Gemini non ha ancora flag verificati, quindi l'editor può solo chiedergli —come istruzione, per quanto possibile— di restare in sola lettura; non può costringerlo. Considera la sola lettura non garantita su Gemini: potrebbe comunque scrivere su disco, e il suo comportamento è retto in ultima analisi dalla configurazione della tua riga di comando. Se la cosa ti importa, tieni quel lavoro in una cartella sotto controllo di versione.

La casella Consenti modifiche ai file (accanto all'elenco a discesa dei motori, disattivata per impostazione predefinita, ricordata tra le sessioni) abilita la modifica da parte dell'agente:

le modifiche ai file dell'agente vengono accettate automaticamente ed esso può modificare file nella cartella aperta durante un'esecuzione;
ogni scrittura viene segnalata nella conversazione come [l'agente ha modificato un file: …], e i documenti aperti recepiscono le modifiche attraverso il normale monitoraggio dei file dell'editor;
quando l'esecuzione termina, un'unica riga di riepilogo elenca l'intero insieme dei file toccati con un conteggio, ad es. [file modificati (3): …];
l'accesso di Claude alla shell e i suoi sottoagenti restano bloccati anche con l'opzione attiva.

Con Codex l'opzione porta la sua sandbox a -s workspace-write: Codex può allora modificare file, ed eseguire comandi della shell, all'interno della cartella aperta e della directory temporanea. Codex non comunica le sue modifiche all'editor, quindi la chat non elenca i file che ha cambiato e non c'è alcuna riga di riepilogo; i documenti aperti recepiscono comunque le modifiche attraverso il monitoraggio dei file. Le scritture vere e proprie le esegue la sandbox di Codex: se Codex risponde che non è riuscito ad avviare il suo esecutore di comandi, quella sandbox non funziona sul tuo computer — controlla la sua diagnostica (codex doctor), non l'editor.

Lo stesso interruttore è anche in Preferenze → Assistente IA, come Consenti al motore IA di modificare i file. Sono un'unica impostazione, non due: applicarla nelle Preferenze spunta o toglie la spunta alla casella del pannello all'istante, e ciò che imposti nel pannello è ciò che le Preferenze mostrano la volta successiva che le apri.

I documenti con modifiche non salvate vengono gestiti per te. L'agente non deve modificare il file su disco di un documento che hai cambiato ma non salvato: quella copia è superata, e scriverci sopra lascerebbe il file e il tuo editor in disaccordo. Perciò all'agente viene data la copia temporanea del tuo testo attuale da modificare, e quando l'esecuzione termina l'editor riporta il risultato nel tuo documento aperto come una modifica comune e annullabile. I documenti senza titolo funzionano allo stesso modo, pur non avendo alcun file. Se per caso hai modificato tu stesso il documento mentre l'agente lavorava, l'editor non ti sovrascrive: apre la consueta finestra di revisione rispetto al tuo testo attuale, così decidi modifica per modifica. Chiudere il documento durante l'esecuzione scarta semplicemente il lavoro dell'agente, con una nota nella conversazione.

Consenti modifiche ai file può sovrascrivere o cancellare il tuo lavoro

Con l'opzione attiva l'agente scrive direttamente su disco e quelle scritture vengono accettate automaticamente: non c'è alcuna finestra di revisione per singola modifica. L'agente può sovrascrivere, cancellare o rovinare i file della cartella aperta, e le modifiche a file che non hai aperto non ti vengono mostrate come diff. Attiva questo solo per una cartella sotto controllo di versione (Git, SVN, …): esegui prima un commit o uno stash del tuo lavoro, poi usa il diff del controllo di versione per esaminare ogni modifica e annullare ciò che non vuoi — considera il controllo di versione il tuo annulla per le modifiche dell'agente. Gemini, i cui flag di permesso non sono ancora verificati, ignora del tutto questa opzione, quindi le sue modifiche sono rette soltanto dalla configurazione della tua riga di comando.

Cambiare motore¶

All'avvio l'editor cerca ogni motore che conosce, e l'elenco a discesa Motore mostra solo quelli installati su questo computer. Se il motore che avevi scelto l'ultima volta non c'è più, il primo installato ne prende automaticamente il posto. Un motore installato mentre l'editor è in esecuzione compare dopo un riavvio. Se non è installato alcun motore, l'elenco mostra tutti i motori che l'editor conosce e il pannello resta in grigio con il suggerimento di installare ed eseguire l'accesso.

Scegli un altro agente dall'elenco a discesa Motore quando vuoi (è disattivato mentre un'esecuzione è attiva). Cambiare annulla il rilevamento del motore precedente, sonda quello nuovo in secondo piano e avvia conversazioni nuove: una chat iniziata con un motore non può essere proseguita da un altro. Il cambio svuota anche la trascrizione, perché quella conversazione apparteneva all'altro motore; ciò che avevi digitato nel campo di immissione resta.

Scegliere il modello¶

Per impostazione predefinita l'editor non richiede un modello, quindi ogni esecuzione usa quello che il tuo agente da riga di comando è configurato per usare — per Claude Code è il model nel tuo ~/.claude/settings.json personale. Spesso non è ciò che vuoi per l'editor: è una preferenza globale, può cambiare senza che tu te ne accorga, e il modello decide quanto costa ogni richiesta.

La riga di stato ti dice che cosa è stato usato davvero, così puoi sempre controllare. Per fissare un modello per l'editor stesso, digitalo nella chat:

Digiti	Che cosa succede
`.model claude-sonnet-5`	ogni domanda successiva richiede quel modello
`.model`	riporta il modello fissato e il modello davvero usato per ultimo
`.model default`	toglie il fissaggio; torna a valere il valore predefinito dell'agente

.model è gestito dall'editor: non avvia mai l'agente, quindi risponde all'istante e non costa nulla. Un fissaggio ha effetto dalla tua prossima domanda, e la riga di stato lo conferma quando arriva la risposta.

La stessa cosa si può impostare a mano, per motore, nel file delle impostazioni di OctoEdit:

Chiave	Valore	Effetto
`ai/model/<engine>`	un id di modello, ad es. `claude-sonnet-5`	ogni esecuzione usa quel modello
`ai/model/<engine>`	vuoto / assente (predefinito)	il valore predefinito dell'agente da riga di comando

<engine> è l'id del motore come appare nell'elenco a discesa, in minuscolo — ad es. ai/model/claude o ai/model/codex. Serve che il pannello faccia la richiesta successiva perché abbia effetto, poi confermalo nella riga di stato. Gemini, il cui flag di modello non è ancora verificato, ignora l'impostazione.

Impostazione avanzata correlata

ai/programPath/<engine> fa lo stesso lavoro per il binario: impostalo a un percorso assoluto quando l'agente è installato in un punto che la ricerca per PATH dell'editor non vede. Entrambe le chiavi sono di proposito vie di fuga solo da file: un valore sbagliato fallisce rumorosamente invece di essere ignorato in silenzio.

Quando un'esecuzione fallisce¶

Se l'agente termina con un errore, la chat mostra [agent exited with code N seguito dalle righe di errore dell'agente stesso e da una ] di chiusura; per Codex, il suo banner di avvio e le sue righe ERROR: …, come il 401 Unauthorized che ricevi quando non hai eseguito l'accesso. Di solito basta per capire che cosa è andato storto; avviare l'agente una volta da un terminale ti dice il resto.

Il log dell'editor (mte.log, vedi Registrazione e diagnostica) annota ogni esecuzione in righe che iniziano con AI:: quali motori sono stati trovati, il programma e gli argomenti di ogni esecuzione, il suo codice di uscita e le ultime righe di errore dell'agente quando un'esecuzione fallisce; avviare l'editor con --log=debug aggiunge il resto dell'output diagnostico dell'agente. La tua domanda e la risposta non compaiono mai nel messaggio di errore e non vengono mai scritte nel log: il log riporta solo la dimensione della domanda in byte.

Riservatezza e costo¶

Le richieste vengono inviate dall'agente da riga di comando che hai scelto, con il proprio account e la propria connessione di rete: l'editor non aggiunge telemetria né endpoint propri. (Codex ripete l'intero scambio nel suo output diagnostico; l'editor scarta quella copia e non la scrive mai nel suo log.) Che cosa viene inviato (la tua istruzione, la tua selezione o il documento, e il testo non salvato dei documenti aperti quando una domanda lo richiede) e quanto costa sono retti dall'abbonamento o dal piano di quell'agente. Nulla esce dall'editor senza l'avviso di consenso descritto sopra, e la riga di stato nomina il modello che ogni richiesta ha davvero usato.

Che cosa c'è oggi

I comandi agiscono sulla selezione corrente (o sull'intero documento, con consenso) e, quando accettati, la sostituiscono. Ci sono due livelli di autorità: il flusso in sola lettura che si limita a proporre, descritto sopra, oppure l'adesione esplicita tramite Consenti modifiche ai file. Non esiste una revisione separata, dentro l'editor, delle modifiche che l'agente fa direttamente su disco: con Consenti modifiche ai file attivo, affidati al tuo controllo di versione; l'unica eccezione è un documento aperto con modifiche non salvate, le cui modifiche tornano attraverso l'editor.