feat(ui): add diff output mode for AI actions

Add a new output mode that displays AI-generated changes in a
side-by-side diff window, allowing users to accept, reject, or
refine the result.

- Adding DiffPlex package and related DTOs
- Implementing DiffViewWindow and DiffViewModel
- Updating action orchestration and UI components
- Adding new event for diff view requests

Author: LSXPrime

ProseFlow.Application/DTOs/ActionExecutionRequest.cs

@@ -0,0 +1,12 @@
+using ProseFlow.Core.Enums;
+using Action = ProseFlow.Core.Models.Action;
+
+namespace ProseFlow.Application.DTOs;
+
+/// <summary>
+/// A request to execute a specific action with potential overrides.
+/// </summary>
+/// <param name="ActionToExecute">The action chosen by the user.</param>
+/// <param name="Mode">The desired output mode for the result (e.g., InPlace, Windowed, Diff).</param>
+/// <param name="ProviderOverride">Optional provider name to override the default for this single execution.</param>
+public record ActionExecutionRequest(Action ActionToExecute, OutputMode Mode, string? ProviderOverride);

ProseFlow.Application/DTOs/DiffViewData.cs

@@ -0,0 +1,9 @@
+namespace ProseFlow.Application.DTOs;
+
+/// <summary>
+/// A Data Transfer Object to carry all necessary information for displaying the Diff View Window.
+/// </summary>
+/// <param name="ActionName">The name of the action performed, for the window title.</param>
+/// <param name="OriginalText">The user's original, selected text.</param>
+/// <param name="GeneratedText">The AI-generated text to be compared.</param>
+public record DiffViewData(string ActionName, string OriginalText, string GeneratedText);

ProseFlow.Application/DTOs/DiffViewResult.cs

@@ -0,0 +1,27 @@
+namespace ProseFlow.Application.DTOs;
+
+/// <summary>
+/// Represents the user's decision from the Diff View window.
+/// This is a discriminated union pattern.
+/// </summary>
+public abstract record DiffViewResult;
+
+/// <summary>
+/// The user accepted the changes. The new text should be pasted.
+/// </summary>
+public record Accepted(string NewText) : DiffViewResult;
+
+/// <summary>
+/// The user wants to refine the output with a new instruction.
+/// </summary>
+public record Refined(string RefinementInstruction) : DiffViewResult;
+
+/// <summary>
+/// The user wants to re-run the original action to get a new suggestion.
+/// </summary>
+public record Regenerated : DiffViewResult;
+
+/// <summary>
+/// The user closed the window or cancelled the operation.
+/// </summary>
+public record Cancelled : DiffViewResult;

ProseFlow.Application/Events/AppEvents.cs

@@ -3,14 +3,6 @@
 
 namespace ProseFlow.Application.Events;
 
-/// <summary>
-/// A request to execute a specific action with potential overrides.
-/// </summary>
-/// <param name="ActionToExecute">The action chosen by the user.</param>
-/// <param name="ForceOpenInWindow">Whether the user overrode the default behavior to force opening a new window.</param>
-/// <param name="ProviderOverride">Optional provider name to override the default for this single execution.</param>
-public record ActionExecutionRequest(Action ActionToExecute, bool ForceOpenInWindow, string? ProviderOverride);
-
 public enum NotificationType { Info, Success, Warning, Error }
 
 public static class AppEvents
@@ -72,7 +64,26 @@ public static class AppEvents
         return ShowResultWindowAndAwaitRefinement is not null
             ? await ShowResultWindowAndAwaitRefinement.Invoke(data)
             : await Task.FromResult<RefinementRequest?>(null);
