Files
Anubis/tools/Anubis.Tasks/Program.cs
T
Alby96andClaude Opus 5.5 959fe6ccba
ci / test (postgres) (pull_request) Successful in 9m38s
ci / test (sqlite) (pull_request) Successful in 5m26s
ci / image (pull_request) Successful in 2m23s
ci / test (postgres) (push) Successful in 9m28s
ci / test (sqlite) (push) Successful in 5m3s
ci / image (push) Successful in 1m56s
Show the news and the market, and set news and calendar from the settings (refs #60)
The news screen of SPEC 13 lists what the bot read in the last 24 hours and
what it did about each story, with the three filters of the mockup, the mood
of the market, the calendar with the effect of each event, the sources and
the spending of the day. Each note of the bot now keeps its action sentence
and the end of its restriction, so the screen shows the decision as it was.

Settings gain a news section: the rows of SPEC 10.5, the sources (enable and
trust), the key and daily cap of the language model, the Finnhub and FRED
keys and the central bank meetings. The demo seeds the F.9 data and matches
the mockup; the overview tile now shows the real news that matter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 15:43:09 +01:00

298 lines
11 KiB
C#

using System.Diagnostics;
using System.Globalization;
// Project commands (ADR 0003): the same steps on Windows and Linux, without make.
// Run through tasks.ps1 / tasks.sh, which build this tool apart from the solution.
var root = FindRoot();
var command = args.Length > 0 ? args[0].ToLowerInvariant() : "help";
var rest = args.Skip(1).ToArray();
return command switch
{
"check" => Check(),
"test" => Test(Environment.GetEnvironmentVariable("ANUBIS_TEST_DB") ?? "sqlite", rest),
"dev" => Run("dotnet", ["watch", "--project", "src/Anubis.Server", "run", .. rest]),
"build" => BuildImage("dev"),
"ci" => Ci(),
"hooks" => Step("Attivazione dell'hook pre-commit (.githooks)", "git", ["config", "core.hooksPath", ".githooks"]) ?? 0,
"seed-demo" => Run("dotnet", ["run", "--project", "src/Anubis.Server", "-c", "Release", "--", "--demo", .. rest]),
"screenshots" => Screenshots(rest),
"release-win" => ReleaseWindows(),
"desktop-win" => NotYet("desktop-win", 10),
_ => Help(),
};
// Locked restore, formatting, build with analyzers as errors, tests on the engine in ANUBIS_TEST_DB.
int Check()
{
var engine = Environment.GetEnvironmentVariable("ANUBIS_TEST_DB") ?? "sqlite";
return Step("Ripristino dei pacchetti dai file di blocco", "dotnet", ["restore", "Anubis.slnx", "--locked-mode"])
?? Step("Controllo della formattazione", "dotnet", ["format", "Anubis.slnx", "--verify-no-changes", "--no-restore"])
?? Step("Compilazione con gli analizzatori", "dotnet", ["build", "Anubis.slnx", "--no-restore", "-c", "Release"])
?? Test(engine, ["--no-build", "-c", "Release"]);
}
int Test(string engine, string[] extra)
{
var env = new Dictionary<string, string> { ["ANUBIS_TEST_DB"] = engine, ["TESTINGPLATFORM_TELEMETRY_OPTOUT"] = "1" };
return Step($"Test su {engine}", "dotnet",
["test", "Anubis.slnx", "--filter", "TestCategory!=LiveDemo", "--logger", "console;verbosity=normal", .. extra], env) ?? 0;
}
// What the remote CI does, run locally: check on SQLite, tests on PostgreSQL, image build, the guard drill in the image.
int Ci()
{
var failed = Check();
if (failed != 0)
{
return failed;
}
var ownPostgres = Environment.GetEnvironmentVariable("ANUBIS_TEST_PG_HOST") is null;
if (ownPostgres)
{
failed = Step("Avvio di PostgreSQL per i test", "docker", ["compose", "up", "-d", "--wait", "postgres"]) ?? 0;
if (failed != 0)
{
return failed;
}
}
try
{
failed = Test("postgres", ["--no-build", "-c", "Release"]);
}
finally
{
if (ownPostgres)
{
Step("Arresto di PostgreSQL", "docker", ["compose", "stop", "postgres"]);
}
}
failed = failed != 0 ? failed : BuildImage("ci");
return failed != 0 ? failed : GuardDrill("ci");
}
// The guard drill inside the image (issue #48): the real guard and the real engine, a sale blocked halfway, the restart.
int GuardDrill(string tag) =>
Step("Esercitazione della guardia nell'immagine", "docker", ["run", "--rm", $"gitea.encke-hake.ts.net/balbosoft/anubis:{tag}", "drill"]) ?? 0;
int BuildImage(string tag) =>
Step("Costruzione dell'immagine Docker", "docker",
["build", "-f", "deploy/docker/Dockerfile", "-t", $"gitea.encke-hake.ts.net/balbosoft/anubis:{tag}", "."]) ?? 0;
// Demo data photographed at 1440 and 390 pixels, light and dark, to compare with docs/design (SPEC 13.1). Uses the
// Edge or Chrome already on the computer, driven through its DevTools protocol: nothing to install (ADR 0007).
int Screenshots(string[] pages)
{
var browser = FindBrowser();
if (browser is null)
{
Console.Error.WriteLine("Serve Microsoft Edge o Google Chrome installato per le fotografie.");
return 2;
}
var failed = Step("Compilazione del server", "dotnet", ["build", "src/Anubis.Server", "-c", "Release"]);
if (failed is not null)
{
return failed.Value;
}
var port = FreePort();
var url = "http://127.0.0.1:" + port.ToString(CultureInfo.InvariantCulture);
var server = new ProcessStartInfo("dotnet") { WorkingDirectory = root, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true };
foreach (var argument in new[] { Path.Combine("src", "Anubis.Server", "bin", "Release", "net10.0", "Anubis.Server.dll"), "--demo", "--urls", url })
{
server.ArgumentList.Add(argument);
}
using var process = Process.Start(server)!;
process.OutputDataReceived += (_, _) => { };
process.ErrorDataReceived += (_, _) => { };
process.BeginOutputReadLine();
process.BeginErrorReadLine();
try
{
using var http = new System.Net.Http.HttpClient();
var ready = false;
for (var i = 0; i < 60 && !ready; i++)
{
try
{
ready = http.GetAsync(new Uri(url + "/health")).GetAwaiter().GetResult().IsSuccessStatusCode;
}
catch (System.Net.Http.HttpRequestException)
{
}
if (!ready)
{
Thread.Sleep(500);
}
}
if (!ready)
{
Console.Error.WriteLine("Il server dimostrativo non risponde.");
return 1;
}
var folder = Path.Combine(root, "artifacts", "screenshots");
Directory.CreateDirectory(folder);
var targets = pages.Length > 0 ? pages : ["/", "/conti", "/diario", "/notizie", "/impostazioni"];
using var shots = Shots.Start(browser);
foreach (var page in targets)
{
var name = page == "/" ? "panoramica" : page.Trim('/').Replace('/', '-');
foreach (var (width, height, dark) in new[] { (1440, 1400, false), (390, 2200, false), (1440, 1400, true) })
{
var file = Path.Combine(folder, $"{name}-{width.ToString(CultureInfo.InvariantCulture)}{(dark ? "-scuro" : "")}.png");
shots.Take(url + page, width, height, dark, file);
Console.WriteLine($" {file}");
}
}
return 0;
}
finally
{
process.Kill(entireProcessTree: true);
}
}
static string? FindBrowser()
{
string[] candidates =
[
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Microsoft", "Edge", "Application", "msedge.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Microsoft", "Edge", "Application", "msedge.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Google", "Chrome", "Application", "chrome.exe"),
"/usr/bin/chromium", "/usr/bin/chromium-browser", "/usr/bin/google-chrome", "/usr/bin/microsoft-edge",
];
return candidates.FirstOrDefault(File.Exists);
}
static int FreePort()
{
var listener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
listener.Start();
var port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
listener.Stop();
return port;
}
// The zip of a trial release for Windows (ADR 0013, point 6): the server, a start script and the instructions, before
// the Phase 10 installer exists. It needs the ASP.NET Core 10 runtime on the computer.
int ReleaseWindows()
{
var props = File.ReadAllText(Path.Combine(root, "Directory.Build.props"));
var start = props.IndexOf("<Version>", StringComparison.Ordinal) + "<Version>".Length;
var version = props[start..props.IndexOf("</Version>", start, StringComparison.Ordinal)];
var name = $"anubis-{version}-win-x64";
var output = Path.Combine(root, "artifacts", "release");
var folder = Path.Combine(output, name);
if (Directory.Exists(folder))
{
Directory.Delete(folder, recursive: true);
}
var failed = Step($"Pubblicazione del server {version} per Windows", "dotnet",
["publish", "src/Anubis.Server", "-c", "Release", "-r", "win-x64", "--self-contained", "false", "-o", folder]);
if (failed is { } code)
{
return code;
}
foreach (var file in Directory.EnumerateFiles(Path.Combine(root, "deploy", "windows")))
{
File.Copy(file, Path.Combine(folder, Path.GetFileName(file)), overwrite: true);
}
var zip = Path.Combine(output, name + ".zip");
File.Delete(zip);
System.IO.Compression.ZipFile.CreateFromDirectory(folder, zip, System.IO.Compression.CompressionLevel.Optimal, includeBaseDirectory: true);
Console.WriteLine();
Console.WriteLine($"== Pronto: {zip} ({(new FileInfo(zip).Length / 1048576.0).ToString("0.0", CultureInfo.InvariantCulture)} MB)");
return 0;
}
int NotYet(string name, int phase)
{
Console.Error.WriteLine($"'tasks {name}' arriva nella Fase {phase.ToString(CultureInfo.InvariantCulture)}.");
return 2;
}
int Help()
{
Console.WriteLine("""
Comandi di Anubis (ADR 0003):
tasks check ripristino bloccato, formattazione, compilazione, test
tasks test solo i test (motore da ANUBIS_TEST_DB, predefinito sqlite)
tasks dev avvia il server e lo riavvia a ogni modifica
tasks build costruisce l'immagine Docker
tasks ci come la CI: check, test su PostgreSQL, immagine
tasks hooks attiva l'hook che esegue check prima di ogni commit
tasks seed-demo avvia la modalità dimostrativa (dati dell'appendice F, database a parte)
tasks screenshots fotografa le schermate dimostrative a 1440 e 390 pixel
tasks release-win zip di prova per Windows in artifacts/release (ADR 0013)
tasks desktop-win installatore Windows (Fase 10)
""");
return command == "help" ? 0 : 1;
}
// Runs one step and returns its exit code only when it failed, so steps chain with ??.
int? Step(string title, string file, string[] arguments, Dictionary<string, string>? env = null)
{
Console.WriteLine();
Console.WriteLine($"== {title}");
var code = Run(file, arguments, env);
if (code != 0)
{
Console.Error.WriteLine($"!! {title}: non riuscito (codice {code.ToString(CultureInfo.InvariantCulture)})");
return code;
}
return null;
}
int Run(string file, string[] arguments, Dictionary<string, string>? env = null)
{
var info = new ProcessStartInfo(file) { WorkingDirectory = root, UseShellExecute = false };
foreach (var argument in arguments)
{
info.ArgumentList.Add(argument);
}
foreach (var (key, value) in env ?? [])
{
info.Environment[key] = value;
}
try
{
using var process = Process.Start(info)!;
process.WaitForExit();
return process.ExitCode;
}
catch (System.ComponentModel.Win32Exception ex)
{
Console.Error.WriteLine($"Impossibile avviare '{file}': {ex.Message}");
return 127;
}
}
static string FindRoot()
{
for (var dir = new DirectoryInfo(Environment.CurrentDirectory); dir is not null; dir = dir.Parent)
{
if (File.Exists(Path.Combine(dir.FullName, "Anubis.slnx")))
{
return dir.FullName;
}
}
throw new InvalidOperationException("Anubis.slnx non trovato: lancia i comandi dalla cartella del repository.");
}