Compare commits

..
10 Commits
Author SHA1 Message Date
davideandClaude Sonnet 5.5 74abd11d3a Istruzioni per gli agenti: AGENT.md come unica sorgente, puntatori CLAUDE.md e GEMINI.md
CLAUDE.md diventa AGENT.md, pensato per qualsiasi assistente di codice.
CLAUDE.md e GEMINI.md restano come file puntatori che importano AGENT.md con
@AGENT.md, perché Claude Code e Gemini CLI cercano file con il proprio nome.
docs/README.md descrive la regola (nessun contenuto nei puntatori) e i
riferimenti nei doc sono aggiornati.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:23:05 +02:00
davideandClaude Sonnet 5.5 f0e9fcfba5 Documentazione: stato del progetto (stadio MVP)
Aggiunge docs/PROJECT_STATE.md: stadio MVP, stato per area, criteri di
accettazione con verifica manuale e automatica, debiti noti (soprattutto i
test), tabella degli ADR e proposta di cosa manca per chiudere l'MVP.
Collegato da indice dei doc, README, ROADMAP e CLAUDE.md, che chiede di
aggiornarlo a ogni cambio di stadio, funzione, ADR o debito.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:19:12 +02:00
davideandClaude Sonnet 5.5 99f6105556 Build degli eseguibili da Linux e da Windows: script PowerShell e README
Aggiunge scripts/publish.ps1, equivalente di publish.sh per Windows
PowerShell (5.1 e 7), provato su Windows nativo con SDK 10. Il README
descrive i tre passi (installare l'SDK, lanciare lo script, trovare i file
in dist/) per entrambi i sistemi, il comando dotnet publish senza script e
cosa è stato verificato. CLAUDE.md cita i due script e chiede di tenerli
allineati.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:17:23 +02:00
davideandClaude Sonnet 5.5 c0c140b08d Windows: eseguibile senza console e CLI che riaggancia il terminale
OutputType passa a WinExe: nessuna finestra di console al doppio clic. Con
argomenti Core/ConsoleHost.cs chiama AttachConsole sul terminale padre e
collega stdout e stderr a CONOUT$ solo se non sono già reindirizzati; senza
terminale padre non fa nulla. Su Linux il comportamento non cambia.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:13:01 +02:00
davideandClaude Sonnet 5.5 d4b6c3693a Documentazione: Windows senza finestra di console (ADR-0005)
Nuovo ADR-0005: su Windows l'eseguibile è senza console, così il doppio clic
mostra solo la GUI, e la CLI riaggancia il terminale padre. L'alternativa a
due file resta registrata. MVP, README e CLAUDE.md spiegano la conseguenza
sull'exit code (disponibile solo se il chiamante attende il processo, con
start /wait o Start-Process -Wait); TESTING.md aggiunge le righe WIN.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:13:01 +02:00
davideandClaude Sonnet 5.5 d7e8a341ab Script di publish e modello più piccolo con effort low come predefiniti
scripts/publish.sh crea in dist/ gli eseguibili single-file per win-x64 e
linux-x64 (o i rid indicati) e toglie i simboli delle librerie native;
dist/ è ignorata da git. Ogni motore dichiara DefaultModelId (Haiku 5.5 per
Claude Code, GPT-5.6 Luna per Codex) e il ViewModel parte da quel modello con
effort low, all'avvio e a ogni cambio di CLI; "Predefinito" resta scelta
possibile.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:03:03 +02:00
davideandClaude Sonnet 5.5 d6f293722e Documentazione: creazione degli eseguibili e valori iniziali di modello ed effort
README spiega come creare gli eseguibili Windows e Linux (scripts/publish.sh
o dotnet publish a mano), la dimensione, come usarli e l'avviso sul file non
firmato. MVP, ADR-0002, CLAUDE.md e TESTING.md (riga VM-20) indicano che
all'avvio e a ogni cambio di CLI si parte dal modello più piccolo del motore
con effort low.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 12:03:03 +02:00
davideandClaude Sonnet 5.5 8b20f5224e Impostazioni: controllo e aggiornamento dei CLI con pulsante evidenziato
Sezione Aggiornamenti nel riquadro Impostazioni: per ogni CLI installato
versione, esito del controllo (disponibile, aggiornato, non riuscito) e
pulsante Aggiorna che esegue il comando ufficiale. Il pulsante e un puntino
sul pulsante Impostazioni si evidenziano solo se c'è una versione nuova. Il
controllo legge l'ultima versione dalle sorgenti ufficiali (downloads.claude.ai
e release GitHub di Codex), parte all'avvio e all'apertura del riquadro con
cache di 5 minuti e non fallisce mai in modo invasivo. L'aggiornamento ha
tempo massimo di 10 minuti, blocca invio e cambio CLI, e in caso di errore
suggerisce il comando manuale per npm, Homebrew, WinGet o installazione nativa.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 11:49:22 +02:00
davideandClaude Sonnet 5.5 6498e45a0d Documentazione: aggiornamento dei CLI con controllo preventivo (ADR-0004)
Nuovo ADR-0004: dalle Impostazioni l'app controlla se Claude Code e Codex
hanno una versione più recente (sorgenti ufficiali, cache di 5 minuti),
evidenzia il pulsante Aggiorna solo se serve e lo esegue con il comando
ufficiale, mostrando l'esito e il comando manuale adatto al metodo di
installazione. MVP, ROADMAP, INSTALL, README, CLAUDE.md e la matrice di
TESTING.md (righe UP) sono allineati; rimossi riferimenti obsoleti a
WinForms e RunClaude.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 11:49:22 +02:00
davideandClaude Sonnet 5.5 e60d64ed58 Motori multipli: Codex e interruttore CLI nelle Impostazioni
Introduce l'astrazione Engine (Claude Code, Codex) con argomenti e parser
propri e EngineRunner come unico punto di avvio, al posto di Claude.cs. Il
JSON delle chat salva motore e id di sessione (i file vecchi restano chat di
Claude Code). Cambiare CLI apre una nuova chat; modelli ed effort seguono il
motore; un motore non installato non è selezionabile. La CLI accetta
--engine <id>. Codex gira in sola lettura e la sessione si legge da
thread.started.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-15 11:40:47 +02:00
28 changed files with 1121 additions and 116 deletions

No files matched your search

