feat(codebuddy-console): add Codebuddy dedicated console implementation

Add dedicated Codebuddy console built on shared ConsoleTesting harness with provider definition, execution options, console runner, scenarios, and test project reference.

Co-Authored-By: Hagicode <noreply@hagicode.com>

Author: newbe36524

src/HagiCode.Libs.Codebuddy.Console/CodebuddyConsoleDefinition.cs

@@ -0,0 +1,24 @@
+using HagiCode.Libs.ConsoleTesting;
+
+namespace HagiCode.Libs.Codebuddy.Console;
+
+public static class CodebuddyConsoleDefinition
+{
+    public static ProviderConsoleDefinition Instance { get; } = new(
+        consoleName: "HagiCode.Libs.Codebuddy.Console",
+        providerDisplayName: "CodeBuddy",
+        defaultProviderName: "codebuddy",
+        helpDescription: "Dedicated provider validation for the CodeBuddy CLI.",
+        aliases: ["codebuddy-cli"],
+        optionLines:
+        [
+            "--repo <path>         Include the repository summary scenario in the suite",
+            "--model <model>       Override the CodeBuddy model for scenario runs"
+        ],
+        exampleLines:
+        [
+            "HagiCode.Libs.Codebuddy.Console",
+            "HagiCode.Libs.Codebuddy.Console --test-provider codebuddy-cli",
+            "HagiCode.Libs.Codebuddy.Console --test-provider-full --repo ."
+        ]);
+}

src/HagiCode.Libs.Codebuddy.Console/CodebuddyConsoleExecutionOptions.cs

@@ -0,0 +1,55 @@
+using HagiCode.Libs.Providers.Codebuddy;
+
+namespace HagiCode.Libs.Codebuddy.Console;
+
+public sealed record CodebuddyConsoleExecutionOptions(
+    string? Model,
+    string? RepositoryPath)
+{
+    public const string DefaultModel = "glm-4.7";
+
+    public static CodebuddyConsoleExecutionOptions Parse(IReadOnlyList<string> args)
+    {
+        ArgumentNullException.ThrowIfNull(args);
+
+        string? model = null;
+        string? repositoryPath = null;
+
+        for (var index = 0; index < args.Count; index++)
+        {
+            var argument = args[index];
+            switch (argument)
+            {
+                case "--model":
+                    model = ReadValue(args, ref index, argument);
+                    break;
+                case "--repo":
+                    repositoryPath = ReadValue(args, ref index, argument);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown option: {argument}");
+            }
+        }
+
+        return new CodebuddyConsoleExecutionOptions(model, repositoryPath);
+    }
+
+    public CodebuddyOptions CreateBaseOptions()
+    {
+        return new CodebuddyOptions
+        {
+            Model = string.IsNullOrWhiteSpace(Model) ? DefaultModel : Model,
+        };
+    }
+
+    private static string ReadValue(IReadOnlyList<string> args, ref int index, string flag)
+    {
+        if (index + 1 >= args.Count || args[index + 1].StartsWith("-", StringComparison.Ordinal))
+        {
+            throw new ArgumentException($"{flag} requires a value.");
+        }
+
+        index++;
+        return args[index];
+    }
+}

src/HagiCode.Libs.Codebuddy.Console/CodebuddyConsoleRunner.cs

@@ -0,0 +1,41 @@
+using HagiCode.Libs.Codebuddy.Console.Scenarios;
+using HagiCode.Libs.ConsoleTesting;
+using HagiCode.Libs.Providers;
+using HagiCode.Libs.Providers.Codebuddy;
+
+namespace HagiCode.Libs.Codebuddy.Console;
+
+public sealed class CodebuddyConsoleRunner : ProviderConsoleRunnerBase<ICliProvider<CodebuddyOptions>>
+{
+    public CodebuddyConsoleRunner(
+        ProviderConsoleDefinition definition,
+        ICliProvider<CodebuddyOptions> provider,
+        ProviderConsoleOutputFormatter formatter)
+        : base(definition, provider, formatter)
+    {
+    }
+
+    protected override void ValidateAdditionalArgs(IReadOnlyList<string> additionalArgs)
+    {
+        _ = CodebuddyConsoleExecutionOptions.Parse(additionalArgs);
+    }
+
+    protected override IReadOnlyList<ProviderConsoleScenario<ICliProvider<CodebuddyOptions>>> CreateScenarios(
+        IReadOnlyList<string> additionalArgs)
+    {
+        var options = CodebuddyConsoleExecutionOptions.Parse(additionalArgs);
+        var scenarios = new List<ProviderConsoleScenario<ICliProvider<CodebuddyOptions>>>
+        {
+            SimplePromptScenario.Create(options),
+            ComplexPromptScenario.Create(options),
+            SessionResumeScenario.Create(options)
+        };
+
+        if (!string.IsNullOrWhiteSpace(options.RepositoryPath))
+        {
+            scenarios.Add(RepositorySummaryScenario.Create(options));
+        }
+
+        return scenarios;
+    }
+}

