feat: add --verbosity and --log-file CLI options

Wire Serilog logging to CLI commands:
- Add --log-file option to enable file logging from CLI
- Wire --verbosity to Serilog log levels (silent=Fatal, quiet=Warning, normal=Info, verbose=Debug)
- Inject ILoggerFactory via DI into all commands
- Update BaseCommand to accept ILoggerFactory
- Update all command constructors to pass logger factory
- Fix environment detector test isolation

Author: dluc

src/Main/CLI/CliApplicationBuilder.cs

@@ -1,9 +1,12 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using KernelMemory.Core.Config;
+using KernelMemory.Core.Logging;
 using KernelMemory.Main.CLI.Commands;
 using KernelMemory.Main.CLI.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Serilog.Events;
 using Spectre.Console.Cli;
 
 namespace KernelMemory.Main.CLI;
@@ -45,25 +48,36 @@ public sealed class CliApplicationBuilder
     /// </summary>
     /// <param name="args">Command line arguments (used to extract --config flag).</param>
     /// <returns>A configured CommandApp ready to execute commands.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope",
+        Justification = "ILoggerFactory lifetime is managed by DI container and must remain alive for duration of CLI execution")]
     public CommandApp Build(string[]? args = null)
     {
+        var actualArgs = args ?? [];
+
         // 1. Determine config path from args early (before command execution)
-        string configPath = this.DetermineConfigPath(args ?? []);
+        string configPath = this.DetermineConfigPath(actualArgs);
 
         // 2. Load config ONCE (happens before any command runs)
         AppConfig config = ConfigParser.LoadFromFile(configPath);
 
-        // 3. Create DI container and register AppConfig as singleton
+        // 3. Parse logging options from args and config
+        var loggingConfig = this.BuildLoggingConfig(actualArgs, config);
+
+        // 4. Create logger factory using Serilog
+        ILoggerFactory loggerFactory = SerilogFactory.CreateLoggerFactory(loggingConfig);
+
+        // 5. Create DI container and register services
         ServiceCollection services = new();
         services.AddSingleton(config);
+        services.AddSingleton(loggerFactory);
 
         // Also register the config path so commands can access it
         services.AddSingleton(new ConfigPathService(configPath));
 
-        // 4. Create type registrar for Spectre.Console.Cli DI integration
+        // 6. Create type registrar for Spectre.Console.Cli DI integration
         TypeRegistrar registrar = new(services);
 
-        // 5. Build CommandApp with DI support
+        // 7. Build CommandApp with DI support
         CommandApp app = new(registrar);
         this.Configure(app);
         return app;
@@ -93,6 +107,61 @@ private string DetermineConfigPath(string[] args)
             Constants.DefaultConfigFileName);
     }
 
+    /// <summary>
+    /// Builds logging configuration from CLI args and app config.
+    /// CLI args take precedence over config file settings.
+    /// </summary>
+    /// <param name="args">Command line arguments.</param>
+    /// <param name="config">Application configuration.</param>
+    /// <returns>Logging configuration for SerilogFactory.</returns>
+    private LoggingConfig BuildLoggingConfig(string[] args, AppConfig config)
+    {
+        // Start with config file settings or defaults
+        var loggingConfig = config.Logging ?? new LoggingConfig();
+
+        // Parse --verbosity / -v from args (takes precedence)
+        var verbosity = this.ParseArgValue(args, "--verbosity", "-v");
+        if (verbosity != null)
+        {
+            loggingConfig.Level = verbosity.ToLowerInvariant() switch
+            {
+                "silent" => LogEventLevel.Fatal,
+                "quiet" => LogEventLevel.Warning,
+                "verbose" => LogEventLevel.Debug,
+                _ => LogEventLevel.Information // "normal" and default
+            };
+        }
+
+        // Parse --log-file from args (takes precedence)
+        var logFile = this.ParseArgValue(args, "--log-file", null);
+        if (logFile != null)
+        {
+            loggingConfig.FilePath = logFile;
+        }
+
+        return loggingConfig;
+    }
+
+    /// <summary>
+    /// Parses a value for a command line argument.
+    /// </summary>
+    /// <param name="args">Command line arguments.</param>
+    /// <param name="longName">Long form of argument (e.g., "--verbosity").</param>
+    /// <param name="shortName">Short form of argument (e.g., "-v"), or null if none.</param>
+    /// <returns>The argument value, or null if not found.</returns>
+    private string? ParseArgValue(string[] args, string longName, string? shortName)
+    {
+        for (int i = 0; i < args.Length - 1; i++)
+        {
+            if (args[i] == longName || (shortName != null && args[i] == shortName))
+            {
+                return args[i + 1];
+            }
+        }
+
+        return null;
+    }
+
     /// <summary>
     /// Configures the CommandApp with all commands and examples.
     /// Made public to allow tests to reuse command configuration.

