aia 0.9.24 → 0.10.2

data/lib/aia/logger.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+# lib/aia/logger.rb
+#
+# Centralized logger management for AIA using Lumberjack.
+# Provides loggers for three systems:
+#   - aia: Used within the AIA codebase for application-level logging
+#   - llm: Passed to RubyLLM gem's configuration (RubyLLM.logger)
+#   - mcp: Passed to RubyLLM::MCP process (RubyLLM::MCP.logger)
+#
+# Configuration is read from AIA.config.logger section:
+#   logger:
+#     aia:
+#       file: STDOUT
+#       level: warn
+#     llm:
+#       file: STDOUT
+#       level: warn
+#     mcp:
+#       file: STDOUT
+#       level: warn
+#
+# Lumberjack provides structured logging, context isolation,
+# automatic log file rolling, and multi-process safe file writes.
+#
+# For testing, use test_mode! to switch to Lumberjack's :test device:
+#   AIA::LoggerManager.test_mode!
+#   # ... run tests ...
+#   AIA::LoggerManager.clear_test_logs!  # between tests
+#   entries = AIA::LoggerManager.aia_logger.device.entries  # inspect logs
+
+require 'lumberjack'
+
+module AIA
+  module LoggerManager
+    # Log level mapping from config strings to Lumberjack severity constants
+    LOG_LEVELS = {
+      'debug' => Lumberjack::Severity::DEBUG,
+      'info'  => Lumberjack::Severity::INFO,
+      'warn'  => Lumberjack::Severity::WARN,
+      'error' => Lumberjack::Severity::ERROR,
+      'fatal' => Lumberjack::Severity::FATAL
+    }.freeze
+
+    class << self
+      # Track whether we're in test mode
+      attr_accessor :test_mode
+
+      # Get or create the AIA application logger
+      #
+      # @return [Lumberjack::Logger] The AIA logger instance
+      def aia_logger
+        @aia_logger ||= create_logger(:aia)
+      end
+
+      # Get or create the RubyLLM logger
+      #
+      # @return [Lumberjack::Logger] The LLM logger instance
+      def llm_logger
+        @llm_logger ||= create_logger(:llm)
+      end
+
+      # Get or create the RubyLLM::MCP logger
+      #
+      # @return [Lumberjack::Logger] The MCP logger instance
+      def mcp_logger
+        @mcp_logger ||= create_logger(:mcp)
+      end
+
+      # Configure RubyLLM's logger
+      # RubyLLM.logger is a memoized method that uses config.logger or creates a new one.
+      # We need to:
+      # 1. Set config.logger to our logger
+      # 2. Set config.log_file in case the logger gets recreated
+      # 3. Reset the memoized @logger so next call uses our config
+      def configure_llm_logger
+        return unless defined?(RubyLLM)
+
+        logger = llm_logger
+
+        # Set our logger on the RubyLLM config object
+        if RubyLLM.config.respond_to?(:logger=)
+          RubyLLM.config.logger = logger
+        end
+
+        # Also set log_file and log_level in case the logger gets recreated
+        if RubyLLM.config.respond_to?(:log_file=)
+          file = effective_log_file(logger_config_for(:llm))
+          RubyLLM.config.log_file = resolve_log_file_io(file)
+        end
+
+        if RubyLLM.config.respond_to?(:log_level=)
+          level = effective_log_level(logger_config_for(:llm))
+          RubyLLM.config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
+        end
+
+        # Reset the memoized @logger on RubyLLM module so next call uses our config
+        # RubyLLM.logger does: @logger ||= config.logger || Logger.new(...)
+        RubyLLM.instance_variable_set(:@logger, nil) if RubyLLM.instance_variable_defined?(:@logger)
+      end
+
+      # Configure RubyLLM::MCP's logger
+      # RubyLLM::MCP.config has attr_writer :logger and a memoized getter.
+      # We need to set both the config.logger and reset any memoization.
+      def configure_mcp_logger
+        return unless defined?(RubyLLM::MCP)
+
+        logger = mcp_logger
+
+        # First reset the memoized @logger so our settings take effect
+        # RubyLLM::MCP.config.logger does: @logger ||= Logger.new(...)
+        config = RubyLLM::MCP.config
+        config.instance_variable_set(:@logger, nil) if config.instance_variable_defined?(:@logger)
+
+        # Set our logger on the MCP config object
+        # RubyLLM::MCP.config has attr_writer :logger (which sets @logger directly)
+        if config.respond_to?(:logger=)
+          config.logger = logger
+        end
+
+        # Also set log_file and log_level in case the logger gets recreated
+        if config.respond_to?(:log_file=)
+          file = effective_log_file(logger_config_for(:mcp))
+          config.log_file = resolve_log_file_io(file)
+        end
+
+        if config.respond_to?(:log_level=)
+          level = effective_log_level(logger_config_for(:mcp))
+          config.log_level = LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN)
+        end
+      end
+
+      # Convert log file specification to IO object or file path
+      # RubyLLM::MCP expects an IO object or file path for log_file config
+      def resolve_log_file_io(file)
+        case file.to_s.upcase
+        when 'STDOUT'
+          $stdout
+        when 'STDERR'
+          $stderr
+        else
+          File.expand_path(file)
+        end
+      end
+
+      # Get the log level symbol for RubyLLM configuration
+      #
+      # @return [Symbol] The log level as a symbol (e.g., :warn, :debug)
+      def llm_log_level_symbol
+        config = logger_config_for(:llm)
+        level = effective_log_level(config)
+        level.to_sym
+      end
+
+      # Reset all cached loggers (useful for testing or reconfiguration)
+      def reset!
+        @aia_logger = nil
+        @llm_logger = nil
+        @mcp_logger = nil
+        @test_mode = false
+      end
+
+      # =======================================================================
+      # Test Mode Support
+      # =======================================================================
+      # Use Lumberjack's :test device to capture log entries in memory
+      # for assertions in tests.
+
+      # Enable test mode - all loggers will use Lumberjack's :test device
+      # which captures entries in memory for inspection and assertions.
+      #
+      # @param level [Symbol, String] Log level for test loggers (default: :debug)
+      def test_mode!(level: :debug)
+        reset!
+        @test_mode = true
+        @test_level = LOG_LEVELS.fetch(level.to_s, Lumberjack::Severity::DEBUG)
+
+        # Pre-create loggers with test devices
+        @aia_logger = create_test_logger(:aia)
+        @llm_logger = create_test_logger(:llm)
+        @mcp_logger = create_test_logger(:mcp)
+
+        # Surface logging errors in tests instead of swallowing them
+        Lumberjack.raise_logger_errors = true
+      end
+
+      # Check if test mode is enabled
+      #
+      # @return [Boolean] true if in test mode
+      def test_mode?
+        @test_mode == true
+      end
+
+      # Clear all test log entries (call between tests)
+      def clear_test_logs!
+        return unless test_mode?
+
+        [@aia_logger, @llm_logger, @mcp_logger].each do |logger|
+          logger&.device&.clear if logger&.device.respond_to?(:clear)
+        end
+      end
+
+      # Get all entries from a specific test logger
+      #
+      # @param system [Symbol] The logger to get entries from (:aia, :llm, :mcp)
+      # @return [Array<Lumberjack::LogEntry>] Array of log entries
+      def test_entries(system = :aia)
+        logger = case system
+                 when :aia then aia_logger
+                 when :llm then llm_logger
+                 when :mcp then mcp_logger
+                 else raise ArgumentError, "Unknown logger: #{system}"
+                 end
+
+        return [] unless logger&.device.respond_to?(:entries)
+
+        logger.device.entries
+      end
+
+      # Get the last entry from a specific test logger
+      #
+      # @param system [Symbol] The logger to get entry from (:aia, :llm, :mcp)
+      # @return [Lumberjack::LogEntry, nil] The last log entry or nil
+      def last_test_entry(system = :aia)
+        test_entries(system).last
+      end
+
+      private
+
+      # Create a test logger with Lumberjack's :test device
+      #
+      # @param system [Symbol] The system name for progname
+      # @return [Lumberjack::Logger] Logger with test device
+      def create_test_logger(system)
+        Lumberjack::Logger.new(
+          :test,
+          level: @test_level || Lumberjack::Severity::DEBUG,
+          progname: system.to_s.upcase
+        )
+      end
+
+      # Create a logger instance from configuration
+      #
+      # @param system [Symbol] The system to create a logger for (:aia, :llm, :mcp)
+      # @return [Lumberjack::Logger] Configured logger instance
+      def create_logger(system)
+        config = logger_config_for(system)
+
+        file  = effective_log_file(config)
+        level = effective_log_level(config, system)
+        flush = config&.flush != false  # default to true
+
+        device = create_device(file, flush: flush)
+        Lumberjack::Logger.new(
+          device,
+          level:    LOG_LEVELS.fetch(level, Lumberjack::Severity::WARN),
+          progname: system.to_s.upcase
+        )
+      end
+
+      # Get the effective log file, considering any override
+      #
+      # @param config [ConfigSection, nil] The logger config for a specific system
+      # @return [String] The log file path or STDOUT/STDERR
+      def effective_log_file(config)
+        # CLI override (--log-to) takes precedence over per-system config
+        override = AIA.config&.log_file_override
+        return override if override && !override.to_s.empty?
+
+        config&.file || 'STDOUT'
+      end
+
+      # Get the effective log level, considering any override
+      #
+      # @param config [ConfigSection, nil] The logger config for a specific system
+      # @return [String] The log level to use
+      def effective_log_level(config, _system = nil)
+        # CLI override takes precedence over per-system config
+        override = AIA.config&.log_level_override
+        return override.to_s.downcase if override && !override.to_s.empty?
+
+        config&.level&.to_s&.downcase || 'warn'
+      end
+
+      # Create appropriate Lumberjack device based on file config
+      #
+      # @param file [String] The file config value
+      # @param flush [Boolean] If true, flush immediately (no buffering)
+      # @return [Lumberjack::Device] The device instance
+      def create_device(file, flush: true)
+        # buffer_size: 0 means immediate flush (no buffering)
+        buffer_size = flush ? 0 : 8192
+
+        case file.to_s.upcase
+        when 'STDOUT'
+          Lumberjack::Device::Writer.new($stdout, buffer_size: buffer_size)
+        when 'STDERR'
+          Lumberjack::Device::Writer.new($stderr, buffer_size: buffer_size)
+        else
+          path = File.expand_path(file)
+          # Use date rolling for file-based logs
+          # Multiple loggers can safely write to the same file
+          Lumberjack::Device::DateRollingLogFile.new(
+            path,
+            roll: :daily,
+            buffer_size: buffer_size
+          )
+        end
+      end
+
+      # Get the logger configuration for a specific system
+      #
+      # @param system [Symbol] The system (:aia, :llm, :mcp)
+      # @return [ConfigSection, nil] The configuration section
+      def logger_config_for(system)
+        return nil unless AIA.config&.logger
+
+        case system
+        when :aia then AIA.config.logger.aia
+        when :llm then AIA.config.logger.llm
+        when :mcp then AIA.config.logger.mcp
+        end
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+end

