feat(cli): Introduce new enums for Format, Provider, and Tool; update DoCommandHandler for improved type safety

Author: HavenDV

.github/workflows/auto-labeling.yml

@@ -14,6 +14,7 @@ jobs:
       issue-number: ${{ github.event.issue.number }}
       model: free-fast
       provider: openrouter
+      instructions: 'if an issue looks simple and does not affect database, add one of aider labels to try to solve it automatically'
     secrets:
       personal-access-token: ${{ secrets.PERSONAL_TOKEN }}
       openrouter-api-key: ${{ secrets.OPENROUTER_API_KEY_FOR_PRS }}

src/Cli/src/Commands/DoCommandHandler.cs

@@ -6,34 +6,38 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Schema;
+using LangChain.Cli.Models;
 using Microsoft.Extensions.AI;
 using ModelContextProtocol;
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol.Transport;
 using ModelContextProtocol.Protocol.Types;
+using Tool = LangChain.Cli.Models.Tool;
 
 namespace LangChain.Cli.Commands;
 
 internal sealed class DoCommandHandler : ICommandHandler
 {
     public Option<string> InputOption { get; } = CommonOptions.Input;
-    public Option<string> InputFileOption { get; } = CommonOptions.InputFile;
-    public Option<string> OutputFileOption { get; } = CommonOptions.OutputFile;
+    public Option<FileInfo?> InputFileOption { get; } = CommonOptions.InputFile;
+    public Option<FileInfo?> OutputFileOption { get; } = CommonOptions.OutputFile;
     public Option<bool> DebugOption { get; } = CommonOptions.Debug;
     public Option<string> ModelOption { get; } = CommonOptions.Model;
-    public Option<string> ProviderOption { get; } = CommonOptions.Provider;
-    public Option<string[]> ToolsOption { get; } = new(
+    public Option<Provider> ProviderOption { get; } = CommonOptions.Provider;
+    public Option<Tool[]> ToolsOption { get; } = new(
         aliases: ["--tools", "-t"],
-        parseArgument: result => result.Tokens.SelectMany(t => t.Value.Split(',')).ToArray(),
-        description: $"Tools you want to use. Example: --tools={string.Join(",", Formats.All)}");
-    public Option<string[]> DirectoriesOption { get; } = new(
+        description: $"Tools you want to use - {string.Join(", ", Enum.GetNames<Tool>())}.")
+    {
+        AllowMultipleArgumentsPerToken = true,
+    };
+    public Option<DirectoryInfo[]> DirectoriesOption { get; } = new(
         aliases: ["--directories", "-d"],
-        getDefaultValue: () => ["."],
+        getDefaultValue: () => [new DirectoryInfo(".")],
         description: "Directories you want to use for filesystem.");
-    public Option<string> FormatOption { get; } = new(
+    public Option<Format> FormatOption { get; } = new(
         aliases: ["--format", "-f"],
-        getDefaultValue: () => Formats.Text,
-        description: $"Format of answer. Can be {string.Join(" or ", Formats.All)}.");
+        getDefaultValue: () => Format.Text,
+        description: "Format of answer.");
 
     public int Invoke(InvocationContext context)
     {
@@ -43,7 +47,7 @@ public int Invoke(InvocationContext context)
     public async Task<int> InvokeAsync(InvocationContext context)
     {
         var input = context.ParseResult.GetValueForOption(InputOption) ?? string.Empty;
-        var inputPath = context.ParseResult.GetValueForOption(InputFileOption) ?? string.Empty;
+        var inputPath = context.ParseResult.GetValueForOption(InputFileOption);
         var outputPath = context.ParseResult.GetValueForOption(OutputFileOption);
         var debug = context.ParseResult.GetValueForOption(DebugOption);
         var model = context.ParseResult.GetValueForOption(ModelOption);
@@ -60,76 +64,76 @@ public async Task<int> InvokeAsync(InvocationContext context)
             return await McpClientFactory.CreateAsync(
                 tool switch
                 {
-                    Tools.Filesystem => new McpServerConfig
+                    Tool.Filesystem => new McpServerConfig
                     {
-                        Id = Tools.Filesystem,
-                        Name = Tools.Filesystem,
+                        Id = Tool.Filesystem.ToString(),
+                        Name = Tool.Filesystem.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "npx",
-                            ["arguments"] = $"-y @modelcontextprotocol/server-filesystem {string.Join(' ', directories)}",
+                            ["arguments"] = $"-y @modelcontextprotocol/server-filesystem {string.Join(' ', directories.Select(x => x.FullName))}",
                         },
                     },
-                    Tools.Fetch => new McpServerConfig
+                    Tool.Fetch => new McpServerConfig
                     {
-                        Id = Tools.Fetch,
-                        Name = Tools.Fetch,
+                        Id = Tool.Fetch.ToString(),
+                        Name = Tool.Fetch.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "docker",
                             ["arguments"] = "run -i --rm mcp/fetch",
                         },
                     },
-                    Tools.GitHub => new McpServerConfig
+                    Tool.GitHub => new McpServerConfig
                     {
-                        Id = Tools.GitHub,
-                        Name = Tools.GitHub,
+                        Id = Tool.GitHub.ToString(),
+                        Name = Tool.GitHub.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "docker",
                             ["arguments"] = $"run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN={Environment.GetEnvironmentVariable("GITHUB_TOKEN")} ghcr.io/github/github-mcp-server",
                         },
                     },
-                    Tools.Git => new McpServerConfig
+                    Tool.Git => new McpServerConfig
                     {
-                        Id = Tools.Git,
-                        Name = Tools.Git,
+                        Id = Tool.Git.ToString(),
+                        Name = Tool.Git.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "docker",
                             ["arguments"] = $"run -i --rm {string.Join(' ', directories.Select(x => $"--mount type=bind,src={x},dst={x} "))} mcp/git",
                         },
                     },
-                    Tools.Puppeteer => new McpServerConfig
+                    Tool.Puppeteer => new McpServerConfig
                     {
-                        Id = Tools.Puppeteer,
-                        Name = Tools.Puppeteer,
+                        Id = Tool.Puppeteer.ToString(),
+                        Name = Tool.Puppeteer.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "docker",
                             ["arguments"] = "run -i --rm --init -e DOCKER_CONTAINER=true mcp/puppeteer",
                         },
                     },
-                    Tools.SequentialThinking => new McpServerConfig
+                    Tool.SequentialThinking => new McpServerConfig
                     {
-                        Id = Tools.SequentialThinking,
-                        Name = Tools.SequentialThinking,
+                        Id = Tool.SequentialThinking.ToString(),
+                        Name = Tool.SequentialThinking.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
                             ["command"] = "docker",
                             ["arguments"] = "run -i --rm mcp/sequentialthinking",
                         },
                     },
