Compare commits
30
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6080a65edc | ||
|
|
dc7dbbd3bb | ||
|
|
28201fbbda | ||
|
|
3587f35c2d | ||
|
|
b6574776b6 | ||
|
|
6bbaf7192f | ||
|
|
f2086de31d | ||
|
|
5870de6fda | ||
|
|
51993dd0c8 | ||
|
|
b3223fb579 | ||
|
|
15c664007d | ||
|
|
af171201b5 | ||
|
|
67d91e6a1f | ||
|
|
74abd11d3a | ||
|
|
f0e9fcfba5 | ||
|
|
99f6105556 | ||
|
|
c0c140b08d | ||
|
|
d4b6c3693a | ||
|
|
d7e8a341ab | ||
|
|
d6f293722e | ||
|
|
8b20f5224e | ||
|
|
6498e45a0d | ||
|
|
e60d64ed58 | ||
|
|
c50bd63723 | ||
|
|
007cc9bdfa | ||
|
|
fee788134d | ||
|
|
84fefda219 | ||
|
|
941d02110d | ||
|
|
9c6a679e6a | ||
|
|
c4c1ad4520 |
No files matched your search
@@ -1,2 +1,3 @@
|
||||
bin/
|
||||
obj/
|
||||
dist/
|
||||
@@ -0,0 +1,59 @@
|
||||
# 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`), Codex (`codex exec`) o Antigravity (`agy … -p`) 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` dalla radice (soluzione `agent-wiki-ui.slnx`: app in `src/agent-wiki-ui/`, test in `tests/`; `net10.0`, Avalonia)
|
||||
- GUI: `dotnet run --project src/agent-wiki-ui`; CLI: `dotnet run --project src/agent-wiki-ui -- "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 src/agent-wiki-ui -c Release -r win-x64 --self-contained -p:PublishSingleFile=true` e `-r linux-x64`
|
||||
- Test: `dotnet test` dalla radice (xUnit v3 + Avalonia.Headless con Skia reale; `tests/FakeClaude` è il `claude` finto per i test di processo). Per ora coprono le immagini e le formule del renderer, il `FakeClaude` e il motore Antigravity (AG-01…AG-12, UP-21); il resto è pianificato in docs/TESTING.md (Fase 6). 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](src/agent-wiki-ui/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](src/agent-wiki-ui/Core/Engine.cs): astrazione "motore" (ADR-0002): `Engine` (id, nome, eseguibile, modelli, effort, `BuildArgs`, `Parse`, `FetchLatestVersionAsync` per il controllo delle versioni), `ClaudeEngine`, `CodexEngine`, `AgyEngine`, 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](src/agent-wiki-ui/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](src/agent-wiki-ui/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](src/agent-wiki-ui/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](src/agent-wiki-ui/Core/AppInfo.cs): nome dell'app, letto dall'`AssemblyName` del csproj (unica sorgente).
|
||||
- [Gui/MainViewModel.cs](src/agent-wiki-ui/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](src/agent-wiki-ui/Gui/MainWindow.axaml) (+ `.cs`): layout XAML con binding compilati. [Gui/App.axaml](src/agent-wiki-ui/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](src/agent-wiki-ui/Gui/MarkdownView.cs): renderer markdown proprio (albero Markdig → controlli Avalonia, `DisableHtml`); la parte sulle immagini è in [Gui/MarkdownView.Images.cs](src/agent-wiki-ui/Gui/MarkdownView.Images.cs) (`partial`); le formule LaTeX (ADR-0008) sono in [Gui/MarkdownView.Math.cs](src/agent-wiki-ui/Gui/MarkdownView.Math.cs) (`partial`, libreria `Sylinko.CSharpMath.Avalonia`). Le immagini si mostrano solo da file locale (ADR-0006), mai da URL; i percorsi relativi si cercano nella cartella dell'exe e poi nelle superiori (radice della wiki).
|
||||
- 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, `agy` può bloccarsi su output rediretto (issue #318).
|
||||
- `claude` e `agy` sono eseguibili nativi (`~/.local/bin`, `~/.gemini/bin`), avviabili direttamente. Se fossero script `.cmd` (Windows) servirebbe `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).
|
||||
- Antigravity (`AgyEngine`): eseguibile `agy`; tutti i flag di configurazione vanno passati prima di `-p <prompt>`; per usare `agy` in modalità non interattiva (`-p`) in sola lettura, nel file `~/.gemini/antigravity-cli/settings.json` deve essere presente la regola `'read_file(*)'` sotto `'permissions.allow'` (altrimenti headless mode nega `read_file` con errore jetski: 'jetski: no output produced - a tool required the read_file permission that headless mode cannot prompt for'), mentre scritture e comandi restano negati di default; non passare `--mode plan` né `--mode auto` e mai usare `--dangerously-skip-permissions`; per la GUI si usa `--output-format json` e l'id di sessione si legge da `conversation_id` (`OwnsSessionId => true`); la ripresa della conversazione usa `--conversation <id>`; per evitare il blocco su sottoprocesso con output rediretto (issue #318) si passa `--print-timeout 120s` e si chiude immediatamente lo stdin.
|
||||
- Il controllo delle versioni contatta solo `downloads.claude.ai` (Claude Code), `api.github.com` (Codex, serve lo User-Agent) e `antigravity-cli-auto-updater-974169037036.us-central1.run.app` (Antigravity), 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.
|
||||
@@ -1,43 +1,5 @@
|
||||
# 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
|
||||
|
||||
LlmRun: eseguibile C# (.NET 10, Windows) che invoca Claude Code (`claude -p`) da terminale. Senza argomenti apre una GUI WinForms, con argomenti funziona da CLI. Non è un repo git.
|
||||
|
||||
## Workflow doc-first (obbligatorio)
|
||||
|
||||
- Specifica e criteri di accettazione: [docs/MVP.md](docs/MVP.md). Fasi e stato: [docs/ROADMAP.md](docs/ROADMAP.md). Uso: [README.md](README.md).
|
||||
- Ad ogni richiesta di modifica: aggiornare prima i doc interessati (MVP.md, ROADMAP.md con le spunte, README.md se cambia l'uso), poi il codice, poi questo file se cambiano comandi, design o vincoli. Nessuna modifica deve lasciare i doc disallineati.
|
||||
|
||||
## Comandi
|
||||
|
||||
- Build: `dotnet build` (LlmRun.csproj, net10.0-windows, WinForms)
|
||||
- GUI: `dotnet run`; CLI: `dotnet run -- "prompt"`
|
||||
- Publish single-file: `dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true`
|
||||
- Test: non esistono ancora.
|
||||
|
||||
## Architettura
|
||||
|
||||
- [Program.cs](Program.cs): top-level statements. Senza argomenti avvia `Gui`; con argomenti è la CLI (`claude -p <prompt>` con `ArgumentList`, stdout/stderr ereditati, exit code propagato, 127 se `claude` non è nel PATH).
|
||||
- [Gui.cs](Gui.cs): host WinForms sottile. Un solo WebView2 che carica [ui.html](ui.html) (embedded resource; `{{MODELS}}` è sostituito con le opzioni dei modelli). Pagina e C# dialogano con `WebMessage` JSON (protocollo in `docs/MVP.md`). Per ogni `send` C# lancia `claude -p` con stdout/stderr rediretti, converte la risposta da markdown a HTML con Markdig (`DisableHtml`) e la rimanda alla pagina. Contesto: `--session-id <guid>` al primo messaggio, `--resume <guid>` poi. Cronologia: un JSON per chat in `%LOCALAPPDATA%\LlmRun\chats\<guid>.json` (il nome file è l'id di sessione, validato come Guid prima dell'uso), salvato appena l'utente invia e di nuovo alla risposta; all'avvio (primo `list` dalla pagina) viene riaperta la chat più recente. `--model`/`--effort` omessi se "Predefinito". Lista modelli hardcoded in `Gui.Models`, da aggiornare quando escono nuovi modelli.
|
||||
- [ui.html](ui.html): tutta la UI (HTML+CSS+JS, nessuna libreria). Token di colore/tipografia come variabili CSS in cima; specifiche in `docs/MVP.md` → "Design (UI/UX)". Cambiando l'aspetto aggiornare quella sezione.
|
||||
- Dipendenze NuGet (solo GUI): Markdig, Microsoft.Web.WebView2.
|
||||
|
||||
## 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 di `claude` va redirezionato e chiuso subito, altrimenti aspetta 3s.
|
||||
- `claude` è un .exe nativo (`~/.local/bin`), avviabile direttamente. Se fosse `claude.cmd` serve `cmd.exe /c`.
|
||||
- La logica di avvio processo è duplicata tra CLI (`Program.cs`) e GUI (`Gui.cs`): se cambia (cartella di lavoro, stdin, flag), modificarla in entrambi i punti.
|
||||
- Nella GUI i link `http(s)` non devono navigare nella finestra: si aprono nel browser di sistema (`NavigationStarting`/`NewWindowRequested`).
|
||||
- La GUI deve girare su un thread STA (creato a mano in `Program.cs`, perché i top-level statements non hanno `[STAThread]`): senza, WebView2 fallisce con `RPC_E_CHANGED_MODE`.
|
||||
|
||||
## 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.
|
||||
@AGENT.md
|
||||
@@ -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
|
||||
@@ -1,211 +0,0 @@
|
||||
using System.Diagnostics;
|
||||
using System.Net;
|
||||
using System.Reflection;
|
||||
using System.Text.Json;
|
||||
using System.Windows.Forms;
|
||||
using Markdig;
|
||||
using Microsoft.Web.WebView2.Core;
|
||||
using Microsoft.Web.WebView2.WinForms;
|
||||
|
||||
// Host sottile: l'interfaccia vive in ui.html (embedded). Protocollo messaggi: docs/MVP.md.
|
||||
class Gui : Form
|
||||
{
|
||||
record Model(string Label, string Id);
|
||||
record Msg(string Role, string Text); // Role: user | ai | err
|
||||
record Stored(string Id, string Title, DateTime Updated, bool Started, List<Msg> Messages);
|
||||
static readonly Model[] Models =
|
||||
[
|
||||
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"),
|
||||
];
|
||||
|
||||
static readonly MarkdownPipeline Md = new MarkdownPipelineBuilder().UseAdvancedExtensions().DisableHtml().Build();
|
||||
|
||||
readonly WebView2 view = new()
|
||||
{
|
||||
Dock = DockStyle.Fill,
|
||||
// evita il lampo bianco all'avvio in tema scuro (stesso --bg di ui.html)
|
||||
DefaultBackgroundColor = Application.IsDarkModeEnabled ? Color.FromArgb(0x0F, 0x17, 0x2A) : Color.White,
|
||||
};
|
||||
|
||||
static readonly string ChatsDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "LlmRun", "chats");
|
||||
|
||||
string sessionId = Guid.NewGuid().ToString();
|
||||
bool started; // true dopo il primo messaggio riuscito: da lì in poi --resume
|
||||
bool busy;
|
||||
bool restored; // la chat più recente si riapre solo al primo avvio
|
||||
List<Msg> messages = [];
|
||||
|
||||
public Gui()
|
||||
{
|
||||
Text = "LlmRun";
|
||||
var area = Screen.PrimaryScreen!.WorkingArea;
|
||||
StartPosition = FormStartPosition.CenterScreen;
|
||||
// proporzioni 16:10 orizzontali: 75% della larghezza utile (max 1440), altezza max 90%
|
||||
var w = Math.Min(1440, area.Width * 3 / 4);
|
||||
var h = Math.Min(w * 10 / 16, area.Height * 9 / 10);
|
||||
Size = new Size(h * 16 / 10, h);
|
||||
MinimumSize = new Size(900, 600);
|
||||
Controls.Add(view);
|
||||
|
||||
Load += async (_, _) =>
|
||||
{
|
||||
var dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "LlmRun");
|
||||
await view.EnsureCoreWebView2Async(await CoreWebView2Environment.CreateAsync(null, dir));
|
||||
var web = view.CoreWebView2;
|
||||
web.Settings.AreDevToolsEnabled = Debugger.IsAttached;
|
||||
web.NavigationStarting += (_, e) => { if (IsWeb(e.Uri)) { e.Cancel = true; Open(e.Uri); } };
|
||||
web.NewWindowRequested += (_, e) => { e.Handled = true; if (IsWeb(e.Uri)) Open(e.Uri); };
|
||||
web.WebMessageReceived += (_, e) => OnMessage(e.WebMessageAsJson);
|
||||
view.NavigateToString(LoadPage());
|
||||
};
|
||||
}
|
||||
|
||||
static bool IsWeb(string uri) => uri.StartsWith("http", StringComparison.OrdinalIgnoreCase);
|
||||
static void Open(string uri) => Process.Start(new ProcessStartInfo(uri) { UseShellExecute = true });
|
||||
|
||||
static string LoadPage()
|
||||
{
|
||||
var asm = Assembly.GetExecutingAssembly();
|
||||
using var s = asm.GetManifestResourceStream(asm.GetManifestResourceNames().First(n => n.EndsWith("ui.html")))!;
|
||||
var html = new StreamReader(s).ReadToEnd();
|
||||
var options = string.Concat(Models.Select(m => $"<option value=\"{m.Id}\">{WebUtility.HtmlEncode(m.Label)}</option>"));
|
||||
return html.Replace("{{MODELS}}", "<option value=\"\">Predefinito</option>" + options);
|
||||
}
|
||||
|
||||
void Post(object message) => view.CoreWebView2.PostWebMessageAsJson(JsonSerializer.Serialize(message));
|
||||
|
||||
void OnMessage(string json)
|
||||
{
|
||||
using var doc = JsonDocument.Parse(json);
|
||||
var r = doc.RootElement;
|
||||
switch (r.GetProperty("type").GetString())
|
||||
{
|
||||
case "reset" when !busy:
|
||||
NewSession(); PostChats();
|
||||
break;
|
||||
case "list":
|
||||
if (!restored) { restored = true; if (LatestId() is { } last) { OpenChat(last); break; } }
|
||||
PostChats();
|
||||
break;
|
||||
case "open" when !busy:
|
||||
OpenChat(r.GetProperty("id").GetString()!);
|
||||
break;
|
||||
case "delete" when !busy:
|
||||
Delete(r.GetProperty("id").GetString()!);
|
||||
break;
|
||||
case "send" when !busy:
|
||||
_ = HandleSend(r.GetProperty("text").GetString()!, r.GetProperty("model").GetString()!, r.GetProperty("effort").GetString()!);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
async Task HandleSend(string text, string model, string effort)
|
||||
{
|
||||
busy = true;
|
||||
messages.Add(new("user", text));
|
||||
try { Save(); PostChats(); } catch (IOException) { } // il messaggio non va perso se l'app si chiude durante l'attesa
|
||||
try
|
||||
{
|
||||
var (code, stdout, stderr) = await RunClaude(text, model, effort);
|
||||
if (code == 0) { started = true; messages.Add(new("ai", stdout)); Post(new { type = "ai", html = Markdown.ToHtml(stdout, Md), md = stdout }); }
|
||||
else Fail($"claude è uscito con codice {code}\n{stderr}".Trim());
|
||||
}
|
||||
catch (System.ComponentModel.Win32Exception) { Fail("'claude' non trovato nel PATH."); }
|
||||
catch (Exception ex) { Fail(ex.Message); }
|
||||
finally
|
||||
{
|
||||
busy = false;
|
||||
try { Save(); } catch (IOException) { } // la chat resta a schermo anche se il salvataggio fallisce
|
||||
PostChats();
|
||||
Post(new { type = "done" });
|
||||
}
|
||||
}
|
||||
|
||||
void Fail(string text) { messages.Add(new("err", text)); Post(new { type = "err", text }); }
|
||||
|
||||
void NewSession() { sessionId = Guid.NewGuid().ToString(); started = false; messages = []; }
|
||||
|
||||
// L'id arriva dalla pagina e diventa un nome file: accettare solo Guid.
|
||||
static string? PathFor(string id) => Guid.TryParse(id, out var g) ? Path.Combine(ChatsDir, g.ToString() + ".json") : null;
|
||||
|
||||
void Save()
|
||||
{
|
||||
if (messages.Count == 0) return;
|
||||
Directory.CreateDirectory(ChatsDir);
|
||||
var first = messages.First(m => m.Role == "user").Text.ReplaceLineEndings(" ").Trim();
|
||||
var title = first.Length > 50 ? first[..50] + "…" : first;
|
||||
File.WriteAllText(PathFor(sessionId)!, JsonSerializer.Serialize(new Stored(sessionId, title, DateTime.Now, started, messages)));
|
||||
}
|
||||
|
||||
static Stored? Read(string file)
|
||||
{
|
||||
try { return JsonSerializer.Deserialize<Stored>(File.ReadAllText(file)); }
|
||||
catch (Exception e) when (e is IOException or JsonException) { return null; } // file corrotto: ignorato
|
||||
}
|
||||
|
||||
static string? LatestId() => Directory.Exists(ChatsDir)
|
||||
? Directory.EnumerateFiles(ChatsDir, "*.json").Select(Read).OfType<Stored>().OrderByDescending(c => c.Updated).FirstOrDefault()?.Id
|
||||
: null;
|
||||
|
||||
void PostChats()
|
||||
{
|
||||
var items = Directory.Exists(ChatsDir)
|
||||
? Directory.EnumerateFiles(ChatsDir, "*.json").Select(Read).OfType<Stored>()
|
||||
.OrderByDescending(c => c.Updated).Select(c => new { id = c.Id, title = c.Title, updated = c.Updated }).ToArray()
|
||||
: [];
|
||||
Post(new { type = "chats", current = sessionId, items });
|
||||
}
|
||||
|
||||
void OpenChat(string id)
|
||||
{
|
||||
var file = PathFor(id);
|
||||
var chat = file is not null && File.Exists(file) ? Read(file) : null;
|
||||
if (chat is null) { PostChats(); return; }
|
||||
sessionId = chat.Id; started = chat.Started; messages = chat.Messages;
|
||||
Post(new
|
||||
{
|
||||
type = "load",
|
||||
messages = messages.Select(m => new { role = m.Role, text = m.Text, html = m.Role == "ai" ? Markdown.ToHtml(m.Text, Md) : null }).ToArray(),
|
||||
});
|
||||
PostChats();
|
||||
}
|
||||
|
||||
void Delete(string id)
|
||||
{
|
||||
var file = PathFor(id);
|
||||
if (file is not null && File.Exists(file)) File.Delete(file);
|
||||
if (id == sessionId)
|
||||
{
|
||||
NewSession();
|
||||
Post(new { type = "load", messages = Array.Empty<object>() });
|
||||
}
|
||||
PostChats();
|
||||
}
|
||||
|
||||
async Task<(int Code, string Out, string Err)> RunClaude(string prompt, string model, string effort)
|
||||
{
|
||||
var psi = new ProcessStartInfo("claude")
|
||||
{
|
||||
WorkingDirectory = AppContext.BaseDirectory,
|
||||
UseShellExecute = false,
|
||||
RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true,
|
||||
CreateNoWindow = true,
|
||||
};
|
||||
psi.ArgumentList.Add("-p");
|
||||
psi.ArgumentList.Add(prompt);
|
||||
psi.ArgumentList.Add(started ? "--resume" : "--session-id");
|
||||
psi.ArgumentList.Add(sessionId);
|
||||
foreach (var (flag, value) in new[] { ("--model", model), ("--effort", effort) })
|
||||
if (value != "") { psi.ArgumentList.Add(flag); psi.ArgumentList.Add(value); }
|
||||
|
||||
using var p = Process.Start(psi)!;
|
||||
p.StandardInput.Close(); // evita l'attesa di stdin di claude
|
||||
var o = p.StandardOutput.ReadToEndAsync();
|
||||
var e = p.StandardError.ReadToEndAsync();
|
||||
await p.WaitForExitAsync();
|
||||
return (p.ExitCode, (await o).Trim(), (await e).Trim());
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0-windows</TargetFramework>
|
||||
<UseWindowsForms>true</UseWindowsForms>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<NoWarn>$(NoWarn);WFO5001</NoWarn> <!-- SetColorMode è sperimentale -->
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Markdig" Version="1.4.0" />
|
||||
<PackageReference Include="Microsoft.Web.WebView2" Version="1.0.4258.31" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<EmbeddedResource Include="ui.html" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
-44
@@ -1,44 +0,0 @@
|
||||
using System.Diagnostics;
|
||||
using System.Windows.Forms;
|
||||
|
||||
if (args.Length == 0)
|
||||
{
|
||||
// WebView2 richiede un thread STA, che i top-level statements non danno
|
||||
var ui = new Thread(() =>
|
||||
{
|
||||
ApplicationConfiguration.Initialize();
|
||||
Application.SetColorMode(SystemColorMode.System);
|
||||
Application.Run(new Gui());
|
||||
});
|
||||
ui.SetApartmentState(ApartmentState.STA);
|
||||
ui.Start();
|
||||
ui.Join();
|
||||
return 0;
|
||||
}
|
||||
|
||||
var psi = NewClaude(string.Join(' ', args));
|
||||
try
|
||||
{
|
||||
using var p = Process.Start(psi)!; // stdout/stderr ereditati: streaming in tempo reale
|
||||
p.StandardInput.Close();
|
||||
p.WaitForExit();
|
||||
return p.ExitCode;
|
||||
}
|
||||
catch (System.ComponentModel.Win32Exception)
|
||||
{
|
||||
Console.Error.WriteLine("'claude' non trovato nel PATH.");
|
||||
return 127;
|
||||
}
|
||||
|
||||
static ProcessStartInfo NewClaude(string prompt)
|
||||
{
|
||||
var psi = new ProcessStartInfo("claude")
|
||||
{
|
||||
WorkingDirectory = AppContext.BaseDirectory,
|
||||
UseShellExecute = false,
|
||||
RedirectStandardInput = true, // evita l'attesa di stdin di claude
|
||||
};
|
||||
psi.ArgumentList.Add("-p");
|
||||
psi.ArgumentList.Add(prompt);
|
||||
return psi;
|
||||
}
|
||||
@@ -1,35 +1,76 @@
|
||||
# LlmRun
|
||||
# agent-wiki-ui
|
||||
|
||||
Eseguibile C# (.NET 10, Windows) che lancia Claude Code (`claude -p`) nella cartella in cui risiede l'eseguibile.
|
||||
Eseguibile C# (.NET 10, Windows e Linux) che lancia Claude Code (`claude -p`), Codex (`codex exec`) o Antigravity (`agy … -p`) nella cartella in cui risiede l'eseguibile. Senza argomenti apre una GUI di chat (Avalonia), con argomenti funziona da riga di comando.
|
||||
|
||||
## Requisiti
|
||||
- .NET SDK 10
|
||||
- `claude` (Claude Code) nel PATH
|
||||
- Runtime WebView2 (incluso in Windows 11) per la GUI
|
||||
- `claude` (Claude Code), `codex` (Codex) o `agy` (Antigravity) installati e nel PATH, già autenticati. Istruzioni: [docs/INSTALL.md](docs/INSTALL.md)
|
||||
- Per sviluppare: .NET SDK 10
|
||||
- Per usare l'eseguibile pubblicato: nessun runtime (è self-contained). Su Linux serve un desktop con X11 o XWayland per la GUI.
|
||||
|
||||
## 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).
|
||||
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, Codex o Antigravity), 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, Gemini 3.0 Flash Low per Antigravity) 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, Codex e Antigravity hanno una versione nuova (pulsante evidenziato) e li aggiorna uno alla volta.
|
||||
```
|
||||
dotnet run
|
||||
dotnet run --project src/agent-wiki-ui
|
||||
```
|
||||
|
||||
Nella GUI, la barra in alto permette di scegliere **modello** (con versione) ed **effort** di ragionamento ("predefinito" = nessun flag, vale la config di `claude`).
|
||||
|
||||
CLI (con argomenti): il prompt viene stampato su terminale, l'exit code è quello di `claude`.
|
||||
CLI (con argomenti): il prompt viene stampato su terminale, l'exit code è quello del motore (127 se non è nel PATH). Di default usa Claude Code; `--engine codex` usa Codex; `--engine agy` usa Antigravity.
|
||||
```
|
||||
dotnet run -- "spiega questo progetto"
|
||||
dotnet run --project src/agent-wiki-ui -- "spiega questo progetto"
|
||||
dotnet run --project src/agent-wiki-ui -- --engine codex "spiega questo progetto"
|
||||
dotnet run --project src/agent-wiki-ui -- --engine agy "spiega questo progetto"
|
||||
```
|
||||
|
||||
Eseguibile già compilato:
|
||||
```
|
||||
dotnet build
|
||||
bin\Debug\net10.0-windows\LlmRun.exe
|
||||
```
|
||||
## Creare gli eseguibili (Windows e Linux)
|
||||
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).
|
||||
|
||||
## Publish single-file
|
||||
```
|
||||
dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true
|
||||
```
|
||||
### 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). Funziona anche su ARM64 (Raspberry Pi): `curl -sSL https://dot.net/v1/dotnet-install.sh -o /tmp/dotnet-install.sh && bash /tmp/dotnet-install.sh --channel 10.0`, poi `export DOTNET_ROOT=$HOME/.dotnet PATH=$PATH:$HOME/.dotnet` (da mettere in `~/.bashrc`).
|
||||
- Controllo: `dotnet --version` deve stampare `10.x`.
|
||||
|
||||
Documentazione: [docs/MVP.md](docs/MVP.md), [docs/ROADMAP.md](docs/ROADMAP.md).
|
||||
### 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 passano allo script allo stesso modo (`scripts/publish.sh linux-arm64`, risultato in `dist/linux-arm64/`), ma non sono verificati. Su un Raspberry Pi servono anche i motori: per Claude Code vedi [docs/INSTALL.md](docs/INSTALL.md). 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 src/agent-wiki-ui -c Release -r <rid> --self-contained -p:PublishSingleFile=true -o dist/<rid>
|
||||
```
|
||||
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`, `agy`) devono essere installati e nel PATH dello stesso sistema: vedi [docs/INSTALL.md](docs/INSTALL.md).
|
||||
|
||||
## Formule nelle risposte
|
||||
Le formule LaTeX si vedono composte: `$ ... $` nel testo e `$$ ... $$` a blocco ([ADR-0008](docs/adr/0008-formule-latex-nel-markdown.md)). Se il LaTeX non è valido compare il sorgente come testo; i `$` isolati (per esempio «10 $ e 20 $») restano testo. Le formule non sono selezionabili come testo, ma il pulsante **Copia** della risposta copia il markdown con il sorgente.
|
||||
|
||||
## Immagini nelle risposte
|
||||
L'app mostra il file indicato dal percorso scritto nella risposta, ovunque stia; non conosce né cartelle né cataloghi di immagini. Se la risposta contiene `` e il file esiste, la chat mostra l'immagine; altrimenti compare il testo `[didascalia]`. Gli URL `http(s)` non si scaricano. Un percorso relativo si cerca nella cartella dell'eseguibile e poi in quelle superiori, quindi funziona anche se l'eseguibile sta in una sottocartella del progetto. Dettagli: [ADR-0006](docs/adr/0006-immagini-nel-markdown.md); per una convenzione di progetto interrogabile con immagini vedi [ADR-0007](docs/adr/0007-schema-wiki-per-query-con-immagini.md).
|
||||
|
||||
## Piattaforme
|
||||
Windows e Linux con lo stesso codice ([ADR-0001](docs/adr/0001-gui-multipiattaforma-avalonia.md)). Motori supportati: Claude Code, Codex CLI e Antigravity CLI, già installati da terminale: [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).
|
||||
@@ -0,0 +1,9 @@
|
||||
<Solution>
|
||||
<Folder Name="/src/">
|
||||
<Project Path="src/agent-wiki-ui/agent-wiki-ui.csproj" />
|
||||
</Folder>
|
||||
<Folder Name="/tests/">
|
||||
<Project Path="tests/agent-wiki-ui.Tests/agent-wiki-ui.Tests.csproj" />
|
||||
<Project Path="tests/FakeClaude/FakeClaude.csproj" />
|
||||
</Folder>
|
||||
</Solution>
|
||||
+143
@@ -0,0 +1,143 @@
|
||||
# Installare i motori (Claude Code, Codex, Antigravity)
|
||||
|
||||
L'app non installa né autentica i motori: lancia quelli che trova nel PATH, già installati e con l'accesso fatto ([ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md)). Questa pagina spiega come prepararli. Fonti e data di consultazione in fondo.
|
||||
|
||||
## Prima di iniziare: un ambiente, un motore
|
||||
Il motore va installato **nello stesso ambiente in cui gira l'app**:
|
||||
|
||||
| Dove avvii l'app | Dove installare il motore |
|
||||
|---|---|
|
||||
| Linux nativo | nel terminale Linux |
|
||||
| WSL (anche con `dotnet run --project src/agent-wiki-ui`) | nel terminale della distribuzione WSL |
|
||||
| Windows (`.exe`) | in Windows (PowerShell), non in WSL |
|
||||
|
||||
Dentro WSL il PATH di Windows è visibile (compare `/mnt/c/…`): se in WSL non c'è un `claude`, `codex` o `agy`, il comando può risolvere nella versione Windows. Controllalo con `command -v claude`, `command -v codex` e `command -v agy`.
|
||||
|
||||
## Claude Code
|
||||
|
||||
**Requisiti**: macOS 13+, Windows 10 1809+ o Server 2019+, Ubuntu 20.04+, Debian 10+, Alpine 3.19+; 4 GB di RAM, x64 o ARM64, connessione a internet. Su Windows nativo [Git for Windows](https://git-scm.com/downloads/win) è consigliato ma facoltativo.
|
||||
|
||||
**Installazione** (una delle opzioni; la prima è la raccomandata):
|
||||
|
||||
| Metodo | Comando |
|
||||
|---|---|
|
||||
| Nativo, Linux/macOS/WSL | `curl -fsSL https://claude.ai/install.sh \| bash` |
|
||||
| Nativo, Windows PowerShell | `irm https://claude.ai/install.ps1 \| iex` |
|
||||
| Nativo, Windows CMD | `curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd` |
|
||||
| Homebrew | `brew install --cask claude-code` |
|
||||
| WinGet | `winget install Anthropic.ClaudeCode` |
|
||||
| npm (serve Node.js 22 o successivo) | `npm install -g @anthropic-ai/claude-code` (mai con `sudo`) |
|
||||
| apt / dnf / apk | repository firmati: vedi la guida ufficiale |
|
||||
|
||||
L'installazione nativa non mostra avanzamento durante il download. A fine installazione apri un **nuovo** terminale.
|
||||
|
||||
**Da zero su Linux, anche ARM64 (per esempio Raspberry Pi 5 con Raspberry Pi OS a 64 bit).** Il metodo nativo riconosce da solo l'architettura (`uname -m` deve dare `aarch64` o `x86_64`):
|
||||
```
|
||||
sudo apt install -y curl # se manca
|
||||
curl -fsSL https://claude.ai/install.sh | bash
|
||||
# apri un nuovo terminale, poi:
|
||||
command -v claude # atteso: ~/.local/bin/claude
|
||||
claude --version
|
||||
claude # primo avvio: accesso nel browser
|
||||
```
|
||||
Su un Raspberry senza schermo l'accesso nel browser si fa da un altro dispositivo, seguendo l'indirizzo che `claude` stampa nel terminale (per esempio via SSH); in alternativa usa una API key o un provider cloud, vedi "Accesso". Se `~/.local/bin` non è nel PATH aggiungi `export PATH="$HOME/.local/bin:$PATH"` a `~/.bashrc`. Con la sola architettura ARM64 e Debian 10+ i requisiti sono soddisfatti; il metodo npm è l'alternativa se lo script nativo non funziona. Non provato su un Raspberry reale: le istruzioni vengono dalla guida ufficiale.
|
||||
|
||||
**Accesso**: esegui `claude` e segui le istruzioni nel browser. Serve un account Pro, Max, Team, Enterprise o Console (il piano gratuito di claude.ai non include Claude Code). In alternativa Amazon Bedrock, Google Cloud o Microsoft Foundry.
|
||||
|
||||
**Verifica**
|
||||
```
|
||||
claude --version # stampa la versione, es. 2.1.x (Claude Code)
|
||||
claude doctor # diagnostica di installazione e impostazioni
|
||||
claude auth status # mostra se hai fatto l'accesso
|
||||
```
|
||||
|
||||
**Aggiornamento**: l'installazione nativa si aggiorna da sola; `claude update` forza l'aggiornamento. Homebrew, WinGet, npm e i gestori di pacchetti vanno aggiornati a mano (`npm install -g @anthropic-ai/claude-code@latest`, evitando `npm update -g`).
|
||||
|
||||
## Codex CLI
|
||||
|
||||
**Requisiti**: macOS (Apple Silicon e Intel), Linux (x86_64 e arm64), Windows tramite lo script PowerShell. Per l'installazione con npm serve Node.js. Serve un piano ChatGPT (Plus, Pro, Business, Edu o Enterprise) oppure una API key.
|
||||
|
||||
**Installazione** (una delle opzioni):
|
||||
|
||||
| Metodo | Comando |
|
||||
|---|---|
|
||||
| Script, Linux/macOS/WSL | `curl -fsSL https://chatgpt.com/codex/install.sh \| sh` |
|
||||
| Script, Windows PowerShell | `powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 \| iex"` |
|
||||
| npm | `npm install -g @openai/codex` |
|
||||
| Homebrew | `brew install --cask codex` |
|
||||
| Binario | archivio dalla pagina delle release su GitHub (`openai/codex`), estratto e rinominato `codex` |
|
||||
|
||||
Gli script scaricano da `releases.openai.com` e, se fallisce, da GitHub Releases; per forzare GitHub imposta `CODEX_INSTALLER_USE_RELEASES_OPENAI_COM=false`.
|
||||
|
||||
**Su Windows preferisci lo script PowerShell a npm.** L'app avvia l'eseguibile direttamente, senza `cmd.exe /c`; un'installazione con npm potrebbe produrre uno script `.cmd` che così non parte (rischio indicato nell'ADR-0002, da verificare su Windows).
|
||||
|
||||
**Accesso**: esegui `codex` e scegli "Sign in with ChatGPT" (consigliato), oppure usa una API key (guida ufficiale: sezione autenticazione).
|
||||
|
||||
**Verifica**
|
||||
```
|
||||
codex --version # es. codex-cli 0.144.x
|
||||
codex login status # "Logged in using ChatGPT" se l'accesso è fatto
|
||||
codex exec --help # uso non interattivo, usato dall'app
|
||||
```
|
||||
|
||||
**Stato su questa macchina** (WSL, controllato il 2026-10-15): `codex` 0.144.3 in `~/.local/bin/codex`, collegamento a `~/.codex/packages/standalone/current/bin/codex`, con accesso ChatGPT già fatto. `claude` 2.1.252 in `~/.npm-global/bin/claude`, con accesso claude.ai già fatto.
|
||||
|
||||
**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.
|
||||
|
||||
## Antigravity CLI (`agy`)
|
||||
|
||||
**Requisiti**: Linux x64 (binario nativo ELF) o Windows x64 (eseguibile nativo `.exe`).
|
||||
|
||||
**Installazione**: binario nativo distribuito ufficialmente (su Linux collocato in `~/.gemini/bin/agy` o in una cartella inclusa nel PATH; su Windows `agy.exe`).
|
||||
|
||||
**Accesso**: autenticazione tramite account Google/Antigravity (`agy` o configurazione di ambiente).
|
||||
|
||||
**Verifica**
|
||||
```
|
||||
agy --version # stampa la versione, es. 1.4.2
|
||||
agy models # catalogo modelli disponibili
|
||||
agy update # controlla e aggiorna alla versione più recente
|
||||
```
|
||||
|
||||
**Permessi per la sola lettura non interattiva**: per usare `agy` in modalità non interattiva (`-p`) in sola lettura, nel file `~/.gemini/antigravity-cli/settings.json` deve essere presente la regola `'read_file(*)'` sotto `'permissions.allow'` (altrimenti headless mode nega `read_file` con errore jetski: `a tool required the read_file permission that headless mode cannot prompt for`), mentre scritture e comandi restano negati di default:
|
||||
|
||||
```json
|
||||
{
|
||||
"permissions": {
|
||||
"allow": [
|
||||
"read_file(*)"
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 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; Antigravity: endpoint ufficiale di auto-update): se c'è, la riga dice "Aggiornamento disponibile", il pulsante **Aggiorna** si evidenzia e compare un puntino sul pulsante Impostazioni. Il pulsante esegue `claude update`, `codex update` o `agy 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 | Antigravity |
|
||||
|---|---|---|---|
|
||||
| npm | `npm install -g @anthropic-ai/claude-code@latest` | `npm install -g @openai/codex@latest` | `agy update` |
|
||||
| Homebrew | `brew upgrade claude-code` | `brew upgrade --cask codex` | `brew upgrade agy` |
|
||||
| WinGet | `winget upgrade Anthropic.ClaudeCode` | reinstalla con lo script PowerShell | `agy update` |
|
||||
| Nativo / script | `claude update` | `codex update` (o rilancia lo script di installazione) | `agy update` |
|
||||
|
||||
Dettagli e decisioni: [ADR-0004](adr/0004-aggiornamento-dei-cli.md).
|
||||
|
||||
## Controllo finale per l'app
|
||||
Dallo stesso terminale da cui avvii l'app:
|
||||
```
|
||||
command -v claude codex agy # Linux/WSL; in PowerShell: Get-Command claude, codex, agy
|
||||
claude -p "rispondi solo: ok"
|
||||
codex exec "rispondi solo: ok"
|
||||
agy -p "rispondi solo: ok"
|
||||
```
|
||||
Se i comandi rispondono, l'app li trova. Se l'app dice che un motore non è trovato nel PATH:
|
||||
- apri un nuovo terminale (il PATH si aggiorna solo ai nuovi);
|
||||
- controlla che la cartella d'installazione sia nel PATH (`~/.local/bin`, `~/.gemini/bin`, o `%USERPROFILE%\.local\bin` su Windows);
|
||||
- verifica di non aver installato in un ambiente diverso da quello dell'app (tabella iniziale).
|
||||
|
||||
## Fonti
|
||||
- Claude Code: documentazione ufficiale "Advanced setup", consultata il 2026-10-15 (`code.claude.com/docs/en/setup`).
|
||||
- Codex: README del repository `github.com/openai/codex`, consultato il 2026-10-15.
|
||||
- Antigravity CLI: binario `agy` verificato in ambiente reale il 2026-10-18.
|
||||
- Comandi `--version`, `agy models`, `agy update`: provati sulla macchina descritta sopra.
|
||||
+33
-29
@@ -5,58 +5,62 @@ Eseguibile C# a riga di comando che inoltra un prompt a Claude Code (`claude`) l
|
||||
|
||||
## Uso
|
||||
```
|
||||
llmrun.exe "spiega questo progetto"
|
||||
<nome-app> "spiega questo progetto"
|
||||
```
|
||||
Tutti gli argomenti sono uniti in un unico prompt.
|
||||
Tutti gli argomenti sono uniti in un unico prompt. Con `--engine <id>` come primo argomento (`claude`, `codex` o `agy`) si sceglie il motore, per esempio `<nome-app> --engine agy "spiega questo progetto"`; senza, si usa Claude Code. Id sconosciuto o prompt mancante: uso su stderr ed exit code 2.
|
||||
|
||||
## Comportamento
|
||||
1. Se non ci sono argomenti: stampa l'uso ed esce con codice 2.
|
||||
2. Avvia `claude -p <prompt>` (modalità non interattiva) con `WorkingDirectory = AppContext.BaseDirectory`.
|
||||
2. Avvia il motore scelto in modalità non interattiva (`claude -p <prompt>`, `codex exec … -- <prompt>` o `agy … -p <prompt>`) con `WorkingDirectory = AppContext.BaseDirectory`.
|
||||
3. Ritrasmette stdout e stderr del processo figlio in tempo reale.
|
||||
4. Esce con lo stesso exit code di `claude`.
|
||||
5. Se `claude` non è trovato: messaggio chiaro ed exit code 127.
|
||||
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.
|
||||
|
||||
## GUI (chat)
|
||||
Senza argomenti si apre una finestra WinForms che contiene solo un WebView2: l'intera interfaccia (header, conversazione, composer) è HTML/CSS in `ui.html`, in stile claude.ai/ChatGPT. Con argomenti resta la CLI.
|
||||
Senza argomenti si apre una finestra Avalonia (C# + XAML, nessun HTML) in stile claude.ai/ChatGPT, identica su Windows e Linux. Con argomenti resta la CLI. Decisione e motivazioni: [ADR-0001](adr/0001-gui-multipiattaforma-avalonia.md).
|
||||
|
||||
**Struttura della pagina**
|
||||
- **Barra laterale** (sinistra, comprimibile): logo e nome, pulsante **Nuova chat**, elenco delle chat salvate (titolo = inizio del primo messaggio, data/ora dell'ultimo scambio; la chat aperta è evidenziata). Un clic su una chat la riapre; la ✕ (con conferma) la elimina. Elenco vuoto: "Nessuna chat salvata".
|
||||
- **Conversazione**: messaggi alternati utente/Claude, aggiunti al DOM uno alla volta (nessun ricaricamento, nessuno sfarfallio). Le risposte sono renderizzate in markdown (Markdig, lato C#): titoli, liste, tabelle, citazioni, blocchi di codice. Sulle risposte il pulsante **Copia** copia il markdown; sui blocchi di codice copia il codice.
|
||||
- **Schermata iniziale** (chat vuota): titolo, sottotitolo e quattro suggerimenti cliccabili che precompilano il campo.
|
||||
- **Composer** (in basso, scheda arrotondata): textarea che cresce fino a ~8 righe, selettori **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), pulsante Invia circolare con icona. `Invio` invia, `Maiusc+Invio` va a capo. Hint sulla tastiera sotto la scheda.
|
||||
- Passati come `--model` / `--effort`; con "Predefinito" il flag viene omesso. Solo GUI.
|
||||
**Struttura della finestra**
|
||||
- **Barra laterale** (sinistra, comprimibile con il pulsante a tre linee): logo e nome dell'app, pulsante **Nuova chat**, elenco delle chat salvate (titolo = inizio del primo messaggio, data/ora dell'ultimo scambio; la chat aperta è evidenziata). Un clic su una chat la riapre; la ✕ (con conferma) la elimina. Elenco vuoto: "Nessuna chat salvata".
|
||||
- **Conversazione**: messaggi alternati utente/Claude. Le risposte sono renderizzate in markdown: titoli, liste, tabelle, citazioni, blocchi di codice, grassetto/corsivo/barrato, codice inline, link, immagini, formule LaTeX (`$…$` nel testo, `$$…$$` a blocco; [ADR-0008](adr/0008-formule-latex-nel-markdown.md); se il LaTeX non è valido compare il sorgente). Le immagini `` si mostrano se il percorso è locale (assoluto, `file://` o relativo: cercato nella cartella dell'exe e poi nelle cartelle superiori, cioè nella radice del progetto del motore) e il file è un'immagine leggibile entro i limiti (caricata in background: prima compare `[alt]`, poi l'immagine); altrimenti, e sempre per gli URL `http(s)`, compare il testo alternativo `[alt]` e non si scarica nulla ([ADR-0006](adr/0006-immagini-nel-markdown.md)). Il rendering è un renderer proprio ([MarkdownView.cs](../src/agent-wiki-ui/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).
|
||||
- **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, Antigravity; un motore non installato è mostrato "non installato" e non è selezionabile; disabilitato durante l'attesa), poi **Modello** (Predefinito, catalogo del motore, "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; Antigravity: Gemini 3.0 Flash Low) 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.
|
||||
- **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 (Antigravity: modelli Gemini Flash / Claude / GPT-OSS, effort fino a max). 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 e Antigravity la sessione è letta dall'output (`thread_id` per Codex, `conversation_id` per Antigravity) e usata per riprendere la chat (`--conversation` su agy); i permessi sono di sola lettura (`sandbox_mode="read-only"` su Codex; su Antigravity in headless mode `-p` la sola lettura è garantita dalla modalità predefinita senza flag `--mode`).
|
||||
- **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 `%LOCALAPPDATA%\LlmRun\chats\<guid>.json` (guid = id di sessione di `claude`, titolo, data, flag `started`, messaggi con ruolo e testo). 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.
|
||||
- La risposta compare a fine generazione (nessuno streaming); durante l'attesa un indicatore a puntini animati e Invia disabilitato. Se `claude` esce con errore, lo stderr appare come messaggio di errore.
|
||||
- I link si aprono nel browser di sistema. L'HTML grezzo nel markdown è disabilitato.
|
||||
- Finestra orizzontale con proporzioni 16:10: larga il 75% dell'area utile dello schermo (max 1440px), altezza di conseguenza (max 90% dell'area utile), centrata; minimo 900x600. Su un monitor Full HD 1920x1080 risulta circa 1440x900.
|
||||
|
||||
**Protocollo pagina ↔ C#** (`WebMessage` JSON). Pagina→C#: `{type:"send", text, model, effort}`, `{type:"reset"}`, `{type:"list"}`, `{type:"open", id}`, `{type:"delete", id}`. C#→pagina: `{type:"ai", html, md}`, `{type:"err", text}`, `{type:"done"}`, `{type:"chats", current, items:[{id,title,updated}]}`, `{type:"load", messages:[{role,text,html?}]}` (sostituisce la conversazione mostrata).
|
||||
- La risposta compare a fine generazione (nessuno streaming); durante l'attesa un indicatore di avanzamento e Invia disabilitato. Se `claude` esce con errore, lo stderr appare come messaggio di errore.
|
||||
- I link `http(s)` si aprono nel browser di sistema.
|
||||
- Finestra orizzontale con proporzioni 16:10: larga il 75% dell'area utile dello schermo (max 1440 px logici), altezza di conseguenza (max 90% dell'area utile), centrata; minimo 900x600. Su un monitor Full HD 1920x1080 risulta circa 1440x900.
|
||||
|
||||
### Design (UI/UX)
|
||||
Sorgente di verità per l'aspetto, derivato dalla skill `ui-ux-pro-max` (stile "strumento per sviluppatori": slate + accento verde).
|
||||
- **Tema**: segue Windows (chiaro/scuro) via `prefers-color-scheme`; la barra del titolo segue `Application.SetColorMode(SystemColorMode.System)`; lo sfondo del WebView2 è impostato per evitare il lampo bianco all'avvio.
|
||||
Sorgente di verità per l'aspetto, derivato dalla skill `ui-ux-pro-max` (stile "strumento per sviluppatori": slate + accento verde). I token vivono come risorse di tema in [Gui/App.axaml](../src/agent-wiki-ui/Gui/App.axaml).
|
||||
- **Tema**: segue il sistema (chiaro/scuro) tramite `RequestedThemeVariant="Default"`.
|
||||
- **Token** (chiaro / scuro): sfondo `#FFFFFF` / `#0F172A`, superficie composer `#FFFFFF` / `#1E293B`, testo `#0F172A` / `#F8FAFC`, testo secondario `#475569` / `#94A3B8`, bordi `#CBD5E1` / `#334155`, accento `#15803D` / `#22C55E`, errore `#B91C1C` / `#F87171`. Contrasto testo ≥ 4.5:1.
|
||||
- **Tipografia**: Segoe UI Variable (corpo 15.5px, interlinea 1.65), Cascadia Code/Consolas per il codice. Nessun font web (funziona offline).
|
||||
- **Forma e movimento**: raggi 10–20px, ombra leggera sul composer, transizioni 150ms, comparsa dei messaggi 180ms; con `prefers-reduced-motion` tutto fermo.
|
||||
- **Barra laterale**: sfondo `--muted`, 272px; voce attiva con barra d'accento a sinistra; ✕ visibile solo al passaggio/focus.
|
||||
- **Accessibilità**: focus sempre visibile, `aria-label` sui pulsanti a sola icona, `role=log`/`aria-live` sulla conversazione, `role=status` sull'attesa, target ≥ 36px, nessuna emoji come icona.
|
||||
- **Non incluso**: evidenziazione sintattica del codice (richiederebbe una libreria da incorporare).
|
||||
- **Tipografia**: font di sistema (Segoe UI Variable/Segoe UI su Windows; Inter, Ubuntu, Cantarell, Noto Sans, DejaVu Sans su Linux; corpo 15.5, titoli fino a 24), Cascadia Code/Consolas/DejaVu Sans Mono per il codice. Nessun font incorporato (funziona offline).
|
||||
- **Forma**: raggi 10–20, bordi sottili, pulsante d'invio circolare.
|
||||
- **Barra laterale**: sfondo `Muted`, 272 px; voce attiva con barra d'accento a sinistra; ✕ per eliminare.
|
||||
- **Accessibilità**: focus visibile (il composer prende il bordo d'accento), `AutomationProperties.Name` sui pulsanti a sola icona e sul campo messaggio, target ≥ 30 px, icone vettoriali (nessuna emoji).
|
||||
- **Non incluso**: evidenziazione sintattica del codice.
|
||||
|
||||
## Scelte tecniche
|
||||
- .NET 10 (WinForms). `Program.cs` (CLI + avvio) e `Gui.cs` (chat). Dipendenze NuGet solo per la GUI: `Markdig` (markdown→HTML) e `Microsoft.Web.WebView2` (richiede il runtime WebView2, già presente su Windows 11).
|
||||
Le scelte architetturali sono negli [ADR](README.md#indice-adr). Sintesi:
|
||||
- .NET 10, un solo progetto `net10.0` per Windows e Linux. Avalonia (GUI), Markdig (parsing markdown), CSharpMath (formule LaTeX). Il codice è diviso in `Core/` (avvio di `claude`, cronologia, nome app) e `Gui/` (finestra, ViewModel, renderer markdown); `Program.cs` sceglie CLI o GUI.
|
||||
- `ProcessStartInfo.ArgumentList` per passare il prompt (niente problemi di quoting).
|
||||
- `claude` è un .exe nativo (`~/.local/bin`): si avvia direttamente, senza `cmd /c`. Lo stdin è chiuso subito per evitare l'attesa di 3s di claude.
|
||||
- `claude` è un eseguibile nativo (`~/.local/bin`): si avvia direttamente, senza `cmd /c`. Lo stdin è chiuso subito per evitare l'attesa di 3s di claude.
|
||||
- Working dir: `AppContext.BaseDirectory`, non la cwd del chiamante.
|
||||
- L'avvio dei motori è in un solo punto ([Core/EngineRunner.cs](../src/agent-wiki-ui/Core/EngineRunner.cs)), usato da CLI e GUI; ogni motore descrive argomenti e parser in [Core/Engine.cs](../src/agent-wiki-ui/Core/Engine.cs).
|
||||
|
||||
## Fuori scope (MVP)
|
||||
Streaming token-per-token nella GUI, annullamento di una risposta in corso, rinomina/ricerca delle chat, config file, altri motori oltre a Claude Code (Codex, Antigravity: vedi [ROADMAP.md](ROADMAP.md), Fase 4), logging su file, test automatici, supporto Linux/macOS.
|
||||
Streaming token-per-token nella GUI, annullamento di una risposta in corso, rinomina/ricerca delle chat, config file, altri motori oltre a Claude Code, Codex e Antigravity ([ADR-0002](adr/0002-motori-cli-claude-codex-antigravity.md)), logging su file, supporto macOS. I test automatici sono pianificati: [TESTING.md](TESTING.md).
|
||||
|
||||
## Criteri di accettazione
|
||||
Ogni criterio ha test automatici nella matrice di [TESTING.md](TESTING.md) (CL-04, CL-08, CL-06, CL-01).
|
||||
|
||||
- [ ] Eseguito da un'altra cartella, `claude` parte nella cartella dell'exe (verificabile chiedendo "pwd").
|
||||
- [ ] 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.
|
||||
|
||||
## Domande aperte
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
# Stato del progetto
|
||||
|
||||
> **Stadio: MVP** (prima di una versione 1.0). Ultimo aggiornamento: 2026-10-18.
|
||||
> 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, Codex e Antigravity 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, Codex, Antigravity | Una chat = un motore; sessione di Codex (`thread_id`) e Antigravity (`conversation_id`) lette dall'output. Sola lettura di default ([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 | **Avviati** | Piano e matrice pronti ([ADR-0003](adr/0003-strategia-di-test.md)); scritti i test di immagini e formule del renderer, `FakeClaude` e motore Antigravity (AG-01…AG-12, UP-21). Il resto della matrice manca. 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
|
||||
- **Antigravity mai provato con `agy` reale**: flag, forma del JSON, sola lettura in headless, nomi dei modelli e URL dell'auto-updater sono dedotti dal lavoro di Benedetta e coperti solo da test con output finto.
|
||||
- **Test automatici incompleti** (Fase 6): restano scoperti `Core/` (tranne Antigravity), `MainViewModel`, finestra e criteri di accettazione; 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, Codex, Antigravity): da aggiornare a mano; il "modello più piccolo" di Codex è un'assunzione (GPT-5.6 Luna), per Antigravity è `gemini-3.0-flash-low`.
|
||||
|
||||
## 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, Antigravity) |
|
||||
| [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 |
|
||||
| [0006](adr/0006-immagini-nel-markdown.md) Immagini nel markdown (solo file locali) | Proposta (implementata, test verdi) |
|
||||
| [0007](adr/0007-schema-wiki-per-query-con-immagini.md) Schema di una wiki interrogabile, con immagini | Proposta (solo documentazione; nessun codice) |
|
||||
| [0008](adr/0008-formule-latex-nel-markdown.md) Formule LaTeX nel markdown | Proposta (implementata) |
|
||||
|
||||
## 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, AG).
|
||||
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): 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.
|
||||
@@ -0,0 +1,57 @@
|
||||
# Documentazione
|
||||
|
||||
Indice e regole. Ogni informazione vive in **un solo documento**; gli altri la richiamano con un link.
|
||||
|
||||
| Documento | Contenuto (sorgente di verità per…) |
|
||||
|---|---|
|
||||
| [../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 |
|
||||
| [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 |
|
||||
| [ROADMAP.md](ROADMAP.md) | Fasi e stato (spunte); solo passi, mai motivazioni |
|
||||
| `adr/NNNN-*.md` | Decisioni architetturali e loro motivazioni (indice sotto) |
|
||||
| [../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
|
||||
Il nome è **`agent-wiki-ui`** (prima `LlmRun`). Questa sezione è l'unica sorgente: gli altri doc scrivono "l'app" o `<nome-app>`.
|
||||
|
||||
Se il nome cambia di nuovo, aggiornare solo questi punti:
|
||||
- [ ] `AssemblyName` in [../src/agent-wiki-ui/agent-wiki-ui.csproj](../src/agent-wiki-ui/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
|
||||
- [ ] **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 [../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)
|
||||
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.
|
||||
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.
|
||||
|
||||
## Regole degli ADR
|
||||
- Un file per decisione, `adr/NNNN-titolo-breve.md`, numerazione progressiva.
|
||||
- Stati: `Proposta` → `Accettata` → eventualmente `Sostituita da ADR-NNNN` o `Rifiutata`.
|
||||
- Un ADR accettato non si riscrive: se la decisione cambia se ne scrive uno nuovo che lo sostituisce e si aggiorna lo stato del vecchio.
|
||||
- Sezioni: Contesto, Criteri, Opzioni, Decisione, Conseguenze, Da verificare, Riferimenti.
|
||||
|
||||
## Indice ADR
|
||||
| ADR | Titolo | Stato |
|
||||
|---|---|---|
|
||||
| [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, Antigravity) |
|
||||
| [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 |
|
||||
| [0006](adr/0006-immagini-nel-markdown.md) | Immagini nel markdown: solo file locali | Proposta |
|
||||
| [0007](adr/0007-schema-wiki-per-query-con-immagini.md) | Schema di una wiki interrogabile, con immagini | Proposta |
|
||||
| [0008](adr/0008-formule-latex-nel-markdown.md) | Formule LaTeX nel markdown | Proposta |
|
||||
+48
-26
@@ -1,6 +1,6 @@
|
||||
# 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
|
||||
- [x] Scrivere MVP.md e ROADMAP.md
|
||||
@@ -22,36 +22,58 @@ Dettagli dell'MVP in [MVP.md](MVP.md).
|
||||
## Fase 3 — Oltre
|
||||
- [x] GUI: cronologia chat (salvataggio JSON, barra laterale, riapertura con `--resume`, eliminazione)
|
||||
- [ ] GUI: streaming della risposta (`--output-format stream-json`), stop, rinomina/ricerca chat
|
||||
- [x] GUI: immagini nel markdown da percorso locale, con ripiego sul testo alternativo ([ADR-0006](adr/0006-immagini-nel-markdown.md); test MD-14, MD-19…MD-30); immagini remote rimandate
|
||||
- [x] Schema di una wiki interrogabile con immagini: convenzione per le istruzioni solo-query, l'indice e il catalogo ([ADR-0007](adr/0007-schema-wiki-per-query-con-immagini.md)); da provare con la chat reale su una wiki di esempio
|
||||
- [x] GUI: formule LaTeX nel markdown, inline `$…$` e a blocco `$$…$$`, con ripiego sul sorgente ([ADR-0008](adr/0008-formule-latex-nel-markdown.md); test MD-31…MD-38)
|
||||
- [ ] Config file accanto all'exe
|
||||
- [ ] Test automatici e CI
|
||||
- [ ] Test automatici e CI (vedi Fase 6)
|
||||
|
||||
## Fase 4 — Più motori (Claude Code, Codex, Antigravity)
|
||||
Obiettivo: oltre a Claude Code, usare **OpenAI Codex CLI** e **Antigravity CLI** (`agy`) dalla stessa chat, scegliendo il motore da una nuova schermata **Impostazioni** della GUI.
|
||||
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.
|
||||
|
||||
Flag delle tre CLI (da verificare con `--help` delle versioni installate: derivano da documentazione e ricerche, non da prove su questo PC, dove `codex` e `agy` non sono ancora installati):
|
||||
- [x] Verificare i flag reali di `codex` e `agy` (provati su Linux/WSL, ADR-0002 accettata per Claude Code, Codex e Antigravity); Windows da verificare
|
||||
- [x] Astrazione "motore" in C# (`src/agent-wiki-ui/Core/Engine.cs`, `src/agent-wiki-ui/Core/EngineRunner.cs`)
|
||||
- [x] Rilevamento dei motori nel PATH; motori assenti disabilitati, messaggio chiaro
|
||||
- [x] Il JSON di ogni chat memorizza il motore e l'id di sessione; cambiare motore apre una nuova chat
|
||||
- [x] GUI: interruttore CLI nel riquadro Impostazioni; modelli ed effort in base al motore; motore della chat indicato nell'interfaccia
|
||||
- [ ] Impostazioni (motore, modello, effort) persistite su disco
|
||||
- [x] Motore Codex: lettura dell'id di sessione dall'output (`thread_id`) per la ripresa
|
||||
- [x] Motore Antigravity: gestione del blocco con output rediretto (`--print-timeout 120s` prima di `-p`, chiusura immediata di stdin)
|
||||
- [x] Motore Antigravity: lettura dell'id di sessione dall'output (`conversation_id`) e ripresa con `--conversation`
|
||||
- [x] Permessi di Codex e Antigravity in sola lettura (`sandbox_mode="read-only"` per Codex; per Antigravity in headless mode `-p` sola lettura garantita dalla modalità di default senza `--mode`; nessun flag che salta i controlli)
|
||||
- [ ] Opzione esplicita per concedere permessi di scrittura
|
||||
- [x] CLI: opzione `--engine`, coerente con la GUI (supporta `claude`, `codex`, `agy`)
|
||||
- [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; provato `agy update`) su Linux e Windows (installazione nativa e npm) e portare l'ADR-0004 ad "Accettata"
|
||||
|
||||
| | Claude Code | Codex CLI | Antigravity CLI |
|
||||
|---|---|---|---|
|
||||
| Comando | `claude -p <prompt>` | `codex exec <prompt>` | `agy -p <prompt>` |
|
||||
| Continuare | `--session-id <guid>` poi `--resume <guid>` | `codex exec resume <id> <prompt>` | da verificare |
|
||||
| Modello | `--model` | `-m` / `--model` | da verificare |
|
||||
| Effort | `--effort` | via `--config` (da verificare) | non noto |
|
||||
## Fase 5 — Multipiattaforma (Windows + Linux), GUI in solo C#
|
||||
Decisione e motivazioni: [ADR-0001](adr/0001-gui-multipiattaforma-avalonia.md). Qui solo i passi.
|
||||
|
||||
**Architettura**
|
||||
- [ ] Un'astrazione "motore" in C#: per ogni motore, eseguibile, argomenti per primo messaggio e per ripresa, elenco modelli, supporto effort, lettura dell'id di sessione. `RunClaude` diventa `RunEngine(engine, ...)`; la logica di avvio (cartella dell'exe, stdin chiuso) resta in un solo punto, eliminando la duplicazione CLI/GUI.
|
||||
- [ ] Rilevamento dei motori installati (PATH) e messaggio chiaro se mancano; i motori assenti sono disabilitati nelle Impostazioni.
|
||||
- [ ] Il file JSON di ogni chat memorizza il **motore**; riaprendo una chat si usa il suo motore. Il contesto di sessione non passa da un motore all'altro: cambiare motore apre una nuova chat.
|
||||
- [x] Chiudere le verifiche dell'ADR-0001 con un prototipo e portarlo a "Accettata" (restano due verifiche indicate nell'ADR)
|
||||
- [x] Nome dell'app in un solo punto: `AssemblyName` nel csproj, letto da `Core/AppInfo.cs`; la rinomina segue la checklist di docs/README.md
|
||||
- [x] Rinomina in `agent-wiki-ui` (csproj, namespace) e migrazione automatica della cartella dati `LlmRun` → `agent-wiki-ui`
|
||||
- [x] Target `net10.0` (non più `net10.0-windows`); rimossi WinForms e WebView2
|
||||
- [x] Estrarre in un solo punto la logica di avvio dei motori (`Core/EngineRunner.cs`: cartella dell'exe, stdin chiuso), prima duplicata tra `Program.cs` e `Gui.cs`
|
||||
- [x] Cronologia in `Environment.SpecialFolder.LocalApplicationData` (stesso formato JSON, chat esistenti ancora leggibili)
|
||||
- [x] GUI Avalonia: finestra, barra laterale delle chat, conversazione, composer con modello ed effort
|
||||
- [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] 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
|
||||
- [x] Aggiornare README.md e AGENT.md (già CLAUDE.md: comandi, architettura, vincoli) a migrazione conclusa
|
||||
|
||||
**GUI: Impostazioni**
|
||||
- [ ] Schermata/pannello Impostazioni (icona nella barra laterale) con selettore del **motore** attivo.
|
||||
- [ ] Il selettore Modello mostra solo i modelli del motore scelto; Effort compare solo se il motore lo supporta.
|
||||
- [ ] Impostazioni persistite su disco (motore, modello, effort), così si ritrovano alla riapertura. Si lega al "config file" della Fase 3.
|
||||
- [ ] Il motore della chat aperta è indicato nell'interfaccia (etichetta sull'intestazione o sulla voce in elenco).
|
||||
## 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.
|
||||
|
||||
**Rischi e punti da verificare**
|
||||
- [ ] **Codex**: l'id di sessione non lo sceglie l'app (lo genera Codex): va letto dall'output (probabilmente con l'output JSON) per poter riprendere la chat.
|
||||
- [ ] **Antigravity**: segnalato un blocco di `agy -p` quando lanciato da sottoprocesso con output rediretto su Windows ([issue #318](https://github.com/google-antigravity/antigravity-cli/issues/318)); provare con un timeout (`--print-timeout`) e prevedere un messaggio d'errore. I flag vanno messi prima di `-p`.
|
||||
- [ ] **Permessi**: Codex e Antigravity chiedono conferma per le azioni; in modalità non interattiva serve decidere una politica (sola lettura di default, opzione esplicita per concedere di più) invece di usare flag che saltano ogni controllo.
|
||||
- [ ] Formato dell'output di ciascun motore (testo semplice o JSON) e normalizzazione prima del rendering markdown.
|
||||
- [ ] Autenticazione: ogni CLI deve essere già autenticata; l'app non gestisce login.
|
||||
- [ ] CLI (`LlmRun "prompt"`): opzione `--engine`, coerente con la GUI.
|
||||
- [ ] Verificare le compatibilità dell'ADR-0003 (xUnit, Avalonia.Headless, coverlet, `dotnet test`) e portarlo ad "Accettata"
|
||||
- [x] Ristrutturare in `src/` e `tests/` con soluzione unica e `InternalsVisibleTo`
|
||||
- [ ] Predisposizioni di testabilità: `ChatStore` a istanza, `IClaudeRunner`
|
||||
- [x] `FakeClaude`: eseguibile finto per i test di processo (`tests/FakeClaude`, prove FK-01…FK-05)
|
||||
- [ ] Test `Core/` (CL, ST) e `MainViewModel` (VM)
|
||||
- [ ] Test del renderer markdown (MD) e della GUI headless (UI)
|
||||
- [ ] Test end-to-end e smoke di publish per `win-x64` e `linux-x64` (PUB)
|
||||
- [ ] Soglie di copertura che fanno fallire la build
|
||||
- [ ] CI con matrice Windows + Linux (fornitore da scegliere)
|
||||
- [ ] Batteria di contratto per ogni motore (EN), insieme alla Fase 4
|
||||
+307
@@ -0,0 +1,307 @@
|
||||
# Piano dei test
|
||||
|
||||
Decisioni (strumenti, livelli, struttura): [ADR-0003](adr/0003-strategia-di-test.md). Qui: regola, flusso, soglie e **matrice requisito → test**, sorgente di verità per la copertura. Le spunte `[ ]` passano a `[x]` quando il test esiste e passa.
|
||||
|
||||
## Regola
|
||||
**Nuova funzione, correzione o cambio di comportamento ⇒ test nello stesso commit.** Niente test, funzione non finita.
|
||||
- Una nuova funzione aggiunge righe alla matrice qui sotto (con ID) prima di scrivere il codice.
|
||||
- Una correzione di bug parte da un test che fallisce e lo lascia come regressione.
|
||||
- Una modifica che cambia un requisito aggiorna prima il doc, poi la riga della matrice, poi i test, poi il codice.
|
||||
- Una riga senza test non è copertura: va lasciata `[ ]` e conta come debito visibile.
|
||||
|
||||
## 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/AGENT.md.
|
||||
|
||||
## Livelli
|
||||
| Livello | Cosa prova | Come |
|
||||
|---|---|---|
|
||||
| **U** — unitario | `Core/` e `MainViewModel` | xUnit, finto runner, cartella dati temporanea |
|
||||
| **R** — renderer | `MarkdownView` | xUnit + Headless, asserzioni sull'albero visuale |
|
||||
| **G** — GUI headless | `MainWindow`, template, tastiera, finestre di dialogo | xUnit + Headless, senza schermo |
|
||||
| **P** — processo | avvio reale di un processo (`Claude`) | `FakeClaude` nel PATH |
|
||||
| **E** — end-to-end | l'eseguibile pubblicato (CLI, 127, exit code) | publish + processo figlio + `FakeClaude` |
|
||||
|
||||
## Struttura
|
||||
```
|
||||
agent-wiki-ui.slnx
|
||||
src/agent-wiki-ui/ app (Core/, Gui/, Program.cs)
|
||||
tests/agent-wiki-ui.Tests/ Support/ (TestApp, PngFactory), Gui/ (R, G), Process/ (P), Core/ (U), E2E/ (E)
|
||||
tests/FakeClaude/ eseguibile finto `claude` (vedi sotto)
|
||||
```
|
||||
I percorsi `Core/` e `Gui/` citati in questo documento sono relativi a `src/agent-wiki-ui/`.
|
||||
Una cartella per livello, creata quando c'è il primo test; il livello si dichiara anche con `[Trait("Category", "Unit" | "Gui" | "Process" | "E2E")]`.
|
||||
|
||||
### FakeClaude
|
||||
Piccolo eseguibile (`AssemblyName` `claude`, nel PATH dei test) che prende il posto del vero motore. Un test lo configura con variabili d'ambiente del processo che avvia:
|
||||
|
||||
| Variabile | Effetto |
|
||||
|---|---|
|
||||
| `FAKE_CLAUDE_LOG` | file in cui accoda una riga JSON per invocazione: `{"args": [...], "cwd": "...", "stdin": "..."}` |
|
||||
| `FAKE_CLAUDE_OUT` | testo scritto su stdout (anche per `--version`) |
|
||||
| `FAKE_CLAUDE_ERR` | testo scritto su stderr |
|
||||
| `FAKE_CLAUDE_EXIT` | exit code (predefinito 0) |
|
||||
| `FAKE_CLAUDE_DELAY_MS` | attesa prima di rispondere |
|
||||
|
||||
Legge stdin fino alla fine e lo registra: se il chiamante non lo chiude, il processo non termina (così CL-05 è verificabile). Il percorso del file compilato lo fornisce l'helper di test `FakeClaudePath`.
|
||||
|
||||
## Predisposizioni di testabilità (prerequisito dei test)
|
||||
- [ ] `ChatStore` come istanza con cartella iniettata (oggi statico su `LocalApplicationData`)
|
||||
- [ ] `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)
|
||||
- [x] `InternalsVisibleTo` verso il progetto di test
|
||||
- [x] Spostamento in `src/agent-wiki-ui/` e `tests/` con soluzione unica `agent-wiki-ui.slnx`
|
||||
|
||||
## Soglie di copertura (la build fallisce sotto soglia)
|
||||
| Area | Righe | Rami |
|
||||
|---|---|---|
|
||||
| `Core/` | ≥ 95% | ≥ 90% |
|
||||
| `Gui/MainViewModel` | ≥ 95% | ≥ 90% |
|
||||
| `Gui/MarkdownView` | ≥ 90% | ≥ 85% |
|
||||
| `Gui/MainWindow*`, `ConfirmDialog` (code-behind) | ≥ 85% | — |
|
||||
| Totale | ≥ 90% | — |
|
||||
|
||||
Esclusi dal calcolo: XAML generato, `Program.cs` (tre righe, coperte da E2E), `App.axaml.cs`. La soglia non sostituisce la matrice: copertura di righe alta con requisiti scoperti non basta.
|
||||
|
||||
## Matrice requisito → test
|
||||
Fonte dei requisiti: [MVP.md](MVP.md) e gli ADR. Livello: vedi sopra. Il nome del test è indicativo.
|
||||
|
||||
### Avvio dei motori — `Core/EngineRunner.cs`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| CL-01 | Il prompt è un solo argomento, anche con virgolette e spazi (criterio MVP 4) | U/P | `Prompt_con_virgolette_arriva_intatto` | [ ] |
|
||||
| CL-02 | Primo messaggio: `--session-id <guid>`; successivi: `--resume <guid>` | U | `Sessione_prima_e_ripresa` | [ ] |
|
||||
| CL-03 | `--model`/`--effort` omessi se vuoti, presenti se valorizzati | U | `Flag_opzionali` | [ ] |
|
||||
| CL-04 | Cartella di lavoro = cartella dell'exe, non la cwd del chiamante (criterio MVP 1) | U/P | `Cartella_di_lavoro_e_quella_dell_exe` | [ ] |
|
||||
| CL-05 | Stdin chiuso subito: nessuna attesa di 3 s | P | `Stdin_chiuso_non_blocca` | [ ] |
|
||||
| CL-06 | CLI: l'exit code di `claude` è propagato (criterio MVP 3) | P/E | `ExitCode_propagato` | [ ] |
|
||||
| CL-07 | CLI: eseguibile del motore assente ⇒ messaggio chiaro (con il nome dell'eseguibile) ed exit code 127 | P/E | `Claude_assente_127` | [ ] |
|
||||
| CL-08 | CLI: stdout/stderr ereditati e ritrasmessi (criterio MVP 2: streaming) | E | `Output_ereditato_in_tempo_reale` | [ ] |
|
||||
| CL-09 | GUI: output catturato e ripulito agli estremi; stderr separato | P | `Output_catturato` | [ ] |
|
||||
| CL-10 | GUI: `claude` assente ⇒ eccezione riconoscibile, non crash | P | `Claude_assente_in_GUI` | [ ] |
|
||||
| CL-11 | Il catalogo modelli contiene gli ID attesi e gli effort previsti | U | `Catalogo_modelli_ed_effort` | [ ] |
|
||||
| CL-12 | Senza argomenti non parte la CLI; con argomenti sì (tutti uniti in un prompt) | E | `Argomenti_uniti_in_un_prompt` | [ ] |
|
||||
|
||||
### Codex — `Core/Engine.cs` (parser e argomenti), `Core/EngineRunner.cs`
|
||||
Le righe CL valgono per ogni motore; queste sono specifiche di Codex (ADR-0002). Il parser si prova con output JSONL reali salvati nei test.
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| CX-01 | Primo messaggio: `exec --json --skip-git-repo-check -s read-only … -- <prompt>` | U | `Codex_primo_messaggio` | [ ] |
|
||||
| CX-02 | Ripresa: `exec resume --json … -c sandbox_mode="read-only" <id> -- <prompt>`, senza `-s` | U | `Codex_ripresa` | [ ] |
|
||||
| CX-03 | Un prompt che inizia con `-` arriva intatto (grazie a `--`) | U/P | `Codex_prompt_con_trattino` | [ ] |
|
||||
| CX-04 | Modello ⇒ `-m`; effort ⇒ `-c model_reasoning_effort=<livello>`; vuoti ⇒ omessi | U | `Codex_modello_ed_effort` | [ ] |
|
||||
| CX-05 | Il parser legge `thread_id` da `thread.started` | U | `Codex_thread_id` | [ ] |
|
||||
| CX-06 | La risposta è l'ultimo `agent_message`, anche con più messaggi | U | `Codex_ultimo_agent_message` | [ ] |
|
||||
| CX-07 | `turn.failed`: messaggio interno di `error.message` estratto dal JSON annidato; exit ≠ 0 ⇒ errore | U | `Codex_errore_turno` | [ ] |
|
||||
| CX-08 | Eventi `item.completed` di tipo `error` (avvisi) non fanno fallire la risposta | U | `Codex_avvisi_ignorati` | [ ] |
|
||||
| CX-09 | Exit 0 senza `agent_message` ⇒ errore "nessuna risposta" | U | `Codex_nessuna_risposta` | [ ] |
|
||||
| CX-10 | Righe non JSON o eventi sconosciuti sono ignorati senza eccezioni | U | `Codex_righe_non_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` | [ ] |
|
||||
|
||||
### Antigravity — `Core/Engine.cs` (parser e argomenti), `Core/EngineRunner.cs`
|
||||
Le righe CL valgono per ogni motore; queste sono specifiche di Antigravity CLI (`agy`, ADR-0002).
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| AG-01 | Primo messaggio: `--output-format json --print-timeout 120s … -p <prompt>` (senza `--mode`, sola lettura garantita dal default in headless) | U | `Agy_primo_messaggio` | [x] |
|
||||
| AG-02 | Ripresa: `--output-format json --conversation <sessionId> … -p <prompt>` (senza `--mode`) | U | `Agy_ripresa` | [x] |
|
||||
| AG-03 | Tutti i flag precedono rigorosamente `-p <prompt>` | U | `Agy_flag_prima_di_p` | [x] |
|
||||
| AG-04 | Modello ⇒ `--model`; effort ⇒ `--effort`; vuoti ⇒ omessi | U | `Agy_modello_ed_effort` | [x] |
|
||||
| AG-05 | Il parser legge `conversation_id` dall'output JSON (`OwnsSessionId => true`) | U | `Agy_conversation_id` | [x] |
|
||||
| AG-06 | La risposta è estratta dal campo `response` del JSON | U | `Agy_estrazione_risposta` | [x] |
|
||||
| AG-07 | `status` diverso da SUCCESS o campo `error` ⇒ errore; exit ≠ 0 ⇒ Failed(code, stderr) | U | `Agy_errore_status` | [x] |
|
||||
| AG-08 | Avvisi o testo spurio prima/dopo il JSON sono isolati correttamente | U | `Agy_estrazione_json_robusta` | [x] |
|
||||
| AG-09 | Exit 0 con `response` vuoto ⇒ errore "agy non ha restituito nessuna risposta" | U | `Agy_nessuna_risposta` | [x] |
|
||||
| AG-10 | In modalità CLI (`structured = false`) non si usa `--output-format json` | U | `Agy_cli_senza_json` | [x] |
|
||||
| AG-11 | Stdin chiuso subito e `--print-timeout 120s` prevengono il blocco con output rediretto | P | `Agy_timeout_e_stdin` | [x] |
|
||||
| AG-12 | Catalogo modelli con i 6 modelli attesi ed effort fino a max; default `gemini-3.0-flash-low`, `low` | U | `Agy_catalogo_modelli` | [x] |
|
||||
|
||||
### 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` | [ ] |
|
||||
| UP-21 | Antigravity: l'ultima versione si legge dal servizio auto-updater ufficiale (stringa "Stable Version: X.Y.Z") | U | `Ultima_versione_agy` | [x] |
|
||||
|
||||
### Cronologia — `Core/ChatStore.cs`, `Core/AppInfo.cs`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| ST-01 | Salvataggio e rilettura: id, titolo, data, `started`, messaggi con ruolo e testo | U | `Salva_e_rileggi` | [ ] |
|
||||
| ST-02 | Una chat senza messaggi non viene salvata | U | `Chat_vuota_non_salvata` | [ ] |
|
||||
| ST-03 | Titolo = inizio del primo messaggio utente: 50 caratteri + "…", a capo sostituiti da spazi | U | `Titolo_troncato` | [ ] |
|
||||
| ST-04 | L'id deve essere un Guid: un id con `..` o separatori non tocca il disco fuori dalla cartella | U | `Id_non_guid_rifiutato` | [ ] |
|
||||
| ST-05 | L'elenco è ordinato dalla più recente | U | `Elenco_ordinato` | [ ] |
|
||||
| ST-06 | File JSON corrotto ignorato senza eccezioni | U | `File_corrotto_ignorato` | [ ] |
|
||||
| ST-07 | Eliminazione: rimuove solo il file di quella chat; id inesistente senza errori | U | `Elimina_chat` | [ ] |
|
||||
| ST-08 | Compatibilità del formato: un JSON scritto dalla versione WinForms si legge | U | `Formato_storico_compatibile` | [ ] |
|
||||
| ST-09 | Migrazione: la cartella di un nome precedente (`LlmRun`) si sposta nella nuova al primo avvio; se la nuova esiste non si tocca nulla | U | `Migrazione_da_nome_precedente` | [ ] |
|
||||
| ST-10 | `AppInfo.Name` = `AssemblyName` del csproj | U | `Nome_da_assembly` | [ ] |
|
||||
| ST-12 | Il JSON salva `Engine` e `SessionId`; un file senza questi campi si legge come chat di Claude Code con `SessionId` = id | U | `Motore_e_sessione_salvati_e_compatibilita` | [ ] |
|
||||
| ST-11 | Errore di I/O nel salvataggio non perde la chat a schermo | U | vedi VM-12 | [ ] |
|
||||
|
||||
### Logica della chat — `Gui/MainViewModel.cs`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| VM-01 | Senza chat salvate: schermata iniziale (`ShowEmpty`), elenco vuoto | U | `Avvio_senza_chat` | [ ] |
|
||||
| VM-02 | All'avvio si riapre la chat più recente | U | `Avvio_riapre_ultima` | [ ] |
|
||||
| VM-03 | `CanSend` falso se il testo è vuoto o solo spazi, o se occupato | U | `CanSend` | [ ] |
|
||||
| VM-04 | Invio: il messaggio utente compare e viene **salvato prima** della risposta | U | `Messaggio_salvato_prima_della_risposta` | [ ] |
|
||||
| VM-05 | Risposta riuscita: aggiunta come "ai", `started` diventa vero, il secondo invio usa `--resume` | U | `Risposta_e_ripresa` | [ ] |
|
||||
| VM-06 | Risposta fallita (exit ≠ 0): messaggio "err" con codice e stderr; `started` resta falso e il tentativo successivo usa ancora `--session-id` | U | `Errore_non_avvia_la_sessione` | [ ] |
|
||||
| VM-07 | `claude` assente: messaggio "'claude' non trovato nel PATH." | U | `Claude_assente_messaggio` | [ ] |
|
||||
| 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-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-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-14 | Eliminazione: con conferma rimuove; senza conferma non fa nulla; se è la chat aperta parte una nuova | U | `Elimina_con_e_senza_conferma` | [ ] |
|
||||
| VM-16 | Barra laterale: il comando commuta `SidebarOpen` | U | `Barra_laterale` | [ ] |
|
||||
| VM-17 | Copia: il comando passa il testo alla funzione degli appunti | U | `Copia_negli_appunti` | [ ] |
|
||||
| VM-18 | Notifiche di proprietà: `HasMessages`, `ShowEmpty`, `CanSend`, `IsCustomModel` cambiano quando devono | U | `Notifiche_proprieta` | [ ] |
|
||||
| VM-19 | Il titolo e la data dell'elenco riflettono l'ultimo scambio; la chat aperta è marcata attiva | U | `Elenco_chat_attiva` | [ ] |
|
||||
|
||||
### Renderer markdown — `Gui/MarkdownView.cs`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| MD-01 | Sorgente vuota o nulla ⇒ nessun contenuto, senza errori | R | `Sorgente_vuota` | [ ] |
|
||||
| MD-02 | Titoli h1–h6 con dimensioni decrescenti e peso semi-grassetto | R | `Titoli` | [ ] |
|
||||
| MD-03 | Paragrafi; a capo morbido = spazio, a capo forzato = riga nuova | R | `A_capo` | [ ] |
|
||||
| MD-04 | Grassetto, corsivo, barrato, anche annidati | R | `Enfasi` | [ ] |
|
||||
| MD-05 | Codice inline in carattere monospazio con sfondo | R | `Codice_inline` | [ ] |
|
||||
| MD-06 | Blocco di codice: monospazio, scorrimento orizzontale, pulsante Copia che copia solo il codice | R/G | `Blocco_codice_e_copia` | [ ] |
|
||||
| MD-07 | Liste puntate e numerate (rispetta il numero iniziale), annidate | R | `Liste` | [ ] |
|
||||
| MD-08 | Citazioni con barra laterale, anche annidate | R | `Citazioni` | [ ] |
|
||||
| MD-09 | Tabelle: intestazione in evidenza, allineamenti sinistra/centro/destra, righe irregolari | R | `Tabelle` | [ ] |
|
||||
| MD-10 | Linea orizzontale | R | `Linea_orizzontale` | [ ] |
|
||||
| MD-11 | Link: colore d'accento e sottolineatura; il clic apre solo `http(s)` | R | `Link_http_https` | [ ] |
|
||||
| MD-12 | Link: nessuna apertura se c'è una selezione in corso; cursore a mano sopra il link | R | `Link_con_selezione` | [ ] |
|
||||
| MD-13 | Posizioni dei link corrette con enfasi, codice inline e a capo prima del link | R | `Intervalli_link` | [ ] |
|
||||
| MD-14 | Immagini con URL `http(s)` o altro schema: si mostra il testo alternativo, nessuna richiesta di rete | R | `Immagini_remote_come_testo` | [x] |
|
||||
| MD-19 | Immagine con percorso assoluto di un file png valido ⇒ controllo immagine con le dimensioni attese (ADR-0006) | R | `Immagine_percorso_assoluto` | [x] |
|
||||
| MD-20 | Percorso relativo risolto rispetto a `AppContext.BaseDirectory`; anche URI `file://` | R | `Immagine_percorso_relativo_e_file_uri` | [x] |
|
||||
| MD-21 | File mancante, illeggibile, corrotto o con estensione non ammessa ⇒ testo alternativo, nessuna eccezione | R | `Immagine_non_valida_ripiego` | [x] |
|
||||
| MD-22 | File oltre il limite di 20 MB ⇒ testo alternativo, file non decodificato | R | `Immagine_oltre_limite` | [x] |
|
||||
| MD-23 | Immagine più larga della colonna ⇒ ridotta in larghezza mantenendo le proporzioni; mai ingrandita oltre l'originale | R | `Immagine_larghezza_massima` | [x] |
|
||||
| MD-24 | Il testo alternativo è nome accessibile e suggerimento dell'immagine | R | `Immagine_testo_alternativo_accessibile` | [x] |
|
||||
| MD-25 | Immagine dentro un link, in una lista o in una tabella ⇒ resa senza rompere intervalli dei link (MD-13) né il layout | R | `Immagine_in_contesti_annidati` | [x] |
|
||||
| MD-26 | Cambio di tema con immagini presenti ⇒ vista ricostruita, immagini ancora mostrate | R | `Immagine_cambio_tema` | [x] |
|
||||
| MD-27 | Il caricamento è in background: subito dopo il rendering c'è il segnaposto `[alt]` e un'immagine in attesa; a fine decodifica compare l'immagine; un file corrotto lascia `[alt]` | R | `Immagine_caricamento_in_background` | [x] |
|
||||
| MD-28 | Percorso relativo non presente nella cartella dell'exe ma in una cartella superiore (radice del progetto, es. `<cartella>/<file>` con l'exe in una sottocartella) ⇒ immagine mostrata | R | `Immagine_percorso_relativo_alla_radice` | [x] |
|
||||
| MD-29 | Se il file esiste in più cartelle, vince la più vicina all'exe; se non esiste in nessuna ⇒ testo alternativo | R | `Immagine_cartella_piu_vicina` | [x] |
|
||||
| MD-30 | Risposta con immagine e, sotto, didascalia e link in markdown: l'immagine compare e la didascalia resta testo; l'app non legge nessun catalogo | R | `Immagine_risposta_con_didascalia` | [x] |
|
||||
| MD-31 | Formula inline `$…$` ⇒ controllo formula inserito nel testo; il testo prima e dopo resta intatto e non sparisce più (ADR-0008) | R | `Formula_inline` | [x] |
|
||||
| MD-32 | Formula a blocco `$$…$$` ⇒ controllo formula (non un blocco di codice col sorgente) | R | `Formula_a_blocco` | [x] |
|
||||
| MD-33 | LaTeX non valido (inline e a blocco) ⇒ sorgente come testo, nessuna eccezione | R | `Formula_non_valida_ripiego` | [x] |
|
||||
| MD-34 | Costrutti LaTeX comuni (frazioni, apici e pedici, `\mathbf`, `\overline`, `\times`, lettere greche, `\left…\right`, `\sum`) ⇒ nessun errore | R | `Costrutti_latex_comuni` | [x] |
|
||||
| MD-35 | Cambio di tema con formule presenti ⇒ vista ricostruita, formule ancora mostrate | R | `Formula_cambio_tema` | [x] |
|
||||
| MD-36 | Formula dentro una lista, una tabella o un link ⇒ resa senza rompere il layout né gli intervalli dei link (MD-13) | R | `Formula_in_contesti_annidati` | [x] |
|
||||
| MD-37 | Il nome accessibile della formula è il suo sorgente LaTeX | R | `Formula_nome_accessibile` | [x] |
|
||||
| MD-38 | Simboli `$` isolati (es. prezzi «10 $ e 20 $») restano testo, nessuna formula | R | `Dollari_isolati_restano_testo` | [x] |
|
||||
| MD-15 | HTML grezzo disabilitato: i tag compaiono come testo, non come elementi | R | `Html_disabilitato` | [ ] |
|
||||
| MD-16 | Cambio di tema (chiaro/scuro): i colori si aggiornano ricostruendo la vista | R | `Cambio_tema` | [ ] |
|
||||
| MD-17 | Markdown malformato o blocchi sconosciuti non fanno crashare | R | `Markdown_malformato` | [ ] |
|
||||
| MD-18 | Testo selezionabile | R | `Testo_selezionabile` | [ ] |
|
||||
|
||||
### Finestra e interazione — `Gui/MainWindow*`, `Gui/App.axaml`, `Gui/ConfirmDialog.cs`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| UI-01 | La finestra si apre e mostra la schermata iniziale (logo, titolo, sottotitolo, nessun suggerimento) | G | `Apertura_schermata_iniziale` | [ ] |
|
||||
| UI-02 | Proporzioni 16:10, 75% dell'area utile (max 1440), minimo 900x600; senza schermo primario 1280x800 | G | `Dimensioni_finestra` | [ ] |
|
||||
| UI-03 | `Invio` invia, `Maiusc+Invio` va a capo, nessun invio a campo vuoto | G | `Tasti_invio` | [ ] |
|
||||
| UI-04 | Il pulsante Invia è disabilitato con campo vuoto o in attesa | G | `Pulsante_invia` | [ ] |
|
||||
| UI-05 | I messaggi hanno aspetto per ruolo: utente, Claude (con Copia), errore | G | `Template_per_ruolo` | [ ] |
|
||||
| UI-06 | La conversazione scorre in fondo a ogni nuovo messaggio | G | `Scorrimento_in_fondo` | [ ] |
|
||||
| UI-07 | Indicatore di attesa visibile solo durante l'elaborazione | G | `Indicatore_attesa` | [ ] |
|
||||
| UI-08 | Elenco chat: voce attiva evidenziata, clic apre, ✕ elimina; "Nessuna chat salvata" se vuoto | G | `Elenco_chat` | [ ] |
|
||||
| UI-09 | Nel riquadro Impostazioni il campo "Altro ID…" compare solo con quella voce del modello | G | `Campo_modello_personalizzato` | [ ] |
|
||||
| UI-10 | Il pulsante a tre linee mostra/nasconde la barra laterale | G | `Mostra_nascondi_barra` | [ ] |
|
||||
| UI-11 | Dialogo di conferma: restituisce vero con Elimina, falso con Annulla o chiusura | G | `Dialogo_conferma` | [ ] |
|
||||
| UI-12 | Accessibilità: ogni pulsante a sola icona e il campo messaggio hanno `AutomationProperties.Name` | G | `Nomi_accessibili` | [ ] |
|
||||
| UI-13 | Tema: sia il chiaro sia lo scuro risolvono tutti i token usati (nessuna risorsa mancante) | G | `Token_tema_completi` | [ ] |
|
||||
| UI-14 | Focus sul campo messaggio all'apertura, dopo la risposta e dopo "Nuova chat" | G | `Focus_campo` | [ ] |
|
||||
| UI-16 | Il pulsante Impostazioni (in alto a destra) apre il riquadro con Modello ed Effort; `Esc` lo chiude | G | `Riquadro_impostazioni` | [ ] |
|
||||
| UI-17 | Il composer non contiene selettori di modello ed effort | G | `Composer_senza_selettori` | [ ] |
|
||||
| UI-18 | Le scelte fatte nel riquadro arrivano ai flag `--model`/`--effort` del messaggio successivo | G/U | `Impostazioni_applicate_all_invio` | [ ] |
|
||||
| UI-15 | Il nome dell'app compare nel titolo della finestra e nella barra laterale | G | `Nome_app_visibile` | [ ] |
|
||||
|
||||
### 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 | |
|
||||
|---|---|---|---|---|
|
||||
| PUB-01 | Il publish single-file `linux-x64` si compila e la CLI risponde con `FakeClaude` | E | `Publish_linux_smoke` | [ ] |
|
||||
| PUB-02 | Il publish single-file `win-x64` si compila e la CLI risponde con `FakeClaude` | E | `Publish_windows_smoke` | [ ] |
|
||||
| PUB-03 | Le librerie native (Skia/HarfBuzz) vengono estratte e la GUI si avvia (provata con timeout) | E | `Gui_si_avvia` | [ ] |
|
||||
|
||||
### Più motori (ADR-0002) — da compilare quando si implementa la Fase 4
|
||||
Per **ogni** motore, la stessa batteria di contratto:
|
||||
| ID | Requisito | Liv. | |
|
||||
|---|---|---|---|
|
||||
| EN-01 | Argomenti del primo messaggio e della ripresa (Claude: CL-02; Codex: CX-01, CX-02) | U | [ ] |
|
||||
| EN-02 | Rilevamento nel PATH; assente ⇒ disabilitato e messaggio chiaro | U/P | [ ] |
|
||||
| EN-03 | Lettura dell'id di sessione dall'output (Codex: CX-05) | U | [ ] |
|
||||
| EN-04 | Parser dell'output → markdown, con output di esempio reali salvati nei test | U | [ ] |
|
||||
| EN-05 | Modelli ed effort mostrati secondo il motore | U/G | [ ] |
|
||||
| EN-06 | Il JSON della chat memorizza il motore; cambiare motore apre una nuova chat | U | [ ] |
|
||||
| EN-07 | Politica dei permessi: nessun flag che salta i controlli senza scelta esplicita | U | [ ] |
|
||||
| EN-08 | Impostazioni persistite e rilette | U | [ ] |
|
||||
| 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-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-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-15 | Etichetta autore, segnaposto, messaggio d'attesa ed elenco chat mostrano il nome del motore | U/G | [ ] |
|
||||
| EN-16 | Dopo il primo invio con Codex il `SessionId` è quello letto dall'output e il secondo invio usa la ripresa; con errore al primo invio resta senza sessione | U | [ ] |
|
||||
| EN-17 | CLI `--engine <id> "prompt"`; id sconosciuto o prompt mancante ⇒ uso su stderr ed exit 2; senza `--engine` ⇒ Claude Code | E | [ ] |
|
||||
| EN-18 | Rilevamento nel PATH: nome esatto su Linux, `.exe` su Windows; cartella inesistente nel PATH ignorata | U | [ ] |
|
||||
|
||||
### FakeClaude — `tests/FakeClaude`
|
||||
| ID | Requisito | Liv. | Test | |
|
||||
|---|---|---|---|---|
|
||||
| FK-01 | Registra argomenti (anche con virgolette e spazi, uno per elemento), cartella di lavoro e stdin | P | `Registra_argomenti_cwd_e_stdin` | [x] |
|
||||
| FK-02 | Scrive su stdout e stderr il testo configurato | P | `Output_e_stderr_configurati` | [x] |
|
||||
| FK-03 | L'exit code configurato è quello del processo | P | `ExitCode_configurato` | [x] |
|
||||
| FK-04 | Il ritardo configurato è rispettato | P | `Ritardo_configurato` | [x] |
|
||||
| FK-05 | Termina solo dopo la chiusura di stdin | P | `Attende_la_chiusura_di_stdin` | [x] |
|
||||
|
||||
## Come si eseguono (a implementazione avvenuta)
|
||||
Comandi previsti, da confermare con ADR-0003 → "Da verificare":
|
||||
- Tutti i test: `dotnet test`
|
||||
- Con copertura e soglie: `dotnet test --collect:"XPlat Code Coverage"` e controllo delle soglie della tabella sopra
|
||||
- Solo una categoria: `dotnet test --filter "Category=Unit"` (o `Gui`, `Process`, `E2E`)
|
||||
Su Linux i test GUI girano senza display (Headless).
|
||||
|
||||
## Definition of Done di una modifica
|
||||
- [ ] Doc aggiornati (MVP, ROADMAP, ADR se serve)
|
||||
- [ ] Righe nuove o modificate nella matrice, con ID
|
||||
- [ ] Test scritti e verdi su Windows e Linux
|
||||
- [ ] Soglie di copertura rispettate
|
||||
- [ ] Nessun requisito della modifica resta con la casella `[ ]` senza motivo scritto
|
||||
@@ -0,0 +1,61 @@
|
||||
# ADR-0001 — GUI multipiattaforma in solo C# con Avalonia
|
||||
|
||||
- **Stato**: Accettata (implementata; restano due verifiche, vedi sotto)
|
||||
- **Data**: 2026-10-15
|
||||
- **Sostituisce**: la parte "GUI WinForms + WebView2 + `ui.html`" di [MVP.md](../MVP.md) (le sezioni interessate rimandano a questo ADR)
|
||||
|
||||
## Contesto
|
||||
L'app nasce per Windows: GUI WinForms con un solo WebView2 che carica `ui.html` (HTML/CSS/JS), CLI in `Program.cs`. L'obiettivo ora è avere **un eseguibile standalone per Windows e Linux** nel modo più semplice, **scritto interamente in C#, senza HTML**.
|
||||
|
||||
Oggi non è possibile: WinForms e WebView2 sono solo Windows, il csproj punta a `net10.0-windows`, la cronologia usa `%LOCALAPPDATA%`. La CLI invece è già portabile.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Un solo codice sorgente, compilabile per `win-x64` e `linux-x64`.
|
||||
2. Standalone: publish single-file self-contained, senza runtime né librerie da installare oltre a quanto offre un normale desktop.
|
||||
3. Solo C# (e XAML per il layout): niente HTML/CSS/JS.
|
||||
4. Mantenere la GUI a finestra (chat con barra laterale, markdown, selettori modello/effort).
|
||||
5. Riuso massimo della logica esistente (`claude -p`, sessioni, cronologia JSON, Markdig).
|
||||
|
||||
## Opzioni considerate
|
||||
| Opzione | Esito | Motivo |
|
||||
|---|---|---|
|
||||
| Mantenere WinForms + WebView2 | Scartata | Solo Windows, e richiede HTML. |
|
||||
| Photino / WebView nativa | Scartata | Richiede HTML e, su Linux, webkit2gtk da installare: non standalone. |
|
||||
| Server HTTP locale (Kestrel) + browser | Scartata | Portabile e semplice, ma la UI resta HTML e non è una finestra propria. |
|
||||
| MAUI | Scartata | Nessun supporto desktop Linux ufficiale. |
|
||||
| Terminal.Gui (TUI) | Alternativa | Puro C#, binario leggero, ma è un'interfaccia da terminale, non una finestra. |
|
||||
| **Avalonia UI** | **Scelta** | GUI nativa, C# + XAML, render Skia, Windows e Linux, publish single-file self-contained. |
|
||||
|
||||
## Decisione
|
||||
La GUI viene riscritta con **Avalonia UI**:
|
||||
- Layout in XAML, logica in C# con `ViewModel` e binding. `ui.html`, il protocollo `WebMessage` e le dipendenze WinForms/WebView2 spariscono.
|
||||
- Rendering markdown con un **renderer proprio** che trasforma l'albero di Markdig in controlli Avalonia (`src/agent-wiki-ui/Gui/MarkdownView.cs`), al posto della conversione in HTML. Si è scelto di non usare `Markdown.Avalonia` perché l'ultima versione pubblicata (11.0.x) è per Avalonia 11, mentre si usa Avalonia 12. I link `http(s)` si aprono nel browser di sistema.
|
||||
- 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 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 `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`.
|
||||
|
||||
## Conseguenze
|
||||
**Positive**
|
||||
- Un solo eseguibile per sistema, senza dipendenze di runtime.
|
||||
- Nessun HTML/JS da mantenere; il vincolo STA di WinForms/WebView2 non c'è più.
|
||||
- Pulizia della duplicazione CLI/GUI.
|
||||
|
||||
**Negative / costi**
|
||||
- Riscrittura della sola parte GUI (`Gui.cs` + `ui.html`), più ampia di una soluzione basata sul browser.
|
||||
- Eseguibile più pesante (include Avalonia/Skia).
|
||||
- Perdita di alcune comodità del web: la resa del markdown (tabelle, blocchi di codice, pulsante Copia) dipende dalla libreria scelta e va riprodotta o adattata.
|
||||
- Su Linux serve un desktop con X11 o XWayland e le librerie di base (fontconfig ecc.).
|
||||
|
||||
## Da verificare (prima di passare a "Accettata")
|
||||
- [x] Rendering markdown: tabelle, citazioni, liste, codice, link ed enfasi verificati con uno screenshot headless in tema chiaro e scuro (libreria `Markdown.Avalonia` scartata, vedi Decisione).
|
||||
- [x] Il publish single-file `linux-x64` (48 MB con compressione) parte; verificato su WSL2 con WSLg. **Da verificare** su una distribuzione desktop pulita.
|
||||
- [x] Il publish single-file `win-x64` si compila e la CLI parte (provata da WSL tramite interoperabilità). **Da verificare** la GUI su Windows nativo.
|
||||
- [x] `claude` viene trovato nel PATH su Linux e la CLI mantiene exit code e codice 127 (provato con un `claude` finto).
|
||||
- [ ] Il tema chiaro/scuro segue il sistema anche su Linux (impostato con `RequestedThemeVariant="Default"`; non verificato su un desktop reale).
|
||||
- [x] Le chat esistenti restano leggibili (stesso formato JSON). Se il nome cambia cambia anche la cartella dati: la vecchia cartella viene migrata (fatto per `LlmRun` → `agent-wiki-ui`).
|
||||
|
||||
## Riferimenti
|
||||
- Piano di lavoro: [ROADMAP.md](../ROADMAP.md), Fase 5.
|
||||
- Specifica funzionale della chat: [MVP.md](../MVP.md).
|
||||
@@ -0,0 +1,72 @@
|
||||
# ADR-0002 — Più motori CLI (Claude Code, Codex, Antigravity) su Windows e Linux
|
||||
|
||||
- **Stato**: Accettata (Claude Code, Codex, Antigravity)
|
||||
- **Data**: 2026-10-15 (aggiornato 2026-10-18 per Antigravity)
|
||||
- **Collegato a**: [ADR-0001](0001-gui-multipiattaforma-avalonia.md) (GUI e piattaforme)
|
||||
|
||||
## Contesto
|
||||
L'app lanciava solo `claude -p`. Si vuole usare dalla stessa chat anche **OpenAI Codex CLI** e **Antigravity CLI** (`agy`), così come `claude` già installati da terminale dall'utente, su Windows e Linux. L'app non li installa e non gestisce login: sono programmi esterni, autenticati a parte.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Aggiungere un motore costa una definizione dichiarativa, non nuova logica sparsa.
|
||||
2. Funziona uguale su Windows e Linux: i motori si trovano nel PATH come da terminale.
|
||||
3. Un solo punto di avvio processo (cartella dell'exe, stdin chiuso, `ArgumentList`), condiviso da CLI e GUI.
|
||||
4. Nessuna scorciatoia che disattivi i controlli di permesso senza una scelta esplicita dell'utente.
|
||||
|
||||
## 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` è 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.
|
||||
- **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 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`, `agy`).
|
||||
- **Sessione**: per Claude Code l'id lo sceglie l'app; per Codex e Antigravity lo genera il motore e l'app lo legge dall'output (`thread_id` per Codex, `conversation_id` per Antigravity). 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.
|
||||
- **Permessi**: di default sola lettura / nessun bypass dei controlli; concedere di più è un'opzione esplicita.
|
||||
- **Output**: ogni motore ha un parser che lo normalizza in testo markdown prima del rendering.
|
||||
|
||||
## Comandi dei motori
|
||||
Claude Code, Codex e Antigravity sono verificati con prove reali (Linux/WSL, ottobre 2026).
|
||||
|
||||
| | Claude Code | Codex CLI | Antigravity CLI |
|
||||
|---|---|---|---|
|
||||
| Comando (GUI) | `claude -p <prompt>` | `codex exec --json --skip-git-repo-check -s read-only [opzioni] -- <prompt>` | `agy --output-format json --print-timeout 120s [opzioni] -p <prompt>` |
|
||||
| Continuare | `--session-id <guid>`, poi `--resume <guid>` | `codex exec resume --json --skip-git-repo-check -c 'sandbox_mode="read-only"' [opzioni] <id> -- <prompt>` | `agy --output-format json --print-timeout 120s --conversation <id> [opzioni] -p <prompt>` |
|
||||
| Modello | `--model` | `-m` / `--model` | `--model` |
|
||||
| Effort | `--effort` | `-c model_reasoning_effort=<livello>` | `--effort` |
|
||||
| Output usato | testo su stdout | JSONL su stdout (vedi sotto) | JSON su stdout (`conversation_id`, `status`, `response`) |
|
||||
|
||||
**Codex: esito delle prove**
|
||||
- L'id di sessione non si sceglie: compare nel primo evento JSONL `{"type":"thread.started","thread_id":"<uuid>"}`. Nel testo normale compare solo nell'intestazione su stderr.
|
||||
- Con `--json`, stdout contiene solo eventi: `thread.started`, `turn.started`, `item.completed` (con `item.type = "agent_message"` e il testo della risposta; con `"error"` sono avvisi non fatali), `turn.completed`, e in caso di errore `error` e `turn.failed`. Il messaggio di errore è una stringa che contiene a sua volta un JSON (`error.message`): l'app estrae il messaggio interno. L'exit code è 1 se il turno fallisce.
|
||||
- La risposta mostrata è l'**ultimo** `agent_message` del turno (come `--output-last-message`).
|
||||
- `exec resume` **non accetta `-s/--sandbox`**: la sola lettura si ottiene con `-c 'sandbox_mode="read-only"'`, verificato (un file richiesto in scrittura non viene creato). Accetta `-m` e `-c`.
|
||||
- `--skip-git-repo-check` serve perché la cartella dell'exe non è un repository Git.
|
||||
- `--` 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.
|
||||
- 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.
|
||||
|
||||
**Antigravity (`agy`): esito delle prove**
|
||||
- Eseguibile nativo: ELF su Linux (`~/.gemini/bin/agy`), `.exe` nativo su Windows.
|
||||
- Permessi e sicurezza: per usare `agy` in modalità non interattiva (`-p`) in sola lettura, nel file `~/.gemini/antigravity-cli/settings.json` deve essere presente la regola `'read_file(*)'` sotto `'permissions.allow'` (altrimenti headless mode nega `read_file` con errore jetski: `a tool required the read_file permission that headless mode cannot prompt for`), mentre scritture e comandi restano negati di default. Non si passa `--mode plan` (che fallisce anch'esso con errore jetski) né `--mode auto` (non disponibile per l'account) né alcun flag `--mode`. Mai usare `--dangerously-skip-permissions`.
|
||||
- Posizione di `-p`: tutti i flag di configurazione vanno passati rigorosamente prima di `-p <prompt>`.
|
||||
- Formato output: per la GUI (`structured = true`) si passa `--output-format json`; per la CLI si omette per ereditare testo normale. L'output JSON contiene `conversation_id`, `status` ("SUCCESS") e `response` con il testo generato.
|
||||
- Sessione: l'id di sessione è un UUID generato da `agy` (`OwnsSessionId => true`), letto da `conversation_id`. La ripresa avviene passando `--conversation <sessionId>`.
|
||||
- Blocco sottoprocesso su output rediretto (issue #318): mitigato passando `--print-timeout 120s` (formato durata Go) e assicurando la chiusura immediata dello stdin.
|
||||
- Modelli ed effort: modelli fissi da catalogo `agy models`, modello più piccolo predefinito `gemini-3.0-flash-low`, effort supportati `low`, `medium`, `high`, `xhigh`, `max` (default `low`).
|
||||
|
||||
## Conseguenze
|
||||
**Positive**: un solo flusso di avvio; nuovi motori aggiungibili con una definizione; elimina la duplicazione CLI/GUI.
|
||||
**Negative**: i flag delle CLI cambiano nel tempo e vanno mantenuti; le sessioni non si trasferiscono tra motori; più superficie da testare su due sistemi operativi.
|
||||
|
||||
## Rischi e da verificare
|
||||
- [x] **Codex**: l'id di sessione lo genera Codex; letto dall'evento `thread.started` (vedi sopra).
|
||||
- [x] **Antigravity**: verificato il comando non interattivo `agy [flag] -p <prompt>`, output JSON `--output-format json`, ripresa con `--conversation`, timeout con `--print-timeout 120s` e chiusura stdin.
|
||||
- [ ] **Forma dell'eseguibile**: `claude` e `agy` sono binari nativi avviabili direttamente; per installazioni tramite gestori di pacchetti verificare eventuali script wrapper su Windows.
|
||||
- [ ] Autenticazione: ogni CLI deve essere già autenticata; l'app mostra l'errore del motore senza gestire login.
|
||||
- [x] Formato dell'output di Codex e Antigravity: Codex JSONL, Antigravity JSON su stdout, normalizzati in testo markdown.
|
||||
- [x] Mappatura effort e modelli per Codex e Antigravity (liste fisse, da aggiornare).
|
||||
|
||||
## Riferimenti
|
||||
- Passi: [ROADMAP.md](../ROADMAP.md), Fase 4.
|
||||
- Installazione e accesso dei motori: [INSTALL.md](../INSTALL.md).
|
||||
@@ -0,0 +1,52 @@
|
||||
# ADR-0003 — Strategia di test e regola "nuova funzione = nuovi test"
|
||||
|
||||
- **Stato**: Proposta
|
||||
- **Data**: 2026-10-15
|
||||
- **Collegato a**: [ADR-0001](0001-gui-multipiattaforma-avalonia.md), [ADR-0002](0002-motori-cli-claude-codex-antigravity.md)
|
||||
|
||||
## Contesto
|
||||
Oggi non esistono test. L'app gira su due sistemi operativi, ha una CLI, una GUI e una dipendenza esterna (`claude`) che non si può chiamare nei test: costa, è lenta e non è deterministica. Con l'arrivo di altri motori (ADR-0002) la superficie da proteggere cresce. Serve una strategia che garantisca **copertura completa** e che renda i test parte del lavoro di ogni nuova funzione.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Nessun test dipende da `claude`, `codex`, `agy`, dalla rete o da un account.
|
||||
2. Gli stessi test girano su Windows e Linux, senza schermo (CI senza display).
|
||||
3. Copertura misurata e con soglia che fa fallire la build, non solo un numero da guardare.
|
||||
4. Ogni requisito scritto nei doc è tracciabile a uno o più test.
|
||||
5. Costo basso per aggiungere un test: il codice deve essere progettato per essere testabile.
|
||||
|
||||
## Decisione
|
||||
- **Regola**: una funzione, correzione o modifica di comportamento non è finita finché non ha test che la coprono, **nello stesso commit**. Una correzione di bug parte da un test che fallisce. La regola e il flusso sono in [TESTING.md](../TESTING.md).
|
||||
- **Piano dei test come documento**: [TESTING.md](../TESTING.md) è l'unica sorgente della matrice requisito → test e della politica di copertura. Gli altri doc la richiamano con un link.
|
||||
- **Strumenti**: xUnit come framework; `Avalonia.Headless` (con l'integrazione xUnit) per i test della GUI senza schermo; `coverlet` per la copertura. Le versioni compatibili con Avalonia 12 e .NET 10 vanno verificate (vedi sotto).
|
||||
- **Doppio di `claude`**: un piccolo eseguibile di test, `FakeClaude`, scritto in C# e compilato insieme ai test. Registra argomenti, cartella di lavoro e stdin, e risponde in base a variabili d'ambiente (testo, stderr, exit code, ritardo). Essendo un eseguibile nativo funziona uguale su Windows e Linux (uno script `.sh` o `.cmd` non sarebbe avviabile direttamente come `claude`).
|
||||
- **Livelli**: unitari (Core, ViewModel, renderer markdown), componenti GUI headless (finestra, template, tastiera), end-to-end sull'eseguibile pubblicato (CLI e codice 127) e smoke di publish per `win-x64` e `linux-x64`.
|
||||
- **Predisposizioni di testabilità** nel codice (da fare insieme ai primi test):
|
||||
- `ChatStore` diventa un'istanza con cartella iniettata, non uno statico legato a `LocalApplicationData`.
|
||||
- L'esecuzione dei motori sta dietro un'interfaccia (`IEngineRunner`) iniettata nel ViewModel; l'implementazione reale resta in `Core/EngineRunner.cs`. I test del ViewModel usano un finto runner; quelli di `EngineRunner` usano `FakeClaude` (che con la configurazione giusta imita anche Codex).
|
||||
- La conferma di eliminazione, gli appunti e il focus sono già delegati (`ConfirmDelete`, `CopyText`, `FocusInput`) e restano sostituibili.
|
||||
- Gli ADR-0002 (motori) richiedono che ogni motore abbia la propria batteria di test sugli argomenti e sul parser dell'output.
|
||||
- **Struttura del repo**: codice dell'app in `src/agent-wiki-ui/`, test in `tests/`, soluzione unica alla radice. Così il globbing del csproj dell'app non include i sorgenti dei test. Il progetto dell'app espone gli `internal` ai test con `InternalsVisibleTo`.
|
||||
- **Porte di qualità**: copertura minima per area (in TESTING.md); `dotnet test` con copertura deve passare su Windows e Linux. Il fornitore di CI non è ancora scelto: i comandi sono indipendenti dal fornitore e vivono nel repo.
|
||||
|
||||
## Opzioni considerate
|
||||
| Opzione | Esito | Motivo |
|
||||
|---|---|---|
|
||||
| Test manuali con checklist | Scartata | Non scala, non gira in CI, non protegge dalle regressioni. |
|
||||
| Test solo unitari sulla logica | Scartata | La GUI e la CLI reale (exit code, 127, cartella di lavoro, stdin) resterebbero scoperte. |
|
||||
| Test GUI con screenshot di riferimento | Rinviata | Font e rendering cambiano tra Windows e Linux: i confronti pixel sono instabili. Si usano asserzioni sull'albero visuale; gli screenshot restano come artefatti da guardare. |
|
||||
| `claude` finto come script | Scartata | Su Windows `claude` si avvia direttamente (senza `cmd /c`): serve un eseguibile. |
|
||||
| **xUnit + Headless + FakeClaude + coverlet** | **Scelta** | Copre tutti i livelli, senza dipendenze esterne, su entrambi i sistemi. |
|
||||
|
||||
## Conseguenze
|
||||
**Positive**: regressioni intercettate su entrambi i sistemi; requisiti tracciabili; i motori aggiuntivi si aggiungono con test di contratto uniformi.
|
||||
**Negative / costi**: un refactoring iniziale per iniettare cartella dati e runner; la struttura `src/` + `tests/` sposta file; la soglia di copertura obbliga a mantenere i test anche per codice di interfaccia; i test headless sono più lenti degli unitari.
|
||||
|
||||
## Da verificare
|
||||
- [ ] Versioni di xUnit, `Avalonia.Headless` (integrazione xUnit) e `coverlet` compatibili con Avalonia 12 e .NET 10, e `dotnet test` funzionante con la soluzione.
|
||||
- [ ] `Avalonia.Headless` con rendering Skia disponibile su Windows e Linux senza display (in questa macchina il rendering headless è già stato provato fuori dal repo).
|
||||
- [ ] Nessun test di GUI instabile per i tempi (usare attese su condizioni, non pause fisse).
|
||||
- [ ] Scelta del fornitore di CI e traduzione dei comandi in una pipeline con matrice Windows + Linux.
|
||||
|
||||
## Riferimenti
|
||||
- Piano, matrice e regole: [TESTING.md](../TESTING.md).
|
||||
- Passi: [ROADMAP.md](../ROADMAP.md), Fase 6.
|
||||
@@ -0,0 +1,73 @@
|
||||
# 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`).
|
||||
- Antigravity: `GET https://antigravity-cli-auto-updater-974169037036.us-central1.run.app`, testo con `Stable Version: X.Y.Z` (la sorgente dell'auto-updater ufficiale presente nel binario `agy`).
|
||||
- Le versioni si ricavano con il primo numero `N.N.N` del testo e si confrontano come versioni. Verificate il 2026-10-15 e 2026-10-18.
|
||||
- **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 gli indirizzi ufficiali 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 | Antigravity |
|
||||
|---|---|---|---|---|
|
||||
| `node_modules`, `.npm` | npm | `npm install -g @anthropic-ai/claude-code@latest` | `npm install -g @openai/codex@latest` | `agy update` |
|
||||
| `Cellar`, `homebrew`, `linuxbrew` | Homebrew | `brew upgrade claude-code` (o `claude-code@latest`) | `brew upgrade --cask codex` | `brew upgrade agy` |
|
||||
| `WinGet`, `WindowsApps` | WinGet | `winget upgrade Anthropic.ClaudeCode` | script PowerShell di [INSTALL.md](../INSTALL.md) | `agy update` |
|
||||
| altro | nativo/script | `claude update` da terminale | script di installazione di [INSTALL.md](../INSTALL.md) | `agy update` |
|
||||
|
||||
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.
|
||||
@@ -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.
|
||||
@@ -0,0 +1,47 @@
|
||||
# ADR-0006 — Immagini nel markdown: solo file locali
|
||||
|
||||
- **Stato**: Proposta
|
||||
- **Data**: 2026-10-15
|
||||
- **Collegato a**: [ADR-0001](0001-gui-multipiattaforma-avalonia.md) (GUI), [ADR-0003](0003-strategia-di-test.md) (test)
|
||||
|
||||
## Contesto
|
||||
Il renderer markdown ([Gui/MarkdownView.cs](../../src/agent-wiki-ui/Gui/MarkdownView.cs)) trasforma `` nel solo testo alternativo `[alt]`: non carica nulla. Un motore (Claude Code, Codex) può però produrre o citare un'immagine su disco (un grafico, uno screenshot) e rispondere con ``. Se il percorso è noto e il file esiste, l'utente si aspetta di vederla nella chat. Oggi l'app contatta la rete solo per il controllo delle versioni ([AGENT.md](../../AGENT.md), "Vincoli non ovvi"); aprire le immagini remote cambierebbe questo vincolo.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Mostrare l'immagine quando il percorso è locale e il file è leggibile.
|
||||
2. Nessun accesso alla rete oltre a quello già previsto.
|
||||
3. Nessun crash e nessun blocco della chat per file mancanti, enormi o corrotti: ripiego sul testo alternativo di oggi.
|
||||
4. Coerenza con il resto del renderer: colori dal tema, testo selezionabile, accessibilità.
|
||||
|
||||
## Opzioni considerate
|
||||
| Opzione | Esito | Motivo |
|
||||
|---|---|---|
|
||||
| Lasciare il testo `[alt]` | Scartata | Il percorso noto resta inutilizzato. |
|
||||
| **Solo percorsi locali** | **Scelta** | Soddisfa il caso d'uso, nessuna rete, sola lettura. |
|
||||
| Locali + URL `http(s)` | Rimandata | Una risposta del modello farebbe partire richieste di rete verso indirizzi scelti dal modello (tracciamento, indirizzo IP dell'utente esposto). Si può riprendere con un nuovo ADR e un consenso esplicito. |
|
||||
|
||||
## Decisione
|
||||
- `` mostra l'immagine se la destinazione è un **percorso locale**: assoluto, relativo oppure un URI `file://`.
|
||||
- **Percorsi relativi: radice del progetto.** Il motore gira nella cartella dell'exe, ma le istruzioni che segue (il `CLAUDE.md` di una wiki) stanno di solito in una cartella superiore e scrivono i percorsi relativi a *quella* radice (esempio: una wiki con l'exe in `<wiki>/query/`, accanto a un `CLAUDE.md` solo-query, e istruzioni del tipo «``, percorso relativo alla radice del repo»). Un percorso relativo si cerca quindi nella cartella dell'exe e poi in ciascuna cartella superiore, fino alla radice del filesystem; vince la prima in cui il file esiste (la più vicina all'exe).
|
||||
- **Nessuno standard imposto (prototipo).** L'app non conosce né una cartella delle immagini né un formato di catalogo: la cartella delle immagini e il catalogo sono la convenzione di ciascuna wiki, non un requisito. Cartella e catalogo possono cambiare; la wiki lo dice al motore nelle sue istruzioni, e l'app mostra qualunque file locale raggiungibile con il percorso scritto nella risposta.
|
||||
- **Cataloghi e metadati restano del motore.** Struttura tipo di una wiki con figure: un catalogo JSON con i metadati delle figure (file, didascalia stampata e generata, posizione, avvertenze) e una cartella delle immagini. Chi legge il catalogo e sceglie le figure è il motore, guidato dalle istruzioni della wiki; l'app non legge né interpreta il catalogo: mostra le immagini che la risposta cita in markdown, e la didascalia, la posizione e le avvertenze che il motore scrive sotto l'immagine sono testo markdown normale.
|
||||
- Formati: png, jpg/jpeg, gif (primo fotogramma), webp, bmp. Altre estensioni ⇒ ripiego.
|
||||
- Limiti: file fino a **20 MB**; se l'immagine è più larga di **1600 px** si decodifica a 1600 px di larghezza, per non occupare memoria inutile. In visualizzazione l'immagine non supera la larghezza della colonna dei messaggi (proporzioni mantenute) e non è mai ingrandita oltre l'originale.
|
||||
- Un paragrafo fatto solo di immagini le mostra come blocchi; un'immagine dentro una riga di testo (o dentro un link) è inline, con larghezza massima di 480 px.
|
||||
- **Ripiego** sul testo `[alt]` (come oggi) quando: la destinazione è `http(s)` o altro schema, il file manca o non è leggibile, il formato non è ammesso, il file supera il limite, la decodifica fallisce. Nessun errore a schermo, nessuna eccezione.
|
||||
- **Caricamento in background**: al rendering un controllo di controllo rapido e sincrono (percorso, estensione, esistenza, dimensione) decide se l'immagine è plausibile; se no, compare subito `[alt]`. Se sì, compare `[alt]` come segnaposto e la decodifica avviene su un altro thread; a fine decodifica il segnaposto diventa l'immagine, se la decodifica fallisce resta `[alt]`. Così la GUI non si blocca con file grandi o dischi lenti.
|
||||
- Accessibilità: l'immagine espone `alt` come nome per le tecnologie assistive e come suggerimento al passaggio del mouse.
|
||||
- Nessuna azione al clic (non si apre il file). Il pulsante **Copia** della risposta continua a copiare il markdown originale.
|
||||
|
||||
## Conseguenze
|
||||
**Positive**: le immagini prodotte dai motori si vedono nella chat; nessuna richiesta di rete in più; ripiego sicuro.
|
||||
**Negative**: una risposta può far leggere e mostrare un file immagine qualsiasi dell'utente (sola lettura, solo a schermo, nessun invio altrove); le immagini remote restano non supportate e si vedono come testo.
|
||||
|
||||
## Da verificare
|
||||
- Quali formati decodifica davvero Avalonia 12 con Skia su Windows e Linux (in particolare webp e gif) e se il limite di 20 MB è adeguato.
|
||||
- Il comportamento dei percorsi Windows (`C:\…`, UNC) e di quelli WSL (`/mnt/c/…`).
|
||||
- Se la ricerca nelle cartelle superiori debba fermarsi alla prima cartella con un marcatore di progetto (`CLAUDE.md`, `.git`) invece di salire fino alla radice del filesystem.
|
||||
- Se e quando emergerà uno standard per cataloghi e cartelle delle immagini (nomi, campi minimi come file, didascalia, posizione), valutare un nuovo ADR; per ora è fuori dall'app.
|
||||
|
||||
## Riferimenti
|
||||
- [MVP.md](../MVP.md) → "GUI (chat)"; matrice MD-14, MD-19…MD-30 in [TESTING.md](../TESTING.md).
|
||||
@@ -0,0 +1,62 @@
|
||||
# ADR-0007 — Schema di una wiki interrogabile, con immagini (prototipo)
|
||||
|
||||
- **Stato**: Proposta
|
||||
- **Data**: 2026-10-15
|
||||
- **Collegato a**: [ADR-0006](0006-immagini-nel-markdown.md) (l'app mostra le immagini citate nella risposta)
|
||||
|
||||
## Contesto
|
||||
agent-wiki-ui è il terminale di chat per interrogare una wiki mantenuta da un motore (Claude Code, Codex), per esempio una wiki di studio o di documentazione tecnica: pagine markdown, un indice, un catalogo JSON delle figure con i metadati e una cartella di immagini. Per rispondere in modo strutturato — meglio di un RAG, che recupera frammenti di testo e perde le relazioni — il motore deve sapere **dove cercare** (indice → pagina → tabella o figura) e **come citare** un'immagine perché la chat la stampi. Oggi questo sapere sta in un file scritto per una sola wiki. Non esiste uno standard: la cartella delle immagini e il formato del catalogo cambiano da wiki a wiki, ed è un prototipo.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Un solo posto per i percorsi delle immagini, senza duplicarli a mano.
|
||||
2. Le mappe sono derivate dal catalogo (si rigenerano), non scritte a mano.
|
||||
3. Nessuna cartella o nome di file imposti: la wiki dichiara la sua struttura.
|
||||
4. Degrado sicuro: un percorso sbagliato dà `[alt]` nella chat (ADR-0006), mai un errore.
|
||||
5. Nessun codice nell'app: la logica sta nelle istruzioni al motore e negli script della wiki.
|
||||
6. Pochi campi minimi, perché lo standard possa nascere dall'uso.
|
||||
|
||||
## Opzioni considerate
|
||||
| Opzione | Esito | Motivo |
|
||||
|---|---|---|
|
||||
| Solo RAG sul testo (embedding di `search_text`) | Scartata come unica via | Perde la struttura che rende affidabile la risposta: dato → pagina unica, avvertenze, difetti noti, figura → file. Resta come ripiego (ricerca testuale). |
|
||||
| L'app legge il catalogo e inserisce le immagini nelle risposte | Scartata | Lega l'app a un formato non standard e duplica la scelta delle figure, che il motore fa già leggendo la domanda. |
|
||||
| **Schema in tre parti, letto dal motore; l'app stampa** | **Scelta** | Conserva la struttura, non tocca l'app, si adatta a wiki diverse. |
|
||||
|
||||
## Decisione
|
||||
Una wiki interrogabile ha tre parti. Il formato è una convenzione consigliata, non un requisito dell'app.
|
||||
|
||||
1. **Indice** (`index.md`): catalogo delle pagine, una riga per pagina, `- [[pagina]] — sintesi`. Una pagina con figure aggiunge in coda gli id del catalogo: `· figure: fig-026, fig-027`. L'indice non elenca le figure una per una e non contiene percorsi di file.
|
||||
2. **Catalogo delle figure** (JSON, nome e posizione dichiarati nello schema della wiki). Campi minimi per figura:
|
||||
- `id` stabile, `label` (ad es. «Figura 26»);
|
||||
- `caption_printed` (testo della fonte, alla lettera) e, a parte, ogni testo generato dall'immagine, contrassegnato come non verificato;
|
||||
- `location` (sezione e riga nella fonte);
|
||||
- `panels[]` con `file` e `path` (relativo alla cartella del catalogo) e una descrizione;
|
||||
- `quality`: `flags` e `review_notes`.
|
||||
Indici facoltativi per sezione, composto, tipo e concetto. L'ordine di preferenza per trovare una figura è: indice dell'indice → pagina → `figures` nel frontmatter → indici del catalogo → ricerca testuale.
|
||||
3. **Istruzioni per le query**: un file `CLAUDE.md` (per Codex `AGENTS.md`) in una cartella dedicata sotto la radice della wiki, da cui si avvia l'app. Si aggiunge a quello della radice e prevale su di esso. Impone la **sola lettura**, instrada le domande per tipo verso l'indice giusto e fissa le regole per le immagini.
|
||||
|
||||
**Regole per le immagini nella risposta:**
|
||||
- Il percorso si ricava da catalogo e `path`, si **verifica che esista** e si scrive **relativo alla radice** della wiki, senza `..` (l'app lo cerca nella sua cartella e poi nelle superiori, ADR-0006).
|
||||
- Subito sotto: didascalia stampata alla lettera, posizione nella fonte, link alla nota della figura; una riga di avvertenza se `flags` o `review_notes`.
|
||||
- Ciò che deriva dall'immagine (descrizioni, valori letti da un grafico) si dichiara non verificato. Massimo 3-4 immagini per risposta.
|
||||
|
||||
**Percorsi derivati.** Se il catalogo ha percorsi relativi alla propria cartella, la wiki genera con uno script una mappa figura → percorso dalla radice → pagine che la citano (per esempio colonne in più di `figure-indice.md`). Lo script, e un controllo in fase di lint che ogni percorso della mappa esista, sono della wiki, non di questo repo.
|
||||
|
||||
**Chi fa cosa**
|
||||
| Parte | Compito |
|
||||
|---|---|
|
||||
| Wiki | Mantiene indice, catalogo e immagini; rigenera la mappa; controlla che i percorsi esistano |
|
||||
| Motore | Instrada la domanda, legge indici e pagine, sceglie le figure, scrive il markdown con l'immagine e la didascalia |
|
||||
| App | Stampa il markdown; mostra l'immagine se il file esiste, altrimenti `[alt]` |
|
||||
|
||||
## Conseguenze
|
||||
**Positive**: una risposta ripercorre indice → pagina → figura invece di cercare frammenti; i percorsi stanno in un solo posto e si rigenerano; l'app non cambia; wiki diverse adottano lo stesso modello cambiando pochi campi.
|
||||
**Negative**: il rispetto dello schema dipende dal motore che segue le istruzioni (può sbagliare percorso: l'app lo mostra come `[alt]`); la wiki deve mantenere lo script e il controllo dei percorsi; lo standard è provvisorio.
|
||||
|
||||
## Da verificare
|
||||
- Che Claude Code, avviato dalla cartella dedicata, legga e rispetti sia il file di quella cartella sia quello della radice (prova con la chat reale su una wiki di esempio).
|
||||
- L'equivalente per Codex (`AGENTS.md`) e come si comporta con le immagini nei suoi comandi.
|
||||
- Se il campo minimo `path` debba diventare un percorso dalla radice nel catalogo stesso, eliminando la mappa derivata.
|
||||
|
||||
## Riferimenti
|
||||
- Uso con le immagini: [README.md](../../README.md), sezione «Immagini nelle risposte».
|
||||
@@ -0,0 +1,45 @@
|
||||
# ADR-0008 — Formule LaTeX nel markdown
|
||||
|
||||
- **Stato**: Proposta
|
||||
- **Data**: 2026-10-20
|
||||
- **Collegato a**: [ADR-0006](0006-immagini-nel-markdown.md) (stesso renderer, stessi vincoli di sicurezza), [ADR-0007](0007-schema-wiki-per-query-con-immagini.md) (stesso tipo di risposte)
|
||||
|
||||
## Contesto
|
||||
Le risposte dei motori possono contenere formule in LaTeX: `$ ... $` nel testo e `$$ ... $$` a blocco. Il renderer markdown ([Gui/MarkdownView.cs](../../src/agent-wiki-ui/Gui/MarkdownView.cs)) usa Markdig con `UseAdvancedExtensions()`, che comprende l'estensione matematica: il parser riconosce le formule ma il renderer non le gestisce. Quelle a blocco finiscono in un blocco di codice con il sorgente LaTeX; quelle nel testo non vengono disegnate (nodo ignorato). L'utente vede sorgente illeggibile o formule mancanti.
|
||||
|
||||
## Criteri di decisione
|
||||
1. Mostrare le formule composte (frazioni, apici e pedici, lettere greche, sommatorie, sopralineature) come in un testo tipografico.
|
||||
2. Nessuna rete e nessuna esecuzione di codice: la formula è solo dato da disegnare (come per le immagini, ADR-0006).
|
||||
3. Degrado sicuro: un LaTeX non valido mostra il sorgente come testo, mai un errore né un blocco della chat.
|
||||
4. Coerenza con il resto del renderer: colori dal tema, ricostruzione al cambio di tema, testo circostante selezionabile, accessibilità.
|
||||
5. Funziona su Windows e Linux nel publish single-file, senza runtime aggiuntivi.
|
||||
6. Dipendenza manutenuta e compatibile con la versione di Avalonia in uso.
|
||||
|
||||
## Opzioni considerate
|
||||
| Opzione | Esito | Motivo |
|
||||
|---|---|---|
|
||||
| Lasciare com'è | Scartata | Il sorgente LaTeX o l'assenza delle formule rendono illeggibili le risposte con formule. |
|
||||
| Convertire il LaTeX in testo Unicode (`x_1` → `x`+pedice) con un mini-interprete proprio | Scartata | Copre solo i casi semplici; frazioni, `\overline`, `\left…\right` e matrici richiederebbero di riscrivere un motore di composizione. |
|
||||
| Rendere con un motore web (KaTeX/MathJax in una WebView) | Scartata | Aggiunge un browser incorporato e codice JavaScript, contro il criterio 2 e il peso dell'eseguibile. |
|
||||
| **Libreria di composizione TeX per Avalonia (`Sylinko.CSharpMath.Avalonia`, licenza MIT, basata su CSharpMath)** | **Scelta** | Disegna LaTeX come controllo Avalonia, senza rete né script; l'ultima versione (12.0.0) è per Avalonia 12, come l'app. |
|
||||
|
||||
## Decisione
|
||||
- La formula tra `$ … $` è un'**immagine inline** composta dal controllo della libreria, inserita nel testo (`InlineUIContainer`) con allineamento al testo; `$$ … $$` è un **blocco** a sé, allineato a sinistra, con scorrimento orizzontale se più larga della colonna.
|
||||
- Il colore è quello del testo del tema (`Fg`, o il colore ereditato se il token manca); al cambio di tema la vista si ricostruisce (già così per il resto).
|
||||
- **Ripiego**: se il LaTeX non è valido la formula compare come testo sorgente (`$…$` con carattere monospazio), senza eccezioni.
|
||||
- Il nome accessibile del controllo è il sorgente LaTeX; la formula non è selezionabile come testo (è un disegno): il pulsante **Copia** della risposta continua a copiare il markdown originale, quindi anche il sorgente delle formule.
|
||||
- I simboli `$` isolati, ad esempio un prezzo («10 $ e 20 $»), restano testo. Markdig da solo li prenderebbe per una formula (e toglie gli spazi dal contenuto): il renderer applica la regola di Pandoc sul testo originale, cioè niente spazio subito dopo il `$` di apertura né subito prima di quello di chiusura. Per questo gli intervalli di Markdig si leggono su un testo con fine riga uniformi (`\n`).
|
||||
- Nessuna rete e nessuna lettura di file: la formula è solo dato per il disegno.
|
||||
|
||||
## Conseguenze
|
||||
**Positive**: le risposte con formule mostrano le formule composte; nessun cambiamento ai motori né ai prompt.
|
||||
**Negative**: una dipendenza in più (e le sue librerie di disegno); il pacchetto è un fork per Avalonia 12 e va tenuto d'occhio quando Avalonia aggiorna; le formule non sono selezionabili come testo; il supporto non copre tutto LaTeX (le macro non supportate cadono nel ripiego).
|
||||
|
||||
## Da verificare
|
||||
- Dimensione dell'eseguibile pubblicato (single-file) dopo l'aggiunta della libreria e dei suoi font.
|
||||
- Allineamento verticale delle formule inline rispetto al testo con font diversi, su Windows e Linux.
|
||||
- Quali comandi LaTeX comuni (matrici, ambienti `align`, estensioni a pacchetto) sono supportati.
|
||||
- Il comportamento con formule molto lunghe in una riga di testo (a capo).
|
||||
|
||||
## Riferimenti
|
||||
- [MVP.md](../MVP.md) → "GUI (chat)"; matrice MD-31…MD-38 in [TESTING.md](../TESTING.md).
|
||||
@@ -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 src/agent-wiki-ui/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) }
|
||||
}
|
||||
Executable
+19
@@ -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 src/agent-wiki-ui/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
|
||||
@@ -0,0 +1,7 @@
|
||||
namespace AgentWikiUi.Core;
|
||||
|
||||
static class AppInfo
|
||||
{
|
||||
// Letto dall'AssemblyName del csproj: rinominare l'app = cambiare solo quello.
|
||||
public static readonly string Name = typeof(AppInfo).Assembly.GetName().Name!;
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using System.Text.Json;
|
||||
|
||||
namespace AgentWikiUi.Core;
|
||||
|
||||
record Msg(string Role, string Text); // Role: user | ai | err
|
||||
// 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`.
|
||||
static class ChatStore
|
||||
{
|
||||
// Nomi precedenti dell'app: le loro chat vengono spostate nella cartella attuale al primo avvio.
|
||||
static readonly string[] LegacyNames = ["LlmRun"];
|
||||
|
||||
static readonly string Dir = Prepare();
|
||||
|
||||
static string Prepare()
|
||||
{
|
||||
var data = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
||||
var dir = Path.Combine(data, AppInfo.Name, "chats");
|
||||
if (Directory.Exists(dir)) return dir;
|
||||
foreach (var name in LegacyNames)
|
||||
{
|
||||
var old = Path.Combine(data, name, "chats");
|
||||
if (!Directory.Exists(old)) continue;
|
||||
try { Directory.CreateDirectory(Path.GetDirectoryName(dir)!); Directory.Move(old, dir); }
|
||||
catch (IOException) { } // se non si riesce a spostare, si riparte da una cartella vuota
|
||||
break;
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
// 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;
|
||||
|
||||
public static void Save(string id, string engine, string? sessionId, bool started, List<Msg> messages)
|
||||
{
|
||||
if (messages.Count == 0) return;
|
||||
Directory.CreateDirectory(Dir);
|
||||
var first = messages.First(m => m.Role == "user").Text.ReplaceLineEndings(" ").Trim();
|
||||
var title = first.Length > 50 ? first[..50] + "…" : first;
|
||||
File.WriteAllText(PathFor(id)!, JsonSerializer.Serialize(new Stored(id, title, DateTime.Now, started, messages, engine, sessionId)));
|
||||
}
|
||||
|
||||
public static Stored? Load(string id)
|
||||
{
|
||||
var file = PathFor(id);
|
||||
return file is not null && File.Exists(file) ? Read(file) : null;
|
||||
}
|
||||
|
||||
// Dalla più recente; i file corrotti sono ignorati.
|
||||
public static List<Stored> List() => Directory.Exists(Dir)
|
||||
? Directory.EnumerateFiles(Dir, "*.json").Select(Read).OfType<Stored>().OrderByDescending(c => c.Updated).ToList()
|
||||
: [];
|
||||
|
||||
public static void Delete(string id)
|
||||
{
|
||||
var file = PathFor(id);
|
||||
if (file is not null && File.Exists(file)) File.Delete(file);
|
||||
}
|
||||
|
||||
static Stored? Read(string file)
|
||||
{
|
||||
try { return JsonSerializer.Deserialize<Stored>(File.ReadAllText(file)); }
|
||||
catch (Exception e) when (e is IOException or JsonException) { return null; }
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
using System.Text.Json;
|
||||
using System.Text.RegularExpressions;
|
||||
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; }
|
||||
}
|
||||
}
|
||||
|
||||
sealed class AgyEngine : Engine
|
||||
{
|
||||
public override string Id => "agy";
|
||||
public override string Name => "Antigravity";
|
||||
public override string Author => "Antigravity";
|
||||
public override string Executable => "agy";
|
||||
public override bool OwnsSessionId => true;
|
||||
|
||||
public override ModelOption[] Models { get; } =
|
||||
[
|
||||
new("Gemini 3.0 Flash (Low)", "gemini-3.0-flash-low"),
|
||||
new("Gemini 3.0 Flash (Medium)", "gemini-3.0-flash-medium"),
|
||||
new("Gemini 3.0 Flash (High)", "gemini-3.0-flash-high"),
|
||||
new("Claude Sonnet 4.6 (Thinking)", "claude-sonnet-4-6"),
|
||||
new("Claude Opus 4.6 (Thinking)", "claude-opus-4-6-thinking"),
|
||||
new("GPT-OSS 120B (Medium)", "gpt-oss-120b-medium"),
|
||||
];
|
||||
|
||||
public override string[] Efforts { get; } = ["low", "medium", "high", "xhigh", "max"];
|
||||
public override string DefaultModelId => "gemini-3.0-flash-low";
|
||||
|
||||
public override List<string> BuildArgs(string prompt, string? sessionId, bool resume, string model, string effort, bool structured)
|
||||
{
|
||||
var args = new List<string>();
|
||||
if (structured) args.AddRange(["--output-format", "json"]);
|
||||
if (resume && sessionId is not null) args.AddRange(["--conversation", sessionId]);
|
||||
if (model != "") args.AddRange(["--model", model]);
|
||||
if (effort != "") args.AddRange(["--effort", effort]);
|
||||
args.AddRange(["--print-timeout", "120s"]);
|
||||
args.AddRange(["-p", prompt]); // tutti i flag vanno passati PRIMA di -p
|
||||
return args;
|
||||
}
|
||||
|
||||
public override EngineReply Parse(int code, string stdout, string stderr)
|
||||
{
|
||||
string? conversationId = null;
|
||||
string? response = null;
|
||||
string? error = null;
|
||||
|
||||
var trimmed = stdout.Trim();
|
||||
if (!string.IsNullOrEmpty(trimmed))
|
||||
{
|
||||
var start = trimmed.IndexOf('{');
|
||||
var end = trimmed.LastIndexOf('}');
|
||||
if (start >= 0 && end > start)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var doc = JsonDocument.Parse(trimmed.Substring(start, end - start + 1));
|
||||
var root = doc.RootElement;
|
||||
if (root.TryGetProperty("conversation_id", out var convProp))
|
||||
conversationId = convProp.GetString();
|
||||
if (root.TryGetProperty("response", out var respProp))
|
||||
response = respProp.GetString();
|
||||
if (root.TryGetProperty("status", out var statusProp) && statusProp.GetString() != "SUCCESS")
|
||||
error = $"Stato {statusProp.GetString()}";
|
||||
if (root.TryGetProperty("error", out var errProp))
|
||||
error = errProp.GetString() ?? error;
|
||||
}
|
||||
catch (JsonException) { }
|
||||
}
|
||||
}
|
||||
|
||||
if (code != 0) return new("", conversationId, Failed(code, error ?? stderr.Trim()));
|
||||
if (error is not null && string.IsNullOrWhiteSpace(response)) return new("", conversationId, error);
|
||||
if (string.IsNullOrWhiteSpace(response)) return new("", conversationId, error ?? (string.IsNullOrWhiteSpace(stderr) ? "agy non ha restituito nessuna risposta." : stderr.Trim()));
|
||||
return new(response.Trim(), conversationId, null);
|
||||
}
|
||||
|
||||
public override async Task<string?> FetchLatestVersionAsync(HttpClient http, CancellationToken ct)
|
||||
{
|
||||
var text = await http.GetStringAsync("https://antigravity-cli-auto-updater-974169037036.us-central1.run.app", ct);
|
||||
var m = Regex.Match(text, @"Stable Version:\s*v?(\d+\.\d+(?:\.\d+)?)");
|
||||
return m.Success ? m.Groups[1].Value : text.Trim();
|
||||
}
|
||||
}
|
||||
|
||||
static class Engines
|
||||
{
|
||||
public static readonly Engine Claude = new ClaudeEngine();
|
||||
public static readonly Engine Codex = new CodexEngine();
|
||||
public static readonly Engine Agy = new AgyEngine();
|
||||
public static readonly Engine[] All = [Claude, Codex, Agy];
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
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",
|
||||
("agy", InstallMethod.Homebrew) => "brew upgrade agy",
|
||||
("agy", _) => "agy update",
|
||||
_ => $"{engine.Executable} update",
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
<Application xmlns="https://github.com/avaloniaui"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
x:Class="AgentWikiUi.Gui.App"
|
||||
RequestedThemeVariant="Default">
|
||||
<!-- Token di design: vedi docs/MVP.md → "Design (UI/UX)". Il tema segue il sistema. -->
|
||||
<Application.Resources>
|
||||
<ResourceDictionary>
|
||||
<ResourceDictionary.ThemeDictionaries>
|
||||
<ResourceDictionary x:Key="Light">
|
||||
<SolidColorBrush x:Key="Bg">#FFFFFF</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Surface">#FFFFFF</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Fg">#0F172A</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Muted">#F1F5F9</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="FgMuted">#475569</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Border">#CBD5E1</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Accent">#15803D</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="OnAccent">#FFFFFF</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="AccentSoft">#DCFCE7</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Err">#B91C1C</SolidColorBrush>
|
||||
</ResourceDictionary>
|
||||
<ResourceDictionary x:Key="Dark">
|
||||
<SolidColorBrush x:Key="Bg">#0F172A</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Surface">#1E293B</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Fg">#F8FAFC</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Muted">#1E293B</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="FgMuted">#94A3B8</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Border">#334155</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Accent">#22C55E</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="OnAccent">#0F172A</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="AccentSoft">#14301F</SolidColorBrush>
|
||||
<SolidColorBrush x:Key="Err">#F87171</SolidColorBrush>
|
||||
</ResourceDictionary>
|
||||
</ResourceDictionary.ThemeDictionaries>
|
||||
</ResourceDictionary>
|
||||
</Application.Resources>
|
||||
|
||||
<Application.Styles>
|
||||
<FluentTheme />
|
||||
|
||||
<Style Selector="Window">
|
||||
<Setter Property="Background" Value="{DynamicResource Bg}" />
|
||||
<Setter Property="Foreground" Value="{DynamicResource Fg}" />
|
||||
<Setter Property="FontFamily" Value="Segoe UI Variable Text, Segoe UI, Inter, Ubuntu, Cantarell, Noto Sans, DejaVu Sans, sans-serif" />
|
||||
<Setter Property="FontSize" Value="15.5" />
|
||||
</Style>
|
||||
|
||||
<Style Selector="Button.ghost">
|
||||
<Setter Property="Background" Value="Transparent" />
|
||||
<Setter Property="BorderBrush" Value="{DynamicResource Border}" />
|
||||
<Setter Property="BorderThickness" Value="1" />
|
||||
<Setter Property="CornerRadius" Value="10" />
|
||||
<Setter Property="MinHeight" Value="36" />
|
||||
<Setter Property="Padding" Value="14,0" />
|
||||
<Setter Property="VerticalContentAlignment" Value="Center" />
|
||||
</Style>
|
||||
<Style Selector="Button.ghost:pointerover /template/ ContentPresenter">
|
||||
<Setter Property="Background" Value="{DynamicResource Bg}" />
|
||||
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
|
||||
</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">
|
||||
<Setter Property="FontSize" Value="12" />
|
||||
<Setter Property="Padding" Value="8,2" />
|
||||
<Setter Property="MinHeight" Value="24" />
|
||||
<Setter Property="CornerRadius" Value="6" />
|
||||
<Setter Property="Background" Value="{DynamicResource Surface}" />
|
||||
<Setter Property="BorderBrush" Value="{DynamicResource Border}" />
|
||||
<Setter Property="BorderThickness" Value="1" />
|
||||
</Style>
|
||||
<Style Selector="Button.send">
|
||||
<Setter Property="Width" Value="36" />
|
||||
<Setter Property="Height" Value="36" />
|
||||
<Setter Property="CornerRadius" Value="18" />
|
||||
<Setter Property="Padding" Value="0" />
|
||||
<Setter Property="Background" Value="{DynamicResource Accent}" />
|
||||
<Setter Property="Foreground" Value="{DynamicResource OnAccent}" />
|
||||
<Setter Property="HorizontalContentAlignment" Value="Center" />
|
||||
<Setter Property="VerticalContentAlignment" Value="Center" />
|
||||
</Style>
|
||||
<Style Selector="Button.send:disabled /template/ ContentPresenter">
|
||||
<Setter Property="Background" Value="{DynamicResource Border}" />
|
||||
<Setter Property="Foreground" Value="{DynamicResource FgMuted}" />
|
||||
</Style>
|
||||
<Style Selector="Button.send:pointerover:not(:disabled) /template/ ContentPresenter">
|
||||
<Setter Property="Background" Value="{DynamicResource Accent}" />
|
||||
<Setter Property="Opacity" Value="0.88" />
|
||||
</Style>
|
||||
|
||||
<Style Selector="TextBox.bare /template/ Border#PART_BorderElement">
|
||||
<Setter Property="BorderThickness" Value="0" />
|
||||
<Setter Property="Background" Value="Transparent" />
|
||||
</Style>
|
||||
<Style Selector="Border.composer:focus-within">
|
||||
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
|
||||
</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">
|
||||
<Setter Property="CornerRadius" Value="10" />
|
||||
<Setter Property="Margin" Value="8,1" />
|
||||
<Setter Property="BorderThickness" Value="3,0,0,0" />
|
||||
<Setter Property="BorderBrush" Value="Transparent" />
|
||||
</Style>
|
||||
<Style Selector="Border.item.active">
|
||||
<Setter Property="Background" Value="{DynamicResource Bg}" />
|
||||
<Setter Property="BorderBrush" Value="{DynamicResource Accent}" />
|
||||
</Style>
|
||||
<Style Selector="Border.item:pointerover">
|
||||
<Setter Property="Background" Value="{DynamicResource Bg}" />
|
||||
</Style>
|
||||
</Application.Styles>
|
||||
</Application>
|
||||
@@ -0,0 +1,17 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Controls.ApplicationLifetimes;
|
||||
using Avalonia.Markup.Xaml;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
class App : Application
|
||||
{
|
||||
public override void Initialize() => AvaloniaXamlLoader.Load(this);
|
||||
|
||||
public override void OnFrameworkInitializationCompleted()
|
||||
{
|
||||
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
|
||||
desktop.MainWindow = new MainWindow();
|
||||
base.OnFrameworkInitializationCompleted();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Layout;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
static class ConfirmDialog
|
||||
{
|
||||
public static Task<bool> Ask(Window owner, string question)
|
||||
{
|
||||
var yes = new Button { Content = "Elimina", MinWidth = 90 };
|
||||
var no = new Button { Content = "Annulla", MinWidth = 90 };
|
||||
var dlg = new Window
|
||||
{
|
||||
Title = question, Width = 340, SizeToContent = SizeToContent.Height, CanResize = false,
|
||||
WindowStartupLocation = WindowStartupLocation.CenterOwner,
|
||||
Content = new StackPanel
|
||||
{
|
||||
Margin = new(20), Spacing = 18,
|
||||
Children =
|
||||
{
|
||||
new TextBlock { Text = question, TextWrapping = Avalonia.Media.TextWrapping.Wrap },
|
||||
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, HorizontalAlignment = HorizontalAlignment.Right, Children = { no, yes } },
|
||||
},
|
||||
},
|
||||
};
|
||||
yes.Click += (_, _) => dlg.Close(true);
|
||||
no.Click += (_, _) => dlg.Close(false);
|
||||
return dlg.ShowDialog<bool>(owner);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,323 @@
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Windows.Input;
|
||||
using AgentWikiUi.Core;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
class MessageVm(string role, string text, string author)
|
||||
{
|
||||
public string Role { get; } = role;
|
||||
public string Text { get; } = text;
|
||||
public string Author { get; } = author;
|
||||
public bool IsUser => Role == "user";
|
||||
public bool IsAi => Role == "ai";
|
||||
public bool IsErr => Role == "err";
|
||||
}
|
||||
|
||||
class ChatItem(string id, string title, DateTime updated, bool active, string engineName)
|
||||
{
|
||||
public string Id { get; } = id;
|
||||
public string Title { get; } = title;
|
||||
public string When { get; } = $"{engineName} · {updated:d MMM HH:mm}";
|
||||
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
|
||||
{
|
||||
static readonly ModelOption Default = new("Predefinito", "");
|
||||
static readonly ModelOption Custom = new("Altro ID…", "__custom");
|
||||
const string NoEffort = "Predefinito";
|
||||
|
||||
public ObservableCollection<MessageVm> Messages { get; } = [];
|
||||
public ObservableCollection<ChatItem> Chats { get; } = [];
|
||||
public EngineChoice[] EngineChoices { get; } = Engines.All.Select(e => new EngineChoice(e)).ToArray();
|
||||
/// <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 CopyCommand { get; }
|
||||
public ICommand SendCommand { get; }
|
||||
public ICommand OpenCommand { get; }
|
||||
public ICommand DeleteCommand { get; }
|
||||
public ICommand ToggleSidebarCommand { get; }
|
||||
public ICommand UpdateCommand { get; }
|
||||
|
||||
/// <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>
|
||||
public Func<string, Task> CopyText { get; set; } = _ => Task.CompletedTask;
|
||||
/// <summary>Chiesto alla finestra di rimettere il fuoco sul campo messaggio.</summary>
|
||||
public event Action? FocusInput;
|
||||
|
||||
// Una chat = un motore. chatId è il nome del file; sessionId è l'id del motore:
|
||||
// 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 = [];
|
||||
|
||||
EngineChoice selectedEngine;
|
||||
ModelOption[] modelChoices = [];
|
||||
string[] effortChoices = [];
|
||||
string input = "";
|
||||
bool busy, updating, sidebarOpen = true;
|
||||
ModelOption selectedModel = Default;
|
||||
string customModel = "";
|
||||
string selectedEffort = NoEffort;
|
||||
readonly RelayCommand<object> send, newChat;
|
||||
|
||||
public MainViewModel()
|
||||
{
|
||||
selectedEngine = EngineChoices.FirstOrDefault(c => c.Installed) ?? EngineChoices[0];
|
||||
ApplyEngine(selectedEngine);
|
||||
send = new(_ => _ = SendAsync(), () => CanSend);
|
||||
SendCommand = send;
|
||||
newChat = new(_ => NewChat(), () => !busy && !updating);
|
||||
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); });
|
||||
DeleteCommand = new RelayCommand<ChatItem>(c => { if (c is not null) _ = DeleteAsync(c); });
|
||||
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)); };
|
||||
ResetSession();
|
||||
|
||||
_ = CheckUpdatesAsync();
|
||||
|
||||
// all'avvio riapre la chat più recente
|
||||
if (ChatStore.List().FirstOrDefault() is { } last) OpenChat(last.Id); else RefreshChats();
|
||||
}
|
||||
|
||||
Engine Engine => selectedEngine.Engine;
|
||||
|
||||
public bool HasMessages => Messages.Count > 0;
|
||||
public bool ShowEmpty => Messages.Count == 0;
|
||||
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
|
||||
{
|
||||
get => input;
|
||||
set { if (Set(ref input, value)) { Raise(nameof(CanSend)); send.Refresh(); } }
|
||||
}
|
||||
|
||||
public bool IsBusy
|
||||
{
|
||||
get => busy;
|
||||
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); }
|
||||
|
||||
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
|
||||
{
|
||||
get => selectedModel;
|
||||
set { if (Set(ref selectedModel, value)) Raise(nameof(IsCustomModel)); }
|
||||
}
|
||||
public bool IsCustomModel => selectedModel == Custom;
|
||||
public string CustomModel { get => customModel; set => Set(ref customModel, 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()
|
||||
{
|
||||
Chats.Clear();
|
||||
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, string author)
|
||||
{
|
||||
Messages.Clear();
|
||||
foreach (var m in msgs) Messages.Add(new(m.Role, m.Text, author));
|
||||
}
|
||||
|
||||
void NewChat()
|
||||
{
|
||||
ResetSession();
|
||||
Show(history, Author); RefreshChats(); FocusInput?.Invoke();
|
||||
}
|
||||
|
||||
void OpenChat(string id)
|
||||
{
|
||||
if (busy) return;
|
||||
if (ChatStore.Load(id) is not { } chat) { RefreshChats(); return; }
|
||||
var choice = EngineChoices.FirstOrDefault(c => c.Engine.Id == chat.EngineId);
|
||||
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)
|
||||
{
|
||||
if (busy || !await ConfirmDelete()) return;
|
||||
ChatStore.Delete(c.Id);
|
||||
if (c.Id == chatId) NewChat(); else RefreshChats();
|
||||
}
|
||||
|
||||
async Task SendAsync()
|
||||
{
|
||||
if (!CanSend) return;
|
||||
var text = input.Trim();
|
||||
var model = IsCustomModel ? customModel.Trim() : selectedModel.Id;
|
||||
var effort = selectedEffort == NoEffort ? "" : selectedEffort;
|
||||
|
||||
Input = ""; IsBusy = true;
|
||||
Add("user", text);
|
||||
Persist(); // il messaggio non va perso se l'app si chiude durante l'attesa
|
||||
RefreshChats();
|
||||
try
|
||||
{
|
||||
var r = await EngineRunner.RunCapturedAsync(Engine, text, sessionId, started, model, effort);
|
||||
if (r.Error is null)
|
||||
{
|
||||
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", $"'{Engine.Executable}' non trovato nel PATH."); }
|
||||
catch (Exception ex) { Add("err", ex.Message); }
|
||||
finally
|
||||
{
|
||||
IsBusy = false;
|
||||
Persist();
|
||||
RefreshChats();
|
||||
FocusInput?.Invoke();
|
||||
}
|
||||
}
|
||||
|
||||
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()
|
||||
{
|
||||
try { ChatStore.Save(chatId, Engine.Id, sessionId, started, history); }
|
||||
catch (IOException) { } // la chat resta a schermo anche se il salvataggio fallisce
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,205 @@
|
||||
<Window xmlns="https://github.com/avaloniaui"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:gui="using:AgentWikiUi.Gui"
|
||||
xmlns:core="using:AgentWikiUi.Core"
|
||||
x:Class="AgentWikiUi.Gui.MainWindow"
|
||||
x:DataType="gui:MainViewModel"
|
||||
Title="{x:Static core:AppInfo.Name}"
|
||||
MinWidth="900" MinHeight="600">
|
||||
|
||||
<Grid ColumnDefinitions="Auto,*">
|
||||
|
||||
<!-- Barra laterale -->
|
||||
<Border Grid.Column="0" Width="272" IsVisible="{Binding SidebarOpen}"
|
||||
Background="{DynamicResource Muted}" BorderBrush="{DynamicResource Border}" BorderThickness="0,0,1,0">
|
||||
<DockPanel>
|
||||
<StackPanel DockPanel.Dock="Top" Margin="14,16,14,10" Spacing="14">
|
||||
<StackPanel Orientation="Horizontal" Spacing="10" Margin="4,0">
|
||||
<Border Width="28" Height="28" CornerRadius="8" Background="{DynamicResource Accent}">
|
||||
<Viewbox Width="16" Height="16">
|
||||
<Path Data="M12 2L14.4 8.6L21 11L14.4 13.4L12 20L9.6 13.4L3 11L9.6 8.6Z" Fill="{DynamicResource OnAccent}" />
|
||||
</Viewbox>
|
||||
</Border>
|
||||
<TextBlock Text="{x:Static core:AppInfo.Name}" FontWeight="SemiBold" VerticalAlignment="Center" />
|
||||
</StackPanel>
|
||||
<Button Classes="ghost" Command="{Binding NewChatCommand}" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
|
||||
Background="{DynamicResource Bg}" AutomationProperties.Name="Nuova chat">
|
||||
<StackPanel Orientation="Horizontal" Spacing="8">
|
||||
<Viewbox Width="16" Height="16"><Path Data="M12 5V19M5 12H19" Stroke="{DynamicResource Fg}" StrokeThickness="2" StrokeLineCap="Round" /></Viewbox>
|
||||
<TextBlock Text="Nuova chat" />
|
||||
</StackPanel>
|
||||
</Button>
|
||||
</StackPanel>
|
||||
<TextBlock DockPanel.Dock="Top" Text="CHAT" FontSize="11.5" FontWeight="SemiBold" Foreground="{DynamicResource FgMuted}" Margin="22,8,14,4" />
|
||||
<TextBlock DockPanel.Dock="Top" Text="Nessuna chat salvata" Foreground="{DynamicResource FgMuted}" FontSize="13.5" Margin="22,6"
|
||||
IsVisible="{Binding !Chats.Count}" />
|
||||
<ScrollViewer>
|
||||
<ItemsControl ItemsSource="{Binding Chats}">
|
||||
<ItemsControl.ItemTemplate>
|
||||
<DataTemplate x:DataType="gui:ChatItem">
|
||||
<Border Classes="item" Classes.active="{Binding IsActive}">
|
||||
<Grid ColumnDefinitions="*,Auto">
|
||||
<Button Grid.ColumnSpan="2" Background="Transparent" BorderThickness="0" HorizontalAlignment="Stretch"
|
||||
HorizontalContentAlignment="Left" Padding="12,8,40,8"
|
||||
Command="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).OpenCommand}" CommandParameter="{Binding}"
|
||||
AutomationProperties.Name="{Binding Title, StringFormat='Apri chat: {0}'}">
|
||||
<StackPanel>
|
||||
<TextBlock Text="{Binding Title}" TextTrimming="CharacterEllipsis" FontSize="14" />
|
||||
<TextBlock Text="{Binding When}" FontSize="12" Foreground="{DynamicResource FgMuted}" />
|
||||
</StackPanel>
|
||||
</Button>
|
||||
<Button Grid.Column="1" Background="Transparent" BorderThickness="0" Width="32" Height="32" Margin="0,0,4,0"
|
||||
VerticalAlignment="Center" Padding="0" HorizontalContentAlignment="Center"
|
||||
Command="{Binding $parent[ItemsControl].((gui:MainViewModel)DataContext).DeleteCommand}" CommandParameter="{Binding}"
|
||||
AutomationProperties.Name="Elimina chat">
|
||||
<Viewbox Width="12" Height="12"><Path Data="M6 6L18 18M18 6L6 18" Stroke="{DynamicResource FgMuted}" StrokeThickness="2.4" StrokeLineCap="Round" /></Viewbox>
|
||||
</Button>
|
||||
</Grid>
|
||||
</Border>
|
||||
</DataTemplate>
|
||||
</ItemsControl.ItemTemplate>
|
||||
</ItemsControl>
|
||||
</ScrollViewer>
|
||||
</DockPanel>
|
||||
</Border>
|
||||
|
||||
<!-- Area principale -->
|
||||
<Grid Grid.Column="1" RowDefinitions="*,Auto">
|
||||
|
||||
<ScrollViewer Grid.Row="0" x:Name="Scroll">
|
||||
<StackPanel MaxWidth="780" Margin="24,56,24,16" Spacing="20">
|
||||
|
||||
<!-- Schermata iniziale -->
|
||||
<StackPanel IsVisible="{Binding ShowEmpty}" Spacing="10" Margin="0,40,0,0" HorizontalAlignment="Center">
|
||||
<Border Width="44" Height="44" CornerRadius="12" Background="{DynamicResource Accent}" HorizontalAlignment="Center">
|
||||
<Viewbox Width="24" Height="24">
|
||||
<Path Data="M12 2L14.4 8.6L21 11L14.4 13.4L12 20L9.6 13.4L3 11L9.6 8.6Z" Fill="{DynamicResource OnAccent}" />
|
||||
</Viewbox>
|
||||
</Border>
|
||||
<TextBlock Text="Come posso aiutarti?" FontSize="28" FontWeight="SemiBold" HorizontalAlignment="Center" />
|
||||
<TextBlock Text="Scrivi un messaggio per iniziare." Foreground="{DynamicResource FgMuted}" HorizontalAlignment="Center" />
|
||||
</StackPanel>
|
||||
|
||||
<!-- Conversazione -->
|
||||
<ItemsControl ItemsSource="{Binding Messages}" AutomationProperties.Name="Conversazione">
|
||||
<ItemsControl.ItemsPanel>
|
||||
<ItemsPanelTemplate><StackPanel Spacing="22" /></ItemsPanelTemplate>
|
||||
</ItemsControl.ItemsPanel>
|
||||
<ItemsControl.ItemTemplate>
|
||||
<DataTemplate x:DataType="gui:MessageVm">
|
||||
<Panel>
|
||||
<Border IsVisible="{Binding IsUser}" HorizontalAlignment="Right" MaxWidth="620" CornerRadius="18,18,4,18"
|
||||
Background="{DynamicResource AccentSoft}" Padding="16,10">
|
||||
<SelectableTextBlock Text="{Binding Text}" TextWrapping="Wrap" />
|
||||
</Border>
|
||||
<StackPanel IsVisible="{Binding IsAi}" Spacing="6">
|
||||
<TextBlock Text="{Binding Author}" FontWeight="SemiBold" FontSize="13.5" Foreground="{DynamicResource Accent}" />
|
||||
<gui:MarkdownView Source="{Binding Text}" />
|
||||
<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}"
|
||||
AutomationProperties.Name="Copia la risposta" />
|
||||
</StackPanel>
|
||||
<SelectableTextBlock IsVisible="{Binding IsErr}" Text="{Binding Text}" TextWrapping="Wrap" Foreground="{DynamicResource Err}" />
|
||||
</Panel>
|
||||
</DataTemplate>
|
||||
</ItemsControl.ItemTemplate>
|
||||
</ItemsControl>
|
||||
|
||||
<!-- Attesa -->
|
||||
<StackPanel IsVisible="{Binding IsBusy}" Orientation="Horizontal" Spacing="12">
|
||||
<ProgressBar IsIndeterminate="True" Width="80" Height="4" Foreground="{DynamicResource Accent}" VerticalAlignment="Center" />
|
||||
<TextBlock Text="{Binding BusyText}" Foreground="{DynamicResource FgMuted}" />
|
||||
</StackPanel>
|
||||
</StackPanel>
|
||||
</ScrollViewer>
|
||||
|
||||
<Button Grid.Row="0" Classes="ghost" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="12" Padding="0" Width="36"
|
||||
HorizontalContentAlignment="Center" Command="{Binding ToggleSidebarCommand}" AutomationProperties.Name="Mostra o nascondi le chat">
|
||||
<Viewbox Width="16" Height="16"><Path Data="M4 6H20M4 12H20M4 18H20" Stroke="{DynamicResource Fg}" StrokeThickness="2" StrokeLineCap="Round" /></Viewbox>
|
||||
</Button>
|
||||
|
||||
<!-- Impostazioni: modello ed effort -->
|
||||
<Button Grid.Row="0" Classes="ghost" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="12" Padding="0" Width="36"
|
||||
HorizontalContentAlignment="Center" AutomationProperties.Name="Impostazioni" ToolTip.Tip="Impostazioni">
|
||||
<Button.Flyout>
|
||||
<Flyout Placement="BottomEdgeAlignedRight" Opening="OnSettingsOpening">
|
||||
<StackPanel Width="340" Spacing="6" Margin="4">
|
||||
<TextBlock Text="Impostazioni" FontWeight="SemiBold" Margin="0,0,0,6" />
|
||||
<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"
|
||||
AutomationProperties.Name="Modello">
|
||||
<ComboBox.ItemTemplate>
|
||||
<DataTemplate x:DataType="core:ModelOption"><TextBlock Text="{Binding Label}" /></DataTemplate>
|
||||
</ComboBox.ItemTemplate>
|
||||
</ComboBox>
|
||||
<TextBox Text="{Binding CustomModel}" IsVisible="{Binding IsCustomModel}" PlaceholderText="es. claude-opus-5-5"
|
||||
AutomationProperties.Name="ID modello personalizzato" />
|
||||
<TextBlock Text="Effort" FontSize="13" Foreground="{DynamicResource FgMuted}" Margin="0,8,0,0" />
|
||||
<ComboBox ItemsSource="{Binding EffortChoices}" SelectedItem="{Binding SelectedEffort}" HorizontalAlignment="Stretch"
|
||||
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>
|
||||
</Flyout>
|
||||
</Button.Flyout>
|
||||
<Panel>
|
||||
<Viewbox Width="16" Height="16">
|
||||
<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"
|
||||
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>
|
||||
|
||||
<!-- Composer -->
|
||||
<StackPanel Grid.Row="1" MaxWidth="780" Margin="24,0,24,12">
|
||||
<Border Classes="composer" Background="{DynamicResource Surface}" BorderBrush="{DynamicResource Border}" BorderThickness="1" CornerRadius="20" Padding="14,10">
|
||||
<Grid ColumnDefinitions="*,Auto">
|
||||
<TextBox x:Name="InputBox" Classes="bare" Text="{Binding Input, Mode=TwoWay}" AcceptsReturn="True" TextWrapping="Wrap" MaxHeight="200"
|
||||
PlaceholderText="{Binding InputPlaceholder}" BorderThickness="0" Background="Transparent"
|
||||
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">
|
||||
<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>
|
||||
</Button>
|
||||
</Grid>
|
||||
</Border>
|
||||
<TextBlock Text="Invio per inviare · Maiusc+Invio per andare a capo" FontSize="12" Foreground="{DynamicResource FgMuted}"
|
||||
HorizontalAlignment="Center" Margin="0,8,0,0" />
|
||||
</StackPanel>
|
||||
</Grid>
|
||||
</Grid>
|
||||
</Window>
|
||||
@@ -0,0 +1,51 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Input;
|
||||
using Avalonia.Input.Platform;
|
||||
using Avalonia.Interactivity;
|
||||
using Avalonia.Threading;
|
||||
using AgentWikiUi.Core;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
partial class MainWindow : Window
|
||||
{
|
||||
public MainWindow()
|
||||
{
|
||||
InitializeComponent();
|
||||
var vm = new MainViewModel();
|
||||
DataContext = vm;
|
||||
|
||||
// proporzioni 16:10 orizzontali: 75% della larghezza utile (max 1440), altezza max 90%
|
||||
var screen = Screens.Primary;
|
||||
if (screen is not null)
|
||||
{
|
||||
var area = screen.WorkingArea;
|
||||
double w = Math.Min(1440, area.Width / screen.Scaling * 3 / 4);
|
||||
var h = Math.Min(w * 10 / 16, area.Height / screen.Scaling * 9 / 10);
|
||||
Width = h * 16 / 10; Height = h;
|
||||
}
|
||||
else { Width = 1280; Height = 800; }
|
||||
WindowStartupLocation = WindowStartupLocation.CenterScreen;
|
||||
|
||||
vm.CopyText = async text => { if (Clipboard is { } cb) await cb.SetTextAsync(text); };
|
||||
vm.ConfirmDelete = () => ConfirmDialog.Ask(this, "Eliminare questa chat?");
|
||||
vm.FocusInput += () => Dispatcher.UIThread.Post(() => InputBox.Focus());
|
||||
vm.Messages.CollectionChanged += (_, _) => Dispatcher.UIThread.Post(() => Scroll.ScrollToEnd(), DispatcherPriority.Background);
|
||||
|
||||
// Invio invia, Maiusc+Invio va a capo (tunnel: prima che il TextBox inserisca l'a capo)
|
||||
InputBox.AddHandler(KeyDownEvent, (_, e) =>
|
||||
{
|
||||
if (e.Key == Key.Enter && !e.KeyModifiers.HasFlag(KeyModifiers.Shift))
|
||||
{
|
||||
e.Handled = true;
|
||||
if (vm.SendCommand.CanExecute(null)) vm.SendCommand.Execute(null);
|
||||
}
|
||||
}, RoutingStrategies.Tunnel);
|
||||
|
||||
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();
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
using Avalonia.Automation;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Documents;
|
||||
using Avalonia.Layout;
|
||||
using Avalonia.Media;
|
||||
using Avalonia.Media.Imaging;
|
||||
using Markdig.Syntax;
|
||||
using Markdig.Syntax.Inlines;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
/// <summary>Immagini nel markdown (ADR-0006): solo file locali, caricamento in background, ripiego sul testo alternativo.</summary>
|
||||
partial class MarkdownView
|
||||
{
|
||||
// Immagini (ADR-0006): solo file locali, entro questi limiti
|
||||
const long MaxImageBytes = 20L * 1024 * 1024;
|
||||
const int MaxDecodeWidth = 1600;
|
||||
const double MaxInlineImageWidth = 480;
|
||||
static readonly string[] ImageExtensions = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"];
|
||||
|
||||
/// <summary>Immagini ancora in decodifica (ADR-0006); i test attendono che scenda a zero.</summary>
|
||||
internal int PendingImages { get; private set; }
|
||||
|
||||
/// <summary>Cartella da cui si cercano i percorsi relativi delle immagini: l'exe, poi le cartelle superiori (ADR-0006). Modificabile dai test.</summary>
|
||||
internal string BaseDirectory { get; set; } = AppContext.BaseDirectory;
|
||||
|
||||
static string AltText(LinkInline img) => string.Concat(img.OfType<LiteralInline>().Select(l => l.Content.ToString()));
|
||||
|
||||
/// <summary>Percorso locale a cui punta la destinazione di un'immagine; nullo per URL remoti o altri schemi.
|
||||
/// Un percorso relativo si cerca in <paramref name="baseDir"/> e poi nelle cartelle superiori (radice del progetto del motore): vince la prima in cui il file esiste.</summary>
|
||||
internal static string? ResolveImagePath(string? url, string baseDir)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(url)) return null;
|
||||
if (Uri.TryCreate(url, UriKind.Absolute, out var uri)) return uri.IsFile ? uri.LocalPath : null;
|
||||
var relative = Uri.UnescapeDataString(url);
|
||||
var first = Path.GetFullPath(relative, baseDir);
|
||||
for (var dir = new DirectoryInfo(baseDir); dir is not null; dir = dir.Parent)
|
||||
{
|
||||
var candidate = Path.GetFullPath(relative, dir.FullName);
|
||||
if (File.Exists(candidate)) return candidate;
|
||||
}
|
||||
return first; // non esiste da nessuna parte: il controllo successivo lo scarta
|
||||
}
|
||||
|
||||
/// <summary>Controllo rapido e sincrono: percorso locale, formato ammesso, file esistente entro il limite. Non decodifica.</summary>
|
||||
static bool IsImageCandidate(string? path)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (path is null || !ImageExtensions.Contains(Path.GetExtension(path), StringComparer.OrdinalIgnoreCase)) return false;
|
||||
var info = new FileInfo(path);
|
||||
return info.Exists && info.Length <= MaxImageBytes;
|
||||
}
|
||||
catch { return false; }
|
||||
}
|
||||
|
||||
/// <summary>Decodifica l'immagine (chiamata fuori dal thread della GUI); nullo se illeggibile, mai eccezioni.</summary>
|
||||
static Bitmap? DecodeImage(string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var fs = File.OpenRead(path);
|
||||
var bmp = new Bitmap(fs);
|
||||
if (bmp.PixelSize.Width <= MaxDecodeWidth) return bmp;
|
||||
bmp.Dispose();
|
||||
fs.Position = 0;
|
||||
return Bitmap.DecodeToWidth(fs, MaxDecodeWidth);
|
||||
}
|
||||
catch { return null; }
|
||||
}
|
||||
|
||||
// Segnaposto `[alt]` che diventa l'immagine a decodifica finita; se la decodifica fallisce resta il testo.
|
||||
Control ImageHost(string path, string alt, double maxWidth)
|
||||
{
|
||||
var host = new Decorator { HorizontalAlignment = HorizontalAlignment.Left, Child = new TextBlock { Text = "[" + alt + "]", TextWrapping = TextWrapping.Wrap } };
|
||||
PendingImages++;
|
||||
_ = LoadInto(host, path, alt, maxWidth);
|
||||
return host;
|
||||
}
|
||||
|
||||
async Task LoadInto(Decorator host, string path, string alt, double maxWidth)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (await Task.Run(() => DecodeImage(path)) is { } bmp) host.Child = ImageOf(bmp, alt, maxWidth);
|
||||
}
|
||||
finally { PendingImages--; }
|
||||
}
|
||||
|
||||
static Image ImageOf(Bitmap bmp, string alt, double maxWidth)
|
||||
{
|
||||
var img = new Image
|
||||
{
|
||||
Source = bmp, Stretch = Stretch.Uniform, StretchDirection = StretchDirection.DownOnly,
|
||||
MaxWidth = Math.Min(maxWidth, bmp.Size.Width), HorizontalAlignment = HorizontalAlignment.Left,
|
||||
};
|
||||
AutomationProperties.SetName(img, alt);
|
||||
ToolTip.SetTip(img, alt);
|
||||
return img;
|
||||
}
|
||||
|
||||
// Paragrafo fatto solo di immagini: blocchi alla larghezza della colonna. Nullo se non è così o nessuna è plausibile.
|
||||
Control? ImageParagraph(ParagraphBlock p)
|
||||
{
|
||||
if (p.Inline is null) return null;
|
||||
var images = new List<LinkInline>();
|
||||
foreach (var node in p.Inline)
|
||||
{
|
||||
if (node is LinkInline { IsImage: true } img) images.Add(img);
|
||||
else if (node is not LineBreakInline && !(node is LiteralInline lit && string.IsNullOrWhiteSpace(lit.Content.ToString()))) return null;
|
||||
}
|
||||
if (images.Count == 0) return null;
|
||||
var paths = images.Select(i => ResolveImagePath(i.Url, BaseDirectory)).ToList();
|
||||
if (!paths.Any(IsImageCandidate)) return null;
|
||||
var panel = new StackPanel { Spacing = 8 };
|
||||
for (var i = 0; i < images.Count; i++)
|
||||
{
|
||||
var image = images[i];
|
||||
panel.Children.Add(IsImageCandidate(paths[i]) ? ImageHost(paths[i]!, AltText(image), double.PositiveInfinity)
|
||||
: new SelectableTextBlock { Text = "[" + AltText(image) + "]", TextWrapping = TextWrapping.Wrap });
|
||||
}
|
||||
return panel;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
using Avalonia.Automation;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Documents;
|
||||
using Avalonia.Controls.Primitives;
|
||||
using Avalonia.Layout;
|
||||
using Avalonia.Media;
|
||||
using CSharpMath.Avalonia;
|
||||
using Markdig.Extensions.Mathematics;
|
||||
using Markdig.Syntax;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
/// <summary>Formule LaTeX nel markdown (ADR-0008): inline <c>$…$</c> e a blocco <c>$$…$$</c>; se il LaTeX non è valido compare il sorgente.</summary>
|
||||
partial class MarkdownView
|
||||
{
|
||||
const double InlineFormulaSize = 15;
|
||||
const double BlockFormulaSize = 18;
|
||||
|
||||
/// <summary>Sorgente LaTeX di un blocco <c>$$…$$</c> (righe tra i delimitatori).</summary>
|
||||
static string BlockSource(LeafBlock block) =>
|
||||
string.Join('\n', block.Lines.Lines.Take(block.Lines.Count).Select(l => l.ToString())).Trim();
|
||||
|
||||
Control FormulaBlock(string latex)
|
||||
{
|
||||
var formula = Formula(latex, BlockFormulaSize, "$$");
|
||||
// formula più larga della colonna: scorrimento orizzontale invece di tagliarla
|
||||
return new ScrollViewer
|
||||
{
|
||||
HorizontalScrollBarVisibility = ScrollBarVisibility.Auto, VerticalScrollBarVisibility = ScrollBarVisibility.Disabled,
|
||||
HorizontalAlignment = HorizontalAlignment.Left, Content = formula,
|
||||
};
|
||||
}
|
||||
|
||||
// colore del testo del tema (token Fg); senza il token (es. nei test) quello ereditato dal controllo
|
||||
Color TextColor() =>
|
||||
this.TryFindResource("Fg", ActualThemeVariant, out var v) && v is ISolidColorBrush s ? s.Color
|
||||
: TextElement.GetForeground(this) is ISolidColorBrush f ? f.Color : Colors.Black;
|
||||
|
||||
/// <summary>Regola di Pandoc per <c>$…$</c>: niente spazio dopo l'apertura né prima della chiusura, altrimenti i due <c>$</c> sono testo (prezzi, importi). Markdig da solo accetterebbe «10 $ e 20 $».</summary>
|
||||
static bool IsDollarText(string source, MathInline math)
|
||||
{
|
||||
// Markdig toglie gli spazi dal contenuto: si controlla il testo originale tra i due delimitatori
|
||||
if (math.DelimiterCount != 1) return false;
|
||||
var (start, end) = (math.Span.Start, math.Span.End);
|
||||
if (start < 0 || end >= source.Length || end - start < 2) return false; // intervallo non affidabile: si tratta come formula
|
||||
return char.IsWhiteSpace(source[start + 1]) || char.IsWhiteSpace(source[end - 1]);
|
||||
}
|
||||
|
||||
Control FormulaInline(string latex) => Formula(latex, InlineFormulaSize, "$");
|
||||
|
||||
/// <summary>Controllo che disegna la formula; se il LaTeX non è valido, il sorgente come testo monospazio (ripiego sicuro).</summary>
|
||||
Control Formula(string latex, double size, string delimiter)
|
||||
{
|
||||
latex = latex.Trim();
|
||||
try
|
||||
{
|
||||
var view = new MathView
|
||||
{
|
||||
LaTeX = latex, FontSize = (float)size, TextColor = TextColor(), DisplayErrorInline = false,
|
||||
VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Left,
|
||||
};
|
||||
if (latex.Length > 0 && string.IsNullOrEmpty(view.ErrorMessage))
|
||||
{
|
||||
AutomationProperties.SetName(view, latex);
|
||||
ToolTip.SetTip(view, latex);
|
||||
return view;
|
||||
}
|
||||
}
|
||||
catch (Exception) { /* LaTeX o disegno non riusciti: ripiego sul sorgente */ }
|
||||
return new TextBlock { Text = delimiter + latex + delimiter, FontFamily = Mono, FontSize = 13.5, Foreground = Brush("FgMuted"), TextWrapping = TextWrapping.Wrap };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Documents;
|
||||
using Avalonia.Input;
|
||||
using Avalonia.Input.Platform;
|
||||
using Avalonia.Layout;
|
||||
using Avalonia.Media;
|
||||
using Markdig;
|
||||
using Markdig.Extensions.Mathematics;
|
||||
using Markdig.Extensions.Tables;
|
||||
using Markdig.Syntax;
|
||||
using Markdig.Syntax.Inlines;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
/// <summary>Mostra markdown come controlli Avalonia (nessun HTML): il testo è Markdig, il rendering è qui.</summary>
|
||||
partial class MarkdownView : Decorator
|
||||
{
|
||||
public static readonly StyledProperty<string?> SourceProperty = AvaloniaProperty.Register<MarkdownView, string?>(nameof(Source));
|
||||
static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().DisableHtml().Build();
|
||||
static readonly FontFamily Mono = new("Cascadia Code, Consolas, DejaVu Sans Mono, Liberation Mono, monospace");
|
||||
|
||||
public string? Source { get => GetValue(SourceProperty); set => SetValue(SourceProperty, value); }
|
||||
|
||||
public MarkdownView()
|
||||
{
|
||||
// i colori si risolvono in fase di rendering: al cambio di tema si ricostruisce
|
||||
ActualThemeVariantChanged += (_, _) => Rebuild();
|
||||
}
|
||||
|
||||
protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
|
||||
{
|
||||
base.OnPropertyChanged(change);
|
||||
if (change.Property == SourceProperty) Rebuild();
|
||||
}
|
||||
|
||||
string parsed = "";
|
||||
|
||||
void Rebuild()
|
||||
{
|
||||
// fine riga uniformi: gli intervalli di Markdig (Span) devono valere per il testo che si legge qui (ADR-0008)
|
||||
parsed = Source?.ReplaceLineEndings("\n") ?? "";
|
||||
Child = parsed.Length == 0 ? null : RenderBlocks(Markdig.Markdown.Parse(parsed, Pipeline), 10);
|
||||
}
|
||||
|
||||
IBrush Brush(string key) => this.TryFindResource(key, ActualThemeVariant, out var v) && v is IBrush b ? b : Brushes.Gray;
|
||||
|
||||
Control RenderBlocks(IEnumerable<Block> blocks, double spacing)
|
||||
{
|
||||
var panel = new StackPanel { Spacing = spacing };
|
||||
foreach (var b in blocks) panel.Children.Add(RenderBlock(b));
|
||||
return panel;
|
||||
}
|
||||
|
||||
Control RenderBlock(Block block) => block switch
|
||||
{
|
||||
HeadingBlock h => Text(h.Inline, bold: true, size: h.Level switch { 1 => 24, 2 => 20, 3 => 18, 4 => 16, _ => 15.5 }),
|
||||
ParagraphBlock p => ImageParagraph(p) ?? Text(p.Inline),
|
||||
MathBlock m => FormulaBlock(BlockSource(m)),
|
||||
FencedCodeBlock or CodeBlock => Code(string.Join('\n', ((LeafBlock)block).Lines.Lines.Take(((LeafBlock)block).Lines.Count).Select(l => l.ToString()))),
|
||||
QuoteBlock q => new Border { BorderBrush = Brush("Border"), BorderThickness = new(3, 0, 0, 0), Padding = new(12, 0, 0, 0), Child = RenderBlocks(q, 8) },
|
||||
ListBlock l => List(l),
|
||||
Table t => TableOf(t),
|
||||
ThematicBreakBlock => new Border { Height = 1, Background = Brush("Border"), Margin = new(0, 6) },
|
||||
LeafBlock leaf => Text(leaf.Inline),
|
||||
ContainerBlock c => RenderBlocks(c, 8),
|
||||
_ => new Panel(),
|
||||
};
|
||||
|
||||
Control List(ListBlock list)
|
||||
{
|
||||
var panel = new StackPanel { Spacing = 4 };
|
||||
var n = int.TryParse(list.OrderedStart, out var start) ? start : 1;
|
||||
foreach (var item in list.OfType<ListItemBlock>())
|
||||
{
|
||||
var row = new Grid { ColumnDefinitions = new("Auto,*") };
|
||||
var marker = new TextBlock { Text = list.IsOrdered ? $"{n++}." : "•", Foreground = Brush("FgMuted"), Margin = new(0, 0, 8, 0), MinWidth = 18, TextAlignment = TextAlignment.Right };
|
||||
var body = RenderBlocks(item, 4);
|
||||
Grid.SetColumn(body, 1);
|
||||
row.Children.Add(marker);
|
||||
row.Children.Add(body);
|
||||
panel.Children.Add(row);
|
||||
}
|
||||
return panel;
|
||||
}
|
||||
|
||||
Control Code(string code)
|
||||
{
|
||||
var text = new SelectableTextBlock { Text = code, FontFamily = Mono, FontSize = 13.5, Padding = new(14, 12, 64, 12) };
|
||||
var copy = new Button { Content = "Copia", Classes = { "mini" }, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Top, Margin = new(0, 6, 6, 0) };
|
||||
copy.Click += async (_, _) =>
|
||||
{
|
||||
if (TopLevel.GetTopLevel(this)?.Clipboard is { } cb) await cb.SetTextAsync(code);
|
||||
copy.Content = "Copiato";
|
||||
await Task.Delay(1400);
|
||||
copy.Content = "Copia";
|
||||
};
|
||||
return new Border
|
||||
{
|
||||
Background = Brush("Muted"), BorderBrush = Brush("Border"), BorderThickness = new(1), CornerRadius = new(10),
|
||||
Child = new Grid { Children = { new ScrollViewer { HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto, Content = text }, copy } },
|
||||
};
|
||||
}
|
||||
|
||||
Control TableOf(Table table)
|
||||
{
|
||||
var grid = new Grid();
|
||||
var rows = table.OfType<TableRow>().ToList();
|
||||
var cols = rows.Max(r => r.Count);
|
||||
for (var c = 0; c < cols; c++) grid.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Star));
|
||||
for (var r = 0; r < rows.Count; r++)
|
||||
{
|
||||
grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
|
||||
var cells = rows[r].OfType<TableCell>().ToList();
|
||||
for (var c = 0; c < cells.Count; c++)
|
||||
{
|
||||
var cell = RenderBlocks(cells[c], 4);
|
||||
if (cell is StackPanel { Children: [SelectableTextBlock tb] }) // intestazione in grassetto
|
||||
if (rows[r].IsHeader) tb.FontWeight = FontWeight.SemiBold;
|
||||
var align = c < table.ColumnDefinitions.Count ? table.ColumnDefinitions[c].Alignment : null;
|
||||
cell.HorizontalAlignment = align switch { TableColumnAlign.Center => HorizontalAlignment.Center, TableColumnAlign.Right => HorizontalAlignment.Right, _ => HorizontalAlignment.Left };
|
||||
var box = new Border
|
||||
{
|
||||
BorderBrush = Brush("Border"), BorderThickness = new(0.5), Padding = new(10, 6),
|
||||
Background = rows[r].IsHeader ? Brush("Muted") : null, Child = cell,
|
||||
};
|
||||
Grid.SetRow(box, r); Grid.SetColumn(box, c);
|
||||
grid.Children.Add(box);
|
||||
}
|
||||
}
|
||||
return new Border { BorderBrush = Brush("Border"), BorderThickness = new(0.5), CornerRadius = new(6), ClipToBounds = true, Child = grid };
|
||||
}
|
||||
|
||||
// Testo con inline; i link sono Run colorati e il clic si risolve con l'hit-test sul testo.
|
||||
SelectableTextBlock Text(ContainerInline? inline, bool bold = false, double size = 0)
|
||||
{
|
||||
var tb = new SelectableTextBlock { TextWrapping = TextWrapping.Wrap };
|
||||
if (size > 0) tb.FontSize = size;
|
||||
if (bold) tb.FontWeight = FontWeight.SemiBold;
|
||||
var links = new List<(int Start, int End, string Url)>();
|
||||
var pos = 0;
|
||||
AddInlines(tb.Inlines!, inline, new(), links, ref pos);
|
||||
if (links.Count > 0) WireLinks(tb, links);
|
||||
return tb;
|
||||
}
|
||||
|
||||
record struct Style(bool Bold, bool Italic, bool Strike, bool Link);
|
||||
|
||||
void AddInlines(InlineCollection target, ContainerInline? container, Style st, List<(int, int, string)> links, ref int pos)
|
||||
{
|
||||
if (container is null) return;
|
||||
foreach (var node in container)
|
||||
{
|
||||
switch (node)
|
||||
{
|
||||
case LiteralInline lit: Add(target, lit.Content.ToString(), st, ref pos); break;
|
||||
case MathInline math:
|
||||
var latex = math.Content.ToString();
|
||||
if (IsDollarText(parsed, math)) // es. «10 $ e 20 $»: non è una formula
|
||||
Add(target, parsed.Substring(math.Span.Start, math.Span.End - math.Span.Start + 1), st, ref pos);
|
||||
else
|
||||
{
|
||||
target.Add(new InlineUIContainer(FormulaInline(latex)));
|
||||
pos += 1; // un controllo incorporato occupa una posizione nel testo
|
||||
}
|
||||
break;
|
||||
case LineBreakInline br: Add(target, br.IsHard ? "\n" : " ", st, ref pos); break;
|
||||
case CodeInline code:
|
||||
target.Add(new Run(code.Content) { FontFamily = Mono, FontSize = 13.5, Background = Brush("Muted") });
|
||||
pos += code.Content.Length;
|
||||
break;
|
||||
case EmphasisInline em:
|
||||
var inner = em.DelimiterChar == '~' ? st with { Strike = true }
|
||||
: em.DelimiterCount >= 2 ? st with { Bold = true } : st with { Italic = true };
|
||||
AddInlines(target, em, inner, links, ref pos);
|
||||
break;
|
||||
case LinkInline { IsImage: true } img:
|
||||
if (ResolveImagePath(img.Url, BaseDirectory) is { } imgPath && IsImageCandidate(imgPath))
|
||||
{
|
||||
target.Add(new InlineUIContainer(ImageHost(imgPath, AltText(img), MaxInlineImageWidth)));
|
||||
pos += 1; // un controllo incorporato occupa una posizione nel testo
|
||||
}
|
||||
else Add(target, "[" + AltText(img) + "]", st, ref pos);
|
||||
break;
|
||||
case LinkInline link:
|
||||
var start = pos;
|
||||
AddInlines(target, link, st with { Link = true }, links, ref pos);
|
||||
if (link.Url is { } url) links.Add((start, pos, url));
|
||||
break;
|
||||
case AutolinkInline auto:
|
||||
var s = pos;
|
||||
Add(target, auto.Url, st with { Link = true }, ref pos);
|
||||
links.Add((s, pos, auto.Url));
|
||||
break;
|
||||
case ContainerInline c: AddInlines(target, c, st, links, ref pos); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Add(InlineCollection target, string text, Style st, ref int pos)
|
||||
{
|
||||
var run = new Run(text);
|
||||
if (st.Bold) run.FontWeight = FontWeight.Bold;
|
||||
if (st.Italic) run.FontStyle = FontStyle.Italic;
|
||||
if (st.Strike) run.TextDecorations = TextDecorations.Strikethrough;
|
||||
if (st.Link) { run.Foreground = Brush("Accent"); run.TextDecorations = TextDecorations.Underline; }
|
||||
target.Add(run);
|
||||
pos += text.Length;
|
||||
}
|
||||
|
||||
void WireLinks(SelectableTextBlock tb, List<(int Start, int End, string Url)> links)
|
||||
{
|
||||
string? UrlAt(Point p)
|
||||
{
|
||||
var i = tb.TextLayout.HitTestPoint(p).TextPosition;
|
||||
foreach (var (s, e, url) in links) if (i >= s && i < e) return url;
|
||||
return null;
|
||||
}
|
||||
tb.PointerMoved += (_, e) => tb.Cursor = UrlAt(e.GetPosition(tb)) is null ? null : new Cursor(StandardCursorType.Hand);
|
||||
tb.PointerReleased += async (_, e) =>
|
||||
{
|
||||
if (tb.SelectionStart != tb.SelectionEnd) return; // era una selezione, non un clic
|
||||
if (UrlAt(e.GetPosition(tb)) is { } url && Uri.TryCreate(url, UriKind.Absolute, out var uri) && uri.Scheme is "http" or "https")
|
||||
if (TopLevel.GetTopLevel(this)?.Launcher is { } l) await l.LaunchUriAsync(uri);
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
using System.ComponentModel;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Windows.Input;
|
||||
|
||||
namespace AgentWikiUi.Gui;
|
||||
|
||||
class ObservableObject : INotifyPropertyChanged
|
||||
{
|
||||
public event PropertyChangedEventHandler? PropertyChanged;
|
||||
|
||||
protected bool Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
|
||||
{
|
||||
if (EqualityComparer<T>.Default.Equals(field, value)) return false;
|
||||
field = value;
|
||||
Raise(name);
|
||||
return true;
|
||||
}
|
||||
|
||||
protected void Raise([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new(name));
|
||||
}
|
||||
|
||||
class RelayCommand<T>(Action<T?> run, Func<bool>? canRun = null) : ICommand
|
||||
{
|
||||
public event EventHandler? CanExecuteChanged;
|
||||
public bool CanExecute(object? parameter) => canRun?.Invoke() ?? true;
|
||||
public void Execute(object? parameter) => run(parameter is T t ? t : default);
|
||||
public void Refresh() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using Avalonia;
|
||||
using AgentWikiUi.Core;
|
||||
using AgentWikiUi.Gui;
|
||||
|
||||
// Con argomenti: CLI. Con `--engine <id>` per primo si sceglie il motore (default Claude Code);
|
||||
// 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);
|
||||
@@ -0,0 +1,31 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<!-- 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>
|
||||
<!-- Unica sorgente del nome dell'app (vedi docs/README.md → "Nome del progetto") -->
|
||||
<AssemblyName>agent-wiki-ui</AssemblyName>
|
||||
<RootNamespace>AgentWikiUi</RootNamespace>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
|
||||
<!-- publish single-file: le librerie native (Skia, HarfBuzz) vengono estratte al primo avvio -->
|
||||
<IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
|
||||
<EnableCompressionInSingleFile>true</EnableCompressionInSingleFile>
|
||||
<DebugType>none</DebugType>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<InternalsVisibleTo Include="agent-wiki-ui.Tests" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Avalonia" Version="12.1.4" />
|
||||
<PackageReference Include="Avalonia.Desktop" Version="12.1.4" />
|
||||
<PackageReference Include="Avalonia.Themes.Fluent" Version="12.1.4" />
|
||||
<PackageReference Include="Markdig" Version="1.4.0" />
|
||||
<PackageReference Include="Sylinko.CSharpMath.Avalonia" Version="12.0.0" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,13 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<!-- Doppio di test di `claude` (vedi docs/TESTING.md → FakeClaude): l'eseguibile si chiama `claude` per poterlo mettere nel PATH -->
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<AssemblyName>claude</AssemblyName>
|
||||
<RootNamespace>FakeClaude</RootNamespace>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
</PropertyGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,15 @@
|
||||
using System.Text.Json;
|
||||
|
||||
// Configurazione e formato del registro: docs/TESTING.md → FakeClaude.
|
||||
var stdin = Console.In.ReadToEnd(); // resta in attesa finché il chiamante non chiude stdin
|
||||
|
||||
if (Environment.GetEnvironmentVariable("FAKE_CLAUDE_LOG") is { Length: > 0 } log)
|
||||
File.AppendAllText(log, JsonSerializer.Serialize(new { args, cwd = Directory.GetCurrentDirectory(), stdin }) + "\n");
|
||||
|
||||
if (int.TryParse(Environment.GetEnvironmentVariable("FAKE_CLAUDE_DELAY_MS"), out var delay) && delay > 0)
|
||||
Thread.Sleep(delay);
|
||||
|
||||
if (Environment.GetEnvironmentVariable("FAKE_CLAUDE_OUT") is { } o) Console.Out.Write(o);
|
||||
if (Environment.GetEnvironmentVariable("FAKE_CLAUDE_ERR") is { } e) Console.Error.Write(e);
|
||||
|
||||
return int.TryParse(Environment.GetEnvironmentVariable("FAKE_CLAUDE_EXIT"), out var code) ? code : 0;
|
||||
@@ -0,0 +1,142 @@
|
||||
using System.Net;
|
||||
using AgentWikiUi.Core;
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Motore Antigravity (docs/TESTING.md → Antigravity, AG-01…AG-10, AG-12, UP-21).</summary>
|
||||
[Trait("Category", "Unit")]
|
||||
public sealed class AgyEngineTests
|
||||
{
|
||||
static readonly Engine Agy = Engines.Agy;
|
||||
|
||||
sealed class FakeHandler(string body) : HttpMessageHandler
|
||||
{
|
||||
public Uri? Requested;
|
||||
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
|
||||
{
|
||||
Requested = request.RequestUri;
|
||||
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(body) });
|
||||
}
|
||||
}
|
||||
|
||||
[Fact] // AG-01
|
||||
public void Agy_primo_messaggio() =>
|
||||
Assert.Equal(["--output-format", "json", "--print-timeout", "120s", "-p", "ciao"],
|
||||
Agy.BuildArgs("ciao", null, resume: false, model: "", effort: "", structured: true));
|
||||
|
||||
[Fact] // AG-02
|
||||
public void Agy_ripresa() =>
|
||||
Assert.Equal(["--output-format", "json", "--conversation", "conv-1", "--print-timeout", "120s", "-p", "ancora"],
|
||||
Agy.BuildArgs("ancora", "conv-1", resume: true, model: "", effort: "", structured: true));
|
||||
|
||||
[Fact] // AG-03
|
||||
public void Agy_flag_prima_di_p()
|
||||
{
|
||||
var args = Agy.BuildArgs("ciao", "conv-1", true, "gemini-3.0-flash-low", "high", true);
|
||||
Assert.Equal(["-p", "ciao"], args[^2..]);
|
||||
Assert.Single(args, a => a == "-p");
|
||||
}
|
||||
|
||||
[Fact] // AG-04
|
||||
public void Agy_modello_ed_effort()
|
||||
{
|
||||
var con = Agy.BuildArgs("x", null, false, "claude-opus-4-6-thinking", "max", true);
|
||||
Assert.Equal("claude-opus-4-6-thinking", con[con.IndexOf("--model") + 1]);
|
||||
Assert.Equal("max", con[con.IndexOf("--effort") + 1]);
|
||||
|
||||
var senza = Agy.BuildArgs("x", null, false, "", "", true);
|
||||
Assert.DoesNotContain("--model", senza);
|
||||
Assert.DoesNotContain("--effort", senza);
|
||||
}
|
||||
|
||||
[Fact] // AG-05
|
||||
public void Agy_conversation_id()
|
||||
{
|
||||
Assert.True(Agy.OwnsSessionId);
|
||||
var r = Agy.Parse(0, """{"conversation_id":"abc-123","response":"ok","status":"SUCCESS"}""", "");
|
||||
Assert.Equal("abc-123", r.SessionId);
|
||||
}
|
||||
|
||||
[Fact] // AG-06
|
||||
public void Agy_estrazione_risposta()
|
||||
{
|
||||
var r = Agy.Parse(0, """{"conversation_id":"c","response":" Ciao **mondo**\n","status":"SUCCESS"}""", "");
|
||||
Assert.Equal("Ciao **mondo**", r.Text);
|
||||
Assert.Null(r.Error);
|
||||
}
|
||||
|
||||
[Fact] // AG-07
|
||||
public void Agy_errore_status()
|
||||
{
|
||||
var stato = Agy.Parse(0, """{"conversation_id":"c","response":"","status":"FAILED"}""", "");
|
||||
Assert.Equal("Stato FAILED", stato.Error);
|
||||
|
||||
var campo = Agy.Parse(0, """{"conversation_id":"c","status":"SUCCESS","error":"quota esaurita"}""", "");
|
||||
Assert.Equal("quota esaurita", campo.Error);
|
||||
|
||||
var uscita = Agy.Parse(2, "", "boom");
|
||||
Assert.Equal("", uscita.Text);
|
||||
Assert.Contains("agy è uscito con codice 2", uscita.Error);
|
||||
Assert.Contains("boom", uscita.Error);
|
||||
}
|
||||
|
||||
[Fact] // AG-08
|
||||
public void Agy_estrazione_json_robusta()
|
||||
{
|
||||
var out_ = "Avviso: aggiornamento disponibile\n{\"conversation_id\":\"c9\",\"response\":\"risposta\",\"status\":\"SUCCESS\"}\nfine\n";
|
||||
var r = Agy.Parse(0, out_, "");
|
||||
Assert.Equal("risposta", r.Text);
|
||||
Assert.Equal("c9", r.SessionId);
|
||||
Assert.Null(r.Error);
|
||||
}
|
||||
|
||||
[Fact] // AG-09
|
||||
public void Agy_nessuna_risposta()
|
||||
{
|
||||
Assert.Equal("agy non ha restituito nessuna risposta.", Agy.Parse(0, "", "").Error);
|
||||
Assert.Equal("agy non ha restituito nessuna risposta.", Agy.Parse(0, """{"conversation_id":"c","response":" ","status":"SUCCESS"}""", "").Error);
|
||||
Assert.Equal("solo stderr", Agy.Parse(0, "non json", "solo stderr").Error);
|
||||
}
|
||||
|
||||
[Fact] // AG-10
|
||||
public void Agy_cli_senza_json()
|
||||
{
|
||||
var args = Agy.BuildArgs("ciao", null, false, "", "", structured: false);
|
||||
Assert.DoesNotContain("--output-format", args);
|
||||
Assert.DoesNotContain("json", args);
|
||||
Assert.Equal(["-p", "ciao"], args[^2..]);
|
||||
}
|
||||
|
||||
[Fact] // AG-12
|
||||
public void Agy_catalogo_modelli()
|
||||
{
|
||||
Assert.Equal(
|
||||
["gemini-3.0-flash-low", "gemini-3.0-flash-medium", "gemini-3.0-flash-high",
|
||||
"claude-sonnet-4-6", "claude-opus-4-6-thinking", "gpt-oss-120b-medium"],
|
||||
Agy.Models.Select(m => m.Id));
|
||||
Assert.Equal(["low", "medium", "high", "xhigh", "max"], Agy.Efforts);
|
||||
Assert.Equal("gemini-3.0-flash-low", Agy.DefaultModelId);
|
||||
Assert.Equal("low", Agy.DefaultEffort);
|
||||
Assert.Contains(Agy.Models, m => m.Id == Agy.DefaultModelId);
|
||||
Assert.Same(Agy, Engines.Find("agy"));
|
||||
}
|
||||
|
||||
[Theory] // UP-21
|
||||
[InlineData("Stable Version: 1.4.2\nBuild: abc", "1.4.2")]
|
||||
[InlineData("Stable Version: v2.0", "2.0")]
|
||||
[InlineData("1.9.9", "1.9.9")]
|
||||
public async Task Ultima_versione_agy(string body, string expected)
|
||||
{
|
||||
var handler = new FakeHandler(body);
|
||||
using var http = new HttpClient(handler);
|
||||
Assert.Equal(expected, await Agy.FetchLatestVersionAsync(http, CancellationToken.None));
|
||||
Assert.NotNull(handler.Requested);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Comando_manuale_di_aggiornamento()
|
||||
{
|
||||
Assert.Equal("brew upgrade agy", EngineUpdater.ManualCommand(Agy, InstallMethod.Homebrew));
|
||||
Assert.Equal("agy update", EngineUpdater.ManualCommand(Agy, InstallMethod.Npm));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,265 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Automation;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Documents;
|
||||
using Avalonia.Headless.XUnit;
|
||||
using Avalonia.Media.Imaging;
|
||||
using Avalonia.Styling;
|
||||
using Avalonia.Threading;
|
||||
using Avalonia.VisualTree;
|
||||
using AgentWikiUi.Gui;
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Immagini nel markdown (ADR-0006): matrice MD-14 e MD-19…MD-26 in docs/TESTING.md.</summary>
|
||||
[Trait("Category", "Gui")]
|
||||
public sealed class MarkdownImageTests : IDisposable
|
||||
{
|
||||
readonly string dir = Directory.CreateTempSubdirectory("awui-img-").FullName;
|
||||
readonly List<string> inBase = [];
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Directory.Delete(dir, true);
|
||||
foreach (var f in inBase) File.Delete(f);
|
||||
}
|
||||
|
||||
string Png(string name, int w, int h)
|
||||
{
|
||||
var path = Path.Combine(dir, name);
|
||||
File.WriteAllBytes(path, PngFactory.Create(w, h));
|
||||
return path;
|
||||
}
|
||||
|
||||
static (Window Window, MarkdownView View) Show(string markdown, double width = 500, string? baseDir = null)
|
||||
{
|
||||
var view = new MarkdownView();
|
||||
if (baseDir is not null) view.BaseDirectory = baseDir;
|
||||
var window = new Window { Width = width, Height = 800, Content = view };
|
||||
window.Show();
|
||||
view.Source = markdown;
|
||||
WaitForImages(view);
|
||||
return (window, view);
|
||||
}
|
||||
|
||||
// il caricamento è in background (ADR-0006): si fa girare la coda della GUI finché tutte le immagini sono decodificate
|
||||
static void WaitForImages(MarkdownView view)
|
||||
{
|
||||
var deadline = DateTime.UtcNow.AddSeconds(10);
|
||||
while (view.PendingImages > 0 && DateTime.UtcNow < deadline) { Dispatcher.UIThread.RunJobs(); Thread.Sleep(5); }
|
||||
Dispatcher.UIThread.RunJobs();
|
||||
(TopLevel.GetTopLevel(view) as Window)?.UpdateLayout();
|
||||
Assert.Equal(0, view.PendingImages);
|
||||
}
|
||||
|
||||
static List<Image> Images(Visual v) => v.GetVisualDescendants().OfType<Image>().ToList();
|
||||
|
||||
static string Text(Visual v) => string.Concat(v.GetVisualDescendants().OfType<TextBlock>()
|
||||
.Select(t => t.Inlines is { Count: > 0 } ? string.Concat(t.Inlines.OfType<Run>().Select(r => r.Text)) : t.Text));
|
||||
|
||||
[AvaloniaTheory]
|
||||
[InlineData("https://example.com/a.png")]
|
||||
[InlineData("http://example.com/a.png")]
|
||||
[InlineData("ftp://example.com/a.png")]
|
||||
[InlineData("data:image/png;base64,AAAA")]
|
||||
public void Immagini_remote_come_testo(string url)
|
||||
{
|
||||
var (_, view) = Show($"Vedi  qui");
|
||||
Assert.Empty(Images(view));
|
||||
Assert.Contains("[logo]", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_percorso_assoluto()
|
||||
{
|
||||
var path = Png("a.png", 40, 20);
|
||||
var (_, view) = Show($"");
|
||||
var img = Assert.Single(Images(view));
|
||||
var bmp = Assert.IsAssignableFrom<Bitmap>(img.Source);
|
||||
Assert.Equal(new PixelSize(40, 20), bmp.PixelSize);
|
||||
Assert.Equal(40, img.Bounds.Width, 0.5);
|
||||
Assert.DoesNotContain("[griglia]", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_percorso_relativo_e_file_uri()
|
||||
{
|
||||
var name = $"awui-{Guid.NewGuid():N}.png";
|
||||
var inBasePath = Path.Combine(AppContext.BaseDirectory, name);
|
||||
File.WriteAllBytes(inBasePath, PngFactory.Create(10, 10));
|
||||
inBase.Add(inBasePath);
|
||||
var (_, relative) = Show($"");
|
||||
Assert.Single(Images(relative));
|
||||
|
||||
var uri = new Uri(Png("b.png", 12, 12)).AbsoluteUri;
|
||||
var (_, fileUri) = Show($"");
|
||||
Assert.Single(Images(fileUri));
|
||||
}
|
||||
|
||||
[AvaloniaTheory]
|
||||
[InlineData("manca")]
|
||||
[InlineData("corrotto")]
|
||||
[InlineData("estensione")]
|
||||
public void Immagine_non_valida_ripiego(string caso)
|
||||
{
|
||||
var path = caso switch
|
||||
{
|
||||
"manca" => Path.Combine(dir, "non-esiste.png"),
|
||||
"corrotto" => Write("rotto.png", "questo non è un png"u8.ToArray()),
|
||||
_ => Write("dati.txt", PngFactory.Create(8, 8)),
|
||||
};
|
||||
var (_, view) = Show($"");
|
||||
Assert.Empty(Images(view));
|
||||
Assert.Contains("[alt]", Text(view));
|
||||
}
|
||||
|
||||
string Write(string name, byte[] bytes)
|
||||
{
|
||||
var path = Path.Combine(dir, name);
|
||||
File.WriteAllBytes(path, bytes);
|
||||
return path;
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_oltre_limite()
|
||||
{
|
||||
var path = Path.Combine(dir, "grande.png");
|
||||
using (var fs = File.Create(path)) { fs.Write(PngFactory.Create(8, 8)); fs.SetLength(20L * 1024 * 1024 + 1); }
|
||||
var (_, view) = Show($"");
|
||||
Assert.Empty(Images(view));
|
||||
Assert.Contains("[enorme]", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_larghezza_massima()
|
||||
{
|
||||
var (_, wide) = Show($"})", width: 500);
|
||||
var img = Assert.Single(Images(wide));
|
||||
Assert.True(img.Bounds.Width <= 500, $"larghezza {img.Bounds.Width}");
|
||||
Assert.Equal(img.Bounds.Width / 20, img.Bounds.Height, 1); // proporzioni 20:1
|
||||
|
||||
var (_, small) = Show($"})", width: 500);
|
||||
Assert.Equal(50, Assert.Single(Images(small)).Bounds.Width, 0.5); // mai ingrandita
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_testo_alternativo_accessibile()
|
||||
{
|
||||
var (_, view) = Show($"})");
|
||||
var img = Assert.Single(Images(view));
|
||||
Assert.Equal("un grafico", AutomationProperties.GetName(img));
|
||||
Assert.Equal("un grafico", ToolTip.GetTip(img));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_in_contesti_annidati()
|
||||
{
|
||||
var p = Png("n.png", 10, 10);
|
||||
var markdown = $"""
|
||||
Testo  e ancora testo con [un link](https://example.com).
|
||||
|
||||
[](https://example.com)
|
||||
|
||||
- voce 
|
||||
|
||||
| a | b |
|
||||
|---|---|
|
||||
|  | x |
|
||||
""";
|
||||
var (_, view) = Show(markdown);
|
||||
Assert.Equal(4, Images(view).Count);
|
||||
Assert.Contains("un link", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_cambio_tema()
|
||||
{
|
||||
var (window, view) = Show($"})");
|
||||
window.RequestedThemeVariant = ThemeVariant.Dark;
|
||||
WaitForImages(view);
|
||||
Assert.Single(Images(view));
|
||||
window.RequestedThemeVariant = ThemeVariant.Light;
|
||||
WaitForImages(view);
|
||||
Assert.Single(Images(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_caricamento_in_background()
|
||||
{
|
||||
var path = Png("bg.png", 30, 30);
|
||||
var view = new MarkdownView();
|
||||
var window = new Window { Width = 500, Height = 800, Content = view };
|
||||
window.Show();
|
||||
view.Source = $"";
|
||||
// subito dopo il rendering: immagine in attesa e solo il segnaposto (il completamento passa dalla coda della GUI)
|
||||
Assert.Equal(1, view.PendingImages);
|
||||
Assert.Empty(Images(view));
|
||||
Assert.Contains("[segnaposto]", Text(view));
|
||||
WaitForImages(view);
|
||||
Assert.Single(Images(view));
|
||||
Assert.DoesNotContain("[segnaposto]", Text(view));
|
||||
|
||||
// file corrotto: la decodifica fallisce e il segnaposto resta
|
||||
var rotto = Write("rotto2.png", "no"u8.ToArray());
|
||||
view.Source = $"";
|
||||
WaitForImages(view);
|
||||
Assert.Empty(Images(view));
|
||||
Assert.Contains("[guasta]", Text(view));
|
||||
}
|
||||
|
||||
// Struttura tipo wiki: <radice>/catalogo.json, <radice>/figure/<file>, exe in <radice>/query/
|
||||
string Wiki(string name, params string[] files)
|
||||
{
|
||||
var root = Path.Combine(dir, name);
|
||||
Directory.CreateDirectory(Path.Combine(root, "figure"));
|
||||
Directory.CreateDirectory(Path.Combine(root, "query"));
|
||||
foreach (var f in files) File.WriteAllBytes(Path.Combine(root, "figure", f), PngFactory.Create(24, 12));
|
||||
File.WriteAllText(Path.Combine(root, "catalogo.json"), "{\"figures\":[]}");
|
||||
return root;
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_percorso_relativo_alla_radice()
|
||||
{
|
||||
var root = Wiki("wiki-a", "fig1.png");
|
||||
var (_, view) = Show("", baseDir: Path.Combine(root, "query"));
|
||||
Assert.Single(Images(view));
|
||||
Assert.DoesNotContain("[Figura 1]", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_cartella_piu_vicina()
|
||||
{
|
||||
var root = Wiki("wiki-b");
|
||||
File.WriteAllBytes(Path.Combine(root, "figure", "x.png"), PngFactory.Create(30, 30));
|
||||
var exeDir = Path.Combine(root, "query");
|
||||
Directory.CreateDirectory(Path.Combine(exeDir, "figure"));
|
||||
File.WriteAllBytes(Path.Combine(exeDir, "figure", "x.png"), PngFactory.Create(10, 10));
|
||||
|
||||
var (_, view) = Show("", baseDir: exeDir);
|
||||
var bmp = Assert.IsAssignableFrom<Bitmap>(Assert.Single(Images(view)).Source);
|
||||
Assert.Equal(new PixelSize(10, 10), bmp.PixelSize); // vince la cartella più vicina all'exe
|
||||
|
||||
var (_, nowhere) = Show("", baseDir: exeDir);
|
||||
Assert.Empty(Images(nowhere));
|
||||
Assert.Contains("[y]", Text(nowhere));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Immagine_risposta_con_didascalia()
|
||||
{
|
||||
var root = Wiki("wiki-c", "schema-a.png");
|
||||
var risposta = """
|
||||
Lo schema è in Figura 1.
|
||||
|
||||

|
||||
|
||||
Figura 1 - schema generale del sistema · §2.1 r.40 · [[fig-001]]
|
||||
""";
|
||||
var (_, view) = Show(risposta, baseDir: Path.Combine(root, "query"));
|
||||
Assert.Single(Images(view));
|
||||
var text = Text(view);
|
||||
Assert.Contains("Figura 1 - schema generale", text);
|
||||
Assert.Contains("[[fig-001]]", text); // il link alla nota resta testo: l'app non legge il catalogo JSON
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Automation;
|
||||
using Avalonia.Controls;
|
||||
using Avalonia.Controls.Documents;
|
||||
using Avalonia.Headless.XUnit;
|
||||
using Avalonia.Styling;
|
||||
using Avalonia.Threading;
|
||||
using Avalonia.VisualTree;
|
||||
using CSharpMath.Avalonia;
|
||||
using AgentWikiUi.Gui;
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Formule LaTeX nel markdown (ADR-0008): matrice MD-31…MD-38 in docs/TESTING.md.</summary>
|
||||
[Trait("Category", "Gui")]
|
||||
public sealed class MarkdownMathTests
|
||||
{
|
||||
static (Window Window, MarkdownView View) Show(string markdown, double width = 600)
|
||||
{
|
||||
var view = new MarkdownView();
|
||||
var window = new Window { Width = width, Height = 800, Content = view };
|
||||
window.Show();
|
||||
view.Source = markdown;
|
||||
Dispatcher.UIThread.RunJobs();
|
||||
window.UpdateLayout();
|
||||
return (window, view);
|
||||
}
|
||||
|
||||
static List<MathView> Formulas(Visual v) => v.GetVisualDescendants().OfType<MathView>().ToList();
|
||||
|
||||
static string Text(Visual v) => string.Concat(v.GetVisualDescendants().OfType<TextBlock>()
|
||||
.Select(t => t.Inlines is { Count: > 0 } ? string.Concat(t.Inlines.OfType<Run>().Select(r => r.Text)) : t.Text));
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Formula_inline()
|
||||
{
|
||||
var (_, view) = Show("Il gap è $E_g = E_{LUMO} - E_{HOMO}$ in eV.");
|
||||
var f = Assert.Single(Formulas(view));
|
||||
Assert.Equal("E_g = E_{LUMO} - E_{HOMO}", AutomationProperties.GetName(f));
|
||||
Assert.True(string.IsNullOrEmpty(f.ErrorMessage));
|
||||
Assert.True(f.Bounds.Width > 0 && f.Bounds.Height > 0);
|
||||
var text = Text(view);
|
||||
Assert.Contains("Il gap è", text);
|
||||
Assert.Contains("in eV.", text);
|
||||
Assert.DoesNotContain("$", text);
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Formula_a_blocco()
|
||||
{
|
||||
var (_, view) = Show("Prima.\n\n$$\n\\frac{a}{b} = c\n$$\n\nDopo.");
|
||||
var f = Assert.Single(Formulas(view));
|
||||
Assert.Equal("\\frac{a}{b} = c", AutomationProperties.GetName(f));
|
||||
Assert.True(string.IsNullOrEmpty(f.ErrorMessage));
|
||||
Assert.True(f.Bounds.Height > 0);
|
||||
Assert.DoesNotContain("\\frac", Text(view)); // non è un blocco di codice col sorgente
|
||||
Assert.Contains("Prima.", Text(view));
|
||||
Assert.Contains("Dopo.", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaTheory]
|
||||
[InlineData("Testo $\\frac{a$ fine")]
|
||||
[InlineData("$$\n\\unknowncommand{x}\n$$")]
|
||||
[InlineData("Testo $\\begin{matrix$ fine")]
|
||||
public void Formula_non_valida_ripiego(string markdown)
|
||||
{
|
||||
var (_, view) = Show(markdown);
|
||||
Assert.Empty(Formulas(view));
|
||||
Assert.Contains("$", Text(view)); // il sorgente resta visibile come testo
|
||||
}
|
||||
|
||||
[AvaloniaTheory]
|
||||
[InlineData("\\frac{a}{b}")]
|
||||
[InlineData("x^2 + y_i")]
|
||||
[InlineData("\\mathbf{A} \\times \\mathbf{B}")]
|
||||
[InlineData("\\overline{x}")]
|
||||
[InlineData("\\left( \\frac{1}{2} \\right)")]
|
||||
[InlineData("\\lambda_{max} \\approx \\pi \\cdot \\tau")]
|
||||
[InlineData("\\sum_{i=1}^{n} x_i")]
|
||||
[InlineData("\\text{Mn} = \\chi \\varepsilon")]
|
||||
public void Costrutti_latex_comuni(string latex)
|
||||
{
|
||||
var (_, view) = Show($"Prima $${latex}$$ dopo".Replace("$$", "$"));
|
||||
var f = Assert.Single(Formulas(view));
|
||||
Assert.Equal(latex, AutomationProperties.GetName(f));
|
||||
Assert.True(string.IsNullOrEmpty(f.ErrorMessage), f.ErrorMessage);
|
||||
Assert.True(f.Bounds.Width > 0);
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Formula_cambio_tema()
|
||||
{
|
||||
var (window, view) = Show("Gap $E_g$ e\n\n$$\\frac{a}{b}$$");
|
||||
Assert.Equal(2, Formulas(view).Count);
|
||||
window.RequestedThemeVariant = ThemeVariant.Dark;
|
||||
Dispatcher.UIThread.RunJobs();
|
||||
Assert.Equal(2, Formulas(view).Count);
|
||||
window.RequestedThemeVariant = ThemeVariant.Light;
|
||||
Dispatcher.UIThread.RunJobs();
|
||||
Assert.Equal(2, Formulas(view).Count);
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Formula_in_contesti_annidati()
|
||||
{
|
||||
var markdown = """
|
||||
Testo $a_1$ e un [link](https://example.com).
|
||||
|
||||
[vai a $b^2$](https://example.com)
|
||||
|
||||
- voce $c_3$
|
||||
|
||||
| x | y |
|
||||
|---|---|
|
||||
| $d_4$ | z |
|
||||
""";
|
||||
var (_, view) = Show(markdown);
|
||||
Assert.Equal(4, Formulas(view).Count);
|
||||
Assert.Contains("link", Text(view));
|
||||
Assert.Contains("vai a", Text(view));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Formula_nome_accessibile()
|
||||
{
|
||||
var (_, view) = Show("Gap $E_g$.");
|
||||
var f = Assert.Single(Formulas(view));
|
||||
Assert.Equal("E_g", AutomationProperties.GetName(f));
|
||||
}
|
||||
|
||||
[AvaloniaFact]
|
||||
public void Dollari_isolati_restano_testo()
|
||||
{
|
||||
var (_, view) = Show("Costa 10 $ e poi 20 $ in totale.");
|
||||
Assert.Empty(Formulas(view));
|
||||
Assert.Contains("10 $ e poi 20 $", Text(view));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
using System.Diagnostics;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Il doppio di test di <c>claude</c> (docs/TESTING.md → FakeClaude, FK-01…FK-05).</summary>
|
||||
[Trait("Category", "Process")]
|
||||
public sealed class FakeClaudeTests : IDisposable
|
||||
{
|
||||
readonly string dir = Directory.CreateTempSubdirectory("awui-fake-").FullName;
|
||||
|
||||
public void Dispose() => Directory.Delete(dir, true);
|
||||
|
||||
string LogPath => Path.Combine(dir, "log.jsonl");
|
||||
|
||||
Process Start(IEnumerable<string> args, Dictionary<string, string>? env = null, string? cwd = null)
|
||||
{
|
||||
var psi = new ProcessStartInfo(FakeClaudePath.Exe)
|
||||
{
|
||||
UseShellExecute = false, RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true,
|
||||
WorkingDirectory = cwd ?? dir,
|
||||
};
|
||||
foreach (var a in args) psi.ArgumentList.Add(a);
|
||||
psi.Environment["FAKE_CLAUDE_LOG"] = LogPath;
|
||||
foreach (var (k, v) in env ?? []) psi.Environment[k] = v;
|
||||
return Process.Start(psi)!;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Registra_argomenti_cwd_e_stdin()
|
||||
{
|
||||
var cwd = Directory.CreateDirectory(Path.Combine(dir, "lavoro")).FullName;
|
||||
using var p = Start(["-p", "dì \"ciao\" a tutti", "--model", "m"], cwd: cwd);
|
||||
p.StandardInput.Write("dati da stdin");
|
||||
p.StandardInput.Close();
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
|
||||
using var line = JsonDocument.Parse(File.ReadAllLines(LogPath).Single());
|
||||
var r = line.RootElement;
|
||||
Assert.Equal(["-p", "dì \"ciao\" a tutti", "--model", "m"], r.GetProperty("args").EnumerateArray().Select(a => a.GetString()));
|
||||
Assert.Equal(cwd, r.GetProperty("cwd").GetString());
|
||||
Assert.Equal("dati da stdin", r.GetProperty("stdin").GetString());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Output_e_stderr_configurati()
|
||||
{
|
||||
using var p = Start([], new() { ["FAKE_CLAUDE_OUT"] = "risposta", ["FAKE_CLAUDE_ERR"] = "avviso" });
|
||||
p.StandardInput.Close();
|
||||
Assert.Equal("risposta", p.StandardOutput.ReadToEnd());
|
||||
Assert.Equal("avviso", p.StandardError.ReadToEnd());
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(null, 0)]
|
||||
[InlineData("3", 3)]
|
||||
[InlineData("127", 127)]
|
||||
public void ExitCode_configurato(string? configured, int expected)
|
||||
{
|
||||
using var p = Start([], configured is null ? null : new() { ["FAKE_CLAUDE_EXIT"] = configured });
|
||||
p.StandardInput.Close();
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
Assert.Equal(expected, p.ExitCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Ritardo_configurato()
|
||||
{
|
||||
using var p = Start([], new() { ["FAKE_CLAUDE_DELAY_MS"] = "600" });
|
||||
var sw = Stopwatch.StartNew();
|
||||
p.StandardInput.Close();
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
Assert.True(sw.ElapsedMilliseconds >= 500, $"terminato dopo {sw.ElapsedMilliseconds} ms");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Attende_la_chiusura_di_stdin()
|
||||
{
|
||||
using var p = Start([]);
|
||||
try
|
||||
{
|
||||
Assert.False(p.WaitForExit(700), "il processo è terminato con stdin ancora aperto");
|
||||
p.StandardInput.Close();
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
}
|
||||
finally { if (!p.HasExited) p.Kill(); }
|
||||
}
|
||||
|
||||
[Fact] // AG-11
|
||||
public void Agy_timeout_e_stdin()
|
||||
{
|
||||
var psi = AgentWikiUi.Core.EngineRunner.CreateStart(AgentWikiUi.Core.Engines.Agy, "ciao", captured: true);
|
||||
Assert.True(psi.RedirectStandardInput);
|
||||
Assert.Equal(AppContext.BaseDirectory, psi.WorkingDirectory);
|
||||
|
||||
// Gli argomenti di agy, con stdin chiuso subito, bastano a far terminare il processo finto: nessun blocco.
|
||||
using var p = Start(psi.ArgumentList);
|
||||
p.StandardInput.Close();
|
||||
Assert.True(p.WaitForExit(10_000));
|
||||
|
||||
using var line = JsonDocument.Parse(File.ReadAllLines(LogPath).Single());
|
||||
var args = line.RootElement.GetProperty("args").EnumerateArray().Select(a => a.GetString()).ToList();
|
||||
Assert.Equal("120s", args[args.IndexOf("--print-timeout") + 1]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Percorso del <c>claude</c> finto compilato (tests/FakeClaude), nella stessa configurazione dei test.</summary>
|
||||
static class FakeClaudePath
|
||||
{
|
||||
public static string Exe
|
||||
{
|
||||
get
|
||||
{
|
||||
// …/tests/agent-wiki-ui.Tests/bin/<config>/net10.0/
|
||||
var tfm = new DirectoryInfo(AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar));
|
||||
var config = tfm.Parent!;
|
||||
var testsRoot = config.Parent!.Parent!.Parent!;
|
||||
return Path.Combine(testsRoot.FullName, "FakeClaude", "bin", config.Name, tfm.Name, OperatingSystem.IsWindows() ? "claude.exe" : "claude");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
using System.IO.Compression;
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
/// <summary>Scrive PNG minimali (colore pieno) senza dipendere da Avalonia.</summary>
|
||||
static class PngFactory
|
||||
{
|
||||
public static byte[] Create(int width, int height)
|
||||
{
|
||||
var raw = new byte[height * (1 + width * 3)];
|
||||
for (var y = 0; y < height; y++)
|
||||
for (var x = 0; x < width; x++) raw[y * (1 + width * 3) + 1 + x * 3] = 200; // filtro 0 per riga, canale rosso
|
||||
using var ms = new MemoryStream();
|
||||
ms.Write([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
|
||||
var ihdr = new byte[13];
|
||||
WriteInt(ihdr, 0, width); WriteInt(ihdr, 4, height);
|
||||
ihdr[8] = 8; ihdr[9] = 2; // 8 bit, RGB
|
||||
Chunk(ms, "IHDR", ihdr);
|
||||
using (var z = new MemoryStream())
|
||||
{
|
||||
using (var zs = new ZLibStream(z, CompressionLevel.Fastest, leaveOpen: true)) zs.Write(raw);
|
||||
Chunk(ms, "IDAT", z.ToArray());
|
||||
}
|
||||
Chunk(ms, "IEND", []);
|
||||
return ms.ToArray();
|
||||
}
|
||||
|
||||
static void WriteInt(byte[] b, int at, int v) { b[at] = (byte)(v >> 24); b[at + 1] = (byte)(v >> 16); b[at + 2] = (byte)(v >> 8); b[at + 3] = (byte)v; }
|
||||
|
||||
static void Chunk(Stream s, string type, byte[] data)
|
||||
{
|
||||
var len = new byte[4]; WriteInt(len, 0, data.Length);
|
||||
s.Write(len);
|
||||
var body = new byte[4 + data.Length];
|
||||
for (var i = 0; i < 4; i++) body[i] = (byte)type[i];
|
||||
data.CopyTo(body, 4);
|
||||
s.Write(body);
|
||||
var crc = new byte[4]; WriteInt(crc, 0, (int)Crc32(body));
|
||||
s.Write(crc);
|
||||
}
|
||||
|
||||
static uint Crc32(byte[] data)
|
||||
{
|
||||
var crc = 0xFFFFFFFFu;
|
||||
foreach (var b in data)
|
||||
{
|
||||
crc ^= b;
|
||||
for (var k = 0; k < 8; k++) crc = (crc & 1) != 0 ? (crc >> 1) ^ 0xEDB88320u : crc >> 1;
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using Avalonia;
|
||||
using Avalonia.Headless;
|
||||
using Avalonia.Themes.Fluent;
|
||||
using AgentWikiUi.Tests;
|
||||
|
||||
[assembly: AvaloniaTestApplication(typeof(TestAppBuilder))]
|
||||
|
||||
namespace AgentWikiUi.Tests;
|
||||
|
||||
public class TestApp : Application
|
||||
{
|
||||
public override void Initialize() => Styles.Add(new FluentTheme());
|
||||
}
|
||||
|
||||
public static class TestAppBuilder
|
||||
{
|
||||
// Skia reale (non il disegno finto): serve per decodificare davvero le immagini
|
||||
public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure<TestApp>()
|
||||
.UseSkia()
|
||||
.UseHeadless(new AvaloniaHeadlessPlatformOptions { UseHeadlessDrawing = false });
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<IsPackable>false</IsPackable>
|
||||
<RootNamespace>AgentWikiUi.Tests</RootNamespace>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
|
||||
<PackageReference Include="xunit.v3" Version="3.2.2" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="3.1.0" />
|
||||
<PackageReference Include="Avalonia.Headless.XUnit" Version="12.1.4" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<Using Include="Xunit" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="../../src/agent-wiki-ui/agent-wiki-ui.csproj" />
|
||||
<!-- solo compilato (non referenziato): i test avviano l'eseguibile -->
|
||||
<ProjectReference Include="../FakeClaude/FakeClaude.csproj" ReferenceOutputAssembly="false" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -1,272 +0,0 @@
|
||||
<!doctype html>
|
||||
<html lang="it">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>LlmRun</title>
|
||||
<style>
|
||||
/* Token di design: vedi docs/MVP.md → "Design (UI/UX)" */
|
||||
:root {
|
||||
color-scheme: light dark;
|
||||
--bg: #FFFFFF; --surface: #FFFFFF; --fg: #0F172A; --muted: #F1F5F9; --muted-fg: #475569;
|
||||
--border: #CBD5E1; --accent: #15803D; --on-accent: #FFFFFF; --accent-soft: #DCFCE7; --err: #B91C1C;
|
||||
--shadow: 0 1px 2px rgba(15,23,42,.06), 0 8px 24px rgba(15,23,42,.08);
|
||||
--font: 'Segoe UI Variable Text', 'Segoe UI', system-ui, sans-serif;
|
||||
--mono: 'Cascadia Code', Consolas, monospace;
|
||||
}
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root { --bg: #0F172A; --surface: #1E293B; --fg: #F8FAFC; --muted: #1E293B; --muted-fg: #94A3B8;
|
||||
--border: #334155; --accent: #22C55E; --on-accent: #0F172A; --accent-soft: #14301F; --err: #F87171;
|
||||
--shadow: 0 1px 2px rgba(0,0,0,.3), 0 8px 24px rgba(0,0,0,.35); }
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
html, body { height: 100%; margin: 0; }
|
||||
body { display: flex; font: 15.5px/1.65 var(--font); background: var(--bg); color: var(--fg); overflow: hidden; }
|
||||
button, select, textarea, input { font: inherit; color: inherit; }
|
||||
button { cursor: pointer; }
|
||||
:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
|
||||
svg { width: 18px; height: 18px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; flex: none; }
|
||||
|
||||
/* barra laterale */
|
||||
#side { width: 272px; flex: none; display: flex; flex-direction: column; background: var(--muted); border-right: 1px solid var(--border); transition: margin-left .2s; }
|
||||
#side.closed { margin-left: -272px; }
|
||||
.side-top { padding: 16px 14px 10px; display: flex; flex-direction: column; gap: 14px; }
|
||||
.brand { display: flex; align-items: center; gap: 10px; font-weight: 600; letter-spacing: -.01em; padding: 0 4px; }
|
||||
.logo { width: 28px; height: 28px; border-radius: 8px; background: var(--accent); color: var(--on-accent); display: grid; place-items: center; }
|
||||
.logo svg { width: 16px; height: 16px; fill: currentColor; stroke: none; }
|
||||
.ghost { display: inline-flex; align-items: center; gap: 8px; height: 36px; padding: 0 14px; border-radius: 10px; border: 1px solid var(--border); background: transparent; transition: background .15s, border-color .15s; }
|
||||
.ghost:hover { background: var(--bg); }
|
||||
#reset { justify-content: center; background: var(--bg); }
|
||||
#reset:hover { border-color: var(--accent); }
|
||||
.side-h { padding: 8px 18px 4px; font-size: 12px; font-weight: 600; letter-spacing: .05em; text-transform: uppercase; color: var(--muted-fg); }
|
||||
#list { flex: 1; overflow-y: auto; padding: 4px 8px 12px; }
|
||||
.item { position: relative; border-radius: 10px; padding: 8px 38px 8px 12px; transition: background .15s; }
|
||||
.item:hover { background: var(--bg); }
|
||||
.item.active { background: var(--bg); box-shadow: inset 3px 0 0 var(--accent); }
|
||||
.item .open { position: absolute; inset: 0; width: 100%; border: 0; background: transparent; border-radius: 10px; }
|
||||
.item .t, .item .d { position: relative; display: block; pointer-events: none; }
|
||||
.item .t { font-size: 14px; line-height: 1.35; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
|
||||
.item .d { font-size: 12px; color: var(--muted-fg); }
|
||||
.item .x { position: absolute; top: 50%; right: 6px; transform: translateY(-50%); width: 26px; height: 26px; display: grid; place-items: center; border: 0; border-radius: 7px; background: transparent; color: var(--muted-fg); opacity: 0; }
|
||||
.item:hover .x, .item:focus-within .x { opacity: 1; }
|
||||
.item .x:hover { background: var(--muted); color: var(--err); }
|
||||
.item .x svg { width: 14px; height: 14px; }
|
||||
.none { padding: 10px 14px; font-size: 13px; color: var(--muted-fg); }
|
||||
#main { flex: 1; min-width: 0; display: flex; flex-direction: column; position: relative; }
|
||||
#toggle { position: absolute; top: 12px; left: 12px; z-index: 2; width: 36px; height: 36px; padding: 0; justify-content: center; }
|
||||
|
||||
/* conversazione */
|
||||
#scroll { flex: 1; overflow-y: auto; scroll-behavior: smooth; }
|
||||
#chat { max-width: 780px; margin: 0 auto; padding: 28px 20px 12px; }
|
||||
.msg { display: flex; gap: 14px; margin-bottom: 26px; animation: in .18s ease-out; }
|
||||
@keyframes in { from { opacity: 0; transform: translateY(6px); } }
|
||||
.msg.user { justify-content: flex-end; }
|
||||
.bubble { max-width: 85%; padding: 10px 16px; white-space: pre-wrap; overflow-wrap: anywhere; background: var(--muted); border: 1px solid var(--border); border-radius: 18px 18px 4px 18px; }
|
||||
.avatar { width: 30px; height: 30px; border-radius: 50%; background: var(--accent); color: var(--on-accent); display: grid; place-items: center; flex: none; margin-top: 2px; }
|
||||
.avatar svg { width: 16px; height: 16px; fill: currentColor; stroke: none; }
|
||||
.body { min-width: 0; flex: 1; position: relative; }
|
||||
.who { font-size: 12px; font-weight: 600; letter-spacing: .05em; text-transform: uppercase; color: var(--muted-fg); margin-bottom: 2px; }
|
||||
.content > :first-child { margin-top: 0; } .content > :last-child { margin-bottom: 0; }
|
||||
.content a { color: var(--accent); }
|
||||
.content h1, .content h2, .content h3 { line-height: 1.3; margin: 1.4em 0 .5em; }
|
||||
.content p, .content ul, .content ol { margin: .7em 0; }
|
||||
.content code { font-family: var(--mono); font-size: 13.5px; font-variant-ligatures: none; }
|
||||
.content :not(pre) > code { background: var(--muted); border: 1px solid var(--border); padding: 1px 6px; border-radius: 6px; }
|
||||
.content pre { position: relative; margin: 1em 0; padding: 16px; background: var(--muted); border: 1px solid var(--border); border-radius: 12px; overflow-x: auto; }
|
||||
.content table { border-collapse: collapse; display: block; overflow-x: auto; margin: 1em 0; }
|
||||
.content th, .content td { border: 1px solid var(--border); padding: 7px 14px; text-align: left; }
|
||||
.content th { background: var(--muted); font-weight: 600; }
|
||||
.content blockquote { margin: 1em 0; padding: 2px 16px; border-left: 3px solid var(--accent); color: var(--muted-fg); }
|
||||
.content hr { border: 0; border-top: 1px solid var(--border); margin: 1.5em 0; }
|
||||
.mini { position: absolute; top: 8px; right: 8px; height: 28px; padding: 0 10px; font-size: 12px; border-radius: 8px; border: 1px solid var(--border); background: var(--surface); opacity: 0; transition: opacity .15s; }
|
||||
pre:hover > .mini, .mini:focus-visible { opacity: 1; }
|
||||
.actions { margin-top: 8px; opacity: 0; transition: opacity .15s; }
|
||||
.msg:hover .actions, .actions:focus-within { opacity: 1; }
|
||||
.actions .ghost { height: 30px; padding: 0 10px; font-size: 13px; color: var(--muted-fg); border-color: transparent; }
|
||||
.actions .ghost svg { width: 15px; height: 15px; }
|
||||
.err .content { color: var(--err); border: 1px solid var(--err); border-radius: 12px; padding: 10px 14px; white-space: pre-wrap; background: color-mix(in srgb, var(--err) 8%, var(--bg)); }
|
||||
.wait { color: var(--muted-fg); align-items: center; }
|
||||
.dots i { display: inline-block; width: 7px; height: 7px; margin-right: 5px; border-radius: 50%; background: var(--accent); animation: pulse 1.2s infinite ease-in-out; }
|
||||
.dots i:nth-child(2) { animation-delay: .15s; } .dots i:nth-child(3) { animation-delay: .3s; }
|
||||
@keyframes pulse { 0%, 80%, 100% { opacity: .25 } 40% { opacity: 1 } }
|
||||
|
||||
/* schermata iniziale */
|
||||
#empty { max-width: 640px; margin: 0 auto; padding: 12vh 20px 0; text-align: center; }
|
||||
#empty .logo { width: 52px; height: 52px; border-radius: 16px; margin: 0 auto 18px; }
|
||||
#empty .logo svg { width: 28px; height: 28px; }
|
||||
#empty h1 { font-size: 30px; letter-spacing: -.02em; margin: 0 0 6px; }
|
||||
#empty p { color: var(--muted-fg); margin: 0 0 28px; }
|
||||
.chips { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
|
||||
.chip { text-align: left; padding: 12px 16px; border-radius: 14px; border: 1px solid var(--border); background: var(--surface); transition: border-color .15s, transform .15s, background .15s; }
|
||||
.chip:hover { border-color: var(--accent); background: var(--muted); transform: translateY(-1px); }
|
||||
.chip small { display: block; color: var(--muted-fg); font-size: 12.5px; }
|
||||
|
||||
/* composer */
|
||||
footer { flex: none; padding: 8px 20px 12px; }
|
||||
.composer { max-width: 780px; margin: 0 auto; background: var(--surface); border: 1px solid var(--border); border-radius: 20px; box-shadow: var(--shadow); padding: 12px 12px 10px 18px; transition: border-color .15s; }
|
||||
.composer:focus-within { border-color: var(--accent); }
|
||||
textarea { display: block; width: 100%; resize: none; border: 0; outline: 0; background: transparent; padding: 4px 0; max-height: 200px; line-height: 1.55; }
|
||||
textarea:focus-visible { outline: 0; } /* il focus è mostrato dal bordo del .composer */
|
||||
textarea::placeholder { color: var(--muted-fg); }
|
||||
.bar { display: flex; align-items: center; gap: 8px; margin-top: 6px; }
|
||||
.field { display: inline-flex; align-items: center; gap: 6px; font-size: 13px; color: var(--muted-fg); }
|
||||
.field select, .field input { height: 32px; border-radius: 9px; border: 1px solid var(--border); background: var(--bg); padding: 0 8px; font-size: 13px; color: var(--fg); }
|
||||
.field input { width: 190px; }
|
||||
.spacer { flex: 1; }
|
||||
#send { width: 40px; height: 40px; border-radius: 50%; border: 0; background: var(--accent); color: var(--on-accent); display: grid; place-items: center; transition: transform .15s, opacity .15s; }
|
||||
#send:hover:not(:disabled) { transform: scale(1.06); }
|
||||
#send:disabled { opacity: .35; cursor: default; }
|
||||
#send svg { width: 20px; height: 20px; stroke-width: 2.4; }
|
||||
.hint { max-width: 780px; margin: 8px auto 0; text-align: center; font-size: 12px; color: var(--muted-fg); }
|
||||
kbd { font: 11.5px var(--mono); padding: 1px 5px; border: 1px solid var(--border); border-radius: 5px; background: var(--muted); }
|
||||
|
||||
::-webkit-scrollbar { width: 12px; height: 12px; } ::-webkit-scrollbar-thumb { background: var(--border); border-radius: 8px; border: 3px solid var(--bg); }
|
||||
@media (max-width: 720px) { .chips { grid-template-columns: 1fr; } .field input { width: 120px; } }
|
||||
@media (prefers-reduced-motion: reduce) { * { animation: none !important; transition: none !important; scroll-behavior: auto !important; } .dots i { opacity: .7; } }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<aside id="side" aria-label="Chat salvate">
|
||||
<div class="side-top">
|
||||
<div class="brand"><span class="logo"><svg viewBox="0 0 24 24"><path d="M12 2l2.4 6.6L21 11l-6.6 2.4L12 20l-2.4-6.6L3 11l6.6-2.4z"/></svg></span>LlmRun</div>
|
||||
<button class="ghost" id="reset" aria-label="Nuova chat"><svg viewBox="0 0 24 24"><path d="M12 5v14M5 12h14"/></svg>Nuova chat</button>
|
||||
</div>
|
||||
<div class="side-h">Chat</div>
|
||||
<div id="list"></div>
|
||||
</aside>
|
||||
<main id="main">
|
||||
<button class="ghost" id="toggle" aria-label="Mostra o nascondi le chat" aria-expanded="true"><svg viewBox="0 0 24 24"><path d="M4 6h16M4 12h16M4 18h16"/></svg></button>
|
||||
|
||||
<div id="scroll">
|
||||
<div id="empty">
|
||||
<span class="logo"><svg viewBox="0 0 24 24"><path d="M12 2l2.4 6.6L21 11l-6.6 2.4L12 20l-2.4-6.6L3 11l6.6-2.4z"/></svg></span>
|
||||
<h1>Come posso aiutarti?</h1>
|
||||
<p>Scrivi un messaggio oppure parti da uno di questi spunti.</p>
|
||||
<div class="chips">
|
||||
<button class="chip" data-p="Spiega cosa fa questo progetto e come è organizzato.">Spiega il progetto<small>Panoramica e struttura</small></button>
|
||||
<button class="chip" data-p="Scrivi uno script PowerShell che ">Scrivi uno script<small>PowerShell, Python, C#…</small></button>
|
||||
<button class="chip" data-p="Rivedi questo codice e suggerisci miglioramenti: ">Rivedi del codice<small>Bug, leggibilità, prestazioni</small></button>
|
||||
<button class="chip" data-p="Riassumi in modo chiaro questo testo: ">Riassumi un testo<small>Punti chiave in breve</small></button>
|
||||
</div>
|
||||
</div>
|
||||
<div id="chat" role="log" aria-live="polite" aria-label="Conversazione" hidden></div>
|
||||
</div>
|
||||
|
||||
<footer>
|
||||
<div class="composer">
|
||||
<textarea id="input" rows="1" placeholder="Scrivi un messaggio a Claude…" aria-label="Messaggio"></textarea>
|
||||
<div class="bar">
|
||||
<label class="field">Modello
|
||||
<select id="model" aria-label="Modello">{{MODELS}}<option value="__custom">Altro ID…</option></select>
|
||||
<input id="custom" placeholder="es. claude-opus-5-5" aria-label="ID modello personalizzato" hidden>
|
||||
</label>
|
||||
<label class="field">Effort
|
||||
<select id="effort" aria-label="Effort di ragionamento">
|
||||
<option value="">Predefinito</option><option>low</option><option>medium</option><option>high</option><option>xhigh</option><option>max</option>
|
||||
</select>
|
||||
</label>
|
||||
<span class="spacer"></span>
|
||||
<button id="send" aria-label="Invia messaggio" disabled><svg viewBox="0 0 24 24"><path d="M12 19V5M5 12l7-7 7 7"/></svg></button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="hint"><kbd>Invio</kbd> per inviare · <kbd>Maiusc</kbd>+<kbd>Invio</kbd> per andare a capo</div>
|
||||
</footer>
|
||||
</main>
|
||||
|
||||
<script>
|
||||
const $ = s => document.querySelector(s);
|
||||
const chat = $('#chat'), empty = $('#empty'), input = $('#input'), send = $('#send'), scroller = $('#scroll');
|
||||
const host = window.chrome && window.chrome.webview;
|
||||
let busy = false;
|
||||
const ICON_COPY = '<svg viewBox="0 0 24 24"><rect x="9" y="9" width="11" height="11" rx="2"/><path d="M5 15V6a2 2 0 0 1 2-2h9"/></svg>';
|
||||
const STAR = '<svg viewBox="0 0 24 24"><path d="M12 2l2.4 6.6L21 11l-6.6 2.4L12 20l-2.4-6.6L3 11l6.6-2.4z"/></svg>';
|
||||
|
||||
function post(m) { host && host.postMessage(m); }
|
||||
function copy(text) {
|
||||
const t = document.createElement('textarea'); t.value = text; document.body.appendChild(t); t.select();
|
||||
document.execCommand('copy'); t.remove();
|
||||
}
|
||||
function flash(btn, label) { const old = btn.innerHTML; btn.textContent = label; setTimeout(() => btn.innerHTML = old, 1400); }
|
||||
function bottom() { scroller.scrollTop = scroller.scrollHeight; }
|
||||
function el(html) { const d = document.createElement('div'); d.innerHTML = html.trim(); return d.firstChild; }
|
||||
function esc(s) { return s.replace(/[&<>"]/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"' }[c])); }
|
||||
|
||||
function show(node) {
|
||||
empty.hidden = true; chat.hidden = false;
|
||||
chat.appendChild(node); bottom();
|
||||
}
|
||||
function addUser(text) { show(el(`<div class="msg user"><div class="bubble">${esc(text)}</div></div>`)); }
|
||||
function addErr(text) { show(el(`<div class="msg err"><div class="body"><div class="content">${esc(text)}</div></div></div>`)); }
|
||||
function addAi(html, md) {
|
||||
const m = el(`<div class="msg ai"><span class="avatar">${STAR}</span><div class="body"><div class="who">Claude</div><div class="content">${html}</div>
|
||||
<div class="actions"><button class="ghost" aria-label="Copia la risposta">${ICON_COPY}Copia</button></div></div></div>`);
|
||||
m.querySelectorAll('pre').forEach(p => {
|
||||
const b = el('<button class="mini" aria-label="Copia il codice">Copia</button>');
|
||||
b.onclick = () => { copy(p.querySelector('code').innerText); flash(b, 'Copiato'); };
|
||||
p.appendChild(b);
|
||||
});
|
||||
const a = m.querySelector('.actions button'); a.onclick = () => { copy(md); flash(a, 'Copiato'); };
|
||||
show(m);
|
||||
}
|
||||
function setBusy(v) {
|
||||
busy = v; refresh();
|
||||
if (v) show(el(`<div class="msg wait" id="typing" role="status"><span class="avatar">${STAR}</span><span class="dots"><i></i><i></i><i></i></span>Claude sta scrivendo…</div>`));
|
||||
else { const t = $('#typing'); t && t.remove(); input.focus(); }
|
||||
}
|
||||
function refresh() { send.disabled = busy || !input.value.trim(); }
|
||||
function grow() { input.style.height = 'auto'; input.style.height = Math.min(input.scrollHeight, 200) + 'px'; refresh(); }
|
||||
|
||||
function submit() {
|
||||
const text = input.value.trim();
|
||||
if (!text || busy) return;
|
||||
const sel = $('#model').value;
|
||||
const model = sel === '__custom' ? $('#custom').value.trim() : sel;
|
||||
addUser(text); input.value = ''; grow(); setBusy(true);
|
||||
post({ type: 'send', text, model, effort: $('#effort').value });
|
||||
}
|
||||
|
||||
input.addEventListener('input', grow);
|
||||
input.addEventListener('keydown', e => { if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) { e.preventDefault(); submit(); } });
|
||||
send.onclick = submit;
|
||||
$('#model').onchange = e => { const c = $('#custom'); c.hidden = e.target.value !== '__custom'; if (!c.hidden) c.focus(); };
|
||||
function clearView() { chat.replaceChildren(); chat.hidden = true; empty.hidden = false; }
|
||||
$('#reset').onclick = () => { if (busy) return; clearView(); refresh(); post({ type: 'reset' }); input.focus(); };
|
||||
$('#toggle').onclick = () => { const c = $('#side').classList.toggle('closed'); $('#toggle').setAttribute('aria-expanded', String(!c)); };
|
||||
|
||||
const ICON_X = '<svg viewBox="0 0 24 24"><path d="M6 6l12 12M18 6L6 18"/></svg>';
|
||||
function renderList(items, current) {
|
||||
const list = $('#list');
|
||||
list.replaceChildren();
|
||||
if (!items.length) { list.append(el('<div class="none">Nessuna chat salvata</div>')); return; }
|
||||
for (const c of items) {
|
||||
const when = new Date(c.updated).toLocaleString('it-IT', { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
|
||||
const row = el(`<div class="item${c.id === current ? ' active' : ''}"><button class="open" aria-label="Apri chat: ${esc(c.title)}"></button><span class="t">${esc(c.title)}</span><span class="d">${esc(when)}</span><button class="x" aria-label="Elimina chat">${ICON_X}</button></div>`);
|
||||
row.querySelector('.open').onclick = () => { if (!busy && c.id !== current) post({ type: 'open', id: c.id }); };
|
||||
row.querySelector('.x').onclick = () => { if (!busy && confirm('Eliminare questa chat?')) post({ type: 'delete', id: c.id }); };
|
||||
list.append(row);
|
||||
}
|
||||
}
|
||||
function load(messages) {
|
||||
clearView();
|
||||
for (const m of messages) {
|
||||
if (m.role === 'user') addUser(m.text);
|
||||
else if (m.role === 'ai') addAi(m.html, m.text);
|
||||
else addErr(m.text);
|
||||
}
|
||||
bottom();
|
||||
}
|
||||
document.querySelectorAll('.chip').forEach(c => c.onclick = () => { input.value = c.dataset.p; grow(); input.focus(); input.setSelectionRange(input.value.length, input.value.length); });
|
||||
|
||||
host && host.addEventListener('message', e => {
|
||||
const m = e.data;
|
||||
if (m.type === 'ai') addAi(m.html, m.md);
|
||||
else if (m.type === 'err') addErr(m.text);
|
||||
else if (m.type === 'done') setBusy(false);
|
||||
else if (m.type === 'chats') renderList(m.items, m.current);
|
||||
else if (m.type === 'load') load(m.messages);
|
||||
});
|
||||
input.focus();
|
||||
post({ type: 'list' });
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
Reference in new issue
Block a user