makit 0.0.111 → 0.0.126

data/lib/makit/setup/runner.rb

@@ -1,38 +1,52 @@
 # frozen_string_literal: true
+
 require_relative "classlib"
 require_relative "gem"
+require_relative "razorclasslib"
+require_relative "../content/default_gitignore"
 
 module Makit
   module Setup
     class Runner
       def self.run
 
+        # if a .git directory exists, then make sure we have a .gitignore
+        if File.exist?(".git")
+          if !File.exist?(".gitignore")
+            File.write(".gitignore", Makit::Content::GITIGNORE)
+          end
+        end
         # open .makit.json and get project type, to determine which setup to run
-        if File.exist?(".makit.json")
-          begin
-            project = Makit::Serializer.open(".makit.json", Makit::Configuration::Project)
+        return unless File.exist?(".makit.json")
 
-            # Check if the file contains compact JSON and resave as pretty JSON
-            current_content = File.read(".makit.json")
-            pretty_content = project.to_json_pretty
+        begin
+          project = Makit::Serializer.open(".makit.json", Makit::Configuration::Project)
 
-            # Only rewrite if the content is different (i.e., if it was compact)
-            if current_content.strip != pretty_content.strip
-              File.write(".makit.json", pretty_content)
-            end
-          rescue
-            raise "Error opening .makit.json"
-          end
-          project_type = project.project_type
-          case project_type
-          when "classlib"
-            Makit::Setup::ClassLib.run
-          when "gem"
-            Makit::Setup::Gem.run
-          else
-            Makit::Logging.default_logger.warn("Unsupported project type: #{project_type}")
-            #puts "Unsupported project type: #{project_type}"
+          # Update version to match VERSION constant only if project version is truly empty
+          if defined?(Makit::VERSION) && (project.version.nil? || project.version.empty?)
+            project.version = Makit::VERSION
           end
+
+          # Check if the file contains compact JSON and resave as pretty JSON
+          current_content = File.read(".makit.json")
+          pretty_content = project.to_json_pretty
+
+          # Only rewrite if the content is different (i.e., if it was compact or version changed)
+          File.write(".makit.json", pretty_content) if current_content.strip != pretty_content.strip
+        rescue StandardError
+          raise "Error opening .makit.json"
+        end
+        project_type = project.project_type
+        case project_type
+        when "classlib"
+          Makit::Setup::ClassLib.run
+        when "razorclasslib"
+          Makit::Setup::RazorClassLib.run
+        when "gem"
+          Makit::Setup::Gem.run
+        else
+          Makit::Logging.default_logger.warn("Unsupported project type: #{project_type}")
+          # puts "Unsupported project type: #{project_type}"
         end
       end
     end

data/lib/makit/setup.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "setup/runner"
+require_relative "setup/classlib"
+require_relative "setup/gem"

data/lib/makit/symbols.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
-require "rainbow"
+begin
+  require "rainbow"
+rescue LoadError
+  # rainbow gem not available, define a no-op rainbow method
+  class String
+    def rainbow
+      self
+    end
+  end
+end
 
 # https://symbl.cc/en/unicode/table/
 module Makit

data/lib/makit/tasks/at_exit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "English"
 
 at_exit do
@@ -9,5 +11,5 @@ at_exit do
     Makit::Logging.default_logger.info(message)
   else
     Makit::Logging.default_logger.error(message)
-  end # display the humanized duration of the rake execution
+  end
 end

data/lib/makit/tasks/build.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 require_relative "../setup/runner"
 
-desc "Build project artifacts.."
-task :build do
-  # load the default project configuration
-  project = Makit::Configuration::Project.default
+if File.exist?(".makit.json")
+  desc "Build project artifacts.."
+  task :build do
+    Makit::Logging.default_logger.task_start("build")
+    # load the default project configuration
+    # puts "loading 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)
+    # if the project has a build step, run the commands
+    build_step = project.steps.find { |step| step.name == "build" }
+    build_step&.commands&.each do |command|
+      request = Makit::Commands::Request.from_string(command).exit_on_failure(true).show_stderr(true)
+      Makit::Commands::Runner.default.execute(request)
     end
   end
-
-  # Make sure the build commands are in the project configuration
-
+else
+  Makit::Logging.default_logger.debug("Project not configured, skipping setup task definition")
 end

data/lib/makit/tasks/clean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake/clean"
 require_relative "../git/repository"
 require_relative "../commands/runner"

data/lib/makit/tasks/configure.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+desc "Configure the project"
+task :configure do
+  project = Makit::Configuration::Project.default
+  if defined?(GIT_REMOTE_URL)
+    project.git_remote_url = GIT_REMOTE_URL
+    project.save
+  end
+end

