makit 0.0.111 → 0.0.126

data/lib/makit/logging/format_registry.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-
-module Makit
-  module Logging
-    # Registry for managing available log formatters
-    #
-    # Provides a centralized way to register, retrieve, and manage formatters
-    # by name. This allows for easy extension and configuration of formatters.
-    #
-    # @example Registering a custom formatter
-    #   FormatRegistry.register(:audit, AuditFormatter)
-    #   formatter = FormatRegistry.get(:audit).new
-    #
-    # @example Using built-in formatters
-    #   formatter = FormatRegistry.get(:json).new
-    #   formatter = FormatRegistry.get(:text).new(timestamp_format: "%H:%M:%S")
-    class FormatRegistry
-      @formatters = {}
-
-      class << self
-        # @return [Hash] registered formatters
-        attr_reader :formatters
-
-        # Register a formatter class with a name
-        #
-        # @param name [Symbol, String] the name to register the formatter under
-        # @param formatter_class [Class] the formatter class to register
-        # @return [void]
-        def register(name, formatter_class)
-          @formatters[name.to_sym] = formatter_class
-        end
-
-        # Get a formatter class by name
-        #
-        # @param name [Symbol, String] the name of the formatter
-        # @return [Class] the formatter class
-        # @raise [ArgumentError] if formatter is not found
-        def get(name)
-          @formatters[name.to_sym] || raise(ArgumentError, "Unknown formatter: #{name}")
-        end
-
-        # Get all available formatter names
-        #
-        # @return [Array<Symbol>] list of registered formatter names
-        def available_formats
-          @formatters.keys
-        end
-
-        # Check if a formatter is registered
-        #
-        # @param name [Symbol, String] the name to check
-        # @return [Boolean] true if formatter is registered
-        def registered?(name)
-          @formatters.key?(name.to_sym)
-        end
-
-        # Clear all registered formatters
-        #
-        # @return [void]
-        def clear
-          @formatters.clear
-        end
-
-        # Register built-in formatters
-        #
-        # @return [void]
-        def register_built_ins
-          require_relative "formatters/json_formatter"
-          require_relative "formatters/text_formatter"
-          require_relative "formatters/plain_text_formatter"
-          require_relative "formatters/console_formatter"
-
-          register(:json, Formatters::JsonFormatter)
-          register(:text, Formatters::TextFormatter)
-          register(:plain, Formatters::PlainTextFormatter)
-          register(:console, Formatters::ConsoleFormatter)
-        end
-      end
-
-      # Initialize registry with built-in formatters
-      register_built_ins
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    # Registry for managing available log formatters
+    #
+    # Provides a centralized way to register, retrieve, and manage formatters
+    # by name. This allows for easy extension and configuration of formatters.
+    #
+    # @example Registering a custom formatter
+    #   FormatRegistry.register(:audit, AuditFormatter)
+    #   formatter = FormatRegistry.get(:audit).new
+    #
+    # @example Using built-in formatters
+    #   formatter = FormatRegistry.get(:json).new
+    #   formatter = FormatRegistry.get(:text).new(timestamp_format: "%H:%M:%S")
+    class FormatRegistry
+      @formatters = {}
+
+      class << self
+        # @return [Hash] registered formatters
+        attr_reader :formatters
+
+        # Register a formatter class with a name
+        #
+        # @param name [Symbol, String] the name to register the formatter under
+        # @param formatter_class [Class] the formatter class to register
+        # @return [void]
+        def register(name, formatter_class)
+          @formatters[name.to_sym] = formatter_class
+        end
+
+        # Get a formatter class by name
+        #
+        # @param name [Symbol, String] the name of the formatter
+        # @return [Class] the formatter class
+        # @raise [ArgumentError] if formatter is not found
+        def get(name)
+          @formatters[name.to_sym] || raise(ArgumentError, "Unknown formatter: #{name}")
+        end
+
+        # Get all available formatter names
+        #
+        # @return [Array<Symbol>] list of registered formatter names
+        def available_formats
+          @formatters.keys
+        end
+
+        # Check if a formatter is registered
+        #
+        # @param name [Symbol, String] the name to check
+        # @return [Boolean] true if formatter is registered
+        def registered?(name)
+          @formatters.key?(name.to_sym)
+        end
+
+        # Clear all registered formatters
+        #
+        # @return [void]
+        def clear
+          @formatters.clear
+        end
+
+        # Register built-in formatters
+        #
+        # @return [void]
+        def register_built_ins
+          require_relative "formatters/json_formatter"
+          require_relative "formatters/text_formatter"
+          require_relative "formatters/plain_text_formatter"
+          require_relative "formatters/console_formatter"
+
+          register(:json, Formatters::JsonFormatter)
+          register(:text, Formatters::TextFormatter)
+          register(:plain, Formatters::PlainTextFormatter)
+          register(:console, Formatters::ConsoleFormatter)
+        end
+      end
+
+      # Initialize registry with built-in formatters
+      register_built_ins
+    end
+  end
+end

