regen.mde 0.2.2

package/desktop/BuildCorpusEditor/EditorForm.cs

@@ -0,0 +1,540 @@
+using System.Text.Json;
+using System.Drawing.Imaging;
+using Microsoft.Web.WebView2.Core;
+using Microsoft.Web.WebView2.WinForms;
+
+namespace BuildCorpusEditor;
+
+internal sealed class EditorForm : Form
+{
+    private readonly BuildCorpusBridge bridge;
+    private readonly bool smokeUi;
+    private readonly bool background;
+    private readonly string? initialPath;
+    private readonly string smokeLogPath = Path.Combine(Path.GetTempPath(), "regen-mde-smoke.log");
+    private readonly string smokeOutPath = Path.Combine(Path.GetTempPath(), "regen-mde-smoke-output");
+    private readonly WebView2 webView;
+    private readonly JsonSerializerOptions jsonOptions = new(JsonSerializerDefaults.Web);
+
+    public EditorForm(BuildCorpusBridge bridge, bool smokeUi = false, bool background = false)
+    {
+        this.bridge = bridge;
+        this.smokeUi = smokeUi;
+        this.background = background;
+        initialPath = bridge.Startup().InitialPath;
+        Text = "regen.mde";
+        Width = 1280;
+        Height = 860;
+        StartPosition = FormStartPosition.CenterScreen;
+        if (background)
+        {
+            FormBorderStyle = FormBorderStyle.None;
+            ShowInTaskbar = false;
+            StartPosition = FormStartPosition.Manual;
+            Location = new Point(-32000, -32000);
+            Size = new Size(1280, 860);
+            Opacity = 0;
+        }
+        if (smokeUi)
+        {
+            if (Directory.Exists(smokeOutPath)) Directory.Delete(smokeOutPath, recursive: true);
+            Directory.CreateDirectory(smokeOutPath);
+            File.WriteAllText(smokeLogPath, $"[{DateTimeOffset.Now:O}] regen.mde smoke started{Environment.NewLine}");
+            var watchdog = new System.Windows.Forms.Timer { Interval = 60000 };
+            watchdog.Tick += (_, _) =>
+            {
+                LogSmoke("watchdog timeout");
+                Environment.Exit(1);
+            };
+            watchdog.Start();
+        }
+
+        webView = new WebView2 { Dock = DockStyle.Fill };
+        Controls.Add(webView);
+        Load += OnLoad;
+    }
+
+    protected override bool ShowWithoutActivation => background;
+
+    protected override CreateParams CreateParams
+    {
+        get
+        {
+            const int wsExToolWindow = 0x00000080;
+            const int wsExNoActivate = 0x08000000;
+            var cp = base.CreateParams;
+            if (background)
+            {
+                cp.ExStyle |= wsExToolWindow | wsExNoActivate;
+            }
+            return cp;
+        }
+    }
+
+    private async void OnLoad(object? sender, EventArgs e)
+    {
+        try
+        {
+            LogSmoke("OnLoad");
+            var userDataFolder = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                "regen.mde",
+                "WebView2UserData");
+            Directory.CreateDirectory(userDataFolder);
+            var environment = await CoreWebView2Environment.CreateAsync(null, userDataFolder);
+            await webView.EnsureCoreWebView2Async(environment);
+            webView.CoreWebView2.WebMessageReceived += OnWebMessageReceived;
+            webView.CoreWebView2.ProcessFailed += (_, args) =>
+            {
+                LogSmoke($"process failed: {args.ProcessFailedKind}");
+                if (smokeUi) Environment.Exit(1);
+            };
+            if (smokeUi)
+            {
+                await webView.CoreWebView2.AddScriptToExecuteOnDocumentCreatedAsync(
+                    $"window.__REGEN_MDEDITOR_SMOKE_OUT = {JsonSerializer.Serialize(smokeOutPath)}; window.prompt = function(message, value) {{ return String(message || '').includes('Image') ? 'https://example.com/image.png' : 'https://example.com'; }};");
+                webView.CoreWebView2.NavigationCompleted += OnSmokeNavigationCompleted;
+            }
+            var webRoot = Path.Combine(AppContext.BaseDirectory, "wwwroot");
+            LogSmoke($"web root: {webRoot}");
+            webView.CoreWebView2.SetVirtualHostNameToFolderMapping(
+                "build-corpus-editor.local",
+                webRoot,
+                CoreWebView2HostResourceAccessKind.Allow);
+            webView.CoreWebView2.Navigate("https://build-corpus-editor.local/index.html");
+        }
+        catch (Exception ex)
+        {
+            LogSmoke($"OnLoad failed: {ex}");
+            if (smokeUi) Environment.Exit(1);
+            throw;
+        }
+    }
+
+    private async void OnSmokeNavigationCompleted(object? sender, CoreWebView2NavigationCompletedEventArgs e)
+    {
+        try
+        {
+            LogSmoke($"navigation completed: success={e.IsSuccess} status={e.WebErrorStatus}");
+            if (!e.IsSuccess) Environment.Exit(1);
+            await WaitForRenderedContentAsync();
+            LogSmoke("smoke passed");
+            Environment.Exit(0);
+        }
+        catch (Exception ex)
+        {
+            LogSmoke($"smoke failed: {ex}");
+            Environment.Exit(1);
+        }
+    }
+
+    private async Task WaitForRenderedContentAsync()
+    {
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(15);
+        var expected = ExpectedSmokeText();
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            var script = """
+                (() => {
+                  const body = document.body;
+                  const text = body ? body.innerText : "";
+                  const root = document.getElementById("root");
+                  const rect = root ? root.getBoundingClientRect() : { width: 0, height: 0 };
+                  return JSON.stringify({
+                    title: document.title,
+                    text,
+                    rootWidth: rect.width,
+                    rootHeight: rect.height,
+                    error: window.__REGEN_MDEDITOR_ERROR || ""
+                  });
+                })()
+                """;
+            var json = await ExecuteScriptWithTimeoutAsync(script, TimeSpan.FromSeconds(3));
+            var inner = JsonSerializer.Deserialize<string>(json) ?? "{}";
+            var probe = JsonSerializer.Deserialize<SmokeProbe>(inner, jsonOptions);
+            LogSmoke($"probe title='{probe?.Title}' root={probe?.RootWidth}x{probe?.RootHeight} error='{probe?.Error}' text='{TrimForLog(probe?.Text)}'");
+            if (!string.IsNullOrWhiteSpace(probe?.Error))
+            {
+                throw new InvalidOperationException(probe.Error);
+            }
+            if (
+                probe is not null &&
+                probe.Title.Contains("regen.mde", StringComparison.OrdinalIgnoreCase) &&
+                probe.Text.Contains("regen.mde", StringComparison.OrdinalIgnoreCase) &&
+                probe.Text.Contains(expected, StringComparison.OrdinalIgnoreCase) &&
+                probe.RootWidth > 800 &&
+                probe.RootHeight > 500)
+            {
+                LogSmoke("render probe passed");
+                await AssertNonBlankScreenshotAsync();
+                LogSmoke("screenshot probe passed");
+                await AssertEditorControlsWorkAsync();
+                return;
+            }
+            await Task.Delay(250);
+        }
+        throw new TimeoutException("Rendered regen.mde UI did not become visible.");
+    }
+
+    private string ExpectedSmokeText()
+    {
+        if (string.IsNullOrWhiteSpace(initialPath)) return "Open";
+        var name = Path.GetFileNameWithoutExtension(initialPath);
+        return string.IsNullOrWhiteSpace(name) ? "Open" : name;
+    }
+
+    private async Task AssertNonBlankScreenshotAsync()
+    {
+        await using var stream = new MemoryStream();
+        LogSmoke("capturing screenshot");
+        var capture = webView.CoreWebView2.CapturePreviewAsync(CoreWebView2CapturePreviewImageFormat.Png, stream);
+        var completed = await Task.WhenAny(capture, Task.Delay(TimeSpan.FromSeconds(5)));
+        if (completed != capture)
+        {
+            LogSmoke("WebView screenshot capture timed out; trying DrawToBitmap fallback");
+            try
+            {
+                using var fallback = new Bitmap(Math.Max(1, webView.Width), Math.Max(1, webView.Height));
+                webView.DrawToBitmap(fallback, new Rectangle(0, 0, fallback.Width, fallback.Height));
+                AssertBitmapNonBlank(fallback);
+            }
+            catch (Exception ex)
+            {
+                LogSmoke($"DrawToBitmap fallback unavailable: {ex.Message}");
+                await AssertVisibleDomPaintAsync();
+            }
+            return;
+        }
+        await capture;
+        if (stream.Length < 4096) throw new InvalidOperationException("WebView screenshot was too small.");
+        stream.Position = 0;
+        using var bitmap = new Bitmap(stream);
+        AssertBitmapNonBlank(bitmap);
+    }
+
+    private static void AssertBitmapNonBlank(Bitmap bitmap)
+    {
+        var first = bitmap.GetPixel(0, 0).ToArgb();
+        var different = 0;
+        for (var x = 0; x < bitmap.Width; x += Math.Max(1, bitmap.Width / 12))
+        {
+            for (var y = 0; y < bitmap.Height; y += Math.Max(1, bitmap.Height / 12))
+            {
+                if (bitmap.GetPixel(x, y).ToArgb() != first) different++;
+            }
+        }
+        if (different < 5) throw new InvalidOperationException("WebView screenshot appears blank.");
+    }
+
+    private async Task AssertVisibleDomPaintAsync()
+    {
+        var script = """
+            (() => {
+              const visible = [...document.querySelectorAll("main, header, aside, section, article, button, textarea, .page, .canvas-wrap")]
+                .map((element) => {
+                  const style = getComputedStyle(element);
+                  const rect = element.getBoundingClientRect();
+                  return {
+                    tag: element.tagName,
+                    text: (element.textContent || "").trim().slice(0, 80),
+                    width: rect.width,
+                    height: rect.height,
+                    display: style.display,
+                    visibility: style.visibility,
+                    opacity: Number(style.opacity),
+                    bg: style.backgroundColor,
+                    color: style.color
+                  };
+                })
+                .filter((item) =>
+                  item.width > 8 &&
+                  item.height > 8 &&
+                  item.display !== "none" &&
+                  item.visibility !== "hidden" &&
+                  item.opacity > 0.05
+                );
+              const colors = new Set(visible.flatMap((item) => [item.bg, item.color]).filter(Boolean));
+              return JSON.stringify({
+                count: visible.length,
+                colors: colors.size,
+                text: document.body.innerText || ""
+              });
+            })()
+            """;
+        var json = await ExecuteScriptWithTimeoutAsync(script, TimeSpan.FromSeconds(3));
+        var inner = JsonSerializer.Deserialize<string>(json) ?? "{}";
+        var probe = JsonSerializer.Deserialize<DomPaintProbe>(inner, jsonOptions);
+        LogSmoke($"dom paint count={probe?.Count} colors={probe?.Colors}");
+        if (probe is null || probe.Count < 16 || probe.Colors < 4 || !probe.Text.Contains("regen.mde", StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException("DOM paint probe suggests the UI is blank or hidden.");
+        }
+    }
+
+    private async Task AssertEditorControlsWorkAsync()
+    {
+        var markdownOutput = Path.Combine(smokeOutPath, "ui-save-as-markdown.md");
+        var wordOutput = Path.Combine(smokeOutPath, "ui-save-as-word.docx");
+
+        await AssertControlStepAsync("required controls", """
+            (() => {
+              const requiredLabels = ["Open", "Save MD", "Save MD As...", "Export Word...", "Run Check", "Preview", "Compare", "Markdown", "Undo", "Redo", "Link", "Table", "Image"];
+              const text = document.body.innerText || "";
+              for (const label of requiredLabels) {
+                if (!text.includes(label)) throw new Error(`Missing control label: ${label}`);
+              }
+              return "controls present";
+            })()
+            """);
+
+        await ClickButtonAsync("Markdown");
+        await Task.Delay(250);
+        await AssertControlStepAsync("edit markdown", """
+            (() => {
+              const textarea = document.querySelector("textarea.source");
+              if (!textarea) throw new Error("Markdown textarea was not visible.");
+              if (!window.__REGEN_MDEDITOR_SMOKE_API) throw new Error("Smoke editor API was not registered.");
+              return window.__REGEN_MDEDITOR_SMOKE_API.appendMarkdown("\n\nUI functional edit marker");
+            })()
+            """);
+        await Task.Delay(250);
+        await AssertControlStepAsync("markdown marker present", """
+            (() => {
+              const textarea = document.querySelector("textarea.source");
+              if (!textarea || !textarea.value.includes("UI functional edit marker")) throw new Error("Edited Markdown marker was not visible in the textarea.");
+              return "marker present";
+            })()
+            """);
+
+        await ClickButtonAsync("Save MD");
+        await WaitForBodyTextAsync("Saved Markdown ", "Save MD did not update status.");
+
+        await AssertControlStepAsync("edit markdown for save as", """
+            (() => {
+              const textarea = document.querySelector("textarea.source");
+              if (!textarea) throw new Error("Markdown textarea was not visible.");
+              if (!window.__REGEN_MDEDITOR_SMOKE_API) throw new Error("Smoke editor API was not registered.");
+              return window.__REGEN_MDEDITOR_SMOKE_API.appendMarkdown("\n\nUI save-as edit marker");
+            })()
+            """);
+        await Task.Delay(250);
+        await AssertControlStepAsync("save-as marker present", """
+            (() => {
+              const textarea = document.querySelector("textarea.source");
+              if (!textarea || !textarea.value.includes("UI save-as edit marker")) throw new Error("Save-as Markdown marker was not visible in the textarea.");
+              return "marker present";
+            })()
+            """);
+
+        await ClickButtonAsync("Save MD As...");
+        await WaitForBodyTextAsync("Saved Markdown ", "Save MD As did not update status.");
+        await WaitForFileContainsAsync(markdownOutput, "UI save-as edit marker", "Save MD As did not write the smoke Markdown output.");
+
+        await ClickButtonAsync("Export Word...");
+        await WaitForBodyTextAsync("Exported Word ", "Export Word did not update status.");
+        await WaitForFileExistsAsync(wordOutput, "Export Word did not write the smoke DOCX output.");
+
+        await ClickButtonAsync("Compare");
+        await Task.Delay(250);
+        await ClickButtonAsync("Preview");
+        await Task.Delay(250);
+        await ClickButtonAsync("Markdown");
+        await Task.Delay(250);
+        await ClickButtonAsync("Run Check");
+        await WaitForBodyTextAsync("Checked ", "Run Check did not update status.");
+
+        await AssertControlStepAsync("layout still usable", """
+            (() => {
+              const modeStrip = document.querySelector(".mode-strip");
+              if (!modeStrip) throw new Error("Mode strip missing.");
+              const canvas = document.querySelector(".canvas-wrap");
+              if (!canvas || canvas.getBoundingClientRect().width < 300) {
+                throw new Error("Editor canvas did not render with usable width.");
+              }
+              return [...document.querySelectorAll(".statusbar span")].map((node) => node.textContent).join(" | ");
+            })()
+            """);
+
+        if (!File.Exists(markdownOutput) || !File.ReadAllText(markdownOutput).Contains("UI save-as edit marker", StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException("Save MD As did not write the smoke Markdown output.");
+        }
+        if (!File.Exists(wordOutput) || new FileInfo(wordOutput).Length == 0)
+        {
+            throw new InvalidOperationException("Export Word did not write the smoke DOCX output.");
+        }
+    }
+
+    private static async Task WaitForFileContainsAsync(string path, string expected, string failure)
+    {
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(10);
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            if (File.Exists(path) && File.ReadAllText(path).Contains(expected, StringComparison.Ordinal)) return;
+            await Task.Delay(250);
+        }
+        throw new InvalidOperationException(failure);
+    }
+
+    private static async Task WaitForFileExistsAsync(string path, string failure)
+    {
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(15);
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            if (File.Exists(path) && new FileInfo(path).Length > 0) return;
+            await Task.Delay(250);
+        }
+        throw new InvalidOperationException(failure);
+    }
+
+    private async Task ClickButtonAsync(string label)
+    {
+        await AssertControlStepAsync($"click {label}", $$"""
+            (() => {
+              const label = {{JsonSerializer.Serialize(label)}};
+              const button = [...document.querySelectorAll("button")]
+                .find((candidate) => candidate.textContent.trim() === label);
+              if (!button) throw new Error(`Missing button: ${label}`);
+              if (button.disabled) throw new Error(`Button is disabled: ${label}`);
+              setTimeout(() => button.click(), 0);
+              return `scheduled click ${label}`;
+            })()
+            """);
+    }
+
+    private async Task WaitForBodyTextAsync(string expected, string failure)
+    {
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(8);
+        while (DateTimeOffset.UtcNow < deadline)
+        {
+            var contains = await AssertControlStepAsync($"wait for {expected}", $$"""
+                (() => (document.body.innerText || "").includes({{JsonSerializer.Serialize(expected)}}))()
+                """);
+            if (contains == "true") return;
+            await Task.Delay(250);
+        }
+        throw new InvalidOperationException(failure);
+    }
+
+    private async Task<string> AssertControlStepAsync(string name, string script)
+    {
+        try
+        {
+            var wrapped = $$"""
+                (() => {
+                  try {
+                    const value = ({{script}});
+                    return JSON.stringify({ ok: true, value: String(value) });
+                  } catch (error) {
+                    return JSON.stringify({ ok: false, error: error && error.message ? error.message : String(error) });
+                  }
+                })()
+                """;
+            var json = await ExecuteScriptWithTimeoutAsync(wrapped, TimeSpan.FromSeconds(5));
+            var inner = JsonSerializer.Deserialize<string>(json) ?? "{}";
+            var result = JsonSerializer.Deserialize<ControlStepProbe>(inner, jsonOptions);
+            if (result is null || !result.Ok)
+            {
+                throw new InvalidOperationException(result?.Error ?? "script returned no result");
+            }
+            var value = result.Value;
+            LogSmoke($"control {name}: {TrimForLog(value)}");
+            return value;
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Control step failed ({name}): {ex.Message}", ex);
+        }
+    }
+
+    private async Task<string> ExecuteScriptWithTimeoutAsync(string script, TimeSpan timeout)
+    {
+        var task = webView.CoreWebView2.ExecuteScriptAsync(script);
+        var completed = await Task.WhenAny(task, Task.Delay(timeout));
+        if (completed != task)
+        {
+            throw new TimeoutException("WebView script probe timed out.");
+        }
+        return await task;
+    }
+
+    private async void OnWebMessageReceived(object? sender, CoreWebView2WebMessageReceivedEventArgs e)
+    {
+        BridgeRequest? request = null;
+        try
+        {
+            request = JsonSerializer.Deserialize<BridgeRequest>(e.WebMessageAsJson, jsonOptions);
+            if (request is null) throw new InvalidOperationException("Invalid bridge request.");
+            var result = await DispatchAsync(request);
+            await RespondAsync(request.Id, true, result, null);
+        }
+        catch (Exception ex)
+        {
+            await RespondAsync(request?.Id ?? 0, false, null, ex.Message);
+        }
+    }
+
+    private async Task<object?> DispatchAsync(BridgeRequest request)
+    {
+        var p = request.Params;
+        return request.Method switch
+        {
+            "startup" => bridge.Startup(),
+            "chooseOpen" => bridge.ChooseOpen(),
+            "chooseImage" => await bridge.ChooseImageAsync(),
+            "open" => await bridge.OpenAsync(p.GetStringProperty("path")),
+            "save" => bridge.Save(p.GetStringProperty("path"), p.GetStringProperty("content") ?? ""),
+            "saveAs" => await bridge.SaveAsAsync(
+                p.GetStringProperty("suggestedPath"),
+                p.GetStringProperty("format") ?? "markdown",
+                p.GetStringProperty("content") ?? ""),
+            "saveAsDirect" => await bridge.SaveAsDirectAsync(
+                p.GetStringProperty("targetPath"),
+                p.GetStringProperty("format") ?? "markdown",
+                p.GetStringProperty("content") ?? ""),
+            _ => throw new InvalidOperationException($"Unknown bridge method: {request.Method}"),
+        };
+    }
+
+    private async Task RespondAsync(int id, bool ok, object? result, string? error)
+    {
+        var response = JsonSerializer.Serialize(new { id, ok, result, error }, jsonOptions);
+        webView.CoreWebView2.PostWebMessageAsJson(response);
+        await Task.CompletedTask;
+    }
+
+    private void LogSmoke(string message)
+    {
+        if (!smokeUi) return;
+        try
+        {
+            File.AppendAllText(smokeLogPath, $"[{DateTimeOffset.Now:O}] {message}{Environment.NewLine}");
+        }
+        catch
+        {
+        }
+    }
+
+    private static string TrimForLog(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text)) return "";
+        var normalized = text.Replace("\r", " ").Replace("\n", " ");
+        return normalized.Length > 240 ? normalized[..240] : normalized;
+    }
+}
+
+internal sealed record BridgeRequest(int Id, string Method, JsonElement Params);
+internal sealed record SmokeProbe(string Title, string Text, double RootWidth, double RootHeight, string Error);
+internal sealed record DomPaintProbe(int Count, int Colors, string Text);
+internal sealed record ControlStepProbe(bool Ok, string Value, string Error);
+
+internal static class JsonElementExtensions
+{
+    public static string? GetStringProperty(this JsonElement element, string name)
+    {
+        if (element.ValueKind != JsonValueKind.Object) return null;
+        return element.TryGetProperty(name, out var property) && property.ValueKind != JsonValueKind.Null
+            ? property.GetString()
+            : null;
+    }
+}