data/lib/makit/tasks/format.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+desc "Format project files"
+task :format do
+  "rufo .".try if File.exist?("Gemfile") || File.exist?("Rakefile")
+
+  Dir.glob("**/*.csproj").each do |file|
+    "dotnet format #{file}".run
+  end
+end

data/lib/makit/tasks/hook_manager.rb

@@ -2,6 +2,7 @@
 
 require "set"
 require "colorize"
+require "fileutils"
 
 # Task hooks system for Makit
 #
@@ -41,6 +42,12 @@ module Makit
       @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
@@ -57,6 +64,15 @@ module Makit
         # @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.
@@ -118,6 +134,15 @@ module Makit
         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) }
 
@@ -136,6 +161,18 @@ module Makit
         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 && (duration > 0.1)
+              # Log performance for tasks that took longer than 0.1 seconds
+              log_task_performance(task_name, duration, task_info[:level])
+            end
+
+            # Log task failure if there was an error
+            log_task_failure(task_name, duration, error, task_info&.dig(:level) || 0) if error
+          end
+
           # Execute global post-hooks
           @post_hooks.each { |hook| hook.call(task_name, duration, result, error) }
 
@@ -189,9 +226,82 @@ module Makit
             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
@@ -199,7 +309,10 @@ module Makit
         #
         # @return [void]
         def setup_default_hooks
-          # Only setup if no hooks are already registered
+          # 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
@@ -218,17 +331,56 @@ module Makit
         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)
+          # 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("#{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)
+          # 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

data/lib/makit/tasks/init.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Rake.application.top_level_tasks.unshift("init")
 
 task :init do

data/lib/makit/tasks/integrate.rb

@@ -1,15 +1,29 @@
+# frozen_string_literal: true
+
 require_relative "../git/repository"
 
-if Makit::Git::Repository.git_repo?
+if Dir.exist?(".git")
   desc "Integrate changes into the git repository."
   task :integrate do
+    Makit::Logging.default_logger.task_start("integrate")
     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
+      #Makit::Git::CLI.integrate
+      #return unless Repository.git_repo? && !Repository.detached
+
+      ## check for unstaged or untracked files
+      #  unstaged_files = `git status --porcelain`.split("\n")
+      #  untracked_files = `git ls-files --others --exclude-standard`.split("\n")
+      #  return unless unstaged_files.length.positive? || untracked_files.length.positive?
+
+      "git add .".try
+      "git commit -m \"integrate\"".run unless Makit::Git::Repository.clean?
     else
       Makit::Logging.default_logger.info("No unstaged or untracked files found")
-      #puts "  No unstaged or untracked files found".colorize(:grey)
+      # puts "  No unstaged or untracked files found".colorize(:grey)
     end
   end
+else
+  Makit::Logging.default_logger.debug("Not a git repository, skipping integrate")
 end

data/lib/makit/tasks/pull_incoming.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 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
+    Makit::Logging.default_logger.task_start("pull_incoming")
+    # 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

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 require_relative "../setup/runner"
 
-desc "Setup project files.."
-task :setup do
-  Makit::Setup::Runner.run
+if File.exist?(".makit.json")
+  desc "Setup project files.."
+  task :setup do
+    Makit::Logging.default_logger.task_start("setup")
+    Makit::Setup::Runner.run
+  end
+else
+  Makit::Logging.default_logger.debug("Project not configured, skipping setup task definition")
 end

data/lib/makit/tasks/sync.rb

@@ -1,11 +1,17 @@
-require_relative "../git/repository"
+# frozen_string_literal: true
 
-if Makit::Git::Repository.git_repo?
+require_relative "../git/cli"
+
+if Dir.exist?(".git")
   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
+  task :sync do
+    Makit::Logging.default_logger.task_start("sync")
+    # Makit::SHOW.task(:sync)
+    Makit::Git::CLI.sync
+    "git pull".try
+    "git push origin".try
+    "git push origin --tags".try
   end
+else
+  Makit::Logging.default_logger.debug("Not a git repository, skipping sync")
 end

data/lib/makit/tasks/tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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.debug("Not a git repository, skipping tag")
+end

data/lib/makit/tasks/task_monkey_patch.rb

@@ -10,70 +10,72 @@
 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
+module Rake
+  class Task
+    # Store original methods before patching
+    alias original_invoke invoke
+    alias 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
+    # 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)
+      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)
+        # Execute the original task
+        result = original_invoke(*args)
+      rescue StandardError => 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
 
-    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
 
-  # 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)
 
-    begin
-      # Execute pre-task hooks
-      Makit::Tasks::HookManager.execute_pre_hooks(name)
+        # Execute the original task
+        result = original_execute(*args)
+      rescue StandardError => 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
 
-      # 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)
+      result
     end
-
-    result
   end
 end