-        // Graceful failure
+    }
+    
+    /// <summary>
+    /// Raised when a diff view needs to be displayed.
+    /// The UI subscribes, shows the diff window, and returns a task that completes
+    /// with the user's decision (Accept, Refine, Regenerate, or Cancel).
+    /// </summary>
+    public static event Func<DiffViewData, Task<DiffViewResult?>>? ShowDiffViewRequested;
+
+    /// <summary>
+    /// Invokes the event to show the diff view window and waits for user interaction.
+    /// </summary>
+    /// <returns>A DiffViewResult representing the user's choice, or null if the UI handler isn't attached.</returns>
+    public static async Task<DiffViewResult?> RequestDiffViewAsync(DiffViewData data)
+    {
+        if (!IsShowResultWindowEnabled) return null; 
+
+        return ShowDiffViewRequested is not null
+            ? await ShowDiffViewRequested.Invoke(data)
+            : await Task.FromResult<DiffViewResult?>(null);
     }
 
     /// <summary>

ProseFlow.Application/Services/ActionOrchestrationService.cs

@@ -91,7 +91,7 @@ private async Task HandleSmartPasteHotkeyAsync()
             return;
         }
 
-        var request = new ActionExecutionRequest(result.Action, result.Action.OpenInWindow, null);
+        var request = new ActionExecutionRequest(result.Action, OutputMode.InPlace, null); // Smart Paste is always InPlace
         await ProcessRequestAsync(request);
     }
 
@@ -122,84 +122,21 @@ private async Task ProcessRequestAsync(ActionExecutionRequest request)
             conversationHistory.Add(new ChatMessage("system", systemInstruction));
             conversationHistory.Add(new ChatMessage("user", $"{request.ActionToExecute.Prefix}{userInput}"));
 
-            if (request.ForceOpenInWindow || request.ActionToExecute.OpenInWindow)
-            {
-                // Windowed processing loop
-                while (true)
-                {
-                    var executionResult = await ExecuteRequestWithFallbackAsync(conversationHistory, request.ProviderOverride, localSessionId);
-
-                    if (executionResult is null)
-                    {
-                        // Both primary and fallback failed, or no providers are configured.
-                        AppEvents.RequestNotification("All available AI providers failed.", NotificationType.Error);
-                        break;
-                    }
-
-                    if (executionResult.Value.Provider.Type == ProviderType.Local && localSessionId is null)
-                    {
-                        // If this is the first turn in a windowed local session. Create a new session.
-                        localSessionId = _localSessionService.StartSession();
-                        if (localSessionId is null)
-                        {
-                            AppEvents.RequestNotification("Failed to start a local model session.", NotificationType.Error);
-                            return;
-                        }
-                    }
-
-                    var (aiResponse, provider, latencyMs) = executionResult.Value;
-                    conversationHistory.Add(new ChatMessage("assistant", aiResponse.Content));
+            var outputMode = request.Mode == OutputMode.Default
+                ? (request.ActionToExecute.OpenInWindow ? OutputMode.Windowed : OutputMode.InPlace)
+                : request.Mode;
 
-                    // Log to DB
-                    await LogToHistoryAsync(
-                        request.ActionToExecute.Name,
-                        provider.Name,
-                        aiResponse.ProviderName,
-                        conversationHistory.Last(m => m.Role == "user").Content,
-                        aiResponse.Content,
-                        aiResponse.PromptTokens,
-                        aiResponse.CompletionTokens,
-                        latencyMs,
-                        aiResponse.TokensPerSecond);
-
-                    // Parse and show the result window
-                    var (mainOutput, explanation) = ParseOutput(aiResponse.Content, request.ActionToExecute.ExplainChanges);
-
-                    // Show the window and wait for the user to either close it or request a refinement
-                    var windowData = new ResultWindowData(request.ActionToExecute.Name, mainOutput, explanation);
-                    var refinementRequest = await AppEvents.RequestResultWindowAsync(windowData);
-
-                    if (refinementRequest is null)
-                        break; // User closed the window
-
-                    conversationHistory.Add(new ChatMessage("user", refinementRequest.NewInstruction));
-                }
-            }
-            else
+            switch (outputMode)
             {
-                // In-Place execution
-                var executionResult = await ExecuteRequestWithFallbackAsync(conversationHistory, request.ProviderOverride);
-
-                if (executionResult is null)
-                {
-                    AppEvents.RequestNotification("All available AI providers failed.", NotificationType.Error);
-                    return;
-                }
-
-                var (aiResponse, provider, latencyMs) = executionResult.Value;
-
-                await LogToHistoryAsync(
-                    request.ActionToExecute.Name,
-                    provider.Name,
-                    aiResponse.ProviderName,
-                    conversationHistory.Last(m => m.Role == "user").Content,
-                    aiResponse.Content,
-                    aiResponse.PromptTokens,
-                    aiResponse.CompletionTokens,
-                    latencyMs,
-                    aiResponse.TokensPerSecond);
-                
-                await _clipboardService.PasteTextAsync(aiResponse.Content);
+                case OutputMode.Windowed:
+                    localSessionId = await HandleWindowedModeAsync(request, conversationHistory, localSessionId);
+                    break;
+                case OutputMode.InPlace:
+                    await HandleInPlaceModeAsync(request, conversationHistory);
+                    break;
+                case OutputMode.Diff:
+                    localSessionId = await HandleDiffModeAsync(request, userInput, conversationHistory, localSessionId);
+                    break;
             }
 
             overallStopwatch.Stop();
