makit 0.0.111 → 0.0.112

data/lib/makit/tasks/clean.rb

@@ -1,11 +1,11 @@
-require "rake/clean"
-require_relative "../git/repository"
-require_relative "../commands/runner"
-
-CLEAN.include("artifacts/**/*")
-
-task :clean do
-  if Makit::Git::Repository.git_repo?
-    Makit::Commands::Runner.default.execute(Makit::Commands::Request.from_string("git clean -dXf"))
-  end
-end
+require "rake/clean"
+require_relative "../git/repository"
+require_relative "../commands/runner"
+
+CLEAN.include("artifacts/**/*")
+
+task :clean do
+  if Makit::Git::Repository.git_repo?
+    Makit::Commands::Runner.default.execute(Makit::Commands::Request.from_string("git clean -dXf"))
+  end
+end

data/lib/makit/tasks/hook_manager.rb

@@ -1,239 +1,393 @@
-# frozen_string_literal: true
-
-require "set"
-require "colorize"
-
-# Task hooks system for Makit
-#
-# This module provides a comprehensive hook system for Rake tasks, allowing
-# developers to add pre and post execution hooks globally or for specific tasks.
-# It uses monkey patching to intercept all task invocations and execute hooks
-# at the appropriate times.
-#
-# @example Global hooks
-#   Makit::Tasks::HookManager.add_pre_hook do |task_name|
-#     Makit::Logging.info("Starting task: #{task_name}")
-#   end
-#
-#   Makit::Tasks::HookManager.add_post_hook do |task_name, duration, result, error|
-#     if error
-#       Makit::Logging.error("Task failed: #{task_name}")
-#     else
-#       Makit::Logging.success("Task completed: #{task_name}")
-#     end
-#   end
-#
-# @example Task-specific hooks
-#   Makit::Tasks::HookManager.add_pre_hook_for(:build) do |task_name|
-#     Makit::Logging.info("Building project...")
-#   end
-#
-#   Makit::Tasks::HookManager.add_post_hook_for(:test) do |task_name, duration, result, error|
-#     Makit::Logging.info("Test execution took #{duration.round(2)}s")
-#   end
-module Makit
-  module Tasks
-    class HookManager
-      @pre_hooks = []
-      @post_hooks = []
-      @task_specific_pre_hooks = {}
-      @task_specific_post_hooks = {}
-      @excluded_tasks = Set.new
-      @logged_tasks = Set.new
-
-      class << self
-        # @return [Array<Proc>] Global pre-task hooks
-        attr_reader :pre_hooks
-
-        # @return [Array<Proc>] Global post-task hooks
-        attr_reader :post_hooks
-
-        # @return [Hash<String, Array<Proc>>] Task-specific pre-task hooks
-        attr_reader :task_specific_pre_hooks
-
-        # @return [Hash<String, Array<Proc>>] Task-specific post-task hooks
-        attr_reader :task_specific_post_hooks
-
-        # @return [Set<String>] Tasks excluded from hook execution
-        attr_reader :excluded_tasks
-
-        # Add a global pre-task hook
-        #
-        # The hook will be executed before every task runs.
-        #
-        # @yield [task_name] the name of the task being executed
-        # @yieldparam task_name [String] the name of the task
-        # @return [void]
-        def add_pre_hook(&block)
-          @pre_hooks << block
-        end
-
-        # Add a global post-task hook
-        #
-        # The hook will be executed after every task completes (success or failure).
-        #
-        # @yield [task_name, duration, result, error] hook parameters
-        # @yieldparam task_name [String] the name of the task
-        # @yieldparam duration [Float] execution duration in seconds
-        # @yieldparam result [Object, nil] the result of the task execution
-        # @yieldparam error [Exception, nil] any error that occurred during execution
-        # @return [void]
-        def add_post_hook(&block)
-          @post_hooks << block
-        end
-
-        # Add a pre-task hook for a specific task
-        #
-        # The hook will only be executed before the specified task runs.
-        #
-        # @param task_name [String, Symbol] the name of the task
-        # @yield [task_name] the name of the task being executed
-        # @yieldparam task_name [String] the name of the task
-        # @return [void]
-        def add_pre_hook_for(task_name, &block)
-          @task_specific_pre_hooks[task_name.to_s] ||= []
-          @task_specific_pre_hooks[task_name.to_s] << block
-        end
-
-        # Add a post-task hook for a specific task
-        #
-        # The hook will only be executed after the specified task completes.
-        #
-        # @param task_name [String, Symbol] the name of the task
-        # @yield [task_name, duration, result, error] hook parameters
-        # @yieldparam task_name [String] the name of the task
-        # @yieldparam duration [Float] execution duration in seconds
-        # @yieldparam result [Object, nil] the result of the task execution
-        # @yieldparam error [Exception, nil] any error that occurred during execution
-        # @return [void]
-        def add_post_hook_for(task_name, &block)
-          @task_specific_post_hooks[task_name.to_s] ||= []
-          @task_specific_post_hooks[task_name.to_s] << block
-        end
-
-        # Execute all pre-task hooks for a given task
-        #
-        # @param task_name [String] the name of the task
-        # @return [void]
-        def execute_pre_hooks(task_name)
-          return if excluded?(task_name)
-
-          # Execute global pre-hooks
-          @pre_hooks.each { |hook| hook.call(task_name) }
-
-          # Execute task-specific pre-hooks
-          task_hooks = @task_specific_pre_hooks[task_name.to_s] || []
-          task_hooks.each { |hook| hook.call(task_name) }
-        end
-
-        # Execute all post-task hooks for a given task
-        #
-        # @param task_name [String] the name of the task
-        # @param duration [Float] execution duration in seconds
-        # @param result [Object, nil] the result of the task execution
-        # @param error [Exception, nil] any error that occurred during execution
-        # @return [void]
-        def execute_post_hooks(task_name, duration, result, error)
-          return if excluded?(task_name)
-
-          # Execute global post-hooks
-          @post_hooks.each { |hook| hook.call(task_name, duration, result, error) }
-
-          # Execute task-specific post-hooks
-          task_hooks = @task_specific_post_hooks[task_name.to_s] || []
-          task_hooks.each { |hook| hook.call(task_name, duration, result, error) }
-        end
-
-        # Clear all hooks
-        #
-        # @return [void]
-        def clear_all_hooks
-          @pre_hooks.clear
-          @post_hooks.clear
-          @task_specific_pre_hooks.clear
-          @task_specific_post_hooks.clear
-        end
-
-        # Exclude a task from hook execution
-        #
-        # @param task_name [String, Symbol] the name of the task to exclude
-        # @return [void]
-        def exclude_task(task_name)
-          @excluded_tasks.add(task_name.to_s)
-        end
-
-        # Include a task in hook execution (remove from exclusions)
-        #
-        # @param task_name [String, Symbol] the name of the task to include
-        # @return [void]
-        def include_task(task_name)
-          @excluded_tasks.delete(task_name.to_s)
-        end
-
-        # Check if a task is excluded from hook execution
-        #
-        # @param task_name [String, Symbol] the name of the task to check
-        # @return [Boolean] true if the task is excluded
-        def excluded?(task_name)
-          @excluded_tasks.include?(task_name.to_s)
-        end
-
-        # Get statistics about registered hooks
-        #
-        # @return [Hash] hook statistics
-        def stats
-          {
-            global_pre_hooks: @pre_hooks.size,
-            global_post_hooks: @post_hooks.size,
-            task_specific_pre_hooks: @task_specific_pre_hooks.values.flatten.size,
-            task_specific_post_hooks: @task_specific_post_hooks.values.flatten.size,
-            tasks_with_pre_hooks: @task_specific_pre_hooks.keys,
-            tasks_with_post_hooks: @task_specific_post_hooks.keys,
-          }
-        end
-
-        # Setup default task hooks
-        #
-        # This method sets up the default task hooks that provide basic
-        # task execution feedback. It should be called during initialization.
-        #
-        # @return [void]
-        def setup_default_hooks
-          # Only setup if no hooks are already registered
-          return unless @pre_hooks.empty? && @post_hooks.empty?
-
-          # Exclude the init task from hooks to prevent duplication
-          exclude_task(:init)
-          exclude_task(:default)
-
-          # Default pre-task hook: log task start to default logger
-          add_pre_hook do |task_name|
-            log_task_start(task_name)
-          end
-
-          # Default post-task hook: log task completion
-          add_post_hook do |task_name, duration, result, error|
-            log_task_completion(task_name, duration, result, error)
-          end
-        end
-
-        def log_task_start(task_name)
-          #return if @logged_tasks.include?(task_name)
-          #@logged_tasks.add(task_name)
-          #Makit::Logging.info("#{task_name}".colorize(:white).bold)
-        end
-
-        def log_task_completion(task_name, duration, result, error)
-          #Makit::Logging.info("#{task_name}".colorize(:white).bold)
-          #Makit::Logging.info("Task completed".colorize(:green).bold)
-          #Makit::Logging.info("Duration: #{duration.round(2)}s".colorize(:green).bold)
-          # Makit::Logging.info("Result: #{result}".colorize(:green).bold)
-          #Makit::Logging.info("Error: #{error}".colorize(:red).bold)
-        end
-      end
-    end
-  end
-end
-
-# Setup default hooks when the module is loaded
-Makit::Tasks::HookManager.setup_default_hooks
+# frozen_string_literal: true
+
+require "set"
+require "colorize"
+require "fileutils"
+
+# Task hooks system for Makit
+#
+# This module provides a comprehensive hook system for Rake tasks, allowing
+# developers to add pre and post execution hooks globally or for specific tasks.
+# It uses monkey patching to intercept all task invocations and execute hooks
+# at the appropriate times.
+#
+# @example Global hooks
+#   Makit::Tasks::HookManager.add_pre_hook do |task_name|
+#     Makit::Logging.info("Starting task: #{task_name}")
+#   end
+#
+#   Makit::Tasks::HookManager.add_post_hook do |task_name, duration, result, error|
+#     if error
+#       Makit::Logging.error("Task failed: #{task_name}")
+#     else
+#       Makit::Logging.success("Task completed: #{task_name}")
+#     end
+#   end
+#
+# @example Task-specific hooks
+#   Makit::Tasks::HookManager.add_pre_hook_for(:build) do |task_name|
+#     Makit::Logging.info("Building project...")
+#   end
+#
+#   Makit::Tasks::HookManager.add_post_hook_for(:test) do |task_name, duration, result, error|
+#     Makit::Logging.info("Test execution took #{duration.round(2)}s")
+#   end
+module Makit
+  module Tasks
+    class HookManager
+      @pre_hooks = []
+      @post_hooks = []
+      @task_specific_pre_hooks = {}
+      @task_specific_post_hooks = {}
+      @excluded_tasks = Set.new
+      @logged_tasks = Set.new
+      
+      # Timing functionality
+      @timing_enabled = false
+      @task_stack = []
+      @performance_log = "artifacts/task_performance.log"
+      @hooks_installed = false
+
+      class << self
+        # @return [Array<Proc>] Global pre-task hooks
+        attr_reader :pre_hooks
+
+        # @return [Array<Proc>] Global post-task hooks
+        attr_reader :post_hooks
+
+        # @return [Hash<String, Array<Proc>>] Task-specific pre-task hooks
+        attr_reader :task_specific_pre_hooks
+
+        # @return [Hash<String, Array<Proc>>] Task-specific post-task hooks
+        attr_reader :task_specific_post_hooks
+
+        # @return [Set<String>] Tasks excluded from hook execution
+        attr_reader :excluded_tasks
+        
+        # @return [Boolean] Whether timing is enabled
+        attr_reader :timing_enabled
+        
+        # @return [Array<Hash>] Stack of currently executing tasks
+        attr_reader :task_stack
+        
+        # @return [String] Path to performance log file
+        attr_reader :performance_log
+
+        # Add a global pre-task hook
+        #
+        # The hook will be executed before every task runs.
+        #
+        # @yield [task_name] the name of the task being executed
+        # @yieldparam task_name [String] the name of the task
+        # @return [void]
+        def add_pre_hook(&block)
+          @pre_hooks << block
+        end
+
+        # Add a global post-task hook
+        #
+        # The hook will be executed after every task completes (success or failure).
+        #
+        # @yield [task_name, duration, result, error] hook parameters
+        # @yieldparam task_name [String] the name of the task
+        # @yieldparam duration [Float] execution duration in seconds
+        # @yieldparam result [Object, nil] the result of the task execution
+        # @yieldparam error [Exception, nil] any error that occurred during execution
+        # @return [void]
+        def add_post_hook(&block)
+          @post_hooks << block
+        end
+
+        # Add a pre-task hook for a specific task
+        #
+        # The hook will only be executed before the specified task runs.
+        #
+        # @param task_name [String, Symbol] the name of the task
+        # @yield [task_name] the name of the task being executed
+        # @yieldparam task_name [String] the name of the task
+        # @return [void]
+        def add_pre_hook_for(task_name, &block)
+          @task_specific_pre_hooks[task_name.to_s] ||= []
+          @task_specific_pre_hooks[task_name.to_s] << block
+        end
+
+        # Add a post-task hook for a specific task
+        #
+        # The hook will only be executed after the specified task completes.
+        #
+        # @param task_name [String, Symbol] the name of the task
+        # @yield [task_name, duration, result, error] hook parameters
+        # @yieldparam task_name [String] the name of the task
+        # @yieldparam duration [Float] execution duration in seconds
+        # @yieldparam result [Object, nil] the result of the task execution
+        # @yieldparam error [Exception, nil] any error that occurred during execution
+        # @return [void]
+        def add_post_hook_for(task_name, &block)
+          @task_specific_post_hooks[task_name.to_s] ||= []
+          @task_specific_post_hooks[task_name.to_s] << block
+        end
+
+        # Execute all pre-task hooks for a given task
+        #
+        # @param task_name [String] the name of the task
+        # @return [void]
+        def execute_pre_hooks(task_name)
+          return if excluded?(task_name)
+
+          # Track timing if enabled
+          if timing_enabled?
+            @task_stack.push({
+              name: task_name,
+              start_time: Time.now,
+              level: @task_stack.length,
+            })
+          end
+
+          # Execute global pre-hooks
+          @pre_hooks.each { |hook| hook.call(task_name) }
+
+          # Execute task-specific pre-hooks
+          task_hooks = @task_specific_pre_hooks[task_name.to_s] || []
+          task_hooks.each { |hook| hook.call(task_name) }
+        end
+
+        # Execute all post-task hooks for a given task
+        #
+        # @param task_name [String] the name of the task
+        # @param duration [Float] execution duration in seconds
+        # @param result [Object, nil] the result of the task execution
+        # @param error [Exception, nil] any error that occurred during execution
+        # @return [void]
+        def execute_post_hooks(task_name, duration, result, error)
+          return if excluded?(task_name)
+
+          # Handle timing if enabled
+          if timing_enabled?
+            task_info = @task_stack.pop
+            if task_info && task_info[:name] == task_name
+              # Log performance for tasks that took longer than 0.1 seconds
+              log_task_performance(task_name, duration, task_info[:level]) if duration > 0.1
+            end
+            
+            # Log task failure if there was an error
+            if error
+              log_task_failure(task_name, duration, error, task_info&.dig(:level) || 0)
+            end
+          end
+
+          # Execute global post-hooks
+          @post_hooks.each { |hook| hook.call(task_name, duration, result, error) }
+
+          # Execute task-specific post-hooks
+          task_hooks = @task_specific_post_hooks[task_name.to_s] || []
+          task_hooks.each { |hook| hook.call(task_name, duration, result, error) }
+        end
+
+        # Clear all hooks
+        #
+        # @return [void]
+        def clear_all_hooks
+          @pre_hooks.clear
+          @post_hooks.clear
+          @task_specific_pre_hooks.clear
+          @task_specific_post_hooks.clear
+        end
+
+        # Exclude a task from hook execution
+        #
+        # @param task_name [String, Symbol] the name of the task to exclude
+        # @return [void]
+        def exclude_task(task_name)
+          @excluded_tasks.add(task_name.to_s)
+        end
+
+        # Include a task in hook execution (remove from exclusions)
+        #
+        # @param task_name [String, Symbol] the name of the task to include
+        # @return [void]
+        def include_task(task_name)
+          @excluded_tasks.delete(task_name.to_s)
+        end
+
+        # Check if a task is excluded from hook execution
+        #
+        # @param task_name [String, Symbol] the name of the task to check
+        # @return [Boolean] true if the task is excluded
+        def excluded?(task_name)
+          @excluded_tasks.include?(task_name.to_s)
+        end
+
+        # Get statistics about registered hooks
+        #
+        # @return [Hash] hook statistics
+        def stats
+          {
+            global_pre_hooks: @pre_hooks.size,
+            global_post_hooks: @post_hooks.size,
+            task_specific_pre_hooks: @task_specific_pre_hooks.values.flatten.size,
+            task_specific_post_hooks: @task_specific_post_hooks.values.flatten.size,
+            tasks_with_pre_hooks: @task_specific_pre_hooks.keys,
+            tasks_with_post_hooks: @task_specific_post_hooks.keys,
+            timing_enabled: @timing_enabled,
+            task_stack_depth: @task_stack.size,
+          }
+        end
+
+        # Enable task timing and performance logging
+        #
+        # @return [void]
+        def enable_timing!
+          @timing_enabled = true
+          puts "🔧 Task timing enabled".colorize(:grey) if defined?(String.instance_method(:colorize))
+        end
+
+        # Disable task timing and performance logging
+        #
+        # @return [void]
+        def disable_timing!
+          @timing_enabled = false
+        end
+
+        # Check if timing is enabled
+        #
+        # @return [Boolean] true if timing is enabled
+        def timing_enabled?
+          @timing_enabled == true
+        end
+
+        # Clear performance logs
+        #
+        # @return [void]
+        def clear_performance_logs
+          FileUtils.rm_f(@performance_log)
+          FileUtils.rm_f("artifacts/task_failures.log")
+        end
+
+        # Setup task hooks by monkey patching Rake::Task
+        #
+        # This method patches the Rake::Task#execute method to automatically
+        # call pre and post hooks for all task executions.
+        #
+        # @return [void]
+        def setup!
+          return if @hooks_installed
+
+          Rake::Task.class_eval do
+            alias_method :makit_original_execute, :execute
+
+            def execute(args = nil)
+              start_time = Time.now
+              error = nil
+              result = nil
+
+              begin
+                # Execute pre-hooks
+                Makit::Tasks::HookManager.execute_pre_hooks(name)
+
+                # Execute the original task
+                result = makit_original_execute(args)
+              rescue StandardError => e
+                error = e
+                raise
+              ensure
+                # Calculate duration
+                duration = Time.now - start_time
+
+                # Execute post-hooks
+                Makit::Tasks::HookManager.execute_post_hooks(name, duration, result, error)
+              end
+
+              result
+            end
+          end
+
+          @hooks_installed = true
+        end
+
+        # Setup default task hooks
+        #
+        # This method sets up the default task hooks that provide basic
+        # task execution feedback. It should be called during initialization.
+        #
+        # @return [void]
+        def setup_default_hooks
+          # Setup the monkey patching first
+          setup!
+
+          # Only setup default hooks if no hooks are already registered
+          return unless @pre_hooks.empty? && @post_hooks.empty?
+
+          # Exclude the init task from hooks to prevent duplication
+          exclude_task(:init)
+          exclude_task(:default)
+
+          # Default pre-task hook: log task start to default logger
+          add_pre_hook do |task_name|
+            log_task_start(task_name)
+          end
+
+          # Default post-task hook: log task completion
+          add_post_hook do |task_name, duration, result, error|
+            log_task_completion(task_name, duration, result, error)
+          end
+        end
+
+        def log_task_start(task_name)
+          #return if @logged_tasks.include?(task_name)
+          #@logged_tasks.add(task_name)
+          #Makit::Logging.info("#{task_name}".colorize(:white).bold)
+        end
+
+        def log_task_completion(task_name, duration, result, error)
+          #Makit::Logging.info("#{task_name}".colorize(:white).bold)
+          #Makit::Logging.info("Task completed".colorize(:green).bold)
+          #Makit::Logging.info("Duration: #{duration.round(2)}s".colorize(:green).bold)
+          # Makit::Logging.info("Result: #{result}".colorize(:green).bold)
+          #Makit::Logging.info("Error: #{error}".colorize(:red).bold)
+        end
+
+        private
+
+        # Log task performance to file
+        #
+        # @param name [String] task name
+        # @param duration [Float] execution duration
+        # @param level [Integer] nesting level
+        # @return [void]
+        def log_task_performance(name, duration, level)
+          return if ENV["CI"] == "true" && duration < 1.0
+
+          FileUtils.mkdir_p("artifacts")
+          File.open(@performance_log, "a") do |f|
+            f.puts "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")},#{name},#{duration.round(4)},#{level}"
+          end
+        rescue StandardError
+          # Silently fail performance logging to not interrupt tasks
+        end
+
+        # Log task failure to file
+        #
+        # @param name [String] task name
+        # @param duration [Float] execution duration
+        # @param error [Exception] the error that occurred
+        # @param level [Integer] nesting level
+        # @return [void]
+        def log_task_failure(name, duration, error, level)
+          failure_log = "artifacts/task_failures.log"
+          FileUtils.mkdir_p("artifacts")
+
+          File.open(failure_log, "a") do |f|
+            timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+            message = error.message.gsub(",", ";")
+            f.puts "#{timestamp},#{name},#{duration.round(4)},#{error.class.name},#{message}"
+          end
+        rescue StandardError
+          # Silently fail error logging
+        end
+      end
+    end
+  end
+end
+
+# Setup default hooks when the module is loaded
+Makit::Tasks::HookManager.setup_default_hooks