makit 0.0.99 → 0.0.112

data/lib/makit/tasks/hook_manager.rb

@@ -0,0 +1,393 @@
+# 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

data/lib/makit/tasks/init.rb

@@ -0,0 +1,47 @@
+Rake.application.top_level_tasks.unshift("init")
+
+task :init do
+  puts "-" * 80
+  humanized_timestamp = Makit::Humanize.get_humanized_timestamp(Time.now)
+  # log the rake + arguments, as it would be invoke at the console.
+  # for instance: rake -T
+  # or: rake
+  # or: rake clean
+  # or: rake LOG_LEVEL=debug
+  command = "rake #{ARGV.join(" ")}"
+  message = "#{command} (#{humanized_timestamp})"
+
+  # Create filename-friendly version of rake command
+  rake_name = command.gsub(/[^a-zA-Z0-9\-_]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
+
+  # Get the default logger and add custom file logging sinks
+  log = Makit::Logging.default_logger
+
+  # Add structured JSON and simple text logging sinks to the default logger
+  additional_sinks = [
+    Makit::Logging::Sinks::UnifiedFileSink.new(
+      configurations: [
+        # Structured JSON logging
+        {
+          file: "artifacts/#{rake_name}.json",
+          format: :json,
+          append: true,
+          include_metadata: true,
+        },
+        # Simple text logging with rendered context
+        {
+          file: "artifacts/#{rake_name}.txt",
+          format: :plain,
+          append: true,
+          include_context: true,
+        },
+      ],
+    ),
+  ]
+
+  # Add the additional sinks to the default logger
+  log.sinks.concat(additional_sinks)
+
+  # Log with the enhanced default logger
+  log.info(message)
+end

data/lib/makit/tasks/integrate.rb

@@ -0,0 +1,17 @@
+require_relative "../git/repository"
+
+if Dir.exist?(".git")
+  desc "Integrate changes into the git repository."
+  task :integrate do
+    unstaged_files = Makit::Git::Repository.unstaged_files
+    untracked_files = Makit::Git::Repository.untracked_files
+    if unstaged_files.length.positive? || untracked_files.length.positive?
+      Makit::Git::CLI.integrate
+    else
+      Makit::Logging.default_logger.info("No unstaged or untracked files found")
+      #puts "  No unstaged or untracked files found".colorize(:grey)
+    end
+  end
+else
+  Makit::Logging.default_logger.info("Not a git repository, skipping integrate")
+end

data/lib/makit/tasks/pull_incoming.rb

@@ -0,0 +1,11 @@
+require_relative "../git/repository"
+
+if Makit::Git::Repository.git_repo?
+  desc "pull changes from the remote branch, preferring incoming changes for conflicts"
+  task :pull_incoming do
+      # Makit::SHOW.task(:pull_incoming)
+      puts "  git branch is ".colorize(:grey) + Makit::Git::Repository.branch.to_s.colorize(:green)
+      "git pull origin #{Makit::Git::Repository.branch} -X theirs".try
+    end
+  
+end

data/lib/makit/tasks/setup.rb

@@ -0,0 +1,6 @@
+require_relative "../setup/runner"
+
+desc "Setup project files.."
+task :setup do
+  Makit::Setup::Runner.run
+end

data/lib/makit/tasks/sync.rb

@@ -0,0 +1,12 @@
+require_relative "../git/repository"
+
+if Dir.exist?(".git")
+  desc "Sync changes with the git repository."
+  task :sync do
+      # Makit::SHOW.task(:sync)
+      #Makit::Git::CLI.sync
+    end
+
+else
+  Makit::Logging.default_logger.info("Not a git repository, skipping sync")
+end

data/lib/makit/tasks/tag.rb

@@ -0,0 +1,15 @@
+if Dir.exist?(".git")
+  desc "tag the current version"
+  task :tag do
+
+    # check if the variable VERSION is defined
+    unless defined?(VERSION)
+      puts "  VERSION is not defined".colorize(:red)
+      return
+    end
+
+    Makit::Git::CLI.tag(VERSION)
+  end
+else
+  Makit::Logging.default_logger.info("Not a git repository, skipping tag")
+end

data/lib/makit/tasks/task_monkey_patch.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Monkey patch for Rake::Task to add hook support
+#
+# This module patches Rake::Task to automatically execute pre and post hooks
+# for all task invocations. It preserves the original behavior while adding
+# the hook functionality.
+#
+# @note This file should be required after the HookManager class is defined
+require_relative "hook_manager"
+
+# Monkey patch Rake::Task to add hook support
+class Rake::Task
+  # Store original methods before patching
+  alias_method :original_invoke, :invoke
+  alias_method :original_execute, :execute
+
+  # Enhanced invoke method with hook support
+  #
+  # This method wraps the original invoke method to execute pre and post hooks
+  # around task execution. It handles errors gracefully and ensures hooks are
+  # always executed even if the task fails.
+  #
+  # @param args [Array] arguments passed to the task
+  # @return [Object] the result of the task execution
+  def invoke(*args)
+    start_time = Time.now
+    result = nil
+    error = nil
+
+    begin
+      # Execute pre-task hooks
+      Makit::Tasks::HookManager.execute_pre_hooks(name)
+
+      # Execute the original task
+      result = original_invoke(*args)
+    rescue => e
+      error = e
+      raise
+    ensure
+      # Execute post-task hooks (always runs, even on error)
+      duration = Time.now - start_time
+      Makit::Tasks::HookManager.execute_post_hooks(name, duration, result, error)
+    end
+
+    result
+  end
+
+  # Enhanced execute method with hook support
+  #
+  # This method wraps the original execute method to execute pre and post hooks
+  # around task execution. It handles errors gracefully and ensures hooks are
+  # always executed even if the task fails.
+  #
+  # @param args [Array] arguments passed to the task
+  # @return [Object] the result of the task execution
+  def execute(*args)
+    start_time = Time.now
+    result = nil
+    error = nil
+
+    begin
+      # Execute pre-task hooks
+      Makit::Tasks::HookManager.execute_pre_hooks(name)
+
+      # Execute the original task
+      result = original_execute(*args)
+    rescue => e
+      error = e
+      raise
+    ensure
+      # Execute post-task hooks (always runs, even on error)
+      duration = Time.now - start_time
+      Makit::Tasks::HookManager.execute_post_hooks(name, duration, result, error)
+    end
+
+    result
+  end
+end