Added new Input.inject feature.

Author: JordanMarr

.claude/settings.local.json

@@ -51,4 +51,5 @@ Desktop.ini
 *.dbmdl
 *.jfm
 /src/Tests/TestData/AdventureWorksLT_Temp.db
-**/Verify/*.received.*
+**/Verify/*.received.*
+.claude

.gitignore

@@ -11,6 +11,7 @@ _[Click here to view the old beta 4 README](README-beta4.md)_
 * `Input.option` helper avoids the need to use the `System.CommandLine.Option` type directly (which conflicts with the F# `Option` type) 
 * `Input.optionMaybe` and `Input.argumentMaybe` helpers allow you to use F# `option` types in your handler function.
 * `Input.context` helper allows you to pass the `ActionContext` to your action function which is necessary for some operations.
+* `Input.inject` helper allows you to inject pre-resolved dependencies (e.g., loggers, services) into your action function alongside parsed CLI inputs.
 * `Input.validate` helper allows you to validate against parsed value using the F# `Result` type.
 
 ## Example
@@ -70,6 +71,7 @@ The new `Input` module contains functions for the underlying System.CommandLine
 * `argumentMaybe` creates a named `Argument<'T option>` that defaults to `None`.
 * `option` creates a named `Option<'T>`
 * `optionMaybe` creates a named `Option<'T option>` that defaults to `None`.
+* `inject` wraps a pre-resolved dependency value for injection into the action inputs tuple.
 
 ### Input Properties
 * `acceptLegalFileNamesOnly` sets the option or argument to accept only values representing legal file names.
@@ -290,6 +292,37 @@ let main argv =
 
 </details>
 
+<details>
+<summary><b>Injecting Dependencies</b></summary>
+
+You can use `Input.inject` to pass pre-resolved dependencies into your action handler alongside parsed CLI inputs. This is useful for injecting loggers, database connections, or any other service.
+
+```F#
+open Serilog
+open FSharp.SystemCommandLine
+open Input
+
+[<EntryPoint>]
+let main argv =
+    let logger =
+        LoggerConfiguration()
+            .WriteTo.Console()
+            .CreateLogger()
+        |> Input.inject
+
+    let name = option<string> "--name" |> desc "Your name"
+
+    rootCommand argv {
+        description "Greets a user"
+        inputs (logger, name)
+        setAction (fun (logger: ILogger, name) ->
+            logger.Information("Hello, {Name}!", name)
+        )
+    }
+```
+
+</details>
+
 <details>
 <summary><b>Microsoft.Extensions.Hosting</b></summary>
 

README.md

@@ -14,6 +14,7 @@ let private parseInput<'V> (handlerInput: ActionInput) (pr: ParseResult) (cancel
     | ParsedOption o -> pr.GetValue<'V>(o :?> Option<'V>)
     | ParsedArgument a -> pr.GetValue<'V>(a :?> Argument<'V>)
     | Context -> { ParseResult = pr; CancellationToken = cancelToken } |> unbox<'V>
+    | Injection value -> value |> unbox<'V>
 
 type CommandSpec<'Inputs, 'Output> = 
     {
@@ -265,14 +266,14 @@ type BaseCommandBuilder<'A, 'B, 'C, 'D, 'E, 'F, 'G, 'H, 'Output>() =
             match input.Source with
             | ParsedOption o -> cmd.Add o
             | ParsedArgument a -> cmd.Add a
-            | Context -> ()
+            | Context | Injection _ -> ()
         )
         spec.ExtraInputs
         |> Seq.iter (fun input ->
             match input.Source with
             | ParsedOption o -> cmd.Add o
             | ParsedArgument a -> cmd.Add a
-            | Context -> ()
+            | Context | Injection _ -> ()
         )
         spec.SubCommands |> List.iter cmd.Add
         spec.Aliases |> List.iter cmd.Aliases.Add

src/FSharp.SystemCommandLine/CommandBuilders.fs

@@ -20,10 +20,11 @@ type ActionContext =
         CancellationToken: System.Threading.CancellationToken
     }
 
-type ActionInputSource = 
+type ActionInputSource =
     | ParsedOption of Option
     | ParsedArgument of Argument
     | Context
+    | Injection of obj
 
 type ActionInput(source: ActionInputSource) = 
     member this.Source = source
@@ -43,6 +44,7 @@ type ActionInput<'T>(inputType: ActionInputSource) =
         | ParsedOption o -> o :?> Option<'T> |> parseResult.GetValue
         | ParsedArgument a -> a :?> Argument<'T> |> parseResult.GetValue
         | Context -> parseResult |> unbox<'T>
+        | Injection value -> value |> unbox<'T>
 
 type Arity =
     | ArgumentArity of min: int * max: int
@@ -77,9 +79,13 @@ type Arity =
 module Input = 
 
     /// Injects an `ActionContext` into the action which contains the `ParseResult` and a cancellation token.
-    let context = 
+    let context =
         ActionInput<ActionContext>(Context)
 
+    /// Injects a dependency value into the action inputs tuple.
+    let inject<'T> (value: 'T) =
+        ActionInput<'T>(Injection (box value))
+
     /// Creates a named option. Example: `option "--file-name"`
     let option<'T> (name: string) = 
         Option<'T>(name) |> ActionInput.OfOption

src/FSharp.SystemCommandLine/Inputs.fs

@@ -203,3 +203,44 @@ let ``09 tryParser Directory Info`` () =
         )
     } =! 1 // Should fail
     actionCalled =! false
+
+type AppSettings = { ConnectionString: string; MaxRetries: int }
+
+[<Test>]
+let ``10 - Input_inject should pass a dependency into the action`` () =
+    let settings = { ConnectionString = "Server=localhost"; MaxRetries = 3 }
+
+    testRootCommand "--name Jordan" {
+        description "Inject a dependency"
+        inputs (
+            option<string> "--name" |> desc "Your name",
+            inject settings
+        )
+        setAction (fun (name, injectedSettings) ->
+            name =! "Jordan"
+            injectedSettings =! settings
+            actionCalled <- true
+        )
+    } =! 0
+    actionCalled =! true
+
+type Env = { GetRandom: int -> int -> int }
+
+[<Test>]
+let ``11 - Input_inject should allow injecting behavior into a pure action`` () =
+    let env = { GetRandom = fun min max -> 42 }
+
+    testRootCommand "--count 5" {
+        description "Generate random numbers"
+        inputs (
+            inject env,
+            option<int> "--count" |> desc "How many numbers to generate"
+        )
+        setAction (fun (env, count) ->
+            let result = env.GetRandom 1 100
+            count =! 5
+            result =! 42
+            actionCalled <- true
+        )
+    } =! 0
+    actionCalled =! true

src/Tests/SimpleAppTest.fs

@@ -1,14 +1,15 @@
-#r "nuget: Fun.Build, 1.0.5"
+#r "nuget: Fun.Build, 1.1.17"
 
 open Fun.Build
 
 let src = __SOURCE_DIRECTORY__
+let fsproj = $"{src}/FSharp.SystemCommandLine/FSharp.SystemCommandLine.fsproj"
 
-pipeline "CI Build" {
+pipeline "Build" {
 
     stage "Build FSharp.SystemCommandLine.sln" {
-        run $"dotnet restore {src}/FSharp.SystemCommandLine/FSharp.SystemCommandLine.fsproj"
-        run $"dotnet build {src}/FSharp.SystemCommandLine/FSharp.SystemCommandLine.fsproj --configuration Release"
+        run $"dotnet restore {fsproj}"
+        run $"dotnet build {fsproj} --configuration Release"
     }
 
     stage "Run Tests" {
@@ -18,4 +19,24 @@ pipeline "CI Build" {
     runIfOnlySpecified false
 }
 
+open System.Xml.Linq
+
+pipeline "Publish" {
+
+    stage "Pack" {
+        run $"dotnet pack {fsproj} --configuration Release"
+    }
+
+    stage "Push to NuGet" {
+        run (fun _ -> 
+            let version = XDocument.Load(fsproj).Descendants(XName.Get "Version") |> Seq.head |> _.Value
+            let nupkg = $"{src}/FSharp.SystemCommandLine/bin/Release/FSharp.SystemCommandLine.%s{version}.nupkg"
+            let nugetKey = System.Environment.GetEnvironmentVariable("NUGET_KEY")
+            $"dotnet nuget push %s{nupkg} --source https://api.nuget.org/v3/index.json --api-key %s{nugetKey} --skip-duplicate"
+        )
+    }
+
+    runIfOnlySpecified true
+}
+
 tryPrintPipelineCommandHelp ()

src/build.fsx

@@ -0,0 +1 @@
+dotnet fsi build.fsx -- -p Build -p Publish