data/lib/aia/prompt_handler.rb

@@ -8,14 +8,14 @@ require 'erb'
 module AIA
   class PromptHandler
     def initialize
-      @prompts_dir         = AIA.config.prompts_dir
-      @roles_dir           = AIA.config.roles_dir # A sub-directory of @prompts_dir
+      @prompts_dir         = AIA.config.prompts.dir
+      @roles_dir           = AIA.config.prompts.roles_dir # A sub-directory of @prompts_dir
       @directive_processor = AIA::DirectiveProcessor.new
 
       PromptManager::Prompt.storage_adapter =
         PromptManager::Storage::FileSystemAdapter.config do |c|
           c.prompts_dir      = @prompts_dir
-          c.prompt_extension = '.txt'  # default
+          c.prompt_extension = AIA.config.prompts.extname
           c.params_extension = '.json' # default
         end.new
     end
@@ -24,7 +24,7 @@ module AIA
     def get_prompt(prompt_id, role_id = '')
       prompt = fetch_prompt(prompt_id)
 
-      unless role_id.empty?
+      unless role_id.nil? || role_id.empty?
         role_prompt = fetch_role(role_id)
         prompt.text.prepend(role_prompt.text)
       end
@@ -45,8 +45,8 @@ module AIA
           id: prompt_id,
           directives_processor: @directive_processor,
           external_binding: binding,