data/lib/makit/logging/formatters/console_formatter.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
-require "colorize"
+begin
+  require "colorize"
+rescue LoadError
+  # colorize gem not available, define a no-op colorize method
+  class String
+    def colorize(*_args)
+      self
+    end
+  end
+end
 require_relative "base"
 
 module Makit
@@ -55,14 +64,18 @@ module Makit
           symbol_color = get_level_color(log_request.level)
           message = log_request.message
 
-          # Add context if present
-          if !log_request.context.empty?
-            context_str = log_request.context.map { |k, v| "#{k}=#{v}" }.join(" ")
-            message += " #{context_str}".colorize(:light_black)
+          # Special handling for task messages - no symbol, no context, just the message
+          if log_request.context[:task_message]
+            parts << message
+          else
+            # Add context if present (only for non-task messages)
+            unless log_request.context.empty?
+              context_str = log_request.context.map { |k, v| "#{k}=#{v}" }.join(" ")
+              message += " #{context_str}".colorize(:light_black)
+            end
+            parts << "#{symbol} #{message}".colorize(symbol_color)
           end
 
-          parts << "#{symbol} #{message}".colorize(symbol_color)
-
           parts.join(" ")
         end
 
@@ -108,9 +121,9 @@ module Makit
           when :debug
             "•"
           when :info
-            " " #"→"
+            " " # "→"
           when :warn
-            "!" #"⚠"
+            "!" # "⚠"
           when :error
             "✗"
           when :fatal

data/lib/makit/logging/log_request.rb

@@ -33,18 +33,22 @@ module Makit
 
       # @return [Time] when the log request was created
       attr_reader :timestamp
+      # @return [Symbol] the verbosity level (:quiet, :normal, :verbose, :debug)
+      attr_reader :verbosity
 
       # Initialize a new log request
       #
       # @param level [Symbol] the log level
       # @param message [String] the log message
       # @param context [Hash] additional context information
-      def initialize(level, message, context = {})
+      # @param verbosity [Symbol] the verbosity level (:quiet, :normal, :verbose, :debug)
+      def initialize(level, message, context = {}, verbosity: :normal)
         @level = level
         @message = message
         @context = context.dup
         @metadata = {}
         @timestamp = Time.now
+        @verbosity = verbosity
       end
 
       # Add metadata to the log request
@@ -71,7 +75,7 @@ module Makit
       # Convert the log request to a JSON string
       #
       # @return [String] JSON representation of the log request
-      def to_json
+      def to_json(*_args)
         require "json"
         JSON.generate(to_h)
       end

data/lib/makit/logging/logger.rb

@@ -35,14 +35,18 @@ module Makit
       attr_reader :sinks
       # @return [Symbol] minimum log level for filtering
       attr_reader :level
+      # @return [Symbol] current verbosity level
+      attr_reader :verbosity
 
       # 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)
+      # @param verbosity [Symbol] verbosity level (:quiet, :normal, :verbose, :debug)
+      def initialize(sinks: [], level: :info, verbosity: :normal)
         @sinks = sinks
         @level = level
+        @verbosity = verbosity
         @logged_tasks = Set.new
       end
 
@@ -51,11 +55,13 @@ module Makit
       # @param level [Symbol] the log level (:debug, :info, :warn, :error, :fatal, :success)
       # @param message [String] the log message
       # @param context [Hash] additional context information
+      # @param verbosity [Symbol] verbosity level (:quiet, :normal, :verbose, :debug)
       # @return [void]
-      def log(level, message, context = {})
+      def log(level, message, context = {}, verbosity: :normal)
         return unless should_log?(level)
+        return unless should_show_verbosity?(verbosity)
 
-        log_request = LogRequest.new(level, message, context)
+        log_request = LogRequest.new(level, message, context, verbosity: verbosity)
         execute_sinks(log_request)
       end
 
@@ -113,10 +119,33 @@ module Makit
         log(:fatal, message, context)
       end
 
+      # Log a verbose message (only shown in verbose or debug mode)
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def verbose(message, context = {})
+        log(:info, message, context, verbosity: :verbose)
+      end
+
+      # Log a quiet message (shown even in quiet mode)
+      #
+      # @param message [String] the log message
+      # @param context [Hash] additional context information
+      # @return [void]
+      def quiet(message, context = {})
+        log(:info, message, context, verbosity: :quiet)
+      end
+
       def task_start(message, context = {})
         return if @logged_tasks.include?(message)
+
         @logged_tasks.add(message)
-        log(:info, message, context)
+        # 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
@@ -137,10 +166,21 @@ module Makit
       # @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 = %i[debug info warn error fatal success]
         levels.index(level) >= levels.index(@level)
       end
 
