makit 0.0.111 → 0.0.112

data/lib/makit/logging/logger.rb

@@ -1,159 +1,163 @@
-# frozen_string_literal: true
-
-require "set"
-require_relative "log_request"
-require_relative "sinks/base"
-require_relative "sinks/console"
-require_relative "sinks/file_sink"
-require_relative "sinks/structured"
-
-module Makit
-  module Logging
-    # Main logger class that orchestrates logging through sinks
-    #
-    # This class provides a clean interface for logging with support for
-    # sink-based output processing. It follows the same pattern as the
-    # Commands::Runner but for logging operations.
-    #
-    # @example Basic usage
-    #   logger = Logger.new
-    #   logger.info("Processing started")
-    #
-    # @example With custom sinks
-    #   logger = Logger.new(
-    #     sinks: [
-    #       Sinks::Console.new,
-    #       Sinks::File.new(log_file: "custom.log")
-    #     ]
-    #   )
-    #
-    # @example Using convenience methods
-    #   logger.success("Build completed")
-    #   logger.error("Build failed", { repository: "user/repo" })
-    class Logger
-      # @return [Array<Sinks::Base>] list of sinks to process log requests
-      attr_reader :sinks
-      # @return [Symbol] minimum log level for filtering
-      attr_reader :level
-
-      # Initialize the logger with sinks and log level
-      #
-      # @param sinks [Array<Sinks::Base>] list of sinks to use
-      # @param level [Symbol] minimum log level (:debug, :info, :warn, :error, :fatal, :success)
-      def initialize(sinks: [], level: :info)
-        @sinks = sinks
-        @level = level
-        @logged_tasks = Set.new
-      end
-
-      # Log a message with the specified level
-      #
-      # @param level [Symbol] the log level (:debug, :info, :warn, :error, :fatal, :success)
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def log(level, message, context = {})
-        return unless should_log?(level)
-
-        log_request = LogRequest.new(level, message, context)
-        execute_sinks(log_request)
-      end
-
-      # Log an info message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def info(message, context = {})
-        log(:info, message, context)
-      end
-
-      # Log a success message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def success(message, context = {})
-        log(:success, message, context)
-      end
-
-      # Log an error message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def error(message, context = {})
-        log(:error, message, context)
-      end
-
-      # Log a warning message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def warn(message, context = {})
-        log(:warn, message, context)
-      end
-
-      # Log a debug message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def debug(message, context = {})
-        log(:debug, message, context)
-      end
-
-      # Log a fatal message
-      #
-      # @param message [String] the log message
-      # @param context [Hash] additional context information
-      # @return [void]
-      def fatal(message, context = {})
-        log(:fatal, message, context)
-      end
-
-      def task_start(message, context = {})
-        return if @logged_tasks.include?(message)
-        @logged_tasks.add(message)
-        log(:info, message, context)
-      end
-
-      # Get logger configuration
-      #
-      # @return [Hash] logger configuration
-      def config
-        {
-          level: @level,
-          sinks_count: @sinks.length,
-          sinks: @sinks.map(&:config),
-        }
-      end
-
-      private
-
-      # Check if a log level should be processed
-      #
-      # @param level [Symbol] the log level to check
-      # @return [Boolean] true if the level should be logged
-      def should_log?(level)
-        levels = [:debug, :info, :warn, :error, :fatal, :success]
-        levels.index(level) >= levels.index(@level)
-      end
-
-      # Execute the sink chain for a log request
-      #
-      # @param log_request [LogRequest] the log request to process
-      # @return [void]
-      def execute_sinks(log_request)
-        # Filter applicable sinks
-        applicable_sinks = @sinks.select { |s| s.applicable?(log_request) }
-
-        # Execute sink chain
-        applicable_sinks.reduce(log_request) do |request, sink|
-          sink.call(request)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "set"
+require_relative "log_request"
+require_relative "sinks/base"
+require_relative "sinks/console"
+require_relative "sinks/file_sink"
+require_relative "sinks/structured"
+
+module Makit
+  module Logging
+    # Main logger class that orchestrates logging through sinks
+    #
+    # This class provides a clean interface for logging with support for
+    # sink-based output processing. It follows the same pattern as the
+    # Commands::Runner but for logging operations.
+    #
+    # @example Basic usage
+    #   logger = Logger.new
+    #   logger.info("Processing started")
+    #
+    # @example With custom sinks
+    #   logger = Logger.new(
+    #     sinks: [
+    #       Sinks::Console.new,
+    #       Sinks::File.new(log_file: "custom.log")
+    #     ]
+    #   )
+    #
+    # @example Using convenience methods
+    #   logger.success("Build completed")
+    #   logger.error("Build failed", { repository: "user/repo" })
+    class Logger
+      # @return [Array<Sinks::Base>] list of sinks to process log requests
+      attr_reader :sinks
+      # @return [Symbol] minimum log level for filtering
+      attr_reader :level
+
+      # Initialize the logger with sinks and log level
+      #
+      # @param sinks [Array<Sinks::Base>] list of sinks to use
+      # @param level [Symbol] minimum log level (:debug, :info, :warn, :error, :fatal, :success)
+      def initialize(sinks: [], level: :info)
+        @sinks = sinks
+        @level = level
+        @logged_tasks = Set.new
+      end
+
+      # Log a message with the specified level
+      #
+      # @param level [Symbol] the log level (:debug, :info, :warn, :error, :fatal, :success)
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def log(level, message, context = {})
+        return unless should_log?(level)
+
+        log_request = LogRequest.new(level, message, context)
+        execute_sinks(log_request)
+      end
+
+      # Log an info message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def info(message, context = {})
+        log(:info, message, context)
+      end
+
+      # Log a success message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def success(message, context = {})
+        log(:success, message, context)
+      end
+
+      # Log an error message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def error(message, context = {})
+        log(:error, message, context)
+      end
+
+      # Log a warning message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def warn(message, context = {})
+        log(:warn, message, context)
+      end
+
+      # Log a debug message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def debug(message, context = {})
+        log(:debug, message, context)
+      end
+
+      # Log a fatal message
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def fatal(message, context = {})
+        log(:fatal, message, context)
+      end
+
+      def task_start(message, context = {})
+        return if @logged_tasks.include?(message)
+        @logged_tasks.add(message)
+        # Format task name with colon prefix and bold white styling
+        formatted_message = ": #{message}".colorize(:white).bold
+        # Add special context to identify task messages
+        task_context = context.merge(task_message: true)
+        log(:info, formatted_message, task_context)
+      end
+
+      # Get logger configuration
+      #
+      # @return [Hash] logger configuration
+      def config
+        {
+          level: @level,
+          sinks_count: @sinks.length,
+          sinks: @sinks.map(&:config),
+        }
+      end
+
+      private
+
+      # Check if a log level should be processed
+      #
+      # @param level [Symbol] the log level to check
+      # @return [Boolean] true if the level should be logged
+      def should_log?(level)
+        levels = [:debug, :info, :warn, :error, :fatal, :success]
+        levels.index(level) >= levels.index(@level)
+      end
+
+      # Execute the sink chain for a log request
+      #
+      # @param log_request [LogRequest] the log request to process
+      # @return [void]
+      def execute_sinks(log_request)
+        # Filter applicable sinks
+        applicable_sinks = @sinks.select { |s| s.applicable?(log_request) }
+
+        # Execute sink chain
+        applicable_sinks.reduce(log_request) do |request, sink|
+          sink.call(request)
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/sinks/console.rb