@@ -221,6 +158,138 @@ await LogToHistoryAsync(
         }
     }
 
+    private async Task<Guid?> HandleWindowedModeAsync(ActionExecutionRequest request, List<ChatMessage> conversationHistory, Guid? localSessionId)
+    {
+        while (true)
+        {
+            var executionResult = await ExecuteRequestWithFallbackAsync(conversationHistory, request.ProviderOverride, localSessionId);
+
+            if (executionResult is null)
+            {
+                AppEvents.RequestNotification("All available AI providers failed.", NotificationType.Error);
+                break;
+            }
+
+            if (executionResult.Value.Provider.Type == ProviderType.Local && localSessionId is null)
+            {
+                localSessionId = _localSessionService.StartSession();
+                if (localSessionId is null)
+                {
+                    AppEvents.RequestNotification("Failed to start a local model session.", NotificationType.Error);
+                    return localSessionId;
+                }
+            }
+
+            var (aiResponse, provider, latencyMs) = executionResult.Value;
+            conversationHistory.Add(new ChatMessage("assistant", aiResponse.Content));
+
+            await LogToHistoryAsync(
+                request.ActionToExecute.Name,
+                provider.Name,
+                aiResponse.ProviderName,
+                conversationHistory.Last(m => m.Role == "user").Content,
+                aiResponse.Content,
+                aiResponse.PromptTokens,
+                aiResponse.CompletionTokens,
+                latencyMs,
+                aiResponse.TokensPerSecond);
+
+            var (mainOutput, explanation) = ParseOutput(aiResponse.Content, request.ActionToExecute.ExplainChanges);
+            var windowData = new ResultWindowData(request.ActionToExecute.Name, mainOutput, explanation);
+            var refinementRequest = await AppEvents.RequestResultWindowAsync(windowData);
+
+            if (refinementRequest is null) break;
+
+            conversationHistory.Add(new ChatMessage("user", refinementRequest.NewInstruction));
+        }
+        return localSessionId;
+    }
+
+    private async Task HandleInPlaceModeAsync(ActionExecutionRequest request, List<ChatMessage> conversationHistory)
+    {
+        var executionResult = await ExecuteRequestWithFallbackAsync(conversationHistory, request.ProviderOverride);
+
+        if (executionResult is null)
+        {
+            AppEvents.RequestNotification("All available AI providers failed.", NotificationType.Error);
+            return;
+        }
+
+        var (aiResponse, provider, latencyMs) = executionResult.Value;
+
+        await LogToHistoryAsync(
+            request.ActionToExecute.Name,
+            provider.Name,
+            aiResponse.ProviderName,
+            conversationHistory.Last(m => m.Role == "user").Content,
+            aiResponse.Content,
+            aiResponse.PromptTokens,
+            aiResponse.CompletionTokens,
+            latencyMs,
+            aiResponse.TokensPerSecond);
+        
+        await _clipboardService.PasteTextAsync(aiResponse.Content);
+    }
+    
+    private async Task<Guid?> HandleDiffModeAsync(ActionExecutionRequest request, string originalInput, List<ChatMessage> conversationHistory, Guid? localSessionId)
+    {
+        while (true)
+        {
+            var executionResult = await ExecuteRequestWithFallbackAsync(conversationHistory, request.ProviderOverride, localSessionId);
+
+            if (executionResult is null)
+            {
+                AppEvents.RequestNotification("All available AI providers failed.", NotificationType.Error);
+                return localSessionId;
+            }
+            
+            var (aiResponse, provider, latencyMs) = executionResult.Value;
+            
+            if (provider.Type == ProviderType.Local && localSessionId is null)
+            {
+                localSessionId = _localSessionService.StartSession();
+                if (localSessionId is null)
+                {
+                    AppEvents.RequestNotification("Failed to start a local model session.", NotificationType.Error);
+                    return localSessionId;
+                }
+            }
+            
+            var diffData = new DiffViewData(request.ActionToExecute.Name, originalInput, aiResponse.Content);
+            var userDecision = await AppEvents.RequestDiffViewAsync(diffData);
+
+            switch (userDecision)
+            {
+                case Accepted accepted:
+                    await LogToHistoryAsync(
+                        request.ActionToExecute.Name,
+                        provider.Name,
+                        aiResponse.ProviderName,
+                        conversationHistory.Last(m => m.Role == "user").Content,
+                        accepted.NewText,
+                        aiResponse.PromptTokens,
+                        aiResponse.CompletionTokens,
+                        latencyMs,
+                        aiResponse.TokensPerSecond);
+                    await _clipboardService.PasteTextAsync(accepted.NewText);
+                    return localSessionId; 
+                
+                case Refined refined:
+                    // The last message in history is the assistant's previous response. Add it before the user's refinement.
+                    conversationHistory.Add(new ChatMessage("assistant", aiResponse.Content));
+                    conversationHistory.Add(new ChatMessage("user", refined.RefinementInstruction));
+                    continue;
+
+                case Regenerated:
+                    continue;
+
+                case Cancelled or null:
+                    return localSessionId;
+            }
+        }
+    }
+
+
     /// <summary>
     /// Executes an AI request, trying the primary provider first and then the fallback provider upon failure.
     /// </summary>