package/desktop/BuildCorpusEditor/Program.cs

@@ -0,0 +1,81 @@
+using BuildCorpusEditor;
+
+internal static class Program
+{
+    [STAThread]
+    private static void Main(string[] args)
+    {
+        ApplicationConfiguration.Initialize();
+        Application.SetHighDpiMode(HighDpiMode.SystemAware);
+
+        var initialPath = args.FirstOrDefault(arg => !arg.StartsWith("--", StringComparison.Ordinal));
+        var selfTest = args.Any(arg => arg.Equals("--self-test", StringComparison.OrdinalIgnoreCase));
+        var documentSelfTest = args.Any(arg => arg.Equals("--document-self-test", StringComparison.OrdinalIgnoreCase));
+        var smokeUi = args.Any(arg => arg.Equals("--smoke-ui", StringComparison.OrdinalIgnoreCase));
+        var background = smokeUi || args.Any(arg => arg.Equals("--background", StringComparison.OrdinalIgnoreCase));
+        var outputDir = GetOptionValue(args, "--out");
+
+        if (selfTest)
+        {
+            Environment.Exit(RunBridgeSelfTest(initialPath));
+            return;
+        }
+
+        if (documentSelfTest)
+        {
+            Environment.Exit(RunDocumentSelfTest(initialPath, outputDir));
+            return;
+        }
+
+        var bridge = new BuildCorpusBridge(initialPath);
+        using var form = new EditorForm(bridge, smokeUi, background);
+        Application.Run(form);
+    }
+
+    private static int RunBridgeSelfTest(string? initialPath)
+    {
+        try
+        {
+            var bridge = new BuildCorpusBridge(initialPath);
+            var startup = bridge.Startup();
+            if (!string.IsNullOrWhiteSpace(startup.InitialPath))
+            {
+                var opened = bridge.OpenAsync(startup.InitialPath).GetAwaiter().GetResult();
+                if (string.IsNullOrWhiteSpace(opened.Content))
+                {
+                    throw new InvalidOperationException("Self-test opened an empty document.");
+                }
+            }
+            return 0;
+        }
+        catch
+        {
+            return 1;
+        }
+    }
+
+    private static int RunDocumentSelfTest(string? initialPath, string? outputDir)
+    {
+        try
+        {
+            var bridge = new BuildCorpusBridge(initialPath);
+            var result = bridge.RunDocumentSelfTestAsync(initialPath, outputDir).GetAwaiter().GetResult();
+            Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(result));
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine(ex.Message);
+            return 1;
+        }
+    }
+
+    private static string? GetOptionValue(string[] args, string name)
+    {
+        for (var i = 0; i < args.Length - 1; i++)
+        {
+            if (args[i].Equals(name, StringComparison.OrdinalIgnoreCase)) return args[i + 1];
+        }
+        return null;
+    }
+}

package/desktop/BuildCorpusEditor/app.manifest

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="LifeAI.BuildCorpusEditor.app"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+</assembly>