+      # Check if a verbosity level should be shown
+      #
+      # @param verbosity [Symbol] the verbosity level to check
+      # @return [Boolean] true if the verbosity should be shown
+      def should_show_verbosity?(verbosity)
+        verbosity_levels = %i[quiet normal verbose debug]
+        verbosity_index = verbosity_levels.index(verbosity) || 1 # default to normal
+        current_index = verbosity_levels.index(@verbosity) || 1
+        verbosity_index <= current_index
+      end
+
       # Execute the sink chain for a log request
       #
       # @param log_request [LogRequest] the log request to process

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

@@ -1,91 +1,91 @@
-# frozen_string_literal: true
-
-module Makit
-  module Logging
-    module Sinks
-      # Base class for all logging sinks
-      #
-      # Sinks provide a way to output log requests to various destinations like
-      # console, files, or external services. This follows the same pattern as
-      # the commands middleware but focuses on output rather than transformation.
-      #
-      # @example Creating a custom logging sink
-      #   class CustomSink < Base
-      #     def call(log_request, &block)
-      #       # Output the log request
-      #       output_log(log_request)
-      #
-      #       # Continue to next sink
-      #       block.call(log_request) if block_given?
-      #     end
-      #   end
-      class Base
-        # Execute sink logic
-        #
-        # This method must be implemented by subclasses to provide the actual
-        # sink functionality. The pattern is to output the log request to the
-        # destination, then call the block to continue the sink chain.
-        #
-        # @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
-        # @raise [NotImplementedError] if not overridden by subclass
-        def call(log_request, &block)
-          raise NotImplementedError, "#{self.class.name} must implement #call"
-        end
-
-        # Check if this sink should be applied to the given log request
-        #
-        # Override this method to provide conditional sink application
-        # based on log request properties like level, message, or context.
-        #
-        # @param log_request [LogRequest] the log request
-        # @return [Boolean] true if sink should be applied
-        def applicable?(log_request)
-          true
-        end
-
-        # Get sink name for logging and debugging
-        #
-        # @return [String] sink name
-        def name
-          self.class.name.split("::").last
-        end
-
-        # Get sink configuration
-        #
-        # Override this method to provide sink-specific configuration.
-        #
-        # @return [Hash] sink configuration
-        def config
-          {}
-        end
-
-        private
-
-        # Pre-process the log request before outputting
-        #
-        # Override this method to modify the log request before it is output
-        # to the destination.
-        #
-        # @param log_request [LogRequest] the log request
-        # @return [LogRequest] the modified log request
-        def pre_process(log_request)
-          log_request
-        end
-
-        # Post-process the log request after outputting
-        #
-        # Override this method to perform any final processing after the
-        # log request has been output to the destination.
-        #
-        # @param log_request [LogRequest] the log request
-        # @return [LogRequest] the final log request
-        def post_process(log_request)
-          log_request
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    module Sinks
+      # Base class for all logging sinks
+      #
+      # Sinks provide a way to output log requests to various destinations like
+      # console, files, or external services. This follows the same pattern as
+      # the commands middleware but focuses on output rather than transformation.
+      #
+      # @example Creating a custom logging sink
+      #   class CustomSink < Base
+      #     def call(log_request, &block)
+      #       # Output the log request
+      #       output_log(log_request)
+      #
+      #       # Continue to next sink
+      #       block.call(log_request) if block_given?
+      #     end
+      #   end
+      class Base
+        # Execute sink logic
+        #
+        # This method must be implemented by subclasses to provide the actual
+        # sink functionality. The pattern is to output the log request to the
+        # destination, then call the block to continue the sink chain.
+        #
+        # @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
+        # @raise [NotImplementedError] if not overridden by subclass
+        def call(log_request, &block)
+          raise NotImplementedError, "#{self.class.name} must implement #call"
+        end
+
+        # Check if this sink should be applied to the given log request
+        #
+        # Override this method to provide conditional sink application
+        # based on log request properties like level, message, or context.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [Boolean] true if sink should be applied
+        def applicable?(_log_request)
+          true
+        end
+
+        # Get sink name for logging and debugging
+        #
+        # @return [String] sink name
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Get sink configuration
+        #
+        # Override this method to provide sink-specific configuration.
+        #
+        # @return [Hash] sink configuration
+        def config
+          {}
+        end
+
+        private
+
+        # Pre-process the log request before outputting
+        #
+        # Override this method to modify the log request before it is output
+        # to the destination.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [LogRequest] the modified log request
+        def pre_process(log_request)
+          log_request
+        end
+
+        # Post-process the log request after outputting
+        #
+        # Override this method to perform any final processing after the
+        # log request has been output to the destination.
+        #
+        # @param log_request [LogRequest] the log request
+        # @return [LogRequest] the final log request
+        def post_process(log_request)
+          log_request
+        end
+      end
+    end
+  end
+end