ProseFlow.Core/Enums/OutputMode.cs

@@ -0,0 +1,27 @@
+namespace ProseFlow.Core.Enums;
+
+/// <summary>
+/// Specifies the desired output mode for an AI action.
+/// </summary>
+public enum OutputMode
+{
+    /// <summary>
+    /// The application decides whether to open a new window or replace in-place based on the action's configuration.
+    /// </summary>
+    Default,
+    
+    /// <summary>
+    /// The result should be pasted directly, replacing the selected text.
+    /// </summary>
+    InPlace,
+    
+    /// <summary>
+    /// The result should be displayed in a new, interactive window.
+    /// </summary>
+    Windowed,
+    
+    /// <summary>
+    /// The result should be displayed in a diff view window for comparison and approval.
+    /// </summary>
+    Diff
+}

ProseFlow.UI/App.axaml.cs

@@ -462,6 +462,23 @@ private void SubscribeToAppEvents()
             });
         };
 
+        AppEvents.ShowDiffViewRequested += data =>
+        {
+            return Dispatcher.UIThread.InvokeAsync(async () =>
+            {
+                var viewModel = new DiffViewModel(data);
+                var window = new DiffViewWindow
+                {
+                    DataContext = viewModel,
+                    Focusable = true,
+                    WindowStartupLocation = WindowStartupLocation.CenterScreen,
+                    WindowState = WindowState.Normal,
+                };
+                window.Show();
+                return await viewModel.CompletionSource.Task;
+            });
+        };
+
         AppEvents.ShowFloatingMenuRequested += async (actions, context) =>
         {
             var providerSettings = await Services.GetRequiredService<SettingsService>().GetProviderSettingsAsync();