@@ -1,72 +1,72 @@
-# frozen_string_literal: true
-
-require_relative "unified_file_sink"
-
-module Makit
-  module Logging
-    module Sinks
-      # Console sink for clean, colored log output
-      #
-      # This is a thin wrapper around UnifiedFileSink that provides a simple
-      # API for console output. It maintains backward compatibility while
-      # leveraging the unified logging architecture.
-      #
-      # @example Basic usage
-      #   console = Console.new
-      #   logger = Logger.new(sinks: [console])
-      #   logger.info("Processing started")
-      #   # Shows: → Processing started
-      #
-      # @example With custom formatter options
-      #   console = Console.new(show_timestamp: true, show_level: true)
-      #
-      # @example With custom formatter
-      #   console = Console.new(formatter: :text)
-      class Console < UnifiedFileSink
-        # @return [Symbol] the format being used
-        attr_reader :format
-
-        # Initialize console sink
-        #
-        # @param formatter [Symbol, String] formatter name (default: :console)
-        # @param show_timestamp [Boolean] whether to show timestamps (default: false)
-        # @param show_level [Boolean] whether to show log levels (default: false)
-        # @param formatter_options [Hash] additional formatter options
-        def initialize(formatter: :console, show_timestamp: false, show_level: false, **formatter_options)
-          @format = formatter.to_sym
-
-          # Build configuration for UnifiedFileSink
-          configuration = {
-            file: $stdout,
-            format: @format,
-            formatter_options: {
-              show_timestamp: show_timestamp,
-              show_level: show_level,
-            }.merge(formatter_options),
-          }
-
-          super(configurations: [configuration])
-        end
-
-        # Get sink configuration
-        #
-        # @return [Hash] sink configuration
-        def config
-          {
-            name: self.class.name.split("::").last,
-            format: @format,
-            colors_enabled: true,
-            unified_sink: true,
-          }
-        end
-
-        # Check if this is a console sink (for compatibility)
-        #
-        # @return [Boolean] always true for Console sink
-        def console?
-          true
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "unified_file_sink"
+
+module Makit
+  module Logging
+    module Sinks
+      # Console sink for clean, colored log output
+      #
+      # This is a thin wrapper around UnifiedFileSink that provides a simple
+      # API for console output. It maintains backward compatibility while
+      # leveraging the unified logging architecture.
+      #
+      # @example Basic usage
+      #   console = Console.new
+      #   logger = Logger.new(sinks: [console])
+      #   logger.info("Processing started")
+      #   # Shows: → Processing started
+      #
+      # @example With custom formatter options
+      #   console = Console.new(show_timestamp: true, show_level: true)
+      #
+      # @example With custom formatter
+      #   console = Console.new(formatter: :text)
+      class Console < UnifiedFileSink
+        # @return [Symbol] the format being used
+        attr_reader :format
+
+        # Initialize console sink
+        #
+        # @param formatter [Symbol, String] formatter name (default: :console)
+        # @param show_timestamp [Boolean] whether to show timestamps (default: false)
+        # @param show_level [Boolean] whether to show log levels (default: false)
+        # @param formatter_options [Hash] additional formatter options
+        def initialize(formatter: :console, show_timestamp: false, show_level: false, **formatter_options)
+          @format = formatter.to_sym
+
+          # Build configuration for UnifiedFileSink
+          configuration = {
+            file: $stdout,
+            format: @format,
+            formatter_options: {
+              show_timestamp: show_timestamp,
+              show_level: show_level,
+            }.merge(formatter_options),
+          }
+
+          super(configurations: [configuration])
+        end
+
+        # Get sink configuration
+        #
+        # @return [Hash] sink configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            format: @format,
+            colors_enabled: true,
+            unified_sink: true,
+          }
+        end
+
+        # Check if this is a console sink (for compatibility)
+        #
+        # @return [Boolean] always true for Console sink
+        def console?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/makit/logging/sinks/file_sink.rb