-          erb_flag: AIA.config.erb,
-          envar_flag: AIA.config.shell
+          erb_flag: AIA.config.flags.erb,
+          envar_flag: AIA.config.flags.shell
         )
 
         # Parameters should be extracted during initialization or to_s
@@ -66,12 +66,8 @@ module AIA
         exit 1
       end
       
-      if AIA.config.fuzzy
+      if AIA.config.flags.fuzzy
         return fuzzy_search_prompt(prompt_id)
-      elsif AIA.config.fuzzy
-        puts "Warning: Fuzzy search is enabled but Fzf tool is not available."
-        STDERR.puts "Error: Could not find prompt with ID: #{prompt_id}"
-        exit 1
       else
         STDERR.puts "Error: Could not find prompt with ID: #{prompt_id}"
         exit 1
@@ -89,8 +85,8 @@ module AIA
         id: new_prompt_id,
         directives_processor: @directive_processor,
         external_binding: binding,
-        erb_flag: AIA.config.erb,
-        envar_flag: AIA.config.shell
+        erb_flag: AIA.config.flags.erb,
+        envar_flag: AIA.config.flags.shell
       )
 
       raise "Error: Could not find prompt with ID: #{prompt_id} even with fuzzy search" if prompt.nil?
@@ -103,8 +99,8 @@ module AIA
       return handle_missing_role("roles/") if role_id.nil?
 
       # Prepend roles_prefix if not already present
