makit 0.0.98 → 0.0.111

data/lib/makit/task_info.rb

@@ -1,57 +1,93 @@
-# lib/task_guard.rb
+# frozen_string_literal: true
+
+# Task timing and performance tracking utilities
 module Makit
+  # Task execution time tracking and reporting
+  #
+  # This class provides functionality to track the execution time of tasks,
+  # store timing information, and generate performance reports. It's designed
+  # to help identify performance bottlenecks in build processes.
   class TaskInfo
-
     #
-    # completed_tasks is a class variable that is used to store the completed tasks
+    # Class variable to store completed task information
     #
     class << self
       attr_accessor :completed_tasks
     end
     @completed_tasks = {}
 
+    # @return [String] Name of the task being tracked
+    # @return [Time] Time when task execution started
+    # @return [Time] Time when task execution ended
+    # @return [String] Directory path for task artifacts
     attr_reader :task_name, :start_time, :end_time, :artifacts_dir
 
+    # Get the name of the slowest completed task
+    #
+    # Analyzes all completed tasks and returns the name of the one
+    # with the longest execution duration.
+    #
+    # @return [String] Name of the slowest task, or "unknown" if no tasks completed
     def self.slowest_task_name
-      if @completed_tasks.empty?
-        return "unknown"
-      end
-      @completed_tasks.max_by { |task_name, task_info| task_info[:duration] }[0]
+      return "unknown" if @completed_tasks.empty?
+
+      @completed_tasks.max_by { |_task_name, task_info| task_info[:duration] }[0]
     end
 
+    # Track execution time of a task with a block
     #
-    # block-yielding initializer
-    #
-    # usage:
+    # Creates a new TaskInfo instance, displays the task name,
+    # executes the provided block, and ensures timing is reported
+    # even if an exception occurs.
     #
-    # Makit::TaskInfo.track(:generate) do
-    #   # generate code
-    # end
+    # @param task_name [String, Symbol] Name of the task to track
+    # @yield [TaskInfo] The task info instance for use within the block
+    # @return [Object] Result of the yielded block
     #
+    # @example
+    #   Makit::TaskInfo.track(:generate) do
+    #     # generate code
+    #   end
     def self.track(task_name)
       task = new(task_name)
       Makit::SHOW.task(task_name)
       yield(task)
     ensure
-      task.report_and_store_time_taken if task
+      task&.report_and_store_time_taken
     end
 
+    # Track execution time with inferred task name
     #
-    # Block-yielding initializer with inferred task name
+    # Similar to track() but attempts to infer the task name automatically.
+    # Currently returns nil as task name inference is not implemented.
     #
-    def self.track_inferred
+    # @yield [TaskInfo] The task info instance for use within the block
+    # @return [Object] Result of the yielded block
+    def self.track_inferred(&block)
       task_name = infer_task_name
       Makit::SHOW.task(task_name)
-      track(task_name) { |task| yield(task) }
+      track(task_name, &block)
     end
 
+    # Initialize a new task tracking instance
+    #
+    # Sets up timing tracking for a named task, creates an artifacts
+    # directory path, and records the start time.
+    #
+    # @param task_name [String, Symbol] Name of the task to track
     def initialize(task_name)
       @task_name = task_name
       @artifacts_dir = File.join("artifacts", task_name.to_s.gsub(":", "_"))
       @start_time = Time.now
-      #at_exit { report_and_store_time_taken }
+      # at_exit { report_and_store_time_taken }
     end
 
+    # Report and store the task execution time
+    #
+    # Calculates the duration, displays a human-readable completion message,
+    # and stores the timing information in the class-level completed_tasks hash.
+    #
+    # @return [nil]
     def report_and_store_time_taken
       @end_time = Time.now
       duration = @end_time - @start_time
@@ -59,7 +95,7 @@ module Makit
       # leverate the Makit::Humanize.get_humanized_duration method
       humanized_duration = Makit::Humanize.get_humanized_duration(duration)
       puts "  #{@task_name} completed in #{humanized_duration}".colorize(:grey)
-      #puts "[TaskGuard] Task '#{@task_name}' completed in #{duration}."
+      # puts "[TaskGuard] Task '#{@task_name}' completed in #{duration}."
 
       # Add to class-level storage
       self.class.completed_tasks[@task_name] = {
@@ -69,7 +105,7 @@ module Makit
       }
     end
 
-    #def format_duration(seconds)
+    # def format_duration(seconds)
     #   if seconds >= 60
     #     mins = (seconds / 60).to_i
     #     secs = (seconds % 60).round(2)
@@ -79,8 +115,14 @@ module Makit
     #      end
     # end
 
+    # Attempt to infer the current task name
+    #
+    # This method would extract the current Rake task name from the
+    # application context, but is currently not implemented.
+    #
+    # @return [String, nil] The inferred task name, or nil if unavailable
     def self.infer_task_name
-      #Rake.application.current_scope.join(":") rescue "unknown"
+      # Rake.application.current_scope.join(":") rescue "unknown"
     end
   end
 end

data/lib/makit/tasks/at_exit.rb

@@ -0,0 +1,13 @@
+require "English"
+
+at_exit do
+  command = "rake #{ARGV.join(" ")}"
+  duration = Time.now - Makit::STARTTIME
+  message = "#{command} (#{Makit::Humanize.get_humanized_duration(duration)})"
+  # detect if the rake execution was successful
+  if $ERROR_INFO.nil?
+    Makit::Logging.default_logger.info(message)
+  else
+    Makit::Logging.default_logger.error(message)
+  end # display the humanized duration of the rake execution
+end

data/lib/makit/tasks/build.rb

@@ -0,0 +1,18 @@
+require_relative "../setup/runner"
+
+desc "Build project artifacts.."
+task :build do
+  # load the default project configuration
+  project = Makit::Configuration::Project.default
+
+  # for each step in the project configuration, run the commands
+  project.steps.each do |step|
+    step.commands.each do |command|
+      request = Makit::Commands::Request.from_string(command)
+      result = Makit::Commands::Runner.default.execute(request)
+    end
+  end
+
+  # Make sure the build commands are in the project configuration
+
+end

data/lib/makit/tasks/clean.rb

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

data/lib/makit/tasks/hook_manager.rb

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

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,15 @@
+require_relative "../git/repository"
+
+if Makit::Git::Repository.git_repo?
+  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
+end

data/lib/makit/tasks/pull_incoming.rb

@@ -0,0 +1,12 @@
+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::TaskInfo.track(: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
+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,11 @@
+require_relative "../git/repository"
+
+if Makit::Git::Repository.git_repo?
+  desc "Sync changes with the git repository."
+  task sync: %i[integrate pull_incoming] do
+    Makit::TaskInfo.track(:sync) do
+      # Makit::SHOW.task(:sync)
+      Makit::Git::CLI.sync
+    end
+  end
+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