regen.mde 0.2.2 → 0.7.0

package/desktop/BuildCorpusEditor/BuildCorpusBridge.cs

@@ -1,270 +1,493 @@
-using System.Diagnostics;
-using System.Text.Json;
-
-namespace BuildCorpusEditor;
-
-internal sealed class BuildCorpusBridge
-{
-    private readonly string? initialPath;
-    private readonly string root;
-    private readonly string sessionRoot;
-
-    public BuildCorpusBridge(string? initialPath)
-    {
-        this.initialPath = string.IsNullOrWhiteSpace(initialPath) ? null : Path.GetFullPath(initialPath);
-        root = LocateRoot();
-        sessionRoot = Path.Combine(Path.GetTempPath(), "build-corpus-editor");
-        Directory.CreateDirectory(sessionRoot);
-    }
-
-    public StartupResult Startup() => new(initialPath);
-
-    public object? ChooseOpen()
-    {
-        using var dialog = new OpenFileDialog
-        {
-            Title = "Open Markdown, Word, or PowerPoint",
-            Filter = "Supported documents|*.md;*.markdown;*.docx;*.pptx;*.ppt|Markdown|*.md;*.markdown|Word|*.docx|PowerPoint|*.pptx;*.ppt|All files|*.*",
-            CheckFileExists = true,
-        };
-        return dialog.ShowDialog() == DialogResult.OK ? new { path = dialog.FileName } : new { path = "" };
-    }
-
-    public async Task<object?> ChooseImageAsync()
-    {
-        using var dialog = new OpenFileDialog
-        {
-            Title = "Insert Image",
-            Filter = "Images|*.png;*.jpg;*.jpeg;*.gif;*.webp;*.bmp|All files|*.*",
-            CheckFileExists = true,
-        };
-        if (dialog.ShowDialog() != DialogResult.OK) return new { src = "", alt = "" };
-
-        var bytes = await File.ReadAllBytesAsync(dialog.FileName);
-        var extension = Path.GetExtension(dialog.FileName).ToLowerInvariant();
-        var mime = extension switch
-        {
-            ".jpg" or ".jpeg" => "image/jpeg",
-            ".gif" => "image/gif",
-            ".webp" => "image/webp",
-            ".bmp" => "image/bmp",
-            _ => "image/png",
-        };
-        return new
-        {
-            src = $"data:{mime};base64,{Convert.ToBase64String(bytes)}",
-            alt = Path.GetFileNameWithoutExtension(dialog.FileName),
-        };
-    }
-
-    public async Task<OpenResult> OpenAsync(string? path)
-    {
-        var source = RequirePath(path);
-        if (!File.Exists(source)) throw new FileNotFoundException("File not found.", source);
-        var ext = Path.GetExtension(source).ToLowerInvariant();
-        if (ext is ".md" or ".markdown")
-        {
-            return new OpenResult(source, source, "markdown", await File.ReadAllTextAsync(source));
-        }
-
-        if (ext is not ".docx" and not ".pptx" and not ".ppt")
-        {
-            throw new InvalidOperationException($"Unsupported file type: {ext}");
-        }
-
-        var outDir = Path.Combine(sessionRoot, Path.GetFileNameWithoutExtension(source) + "-" + Guid.NewGuid().ToString("N")[..8]);
-        Directory.CreateDirectory(outDir);
-        var report = RunBuildCorpus(source, "--out", outDir);
-        var output = report.RootElement.GetProperty("outputs")[0].GetString();
-        if (string.IsNullOrWhiteSpace(output) || !File.Exists(output))
-        {
-            throw new InvalidOperationException("Build Corpus did not produce a Markdown file.");
-        }
-        return new OpenResult(source, output, ext.TrimStart('.'), await File.ReadAllTextAsync(output));
-    }
-
-    public SaveResult Save(string? path, string content)
-    {
-        var target = RequirePath(path);
-        if (Path.GetExtension(target).ToLowerInvariant() is not ".md" and not ".markdown")
-        {
-            target = Path.ChangeExtension(target, ".md");
-        }
-        Directory.CreateDirectory(Path.GetDirectoryName(target)!);
-        File.WriteAllText(target, content);
-        return new SaveResult(target);
-    }
-
-    public async Task<DocumentSelfTestResult> RunDocumentSelfTestAsync(string? inputPath, string? outputDir)
-    {
-        var source = RequirePath(inputPath);
-        var destination = string.IsNullOrWhiteSpace(outputDir)
-            ? Path.Combine(sessionRoot, "document-self-test-" + Guid.NewGuid().ToString("N")[..8])
-            : Path.GetFullPath(outputDir);
-        Directory.CreateDirectory(destination);
-
-        var opened = await OpenAsync(source);
-        if (string.IsNullOrWhiteSpace(opened.Content))
-        {
-            throw new InvalidOperationException("Opened document was empty.");
-        }
-
-        var marker = $"regen.mde functional edit {DateTimeOffset.UtcNow:yyyyMMddHHmmss}";
-        var edited = opened.Content.TrimEnd() + Environment.NewLine + Environment.NewLine + marker + Environment.NewLine;
-        var savedMarkdown = Path.Combine(destination, Path.GetFileNameWithoutExtension(source) + ".edited.md");
-        var save = Save(savedMarkdown, edited);
-        if (!File.ReadAllText(save.Output).Contains(marker, StringComparison.Ordinal))
-        {
-            throw new InvalidOperationException("Saved Markdown did not contain the edit marker.");
-        }
-
-        var exportedWord = Path.Combine(destination, Path.GetFileNameWithoutExtension(source) + ".edited.docx");
-        await ExportWordAsync(exportedWord, edited);
-        if (!File.Exists(exportedWord) || new FileInfo(exportedWord).Length == 0)
-        {
-            throw new InvalidOperationException("Word export was missing or empty.");
-        }
-
-        var reconvertDir = Path.Combine(destination, "reconverted");
-        Directory.CreateDirectory(reconvertDir);
-        var report = RunBuildCorpus(exportedWord, "--out", reconvertDir);
-        var reconvertedMarkdown = report.RootElement.GetProperty("outputs")[0].GetString();
-        if (string.IsNullOrWhiteSpace(reconvertedMarkdown) || !File.Exists(reconvertedMarkdown))
-        {
-            throw new InvalidOperationException("Exported Word document did not reconvert to Markdown.");
-        }
-
-        var reconvertedText = await File.ReadAllTextAsync(reconvertedMarkdown);
-        if (!reconvertedText.Contains("regen.mde functional edit", StringComparison.Ordinal))
-        {
-            throw new InvalidOperationException("Reconverted Markdown did not contain the edit marker.");
-        }
-
-        return new DocumentSelfTestResult(
-            source,
-            opened.WorkingPath,
-            save.Output,
-            exportedWord,
-            reconvertedMarkdown,
-            marker);
-    }
-
-    public async Task<SaveResult?> SaveAsAsync(string? suggestedPath, string format, string content)
-    {
-        using var dialog = new SaveFileDialog
-        {
-            Title = format == "word" ? "Export Word Document" : "Save Markdown",
-            Filter = format == "word" ? "Word document|*.docx" : "Markdown|*.md",
-            FileName = SuggestedFileName(suggestedPath, format == "word" ? ".docx" : ".md"),
-            AddExtension = true,
-            OverwritePrompt = true,
-        };
-        if (dialog.ShowDialog() != DialogResult.OK) return null;
-
-        if (format == "word")
-        {
-            return new SaveResult(await ExportWordAsync(dialog.FileName, content));
-        }
-        File.WriteAllText(dialog.FileName, content);
-        return new SaveResult(dialog.FileName);
-    }
-
-    public async Task<SaveResult> SaveAsDirectAsync(string? targetPath, string format, string content)
-    {
-        var target = RequirePath(targetPath);
-        Directory.CreateDirectory(Path.GetDirectoryName(target)!);
-        if (format == "word")
-        {
-            return new SaveResult(await ExportWordAsync(target, content));
-        }
-        if (Path.GetExtension(target).ToLowerInvariant() is not ".md" and not ".markdown")
-        {
-            target = Path.ChangeExtension(target, ".md");
-        }
-        await File.WriteAllTextAsync(target, content);
-        return new SaveResult(target);
-    }
-
-    private async Task<string> ExportWordAsync(string targetPath, string content)
-    {
-        var tmp = Path.Combine(sessionRoot, "export-" + Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(tmp);
-        var md = Path.Combine(tmp, Path.GetFileNameWithoutExtension(targetPath) + ".md");
-        await File.WriteAllTextAsync(md, content);
-        RunBuildCorpus(md, "--to", "word", "--out-same-dir");
-        var generated = Path.ChangeExtension(md, ".docx");
-        File.Copy(generated, targetPath, overwrite: true);
-        return targetPath;
-    }
-
-    private JsonDocument RunBuildCorpus(params string[] args)
-    {
-        var psi = new ProcessStartInfo
-        {
-            FileName = "node",
-            WorkingDirectory = root,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-        };
-        psi.ArgumentList.Add(Path.Combine(root, "bin", "build-corpus.js"));
-        foreach (var arg in args) psi.ArgumentList.Add(arg);
-        psi.Environment["PYTHONPATH"] = Path.Combine(root, "src");
-
-        using var process = Process.Start(psi) ?? throw new InvalidOperationException("Could not start build-corpus.");
-        var stdout = process.StandardOutput.ReadToEnd();
-        var stderr = process.StandardError.ReadToEnd();
-        process.WaitForExit();
-        if (process.ExitCode != 0)
-        {
-            throw new InvalidOperationException(stderr.Length > 0 ? stderr : stdout);
-        }
-
-        var start = stdout.IndexOf('{');
-        var end = stdout.LastIndexOf('}');
-        if (start < 0 || end < start) throw new InvalidOperationException("Build Corpus did not return JSON.");
-        return JsonDocument.Parse(stdout[start..(end + 1)]);
-    }
-
-    private static string RequirePath(string? path)
-    {
-        if (string.IsNullOrWhiteSpace(path)) throw new InvalidOperationException("Missing path.");
-        return Path.GetFullPath(path);
-    }
-
-    private static string SuggestedFileName(string? path, string extension)
-    {
-        if (string.IsNullOrWhiteSpace(path)) return "document" + extension;
-        return Path.ChangeExtension(Path.GetFileName(path), extension);
-    }
-
-    private static string LocateRoot()
-    {
-        var env = Environment.GetEnvironmentVariable("BUILD_CORPUS_ROOT");
-        if (!string.IsNullOrWhiteSpace(env) && File.Exists(Path.Combine(env, "bin", "build-corpus.js")))
-        {
-            return Path.GetFullPath(env);
-        }
-
-        var current = AppContext.BaseDirectory;
-        while (!string.IsNullOrWhiteSpace(current))
-        {
-            if (File.Exists(Path.Combine(current, "bin", "build-corpus.js"))) return current;
-            var parent = Directory.GetParent(current)?.FullName;
-            if (parent == current) break;
-            current = parent ?? "";
-        }
-        return Directory.GetCurrentDirectory();
-    }
-}
-
-internal sealed record StartupResult(string? InitialPath);
-internal sealed record OpenResult(string SourcePath, string WorkingPath, string OriginalFormat, string Content);
-internal sealed record SaveResult(string Output);
-internal sealed record DocumentSelfTestResult(
-    string SourcePath,
-    string WorkingPath,
-    string SavedMarkdown,
-    string ExportedWord,
-    string ReconvertedMarkdown,
-    string Marker);
+using System.Diagnostics;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+namespace BuildCorpusEditor;
+
+internal sealed class BuildCorpusBridge
+{
+    private readonly string? initialPath;
+    private readonly string root;
+    private readonly string sessionRoot;
+    private readonly bool composeMode;
+    private readonly string? paneId;
+    private readonly string composeDropDir;
+
+    public BuildCorpusBridge(string? initialPath, bool composeMode = false, string? paneId = null)
+    {
+        this.initialPath = string.IsNullOrWhiteSpace(initialPath) ? null : Path.GetFullPath(initialPath);
+        this.composeMode = composeMode;
+        this.paneId = string.IsNullOrWhiteSpace(paneId) ? null : paneId.Trim();
+        root = LocateRoot();
+        sessionRoot = Path.Combine(Path.GetTempPath(), "build-corpus-editor");
+        Directory.CreateDirectory(sessionRoot);
+        composeDropDir = Path.Combine(
+            Path.GetTempPath(),
+            "regen-mde-compose",
+            DateTimeOffset.UtcNow.ToString("yyyyMMdd-HHmmss") + "-" + Guid.NewGuid().ToString("N")[..8]);
+    }
+
+    public StartupResult Startup() => new(initialPath, composeMode, paneId);
+
+    public ComposeInfoResult ComposeInfo() => new(composeMode, paneId, composeDropDir);
+
+    // Save a dropped file (image or any file) to the per-session compose temp folder
+    // and return the absolute local path so the caller can insert it as plain text.
+    // This is the workaround for not being able to drag-drop images into a terminal TUI.
+    public DroppedFileResult SaveDroppedFile(string fileName, string? mimeType, string base64Data)
+    {
+        Directory.CreateDirectory(composeDropDir);
+        var safeName = MakeSafeFileName(fileName);
+        var target = Path.Combine(composeDropDir, safeName);
+        // De-duplicate if a file with the same name already exists this session.
+        if (File.Exists(target))
+        {
+            var stem = Path.GetFileNameWithoutExtension(safeName);
+            var ext = Path.GetExtension(safeName);
+            target = Path.Combine(composeDropDir, $"{stem}-{Guid.NewGuid().ToString("N")[..6]}{ext}");
+        }
+        var bytes = Convert.FromBase64String(StripDataUriPrefix(base64Data));
+        File.WriteAllBytes(target, bytes);
+        var isImage = (mimeType ?? "").StartsWith("image/", StringComparison.OrdinalIgnoreCase)
+            || Path.GetExtension(target).ToLowerInvariant() is ".png" or ".jpg" or ".jpeg" or ".gif" or ".webp" or ".bmp" or ".svg";
+        return new DroppedFileResult(target, isImage, bytes.LongLength);
+    }
+
+    // Write the composed plain-text to a temp file and bracket-paste it into the
+    // captured WezTerm pane via `wezterm cli send-text`. Does NOT press Enter —
+    // the user reviews and submits in the terminal.
+    public SendToPaneResult SendToPane(string content, string? overridePaneId)
+    {
+        var targetPane = string.IsNullOrWhiteSpace(overridePaneId) ? paneId : overridePaneId.Trim();
+        if (string.IsNullOrWhiteSpace(targetPane))
+        {
+            throw new InvalidOperationException("No WezTerm pane id was provided; cannot send text.");
+        }
+
+        Directory.CreateDirectory(composeDropDir);
+        var stampPath = Path.Combine(composeDropDir, $"prompt-{DateTimeOffset.UtcNow:HHmmss}-{Guid.NewGuid().ToString("N")[..6]}.txt");
+        // Persist exactly what we send, as plain UTF-8 (no BOM), for audit/recovery.
+        File.WriteAllText(stampPath, content ?? "", new System.Text.UTF8Encoding(false));
+
+        var wezterm = LocateWezTerm();
+        var psi = new ProcessStartInfo
+        {
+            FileName = wezterm,
+            RedirectStandardInput = true,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            StandardInputEncoding = new System.Text.UTF8Encoding(false),
+        };
+        psi.ArgumentList.Add("cli");
+        psi.ArgumentList.Add("send-text");
+        // --no-paste would send raw; default uses bracketed paste when the app
+        // has it enabled, letting the TUI treat it as a single pasted block.
+        psi.ArgumentList.Add("--pane-id");
+        psi.ArgumentList.Add(targetPane);
+
+        using var process = Process.Start(psi) ?? throw new InvalidOperationException("Could not start wezterm CLI.");
+        process.StandardInput.Write(content ?? "");
+        process.StandardInput.Close();
+        var stderr = process.StandardError.ReadToEnd();
+        process.WaitForExit();
+        if (process.ExitCode != 0)
+        {
+            throw new InvalidOperationException(
+                string.IsNullOrWhiteSpace(stderr) ? $"wezterm send-text exited {process.ExitCode}" : stderr.Trim());
+        }
+        return new SendToPaneResult(targetPane, stampPath, (content ?? "").Length);
+    }
+
+    private static string MakeSafeFileName(string? name)
+    {
+        var parsed = string.IsNullOrWhiteSpace(name) ? "drop.bin" : Path.GetFileName(name);
+        var stem = Path.GetFileNameWithoutExtension(parsed);
+        var ext = Path.GetExtension(parsed);
+        var invalid = Path.GetInvalidFileNameChars();
+        stem = new string((stem ?? "drop").Where(c => !invalid.Contains(c)).ToArray());
+        if (stem.Length == 0) stem = "drop";
+        if (stem.Length > 80) stem = stem[..80];
+        ext = new string((ext ?? "").Where(c => !invalid.Contains(c)).ToArray());
+        return stem + ext;
+    }
+
+    private static string StripDataUriPrefix(string data)
+    {
+        if (string.IsNullOrEmpty(data)) return "";
+        var comma = data.IndexOf(',');
+        if (data.StartsWith("data:", StringComparison.OrdinalIgnoreCase) && comma >= 0)
+        {
+            return data[(comma + 1)..];
+        }
+        return data;
+    }
+
+    private static string LocateWezTerm()
+    {
+        var env = Environment.GetEnvironmentVariable("WEZTERM_EXECUTABLE");
+        if (!string.IsNullOrWhiteSpace(env) && File.Exists(env)) return env;
+        var candidates = new[]
+        {
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "WezTerm", "wezterm.exe"),
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "WezTerm", "wezterm.exe"),
+        };
+        foreach (var candidate in candidates)
+        {
+            if (File.Exists(candidate)) return candidate;
+        }
+        // Fall back to PATH resolution.
+        return "wezterm.exe";
+    }
+
+    public object? ChooseOpen()
+    {
+        using var dialog = new OpenFileDialog
+        {
+            Title = "Open Markdown, Word, or PowerPoint",
+            Filter = "Supported documents|*.md;*.markdown;*.docx;*.pptx;*.ppt|Markdown|*.md;*.markdown|Word|*.docx|PowerPoint|*.pptx;*.ppt|All files|*.*",
+            CheckFileExists = true,
+        };
+        return dialog.ShowDialog() == DialogResult.OK ? new { path = dialog.FileName } : new { path = "" };
+    }
+
+    public object? ChooseFolder()
+    {
+        using var dialog = new FolderBrowserDialog
+        {
+            Description = "Choose a folder of Word or PowerPoint files",
+            UseDescriptionForTitle = true,
+            ShowNewFolderButton = false,
+        };
+        return dialog.ShowDialog() == DialogResult.OK ? new { path = dialog.SelectedPath } : new { path = "" };
+    }
+
+    public async Task<object?> ChooseImageAsync()
+    {
+        using var dialog = new OpenFileDialog
+        {
+            Title = "Insert Image",
+            Filter = "Images|*.png;*.jpg;*.jpeg;*.gif;*.webp;*.bmp|All files|*.*",
+            CheckFileExists = true,
+        };
+        if (dialog.ShowDialog() != DialogResult.OK) return new { src = "", alt = "" };
+
+        var bytes = await File.ReadAllBytesAsync(dialog.FileName);
+        var extension = Path.GetExtension(dialog.FileName).ToLowerInvariant();
+        var mime = extension switch
+        {
+            ".jpg" or ".jpeg" => "image/jpeg",
+            ".gif" => "image/gif",
+            ".webp" => "image/webp",
+            ".bmp" => "image/bmp",
+            _ => "image/png",
+        };
+        return new
+        {
+            src = $"data:{mime};base64,{Convert.ToBase64String(bytes)}",
+            alt = Path.GetFileNameWithoutExtension(dialog.FileName),
+        };
+    }
+
+    public async Task<OpenResult> OpenAsync(string? path)
+    {
+        var source = RequirePath(path);
+        if (!File.Exists(source)) throw new FileNotFoundException("File not found.", source);
+        var ext = Path.GetExtension(source).ToLowerInvariant();
+        if (ext is ".md" or ".markdown")
+        {
+            return new OpenResult(source, source, "markdown", await File.ReadAllTextAsync(source));
+        }
+
+        if (ext is not ".docx" and not ".pptx" and not ".ppt")
+        {
+            throw new InvalidOperationException($"Unsupported file type: {ext}");
+        }
+
+        var outDir = Path.Combine(sessionRoot, Path.GetFileNameWithoutExtension(source) + "-" + Guid.NewGuid().ToString("N")[..8]);
+        Directory.CreateDirectory(outDir);
+        var report = RunBuildCorpus(source, "--out", outDir);
+        var output = report.RootElement.GetProperty("outputs")[0].GetString();
+        if (string.IsNullOrWhiteSpace(output) || !File.Exists(output))
+        {
+            throw new InvalidOperationException("Build Corpus did not produce a Markdown file.");
+        }
+        return new OpenResult(source, output, ext.TrimStart('.'), await File.ReadAllTextAsync(output));
+    }
+
+    public SaveResult Save(string? path, string content)
+    {
+        var target = RequirePath(path);
+        if (Path.GetExtension(target).ToLowerInvariant() is not ".md" and not ".markdown")
+        {
+            target = Path.ChangeExtension(target, ".md");
+        }
+        Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+        File.WriteAllText(target, content);
+        return new SaveResult(target);
+    }
+
+    public async Task<DocumentSelfTestResult> RunDocumentSelfTestAsync(string? inputPath, string? outputDir)
+    {
+        var source = RequirePath(inputPath);
+        var destination = string.IsNullOrWhiteSpace(outputDir)
+            ? Path.Combine(sessionRoot, "document-self-test-" + Guid.NewGuid().ToString("N")[..8])
+            : Path.GetFullPath(outputDir);
+        Directory.CreateDirectory(destination);
+
+        var opened = await OpenAsync(source);
+        if (string.IsNullOrWhiteSpace(opened.Content))
+        {
+            throw new InvalidOperationException("Opened document was empty.");
+        }
+
+        var marker = $"regen-mde functional edit {DateTimeOffset.UtcNow:yyyyMMddHHmmss}";
+        var edited = opened.Content.TrimEnd() + Environment.NewLine + Environment.NewLine + marker + Environment.NewLine;
+        var savedMarkdown = Path.Combine(destination, Path.GetFileNameWithoutExtension(source) + ".edited.md");
+        var save = Save(savedMarkdown, edited);
+        if (!File.ReadAllText(save.Output).Contains(marker, StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException("Saved Markdown did not contain the edit marker.");
+        }
+
+        var exportedWord = Path.Combine(destination, Path.GetFileNameWithoutExtension(source) + ".edited.docx");
+        await ExportWordAsync(exportedWord, edited);
+        if (!File.Exists(exportedWord) || new FileInfo(exportedWord).Length == 0)
+        {
+            throw new InvalidOperationException("Word export was missing or empty.");
+        }
+
+        var reconvertDir = Path.Combine(destination, "reconverted");
+        Directory.CreateDirectory(reconvertDir);
+        var report = RunBuildCorpus(exportedWord, "--out", reconvertDir);
+        var reconvertedMarkdown = report.RootElement.GetProperty("outputs")[0].GetString();
+        if (string.IsNullOrWhiteSpace(reconvertedMarkdown) || !File.Exists(reconvertedMarkdown))
+        {
+            throw new InvalidOperationException("Exported Word document did not reconvert to Markdown.");
+        }
+
+        var reconvertedText = await File.ReadAllTextAsync(reconvertedMarkdown);
+        if (!reconvertedText.Contains("regen-mde functional edit", StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException("Reconverted Markdown did not contain the edit marker.");
+        }
+
+        return new DocumentSelfTestResult(
+            source,
+            opened.WorkingPath,
+            save.Output,
+            exportedWord,
+            reconvertedMarkdown,
+            marker);
+    }
+
+    public async Task<SaveResult?> SaveAsAsync(string? suggestedPath, string format, string content)
+    {
+        using var dialog = new SaveFileDialog
+        {
+            Title = format == "word" ? "Export Word Document" : "Save Markdown",
+            Filter = format == "word" ? "Word document|*.docx" : "Markdown|*.md",
+            FileName = SuggestedFileName(suggestedPath, format == "word" ? ".docx" : ".md"),
+            AddExtension = true,
+            OverwritePrompt = true,
+        };
+        if (dialog.ShowDialog() != DialogResult.OK) return null;
+
+        if (format == "word")
+        {
+            return new SaveResult(await ExportWordAsync(dialog.FileName, content));
+        }
+        File.WriteAllText(dialog.FileName, content);
+        return new SaveResult(dialog.FileName);
+    }
+
+    public async Task<SaveResult> SaveAsDirectAsync(string? targetPath, string format, string content)
+    {
+        var target = RequirePath(targetPath);
+        Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+        if (format == "word")
+        {
+            return new SaveResult(await ExportWordAsync(target, content));
+        }
+        if (Path.GetExtension(target).ToLowerInvariant() is not ".md" and not ".markdown")
+        {
+            target = Path.ChangeExtension(target, ".md");
+        }
+        await File.WriteAllTextAsync(target, content);
+        return new SaveResult(target);
+    }
+
+    public BatchConvertResult ConvertBatch(string? path, bool moveSources)
+    {
+        var source = RequirePath(path);
+        var args = new List<string> { source, "--out-same-dir" };
+        if (moveSources) args.Add("--move-sources");
+        var report = RunBuildCorpus(args.ToArray());
+        var outputs = report.RootElement.GetProperty("outputs").EnumerateArray()
+            .Select(item => item.GetString() ?? "")
+            .Where(item => !string.IsNullOrWhiteSpace(item))
+            .ToArray();
+        return new BatchConvertResult(source, outputs);
+    }
+
+    public async Task<InlineImagesResult> InlineImagesAsync(string content, string? basePath)
+    {
+        var baseDir = string.IsNullOrWhiteSpace(basePath)
+            ? Directory.GetCurrentDirectory()
+            : Path.GetDirectoryName(Path.GetFullPath(basePath)) ?? Directory.GetCurrentDirectory();
+        using var http = new HttpClient();
+        var converted = 0;
+        var skipped = new List<string>();
+        var pattern = new Regex(@"!\[([^\]]*)\]\(([^)\s]+)(?:\s+""[^""]*"")?\)");
+        var output = new System.Text.StringBuilder();
+        var cursor = 0;
+        foreach (Match match in pattern.Matches(content))
+        {
+            output.Append(content, cursor, match.Index - cursor);
+            cursor = match.Index + match.Length;
+            var alt = match.Groups[1].Value;
+            var reference = match.Groups[2].Value;
+            if (reference.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
+            {
+                output.Append(match.Value);
+                continue;
+            }
+            try
+            {
+                output.Append(await InlineOneImageAsync(http, baseDir, alt, reference, match.Value));
+                converted++;
+            }
+            catch (Exception exc)
+            {
+                skipped.Add($"{reference}: {exc.Message}");
+                output.Append(match.Value);
+            }
+        }
+        output.Append(content, cursor, content.Length - cursor);
+        return new InlineImagesResult(output.ToString(), converted, skipped.ToArray());
+    }
+
+    private static async Task<string> InlineOneImageAsync(HttpClient http, string baseDir, string alt, string reference, string fallback)
+    {
+        byte[] data;
+        string mime;
+        if (Uri.TryCreate(reference, UriKind.Absolute, out var uri) && (uri.Scheme == "http" || uri.Scheme == "https"))
+        {
+            using var response = await http.GetAsync(uri);
+            response.EnsureSuccessStatusCode();
+            data = await response.Content.ReadAsByteArrayAsync();
+            mime = response.Content.Headers.ContentType?.MediaType ?? GuessImageMime(reference, data);
+        }
+        else
+        {
+            var path = Path.IsPathRooted(reference) ? reference : Path.Combine(baseDir, reference.Replace('/', Path.DirectorySeparatorChar));
+            if (!File.Exists(path)) return fallback;
+            data = await File.ReadAllBytesAsync(path);
+            mime = GuessImageMime(path, data);
+        }
+        return $"![{alt}](data:{mime};base64,{Convert.ToBase64String(data)})";
+    }
+
+    private static string GuessImageMime(string reference, byte[] data)
+    {
+        var ext = Path.GetExtension(reference).ToLowerInvariant();
+        return ext switch
+        {
+            ".jpg" or ".jpeg" => "image/jpeg",
+            ".gif" => "image/gif",
+            ".webp" => "image/webp",
+            ".bmp" => "image/bmp",
+            ".svg" => "image/svg+xml",
+            _ when data.Length > 8 && data[0] == 0x89 && data[1] == 0x50 => "image/png",
+            _ => "image/png",
+        };
+    }
+
+    private async Task<string> ExportWordAsync(string targetPath, string content)
+    {
+        var tmp = Path.Combine(sessionRoot, "export-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(tmp);
+        var md = Path.Combine(tmp, Path.GetFileNameWithoutExtension(targetPath) + ".md");
+        await File.WriteAllTextAsync(md, content);
+        RunBuildCorpus(md, "--to", "word", "--out-same-dir");
+        var generated = Path.ChangeExtension(md, ".docx");
+        File.Copy(generated, targetPath, overwrite: true);
+        return targetPath;
+    }
+
+    private JsonDocument RunBuildCorpus(params string[] args)
+    {
+        var psi = new ProcessStartInfo
+        {
+            FileName = "node",
+            WorkingDirectory = root,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+        };
+        psi.ArgumentList.Add(Path.Combine(root, "bin", "build-corpus.js"));
+        foreach (var arg in args) psi.ArgumentList.Add(arg);
+        psi.Environment["PYTHONPATH"] = Path.Combine(root, "src");
+
+        using var process = Process.Start(psi) ?? throw new InvalidOperationException("Could not start build-corpus.");
+        var stdout = process.StandardOutput.ReadToEnd();
+        var stderr = process.StandardError.ReadToEnd();
+        process.WaitForExit();
+        if (process.ExitCode != 0)
+        {
+            throw new InvalidOperationException(stderr.Length > 0 ? stderr : stdout);
+        }
+
+        var start = stdout.IndexOf('{');
+        var end = stdout.LastIndexOf('}');
+        if (start < 0 || end < start) throw new InvalidOperationException("Build Corpus did not return JSON.");
+        return JsonDocument.Parse(stdout[start..(end + 1)]);
+    }
+
+    private static string RequirePath(string? path)
+    {
+        if (string.IsNullOrWhiteSpace(path)) throw new InvalidOperationException("Missing path.");
+        return Path.GetFullPath(path);
+    }
+
+    private static string SuggestedFileName(string? path, string extension)
+    {
+        if (string.IsNullOrWhiteSpace(path)) return "document" + extension;
+        return Path.ChangeExtension(Path.GetFileName(path), extension);
+    }
+
+    private static string LocateRoot()
+    {
+        var env = Environment.GetEnvironmentVariable("BUILD_CORPUS_ROOT");
+        if (!string.IsNullOrWhiteSpace(env) && File.Exists(Path.Combine(env, "bin", "build-corpus.js")))
+        {
+            return Path.GetFullPath(env);
+        }
+
+        var current = AppContext.BaseDirectory;
+        while (!string.IsNullOrWhiteSpace(current))
+        {
+            if (File.Exists(Path.Combine(current, "bin", "build-corpus.js"))) return current;
+            var parent = Directory.GetParent(current)?.FullName;
+            if (parent == current) break;
+            current = parent ?? "";
+        }
+        return Directory.GetCurrentDirectory();
+    }
+}
+
+internal sealed record StartupResult(string? InitialPath, bool ComposeMode = false, string? PaneId = null);
+internal sealed record ComposeInfoResult(bool ComposeMode, string? PaneId, string DropDir);
+internal sealed record DroppedFileResult(string Path, bool IsImage, long Size);
+internal sealed record SendToPaneResult(string PaneId, string SavedPath, int Length);
+internal sealed record OpenResult(string SourcePath, string WorkingPath, string OriginalFormat, string Content);
+internal sealed record SaveResult(string Output);
+internal sealed record BatchConvertResult(string Input, string[] Outputs);
+internal sealed record InlineImagesResult(string Content, int Converted, string[] Skipped);
+internal sealed record DocumentSelfTestResult(
+    string SourcePath,
+    string WorkingPath,
+    string SavedMarkdown,
+    string ExportedWord,
+    string ReconvertedMarkdown,
+    string Marker);