src/HagiCode.Libs.Codebuddy.Console/ConsoleHost.cs

@@ -0,0 +1,20 @@
+using HagiCode.Libs.Providers;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HagiCode.Libs.Codebuddy.Console;
+
+public static class ConsoleHost
+{
+    public static ServiceProvider BuildServiceProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddHagiCodeLibs();
+        return services.BuildServiceProvider();
+    }
+
+    public static ICliProvider<TOptions> GetProvider<TOptions>(ServiceProvider provider)
+        where TOptions : class
+    {
+        return provider.GetRequiredService<ICliProvider<TOptions>>();
+    }
+}

src/HagiCode.Libs.Codebuddy.Console/HagiCode.Libs.Codebuddy.Console.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <NoWarn>$(NoWarn);1591</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\HagiCode.Libs.ConsoleTesting\HagiCode.Libs.ConsoleTesting.csproj" />
+    <ProjectReference Include="..\HagiCode.Libs.Providers\HagiCode.Libs.Providers.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+</Project>

src/HagiCode.Libs.Codebuddy.Console/Program.cs

@@ -0,0 +1,19 @@
+using HagiCode.Libs.ConsoleTesting;
+using HagiCode.Libs.Providers.Codebuddy;
+
+namespace HagiCode.Libs.Codebuddy.Console;
+
+public static class Program
+{
+    public static async Task<int> Main(string[] args)
+    {
+        var definition = CodebuddyConsoleDefinition.Instance;
+
+        await using var services = ConsoleHost.BuildServiceProvider();
+        var provider = ConsoleHost.GetProvider<CodebuddyOptions>(services);
+        var formatter = new ProviderConsoleOutputFormatter();
+        var runner = new CodebuddyConsoleRunner(definition, provider, formatter);
+
+        return await ProviderConsoleCommandDispatcher.DispatchAsync(args, definition, runner);
+    }
+}

src/HagiCode.Libs.Codebuddy.Console/Scenarios/CodebuddyScenarioMessageReader.cs

@@ -0,0 +1,118 @@
+using System.Text.Json;
+using System.Text;
+using HagiCode.Libs.Providers;
+using HagiCode.Libs.Providers.Codebuddy;
+
+namespace HagiCode.Libs.Codebuddy.Console.Scenarios;
+
+internal static class CodebuddyScenarioMessageReader
+{
+    public static async Task<CodebuddyScenarioExecutionResult> ReadExecutionResultAsync(
+        ICliProvider<CodebuddyOptions> provider,
+        CodebuddyOptions options,
+        string prompt,
+        CancellationToken cancellationToken = default)
+    {
+        var messages = new List<string>();
+        var assistantTextBuilder = new StringBuilder();
+        string? sessionId = null;
+
+        await foreach (var message in provider.ExecuteAsync(options, prompt, cancellationToken))
+        {
+            if (TryGetFailureMessage(message.Content, out var failureMessage))
+            {
+                throw new InvalidOperationException(failureMessage);
+            }
+
+            if (TryGetSessionId(message.Content, out var resolvedSessionId))
+            {
+                sessionId ??= resolvedSessionId;
+            }
+
+            if (string.Equals(message.Type, "assistant", StringComparison.OrdinalIgnoreCase) &&
+                TryGetText(message.Content, out var assistantText) &&
+                !string.IsNullOrWhiteSpace(assistantText))
+            {
+                messages.Add(assistantText);
+                assistantTextBuilder.Append(assistantText);
+            }
+
+            if (string.Equals(message.Type, "terminal.completed", StringComparison.OrdinalIgnoreCase))
+            {
+                break;
+            }
+        }
+
+        return new CodebuddyScenarioExecutionResult(messages, assistantTextBuilder.ToString().Trim(), sessionId);
+    }
+
+    public static async Task<IReadOnlyList<string>> ReadAssistantMessagesAsync(
+        ICliProvider<CodebuddyOptions> provider,
+        CodebuddyOptions options,
+        string prompt,
+        CancellationToken cancellationToken = default)
+    {
+        var result = await ReadExecutionResultAsync(provider, options, prompt, cancellationToken);
+        return result.Messages;
+    }
+
+    private static bool TryGetSessionId(JsonElement content, out string? sessionId)
+    {
+        sessionId = null;
+        if (content.ValueKind != JsonValueKind.Object)
+        {
+            return false;
+        }
+
+        if (!content.TryGetProperty("session_id", out var sessionIdElement) ||
+            sessionIdElement.ValueKind != JsonValueKind.String)
+        {
+            return false;
+        }
+
+        sessionId = sessionIdElement.GetString();
+        return !string.IsNullOrWhiteSpace(sessionId);
+    }
+
+    private static bool TryGetText(JsonElement content, out string? text)
+    {
+        text = null;
+        if (content.ValueKind != JsonValueKind.Object ||
+            !content.TryGetProperty("text", out var textElement) ||
+            textElement.ValueKind != JsonValueKind.String)
+        {
+            return false;
+        }
+
+        text = textElement.GetString();
+        return !string.IsNullOrWhiteSpace(text);
+    }
+
+    private static bool TryGetFailureMessage(JsonElement content, out string? message)
+    {
+        message = null;
+        if (content.ValueKind != JsonValueKind.Object)
+        {
+            return false;
+        }
+
+        if (content.TryGetProperty("type", out var typeElement) &&
+            typeElement.ValueKind == JsonValueKind.String &&
+            string.Equals(typeElement.GetString(), "terminal.failed", StringComparison.OrdinalIgnoreCase))
+        {
+            if (content.TryGetProperty("message", out var messageElement) &&
+                messageElement.ValueKind == JsonValueKind.String)
+            {
+                message = messageElement.GetString();
+                return !string.IsNullOrWhiteSpace(message);
+            }
+        }
+
+        return false;
+    }
+}
+
+internal sealed record CodebuddyScenarioExecutionResult(
+    IReadOnlyList<string> Messages,
+    string AssistantText,
+    string? SessionId);

