Update CommandHandler base class for System.CommandLine 2.0.0-beta5 compatibility

docs/BETA5-MIGRATION-EXAMPLE.cs

@@ -0,0 +1,138 @@
+// Example: System.CommandLine 2.0.0-beta5 Migration Pattern
+// This file demonstrates how the updated CommandHandler base class
+// will work with the new beta5 API patterns.
+
+using System.CommandLine;
+using System.CommandLine.Parsing;
+using Microsoft.Extensions.Hosting;
+
+namespace GenAIDBExplorer.Console.Examples;
+
+/// <summary>
+/// Example showing how SetupCommand methods will work with beta5 API
+/// </summary>
+public static class Beta5MigrationExample
+{
+    /// <summary>
+    /// Example of how the old beta4 SetupCommand method looked
+    /// </summary>
+    public static Command SetupCommand_Beta4_Pattern(IHost host)
+    {
+        var projectPathOption = new Option<DirectoryInfo>(
+            aliases: ["--project", "-p"],
+            description: "The path to the GenAI Database Explorer project."
+        )
+        {
+            IsRequired = true  // Beta4 syntax
+        };
+
+        var command = new Command("example", "Example command");
+        command.AddOption(projectPathOption);  // Beta4 syntax
+
+        // Beta4 handler pattern
+        command.SetHandler(async (DirectoryInfo projectPath) =>
+        {
+            var handler = host.Services.GetRequiredService<ExampleCommandHandler>();
+            var options = new ExampleCommandHandlerOptions(projectPath);
+            await handler.HandleAsync(options);  // Uses TOptions
+        }, projectPathOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Example of how the new beta5 SetupCommand method will look
+    /// </summary>
+    public static Command SetupCommand_Beta5_Pattern(IHost host)
+    {
+        var projectPathOption = new Option<DirectoryInfo>("--project", "-p")
+        {
+            Description = "The path to the GenAI Database Explorer project.",
+            Required = true  // Beta5 syntax
+        };
+
+        var command = new Command("example", "Example command");
+        command.Options.Add(projectPathOption);  // Beta5 syntax
+
+        // Beta5 handler pattern
+        command.SetAction(async (parseResult) =>
+        {
+            var handler = host.Services.GetRequiredService<ExampleCommandHandler>();
+            await handler.HandleAsync(parseResult);  // Uses ParseResult - NEW!
+        });
+
+        return command;
+    }
+}
+
+/// <summary>
+/// Example command handler showing both old and new patterns
+/// </summary>
+public class ExampleCommandHandler : CommandHandler<ExampleCommandHandlerOptions>
+{
+    // Constructor would go here...
+
+    /// <summary>
+    /// Legacy method - continues to work as before
+    /// </summary>
+    public override async Task HandleAsync(ExampleCommandHandlerOptions commandOptions)
+    {
+        // Original implementation stays the same
+        var projectPath = commandOptions.ProjectPath;
+        // ... handle command logic
+        await Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// New method for beta5 compatibility - automatically provided by base class
+    /// The base class HandleAsync(ParseResult) calls this method to extract options
+    /// </summary>
+    protected override ExampleCommandHandlerOptions ExtractCommandOptions(ParseResult parseResult)
+    {
+        // Use utility methods from base class to extract values
+        var projectPath = GetOptionValue<DirectoryInfo>(parseResult, "--project");
+        return new ExampleCommandHandlerOptions(projectPath);
+    }
+}
+
+/// <summary>
+/// Options class - no changes needed
+/// </summary>
+public class ExampleCommandHandlerOptions : ICommandHandlerOptions
+{
+    public ExampleCommandHandlerOptions(DirectoryInfo projectPath)
+    {
+        ProjectPath = projectPath;
+    }
+
+    public DirectoryInfo ProjectPath { get; }
+}
+
+/*
+MIGRATION SUMMARY:
+
+WHAT CHANGES:
+1. SetupCommand methods update to use:
+   - Required = true instead of IsRequired = true
+   - Options.Add() instead of AddOption()  
+   - SetAction() instead of SetHandler()
+   - ParseResult parameter instead of individual parameters
+
+2. Command handlers implement:
+   - ExtractCommandOptions(ParseResult) method
+   - Use GetOptionValue<T>() utility methods
+
+WHAT STAYS THE SAME:
+1. HandleAsync(TOptions) method - no changes
+2. Options classes - no changes  
+3. Command logic - no changes
+4. Dependency injection - no changes
+5. Tests - existing tests continue to work
+
+BENEFITS:
+- Zero breaking changes to existing code
+- Forward compatibility with beta5
+- Type safety preserved
+- Easy migration path
+- Better performance with beta5
+*/

docs/COMMANDLINE-BETA5-MIGRATION.md

@@ -0,0 +1,144 @@
+# System.CommandLine 2.0.0-beta5 Migration Guide
+
+This document outlines the changes made to support System.CommandLine 2.0.0-beta5 in the CommandHandler base class and provides guidance for developers working with command handlers.
+
+## Overview
+
+The CommandHandler base class has been updated to support both the legacy pattern (using strongly-typed options) and the new System.CommandLine 2.0.0-beta5 pattern (using ParseResult).
+
+## Key Changes
+
+### 1. ICommandHandler Interface
+
+The interface now includes two overloads:
+
+```csharp
+public interface ICommandHandler<TOptions> where TOptions : ICommandHandlerOptions
+{
+    // Legacy method - continues to work as before
+    Task HandleAsync(TOptions commandOptions);
+
+    // New method for beta5 compatibility
+    Task HandleAsync(ParseResult parseResult);
+}
+```
+
+### 2. CommandHandler Base Class
+
+The base class provides:
+
+- **Backward Compatibility**: Existing `HandleAsync(TOptions)` method continues to work
+- **Forward Compatibility**: New `HandleAsync(ParseResult)` method that delegates to the legacy method
+- **Extraction Framework**: `ExtractCommandOptions(ParseResult)` method for converting ParseResult to strongly-typed options
+- **Utility Methods**: Helper methods for extracting values from ParseResult
+
+### 3. Utility Methods
+
+The base class provides several utility methods for working with ParseResult:
+
+```csharp
+// Extract option value by Option<T> reference
+protected static T GetOptionValue<T>(ParseResult parseResult, Option<T> option)
+
+// Extract option value by name
+protected static T GetOptionValue<T>(ParseResult parseResult, string optionName)
+
+// Check if option was provided
+protected static bool HasOption(ParseResult parseResult, Option option)
+```
+
+## Implementation Pattern
+
+### For Command Handlers
+
+Each command handler should implement the `ExtractCommandOptions` method:
+
+```csharp
+public class MyCommandHandler : CommandHandler<MyCommandHandlerOptions>
+{
+    // ... constructor and existing HandleAsync(MyCommandHandlerOptions) method ...
+
+    protected override MyCommandHandlerOptions ExtractCommandOptions(ParseResult parseResult)
+    {
+        var projectPath = GetOptionValue<DirectoryInfo>(parseResult, "--project");
+        var someFlag = GetOptionValue<bool>(parseResult, "--some-flag");
+
+        return new MyCommandHandlerOptions(projectPath, someFlag);
+    }
+}
+```
+
+### For SetupCommand Methods (Future Migration)
+
+When migrating SetupCommand methods to beta5 (in issues #18-#24), the pattern will change from:
+
+**Beta4 Pattern:**
+```csharp
+command.SetHandler(async (DirectoryInfo projectPath, bool flag) =>
+{
+    var handler = host.Services.GetRequiredService<MyCommandHandler>();
+    var options = new MyCommandHandlerOptions(projectPath, flag);
+    await handler.HandleAsync(options);
+}, projectPathOption, flagOption);
+```
+
+**Beta5 Pattern:**
+```csharp
+command.SetAction(async (parseResult) =>
+{
+    var handler = host.Services.GetRequiredService<MyCommandHandler>();
+    await handler.HandleAsync(parseResult);
+});
+```
+
+## Migration Status
+
+### Completed
+- ✅ ICommandHandler interface updated with ParseResult overload
+- ✅ CommandHandler base class updated with extraction framework
+- ✅ InitProjectCommandHandler updated with ExtractCommandOptions
+- ✅ ExtractModelCommandHandler updated with ExtractCommandOptions  
+- ✅ QueryModelCommandHandler updated with ExtractCommandOptions
+
+### Pending (Future Issues)
+- ⏳ DataDictionaryCommandHandler (Issue #18)
+- ⏳ EnrichModelCommandHandler (Issue #19)
+- ⏳ ExportModelCommandHandler (Issue #20)
+- ⏳ ShowObjectCommandHandler (Issue #21)
+- ⏳ Update SetupCommand methods to use SetAction (Issues #22-#24)
+
+## Benefits
+
+1. **Zero Breaking Changes**: Existing code continues to work unchanged
+2. **Future Ready**: New ParseResult pattern is ready for beta5 API usage
+3. **Consistent Pattern**: All command handlers follow the same extraction pattern
+4. **Type Safety**: Strongly-typed options are preserved throughout the application
+5. **Testability**: Both patterns can be easily unit tested
+
+## Testing
+
+The new functionality includes test coverage:
+
+```csharp
+[TestMethod]
+public async Task HandleAsync_WithParseResult_ShouldWork()
+{
+    // Arrange
+    var projectOption = new Option<DirectoryInfo>("--project", "Project path");
+    var rootCommand = new RootCommand();
+    rootCommand.AddOption(projectOption);
+    var parseResult = rootCommand.Parse(new[] { "--project", "/path/to/project" });
+
+    // Act
+    await handler.HandleAsync(parseResult);
+
+    // Assert - verify the command executed correctly
+}
+```
+
+## Next Steps
+
+1. Complete the migration of remaining command handlers
+2. Update SetupCommand methods to use SetAction (depends on issues #15 and #16)
+3. Update Program.cs command registration (issue #16)
+4. Update package reference to beta5 (issue #15)

src/GenAIDBExplorer/GenAIDBExplorer.Console/CommandHandlers/CommandHandler.cs

@@ -5,6 +5,8 @@
 using GenAIDBExplorer.Core.SemanticModelProviders;
 using GenAIDBExplorer.Core.SemanticProviders;
 using Microsoft.Extensions.Logging;
+using System.CommandLine;
+using System.CommandLine.Parsing;
 using System.Resources;
 
 namespace GenAIDBExplorer.Console.CommandHandlers;
@@ -66,6 +68,30 @@ ILogger<ICommandHandler<TOptions>> logger
     /// <param name="commandOptions">The command options that were provided to the command.</param>
     public abstract Task HandleAsync(TOptions commandOptions);
 
+    /// <summary>
+    /// Handles the command using ParseResult for System.CommandLine 2.0.0-beta5 compatibility.
+    /// This method extracts the options from ParseResult and calls the strongly-typed HandleAsync method.
+    /// </summary>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    public virtual Task HandleAsync(ParseResult parseResult)
+    {
+        var commandOptions = ExtractCommandOptions(parseResult);
+        return HandleAsync(commandOptions);
+    }
+
+    /// <summary>
+    /// Extracts the command options from ParseResult. 
+    /// Derived classes should override this method to extract their specific option types.
+    /// </summary>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    /// <returns>The extracted command options.</returns>
+    protected virtual TOptions ExtractCommandOptions(ParseResult parseResult)
+    {
+        throw new NotImplementedException(
+            $"Command handler {GetType().Name} must override ExtractCommandOptions method " +
+            "to support ParseResult-based handling for System.CommandLine 2.0.0-beta5 compatibility.");
+    }
+
     /// <summary>
     /// Asserts that the command options and its properties are valid.
     /// </summary>
@@ -193,4 +219,39 @@ protected Task ShowStoredProcedureDetailsAsync(SemanticModel semanticModel, stri
         }
         return Task.CompletedTask;
     }
+
+    /// <summary>
+    /// Utility method to extract the value of an option from ParseResult.
+    /// </summary>
+    /// <typeparam name="T">The type of the option value.</typeparam>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    /// <param name="option">The option to extract the value for.</param>
+    /// <returns>The extracted option value.</returns>
+    protected static T GetOptionValue<T>(ParseResult parseResult, Option<T> option)
+    {
+        return parseResult.GetValue(option);
+    }
+
+    /// <summary>
+    /// Utility method to extract the value of an option from ParseResult by name.
+    /// </summary>
+    /// <typeparam name="T">The type of the option value.</typeparam>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    /// <param name="optionName">The name of the option to extract the value for.</param>
+    /// <returns>The extracted option value.</returns>
+    protected static T GetOptionValue<T>(ParseResult parseResult, string optionName)
+    {
+        return parseResult.GetValue<T>(optionName);
+    }
+
+    /// <summary>
+    /// Utility method to check if an option was provided in the command line.
+    /// </summary>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    /// <param name="option">The option to check.</param>
+    /// <returns>True if the option was provided, false otherwise.</returns>
+    protected static bool HasOption(ParseResult parseResult, Option option)
+    {
+        return parseResult.FindResultFor(option) != null;
+    }
 }

src/GenAIDBExplorer/GenAIDBExplorer.Console/CommandHandlers/ExtractModelCommandHandler.cs

@@ -6,6 +6,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using System.Resources;
 
 namespace GenAIDBExplorer.Console.CommandHandlers;
@@ -105,4 +106,19 @@ public override async Task HandleAsync(ExtractModelCommandHandlerOptions command
 
         _logger.LogInformation("{Message} '{ProjectPath}'", _resourceManagerLogMessages.GetString("ExtractSemanticModelComplete"), projectPath.FullName);
     }
+
+    /// <summary>
+    /// Extracts the command options from ParseResult for System.CommandLine 2.0.0-beta5 compatibility.
+    /// </summary>
+    /// <param name="parseResult">The parse result containing the parsed command-line arguments.</param>
+    /// <returns>The extracted command options.</returns>
+    protected override ExtractModelCommandHandlerOptions ExtractCommandOptions(ParseResult parseResult)
+    {
+        var projectPath = GetOptionValue<DirectoryInfo>(parseResult, "--project");
+        var skipTables = GetOptionValue<bool>(parseResult, "--skipTables");
+        var skipViews = GetOptionValue<bool>(parseResult, "--skipViews");
+        var skipStoredProcedures = GetOptionValue<bool>(parseResult, "--skipStoredProcedures");
+
+        return new ExtractModelCommandHandlerOptions(projectPath, skipTables, skipViews, skipStoredProcedures);
+    }
 }