src/Main/CLI/Commands/BaseCommand.cs

@@ -15,28 +15,36 @@ namespace KernelMemory.Main.CLI.Commands;
 
 /// <summary>
 /// Base class for all CLI commands providing shared initialization logic.
-/// Config is injected via constructor (loaded once in CliApplicationBuilder).
+/// Config and LoggerFactory are injected via constructor (loaded once in CliApplicationBuilder).
 /// </summary>
 /// <typeparam name="TSettings">The command settings type, must inherit from GlobalOptions.</typeparam>
 public abstract class BaseCommand<TSettings> : AsyncCommand<TSettings>
     where TSettings : GlobalOptions
 {
     private readonly AppConfig _config;
+    private readonly ILoggerFactory _loggerFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="BaseCommand{TSettings}"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    protected BaseCommand(AppConfig config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    protected BaseCommand(AppConfig config, ILoggerFactory loggerFactory)
     {
         this._config = config ?? throw new ArgumentNullException(nameof(config));
+        this._loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
     }
 
     /// <summary>
     /// Gets the injected application configuration.
     /// </summary>
     protected AppConfig Config => this._config;
 
+    /// <summary>
+    /// Gets the injected logger factory.
+    /// </summary>
+    protected ILoggerFactory LoggerFactory => this._loggerFactory;
+
     /// <summary>
     /// Initializes command dependencies: node and formatter.
     /// Config is already injected via constructor (no file I/O).
@@ -121,15 +129,10 @@ protected ContentService CreateContentService(NodeConfig node, bool readonlyMode
 
         // Create dependencies
         var cuidGenerator = new CuidGenerator();
-        var logger = this.CreateLogger();
+        var logger = this._loggerFactory.CreateLogger<ContentStorageService>();
 
-        // Create search indexes from node configuration
-        var loggerFactory = LoggerFactory.Create(builder =>
-        {
-            builder.AddConsole();
-            builder.SetMinimumLevel(LogLevel.Warning);
-        });
-        var searchIndexes = SearchIndexFactory.CreateIndexes(node.SearchIndexes, loggerFactory);
+        // Create search indexes from node configuration using injected logger factory
+        var searchIndexes = SearchIndexFactory.CreateIndexes(node.SearchIndexes, this._loggerFactory);
 
         // Create storage service with search indexes
         var storage = new ContentStorageService(context, cuidGenerator, logger, searchIndexes);
@@ -138,23 +141,6 @@ protected ContentService CreateContentService(NodeConfig node, bool readonlyMode
         return new ContentService(storage, node.Id, searchIndexes);
     }
 
-    /// <summary>
-    /// Creates a simple console logger for ContentStorageService.
-    /// </summary>
-    /// <returns>A logger instance.</returns>
-    [SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope",
-        Justification = "LoggerFactory lifetime is managed by the logger infrastructure. CLI commands are short-lived and disposing would terminate logging prematurely.")]
-    private ILogger<ContentStorageService> CreateLogger()
-    {
-        var loggerFactory = LoggerFactory.Create(builder =>
-        {
-            builder.AddConsole();
-            builder.SetMinimumLevel(LogLevel.Warning);
-        });
-
-        return loggerFactory.CreateLogger<ContentStorageService>();
-    }
-
     /// <summary>
     /// Handles exceptions and returns appropriate exit code.
     /// </summary>

src/Main/CLI/Commands/ConfigCommand.cs

@@ -8,6 +8,7 @@
 using KernelMemory.Main.CLI.Infrastructure;
 using KernelMemory.Main.CLI.Models;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -49,10 +50,12 @@ public class ConfigCommand : BaseCommand<ConfigCommandSettings>
     /// Initializes a new instance of the <see cref="ConfigCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
     /// <param name="configPathService">Service providing the config file path (injected by DI).</param>
     public ConfigCommand(
         AppConfig config,
-        ConfigPathService configPathService) : base(config)
+        ILoggerFactory loggerFactory,
+        ConfigPathService configPathService) : base(config, loggerFactory)
     {
         this._configPathService = configPathService ?? throw new ArgumentNullException(nameof(configPathService));
     }

src/Main/CLI/Commands/DeleteCommand.cs

@@ -3,6 +3,7 @@
 using System.ComponentModel;
 using KernelMemory.Core.Config;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -43,7 +44,8 @@ public class DeleteCommand : BaseCommand<DeleteCommandSettings>
     /// Initializes a new instance of the <see cref="DeleteCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public DeleteCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public DeleteCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/Commands/GetCommand.cs

@@ -5,6 +5,7 @@
 using KernelMemory.Core.Storage.Models;
 using KernelMemory.Main.CLI.Exceptions;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -49,7 +50,8 @@ public class GetCommand : BaseCommand<GetCommandSettings>
     /// Initializes a new instance of the <see cref="GetCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public GetCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public GetCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/Commands/ListCommand.cs

@@ -5,6 +5,7 @@
 using KernelMemory.Core.Storage.Models;
 using KernelMemory.Main.CLI.Exceptions;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -56,7 +57,8 @@ public class ListCommand : BaseCommand<ListCommandSettings>
     /// Initializes a new instance of the <see cref="ListCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public ListCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public ListCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/Commands/NodesCommand.cs

@@ -2,6 +2,7 @@
 
 using KernelMemory.Core.Config;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console.Cli;
 
 namespace KernelMemory.Main.CLI.Commands;
@@ -22,7 +23,8 @@ public class NodesCommand : BaseCommand<NodesCommandSettings>
     /// Initializes a new instance of the <see cref="NodesCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public NodesCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public NodesCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/Commands/SearchCommand.cs

@@ -8,6 +8,7 @@
 using KernelMemory.Core.Search.Models;
 using KernelMemory.Main.CLI.Exceptions;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -144,7 +145,8 @@ public class SearchCommand : BaseCommand<SearchCommandSettings>
     /// Initializes a new instance of the <see cref="SearchCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public SearchCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public SearchCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/Commands/UpsertCommand.cs

@@ -4,6 +4,7 @@
 using KernelMemory.Core.Config;
 using KernelMemory.Core.Storage.Models;
 using KernelMemory.Main.CLI.OutputFormatters;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -65,7 +66,8 @@ public class UpsertCommand : BaseCommand<UpsertCommandSettings>
     /// Initializes a new instance of the <see cref="UpsertCommand"/> class.
     /// </summary>
     /// <param name="config">Application configuration (injected by DI).</param>
-    public UpsertCommand(AppConfig config) : base(config)
+    /// <param name="loggerFactory">Logger factory for creating loggers (injected by DI).</param>
+    public UpsertCommand(AppConfig config, ILoggerFactory loggerFactory) : base(config, loggerFactory)
     {
     }
 

src/Main/CLI/GlobalOptions.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 using System.ComponentModel;
+using Serilog.Events;
 using Spectre.Console;
 using Spectre.Console.Cli;
 
@@ -24,10 +25,14 @@ public class GlobalOptions : CommandSettings
     public string Format { get; init; } = "human";
 
     [CommandOption("-v|--verbosity")]
-    [Description("Verbosity: silent, quiet, normal, verbose")]
+    [Description("Log verbosity: silent, quiet, normal, verbose")]
     [DefaultValue("normal")]
     public string Verbosity { get; init; } = "normal";
 
+    [CommandOption("--log-file")]
+    [Description("Path to log file (enables file logging)")]
+    public string? LogFile { get; init; }
+
     [CommandOption("--no-color")]
     [Description("Disable colored output")]
     public bool NoColor { get; init; }
@@ -51,4 +56,20 @@ public override ValidationResult Validate()
 
         return ValidationResult.Success();
     }
+
+    /// <summary>
+    /// Maps the verbosity string to a Serilog LogEventLevel.
+    /// silent = Fatal only, quiet = Warning+, normal = Information+, verbose = Debug+
+    /// </summary>
+    /// <returns>The corresponding Serilog LogEventLevel.</returns>
+    public LogEventLevel GetLogLevel()
+    {
+        return this.Verbosity.ToLowerInvariant() switch
+        {
+            "silent" => LogEventLevel.Fatal,
+            "quiet" => LogEventLevel.Warning,
+            "verbose" => LogEventLevel.Debug,
+            _ => LogEventLevel.Information // "normal" and default
+        };
+    }
 }