-                    Tools.Slack => new McpServerConfig
+                    Tool.Slack => new McpServerConfig
                     {
-                        Id = Tools.Slack,
-                        Name = Tools.Slack,
+                        Id = Tool.Slack.ToString(),
+                        Name = Tool.Slack.ToString(),
                         TransportType = TransportTypes.StdIo,
                         TransportOptions = new Dictionary<string, string>
                         {
@@ -167,7 +171,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
             {
                 Tools = [
                     .. aiTools.SelectMany(x => x).ToArray(),
-                    .. tools.Contains("filesystem")
+                    .. tools.Contains(Tool.Filesystem)
                         ? new [] { AIFunctionFactory.Create(
                             FindFilePathsByContent,
                             name: "FindFilePathsByContent",
@@ -176,33 +180,33 @@ .. tools.Contains("filesystem")
                 ],
                 ResponseFormat = format switch
                 {
-                    Formats.Text => ChatResponseFormat.Text,
-                    Formats.Lines => ChatResponseFormatForType<StringArraySchema>(),
-                    Formats.ConventionalCommit => ChatResponseFormatForType<ConventionalCommitSchema>(
+                    Format.Text => ChatResponseFormat.Text,
+                    Format.Lines => ChatResponseFormatForType<StringArraySchema>(),
+                    Format.ConventionalCommit => ChatResponseFormatForType<ConventionalCommitSchema>(
                         schemaName: "ConventionalCommitSchema",
                         schemaDescription: "Conventional commit schema. Use this schema to generate conventional commits."),
-                    Formats.Markdown => ChatResponseFormatForType<MarkdownSchema>(
+                    Format.Markdown => ChatResponseFormatForType<MarkdownSchema>(
                         schemaName: "MarkdownSchema",
                         schemaDescription: "Markdown schema. Use this schema to generate markdown."),
-                    Formats.Json => ChatResponseFormat.Json,
+                    Format.Json => ChatResponseFormat.Json,
                     _ => throw new ArgumentException($"Unknown format: {format}"),
                 },
             }).ConfigureAwait(false);
 
         var output = response.Text;
-        if (format == Formats.Lines)
+        if (format == Format.Lines)
         {
             var value = JsonSerializer.Deserialize<StringArraySchema>(response.Text);
 
             output = string.Join(Environment.NewLine, value?.Value ?? []);
         }
-        else if (format == Formats.Markdown)
+        else if (format == Format.Markdown)
         {
             var value = JsonSerializer.Deserialize<MarkdownSchema>(response.Text);
 
             output = value?.Markdown ?? string.Empty;
         }
-        else if (format == Formats.ConventionalCommit)
+        else if (format == Format.ConventionalCommit)
         {
             var value = JsonSerializer.Deserialize<ConventionalCommitSchema>(response.Text);
 

src/Cli/src/CommonOptions.cs

@@ -1,4 +1,5 @@
 using System.CommandLine;
+using LangChain.Cli.Models;
 
 namespace LangChain.Cli;
 
@@ -9,14 +10,14 @@ internal static class CommonOptions
         getDefaultValue: () => string.Empty,
         description: "Input text");
 
-    public static Option<string> InputFile => new(
+    public static Option<FileInfo?> InputFile => new(
         aliases: ["--input-file"],
-        getDefaultValue: () => string.Empty,
+        getDefaultValue: () => null,
         description: "Input file path");
 
-    public static Option<string> OutputFile => new(
+    public static Option<FileInfo?> OutputFile => new(
         aliases: ["--output-file"],
-        getDefaultValue: () => string.Empty,
+        getDefaultValue: () => null,
         description: "Output file path");
 
     public static Option<bool> Debug => new(
@@ -27,10 +28,10 @@ internal static class CommonOptions
     public static Option<string> Model => new(
         aliases: ["--model"],
         getDefaultValue: () => "o3-mini",
-        description: "Model to use for commands. Default is o3-mini.");
+        description: "Model to use for commands.");
 
-    public static Option<string> Provider => new(
+    public static Option<Provider> Provider => new(
         aliases: ["--provider"],
-        getDefaultValue: () => Providers.OpenAi,
-        description: $"Provider to use for commands. Default is {Providers.OpenAi}.");
+        getDefaultValue: () => default,
+        description: $"Provider to use for commands.");
 }

src/Cli/src/Formats.cs

@@ -1,6 +1,7 @@
 using System.ClientModel;
 using System.CommandLine;
 using System.CommandLine.IO;
+using LangChain.Cli.Models;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Logging;
 using OpenAI;
@@ -9,32 +10,32 @@ namespace LangChain.Cli;
 
 internal static class Helpers
 {
-    public static async Task<string> ReadInputAsync(string input, string inputPath, CancellationToken cancellationToken = default)
+    public static async Task<string> ReadInputAsync(string input, FileInfo? inputPath, CancellationToken cancellationToken = default)
     {
-        if (string.IsNullOrWhiteSpace(input) && string.IsNullOrWhiteSpace(inputPath))
+        if (string.IsNullOrWhiteSpace(input) && inputPath is null)
         {
             throw new ArgumentException("Either input or input file must be provided.");
         }
 
         var inputText = input;
-        if (!string.IsNullOrWhiteSpace(inputPath))
+        if (inputPath is not null)
         {
             if (!string.IsNullOrWhiteSpace(inputText))
             {
                 inputText += Environment.NewLine;
             }
 
-            inputText += await File.ReadAllTextAsync(inputPath, cancellationToken).ConfigureAwait(false);
+            inputText += await File.ReadAllTextAsync(inputPath.FullName, cancellationToken).ConfigureAwait(false);
         }
 
         return inputText;
     }
 
-    public static async Task WriteOutputAsync(string outputText, string? outputPath, IConsole? console = null, CancellationToken cancellationToken = default)
+    public static async Task WriteOutputAsync(string outputText, FileInfo? outputPath, IConsole? console = null, CancellationToken cancellationToken = default)
     {
-        if (!string.IsNullOrWhiteSpace(outputPath))
+        if (outputPath is not null)
         {
-            await File.WriteAllTextAsync(outputPath, outputText, cancellationToken).ConfigureAwait(false);
+            await File.WriteAllTextAsync(outputPath.FullName, outputText, cancellationToken).ConfigureAwait(false);
         }
         else
         {
@@ -51,7 +52,7 @@ public static async Task WriteOutputAsync(string outputText, string? outputPath,
 
     public static IChatClient GetChatModel(
         string? model = null,
-        string? provider = null,
+        Provider? provider = null,
         bool debug = false)
     {
         if (debug)
@@ -63,7 +64,7 @@ public static IChatClient GetChatModel(
         IChatClient chatClient;
         Uri? endpoint = provider switch
         {
-            Providers.Free or Providers.OpenRouter => new Uri(tryAGI.OpenAI.CustomProviders.OpenRouterBaseUrl),
+            Provider.Free or Provider.OpenRouter => new Uri(tryAGI.OpenAI.CustomProviders.OpenRouterBaseUrl),
             _ => null,
         };
         model = model switch
@@ -77,9 +78,9 @@ public static IChatClient GetChatModel(
         };
         var apiKey = provider switch
         {
-            Providers.OpenAi or null => Environment.GetEnvironmentVariable("OPENAI_API_KEY") ??
+            Provider.OpenAi or null => Environment.GetEnvironmentVariable("OPENAI_API_KEY") ??
                 throw new InvalidOperationException("OPENAI_API_KEY environment variable is not set."),
-            Providers.OpenRouter or Providers.Free => Environment.GetEnvironmentVariable("OPENROUTER_API_KEY") ??
+            Provider.OpenRouter or Provider.Free => Environment.GetEnvironmentVariable("OPENROUTER_API_KEY") ??
                 throw new InvalidOperationException("OPENROUTER_API_KEY environment variable is not set."),
             _ => throw new NotImplementedException(),
         };

src/Cli/src/Helpers.cs

@@ -0,0 +1,10 @@
+namespace LangChain.Cli;
+
+internal enum Format
+{
+    Text,
+    Lines,
+    Json,
+    Markdown,
+    ConventionalCommit,
+}

src/Cli/src/Models/Format.cs

@@ -0,0 +1,9 @@
+namespace LangChain.Cli.Models;
+
+internal enum Provider
+{
+    OpenAi,
+    OpenRouter,
+    Anthropic,
+    Free,
+}

src/Cli/src/Models/Provider.cs

@@ -0,0 +1,12 @@
+namespace LangChain.Cli.Models;
+
+internal enum Tool
+{
+    Filesystem,
+    Fetch,
+    GitHub,
+    Git,
+    Puppeteer,
+    SequentialThinking,
+    Slack,
+}