@@ -1,92 +1,92 @@
-# frozen_string_literal: true
-
-require_relative "unified_file_sink"
-
-module Makit
-  module Logging
-    module Sinks
-      # File sink for writing log entries to files
-      #
-      # This sink is a thin wrapper around UnifiedFileSink that provides
-      # a simpler API for single-file logging. It maintains backward compatibility
-      # with the original FileSink interface while leveraging the more robust
-      # UnifiedFileSink implementation.
-      #
-      # @example Basic usage with default JSON formatter
-      #   file_sink = FileSink.new(log_file: "makit.log")
-      #   logger = Logger.new(sinks: [file_sink])
-      #   logger.info("Processing started")
-      #
-      # @example Using built-in formatters
-      #   file_sink = FileSink.new(
-      #     log_file: "makit.log",
-      #     formatter: :text
-      #   )
-      #
-      # @example Using custom formatter options
-      #   file_sink = FileSink.new(
-      #     log_file: "makit.log",
-      #     formatter: :json,
-      #     include_context: true,
-      #     include_metadata: true
-      #   )
-      class FileSink < Base
-        # @return [String] path to the log file
-        attr_reader :log_file
-        # @return [Symbol] the formatter format name
-        attr_reader :formatter
-        # @return [Boolean] whether to append to existing file (true) or overwrite (false)
-        attr_reader :append
-        # @return [UnifiedFileSink] the underlying unified sink
-        attr_reader :unified_sink
-
-        # Initialize file sink
-        #
-        # @param log_file [String] path to the log file
-        # @param formatter [Symbol, String] formatter format name
-        # @param append [Boolean] whether to append to existing file (true) or overwrite (false)
-        # @param include_context [Boolean] whether to include context in formatted output
-        # @param include_metadata [Boolean] whether to include metadata in formatted output
-        # @param show_timestamp [Boolean] whether to show timestamp in formatted output
-        # @param show_level [Boolean] whether to show log level in formatted output
-        def initialize(log_file: "makit.log", formatter: :json, append: true, **formatter_options)
-          @log_file = log_file
-          @formatter = formatter.to_sym
-          @append = append
-
-          # Create unified sink configuration
-          config = {
-            file: @log_file,
-            format: @formatter,
-            append: @append,
-          }.merge(formatter_options)
-
-          @unified_sink = UnifiedFileSink.new(configurations: [config])
-        end
-
-        # Execute sink logic to write log entry to file
-        #
-        # @param log_request [LogRequest] the log request to process
-        # @yield [LogRequest] yields the processed log request to the next sink
-        # @yieldreturn [LogRequest] the processed log request
-        # @return [LogRequest] the final processed log request
-        def call(log_request, &block)
-          @unified_sink.call(log_request, &block)
-        end
-
-        # Get sink configuration
-        #
-        # @return [Hash] sink configuration
-        def config
-          {
-            name: self.class.name.split("::").last,
-            log_file: @log_file,
-            formatter: @formatter,
-            append: @append,
-            unified_config: @unified_sink.config,
-          }
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "unified_file_sink"
+
+module Makit
+  module Logging
+    module Sinks
+      # File sink for writing log entries to files
+      #
+      # This sink is a thin wrapper around UnifiedFileSink that provides
+      # a simpler API for single-file logging. It maintains backward compatibility
+      # with the original FileSink interface while leveraging the more robust
+      # UnifiedFileSink implementation.
+      #
+      # @example Basic usage with default JSON formatter
+      #   file_sink = FileSink.new(log_file: "makit.log")
+      #   logger = Logger.new(sinks: [file_sink])
+      #   logger.info("Processing started")
+      #
+      # @example Using built-in formatters
+      #   file_sink = FileSink.new(
+      #     log_file: "makit.log",
+      #     formatter: :text
+      #   )
+      #
+      # @example Using custom formatter options
+      #   file_sink = FileSink.new(
+      #     log_file: "makit.log",
+      #     formatter: :json,
+      #     include_context: true,
+      #     include_metadata: true
+      #   )
+      class FileSink < Base
+        # @return [String] path to the log file
+        attr_reader :log_file
+        # @return [Symbol] the formatter format name
+        attr_reader :formatter
+        # @return [Boolean] whether to append to existing file (true) or overwrite (false)
+        attr_reader :append
+        # @return [UnifiedFileSink] the underlying unified sink
+        attr_reader :unified_sink
+
+        # Initialize file sink
+        #
+        # @param log_file [String] path to the log file
+        # @param formatter [Symbol, String] formatter format name
+        # @param append [Boolean] whether to append to existing file (true) or overwrite (false)
+        # @param include_context [Boolean] whether to include context in formatted output
+        # @param include_metadata [Boolean] whether to include metadata in formatted output
+        # @param show_timestamp [Boolean] whether to show timestamp in formatted output
+        # @param show_level [Boolean] whether to show log level in formatted output
+        def initialize(log_file: "makit.log", formatter: :json, append: true, **formatter_options)
+          @log_file = log_file
+          @formatter = formatter.to_sym
+          @append = append
+
+          # Create unified sink configuration
+          config = {
+            file: @log_file,
+            format: @formatter,
+            append: @append,
+          }.merge(formatter_options)
+
+          @unified_sink = UnifiedFileSink.new(configurations: [config])
+        end
+
+        # Execute sink logic to write log entry to file
+        #
+        # @param log_request [LogRequest] the log request to process
+        # @yield [LogRequest] yields the processed log request to the next sink
+        # @yieldreturn [LogRequest] the processed log request
+        # @return [LogRequest] the final processed log request
+        def call(log_request, &block)
+          @unified_sink.call(log_request, &block)
+        end
+
+        # Get sink configuration
+        #
+        # @return [Hash] sink configuration
+        def config
+          {
+            name: self.class.name.split("::").last,
+            log_file: @log_file,
+            formatter: @formatter,
+            append: @append,
+            unified_config: @unified_sink.config,
+          }
+        end
+      end
+    end
+  end
+end