src/HagiCode.Libs.Codebuddy.Console/Scenarios/ComplexPromptScenario.cs

@@ -0,0 +1,70 @@
+using HagiCode.Libs.ConsoleTesting;
+using HagiCode.Libs.Providers;
+using HagiCode.Libs.Providers.Codebuddy;
+
+namespace HagiCode.Libs.Codebuddy.Console.Scenarios;
+
+public static class ComplexPromptScenario
+{
+    private const int MinResponseLength = 40;
+
+    public static ProviderConsoleScenario<ICliProvider<CodebuddyOptions>> Create(CodebuddyConsoleExecutionOptions executionOptions)
+    {
+        ArgumentNullException.ThrowIfNull(executionOptions);
+
+        return new ProviderConsoleScenario<ICliProvider<CodebuddyOptions>>(
+            "Complex Prompt",
+            "Validate a bounded multi-step analysis prompt.",
+            (provider, cancellationToken) => ExecuteAsync(provider, executionOptions, cancellationToken));
+    }
+
+    private static async Task<ProviderConsoleScenarioResult> ExecuteAsync(
+        ICliProvider<CodebuddyOptions> provider,
+        CodebuddyConsoleExecutionOptions executionOptions,
+        CancellationToken cancellationToken)
+    {
+        var prompt = "Give two short bullet points about software testing: " +
+                     "one advantage and one trade-off. Mention both labels explicitly.";
+
+        var result = await CodebuddyScenarioMessageReader.ReadExecutionResultAsync(
+            provider,
+            executionOptions.CreateBaseOptions(),
+            prompt,
+            cancellationToken);
+
+        if (result.Messages.Count == 0)
+        {
+            return new ProviderConsoleScenarioResult(provider.Name, "Complex Prompt", false, 0, ErrorMessage: "No assistant messages received from provider.");
+        }
+
+        var combined = result.AssistantText;
+        if (combined.Length < MinResponseLength)
+        {
+            return new ProviderConsoleScenarioResult(
+                provider.Name,
+                "Complex Prompt",
+                false,
+                0,
+                ErrorMessage: $"Response too short: {combined.Length} chars (minimum {MinResponseLength}). Response: {combined}");
+        }
+
+        var normalized = combined.ToLowerInvariant();
+        var mentionsAdvantage = normalized.Contains("advantage", StringComparison.Ordinal) ||
+                                normalized.Contains("pro", StringComparison.Ordinal);
+        var mentionsTradeOff = normalized.Contains("trade-off", StringComparison.Ordinal) ||
+                               normalized.Contains("tradeoff", StringComparison.Ordinal) ||
+                               normalized.Contains("con", StringComparison.Ordinal) ||
+                               normalized.Contains("disadvantage", StringComparison.Ordinal);
+        if (!mentionsAdvantage || !mentionsTradeOff)
+        {
+            return new ProviderConsoleScenarioResult(
+                provider.Name,
+                "Complex Prompt",
+                false,
+                0,
+                ErrorMessage: $"Response must mention both an advantage and a trade-off. Response: {combined}");
+        }
+
+        return new ProviderConsoleScenarioResult(provider.Name, "Complex Prompt", true, 0);
+    }
+}