-      unless role_id.start_with?(AIA.config.roles_prefix)
-        role_id = "#{AIA.config.roles_prefix}/#{role_id}"
+      unless role_id.start_with?(AIA.config.prompts.roles_prefix)
+        role_id = "#{AIA.config.prompts.roles_prefix}/#{role_id}"
       end
 
       # NOTE: roles_prefix is a sub-directory of the prompts directory
@@ -115,8 +111,8 @@ module AIA
           id: role_id,
           directives_processor: @directive_processor,
           external_binding: binding,
-          erb_flag: AIA.config.erb,
-          envar_flag: AIA.config.shell
+          erb_flag: AIA.config.flags.erb,
+          envar_flag: AIA.config.flags.shell
         )
         return role_prompt if role_prompt
       else
@@ -155,7 +151,7 @@ module AIA
         exit 1
       end
       
-      if AIA.config.fuzzy
+      if AIA.config.flags.fuzzy
         return fuzzy_search_role(role_id)
       else
         STDERR.puts "Error: Could not find role with ID: #{role_id}"
@@ -173,8 +169,8 @@ module AIA
         id: new_role_id,
         directives_processor: @directive_processor,
         external_binding: binding,
-        erb_flag: AIA.config.erb,
-        envar_flag: AIA.config.shell
+        erb_flag: AIA.config.flags.erb,
+        envar_flag: AIA.config.flags.shell
       )
 
       raise "Error: Could not find role with ID: #{role_id} even with fuzzy search" if role_prompt.nil?
@@ -214,8 +210,8 @@ module AIA
         raise "No role ID selected"
       end
 
-      unless role.start_with?(AIA.config.role_prefix)
-        role = AIA.config.role_prefix + '/' + role
+      unless role.start_with?(AIA.config.prompts.roles_prefix)
+        role = AIA.config.prompts.roles_prefix + '/' + role
       end
 
       role