+1
View File
@@ -1,2 +1,3 @@
bin/ bin/
obj/ obj/
dist/
+58
View File
@@ -0,0 +1,58 @@
# AGENT.md
Guida per gli agenti di codice (Claude Code, Gemini CLI, altri) che lavorano in questo repository. È l'**unica sorgente** delle istruzioni: `CLAUDE.md` e `GEMINI.md` sono puntatori che importano questo file, quindi ogni modifica si fa qui (vedi [docs/README.md](docs/README.md#istruzioni-per-gli-agenti-di-codice)).
## Progetto
agent-wiki-ui (già `LlmRun`; il nome ha un'unica sorgente, vedi [docs/README.md](docs/README.md#nome-del-progetto)): eseguibile C# (.NET 10, Windows e Linux) che invoca Claude Code (`claude -p`) o Codex (`codex exec`) da terminale. Senza argomenti apre una GUI di chat Avalonia, con argomenti funziona da CLI.
## Workflow doc-first (obbligatorio)
- Stato attuale, stadio (MVP), debiti e cosa manca: [docs/PROJECT_STATE.md](docs/PROJECT_STATE.md); aggiornarlo nello stesso commit di ogni cambio di stadio, funzione, ADR o debito. Specifica e criteri di accettazione: [docs/MVP.md](docs/MVP.md). Fasi e stato: [docs/ROADMAP.md](docs/ROADMAP.md). Indice dei doc e regole (SSOT, ADR): [docs/README.md](docs/README.md); una decisione architetturale si scrive solo nel suo ADR, gli altri doc la richiamano con un link. Uso: [README.md](README.md).
- **Test obbligatori** ([docs/TESTING.md](docs/TESTING.md), [ADR-0003](docs/adr/0003-strategia-di-test.md)): ogni nuova funzione, correzione o cambio di comportamento va coperta da test nello stesso commit; prima si aggiunge la riga (con ID) alla matrice in TESTING.md, poi i test, poi il codice. Un bug si corregge partendo da un test che fallisce.
- Ad ogni richiesta di modifica: aggiornare prima i doc interessati (MVP.md, ROADMAP.md con le spunte, README.md se cambia l'uso; un nuovo ADR in `docs/adr/` per ogni scelta architetturale), poi il codice, poi questo file se cambiano comandi, design o vincoli. Nessuna modifica deve lasciare i doc disallineati.
## Comandi
- Build: `dotnet build` (agent-wiki-ui.csproj, `net10.0`, Avalonia)
- GUI: `dotnet run`; CLI: `dotnet run -- "prompt"`
- Publish single-file (uno per sistema): `scripts/publish.sh` (Linux/WSL/macOS) o `scripts/publish.ps1` (Windows PowerShell): creano `dist/win-x64/` e `dist/linux-x64/` (`dist/` è ignorata da git); i due script vanno tenuti allineati, oppure a mano `dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true` e `-r linux-x64`
- Test: non esistono ancora (pianificati, Fase 6: `dotnet test`; il piano è in docs/TESTING.md). Per verificare la GUI senza schermo si può usare `Avalonia.Headless` con `CaptureRenderedFrame()` in un progetto di prova fuori dal repo.
## Architettura
Decisioni e motivazioni negli ADR ([docs/adr/](docs/adr/)); qui solo la mappa del codice.
- [Program.cs](Program.cs): top-level statements. Con argomenti è la CLI (`EngineRunner.RunInherited`, motore scelto con `--engine <id>` come primo argomento, default Claude Code); senza avvia Avalonia (`App`).
- [Core/Engine.cs](Core/Engine.cs): astrazione "motore" (ADR-0002): `Engine` (id, nome, eseguibile, modelli, effort, `BuildArgs`, `Parse`, `FetchLatestVersionAsync` per il controllo delle versioni), `ClaudeEngine`, `CodexEngine`, registro `Engines` e ricerca nel PATH (`PathSearch`). Gli elenchi modelli sono fissi, da aggiornare quando ne escono di nuovi; `DefaultModelId` indica il modello più piccolo, scelto all'avvio insieme a effort `low` (se esce un modello più piccolo, aggiornarlo).
- [Core/EngineRunner.cs](Core/EngineRunner.cs): **unico punto di avvio dei motori** (cartella dell'exe, stdin chiuso, `ArgumentList`): CLI con output ereditato, GUI con output catturato e interpretato da `Engine.Parse`, e `RunToolAsync` per i comandi di servizio (`--version`, `update`) con tempo massimo.
- [Core/EngineUpdater.cs](Core/EngineUpdater.cs): controllo delle versioni in sola lettura (`CheckAsync`, `IsNewer`) e aggiornamento di un CLI con il suo `update` ufficiale (ADR-0004): versione prima/dopo, esito leggibile, metodo di installazione dedotto dal percorso reale e comando manuale da suggerire (l'app lo mostra, non lo esegue).
- [Core/ChatStore.cs](Core/ChatStore.cs): cronologia, un JSON per chat in `<LocalApplicationData>/<nome-app>/chats/<guid>.json` (nome file = id della chat, validato come Guid prima dell'uso; campi `Engine` e `SessionId` opzionali: i file vecchi sono chat di Claude Code).
- [Core/AppInfo.cs](Core/AppInfo.cs): nome dell'app, letto dall'`AssemblyName` del csproj (unica sorgente).
- [Gui/MainViewModel.cs](Gui/MainViewModel.cs): stato e logica della chat (invio, apertura/eliminazione, salvataggio subito all'invio e di nuovo alla risposta, riapertura dell'ultima chat all'avvio, interruttore CLI: cambiare motore apre una nuova chat; aggiornamento dei CLI con un solo aggiornamento alla volta, bloccando invio e cambio motore).
- [Gui/MainWindow.axaml](Gui/MainWindow.axaml) (+ `.cs`): layout XAML con binding compilati. [Gui/App.axaml](Gui/App.axaml): token di colore come risorse di tema chiaro/scuro e stili; specifiche in `docs/MVP.md` → "Design (UI/UX)". Cambiando l'aspetto aggiornare quella sezione.
- [Gui/MarkdownView.cs](Gui/MarkdownView.cs): renderer markdown proprio (albero Markdig → controlli Avalonia, `DisableHtml`).
- Dipendenze NuGet: Avalonia (+ Desktop, Themes.Fluent), Markdig.
## Vincoli non ovvi
- La working directory di `claude` deve essere la cartella dell'exe: usare `AppContext.BaseDirectory`, mai `Environment.CurrentDirectory` né `Assembly.Location` (vuoto in single-file).
- Lo stdin del motore va redirezionato e chiuso subito: `claude` aspetta 3 s, `codex` stampa "Reading additional input from stdin…" e attende.
- `claude` è un eseguibile nativo (`~/.local/bin`), avviabile direttamente. Se fosse `claude.cmd` (Windows) serve `cmd.exe /c`.
- Codex (`CodexEngine`): l'id di sessione lo genera Codex e si legge da `thread.started` nell'output JSONL (`--json`); la risposta è l'ultimo `agent_message`; `exec resume` non accetta `-s`, la sola lettura si impone con `-c 'sandbox_mode="read-only"'`; serve `--skip-git-repo-check` (la cartella dell'exe non è un repository); `--` prima del prompt. Dettagli e prove in ADR-0002. Il modello predefinito è quello di `~/.codex/config.toml`: se richiede un Codex più recente l'errore compare nella chat (vedi docs/INSTALL.md).
- Il controllo delle versioni contatta solo `downloads.claude.ai` (Claude Code) e `api.github.com` (Codex, serve lo User-Agent), al massimo ogni 5 minuti e in background; un errore di rete non è un errore dell'app (stato "sconosciuto").
- L'aggiornamento di un CLI è sempre un gesto esplicito dell'utente (pulsante Aggiorna): nessun aggiornamento automatico e nessun fallback che esegua npm/brew/winget al posto suo.
- Windows: l'eseguibile è `WinExe` (nessuna console al doppio clic); in modalità CLI `Core/ConsoleHost.cs` riaggancia il terminale padre con `AttachConsole` e collega stdout/stderr a `CONOUT$` solo se non sono già reindirizzati (ADR-0005). Il codice deve poter fallire in silenzio senza terminale. Conseguenza: su Windows l'exit code della CLI arriva solo se il chiamante attende il processo.
- Il nome dell'app non va scritto a mano nel codice: usare `AppInfo.Name`. Cambiare nome cambia la cartella dati (vedi checklist in docs/README.md; `ChatStore` migra le cartelle dei nomi precedenti).
- Avalonia 12: la clipboard si usa con `using Avalonia.Input.Platform;` (`SetTextAsync` è un'estensione); `TextBox.Watermark` è obsoleto, usare `PlaceholderText`.
- Nel renderer markdown i colori si risolvono al momento del rendering (`TryFindResource` con `ActualThemeVariant`) e la vista si ricostruisce al cambio di tema.
- I link nel markdown si aprono con hit-test sul testo (`TextLayout.HitTestPoint`) solo se `http(s)` e se non c'è una selezione in corso.
- Il publish single-file richiede `IncludeNativeLibrariesForSelfExtract` (nel csproj): Skia e HarfBuzz sono librerie native.
## Skill del repo
`.claude/settings.json` abilita il plugin `ui-ux-pro-max` (marketplace `nextlevelbuilder/ui-ux-pro-max-skill`). Usarlo per le modifiche alla GUI Avalonia (layout, usabilità, accessibilità).
## Commit
Messaggi di commit in italiano: titolo breve all'indicativo o in forma nominale, eventuale corpo che spiega il perché. Mantenere la riga finale `Co-Authored-By` prevista dall'ambiente. Fare commit solo su richiesta.
+2 -51
View File
@@ -1,54 +1,5 @@
# CLAUDE.md # CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. Le istruzioni per gli agenti di codice sono in [AGENT.md](AGENT.md), unica sorgente. Questo file è solo un puntatore: non aggiungere nulla qui.
## Progetto @AGENT.md
agent-wiki-ui (già `LlmRun`; il nome ha un'unica sorgente, vedi [docs/README.md](docs/README.md#nome-del-progetto)): eseguibile C# (.NET 10, Windows e Linux) che invoca Claude Code (`claude -p`) o Codex (`codex exec`) da terminale. Senza argomenti apre una GUI di chat Avalonia, con argomenti funziona da CLI.
## Workflow doc-first (obbligatorio)
- Specifica e criteri di accettazione: [docs/MVP.md](docs/MVP.md). Fasi e stato: [docs/ROADMAP.md](docs/ROADMAP.md). Indice dei doc e regole (SSOT, ADR): [docs/README.md](docs/README.md); una decisione architetturale si scrive solo nel suo ADR, gli altri doc la richiamano con un link. Uso: [README.md](README.md).
- **Test obbligatori** ([docs/TESTING.md](docs/TESTING.md), [ADR-0003](docs/adr/0003-strategia-di-test.md)): ogni nuova funzione, correzione o cambio di comportamento va coperta da test nello stesso commit; prima si aggiunge la riga (con ID) alla matrice in TESTING.md, poi i test, poi il codice. Un bug si corregge partendo da un test che fallisce.
- Ad ogni richiesta di modifica: aggiornare prima i doc interessati (MVP.md, ROADMAP.md con le spunte, README.md se cambia l'uso; un nuovo ADR in `docs/adr/` per ogni scelta architetturale), poi il codice, poi questo file se cambiano comandi, design o vincoli. Nessuna modifica deve lasciare i doc disallineati.
## Comandi
- Build: `dotnet build` (agent-wiki-ui.csproj, `net10.0`, Avalonia)
- GUI: `dotnet run`; CLI: `dotnet run -- "prompt"`
- Publish single-file (uno per sistema): `dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true` e `-r linux-x64`
- Test: non esistono ancora (pianificati, Fase 6: `dotnet test`; il piano è in docs/TESTING.md). Per verificare la GUI senza schermo si può usare `Avalonia.Headless` con `CaptureRenderedFrame()` in un progetto di prova fuori dal repo.
## Architettura
Decisioni e motivazioni negli ADR ([docs/adr/](docs/adr/)); qui solo la mappa del codice.
- [Program.cs](Program.cs): top-level statements. Con argomenti è la CLI (`EngineRunner.RunInherited`, motore scelto con `--engine <id>` come primo argomento, default Claude Code); senza avvia Avalonia (`App`).
- [Core/Engine.cs](Core/Engine.cs): astrazione "motore" (ADR-0002): `Engine` (id, nome, eseguibile, modelli, effort, `BuildArgs`, `Parse`), `ClaudeEngine`, `CodexEngine`, registro `Engines` e ricerca nel PATH (`PathSearch`). Gli elenchi modelli sono fissi, da aggiornare quando ne escono di nuovi.
- [Core/EngineRunner.cs](Core/EngineRunner.cs): **unico punto di avvio dei motori** (cartella dell'exe, stdin chiuso, `ArgumentList`), CLI con output ereditato e GUI con output catturato e interpretato da `Engine.Parse`.
- [Core/ChatStore.cs](Core/ChatStore.cs): cronologia, un JSON per chat in `<LocalApplicationData>/<nome-app>/chats/<guid>.json` (nome file = id della chat, validato come Guid prima dell'uso; campi `Engine` e `SessionId` opzionali: i file vecchi sono chat di Claude Code).
- [Core/AppInfo.cs](Core/AppInfo.cs): nome dell'app, letto dall'`AssemblyName` del csproj (unica sorgente).
- [Gui/MainViewModel.cs](Gui/MainViewModel.cs): stato e logica della chat (invio, apertura/eliminazione, salvataggio subito all'invio e di nuovo alla risposta, riapertura dell'ultima chat all'avvio, interruttore CLI: cambiare motore apre una nuova chat).
- [Gui/MainWindow.axaml](Gui/MainWindow.axaml) (+ `.cs`): layout XAML con binding compilati. [Gui/App.axaml](Gui/App.axaml): token di colore come risorse di tema chiaro/scuro e stili; specifiche in `docs/MVP.md` → "Design (UI/UX)". Cambiando l'aspetto aggiornare quella sezione.
- [Gui/MarkdownView.cs](Gui/MarkdownView.cs): renderer markdown proprio (albero Markdig → controlli Avalonia, `DisableHtml`).
- Dipendenze NuGet: Avalonia (+ Desktop, Themes.Fluent), Markdig.
## Vincoli non ovvi
- La working directory di `claude` deve essere la cartella dell'exe: usare `AppContext.BaseDirectory`, mai `Environment.CurrentDirectory` né `Assembly.Location` (vuoto in single-file).
- Lo stdin del motore va redirezionato e chiuso subito: `claude` aspetta 3 s, `codex` stampa "Reading additional input from stdin…" e attende.
- `claude` è un eseguibile nativo (`~/.local/bin`), avviabile direttamente. Se fosse `claude.cmd` (Windows) serve `cmd.exe /c`.
- Codex (`CodexEngine`): l'id di sessione lo genera Codex e si legge da `thread.started` nell'output JSONL (`--json`); la risposta è l'ultimo `agent_message`; `exec resume` non accetta `-s`, la sola lettura si impone con `-c 'sandbox_mode="read-only"'`; serve `--skip-git-repo-check` (la cartella dell'exe non è un repository); `--` prima del prompt. Dettagli e prove in ADR-0002. Il modello predefinito è quello di `~/.codex/config.toml`: se richiede un Codex più recente l'errore compare nella chat (vedi docs/INSTALL.md).
- Il nome dell'app non va scritto a mano nel codice: usare `AppInfo.Name`. Cambiare nome cambia la cartella dati (vedi checklist in docs/README.md; `ChatStore` migra le cartelle dei nomi precedenti).
- Avalonia 12: la clipboard si usa con `using Avalonia.Input.Platform;` (`SetTextAsync` è un'estensione); `TextBox.Watermark` è obsoleto, usare `PlaceholderText`.
- Nel renderer markdown i colori si risolvono al momento del rendering (`TryFindResource` con `ActualThemeVariant`) e la vista si ricostruisce al cambio di tema.
- I link nel markdown si aprono con hit-test sul testo (`TextLayout.HitTestPoint`) solo se `http(s)` e se non c'è una selezione in corso.
- Il publish single-file richiede `IncludeNativeLibrariesForSelfExtract` (nel csproj): Skia e HarfBuzz sono librerie native.
## Skill del repo
`.claude/settings.json` abilita il plugin `ui-ux-pro-max` (marketplace `nextlevelbuilder/ui-ux-pro-max-skill`). Usarlo per le modifiche alla GUI WinForms (layout, usabilità, accessibilità).
## Commit
Messaggi di commit in italiano: titolo breve all'indicativo o in forma nominale, eventuale corpo che spiega il perché. Mantenere la riga finale `Co-Authored-By` prevista dall'ambiente. Fare commit solo su richiesta.
+8 -3
View File
@@ -3,7 +3,12 @@ using System.Text.Json;
namespace AgentWikiUi.Core; namespace AgentWikiUi.Core;
record Msg(string Role, string Text); // Role: user | ai | err record Msg(string Role, string Text); // Role: user | ai | err
record Stored(string Id, string Title, DateTime Updated, bool Started, List<Msg> Messages); // Engine e SessionId mancano nei file scritti prima dei motori multipli: valgono Claude Code e SessionId = Id.
record Stored(string Id, string Title, DateTime Updated, bool Started, List<Msg> Messages, string? Engine = null, string? SessionId = null)
{
public string EngineId => Engine ?? "claude";
public string? EffectiveSessionId => SessionId ?? (EngineId == "claude" ? Id : null);
}
// Cronologia: un JSON per chat, il nome file è l'id di sessione di `claude`. // Cronologia: un JSON per chat, il nome file è l'id di sessione di `claude`.
static class ChatStore static class ChatStore
@@ -32,13 +37,13 @@ static class ChatStore
// L'id può arrivare dalla UI e diventa un nome file: accettare solo Guid. // L'id può arrivare dalla UI e diventa un nome file: accettare solo Guid.
static string? PathFor(string id) => Guid.TryParse(id, out var g) ? Path.Combine(Dir, g.ToString() + ".json") : null; static string? PathFor(string id) => Guid.TryParse(id, out var g) ? Path.Combine(Dir, g.ToString() + ".json") : null;
public static void Save(string id, bool started, List<Msg> messages) public static void Save(string id, string engine, string? sessionId, bool started, List<Msg> messages)
{ {
if (messages.Count == 0) return; if (messages.Count == 0) return;
Directory.CreateDirectory(Dir); Directory.CreateDirectory(Dir);
var first = messages.First(m => m.Role == "user").Text.ReplaceLineEndings(" ").Trim(); var first = messages.First(m => m.Role == "user").Text.ReplaceLineEndings(" ").Trim();
var title = first.Length > 50 ? first[..50] + "…" : first; var title = first.Length > 50 ? first[..50] + "…" : first;
File.WriteAllText(PathFor(id)!, JsonSerializer.Serialize(new Stored(id, title, DateTime.Now, started, messages))); File.WriteAllText(PathFor(id)!, JsonSerializer.Serialize(new Stored(id, title, DateTime.Now, started, messages, engine, sessionId)));
} }
public static Stored? Load(string id) public static Stored? Load(string id)
+40
View File
@@ -0,0 +1,40 @@
using System.Runtime.InteropServices;
namespace AgentWikiUi.Core;
// Su Windows l'eseguibile è senza console (WinExe, ADR-0005). In modalità CLI si riaggancia il terminale
// da cui parte, così l'output è visibile; senza terminale padre non succede nulla.
static class ConsoleHost
{
const int AttachParentProcess = -1;
const int StdOutput = -11, StdError = -12;
const uint GenericReadWrite = 0xC0000000, ShareReadWrite = 3, OpenExisting = 3;
static readonly nint InvalidHandle = -1;
[DllImport("kernel32.dll", SetLastError = true)] static extern bool AttachConsole(int processId);
[DllImport("kernel32.dll", SetLastError = true)] static extern nint GetStdHandle(int stdHandle);
[DllImport("kernel32.dll", SetLastError = true)] static extern bool SetStdHandle(int stdHandle, nint handle);
[DllImport("kernel32.dll", EntryPoint = "CreateFileW", SetLastError = true, CharSet = CharSet.Unicode)]
static extern nint CreateFile(string name, uint access, uint share, nint security, uint disposition, uint flags, nint template);
public static void AttachToParent()
{
if (!OperatingSystem.IsWindows()) return;
try
{
if (!AttachConsole(AttachParentProcess)) return; // nessun terminale padre (doppio clic, avvio da altro programma)
Connect(StdOutput);
Connect(StdError);
}
catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException) { }
}
// Collega l'handle alla console solo se non è già valido: un file o una pipe ereditati (> file, | altro) restano com'erano.
static void Connect(int std)
{
var current = GetStdHandle(std);
if (current != 0 && current != InvalidHandle) return;
var console = CreateFile("CONOUT$", GenericReadWrite, ShareReadWrite, 0, OpenExisting, 0, 0);
if (console != InvalidHandle) SetStdHandle(std, console);
}
}
+188
View File
@@ -0,0 +1,188 @@
using System.Text.Json;
using System.Net.Http.Headers;
namespace AgentWikiUi.Core;
record ModelOption(string Label, string Id);
/// <summary>Esito di un messaggio: testo, id di sessione appreso dall'output (se il motore lo sceglie lui) o errore.</summary>
record EngineReply(string Text, string? SessionId, string? Error);
/// <summary>Un motore CLI (Claude Code, Codex): come si avvia, cosa si può scegliere, come si legge l'output. Vedi ADR-0002.</summary>
abstract class Engine
{
/// <summary>Identificatore stabile, salvato nei JSON delle chat e usato da <c>--engine</c>.</summary>
public abstract string Id { get; }
public abstract string Name { get; }
/// <summary>Etichetta sulle risposte ("Claude", "Codex").</summary>
public abstract string Author { get; }
public abstract string Executable { get; }
public abstract ModelOption[] Models { get; }
public abstract string[] Efforts { get; }
/// <summary>Modello scelto all'avvio e a ogni cambio di CLI: il più piccolo, per risposte rapide ed economiche.</summary>
public abstract string DefaultModelId { get; }
public string DefaultEffort => "low";
/// <summary>True se l'id di sessione lo genera il motore e l'app lo legge dall'output.</summary>
public abstract bool OwnsSessionId { get; }
/// <param name="structured">true = GUI (output catturato e da interpretare); false = CLI (output ereditato).</param>
public abstract List<string> BuildArgs(string prompt, string? sessionId, bool resume, string model, string effort, bool structured);
public abstract EngineReply Parse(int code, string stdout, string stderr);
/// <summary>Testo che annuncia l'ultima versione pubblicata (sola lettura, vedi ADR-0004). Eccezioni di rete/formato: le gestisce il chiamante.</summary>
public abstract Task<string?> FetchLatestVersionAsync(HttpClient http, CancellationToken ct);
public bool IsInstalled() => PathSearch.Find(Executable) is not null;
protected string Failed(int code, string detail) => $"{Executable} è uscito con codice {code}\n{detail}".Trim();
}
sealed class ClaudeEngine : Engine
{
public override string Id => "claude";
public override string Name => "Claude Code";
public override string Author => "Claude";
public override string Executable => "claude";
public override bool OwnsSessionId => false;
// Da aggiornare quando escono nuovi modelli.
public override ModelOption[] Models { get; } =
[
new("Fable 5.1", "claude-fable-5-1"),
new("Opus 5.5", "claude-opus-5-5"),
new("Sonnet 5.5", "claude-sonnet-5-5"),
new("Haiku 5.5", "claude-haiku-5-5"),
];
public override string[] Efforts { get; } = ["low", "medium", "high", "xhigh", "max"];
public override string DefaultModelId => "claude-haiku-5-5";
public override List<string> BuildArgs(string prompt, string? sessionId, bool resume, string model, string effort, bool structured)
{
var args = new List<string> { "-p", prompt };
if (sessionId is not null) args.AddRange([resume ? "--resume" : "--session-id", sessionId]);
if (model != "") args.AddRange(["--model", model]);
if (effort != "") args.AddRange(["--effort", effort]);
return args;
}
public override EngineReply Parse(int code, string stdout, string stderr) =>
code == 0 ? new(stdout.Trim(), null, null) : new("", null, Failed(code, stderr.Trim()));
// Stessa sorgente dell'installer nativo: un file di testo con la versione.
public override async Task<string?> FetchLatestVersionAsync(HttpClient http, CancellationToken ct) =>
(await http.GetStringAsync("https://downloads.claude.ai/claude-code-releases/latest", ct)).Trim();
}
sealed class CodexEngine : Engine
{
public override string Id => "codex";
public override string Name => "Codex";
public override string Author => "Codex";
public override string Executable => "codex";
public override bool OwnsSessionId => true;
// Il catalogo di Codex è dinamico (~/.codex/models_cache.json): elenco fisso, da aggiornare.
public override ModelOption[] Models { get; } =
[
new("GPT-5.6 Sol", "gpt-5.6-sol"),
new("GPT-5.6 Terra", "gpt-5.6-terra"),
new("GPT-5.6 Luna", "gpt-5.6-luna"),
];
public override string[] Efforts { get; } = ["low", "medium", "high", "xhigh", "max"];
public override string DefaultModelId => "gpt-5.6-luna";
public override List<string> BuildArgs(string prompt, string? sessionId, bool resume, string model, string effort, bool structured)
{
var args = new List<string> { "exec" };
var resuming = resume && sessionId is not null;
if (resuming) args.Add("resume");
if (structured) args.Add("--json");
args.Add("--skip-git-repo-check");
// `exec resume` non accetta -s: la sola lettura si impone con la configurazione
if (resuming) args.AddRange(["-c", "sandbox_mode=\"read-only\""]);
else args.AddRange(["-s", "read-only"]);
if (model != "") args.AddRange(["-m", model]);
if (effort != "") args.AddRange(["-c", $"model_reasoning_effort={effort}"]);
if (resuming) args.Add(sessionId!);
args.AddRange(["--", prompt]); // `--`: un prompt che inizia con "-" non è un'opzione
return args;
}
// stdout è JSONL: thread.started (id), item.completed/agent_message (testo), turn.failed/error (errore).
public override EngineReply Parse(int code, string stdout, string stderr)
{
string? threadId = null, lastMessage = null, error = null;
foreach (var line in stdout.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
{
try
{
using var doc = JsonDocument.Parse(line);
var e = doc.RootElement;
switch (e.GetProperty("type").GetString())
{
case "thread.started": threadId = e.GetProperty("thread_id").GetString(); break;
case "item.completed" when e.GetProperty("item").GetProperty("type").GetString() == "agent_message":
lastMessage = e.GetProperty("item").GetProperty("text").GetString(); break;
case "turn.failed": error = InnerMessage(e.GetProperty("error").GetProperty("message").GetString()); break;
case "error": error ??= InnerMessage(e.GetProperty("message").GetString()); break;
}
}
catch (Exception ex) when (ex is JsonException or KeyNotFoundException or InvalidOperationException) { } // riga non JSON o evento sconosciuto
}
if (code != 0) return new("", threadId, Failed(code, error ?? stderr.Trim()));
if (string.IsNullOrWhiteSpace(lastMessage)) return new("", threadId, error ?? "codex non ha restituito nessuna risposta.");
return new(lastMessage.Trim(), threadId, null);
}
// Ultima release su GitHub: tag_name tipo "rust-v0.162.1". L'API richiede lo User-Agent (impostato dal chiamante).
public override async Task<string?> FetchLatestVersionAsync(HttpClient http, CancellationToken ct)
{
using var req = new HttpRequestMessage(HttpMethod.Get, "https://api.github.com/repos/openai/codex/releases/latest");
req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.github+json"));
using var resp = await http.SendAsync(req, ct);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync(ct));
return doc.RootElement.GetProperty("tag_name").GetString();
}
// L'errore arriva come stringa che contiene un JSON {"error":{"message":…}}: si mostra il messaggio interno.
static string? InnerMessage(string? raw)
{
if (raw is null) return null;
try
{
using var doc = JsonDocument.Parse(raw);
return doc.RootElement.GetProperty("error").GetProperty("message").GetString() ?? raw;
}
catch (Exception ex) when (ex is JsonException or KeyNotFoundException or InvalidOperationException) { return raw; }
}
}
static class Engines
{
public static readonly Engine Claude = new ClaudeEngine();
public static readonly Engine Codex = new CodexEngine();
public static readonly Engine[] All = [Claude, Codex];
public static Engine? Find(string? id) => All.FirstOrDefault(e => e.Id == id);
}
static class PathSearch
{
// Su Windows i motori si avviano direttamente: solo .exe (niente script .cmd, vedi ADR-0002).
public static string? Find(string name)
{
var file = OperatingSystem.IsWindows() ? name + ".exe" : name;
foreach (var dir in (Environment.GetEnvironmentVariable("PATH") ?? "").Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries))
{
try
{
var full = Path.Combine(dir.Trim('"'), file);
if (File.Exists(full)) return full;
}
catch (ArgumentException) { } // voce del PATH non valida
}
return null;
}
}
+72
View File
@@ -0,0 +1,72 @@
using System.Diagnostics;
namespace AgentWikiUi.Core;
// Unico punto di avvio dei motori, condiviso da CLI e GUI.
static class EngineRunner
{
public static ProcessStartInfo CreateStart(Engine engine, string prompt, bool captured, string? sessionId = null, bool resume = false, string model = "", string effort = "") =>
CreateStart(engine, engine.BuildArgs(prompt, sessionId, resume, model, effort, structured: captured), captured);
public static ProcessStartInfo CreateStart(Engine engine, IEnumerable<string> args, bool captured)
{
var psi = new ProcessStartInfo(engine.Executable)
{
WorkingDirectory = AppContext.BaseDirectory, // mai la cwd del chiamante né Assembly.Location (vuoto in single-file)
UseShellExecute = false,
RedirectStandardInput = true, // chiuso subito dal chiamante: evita l'attesa di stdin del motore
RedirectStandardOutput = captured,
RedirectStandardError = captured,
CreateNoWindow = true,
};
foreach (var a in args) psi.ArgumentList.Add(a);
return psi;
}
// CLI: stdout/stderr ereditati (streaming), exit code propagato, 127 se l'eseguibile manca.
public static int RunInherited(Engine engine, string prompt)
{
try
{
using var p = Process.Start(CreateStart(engine, prompt, captured: false))!;
p.StandardInput.Close();
p.WaitForExit();
return p.ExitCode;
}
catch (System.ComponentModel.Win32Exception)
{
Console.Error.WriteLine($"'{engine.Executable}' non trovato nel PATH.");
return 127;
}
}
// GUI: output catturato e interpretato dal motore. Win32Exception se l'eseguibile non è nel PATH.
public static async Task<EngineReply> RunCapturedAsync(Engine engine, string prompt, string? sessionId, bool resume, string model, string effort)
{
using var p = Process.Start(CreateStart(engine, prompt, captured: true, sessionId, resume, model, effort))!;
p.StandardInput.Close();
var o = p.StandardOutput.ReadToEndAsync();
var e = p.StandardError.ReadToEndAsync();
await p.WaitForExitAsync();
return engine.Parse(p.ExitCode, await o, await e);
}
// Comandi di servizio del motore (--version, update): output catturato, tempo massimo, nessuna chat.
// Win32Exception se l'eseguibile non è nel PATH; allo scadere il processo e i suoi figli sono terminati.
public static async Task<(int Code, string Out, string Err, bool TimedOut)> RunToolAsync(Engine engine, IEnumerable<string> args, TimeSpan timeout)
{
using var p = Process.Start(CreateStart(engine, args, captured: true))!;
p.StandardInput.Close();
var o = p.StandardOutput.ReadToEndAsync();
var e = p.StandardError.ReadToEndAsync();
using var cts = new CancellationTokenSource(timeout);
try { await p.WaitForExitAsync(cts.Token); }
catch (OperationCanceledException)
{
try { p.Kill(entireProcessTree: true); } catch (InvalidOperationException) { }
await p.WaitForExitAsync();
return (-1, await o, await e, true);
}
return (p.ExitCode, await o, await e, false);
}
}
+131
View File
@@ -0,0 +1,131 @@
using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.RegularExpressions;
namespace AgentWikiUi.Core;
enum InstallMethod { Native, Npm, Homebrew, WinGet }
/// <summary>Esito del controllo (sola lettura): versione installata (riga di `--version`), ultima pubblicata e se è più nuova. Available null = sconosciuto.</summary>
record UpdateCheck(string? InstalledText, string? Latest, bool? Available);
/// <summary>Esito di un aggiornamento: messaggio da mostrare e, se riuscito, le versioni prima e dopo.</summary>
record UpdateOutcome(bool Ok, string Message, string? Before, string? After);
// Aggiornamento di un CLI con il suo comando ufficiale (`<cli> update`). Vedi ADR-0004.
static class EngineUpdater
{
public static readonly TimeSpan UpdateTimeout = TimeSpan.FromMinutes(10);
static readonly TimeSpan VersionTimeout = TimeSpan.FromSeconds(30);
static readonly TimeSpan CheckTimeout = TimeSpan.FromSeconds(10);
static readonly HttpClient SharedHttp = NewHttp();
static HttpClient NewHttp()
{
var http = new HttpClient { Timeout = CheckTimeout };
http.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(AppInfo.Name, "1.0")); // GitHub lo richiede
return http;
}
/// <summary>Primo numero N.N.N del testo ("2.1.300 (Claude Code)", "codex-cli 0.162.1", "rust-v0.162.1").</summary>
public static Version? ParseVersion(string? text)
{
var m = text is null ? null : Regex.Match(text, @"\d+\.\d+\.\d+");
return m is { Success: true } && Version.TryParse(m.Value, out var v) ? v : null;
}
/// <summary>true se <paramref name="latest"/> è più nuova di <paramref name="installed"/>; null se una delle due non si legge.</summary>
public static bool? IsNewer(string? latest, string? installed) =>
ParseVersion(latest) is { } l && ParseVersion(installed) is { } i ? l > i : null;
/// <summary>Controlla se c'è una versione più nuova senza installare nulla. Mai eccezioni: rete o formato inattesi ⇒ sconosciuto.</summary>
public static async Task<UpdateCheck> CheckAsync(Engine engine, HttpClient? http = null)
{
var installed = await GetVersionAsync(engine);
string? latest = null;
try
{
using var cts = new CancellationTokenSource(CheckTimeout);
latest = await engine.FetchLatestVersionAsync(http ?? SharedHttp, cts.Token);
}
catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or OperationCanceledException or JsonException or KeyNotFoundException or InvalidOperationException) { }
return new(installed, latest, IsNewer(latest, installed));
}
/// <summary>Prima riga di `--version` ripulita; null se l'eseguibile manca o fallisce.</summary>
public static async Task<string?> GetVersionAsync(Engine engine, TimeSpan? timeout = null)
{
try
{
var r = await EngineRunner.RunToolAsync(engine, ["--version"], timeout ?? VersionTimeout);
if (r.TimedOut || r.Code != 0) return null;
return r.Out.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).FirstOrDefault();
}
catch (System.ComponentModel.Win32Exception) { return null; }
}
public static async Task<UpdateOutcome> UpdateAsync(Engine engine, TimeSpan? timeout = null)
{
var before = await GetVersionAsync(engine);
(int Code, string Out, string Err, bool TimedOut) r;
try { r = await EngineRunner.RunToolAsync(engine, ["update"], timeout ?? UpdateTimeout); }
catch (System.ComponentModel.Win32Exception)
{
return new(false, $"'{engine.Executable}' non trovato nel PATH.", before, null);
}
var manual = ManualCommand(engine, DetectMethod(PathSearch.Find(engine.Executable)));
if (r.TimedOut) return new(false, $"Aggiornamento interrotto: più di {Elapsed(timeout ?? UpdateTimeout)}.\nComando manuale: {manual}", before, null);
if (r.Code != 0) return new(false, $"Aggiornamento non riuscito (codice {r.Code}).\n{Tail(r.Err, r.Out)}\nComando manuale: {manual}".Replace("\n\n", "\n"), before, null);
var after = await GetVersionAsync(engine);
if (before is not null && after is not null && before != after) return new(true, $"Aggiornato da {before} a {after}.", before, after);
return new(true, $"Già aggiornato ({after ?? before ?? "versione sconosciuta"}).", before, after);
}
static string Elapsed(TimeSpan t) => t.TotalMinutes >= 1 ? $"{t.TotalMinutes:0} minuti" : $"{t.TotalSeconds:0} secondi";
// Ultime righe utili dell'output (stderr se c'è, altrimenti stdout).
static string Tail(string err, string output)
{
var text = string.IsNullOrWhiteSpace(err) ? output : err;
return string.Join('\n', text.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).TakeLast(4));
}
/// <summary>Metodo di installazione dedotto dal percorso dell'eseguibile, anche dopo aver risolto i collegamenti simbolici.</summary>
public static InstallMethod DetectMethod(string? path)
{
if (path is null) return InstallMethod.Native;
foreach (var p in new[] { path, RealPath(path) })
{
if (Has(p, "node_modules") || Has(p, ".npm")) return InstallMethod.Npm;
if (Has(p, "Cellar") || Has(p, "homebrew") || Has(p, "linuxbrew")) return InstallMethod.Homebrew;
if (Has(p, "WinGet") || Has(p, "WindowsApps")) return InstallMethod.WinGet;
}
return InstallMethod.Native;
}
static bool Has(string path, string part) => path.Contains(part, StringComparison.OrdinalIgnoreCase);
static string RealPath(string path)
{
try { return new FileInfo(path).ResolveLinkTarget(returnFinalTarget: true)?.FullName ?? path; }
catch (IOException) { return path; }
}
/// <summary>Comando da eseguire a mano quando l'aggiornamento automatico non basta (tabella dell'ADR-0004).</summary>
public static string ManualCommand(Engine engine, InstallMethod method) => (engine.Id, method) switch
{
("claude", InstallMethod.Npm) => "npm install -g @anthropic-ai/claude-code@latest",
("claude", InstallMethod.Homebrew) => "brew upgrade claude-code",
("claude", InstallMethod.WinGet) => "winget upgrade Anthropic.ClaudeCode",
("claude", _) => "claude update",
("codex", InstallMethod.Npm) => "npm install -g @openai/codex@latest",
("codex", InstallMethod.Homebrew) => "brew upgrade --cask codex",
("codex", _) => OperatingSystem.IsWindows()
? "powershell -ExecutionPolicy ByPass -c \"irm https://chatgpt.com/codex/install.ps1 | iex\""
: "curl -fsSL https://chatgpt.com/codex/install.sh | sh",
_ => $"{engine.Executable} update",
};
}
+5
View File
@@ -0,0 +1,5 @@
# GEMINI.md
Le istruzioni per gli agenti di codice sono in [AGENT.md](AGENT.md), unica sorgente. Questo file è solo un puntatore: non aggiungere nulla qui.
@AGENT.md
+25
View File
@@ -57,6 +57,24 @@
<Setter Property="Background" Value="{DynamicResource Bg}" /> <Setter Property="Background" Value="{DynamicResource Bg}" />
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" /> <Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
</Style> </Style>
<Style Selector="Button.ghost.primary">
<Setter Property="Background" Value="{DynamicResource Accent}" />
<Setter Property="Foreground" Value="{DynamicResource OnAccent}" />
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
</Style>
<Style Selector="Button.ghost.primary:pointerover /template/ ContentPresenter">
<Setter Property="Background" Value="{DynamicResource Accent}" />
<Setter Property="Foreground" Value="{DynamicResource OnAccent}" />
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
<Setter Property="Opacity" Value="0.88" />
</Style>
<Style Selector="TextBlock.check">
<Setter Property="Foreground" Value="{DynamicResource FgMuted}" />
</Style>
<Style Selector="TextBlock.check.avail">
<Setter Property="Foreground" Value="{DynamicResource Accent}" />
<Setter Property="FontWeight" Value="SemiBold" />
</Style>
<Style Selector="Button.mini"> <Style Selector="Button.mini">
<Setter Property="FontSize" Value="12" /> <Setter Property="FontSize" Value="12" />
<Setter Property="Padding" Value="8,2" /> <Setter Property="Padding" Value="8,2" />
@@ -93,6 +111,13 @@
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" /> <Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
</Style> </Style>
<Style Selector="SelectableTextBlock.status">
<Setter Property="Foreground" Value="{DynamicResource FgMuted}" />
</Style>
<Style Selector="SelectableTextBlock.status.err">
<Setter Property="Foreground" Value="{DynamicResource Err}" />
</Style>
<Style Selector="Border.item"> <Style Selector="Border.item">
<Setter Property="CornerRadius" Value="10" /> <Setter Property="CornerRadius" Value="10" />
<Setter Property="Margin" Value="8,1" /> <Setter Property="Margin" Value="8,1" />
+183 -28
View File
@@ -4,32 +4,74 @@ using AgentWikiUi.Core;
namespace AgentWikiUi.Gui; namespace AgentWikiUi.Gui;
class MessageVm(string role, string text) class MessageVm(string role, string text, string author)
{ {
public string Role { get; } = role; public string Role { get; } = role;
public string Text { get; } = text; public string Text { get; } = text;
public string Author { get; } = author;
public bool IsUser => Role == "user"; public bool IsUser => Role == "user";
public bool IsAi => Role == "ai"; public bool IsAi => Role == "ai";
public bool IsErr => Role == "err"; public bool IsErr => Role == "err";
} }
class ChatItem(string id, string title, DateTime updated, bool active) class ChatItem(string id, string title, DateTime updated, bool active, string engineName)
{ {
public string Id { get; } = id; public string Id { get; } = id;
public string Title { get; } = title; public string Title { get; } = title;
public string When { get; } = updated.ToString("d MMM HH:mm"); public string When { get; } = $"{engineName} · {updated:d MMM HH:mm}";
public bool IsActive { get; } = active; public bool IsActive { get; } = active;
} }
/// <summary>Voce dell'interruttore CLI: un motore non installato è mostrato ma non selezionabile. Porta anche versione ed esito dell'ultimo aggiornamento.</summary>
class EngineChoice(Engine engine) : ObservableObject
{
string version = "";
string status = "";
bool statusIsError;
bool? available;
string? latest;
public Engine Engine { get; } = engine;
public bool Installed { get; } = engine.IsInstalled();
public string Name => Engine.Name;
public string Label => Installed ? Engine.Name : $"{Engine.Name} (non installato)";
public string Version { get => version; set => Set(ref version, value); }
public string Status { get => status; set { if (Set(ref status, value)) Raise(nameof(HasStatus)); } }
public bool HasStatus => status != "";
public bool StatusIsError { get => statusIsError; set => Set(ref statusIsError, value); }
/// <summary>Esito del controllo: true = c'è una versione nuova, false = aggiornato, null = non controllato o sconosciuto.</summary>
public bool? Available { get => available; private set { if (Set(ref available, value)) { Raise(nameof(UpdateAvailable)); Raise(nameof(CheckText)); } } }
public bool UpdateAvailable => available == true;
public string CheckText => available switch
{
true => $"Aggiornamento disponibile: {latest}",
false => "Aggiornato",
null => checkedOnce ? "Controllo non riuscito" : "",
};
bool checkedOnce;
public void SetCheck(bool? isAvailable, string? latestVersion)
{
latest = latestVersion; checkedOnce = true;
Raise(nameof(CheckText));
Available = isAvailable;
}
}
class MainViewModel : ObservableObject class MainViewModel : ObservableObject
{ {
static readonly ModelOption Default = new("Predefinito", ""); static readonly ModelOption Default = new("Predefinito", "");
static readonly ModelOption Custom = new("Altro ID…", "__custom"); static readonly ModelOption Custom = new("Altro ID…", "__custom");
const string NoEffort = "Predefinito";
public ObservableCollection<MessageVm> Messages { get; } = []; public ObservableCollection<MessageVm> Messages { get; } = [];
public ObservableCollection<ChatItem> Chats { get; } = []; public ObservableCollection<ChatItem> Chats { get; } = [];
public ModelOption[] ModelChoices { get; } = [Default, .. Catalog.Models, Custom]; public EngineChoice[] EngineChoices { get; } = Engines.All.Select(e => new EngineChoice(e)).ToArray();
public string[] EffortChoices { get; } = ["Predefinito", .. Catalog.Efforts]; /// <summary>Righe della sezione Aggiornamenti: solo i CLI installati.</summary>
public EngineChoice[] InstalledEngines => EngineChoices.Where(c => c.Installed).ToArray();
/// <summary>Puntino sul pulsante Impostazioni quando almeno un CLI ha una versione nuova.</summary>
public bool AnyUpdateAvailable => EngineChoices.Any(c => c.UpdateAvailable);
public ICommand NewChatCommand => newChat; public ICommand NewChatCommand => newChat;
public ICommand CopyCommand { get; } public ICommand CopyCommand { get; }
@@ -37,43 +79,63 @@ class MainViewModel : ObservableObject
public ICommand OpenCommand { get; } public ICommand OpenCommand { get; }
public ICommand DeleteCommand { get; } public ICommand DeleteCommand { get; }
public ICommand ToggleSidebarCommand { get; } public ICommand ToggleSidebarCommand { get; }
public ICommand UpdateCommand { get; }
/// <summary>Conferma di eliminazione, fornita dalla finestra.</summary> /// <summary>Conferma di eliminazione, fornita dalla finestra.</summary>
public Func<Task<bool>> ConfirmDelete { get; set; } = () => Task.FromResult(true);
/// <summary>Copia negli appunti, fornita dalla finestra.</summary> /// <summary>Copia negli appunti, fornita dalla finestra.</summary>
public Func<string, Task> CopyText { get; set; } = _ => Task.CompletedTask; public Func<string, Task> CopyText { get; set; } = _ => Task.CompletedTask;
public Func<Task<bool>> ConfirmDelete { get; set; } = () => Task.FromResult(true);
/// <summary>Chiesto alla finestra di rimettere il fuoco sul campo messaggio.</summary> /// <summary>Chiesto alla finestra di rimettere il fuoco sul campo messaggio.</summary>
public event Action? FocusInput; public event Action? FocusInput;
string sessionId = Guid.NewGuid().ToString(); // Una chat = un motore. chatId è il nome del file; sessionId è l'id del motore:
bool started; // true dopo il primo messaggio riuscito: da lì in poi --resume // per Claude Code lo sceglie l'app (= chatId), per Codex arriva dall'output dopo il primo messaggio.
string chatId = Guid.NewGuid().ToString();
string? sessionId;
bool started; // true dopo il primo messaggio riuscito: da lì in poi si riprende la sessione
List<Msg> history = []; List<Msg> history = [];
EngineChoice selectedEngine;
ModelOption[] modelChoices = [];
string[] effortChoices = [];
string input = ""; string input = "";
bool busy, sidebarOpen = true; bool busy, updating, sidebarOpen = true;
ModelOption selectedModel = Default; ModelOption selectedModel = Default;
string customModel = ""; string customModel = "";
string selectedEffort = "Predefinito"; string selectedEffort = NoEffort;
readonly RelayCommand<object> send, newChat; readonly RelayCommand<object> send, newChat;
public MainViewModel() public MainViewModel()
{ {
selectedEngine = EngineChoices.FirstOrDefault(c => c.Installed) ?? EngineChoices[0];
ApplyEngine(selectedEngine);
send = new(_ => _ = SendAsync(), () => CanSend); send = new(_ => _ = SendAsync(), () => CanSend);
SendCommand = send; SendCommand = send;
newChat = new(_ => NewChat(), () => !busy); newChat = new(_ => NewChat(), () => !busy && !updating);
CopyCommand = new RelayCommand<string>(t => { if (t is not null) _ = CopyText(t); }); CopyCommand = new RelayCommand<string>(t => { if (t is not null) _ = CopyText(t); });
OpenCommand = new RelayCommand<ChatItem>(c => { if (c is not null) OpenChat(c.Id); }); OpenCommand = new RelayCommand<ChatItem>(c => { if (c is not null) OpenChat(c.Id); });
DeleteCommand = new RelayCommand<ChatItem>(c => { if (c is not null) _ = DeleteAsync(c); }); DeleteCommand = new RelayCommand<ChatItem>(c => { if (c is not null) _ = DeleteAsync(c); });
ToggleSidebarCommand = new RelayCommand<object>(_ => SidebarOpen = !SidebarOpen); ToggleSidebarCommand = new RelayCommand<object>(_ => SidebarOpen = !SidebarOpen);
UpdateCommand = new RelayCommand<EngineChoice>(c => { if (c is not null) _ = UpdateEngineAsync(c); });
Messages.CollectionChanged += (_, _) => { Raise(nameof(HasMessages)); Raise(nameof(ShowEmpty)); }; Messages.CollectionChanged += (_, _) => { Raise(nameof(HasMessages)); Raise(nameof(ShowEmpty)); };
ResetSession();
_ = CheckUpdatesAsync();
// all'avvio riapre la chat più recente // all'avvio riapre la chat più recente
if (ChatStore.List().FirstOrDefault() is { } last) OpenChat(last.Id); else RefreshChats(); if (ChatStore.List().FirstOrDefault() is { } last) OpenChat(last.Id); else RefreshChats();
} }
Engine Engine => selectedEngine.Engine;
public bool HasMessages => Messages.Count > 0; public bool HasMessages => Messages.Count > 0;
public bool ShowEmpty => Messages.Count == 0; public bool ShowEmpty => Messages.Count == 0;
public bool CanSend => !busy && !string.IsNullOrWhiteSpace(input); public bool CanSend => !busy && !updating && !string.IsNullOrWhiteSpace(input);
/// <summary>I pulsanti Aggiorna sono attivi solo se non c'è una risposta né un altro aggiornamento in corso.</summary>
public bool CanUpdate => !busy && !updating;
public string Author => Engine.Author;
public string InputPlaceholder => $"Scrivi un messaggio a {Engine.Author}…";
public string BusyText => $"{Engine.Author} sta scrivendo…";
public string Input public string Input
{ {
@@ -84,10 +146,34 @@ class MainViewModel : ObservableObject
public bool IsBusy public bool IsBusy
{ {
get => busy; get => busy;
private set { if (Set(ref busy, value)) { Raise(nameof(CanSend)); send.Refresh(); newChat.Refresh(); } } private set { if (Set(ref busy, value)) { Raise(nameof(CanSend)); Raise(nameof(CanSwitchEngine)); Raise(nameof(CanUpdate)); send.Refresh(); newChat.Refresh(); } }
} }
public bool SidebarOpen { get => sidebarOpen; set => Set(ref sidebarOpen, value); } public bool SidebarOpen { get => sidebarOpen; set => Set(ref sidebarOpen, value); }
bool IsUpdating
{
get => updating;
set { if (Set(ref updating, value)) { Raise(nameof(CanSend)); Raise(nameof(CanSwitchEngine)); Raise(nameof(CanUpdate)); send.Refresh(); newChat.Refresh(); } }
}
public bool CanSwitchEngine => !busy && !updating;
/// <summary>Interruttore CLI: cambiare motore apre una nuova chat (il contesto non passa da un motore all'altro).</summary>
public EngineChoice SelectedEngine
{
get => selectedEngine;
set
{
if (value is null || value == selectedEngine || busy || updating || !value.Installed) return;
ApplyEngine(value);
NewChat();
}
}
public ModelOption[] ModelChoices { get => modelChoices; private set => Set(ref modelChoices, value); }
public string[] EffortChoices { get => effortChoices; private set => Set(ref effortChoices, value); }
public ModelOption SelectedModel public ModelOption SelectedModel
{ {
get => selectedModel; get => selectedModel;
@@ -97,37 +183,60 @@ class MainViewModel : ObservableObject
public string CustomModel { get => customModel; set => Set(ref customModel, value); } public string CustomModel { get => customModel; set => Set(ref customModel, value); }
public string SelectedEffort { get => selectedEffort; set => Set(ref selectedEffort, value); } public string SelectedEffort { get => selectedEffort; set => Set(ref selectedEffort, value); }
// Adotta un motore: liste di modelli ed effort sue, scelte riportate a "Predefinito".
void ApplyEngine(EngineChoice choice)
{
selectedEngine = choice;
ModelChoices = [Default, .. choice.Engine.Models, Custom];
EffortChoices = [NoEffort, .. choice.Engine.Efforts];
// valori iniziali: il modello più piccolo del motore ed effort basso ("Predefinito" resta selezionabile)
SelectedModel = ModelChoices.FirstOrDefault(m => m.Id == choice.Engine.DefaultModelId) ?? Default;
CustomModel = ""; SelectedEffort = choice.Engine.DefaultEffort;
Raise(nameof(SelectedEngine)); Raise(nameof(Author)); Raise(nameof(InputPlaceholder)); Raise(nameof(BusyText));
}
void ResetSession()
{
chatId = Guid.NewGuid().ToString();
sessionId = Engine.OwnsSessionId ? null : chatId;
started = false;
history = [];
}
void RefreshChats() void RefreshChats()
{ {
Chats.Clear(); Chats.Clear();
foreach (var c in ChatStore.List()) Chats.Add(new(c.Id, c.Title, c.Updated, c.Id == sessionId)); foreach (var c in ChatStore.List())
Chats.Add(new(c.Id, c.Title, c.Updated, c.Id == chatId, Engines.Find(c.EngineId)?.Name ?? c.EngineId));
} }
void Show(List<Msg> msgs) void Show(List<Msg> msgs, string author)
{ {
Messages.Clear(); Messages.Clear();
foreach (var m in msgs) Messages.Add(new(m.Role, m.Text)); foreach (var m in msgs) Messages.Add(new(m.Role, m.Text, author));
} }
void NewChat() void NewChat()
{ {
sessionId = Guid.NewGuid().ToString(); started = false; history = []; ResetSession();
Show(history); RefreshChats(); FocusInput?.Invoke(); Show(history, Author); RefreshChats(); FocusInput?.Invoke();
} }
void OpenChat(string id) void OpenChat(string id)
{ {
if (busy) return; if (busy) return;
if (ChatStore.Load(id) is not { } chat) { RefreshChats(); return; } if (ChatStore.Load(id) is not { } chat) { RefreshChats(); return; }
sessionId = chat.Id; started = chat.Started; history = chat.Messages; var choice = EngineChoices.FirstOrDefault(c => c.Engine.Id == chat.EngineId);
Show(history); RefreshChats(); if (choice is not null && choice != selectedEngine) ApplyEngine(choice);
chatId = chat.Id; sessionId = chat.EffectiveSessionId; started = chat.Started; history = chat.Messages;
Show(history, Author); RefreshChats();
} }
async Task DeleteAsync(ChatItem c) async Task DeleteAsync(ChatItem c)
{ {
if (busy || !await ConfirmDelete()) return; if (busy || !await ConfirmDelete()) return;
ChatStore.Delete(c.Id); ChatStore.Delete(c.Id);
if (c.Id == sessionId) NewChat(); else RefreshChats(); if (c.Id == chatId) NewChat(); else RefreshChats();
} }
async Task SendAsync() async Task SendAsync()
@@ -135,7 +244,7 @@ class MainViewModel : ObservableObject
if (!CanSend) return; if (!CanSend) return;
var text = input.Trim(); var text = input.Trim();
var model = IsCustomModel ? customModel.Trim() : selectedModel.Id; var model = IsCustomModel ? customModel.Trim() : selectedModel.Id;
var effort = selectedEffort == "Predefinito" ? "" : selectedEffort; var effort = selectedEffort == NoEffort ? "" : selectedEffort;
Input = ""; IsBusy = true; Input = ""; IsBusy = true;
Add("user", text); Add("user", text);
@@ -143,11 +252,16 @@ class MainViewModel : ObservableObject
RefreshChats(); RefreshChats();
try try
{ {
var r = await Claude.RunCapturedAsync(text, sessionId, started, model, effort); var r = await EngineRunner.RunCapturedAsync(Engine, text, sessionId, started, model, effort);
if (r.Code == 0) { started = true; Add("ai", r.Out); } if (r.Error is null)
else Add("err", $"claude è uscito con codice {r.Code}\n{r.Err}".Trim()); {
started = true;
if (r.SessionId is not null) sessionId = r.SessionId;
Add("ai", r.Text);
}
else Add("err", r.Error);
} }
catch (System.ComponentModel.Win32Exception) { Add("err", "'claude' non trovato nel PATH."); } catch (System.ComponentModel.Win32Exception) { Add("err", $"'{Engine.Executable}' non trovato nel PATH."); }
catch (Exception ex) { Add("err", ex.Message); } catch (Exception ex) { Add("err", ex.Message); }
finally finally
{ {
@@ -158,11 +272,52 @@ class MainViewModel : ObservableObject
} }
} }
void Add(string role, string text) { history.Add(new(role, text)); Messages.Add(new(role, text)); } static readonly TimeSpan CheckEvery = TimeSpan.FromMinutes(5);
DateTime lastCheck = DateTime.MinValue;
bool checking;
/// <summary>Controlla (sola lettura) se i CLI hanno una versione nuova. All'avvio, all'apertura del riquadro (al massimo ogni 5 minuti) e dopo un aggiornamento.</summary>
public async Task CheckUpdatesAsync(bool force = false)
{
if (checking || (!force && DateTime.UtcNow - lastCheck < CheckEvery)) return;
checking = true;
try
{
foreach (var c in InstalledEngines)
{
var r = await EngineUpdater.CheckAsync(c.Engine);
if (r.InstalledText is not null) c.Version = r.InstalledText;
c.SetCheck(r.Available, r.Latest);
Raise(nameof(AnyUpdateAvailable));
}
lastCheck = DateTime.UtcNow;
}
finally { checking = false; }
}
// Aggiorna un solo CLI con il suo comando ufficiale e mostra l'esito sulla sua riga (ADR-0004).
async Task UpdateEngineAsync(EngineChoice c)
{
if (!CanUpdate || !c.Installed) return;
IsUpdating = true;
c.StatusIsError = false; c.Status = "Aggiornamento in corso…";
try
{
var r = await EngineUpdater.UpdateAsync(c.Engine);
c.StatusIsError = !r.Ok;
c.Status = r.Message;
if (r.Ok) c.Version = r.After ?? r.Before ?? c.Version;
}
catch (Exception ex) { c.StatusIsError = true; c.Status = ex.Message; }
finally { IsUpdating = false; }
await CheckUpdatesAsync(force: true); // dopo l'aggiornamento: ripete il controllo, il pulsante non resta evidenziato
}
void Add(string role, string text) { history.Add(new(role, text)); Messages.Add(new(role, text, Author)); }
void Persist() void Persist()
{ {
try { ChatStore.Save(sessionId, started, history); } try { ChatStore.Save(chatId, Engine.Id, sessionId, started, history); }
catch (IOException) { } // la chat resta a schermo anche se il salvataggio fallisce catch (IOException) { } // la chat resta a schermo anche se il salvataggio fallisce
} }
} }
+49 -10
View File
@@ -93,7 +93,7 @@
<SelectableTextBlock Text="{Binding Text}" TextWrapping="Wrap" /> <SelectableTextBlock Text="{Binding Text}" TextWrapping="Wrap" />
</Border> </Border>
<StackPanel IsVisible="{Binding IsAi}" Spacing="6"> <StackPanel IsVisible="{Binding IsAi}" Spacing="6">
<TextBlock Text="Claude" FontWeight="SemiBold" FontSize="13.5" Foreground="{DynamicResource Accent}" /> <TextBlock Text="{Binding Author}" FontWeight="SemiBold" FontSize="13.5" Foreground="{DynamicResource Accent}" />
<gui:MarkdownView Source="{Binding Text}" /> <gui:MarkdownView Source="{Binding Text}" />
<Button Classes="ghost" HorizontalAlignment="Left" MinHeight="30" Padding="10,0" FontSize="13" Content="Copia" <Button Classes="ghost" HorizontalAlignment="Left" MinHeight="30" Padding="10,0" FontSize="13" Content="Copia"
Command="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).CopyCommand}" CommandParameter="{Binding Text}" Command="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).CopyCommand}" CommandParameter="{Binding Text}"
@@ -108,7 +108,7 @@
<!-- Attesa --> <!-- Attesa -->
<StackPanel IsVisible="{Binding IsBusy}" Orientation="Horizontal" Spacing="12"> <StackPanel IsVisible="{Binding IsBusy}" Orientation="Horizontal" Spacing="12">
<ProgressBar IsIndeterminate="True" Width="80" Height="4" Foreground="{DynamicResource Accent}" VerticalAlignment="Center" /> <ProgressBar IsIndeterminate="True" Width="80" Height="4" Foreground="{DynamicResource Accent}" VerticalAlignment="Center" />
<TextBlock Text="Claude sta scrivendo…" Foreground="{DynamicResource FgMuted}" /> <TextBlock Text="{Binding BusyText}" Foreground="{DynamicResource FgMuted}" />
</StackPanel> </StackPanel>
</StackPanel> </StackPanel>
</ScrollViewer> </ScrollViewer>
@@ -122,10 +122,22 @@
<Button Grid.Row="0" Classes="ghost" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="12" Padding="0" Width="36" <Button Grid.Row="0" Classes="ghost" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="12" Padding="0" Width="36"
HorizontalContentAlignment="Center" AutomationProperties.Name="Impostazioni" ToolTip.Tip="Impostazioni"> HorizontalContentAlignment="Center" AutomationProperties.Name="Impostazioni" ToolTip.Tip="Impostazioni">
<Button.Flyout> <Button.Flyout>
<Flyout Placement="BottomEdgeAlignedRight"> <Flyout Placement="BottomEdgeAlignedRight" Opening="OnSettingsOpening">
<StackPanel Width="300" Spacing="6" Margin="4"> <StackPanel Width="340" Spacing="6" Margin="4">
<TextBlock Text="Impostazioni" FontWeight="SemiBold" Margin="0,0,0,6" /> <TextBlock Text="Impostazioni" FontWeight="SemiBold" Margin="0,0,0,6" />
<TextBlock Text="Modello" FontSize="13" Foreground="{DynamicResource FgMuted}" /> <TextBlock Text="CLI" FontSize="13" Foreground="{DynamicResource FgMuted}" />
<ComboBox ItemsSource="{Binding EngineChoices}" SelectedItem="{Binding SelectedEngine}" IsEnabled="{Binding CanSwitchEngine}"
HorizontalAlignment="Stretch" AutomationProperties.Name="CLI (motore)">
<ComboBox.Styles>
<Style Selector="ComboBoxItem" x:DataType="gui:EngineChoice">
<Setter Property="IsEnabled" Value="{Binding Installed}" />
</Style>
</ComboBox.Styles>
<ComboBox.ItemTemplate>
<DataTemplate x:DataType="gui:EngineChoice"><TextBlock Text="{Binding Label}" /></DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
<TextBlock Text="Modello" FontSize="13" Foreground="{DynamicResource FgMuted}" Margin="0,8,0,0" />
<ComboBox ItemsSource="{Binding ModelChoices}" SelectedItem="{Binding SelectedModel}" HorizontalAlignment="Stretch" <ComboBox ItemsSource="{Binding ModelChoices}" SelectedItem="{Binding SelectedModel}" HorizontalAlignment="Stretch"
AutomationProperties.Name="Modello"> AutomationProperties.Name="Modello">
<ComboBox.ItemTemplate> <ComboBox.ItemTemplate>
@@ -137,13 +149,40 @@
<TextBlock Text="Effort" FontSize="13" Foreground="{DynamicResource FgMuted}" Margin="0,8,0,0" /> <TextBlock Text="Effort" FontSize="13" Foreground="{DynamicResource FgMuted}" Margin="0,8,0,0" />
<ComboBox ItemsSource="{Binding EffortChoices}" SelectedItem="{Binding SelectedEffort}" HorizontalAlignment="Stretch" <ComboBox ItemsSource="{Binding EffortChoices}" SelectedItem="{Binding SelectedEffort}" HorizontalAlignment="Stretch"
AutomationProperties.Name="Effort di ragionamento" /> AutomationProperties.Name="Effort di ragionamento" />
<Border Height="1" Background="{DynamicResource Border}" Margin="0,12,0,4" />
<TextBlock Text="Aggiornamenti" FontSize="13" Foreground="{DynamicResource FgMuted}" />
<ItemsControl ItemsSource="{Binding InstalledEngines}">
<ItemsControl.ItemTemplate>
<DataTemplate x:DataType="gui:EngineChoice">
<StackPanel Spacing="4" Margin="0,8,0,0">
<Grid ColumnDefinitions="*,Auto">
<StackPanel VerticalAlignment="Center">
<TextBlock Text="{Binding Name}" />
<TextBlock Text="{Binding Version}" FontSize="12" Foreground="{DynamicResource FgMuted}" TextTrimming="CharacterEllipsis" />
<TextBlock Classes="check" Classes.avail="{Binding UpdateAvailable}" Text="{Binding CheckText}" FontSize="12" />
</StackPanel>
<Button Grid.Column="1" Classes="ghost" Classes.primary="{Binding UpdateAvailable}" MinHeight="30" Padding="12,0" FontSize="13" Content="Aggiorna"
IsEnabled="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).CanUpdate}"
Command="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).UpdateCommand}" CommandParameter="{Binding}"
AutomationProperties.Name="{Binding Name, StringFormat='Aggiorna {0}'}" />
</Grid>
<SelectableTextBlock Classes="status" Classes.err="{Binding StatusIsError}" Text="{Binding Status}" IsVisible="{Binding HasStatus}"
TextWrapping="Wrap" FontSize="12.5" />
</StackPanel>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</StackPanel> </StackPanel>
</Flyout> </Flyout>
</Button.Flyout> </Button.Flyout>
<Viewbox Width="16" Height="16"> <Panel>
<Path Data="M4 7H11M17 7H20M4 17H7M13 17H20 M11 7A3 3 0 1 0 17 7A3 3 0 1 0 11 7Z M7 17A3 3 0 1 0 13 17A3 3 0 1 0 7 17Z" <Viewbox Width="16" Height="16">
Stroke="{DynamicResource Fg}" StrokeThickness="2" StrokeLineCap="Round" /> <Path Data="M4 7H11M17 7H20M4 17H7M13 17H20 M11 7A3 3 0 1 0 17 7A3 3 0 1 0 11 7Z M7 17A3 3 0 1 0 13 17A3 3 0 1 0 7 17Z"
</Viewbox> Stroke="{DynamicResource Fg}" StrokeThickness="2" StrokeLineCap="Round" />
</Viewbox>
<Ellipse Width="9" Height="9" Fill="{DynamicResource Accent}" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="0,-5,-6,0"
IsVisible="{Binding AnyUpdateAvailable}" />
</Panel>
</Button> </Button>
<!-- Composer --> <!-- Composer -->
@@ -151,7 +190,7 @@
<Border Classes="composer" Background="{DynamicResource Surface}" BorderBrush="{DynamicResource Border}" BorderThickness="1" CornerRadius="20" Padding="14,10"> <Border Classes="composer" Background="{DynamicResource Surface}" BorderBrush="{DynamicResource Border}" BorderThickness="1" CornerRadius="20" Padding="14,10">
<Grid ColumnDefinitions="*,Auto"> <Grid ColumnDefinitions="*,Auto">
<TextBox x:Name="InputBox" Classes="bare" Text="{Binding Input, Mode=TwoWay}" AcceptsReturn="True" TextWrapping="Wrap" MaxHeight="200" <TextBox x:Name="InputBox" Classes="bare" Text="{Binding Input, Mode=TwoWay}" AcceptsReturn="True" TextWrapping="Wrap" MaxHeight="200"
PlaceholderText="Scrivi un messaggio a Claude…" BorderThickness="0" Background="Transparent" PlaceholderText="{Binding InputPlaceholder}" BorderThickness="0" Background="Transparent"
VerticalContentAlignment="Center" AutomationProperties.Name="Messaggio" /> VerticalContentAlignment="Center" AutomationProperties.Name="Messaggio" />
<Button Grid.Column="1" Classes="send" VerticalAlignment="Bottom" Margin="8,0,0,0" Command="{Binding SendCommand}" AutomationProperties.Name="Invia messaggio"> <Button Grid.Column="1" Classes="send" VerticalAlignment="Bottom" Margin="8,0,0,0" Command="{Binding SendCommand}" AutomationProperties.Name="Invia messaggio">
<Viewbox Width="18" Height="18"><Path Data="M12 19V5M5 12L12 5L19 12" Stroke="{Binding $parent[Button].Foreground}" StrokeThickness="2.2" StrokeLineCap="Round" StrokeJoin="Round" /></Viewbox> <Viewbox Width="18" Height="18"><Path Data="M12 19V5M5 12L12 5L19 12" Stroke="{Binding $parent[Button].Foreground}" StrokeThickness="2.2" StrokeLineCap="Round" StrokeJoin="Round" /></Viewbox>
+3
View File
@@ -45,4 +45,7 @@ partial class MainWindow : Window
Opened += (_, _) => InputBox.Focus(); Opened += (_, _) => InputBox.Focus();
} }
// All'apertura del riquadro si ricontrolla se ci sono aggiornamenti (al massimo ogni 5 minuti).
void OnSettingsOpening(object? sender, EventArgs e) => _ = (DataContext as MainViewModel)?.CheckUpdatesAsync();
} }
+19 -2
View File
@@ -2,7 +2,24 @@ using Avalonia;
using AgentWikiUi.Core; using AgentWikiUi.Core;
using AgentWikiUi.Gui; using AgentWikiUi.Gui;
// Con argomenti: CLI (tutti gli argomenti uniti in un prompt). Senza: GUI. // Con argomenti: CLI. Con `--engine <id>` per primo si sceglie il motore (default Claude Code);
if (args.Length > 0) return Claude.RunInherited(string.Join(' ', args)); // il resto degli argomenti è unito in un solo prompt. Senza argomenti: GUI.
if (args.Length > 0)
{
ConsoleHost.AttachToParent(); // Windows: l'eseguibile non ha console, si usa quella del terminale padre
var engine = Engines.Claude;
var words = args;
if (args[0] == "--engine")
{
if (args.Length < 3 || Engines.Find(args[1]) is not { } chosen)
{
Console.Error.WriteLine($"Uso: <app> [--engine {string.Join('|', Engines.All.Select(e => e.Id))}] \"prompt\"");
return 2;
}
engine = chosen;
words = args[2..];
}
return EngineRunner.RunInherited(engine, string.Join(' ', words));
}
return AppBuilder.Configure<App>().UsePlatformDetect().StartWithClassicDesktopLifetime(args); return AppBuilder.Configure<App>().UsePlatformDetect().StartWithClassicDesktopLifetime(args);
+41 -6
View File
@@ -9,7 +9,7 @@ Eseguibile C# (.NET 10, Windows e Linux) che lancia Claude Code (`claude -p`) o
## Uso ## Uso
GUI (nessun argomento): finestra di chat in stile claude.ai, con la conversazione in markdown in alto e il campo messaggio in basso (`Invio` invia, `Maiusc+Invio` va a capo, "Nuova chat" azzera il contesto). Il riquadro **Impostazioni** (in alto a destra) permette di scegliere la **CLI** (Claude Code o Codex), il **modello** e l'**effort** di ragionamento ("Predefinito" = nessun flag, vale la config del motore). Le chat si salvano su disco e l'ultima si riapre all'avvio. GUI (nessun argomento): finestra di chat in stile claude.ai, con la conversazione in markdown in alto e il campo messaggio in basso (`Invio` invia, `Maiusc+Invio` va a capo, "Nuova chat" azzera il contesto). Il riquadro **Impostazioni** (in alto a destra) permette di scegliere la **CLI** (Claude Code o Codex), il **modello** e l'**effort** di ragionamento. All'avvio, e a ogni cambio di CLI, sono scelti il modello più piccolo (Haiku 5.5 per Claude Code, GPT-5.6 Luna per Codex) ed effort `low`, per risposte rapide e economiche; "Predefinito" = nessun flag, vale la config del motore. Le chat si salvano su disco e l'ultima si riapre all'avvio. Sempre nel riquadro, la sezione **Aggiornamenti** dice se Claude Code e Codex hanno una versione nuova (pulsante evidenziato) e li aggiorna uno alla volta.
``` ```
dotnet run dotnet run
``` ```
@@ -20,15 +20,50 @@ dotnet run -- "spiega questo progetto"
dotnet run -- --engine codex "spiega questo progetto" dotnet run -- --engine codex "spiega questo progetto"
``` ```
## Publish single-file ## Creare gli eseguibili (Windows e Linux)
Un eseguibile per sistema, senza dipendenze: Ogni eseguibile è un **unico file** che include il runtime .NET: chi lo usa non deve installare nulla. Per crearlo serve solo il .NET SDK 10 sulla macchina che compila, e **da ciascun sistema si creano entrambi gli eseguibili** (da Windows anche quello per Linux, e viceversa).
### 1. Installare il .NET SDK 10
- **Windows** (PowerShell o Prompt dei comandi): `winget install Microsoft.DotNet.SDK.10`, oppure il programma di installazione da [dotnet.microsoft.com/download](https://dotnet.microsoft.com/download).
- **Linux / WSL / macOS**: pacchetto della distribuzione o script ufficiale da [dotnet.microsoft.com/download](https://dotnet.microsoft.com/download).
- Controllo: `dotnet --version` deve stampare `10.x`.
### 2. Creare gli eseguibili
Dalla cartella del progetto.
| Sistema | Comando | Scelta del sistema di destinazione |
|---|---|---|
| **Linux, WSL, macOS** (bash) | `scripts/publish.sh` | `scripts/publish.sh linux-x64` |
| **Windows** (PowerShell) | `.\scripts\publish.ps1` | `.\scripts\publish.ps1 win-x64` |
Senza argomenti si creano entrambi. Su Windows, se PowerShell rifiuta di eseguire lo script (criteri di esecuzione): `powershell -ExecutionPolicy Bypass -File .\scripts\publish.ps1`.
Risultato (circa 47 MB per file), in `dist/`, ignorata da git:
| Sistema | File |
|---|---|
| Windows x64 | `dist/win-x64/agent-wiki-ui.exe` |
| Linux x64 | `dist/linux-x64/agent-wiki-ui` |
Altri identificatori (per esempio `win-arm64`, `linux-arm64`) si possono provare allo stesso modo, ma non sono verificati. Lo script è solo una comodità: il comando sotto fa la stessa cosa.
**Senza script** (identico su qualsiasi sistema; sostituisci `<rid>` con `win-x64` o `linux-x64`):
``` ```
dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true dotnet publish -c Release -r <rid> --self-contained -p:PublishSingleFile=true -o dist/<rid>
dotnet publish -c Release -r linux-x64 --self-contained -p:PublishSingleFile=true
``` ```
Il risultato è in `bin/Release/net10.0/<rid>/publish/` (`agent-wiki-ui.exe` o `agent-wiki-ui`, circa 48 MB). Al primo avvio le librerie native vengono estratte in una cartella temporanea. Senza `-o` il risultato è in `bin/Release/net10.0/<rid>/publish/`.
Verificato: da Linux/WSL entrambi gli eseguibili; da Windows nativo (PowerShell 5.1, SDK 10.0.203) entrambi, e il `.exe` creato parte.
**Usarli**
- Windows: doppio clic su `agent-wiki-ui.exe` per la GUI (non si apre nessuna finestra di console), oppure da terminale `agent-wiki-ui.exe "prompt"` per la CLI. Da `cmd` o PowerShell il prompt torna subito e l'output compare dopo; per aspettare la fine e leggere l'exit code usa `start /wait agent-wiki-ui.exe "prompt"` (cmd) o `Start-Process -Wait -NoNewWindow agent-wiki-ui.exe "prompt"` (PowerShell); `& .\agent-wiki-ui.exe "prompt" | Out-Host` aspetta ma non dà l'exit code. Spiegazione in [ADR-0005](docs/adr/0005-windows-senza-console.md). Il file non è firmato: Windows può mostrare un avviso di sicurezza al primo avvio.
- Linux: `chmod +x agent-wiki-ui` (se serve) e poi `./agent-wiki-ui`. La GUI richiede un desktop con X11 o XWayland.
- Al primo avvio le librerie native (Skia, HarfBuzz) vengono estratte in una cartella temporanea: il primo avvio è un po' più lento.
- I motori (`claude`, `codex`) devono essere installati e nel PATH dello stesso sistema: vedi [docs/INSTALL.md](docs/INSTALL.md).
## Piattaforme ## Piattaforme
Windows e Linux con lo stesso codice ([ADR-0001](docs/adr/0001-gui-multipiattaforma-avalonia.md)). Motori supportati: Claude Code e Codex CLI, già installati da terminale; Antigravity CLI è pianificato: [ADR-0002](docs/adr/0002-motori-cli-claude-codex-antigravity.md). Windows e Linux con lo stesso codice ([ADR-0001](docs/adr/0001-gui-multipiattaforma-avalonia.md)). Motori supportati: Claude Code e Codex CLI, già installati da terminale; Antigravity CLI è pianificato: [ADR-0002](docs/adr/0002-motori-cli-claude-codex-antigravity.md).
> **Stato: MVP** (prima della 1.0): la parte funzionale c'è, i test automatici e alcune verifiche su macchine reali mancano. Dettagli in [docs/PROJECT_STATE.md](docs/PROJECT_STATE.md).
Documentazione: [docs/README.md](docs/README.md) (indice, regole, decisioni), [docs/MVP.md](docs/MVP.md), [docs/ROADMAP.md](docs/ROADMAP.md). Documentazione: [docs/README.md](docs/README.md) (indice, regole, decisioni), [docs/MVP.md](docs/MVP.md), [docs/ROADMAP.md](docs/ROADMAP.md).
+2 -1
View File
@@ -1,7 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup> <PropertyGroup>
<OutputType>Exe</OutputType> <!-- WinExe: su Windows nessuna finestra di console al doppio clic; la CLI riaggancia il terminale (ADR-0005). Su Linux è identico a Exe. -->
<OutputType>WinExe</OutputType>
<TargetFramework>net10.0</TargetFramework> <TargetFramework>net10.0</TargetFramework>
<!-- Unica sorgente del nome dell'app (vedi docs/README.md → "Nome del progetto") --> <!-- Unica sorgente del nome dell'app (vedi docs/README.md → "Nome del progetto") -->
<AssemblyName>agent-wiki-ui</AssemblyName> <AssemblyName>agent-wiki-ui</AssemblyName>
+12
View File
@@ -73,6 +73,18 @@ codex exec --help # uso non interattivo, usato dall'app
**Problema noto: "requires a newer version of Codex".** Se il modello predefinito del tuo `~/.codex/config.toml` richiede un Codex più recente, `codex exec` fallisce con quell'errore (l'app lo mostra nella chat). Aggiorna con `codex update`, oppure scegli un altro modello nelle Impostazioni dell'app. Controllato su questa macchina il 2026-10-15 con Codex 0.144.3. **Problema noto: "requires a newer version of Codex".** Se il modello predefinito del tuo `~/.codex/config.toml` richiede un Codex più recente, `codex exec` fallisce con quell'errore (l'app lo mostra nella chat). Aggiorna con `codex update`, oppure scegli un altro modello nelle Impostazioni dell'app. Controllato su questa macchina il 2026-10-15 con Codex 0.144.3.
## Aggiornare un CLI dall'app
Nel riquadro Impostazioni, sezione **Aggiornamenti**, l'app controlla da sola, all'avvio e all'apertura del riquadro, se c'è una versione più recente (Claude Code: `downloads.claude.ai`; Codex: release di GitHub): se c'è, la riga dice "Aggiornamento disponibile", il pulsante **Aggiorna** si evidenzia e compare un puntino sul pulsante Impostazioni. Il pulsante esegue `claude update` o `codex update` (controllano e installano solo se c'è una versione nuova). Nulla si aggiorna senza un clic. Se non va a buon fine l'app mostra l'errore e il comando manuale, che dipende da come hai installato il CLI:
| Installazione | Claude Code | Codex |
|---|---|---|
| npm | `npm install -g @anthropic-ai/claude-code@latest` | `npm install -g @openai/codex@latest` |
| Homebrew | `brew upgrade claude-code` | `brew upgrade --cask codex` |
| WinGet | `winget upgrade Anthropic.ClaudeCode` | reinstalla con lo script PowerShell |
| Nativo / script | `claude update` | `codex update` (o rilancia lo script di installazione) |
Dettagli e decisioni: [ADR-0004](adr/0004-aggiornamento-dei-cli.md).
## Controllo finale per l'app ## Controllo finale per l'app
Dallo stesso terminale da cui avvii l'app: Dallo stesso terminale da cui avvii l'app:
``` ```
+5 -4
View File
@@ -13,7 +13,7 @@ Tutti gli argomenti sono uniti in un unico prompt. Con `--engine <id>` come prim
1. Se non ci sono argomenti: stampa l'uso ed esce con codice 2. 1. Se non ci sono argomenti: stampa l'uso ed esce con codice 2.
2. Avvia il motore scelto in modalità non interattiva (`claude -p <prompt>` o `codex exec … -- <prompt>`) con `WorkingDirectory = AppContext.BaseDirectory`. 2. Avvia il motore scelto in modalità non interattiva (`claude -p <prompt>` o `codex exec … -- <prompt>`) con `WorkingDirectory = AppContext.BaseDirectory`.
3. Ritrasmette stdout e stderr del processo figlio in tempo reale. 3. Ritrasmette stdout e stderr del processo figlio in tempo reale.
4. Esce con lo stesso exit code di `claude`. 4. Esce con lo stesso exit code del motore. **Su Windows** l'eseguibile non ha finestra di console ([ADR-0005](adr/0005-windows-senza-console.md)): `cmd` e PowerShell non aspettano la fine del programma, quindi l'exit code è disponibile solo se il chiamante attende il processo (`start /wait`, `Start-Process -Wait`, `| Out-Host`, script).
5. Se l'eseguibile del motore non è trovato: messaggio chiaro ed exit code 127. 5. Se l'eseguibile del motore non è trovato: messaggio chiaro ed exit code 127.
## GUI (chat) ## GUI (chat)
@@ -24,8 +24,9 @@ Senza argomenti si apre una finestra Avalonia (C# + XAML, nessun HTML) in stile
- **Conversazione**: messaggi alternati utente/Claude. Le risposte sono renderizzate in markdown: titoli, liste, tabelle, citazioni, blocchi di codice, grassetto/corsivo/barrato, codice inline, link. Il rendering è un renderer proprio ([MarkdownView.cs](../Gui/MarkdownView.cs)) che trasforma l'albero di Markdig in controlli Avalonia; l'HTML grezzo è disabilitato. Il testo è selezionabile. Sulle risposte il pulsante **Copia** copia il markdown; sui blocchi di codice copia il codice. - **Conversazione**: messaggi alternati utente/Claude. Le risposte sono renderizzate in markdown: titoli, liste, tabelle, citazioni, blocchi di codice, grassetto/corsivo/barrato, codice inline, link. Il rendering è un renderer proprio ([MarkdownView.cs](../Gui/MarkdownView.cs)) che trasforma l'albero di Markdig in controlli Avalonia; l'HTML grezzo è disabilitato. Il testo è selezionabile. Sulle risposte il pulsante **Copia** copia il markdown; sui blocchi di codice copia il codice.
- **Schermata iniziale** (chat vuota): solo logo, titolo e sottotitolo (nessun suggerimento precompilato). - **Schermata iniziale** (chat vuota): solo logo, titolo e sottotitolo (nessun suggerimento precompilato).
- **Composer** (in basso, scheda arrotondata): campo di testo che cresce fino a ~8 righe e pulsante Invia circolare con icona. `Invio` invia, `Maiusc+Invio` va a capo. Hint sulla tastiera sotto la scheda. Non contiene più i selettori di modello ed effort. - **Composer** (in basso, scheda arrotondata): campo di testo che cresce fino a ~8 righe e pulsante Invia circolare con icona. `Invio` invia, `Maiusc+Invio` va a capo. Hint sulla tastiera sotto la scheda. Non contiene più i selettori di modello ed effort.
- **Impostazioni** (in alto a destra, pulsante con icona a cursori, simmetrico a quello della barra laterale): aprono un riquadro a comparsa con l'interruttore **CLI** (Claude Code, Codex; un motore non installato è mostrato "non installato" e non è selezionabile; disabilitato durante l'attesa), poi **Modello** (Predefinito, Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5, "Altro ID…" con campo libero) ed **Effort** (Predefinito, low, medium, high, xhigh, max). Si chiude con `Esc` o con un clic fuori; le scelte restano valide per i messaggi successivi (non sono ancora salvate su disco). Passati come `--model` / `--effort`; con "Predefinito" il flag viene omesso. Solo GUI. - **Impostazioni** (in alto a destra, pulsante con icona a cursori, simmetrico a quello della barra laterale): aprono un riquadro a comparsa con l'interruttore **CLI** (Claude Code, Codex; un motore non installato è mostrato "non installato" e non è selezionabile; disabilitato durante l'attesa), poi **Modello** (Predefinito, Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5, "Altro ID…" con campo libero) ed **Effort** (Predefinito, low, medium, high, xhigh, max). **Valori iniziali**: il modello più piccolo del motore (Claude Code: Haiku 5.5; Codex: GPT-5.6 Luna) ed effort `low`, per risposte rapide e poco costose; sono quelli che si ritrovano all'avvio e a ogni cambio di CLI. Si chiude con `Esc` o con un clic fuori; le scelte restano valide per i messaggi successivi (non sono ancora salvate su disco). Passati come `--model` / `--effort`; con "Predefinito" il flag viene omesso. Solo GUI.
- **Motori** ([ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md)): una chat usa un solo motore. Cambiare **CLI** apre una nuova chat con quel motore; modello ed effort tornano a "Predefinito" e le liste dipendono dal motore (Codex: modelli GPT-5.6 Sol/Terra/Luna, stessi livelli di effort). Aprendo una chat salvata il selettore passa al motore di quella chat. L'etichetta sulle risposte, il segnaposto del composer e il messaggio d'attesa usano il nome del motore, e l'elenco chat lo indica sotto il titolo. Con Codex la sessione è letta dall'output (`thread_id`) e usata per riprendere la chat; i permessi sono di sola lettura. - **Aggiornamenti** (nello stesso riquadro, sotto le impostazioni): una riga per ogni CLI installato con nome, versione e pulsante **Aggiorna**. L'app **controlla prima** se esiste una versione più recente (all'avvio, all'apertura del riquadro se l'ultimo controllo ha più di 5 minuti, e dopo ogni aggiornamento): se c'è, la riga dice "Aggiornamento disponibile: X", il pulsante è evidenziato e un puntino compare sul pulsante Impostazioni; se no, la riga dice "Aggiornato" e nulla è evidenziato; senza rete "Controllo non riuscito". Il pulsante esegue il comando ufficiale `<cli> update` e mostra l'esito sulla riga: "Aggiornato da X a Y", "Già aggiornato (X)" o l'errore con il comando manuale adatto al metodo di installazione (npm, Homebrew, WinGet, nativo). Un solo aggiornamento alla volta; i pulsanti sono disabilitati durante una risposta. Nessun aggiornamento parte da solo. Vedi [ADR-0004](adr/0004-aggiornamento-dei-cli.md).
- **Motori** ([ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md)): una chat usa un solo motore. Cambiare **CLI** apre una nuova chat con quel motore; modello ed effort tornano ai valori iniziali del nuovo motore (il modello più piccolo ed effort `low`) e le liste dipendono dal motore (Codex: modelli GPT-5.6 Sol/Terra/Luna, stessi livelli di effort). Aprendo una chat salvata il selettore passa al motore di quella chat. L'etichetta sulle risposte, il segnaposto del composer e il messaggio d'attesa usano il nome del motore, e l'elenco chat lo indica sotto il titolo. Con Codex la sessione è letta dall'output (`thread_id`) e usata per riprendere la chat; i permessi sono di sola lettura.
- **Contesto**: `claude -p --session-id <guid>` al primo messaggio, `--resume <guid>` ai successivi. "Nuova chat" svuota la vista e genera un nuovo guid. - **Contesto**: `claude -p --session-id <guid>` al primo messaggio, `--resume <guid>` ai successivi. "Nuova chat" svuota la vista e genera un nuovo guid.
- **Cronologia**: dopo ogni scambio la chat è salvata in `<cartella dati>/<nome-app>/chats/<guid>.json`, dove la cartella dati è `Environment.SpecialFolder.LocalApplicationData` (`%LOCALAPPDATA%` su Windows, `~/.local/share` su Linux; vedi [Nome del progetto](README.md#nome-del-progetto)). Il file contiene guid (= id di sessione di `claude`), titolo, data, flag `started`, messaggi con ruolo e testo, motore (`Engine`) e id di sessione del motore (`SessionId`); i file senza questi campi sono chat di Claude Code. Riaprendo una chat si rimostra la conversazione e si prosegue con `--resume <guid>`, quindi `claude` ricorda il contesto. Il messaggio dell'utente viene salvato subito, prima della risposta (così non si perde se l'app si chiude mentre Claude risponde); la risposta si aggiunge appena arriva. Una chat nuova e vuota non viene salvata. **All'avvio l'app riapre automaticamente l'ultima conversazione** (la più recente); se non ce ne sono parte con la schermata iniziale. "Nuova chat" resta sempre disponibile. Eliminare una chat cancella solo il file JSON, non la sessione di `claude`. Non si può aprire/eliminare una chat mentre Claude sta rispondendo. - **Cronologia**: dopo ogni scambio la chat è salvata in `<cartella dati>/<nome-app>/chats/<guid>.json`, dove la cartella dati è `Environment.SpecialFolder.LocalApplicationData` (`%LOCALAPPDATA%` su Windows, `~/.local/share` su Linux; vedi [Nome del progetto](README.md#nome-del-progetto)). Il file contiene guid (= id di sessione di `claude`), titolo, data, flag `started`, messaggi con ruolo e testo, motore (`Engine`) e id di sessione del motore (`SessionId`); i file senza questi campi sono chat di Claude Code. Riaprendo una chat si rimostra la conversazione e si prosegue con `--resume <guid>`, quindi `claude` ricorda il contesto. Il messaggio dell'utente viene salvato subito, prima della risposta (così non si perde se l'app si chiude mentre Claude risponde); la risposta si aggiunge appena arriva. Una chat nuova e vuota non viene salvata. **All'avvio l'app riapre automaticamente l'ultima conversazione** (la più recente); se non ce ne sono parte con la schermata iniziale. "Nuova chat" resta sempre disponibile. Eliminare una chat cancella solo il file JSON, non la sessione di `claude`. Non si può aprire/eliminare una chat mentre Claude sta rispondendo.
- **Limite noto**: la sessione di `claude` è legata alla cartella in cui gira (quella dell'exe): se si sposta l'exe, le vecchie chat si leggono ancora ma `--resume` non ritrova il contesto. - **Limite noto**: la sessione di `claude` è legata alla cartella in cui gira (quella dell'exe): se si sposta l'exe, le vecchie chat si leggono ancora ma `--resume` non ritrova il contesto.
@@ -59,7 +60,7 @@ Ogni criterio ha test automatici nella matrice di [TESTING.md](TESTING.md) (CL-0
- [ ] Eseguito da un'altra cartella, `claude` parte nella cartella dell'exe (verificabile chiedendo "pwd"). - [ ] Eseguito da un'altra cartella, `claude` parte nella cartella dell'exe (verificabile chiedendo "pwd").
- [ ] L'output appare in streaming, non solo alla fine. - [ ] L'output appare in streaming, non solo alla fine.
- [ ] L'exit code è propagato. - [ ] L'exit code è propagato (su Windows, quando il chiamante attende il processo: vedi sopra).
- [ ] Un prompt con virgolette e spazi arriva intatto. - [ ] Un prompt con virgolette e spazi arriva intatto.
## Domande aperte ## Domande aperte
+56
View File
@@ -0,0 +1,56 @@
# Stato del progetto
> **Stadio: MVP** (prima di una versione 1.0). Ultimo aggiornamento: 2026-10-15.
> Questo documento è la fotografia dello stato, non la fonte di dettagli: i passi sono in [ROADMAP.md](ROADMAP.md), i requisiti in [MVP.md](MVP.md), le decisioni negli ADR (indice in [README.md](README.md)), i test in [TESTING.md](TESTING.md). Qui si legge a colpo d'occhio dove siamo; per il resto si segue il collegamento.
## In una frase
`agent-wiki-ui` è un eseguibile C# (.NET 10) per Windows e Linux che inoltra prompt a Claude Code e Codex già installati, da riga di comando o da una GUI di chat. La parte funzionale dell'MVP c'è; mancano i test automatici e alcune verifiche su macchine reali.
## Stato per area
| Area | Stato | Note |
|---|---|---|
| CLI (`agent-wiki-ui "prompt"`, `--engine`) | Funzionante | Exit code e 127 provati su Linux; su Windows l'exit code arriva solo se il chiamante attende il processo ([ADR-0005](adr/0005-windows-senza-console.md)). |
| GUI di chat (Avalonia) | Funzionante | Barra laterale, cronologia su disco, markdown, tema chiaro/scuro, Impostazioni. Provata con screenshot headless e su WSLg; non su Windows nativo. |
| Motori | Claude Code e Codex | Una chat = un motore; sessione di Codex letta dall'output. Antigravity non iniziato ([ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md)). |
| Aggiornamento dei CLI | Funzionante, non provato in reale | Controllo preventivo e pulsante evidenziato; l'`update` vero non è mai stato lanciato dall'app ([ADR-0004](adr/0004-aggiornamento-dei-cli.md)). |
| Eseguibili standalone | Funzionanti | `win-x64` e `linux-x64` creati da entrambi i sistemi con `scripts/publish.sh` / `.ps1` (circa 47 MB). Windows senza console al doppio clic. |
| Test automatici | **Non iniziati** | Piano e matrice pronti ([ADR-0003](adr/0003-strategia-di-test.md)); nessun test scritto. Vedi debiti. |
| Documentazione | Allineata al codice | Doc-first; ogni funzione ha le righe della matrice in TESTING.md. |
## Criteri di accettazione dell'MVP
Da [MVP.md](MVP.md). Restano non spuntati finché non hanno test automatici (regola di [TESTING.md](TESTING.md)).
| Criterio | Verifica a mano | Test automatico |
|---|---|---|
| `claude` parte nella cartella dell'exe | Sì: Linux e Windows (da `C:\Windows` il motore vede la cartella dell'exe) | No (CL-04) |
| Output in streaming nella CLI | Output ereditato dal motore; non misurato | No (CL-08) |
| Exit code propagato | Linux sì; Windows solo con attesa del processo | No (CL-06) |
| Prompt con virgolette e spazi intatto | Sì, con un `claude` finto su Linux | No (CL-01) |
## Debiti noti
- **Test automatici assenti** (Fase 6): contraddice la regola "nuova funzione = nuovi test" per tutto il codice scritto finora. È il debito principale.
- **Verifiche su macchine reali**: GUI su Windows nativo e su una distribuzione Linux pulita; doppio clic senza console e riaggancio al terminale (ADR-0005); tema che segue il sistema su Linux; `update` reale dei CLI.
- **Impostazioni non salvate su disco**: modello, effort e motore tornano ai valori iniziali a ogni avvio (si parte dal modello più piccolo con effort `low`).
- **Nessuno streaming nella GUI**: la risposta compare a fine generazione.
- **Elenchi dei modelli fissi** (Claude Code e Codex): da aggiornare a mano; il "modello più piccolo" di Codex è un'assunzione (GPT-5.6 Luna).
## Decisioni
| ADR | Stato |
|---|---|
| [0001](adr/0001-gui-multipiattaforma-avalonia.md) GUI Avalonia multipiattaforma | Accettata |
| [0002](adr/0002-motori-cli-claude-codex-antigravity.md) Più motori CLI | Accettata (Claude Code, Codex) |
| [0003](adr/0003-strategia-di-test.md) Strategia di test | Proposta |
| [0004](adr/0004-aggiornamento-dei-cli.md) Aggiornamento dei CLI | Proposta |
| [0005](adr/0005-windows-senza-console.md) Windows senza console | Proposta |
## Per chiudere l'MVP
Proposta, derivata dai punti aperti sopra; da confermare.
1. Test automatici per `Core/` e `MainViewModel` e per i quattro criteri di accettazione (Fase 6, prime righe di CL, ST, VM, CX).
2. Gli ADR 0003, 0004 e 0005 passati ad "Accettata" dopo le loro verifiche.
3. GUI provata su Windows nativo e su Linux pulito.
4. Criteri di accettazione di MVP.md spuntati.
Oltre l'MVP (non bloccanti): Antigravity, impostazioni persistite, streaming nella GUI, rinomina e ricerca delle chat, CI con matrice Windows e Linux, firma dell'eseguibile Windows.
## Come tenere aggiornato questo file
Si aggiorna nello stesso commit di ogni cambio di stadio, di funzione, di ADR o di debito: stato per area, criteri, debiti, tabella delle decisioni, data. Se una riga qui contraddice ROADMAP.md o un ADR, vale quello e questa pagina va corretta.
+16 -3
View File
@@ -5,12 +5,13 @@ Indice e regole. Ogni informazione vive in **un solo documento**; gli altri la r
| Documento | Contenuto (sorgente di verità per…) | | Documento | Contenuto (sorgente di verità per…) |
|---|---| |---|---|
| [../README.md](../README.md) | Uso, requisiti, build e publish | | [../README.md](../README.md) | Uso, requisiti, build e publish |
| [PROJECT_STATE.md](PROJECT_STATE.md) | Stato del progetto a colpo d'occhio: stadio (MVP), stato per area, debiti, decisioni, cosa manca per chiudere l'MVP |
| [MVP.md](MVP.md) | Specifica funzionale, design UI/UX, criteri di accettazione | | [MVP.md](MVP.md) | Specifica funzionale, design UI/UX, criteri di accettazione |
| [INSTALL.md](INSTALL.md) | Come installare e autenticare i motori (Claude Code, Codex), verifica e problemi comuni | | [INSTALL.md](INSTALL.md) | Come installare e autenticare i motori (Claude Code, Codex), verifica e problemi comuni |
| [TESTING.md](TESTING.md) | Piano dei test: regola "nuova funzione = nuovi test", soglie di copertura, matrice requisito → test | | [TESTING.md](TESTING.md) | Piano dei test: regola "nuova funzione = nuovi test", soglie di copertura, matrice requisito → test |
| [ROADMAP.md](ROADMAP.md) | Fasi e stato (spunte); solo passi, mai motivazioni | | [ROADMAP.md](ROADMAP.md) | Fasi e stato (spunte); solo passi, mai motivazioni |
| `adr/NNNN-*.md` | Decisioni architetturali e loro motivazioni (indice sotto) | | `adr/NNNN-*.md` | Decisioni architetturali e loro motivazioni (indice sotto) |
| [../CLAUDE.md](../CLAUDE.md) | Guida per Claude Code: comandi, architettura del codice, vincoli | | [../AGENT.md](../AGENT.md) | Istruzioni per gli agenti di codice (Claude Code, Gemini CLI, altri): comandi, architettura del codice, vincoli. Unica sorgente; `CLAUDE.md` e `GEMINI.md` sono solo puntatori |
## Nome del progetto ## Nome del progetto
Il nome è **`agent-wiki-ui`** (prima `LlmRun`). Questa sezione è l'unica sorgente: gli altri doc scrivono "l'app" o `<nome-app>`. Il nome è **`agent-wiki-ui`** (prima `LlmRun`). Questa sezione è l'unica sorgente: gli altri doc scrivono "l'app" o `<nome-app>`.
@@ -19,10 +20,20 @@ Se il nome cambia di nuovo, aggiornare solo questi punti:
- [ ] `AssemblyName` in [../agent-wiki-ui.csproj](../agent-wiki-ui.csproj) (e il nome del file csproj): da lì il codice legge il nome (`Core/AppInfo.cs`) per titolo finestra, intestazione della barra laterale e cartella dati; l'eseguibile diventa `<nome-app>.exe` / `<nome-app>` - [ ] `AssemblyName` in [../agent-wiki-ui.csproj](../agent-wiki-ui.csproj) (e il nome del file csproj): da lì il codice legge il nome (`Core/AppInfo.cs`) per titolo finestra, intestazione della barra laterale e cartella dati; l'eseguibile diventa `<nome-app>.exe` / `<nome-app>`
- [ ] `RootNamespace` e namespace C# (`AgentWikiUi.*`, anche in `x:Class` e `xmlns` dei file `.axaml`): il nome del namespace non può avere trattini - [ ] `RootNamespace` e namespace C# (`AgentWikiUi.*`, anche in `x:Class` e `xmlns` dei file `.axaml`): il nome del namespace non può avere trattini
- [ ] **Cartella dati** `<LocalApplicationData>/<nome-app>/chats`: cambiando nome le chat salvate non si trovano più. `ChatStore` sposta una vecchia cartella (`LlmRun`) in quella nuova al primo avvio; per un nuovo cambio aggiungere il nome precedente all'elenco `LegacyNames` - [ ] **Cartella dati** `<LocalApplicationData>/<nome-app>/chats`: cambiando nome le chat salvate non si trovano più. `ChatStore` sposta una vecchia cartella (`LlmRun`) in quella nuova al primo avvio; per un nuovo cambio aggiungere il nome precedente all'elenco `LegacyNames`
- [ ] Titolo di [../README.md](../README.md) e riga iniziale di [../CLAUDE.md](../CLAUDE.md) (nome del csproj nei comandi) - [ ] Titolo di [../README.md](../README.md) e riga iniziale di [../AGENT.md](../AGENT.md) (nome del csproj nei comandi)
## Istruzioni per gli agenti di codice
Le istruzioni per chi lavora sul repository con un assistente (Claude Code, Gemini CLI, altri) stanno **solo in [../AGENT.md](../AGENT.md)**. Gli strumenti cercano file con nomi propri, quindi esistono due file puntatori che contengono una riga di importazione e nient'altro:
| File | Letto da | Contenuto |
|---|---|---|
| [../CLAUDE.md](../CLAUDE.md) | Claude Code | `@AGENT.md` (importazione) |
| [../GEMINI.md](../GEMINI.md) | Gemini CLI | `@AGENT.md` (importazione) |
Non si scrive nulla nei puntatori: ogni modifica va in AGENT.md. Per un altro strumento si aggiunge un puntatore con il nome che quello strumento cerca (per esempio `AGENTS.md`, usato da Codex), senza copiare il contenuto. Il nome `AGENT.md` è quello scelto per il progetto, non uno standard.
## Flusso (doc-first, doc-as-code) ## Flusso (doc-first, doc-as-code)
1. Prima i doc, poi i test, poi il codice: ADR (se c'è una scelta architetturale) → MVP → matrice in [TESTING.md](TESTING.md) → test → codice → ROADMAP → README → CLAUDE.md. 1. Prima i doc, poi i test, poi il codice: ADR (se c'è una scelta architetturale) → MVP → matrice in [TESTING.md](TESTING.md) → test → codice → ROADMAP → PROJECT_STATE → README → AGENT.md.
Nessuna funzione è finita senza test che la coprono, nello stesso commit. Nessuna funzione è finita senza test che la coprono, nello stesso commit.
2. I doc stanno nel repo e cambiano con lo stesso commit del codice a cui si riferiscono. 2. I doc stanno nel repo e cambiano con lo stesso commit del codice a cui si riferiscono.
3. Una modifica non deve lasciare i doc disallineati. 3. Una modifica non deve lasciare i doc disallineati.
@@ -39,3 +50,5 @@ Se il nome cambia di nuovo, aggiornare solo questi punti:
| [0001](adr/0001-gui-multipiattaforma-avalonia.md) | GUI multipiattaforma in solo C# con Avalonia | Accettata | | [0001](adr/0001-gui-multipiattaforma-avalonia.md) | GUI multipiattaforma in solo C# con Avalonia | Accettata |
| [0002](adr/0002-motori-cli-claude-codex-antigravity.md) | Più motori CLI (Claude Code, Codex, Antigravity) su Windows e Linux | Accettata (Claude Code, Codex) | | [0002](adr/0002-motori-cli-claude-codex-antigravity.md) | Più motori CLI (Claude Code, Codex, Antigravity) su Windows e Linux | Accettata (Claude Code, Codex) |
| [0003](adr/0003-strategia-di-test.md) | Strategia di test e regola "nuova funzione = nuovi test" | Proposta | | [0003](adr/0003-strategia-di-test.md) | Strategia di test e regola "nuova funzione = nuovi test" | Proposta |
| [0004](adr/0004-aggiornamento-dei-cli.md) | Aggiornamento dei CLI dalle Impostazioni | Proposta |
| [0005](adr/0005-windows-senza-console.md) | Windows: eseguibile senza finestra di console | Proposta |
+7 -3
View File
@@ -1,6 +1,6 @@
# Roadmap # Roadmap
Dettagli dell'MVP in [MVP.md](MVP.md). Dettagli dell'MVP in [MVP.md](MVP.md). Stadio attuale e debiti: [PROJECT_STATE.md](PROJECT_STATE.md) (siamo in fase di **MVP**).
## Fase 0 — Doc-first ## Fase 0 — Doc-first
- [x] Scrivere MVP.md e ROADMAP.md - [x] Scrivere MVP.md e ROADMAP.md
@@ -26,7 +26,7 @@ Dettagli dell'MVP in [MVP.md](MVP.md).
- [ ] Test automatici e CI (vedi Fase 6) - [ ] Test automatici e CI (vedi Fase 6)
## Fase 4 — Più motori (Claude Code, Codex, Antigravity) ## Fase 4 — Più motori (Claude Code, Codex, Antigravity)
Decisione, tabella dei comandi e rischi: [ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md). Qui solo i passi. Va fatta dopo (o insieme a) la Fase 5, che estrae il punto unico di avvio processo. Decisione, tabella dei comandi e rischi: [ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md). Qui solo i passi. Il punto unico di avvio processo l'ha estratto la Fase 5.
- [x] Verificare i flag reali di `codex` (provati su Linux/WSL, ADR-0002 accettata per Claude Code e Codex); `agy` e Windows da verificare - [x] Verificare i flag reali di `codex` (provati su Linux/WSL, ADR-0002 accettata per Claude Code e Codex); `agy` e Windows da verificare
- [x] Astrazione "motore" in C# (`Core/Engine.cs`, `Core/EngineRunner.cs`) - [x] Astrazione "motore" in C# (`Core/Engine.cs`, `Core/EngineRunner.cs`)
@@ -39,6 +39,9 @@ Decisione, tabella dei comandi e rischi: [ADR-0002](adr/0002-motori-cli-claude-c
- [x] Permessi di Codex in sola lettura (nessun flag che salta i controlli) - [x] Permessi di Codex in sola lettura (nessun flag che salta i controlli)
- [ ] Opzione esplicita per concedere permessi di scrittura - [ ] Opzione esplicita per concedere permessi di scrittura
- [x] CLI: opzione `--engine`, coerente con la GUI - [x] CLI: opzione `--engine`, coerente con la GUI
- [x] Aggiornamento dei CLI dalle Impostazioni, un pulsante per CLI con `update` ufficiale ed esito leggibile ([ADR-0004](adr/0004-aggiornamento-dei-cli.md))
- [x] Controllo preventivo della versione più recente (sorgenti ufficiali, cache di 5 minuti); pulsante Aggiorna evidenziato e puntino sul pulsante Impostazioni solo se c'è una versione nuova
- [ ] Provare gli aggiornamenti reali (finora provati solo con CLI finti, e rilevamento del metodo di installazione sui percorsi reali) su Linux e Windows (installazione nativa e npm) e portare l'ADR-0004 ad "Accettata"
## Fase 5 — Multipiattaforma (Windows + Linux), GUI in solo C# ## Fase 5 — Multipiattaforma (Windows + Linux), GUI in solo C#
Decisione e motivazioni: [ADR-0001](adr/0001-gui-multipiattaforma-avalonia.md). Qui solo i passi. Decisione e motivazioni: [ADR-0001](adr/0001-gui-multipiattaforma-avalonia.md). Qui solo i passi.
@@ -53,8 +56,9 @@ Decisione e motivazioni: [ADR-0001](adr/0001-gui-multipiattaforma-avalonia.md).
- [x] Rendering markdown in Avalonia (titoli, liste, tabelle, citazioni, codice), pulsante Copia, link nel browser di sistema - [x] Rendering markdown in Avalonia (titoli, liste, tabelle, citazioni, codice), pulsante Copia, link nel browser di sistema
- [x] Tema chiaro/scuro che segue il sistema, con i token di MVP.md → "Design (UI/UX)" (da provare su un desktop Linux reale) - [x] Tema chiaro/scuro che segue il sistema, con i token di MVP.md → "Design (UI/UX)" (da provare su un desktop Linux reale)
- [x] Eliminare `ui.html` e il protocollo `WebMessage` - [x] Eliminare `ui.html` e il protocollo `WebMessage`
- [x] Windows: eseguibile senza finestra di console, la CLI riaggancia il terminale padre ([ADR-0005](adr/0005-windows-senza-console.md)); da provare su Windows nativo
- [ ] Publish single-file self-contained `win-x64` e `linux-x64`: compilano e partono (Linux: CLI e GUI su WSLg; Windows: solo CLI, via WSL); da provare la GUI su Windows nativo e su una distribuzione Linux pulita - [ ] Publish single-file self-contained `win-x64` e `linux-x64`: compilano e partono (Linux: CLI e GUI su WSLg; Windows: solo CLI, via WSL); da provare la GUI su Windows nativo e su una distribuzione Linux pulita
- [x] Aggiornare README.md e CLAUDE.md (comandi, architettura, vincoli) a migrazione conclusa - [x] Aggiornare README.md e AGENT.md (già CLAUDE.md: comandi, architettura, vincoli) a migrazione conclusa
## Fase 6 — Test e copertura completa ## Fase 6 — Test e copertura completa
Decisione: [ADR-0003](adr/0003-strategia-di-test.md). Piano, soglie e matrice: [TESTING.md](TESTING.md). Da questa fase in poi vale la regola: ogni nuova funzione arriva con i suoi test. Decisione: [ADR-0003](adr/0003-strategia-di-test.md). Piano, soglie e matrice: [TESTING.md](TESTING.md). Da questa fase in poi vale la regola: ogni nuova funzione arriva con i suoi test.
+38 -2
View File
@@ -10,7 +10,7 @@ Decisioni (strumenti, livelli, struttura): [ADR-0003](adr/0003-strategia-di-test
- Una riga senza test non è copertura: va lasciata `[ ]` e conta come debito visibile. - Una riga senza test non è copertura: va lasciata `[ ]` e conta come debito visibile.
## Flusso (estende il doc-first di [README.md](README.md)) ## Flusso (estende il doc-first di [README.md](README.md))
ADR (se serve) → MVP.md (requisito e criterio) → riga in questa matrice → test che falliscono → codice → test verdi → ROADMAP/README/CLAUDE.md. ADR (se serve) → MVP.md (requisito e criterio) → riga in questa matrice → test che falliscono → codice → test verdi → ROADMAP/README/AGENT.md.
## Livelli ## Livelli
| Livello | Cosa prova | Come | | Livello | Cosa prova | Come |
@@ -32,6 +32,7 @@ tests/FakeClaude/ eseguibile finto: registra argv/cwd/stdin; testo,
## Predisposizioni di testabilità (prerequisito dei test) ## Predisposizioni di testabilità (prerequisito dei test)
- [ ] `ChatStore` come istanza con cartella iniettata (oggi statico su `LocalApplicationData`) - [ ] `ChatStore` come istanza con cartella iniettata (oggi statico su `LocalApplicationData`)
- [ ] `IEngineRunner` dietro `Core/EngineRunner.cs`, iniettato nel `MainViewModel` - [ ] `IEngineRunner` dietro `Core/EngineRunner.cs`, iniettato nel `MainViewModel`
- [x] `EngineUpdater.CheckAsync` accetta un `HttpClient`: i test usano un gestore finto (rete assente, risposta non valida, versioni di prova)
- [ ] `InternalsVisibleTo` verso il progetto di test - [ ] `InternalsVisibleTo` verso il progetto di test
- [ ] Spostamento in `src/` e `tests/` con soluzione unica - [ ] Spostamento in `src/` e `tests/` con soluzione unica
@@ -82,6 +83,31 @@ Le righe CL valgono per ogni motore; queste sono specifiche di Codex (ADR-0002).
| CX-11 | In modalità CLI (output ereditato) non si usa `--json` | U | `Codex_cli_senza_json` | [ ] | | CX-11 | In modalità CLI (output ereditato) non si usa `--json` | U | `Codex_cli_senza_json` | [ ] |
| CX-12 | Con un `FakeClaude` configurato come Codex il ciclo primo messaggio + ripresa funziona (id letto e riusato) | P | `Codex_ciclo_completo_con_finto` | [ ] | | CX-12 | Con un `FakeClaude` configurato come Codex il ciclo primo messaggio + ripresa funziona (id letto e riusato) | P | `Codex_ciclo_completo_con_finto` | [ ] |
### Aggiornamento dei CLI — `Core/EngineUpdater.cs`, `Gui/MainViewModel.cs` (ADR-0004)
Si provano con `FakeClaude`/`FakeCodex` che rispondono a `--version` e `update`; nessun test aggiorna un CLI reale.
| ID | Requisito | Liv. | Test | |
|---|---|---|---|---|
| UP-01 | Versione letta da `--version` (prima riga ripulita); eseguibile assente ⇒ versione nulla | P | `Versione_letta` | [ ] |
| UP-02 | Versione cambiata dopo `update` ⇒ esito "Aggiornato da X a Y" | P | `Aggiornato` | [ ] |
| UP-03 | Exit 0 e versione invariata ⇒ "Già aggiornato (X)" | P | `Gia_aggiornato` | [ ] |
| UP-04 | Exit ≠ 0 ⇒ errore con le ultime righe dell'output e il comando manuale | P | `Aggiornamento_fallito` | [ ] |
| UP-05 | Tempo massimo superato ⇒ processo terminato ed errore chiaro | P | `Aggiornamento_scaduto` | [ ] |
| UP-06 | Eseguibile assente ⇒ riga non offerta / errore "non trovato" | U | `Aggiornamento_senza_eseguibile` | [ ] |
| UP-07 | Metodo di installazione dedotto dal percorso reale (npm, Homebrew, WinGet, nativo) con collegamenti simbolici risolti | U | `Metodo_di_installazione` | [ ] |
| UP-08 | Comando manuale corretto per ogni coppia motore × metodo (tabella dell'ADR-0004) | U | `Comando_manuale` | [ ] |
| UP-09 | Un solo aggiornamento alla volta; durante una risposta in corso i pulsanti sono disabilitati e la chat non parte durante l'aggiornamento | U | `Aggiornamento_esclusivo` | [ ] |
| UP-10 | Dopo un aggiornamento riuscito le versioni mostrate si rileggono; la chat aperta resta invariata | U | `Versioni_rilette` | [ ] |
| UP-11 | Le righe di aggiornamento compaiono solo per i CLI installati | U/G | `Righe_solo_installati` | [ ] |
| UP-12 | Il pulsante Aggiorna del riquadro agisce solo sul CLI della sua riga | G | `Pulsante_per_riga` | [ ] |
| UP-13 | Nessun aggiornamento parte senza un clic | U | `Nessun_aggiornamento_automatico` | [ ] |
| UP-14 | Claude Code: l'ultima versione si legge dal testo di `…/claude-code-releases/latest` (spazi e a capo ripuliti) | U | `Ultima_versione_claude` | [ ] |
| UP-15 | Codex: l'ultima versione si legge da `tag_name` della release GitHub (`rust-v0.162.1` ⇒ 0.162.1); intestazione User-Agent inviata | U | `Ultima_versione_codex` | [ ] |
| UP-16 | Confronto: ultima > installata ⇒ disponibile; uguale o più nuova ⇒ aggiornato; versioni con testo attorno (`2.1.300 (Claude Code)`, `codex-cli 0.162.1`) lette bene | U | `Confronto_versioni` | [ ] |
| UP-17 | Rete assente, risposta non valida o timeout ⇒ stato "sconosciuto", nessuna eccezione, pulsante normale | U | `Controllo_senza_rete` | [ ] |
| UP-18 | Disponibile ⇒ riga con "Aggiornamento disponibile: X", pulsante evidenziato e puntino sul pulsante Impostazioni; aggiornato ⇒ nessuno dei tre | U/G | `Evidenziazione_aggiornamento` | [ ] |
| UP-19 | Il controllo parte all'avvio e all'apertura del riquadro solo se l'ultimo ha più di 5 minuti; dopo un aggiornamento riuscito si ripete; non blocca invio né interfaccia | U | `Quando_si_controlla` | [ ] |
| UP-20 | Il controllo non installa nulla e non modifica i CLI | P | `Controllo_in_sola_lettura` | [ ] |
### Cronologia — `Core/ChatStore.cs`, `Core/AppInfo.cs` ### Cronologia — `Core/ChatStore.cs`, `Core/AppInfo.cs`
| ID | Requisito | Liv. | Test | | | ID | Requisito | Liv. | Test | |
|---|---|---|---|---| |---|---|---|---|---|
@@ -111,6 +137,7 @@ Le righe CL valgono per ogni motore; queste sono specifiche di Codex (ADR-0002).
| VM-08 | Durante l'attesa: Invia e Nuova chat disabilitati; aprire/eliminare è ignorato | U | `Occupato_blocca_azioni` | [ ] | | VM-08 | Durante l'attesa: Invia e Nuova chat disabilitati; aprire/eliminare è ignorato | U | `Occupato_blocca_azioni` | [ ] |
| VM-09 | Modello: "Predefinito" ⇒ nessun flag; modello scelto ⇒ ID; "Altro ID…" ⇒ testo libero ripulito | U | `Scelta_modello` | [ ] | | VM-09 | Modello: "Predefinito" ⇒ nessun flag; modello scelto ⇒ ID; "Altro ID…" ⇒ testo libero ripulito | U | `Scelta_modello` | [ ] |
| VM-10 | Effort: "Predefinito" ⇒ nessun flag; altrimenti il valore | U | `Scelta_effort` | [ ] | | VM-10 | Effort: "Predefinito" ⇒ nessun flag; altrimenti il valore | U | `Scelta_effort` | [ ] |
| VM-20 | Valori iniziali: modello più piccolo del motore (Claude Code: Haiku 5.5; Codex: GPT-5.6 Luna) ed effort `low`; il primo invio passa `--model`/`--effort` (o `-m`/`-c model_reasoning_effort`) con quei valori | U | `Valori_iniziali` | [ ] |
| VM-11 | Nuova chat: svuota la vista, nuovo guid, `started` falso, elenco aggiornato | U | `Nuova_chat` | [ ] | | VM-11 | Nuova chat: svuota la vista, nuovo guid, `started` falso, elenco aggiornato | U | `Nuova_chat` | [ ] |
| VM-12 | Errore di I/O nel salvataggio non interrompe l'invio né cancella i messaggi | U | `Salvataggio_fallito_non_perde_chat` | [ ] | | VM-12 | Errore di I/O nel salvataggio non interrompe l'invio né cancella i messaggi | U | `Salvataggio_fallito_non_perde_chat` | [ ] |
| VM-13 | Apertura chat: carica messaggi, `started` e id; chat inesistente ⇒ elenco ricaricato | U | `Apri_chat` | [ ] | | VM-13 | Apertura chat: carica messaggi, `started` e id; chat inesistente ⇒ elenco ricaricato | U | `Apri_chat` | [ ] |
@@ -165,6 +192,15 @@ Le righe CL valgono per ogni motore; queste sono specifiche di Codex (ADR-0002).
| UI-15 | Il nome dell'app compare nel titolo della finestra e nella barra laterale | G | `Nome_app_visibile` | [ ] | | UI-15 | Il nome dell'app compare nel titolo della finestra e nella barra laterale | G | `Nome_app_visibile` | [ ] |
### Eseguibile pubblicato ### Eseguibile pubblicato
Righe WIN: console su Windows (ADR-0005).
| ID | Requisito | Liv. | Test | |
|---|---|---|---|---|
| WIN-01 | L'eseguibile `win-x64` pubblicato ha sottosistema "Windows GUI" (intestazione PE); quello `linux-x64` non è interessato | E | `Sottosistema_gui` | [ ] |
| WIN-02 | CLI con output reindirizzato su file o pipe: l'output arriva, handle ereditati non toccati | E | `Cli_con_output_reindirizzato` | [ ] |
| WIN-03 | CLI da un terminale: output visibile (`AttachConsole` + `CONOUT$`); senza terminale padre l'attacco fallisce in silenzio e l'app prosegue | E (manuale su Windows nativo) | `Cli_con_terminale_padre` | [ ] |
| WIN-04 | Exit code corretto quando il chiamante attende il processo (`start /wait`, `Start-Process -Wait`) | E (manuale su Windows nativo) | `ExitCode_con_attesa` | [ ] |
| WIN-05 | Il codice di `ConsoleHost` non fa nulla su Linux/macOS | U | `ConsoleHost_non_windows` | [ ] |
| ID | Requisito | Liv. | Test | | | ID | Requisito | Liv. | Test | |
|---|---|---|---|---| |---|---|---|---|---|
| PUB-01 | Il publish single-file `linux-x64` si compila e la CLI risponde con `FakeClaude` | E | `Publish_linux_smoke` | [ ] | | PUB-01 | Il publish single-file `linux-x64` si compila e la CLI risponde con `FakeClaude` | E | `Publish_linux_smoke` | [ ] |
@@ -185,7 +221,7 @@ Per **ogni** motore, la stessa batteria di contratto:
| EN-08 | Impostazioni persistite e rilette | U | [ ] | | EN-08 | Impostazioni persistite e rilette | U | [ ] |
| EN-09 | Gestione del blocco di `agy -p` con output rediretto (timeout, errore chiaro) | P | [ ] | | EN-09 | Gestione del blocco di `agy -p` con output rediretto (timeout, errore chiaro) | P | [ ] |
| EN-10 | `Engines.Find` per id (`claude`, `codex`, sconosciuto ⇒ nullo); l'id salvato nei JSON resta stabile | U | [ ] | | EN-10 | `Engines.Find` per id (`claude`, `codex`, sconosciuto ⇒ nullo); l'id salvato nei JSON resta stabile | U | [ ] |
| EN-11 | Cambiare CLI nelle Impostazioni apre una nuova chat con quel motore; modello ed effort tornano a "Predefinito"; liste secondo il motore | U | [ ] | | EN-11 | Cambiare CLI nelle Impostazioni apre una nuova chat con quel motore; modello ed effort tornano ai valori iniziali del nuovo motore (modello più piccolo, `low`); liste secondo il motore | U | [ ] |
| EN-12 | Motore non installato: etichetta "non installato", non selezionabile; il VM rifiuta la selezione | U/G | [ ] | | EN-12 | Motore non installato: etichetta "non installato", non selezionabile; il VM rifiuta la selezione | U/G | [ ] |
| EN-13 | L'interruttore CLI è disabilitato durante l'attesa | U/G | [ ] | | EN-13 | L'interruttore CLI è disabilitato durante l'attesa | U/G | [ ] |
| EN-14 | Aprendo una chat salvata il selettore passa al motore della chat; sessione e `started` coerenti | U | [ ] | | EN-14 | Aprendo una chat salvata il selettore passa al motore della chat; sessione e `started` coerenti | U | [ ] |
@@ -33,7 +33,7 @@ La GUI viene riscritta con **Avalonia UI**:
- Un solo progetto con target `net10.0` (non più `net10.0-windows`). Due publish single-file self-contained: `win-x64` e `linux-x64`. - Un solo progetto con target `net10.0` (non più `net10.0-windows`). Due publish single-file self-contained: `win-x64` e `linux-x64`.
- La CLI (`Program.cs` con argomenti) resta com'è e funziona su entrambi i sistemi. - La CLI (`Program.cs` con argomenti) resta com'è e funziona su entrambi i sistemi.
- La cronologia usa `Environment.SpecialFolder.LocalApplicationData` (`%LOCALAPPDATA%` su Windows, `~/.local/share` su Linux), sottocartella `<nome-app>/chats`. Il nome viene da un'unica costante (vedi [Nome del progetto](../README.md#nome-del-progetto)). - La cronologia usa `Environment.SpecialFolder.LocalApplicationData` (`%LOCALAPPDATA%` su Windows, `~/.local/share` su Linux), sottocartella `<nome-app>/chats`. Il nome viene da un'unica costante (vedi [Nome del progetto](../README.md#nome-del-progetto)).
- La logica di avvio del processo (cartella dell'exe, stdin chiuso, `ArgumentList`) viene estratta in **un solo punto** condiviso da CLI e GUI, eliminando la duplicazione oggi segnalata in `CLAUDE.md`. Si lega all'astrazione "motore" di [ADR-0002](0002-motori-cli-claude-codex-antigravity.md). - La logica di avvio del processo (cartella dell'exe, stdin chiuso, `ArgumentList`) viene estratta in **un solo punto** condiviso da CLI e GUI, eliminando la duplicazione oggi segnalata in `AGENT.md` (già `CLAUDE.md`). Si lega all'astrazione "motore" di [ADR-0002](0002-motori-cli-claude-codex-antigravity.md).
- L'aspetto (token di colore, tipografia, accessibilità) resta definito in [MVP.md](../MVP.md) → "Design (UI/UX)", tradotto in risorse/stili Avalonia. Il tema segue il sistema (chiaro/scuro) tramite `ThemeVariant`. - L'aspetto (token di colore, tipografia, accessibilità) resta definito in [MVP.md](../MVP.md) → "Design (UI/UX)", tradotto in risorse/stili Avalonia. Il tema segue il sistema (chiaro/scuro) tramite `ThemeVariant`.
## Conseguenze ## Conseguenze
@@ -14,10 +14,10 @@ L'app lancia solo `claude -p`. Si vuole usare dalla stessa chat anche **OpenAI C
4. Nessuna scorciatoia che disattivi i controlli di permesso senza una scelta esplicita dell'utente. 4. Nessuna scorciatoia che disattivi i controlli di permesso senza una scelta esplicita dell'utente.
## Decisione ## Decisione
- **Astrazione "motore"** in C#. Ogni motore descrive: nome e eseguibile, argomenti per il primo messaggio e per la ripresa, elenco modelli, supporto effort, modo per ottenere l'id di sessione. `RunClaude` diventa `RunEngine(engine, …)`. - **Astrazione "motore"** in C#. Ogni motore descrive: nome e eseguibile, argomenti per il primo messaggio e per la ripresa, elenco modelli, supporto effort, modo per ottenere l'id di sessione. `RunClaude` è diventato `EngineRunner` con il motore come parametro.
- **Rilevamento** dei motori cercando l'eseguibile nel PATH (su Windows anche le estensioni di PATHEXT). I motori assenti sono disabilitati nelle Impostazioni, con messaggio chiaro; la CLI esce con 127 come oggi. - **Rilevamento** dei motori cercando l'eseguibile nel PATH (su Windows anche le estensioni di PATHEXT). I motori assenti sono disabilitati nelle Impostazioni, con messaggio chiaro; la CLI esce con 127 come oggi.
- **Una chat = un motore**. Il file JSON della chat memorizza il motore; il contesto di sessione non passa da un motore all'altro, quindi cambiare motore apre una nuova chat. - **Una chat = un motore**. Il file JSON della chat memorizza il motore; il contesto di sessione non passa da un motore all'altro, quindi cambiare motore apre una nuova chat.
- **Impostazioni** nella GUI: interruttore **CLI** (motore attivo), modello, effort. Cambiare motore apre una nuova chat; modello ed effort tornano a "Predefinito" e le liste sono quelle del motore. La persistenza su disco delle impostazioni è rinviata. La CLI ottiene `--engine <id>` (`claude`, `codex`). - **Impostazioni** nella GUI: interruttore **CLI** (motore attivo), modello, effort. Cambiare motore apre una nuova chat; modello ed effort tornano ai valori iniziali del motore (il modello più piccolo ed effort `low`; "Predefinito" resta selezionabile) e le liste sono quelle del motore. La persistenza su disco delle impostazioni è rinviata. La CLI ottiene `--engine <id>` (`claude`, `codex`).
- **Sessione**: per Claude Code l'id lo sceglie l'app; per Codex lo genera Codex e l'app lo legge dall'output (`thread_id`). Il JSON della chat ha quindi un campo `Engine` e un campo `SessionId` separato dall'id della chat (che resta il nome del file). I file scritti prima (senza questi campi) si leggono come chat di Claude Code con `SessionId` = id della chat. - **Sessione**: per Claude Code l'id lo sceglie l'app; per Codex lo genera Codex e l'app lo legge dall'output (`thread_id`). Il JSON della chat ha quindi un campo `Engine` e un campo `SessionId` separato dall'id della chat (che resta il nome del file). I file scritti prima (senza questi campi) si leggono come chat di Claude Code con `SessionId` = id della chat.
- **Autore dei messaggi**: l'etichetta sulle risposte e i segnaposto del composer usano il nome del motore della chat; l'elenco chat indica il motore. - **Autore dei messaggi**: l'etichetta sulle risposte e i segnaposto del composer usano il nome del motore della chat; l'elenco chat indica il motore.
- **Permessi**: di default sola lettura / nessun bypass dei controlli; concedere di più è un'opzione esplicita. - **Permessi**: di default sola lettura / nessun bypass dei controlli; concedere di più è un'opzione esplicita.
@@ -43,6 +43,7 @@ Claude Code e Codex sono verificati con prove reali (Codex 0.144.3, 2026-10-15,
- `--` prima del prompt evita che un prompt che inizia con `-` sia letto come opzione (verificato). - `--` prima del prompt evita che un prompt che inizia con `-` sia letto come opzione (verificato).
- Lo stdin va chiuso subito, come per Claude Code: altrimenti Codex stampa "Reading additional input from stdin…" e attende. - Lo stdin va chiuso subito, come per Claude Code: altrimenti Codex stampa "Reading additional input from stdin…" e attende.
- Il modello predefinito è quello di `~/.codex/config.toml`. Se richiede una versione più recente di Codex l'errore è chiaro (`requires a newer version of Codex`): l'app lo mostra e [INSTALL.md](../INSTALL.md) indica `codex update`. - Il modello predefinito è quello di `~/.codex/config.toml`. Se richiede una versione più recente di Codex l'errore è chiaro (`requires a newer version of Codex`): l'app lo mostra e [INSTALL.md](../INSTALL.md) indica `codex update`.
- Il modello più piccolo di Codex è assunto essere GPT-5.6 Luna (nome e supporto agli effort inferiori: non dichiarato da OpenAI nelle prove); da rivedere quando cambia il catalogo.
- Il catalogo modelli di Codex è dinamico (`~/.codex/models_cache.json`); l'app ne usa uno fisso, da aggiornare, con "Predefinito" e "Altro ID…" sempre disponibili. - Il catalogo modelli di Codex è dinamico (`~/.codex/models_cache.json`); l'app ne usa uno fisso, da aggiornare, con "Predefinito" e "Altro ID…" sempre disponibili.
## Conseguenze ## Conseguenze
+72
View File
@@ -0,0 +1,72 @@
# ADR-0004 — Aggiornamento dei CLI dalle Impostazioni
- **Stato**: Proposta
- **Data**: 2026-10-15
- **Collegato a**: [ADR-0002](0002-motori-cli-claude-codex-antigravity.md) (motori), [INSTALL.md](../INSTALL.md)
## Contesto
L'app usa i CLI già installati dall'utente. Un CLI vecchio può smettere di funzionare senza che l'app c'entri: su questa macchina Codex 0.144.3 ha come modello predefinito (`~/.codex/config.toml`) `gpt-6-astra`, che richiede un Codex più recente, e ogni messaggio con "Predefinito" fallisce con `requires a newer version of Codex`. L'unico rimedio è aggiornare il CLI, oggi da terminale, e l'utente non sa nemmeno che esiste una versione nuova.
Sulla macchina di sviluppo il 2026-10-15 i due CLI sono stati poi aggiornati (Codex 0.144.3 → 0.162.1, Claude Code 2.1.252 → 2.1.300) e Codex con il modello predefinito risponde: il problema si risolve aggiornando. Resta il bisogno di saperlo e di farlo dall'app.
Entrambi i CLI hanno un comando di aggiornamento che controlla e, se c'è una versione nuova, la installa: `claude update` (alias `upgrade`: "Check for updates and install if available") e `codex update` ("Update Codex to the latest version"). Verificato con `--help` il 2026-10-15; l'esecuzione reale non è ancora stata provata.
## Criteri di decisione
1. L'app dice se c'è una versione nuova **prima** di proporre l'aggiornamento: evidenzia solo dove serve.
1. L'utente aggiorna un CLI alla volta, senza uscire dall'app.
2. L'app non tocca nulla senza un gesto esplicito (nessun aggiornamento automatico).
3. Si usa il comando ufficiale del CLI, non una procedura inventata dall'app.
4. Se l'aggiornamento non è possibile (installazione via gestore di pacchetti, permessi, rete) l'utente vede il motivo e il comando manuale giusto.
5. Funziona su Windows e Linux e non blocca la GUI.
## Decisione
- Nel riquadro Impostazioni, sezione **Aggiornamenti**: una riga per ogni CLI installato con nome, versione e pulsante **Aggiorna**. Ogni pulsante agisce solo su quel CLI.
- **Controllo prima dell'aggiornamento** (sola lettura, nessuna installazione): l'app confronta la versione installata (`<cli> --version`) con l'ultima pubblicata.
- Claude Code: `GET https://downloads.claude.ai/claude-code-releases/latest`, testo con la versione (la stessa sorgente dell'installer nativo).
- Codex: `GET https://api.github.com/repos/openai/codex/releases/latest`, campo `tag_name` (es. `rust-v0.162.1`, si estrae `0.162.1`).
- Le versioni si ricavano con il primo numero `N.N.N` del testo e si confrontano come versioni. Verificate il 2026-10-15: restituivano 2.1.300 e 0.162.1.
- **Disponibile** (ultima > installata): la riga mostra "Aggiornamento disponibile: X", il pulsante Aggiorna è **evidenziato** (colore d'accento) e un puntino d'accento compare sul pulsante Impostazioni. **Aggiornato** (uguale o più nuova): riga neutra con "Aggiornato", pulsante normale, nessun puntino; resta cliccabile per forzare `update`. **Sconosciuto** (rete assente, risposta non valida, timeout di 10 s): "Controllo non riuscito", pulsante normale, nessun errore invasivo.
- Quando si controlla: all'avvio, in background, e ogni volta che si apre il riquadro Impostazioni se l'ultimo controllo ha più di 5 minuti; subito dopo un aggiornamento. Mai in modo da rallentare la chat. Le richieste non inviano identificativi; l'app contatta solo i due indirizzi sopra.
- **Flusso** di un clic: legge la versione (`<cli> --version`), lancia `<cli> update` (stdin chiuso, output catturato, tempo massimo 10 minuti), rilegge la versione e mostra l'esito sulla riga:
- versione cambiata ⇒ "Aggiornato da X a Y";
- exit 0 e versione invariata ⇒ "Già aggiornato (X)";
- exit ≠ 0, tempo scaduto o eseguibile assente ⇒ errore con le ultime righe dell'output e il **comando manuale** adatto (sotto).
- Pulsanti disabilitati mentre una risposta è in corso o un altro aggiornamento è attivo; la chat non parte durante l'aggiornamento.
- **Comando manuale** scelto dal metodo di installazione, dedotto dal percorso reale dell'eseguibile (collegamenti simbolici risolti):
| Percorso contiene | Metodo | Claude Code | Codex |
|---|---|---|---|
| `node_modules`, `.npm` | npm | `npm install -g @anthropic-ai/claude-code@latest` | `npm install -g @openai/codex@latest` |
| `Cellar`, `homebrew`, `linuxbrew` | Homebrew | `brew upgrade claude-code` (o `claude-code@latest`) | `brew upgrade --cask codex` |
| `WinGet`, `WindowsApps` | WinGet | `winget upgrade Anthropic.ClaudeCode` | script PowerShell di [INSTALL.md](../INSTALL.md) |
| altro | nativo/script | `claude update` da terminale | script di installazione di [INSTALL.md](../INSTALL.md) |
L'app **mostra** il comando, non lo esegue: un'installazione globale con npm o un gestore di pacchetti può richiedere permessi o scelte che spettano all'utente.
- Dopo un aggiornamento riuscito le versioni mostrate si rileggono; la chat aperta non cambia.
- L'aggiornamento di un CLI non rilancia la chat in corso: l'eventuale errore di versione già mostrato resta nella cronologia.
## Opzioni considerate
| Opzione | Esito | Motivo |
|---|---|---|
| Solo documentare `codex update` | Scartata | L'utente deve uscire dall'app e conoscere il comando. |
| Solo `update`, senza controllo preventivo | Scartata | Non dice se serve e non può evidenziare il pulsante: `update` controlla ma installa subito. |
| Controllo con `npm view` | Scartata | Richiede npm anche per installazioni native. |
| Aggiornamento automatico all'avvio | Scartata | Modifica programmi dell'utente senza un suo gesto. |
| Fallback automatico a npm/brew/winget | Scartata | Permessi (`sudo`), scelta del canale e rischi di installazioni doppie spettano all'utente. |
| **Controllo con le sorgenti ufficiali (annuncio delle versioni) + pulsante per CLI con `update` ufficiale + comando manuale suggerito** | **Scelta** | Ufficiale, sicura, uguale su Windows e Linux, evidenzia solo quando serve. |
## Conseguenze
**Positive**: il caso "richiede un Codex più recente" si risolve dall'app; l'esito è comprensibile; nessuna azione nascosta.
**Negative / costi**: il controllo richiede rete e due indirizzi esterni (GitHub ha un limite di richieste anonime, per questo c'è la cache di 5 minuti); il canale scelto da Claude Code (`latest` o `stable`) può dare un "disponibile" che `claude update` non installa, e in quel caso l'esito dopo l'aggiornamento è "Già aggiornato"; l'esito dipende dal testo e dal comportamento dei comandi `update` dei CLI, che possono cambiare; su Windows l'aggiornamento di un eseguibile in uso da un'altra sessione può fallire; un controllo della versione senza installare non c'è.
## Da verificare
- [ ] Il controllo evidenzia correttamente in tutti i casi (installato più vecchio, uguale, più nuovo di `latest`) e senza rete.
- [ ] Utente sul canale `stable` di Claude Code: il confronto con `latest` dà falsi "disponibile"; valutare di leggere anche `/stable` o `autoUpdatesChannel`.
- [ ] Esecuzione reale di `claude update` e `codex update` su Linux e Windows, con installazione nativa e con npm: esito, exit code e testo. (Su Linux/WSL i due CLI risultano aggiornati alle ultime versioni; non è stato registrato l'output.)
- [ ] Cosa stampano quando sono già aggiornati e quando falliscono per permessi.
- [ ] Che `--version` di entrambi si possa leggere in un secondo dopo l'aggiornamento (nessun file bloccato).
- [ ] Il tempo massimo di 10 minuti è adeguato (rete lenta).
## Riferimenti
- Passi: [ROADMAP.md](../ROADMAP.md), Fase 4.
- Matrice dei test: [TESTING.md](../TESTING.md), righe UP.
+45
View File
@@ -0,0 +1,45 @@
# ADR-0005 — Windows: eseguibile senza finestra di console
- **Stato**: Proposta
- **Data**: 2026-10-15
- **Collegato a**: [ADR-0001](0001-gui-multipiattaforma-avalonia.md) (GUI e piattaforme)
## Contesto
Su Windows l'eseguibile è di tipo "console" (`OutputType` `Exe`): con il doppio clic, oltre alla finestra della GUI si apre anche un terminale vuoto che resta aperto finché l'app gira. Il tipo console serve alla CLI (`agent-wiki-ui.exe "prompt"`), perché da terminale `cmd` e PowerShell aspettano la fine del programma, mostrano l'output e danno l'exit code. Un eseguibile "GUI" non ha console, ma allora la CLI perde queste proprietà. Su Linux il problema non esiste: nessuna finestra extra.
## Criteri di decisione
1. Doppio clic: solo la finestra della GUI.
2. La CLI deve continuare a mostrare l'output nel terminale da cui parte, anche con reindirizzamenti (`> file`, `| altro`).
3. Un solo file da distribuire, come per Linux.
4. Nessun cambiamento per Linux.
## Opzioni considerate
| Opzione | Esito | Motivo |
|---|---|---|
| Lasciare il tipo console e nascondere la finestra all'avvio (`FreeConsole`) | Scartata | La finestra compare comunque per un istante; con Windows Terminal come terminale predefinito può restare una scheda. |
| Due file: `agent-wiki-ui.exe` (senza console) e `agent-wiki-ui-cli.exe` (con console) | Alternativa valida | Nessuna perdita nella CLI (exit code corretto ovunque), ma due file da distribuire e da spiegare. Da riprendere se l'exit code della CLI diventa importante in Windows. |
| **Un solo `.exe` senza console; la CLI riaggancia il terminale padre** | **Scelta** | Un file, doppio clic pulito, output visibile nel terminale. |
## Decisione
- Il progetto usa `OutputType` **`WinExe`** (sottosistema Windows). Su Linux non cambia nulla.
- Con **argomenti** (modalità CLI) su Windows, `Core/ConsoleHost.cs` chiama `AttachConsole(ATTACH_PARENT_PROCESS)`: se parte da `cmd`, PowerShell o Windows Terminal l'app usa quel terminale. Se l'output standard non è già valido (non è reindirizzato) lo collega alla console (`CONOUT$`); se è un file o una pipe ereditati li lascia stare, così `> file` e `|` funzionano. Il motore avviato dopo eredita gli stessi handle.
- Senza terminale padre (doppio clic, avvio da un altro programma) l'attacco fallisce in silenzio e l'app prosegue.
- Senza argomenti (GUI) non si tocca la console.
## Conseguenze
**Positive**: il doppio clic mostra solo la finestra; un unico file; output e reindirizzamenti della CLI funzionano.
**Negative / costi — comportamento della CLI su Windows**:
- `cmd` e PowerShell **non aspettano** la fine di un programma a sottosistema Windows: il prompt torna subito e l'output compare dopo, mescolato al prompt.
- L'**exit code** non arriva a `%ERRORLEVEL%` né a `$LASTEXITCODE` in uso interattivo. Arriva se il chiamante aspetta il processo: `start /wait agent-wiki-ui.exe "prompt"` in `cmd`, `Start-Process -Wait -NoNewWindow` o `& .\agent-wiki-ui.exe "prompt" | Out-Host` in PowerShell, script e programmi che attendono il processo figlio. In pipeline (`| Out-Host`, `| more`) PowerShell attende.
- Su Linux e macOS il comportamento della CLI resta quello di sempre (exit code propagato, streaming).
- Il criterio di accettazione dell'MVP sull'exit code vale quindi, su Windows, solo se il chiamante attende il processo.
## Da verificare
- [ ] Doppio clic su Windows nativo: nessuna finestra di console.
- [ ] Da `cmd`, PowerShell e Windows Terminal: output visibile, reindirizzamento su file e pipe, exit code con `start /wait` e con `Start-Process -Wait`.
- [ ] Output corretto quando il processo è avviato da un altro programma senza terminale.
- [ ] Il sottosistema dell'eseguibile pubblicato risulta "Windows GUI" (controllato sull'intestazione PE).
## Riferimenti
- Passi: [ROADMAP.md](../ROADMAP.md), Fase 5.
- Righe di test: [TESTING.md](../TESTING.md), righe WIN.
+20
View File
@@ -0,0 +1,20 @@
# Crea gli eseguibili single-file self-contained in dist\<rid>\.
# Senza argomenti: win-x64 e linux-x64. Con argomenti: i rid indicati (es. .\scripts\publish.ps1 win-x64).
# Funziona su Windows PowerShell 5.1 e PowerShell 7 (la compilazione per un altro sistema non richiede quel sistema).
param([string[]]$Rids = @('win-x64', 'linux-x64'))
$ErrorActionPreference = 'Stop'
Set-Location (Split-Path -Parent $PSScriptRoot)
foreach ($rid in $Rids) {
Write-Host "== $rid"
dotnet publish agent-wiki-ui.csproj -c Release -r $rid --self-contained -p:PublishSingleFile=true -o "dist/$rid" --nologo -v quiet
if ($LASTEXITCODE -ne 0) { throw "publish fallito per $rid" }
Get-ChildItem "dist/$rid" -Filter *.pdb -Recurse | Remove-Item # simboli delle librerie native: inutili a chi usa l'app
}
Write-Host ''
Write-Host 'Eseguibili pronti:'
foreach ($rid in $Rids) {
Get-ChildItem "dist/$rid" -File | ForEach-Object { ' dist/{0}/{1} ({2:N0} MB)' -f $rid, $_.Name, ($_.Length / 1MB) }
}
+19
View File
@@ -0,0 +1,19 @@
#!/usr/bin/env bash
# Crea gli eseguibili single-file self-contained in dist/<rid>/.
# Senza argomenti: win-x64 e linux-x64. Con argomenti: i rid indicati (es. linux-arm64).
# Funziona da Linux, WSL e macOS (la compilazione per un altro sistema non richiede quel sistema).
set -euo pipefail
cd "$(dirname "$0")/.."
rids=("$@")
[ ${#rids[@]} -eq 0 ] && rids=(win-x64 linux-x64)
for rid in "${rids[@]}"; do
echo "== $rid"
dotnet publish agent-wiki-ui.csproj -c Release -r "$rid" --self-contained -p:PublishSingleFile=true -o "dist/$rid" --nologo -v quiet
find "dist/$rid" -name '*.pdb' -delete # simboli delle librerie native: inutili a chi usa l'app
done
echo
echo "Eseguibili pronti:"
for rid in "${rids[@]}"; do ls -lh "dist/$rid" | awk -v r="$rid" 'NR>1 {print " dist/" r "/" $9 " (" $5 ")"}'; done