makit 0.0.130 → 0.0.137

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0621283549942c0c4d2cad1479716f15baa95683610100d19ccdce504d59c7e6'
-  data.tar.gz: a5d3a378e509f16717d52c00759213718d364f67114bd916aff530ff45dba927
+  metadata.gz: 9b1587ff7fc4ebf629318b13cc0b34f7e280067e1d47e72c39e9e4fe0eccdacd
+  data.tar.gz: 3791591e80c80cb78ad1ad4e3a2751116539fa014392ca0de9def3cd2abe3d16
 SHA512:
-  metadata.gz: 46399a0009c96b0834222c940d25d0b9284e708240290efc317fe0840cc6d9a10ee6ace8bb1fb324f463f1de932e7b6f114ae4fd3ee8cbb8c358d476259002c4
-  data.tar.gz: 1fc7149896202a6bbb7619d3b5354e460edcfc210bd972d22eb5b679eb998f48c459520974d64d3db9bcff189934700e321380a8ef0412270a36152b970c9d59
+  metadata.gz: 546e136499db7988f773144965e99334849472abdaa35cc48a43c3a6ead87b390f7a6934369ce7edd90f65c570dfca7cd2ac23220c0009ea783363676dc79a99
+  data.tar.gz: 5b24c2215de2aeeafb894453e3de1aef3ee4db9ef50dcf1880c5c4b489c93018bf56fd9f933d1dee26d31b3b18bd84177c03546c539a5deb40a5732eb29c0671

data/exe/makit

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "makit"
+require "makit/auto"
 Makit::Cli::MainCommand.run(ARGV)

data/lib/makit/auto.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Load the core makit functionality first
+begin
+  require_relative "../makit"
+rescue LoadError => e
+  # If makit can't be loaded (e.g., missing dependencies), 
+  # we'll still provide the auto module
+  puts "Warning: Could not load full makit library: #{e.message}"
+end
+
+# Load CLI functionality for command-line interface
+begin
+  require_relative "cli/main"
+  require_relative "cli/repository_commands"
+  require_relative "cli/project_commands"
+  require_relative "cli/build_commands"
+  require_relative "cli/utility_commands"
+  require_relative "cli/strategy_commands"
+rescue LoadError => e
+  puts "Warning: Could not load CLI modules: #{e.message}"
+end
+
+module Makit
+  # Auto module provides enhanced functionality when requiring "makit/auto"
+  # This includes CLI commands and other enhanced features
+  module Auto
+    # Version of the auto functionality
+    VERSION = "1.0.0"
+    
+    # Check if auto functionality is loaded
+    def self.loaded?
+      true
+    end
+    
+    # Log that auto mode is enabled
+    def self.enable_auto_mode
+      if defined?(Makit::Logging)
+        Makit::Logging.info("Makit auto mode enabled - enhanced functionality available")
+      else
+        puts "Makit auto mode enabled - enhanced functionality available"
+      end
+    end
+  end
+end
+
+# Enable auto mode logging
+Makit::Auto.enable_auto_mode

data/lib/makit/cli/main.rb

@@ -5,6 +5,7 @@ require_relative "repository_commands"
 require_relative "project_commands"
 require_relative "build_commands"
 require_relative "utility_commands"
+require_relative "strategy_commands"
 require_relative "../rake/cli"
 
 module Makit
@@ -20,6 +21,8 @@ module Makit
           project     - Manage project creation and setup (new, init, setup, work)
           build       - Build operations and cleanup (make, clean)
           utility     - System utilities and maintenance (nuget-cache, system-info)
+          strategy    - Manage execution strategies (show, test)
+          trace       - Manage trace functionality (show, enable, disable, test)
           rake        - Manage rake tasks
 
         Common usage examples:
@@ -56,6 +59,8 @@ module Makit
       subcommand "project", "Manage project creation and setup", ProjectCommand
       subcommand "build", "Build operations and cleanup", BuildCommand
       subcommand "utility", "System utilities and maintenance", UtilityCommand
+      subcommand "strategy", "Manage execution strategies", StrategyCommands
+      subcommand "trace", "Manage trace functionality", TraceCommands
       subcommand "rake", "Manage rake tasks", Makit::Rake::CliCommand
     end
   end

data/lib/makit/cli/strategy_commands.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Makit
+  module Cli
+    # Commands for managing execution strategies
+    class StrategyCommands < Base
+      desc "strategy", "Show current execution strategy information"
+      option ["--verbose", "-v"], :flag, "Show detailed strategy information"
+      def strategy
+        runner = Makit::Commands::Runner.default
+        info = runner.strategy_info
+
+        puts "Current Execution Strategy:"
+        puts "  Type: #{info[:type]}"
+        puts "  Class: #{info[:class]}"
+        
+        if options[:verbose]
+          puts "\nFactory Information:"
+          factory_info = info[:factory_info]
+          puts "  Current: #{factory_info[:current]}"
+          puts "  Available: #{factory_info[:available].join(', ')}"
+          puts "  ChildProcess Available: #{factory_info[:childprocess_available]}"
+          puts "  Open3 Available: #{factory_info[:open3_available]}"
+        end
+
+        puts "\nEnvironment Variables:"
+        puts "  MAKIT_STRATEGY: #{ENV['MAKIT_STRATEGY'] || 'not set (using auto-detect)'}"
+      end
+
+      desc "strategy test", "Test both strategies and show performance comparison"
+      option ["--timeout", "-t"], "TIMEOUT", "Timeout for test commands", default: "5"
+      def test
+        timeout = options[:timeout].to_i
+        
+        puts "Testing execution strategies..."
+        puts "=" * 50
+
+        # Test ChildProcess strategy
+        puts "\n1. Testing ChildProcess Strategy:"
+        childprocess_result = test_strategy('childprocess', timeout)
+        
+        # Test Open3 strategy  
+        puts "\n2. Testing Open3 Strategy:"
+        open3_result = test_strategy('open3', timeout)
+
+        # Show comparison
+        puts "\n" + "=" * 50
+        puts "Performance Comparison:"
+        puts "  ChildProcess: #{childprocess_result[:duration]}s (#{childprocess_result[:status]})"
+        puts "  Open3:       #{open3_result[:duration]}s (#{open3_result[:status]})"
+      end
+
+      private
+
+      # Test a specific strategy
+      #
+      # @param strategy_type [String] strategy type to test
+      # @param timeout [Integer] timeout for test commands
+      # @return [Hash] test results
+      def test_strategy(strategy_type, timeout)
+        start_time = Time.now
+        
+        begin
+          # Create runner with specific strategy
+          strategy = Makit::Commands::Strategies::Factory.create(strategy: strategy_type)
+          runner = Makit::Commands::Runner.new(strategy: strategy)
+          
+          # Test with a simple command
+          request = Makit::Commands::Request.new(
+            command: "echo",
+            arguments: ["Hello from #{strategy_type}!"],
+            timeout: timeout
+          )
+          
+          result = runner.execute(request)
+          duration = Time.now - start_time
+          
+          status = result.success? ? "SUCCESS" : "FAILED"
+          puts "  Status: #{status}"
+          puts "  Duration: #{duration.round(3)}s"
+          puts "  Output: #{result.stdout.strip}"
+          
+          if result.failure?
+            puts "  Error: #{result.stderr}"
+          end
+          
+          { duration: duration.round(3), status: status, success: result.success? }
+          
+        rescue => e
+          duration = Time.now - start_time
+          puts "  Status: ERROR"
+          puts "  Duration: #{duration.round(3)}s"
+          puts "  Error: #{e.message}"
+          
+        { duration: duration.round(3), status: "ERROR", success: false }
+      end
+    end
+  end
+end
+
+# Add trace commands to the main CLI
+module Makit
+  module Cli
+    # Commands for managing trace functionality
+    class TraceCommands < Base
+      desc "trace", "Show current trace status and configuration"
+      option ["--verbose", "-v"], :flag, "Show detailed trace information"
+      def trace
+        puts "Makit Trace Status:"
+        puts "=" * 30
+        
+        status = Makit::Rake.status
+        
+        puts "Enhanced Tracing: #{Makit::Rake.tracing_enabled? ? 'Enabled' : 'Disabled'}"
+        puts "Rake Trace: #{status[:trace_controller][:rake_trace] || 'Not set'}"
+        puts "Trace Flag: #{status[:trace_controller][:trace_flag] ? 'Present' : 'Not present'}"
+        puts "Makit Trace: #{status[:trace_controller][:makit_trace] || 'Not set'}"
+        puts "Verbose Mode: #{status[:verbose] ? 'Enabled' : 'Disabled'}"
+        
+        if options[:verbose]
+          puts "\nDetailed Information:"
+          puts "  Strategy: #{status[:strategy][:type] || 'Unknown'}"
+          puts "  Class: #{status[:strategy][:class] || 'Unknown'}"
+          puts "  Factory Info: #{status[:strategy][:factory_info] || 'Not available'}"
+        end
+      end
+
+      desc "trace enable", "Enable enhanced tracing"
+      def enable
+        ENV['MAKIT_TRACE'] = 'true'
+        puts "Enhanced tracing enabled"
+        puts "Run 'rake --trace' to see enhanced output"
+      end
+
+      desc "trace disable", "Disable enhanced tracing"
+      def disable
+        ENV.delete('MAKIT_TRACE')
+        puts "Enhanced tracing disabled"
+      end
+
+      desc "trace test", "Test trace functionality with a simple rake task"
+      def test
+        puts "Testing trace functionality..."
+        puts "Run: rake --trace"
+        puts "You should see [MAKIT] prefixed trace output for makit-related tasks"
+      end
+    end
+  end
+end
+end

data/lib/makit/commands/middleware/command_logger.rb

@@ -230,8 +230,9 @@ module Makit
         # @param duration [Float] execution duration
         # @param command_id [String] unique command identifier
         def log_performance_warnings(request, result, duration, command_id)
+          duration_threshold_seconds = 60.0
           # Log slow commands
-          if duration > 5.0
+          if duration > duration_threshold_seconds
             @logger.warn("Slow command detected",
                          command_id: command_id,
                          command: request.command,

data/lib/makit/commands/runner.rb

@@ -3,6 +3,7 @@
 require_relative "request"
 require_relative "result"
 require_relative "strategies/synchronous"
+require_relative "strategies/factory"
 require_relative "middleware/base"
 require_relative "middleware/command_logger"
 
@@ -40,19 +41,24 @@ module Makit
       # @return [Runner] default runner with standard middleware
       def self.default
         # Recreate the runner if the log level has changed
-        current_log_level = Makit::Logging.current_log_level
+        current_log_level = defined?(Makit::Logging) ? Makit::Logging.current_log_level : :info
         if @default.nil? || @last_log_level != current_log_level
           @last_log_level = current_log_level
-          @default = new(
-            middleware: [
-              Middleware::CommandLogger.new(
-                log_stdout: true,
-                log_stderr: true,
-                log_performance: true,
-                max_output_lines: 50,
-              ),
-            ],
-          )
+          begin
+            @default = new(
+              middleware: [
+                Middleware::CommandLogger.new(
+                  log_stdout: true,
+                  log_stderr: true,
+                  log_performance: true,
+                  max_output_lines: 50,
+                ),
+              ],
+            )
+          rescue => e
+            # Fallback to basic runner if there are issues
+            @default = new
+          end
         end
         @default
       end
@@ -64,7 +70,7 @@ module Makit
       # @param options [Hash] additional configuration
       def initialize(middleware: nil, strategy: nil, **options)
         @middleware = Array(middleware || default_middleware)
-        @strategy = strategy || Strategies::Synchronous.new
+        @strategy = strategy || Strategies::Factory.create(options)
         @options = options
 
         validate_middleware
@@ -314,6 +320,17 @@ module Makit
         raise ArgumentError, "Strategy must respond to #supports?: #{@strategy.class}"
       end
 
+      # Get information about the current strategy
+      #
+      # @return [Hash] strategy information
+      def strategy_info
+        {
+          class: @strategy.class.name,
+          type: @strategy.class.name.split('::').last.downcase,
+          factory_info: Strategies::Factory.strategy_info
+        }
+      end
+
       # Log command execution result using the default logger.
       #
       # @param request [Request] the executed request

data/lib/makit/commands/strategies/child_process.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'childprocess'
+require 'tempfile'
+require_relative "base"
+
+module Makit
+  module Commands
+    module Strategies
+      # ChildProcess-based command execution strategy
+      #
+      # This strategy uses the ChildProcess gem for robust cross-platform
+      # process management. It provides better handling of timeouts, I/O,
+      # and process lifecycle management compared to Open3.
+      #
+      # @example Basic usage
+      #   strategy = ChildProcess.new
+      #   result = strategy.execute(request)
+      #
+      # @example With custom options
+      #   strategy = ChildProcess.new(
+      #     timeout: 60,
+      #     max_output_size: 1_000_000
+      #   )
+      class ChildProcess < Base
+        # @!attribute [r] timeout
+        #   @return [Integer] default timeout in seconds
+        attr_reader :timeout
+
+        # @!attribute [r] max_output_size
+        #   @return [Integer] maximum output size in bytes
+        attr_reader :max_output_size
+
+        # Initialize ChildProcess strategy
+        #
+        # @param timeout [Integer] default timeout in seconds (default: 30)
+        # @param max_output_size [Integer] maximum output size in bytes (default: 1MB)
+        def initialize(timeout: 30, max_output_size: 1_000_000, **options)
+          @timeout = timeout
+          @max_output_size = max_output_size
+          super(**options)
+        end
+
+        # Execute a command request using ChildProcess
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] execution result
+        def execute(request)
+          result = Result.new(
+            command: request.to_shell_command,
+            started_at: Time.now,
+          )
+
+          stdout_file = nil
+          stderr_file = nil
+          process = nil
+
+          begin
+            # Create temporary files for output
+            stdout_file = Tempfile.new('makit_stdout')
+            stderr_file = Tempfile.new('makit_stderr')
+
+            # Build the process
+            process = ChildProcess.build(request.command, *request.arguments)
+
+            # Set working directory
+            process.cwd = request.directory if request.directory
+
+            # Set environment variables
+            (request.environment || {}).each do |key, value|
+              process.environment[key] = value.to_s
+            end
+
+            # Set up I/O
+            process.io.stdout = stdout_file
+            process.io.stderr = stderr_file
+
+            # Start the process
+            process.start
+
+            # Wait for completion with timeout
+            timeout_seconds = request.timeout || @timeout
+            process.poll_for_exit(timeout_seconds)
+
+            # Read output
+            stdout_file.rewind
+            stderr_file.rewind
+            stdout = stdout_file.read
+            stderr = stderr_file.read
+
+            # Truncate output if too large
+            stdout = truncate_output(stdout, "stdout")
+            stderr = truncate_output(stderr, "stderr")
+
+            result.finish!(
+              exit_code: process.exit_code,
+              stdout: stdout,
+              stderr: stderr,
+            )
+
+          rescue ChildProcess::TimeoutError
+            # Handle timeout
+            process&.stop
+            result.finish!(
+              exit_code: 124,
+              stderr: "Command timed out after #{timeout_seconds} seconds",
+            ).add_metadata(:timeout, true)
+            .add_metadata(:strategy, 'childprocess')
+
+          rescue => e
+            # Handle other errors
+            process&.stop rescue nil
+            result.finish!(
+              exit_code: 1,
+              stderr: e.message,
+            ).add_metadata(:error_class, e.class.name)
+            .add_metadata(:strategy, 'childprocess')
+
+          ensure
+            # Clean up resources
+            [stdout_file, stderr_file].each do |file|
+              file&.close
+              file&.unlink rescue nil
+            end
+          end
+
+          result
+        end
+
+        # Execute multiple requests using ChildProcess
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results
+        def execute_batch(requests)
+          # For now, execute sequentially to avoid complexity
+          # Could be enhanced to use process pools in the future
+          requests.map { |request| execute(request) }
+        end
+
+        private
+
+        # Truncate output if it exceeds maximum size
+        #
+        # @param output [String] output to potentially truncate
+        # @param type [String] output type for logging
+        # @return [String] truncated output
+        def truncate_output(output, type)
+          return output if output.bytesize <= @max_output_size
+
+          original_size = output.bytesize
+          truncated = output.byteslice(0, @max_output_size)
+          
+          Makit::Logging.warn(
+            "#{type.capitalize} truncated",
+            original_size: original_size,
+            max_size: @max_output_size,
+            strategy: 'childprocess'
+          )
+
+          "#{truncated}\n[#{type.upcase} TRUNCATED - Original size: #{original_size} bytes]"
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands/strategies/factory.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "synchronous"
+
+module Makit
+  module Commands
+    module Strategies
+      # Factory for creating command execution strategies with fallback support
+      #
+      # This factory allows easy switching between different execution strategies
+      # (ChildProcess, Open3, etc.) with automatic fallback to Open3 if the
+      # preferred strategy fails to load or execute.
+      #
+      # @example Using environment variable to control strategy
+      #   # Use ChildProcess (default)
+      #   MAKIT_STRATEGY=childprocess rake
+      #
+      #   # Force Open3 usage
+      #   MAKIT_STRATEGY=open3 rake
+      #
+      #   # Auto-detect (try ChildProcess, fallback to Open3)
+      #   MAKIT_STRATEGY=auto rake
+      class Factory
+        # Available strategy types
+        STRATEGIES = {
+          'childprocess' => 'ChildProcess',
+          'open3' => 'Synchronous',
+          'auto' => 'AutoDetect'
+        }.freeze
+
+        # Get the configured strategy instance
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] configured strategy instance
+        def self.create(options = {})
+          strategy_type = determine_strategy_type
+          
+          begin
+            case strategy_type
+            when 'childprocess'
+              create_childprocess_strategy(options)
+            when 'open3'
+              create_open3_strategy(options)
+            when 'auto'
+              create_auto_detect_strategy(options)
+            else
+              Makit::Logging.warn("Unknown strategy '#{strategy_type}', falling back to Open3") if defined?(Makit::Logging)
+              create_open3_strategy(options)
+            end
+          rescue => e
+            # Ultimate fallback - create basic synchronous strategy
+            Makit::Logging.warn("Failed to create strategy: #{e.message}") if defined?(Makit::Logging)
+            Synchronous.new
+          end
+        end
+
+        # Get the current strategy type from environment or default
+        #
+        # @return [String] strategy type
+        def self.determine_strategy_type
+          env_strategy = ENV['MAKIT_STRATEGY']&.downcase
+          
+          if env_strategy && STRATEGIES.key?(env_strategy)
+            env_strategy
+          else
+            'auto' # Default to auto-detect
+          end
+        end
+
+        # Create ChildProcess strategy with fallback
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_childprocess_strategy(options)
+          begin
+            require_relative 'child_process'
+            ChildProcess.new(**options)
+          rescue LoadError, StandardError => e
+            Makit::Logging.warn("Failed to load ChildProcess strategy: #{e.message}")
+            Makit::Logging.info("Falling back to Open3 strategy")
+            create_open3_strategy(options)
+          end
+        end
+
+        # Create Open3 strategy
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_open3_strategy(options)
+          Synchronous.new(**options)
+        end
+
+        # Create auto-detect strategy that tries ChildProcess first
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_auto_detect_strategy(options)
+          # Always use Open3 for now to avoid circular dependency issues
+          begin
+            Makit::Logging.debug("Using Open3 strategy") if defined?(Makit::Logging)
+            Synchronous.new(**options)
+          rescue => e
+            # Fallback to basic strategy if there are any issues
+            Makit::Logging.warn("Failed to create Open3 strategy: #{e.message}") if defined?(Makit::Logging)
+            Synchronous.new
+          end
+        end
+
+        # Get information about available strategies
+        #
+        # @return [Hash] strategy information
+        def self.strategy_info
+          {
+            current: determine_strategy_type,
+            available: STRATEGIES.keys,
+            childprocess_available: childprocess_available?,
+            open3_available: true # Always available
+          }
+        end
+
+        # Check if ChildProcess strategy is available
+        #
+        # @return [Boolean] true if ChildProcess can be loaded
+        def self.childprocess_available?
+          begin
+            require 'childprocess'
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/mp/string_mp.rb

@@ -62,7 +62,7 @@ class String
   end
 
   def cache_run(timestamp = nil)
-    puts "cache_run: #{self}"
+    #puts "cache_run: #{self}"
     command = self
     request = Makit::Commands::Request.from_string(command)
     if timestamp
@@ -75,9 +75,9 @@ class String
         environment: request.environment || {},
         metadata: (request.metadata || {}).merge(timestamp: timestamp),
       )
-      puts "timestamp: #{timestamp}"
+      #puts "timestamp: #{timestamp}"
     else
-      puts "no timestamp"
+      #puts "no timestamp"
     end
     Makit::Commands::Runner.default.execute(request)
   end

data/lib/makit/rake/trace_controller.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Makit
+  module Rake
+    # Enhanced trace controller for Rake with Makit-specific debugging information
+    #
+    # This class provides enhanced tracing capabilities when --trace is passed to rake,
+    # adding makit-specific debugging information to help with troubleshooting and
+    # understanding command execution flow.
+    #
+    # @example Basic usage
+    #   # In Rakefile
+    #   require "makit"
+    #   Makit::Rake::TraceController.setup
+    #
+    # @example With environment variable
+    #   MAKIT_TRACE=true rake --trace
+    class TraceController
+      # Set up enhanced tracing for Rake tasks
+      #
+      # This method should be called early in the Rakefile to enable enhanced
+      # tracing when --trace is passed to rake.
+      #
+      # @return [void]
+      def self.setup
+        return unless should_enhance_trace?
+
+        # Set up enhanced tracing
+        setup_enhanced_tracing
+        Makit::Logging.debug("Enhanced trace controller activated") if defined?(Makit::Logging)
+      end
+
+      # Check if trace enhancement should be enabled
+      #
+      # @return [Boolean] true if trace enhancement should be enabled
+      def self.should_enhance_trace?
+        ENV['RAKE_TRACE'] ||
+        ARGV.include?('--trace') ||
+        ENV['MAKIT_TRACE'] == 'true'
+      end
+
+      # Get current trace status
+      #
+      # @return [Hash] trace status information
+      def self.trace_status
+        {
+          rake_trace: ENV['RAKE_TRACE'],
+          trace_flag: ARGV.include?('--trace'),
+          makit_trace: ENV['MAKIT_TRACE'],
+          enhanced: should_enhance_trace?
+        }
+      end
+
+      private
+
+      # Set up enhanced tracing by monkey patching Rake's trace methods
+      #
+      # @return [void]
+      def self.setup_enhanced_tracing
+        # Store the original trace method if not already stored
+        unless ::Rake::Task.method_defined?(:makit_original_trace)
+          ::Rake::Task.class_eval do
+            alias_method :makit_original_trace, :trace
+
+            def trace(mode, message)
+              # Call original trace
+              makit_original_trace(mode, message)
+
+              # Add makit-specific trace info
+              add_makit_trace_info(mode, message)
+            end
+
+            private
+
+            # Add makit-specific trace information
+            #
+            # @param mode [Symbol] trace mode (:execute, :invoke, :prereq, etc.)
+            # @param message [String] trace message
+            # @return [void]
+            def add_makit_trace_info(mode, message)
+              case mode
+              when :execute
+                trace_makit_execution(message)
+              when :invoke
+                trace_makit_invocation(message)
+              when :prereq
+                trace_makit_prerequisite(message)
+              when :syntax
+                trace_makit_syntax(message)
+              end
+            end
+
+            # Trace makit execution with detailed information
+            #
+            # @param message [String] execution message
+            # @return [void]
+            def trace_makit_execution(message)
+              if makit_related?(message)
+                puts "  [MAKIT] Executing: #{message}"
+                puts "  [MAKIT] Strategy: #{get_makit_strategy_info}"
+                puts "  [MAKIT] Environment: #{ENV['MAKIT_STRATEGY'] || 'auto'}"
+                puts "  [MAKIT] Working Directory: #{Dir.pwd}"
+                puts "  [MAKIT] Timestamp: #{Time.now.iso8601}"
+                puts "  [MAKIT] Task: #{name}"
+              end
+            end
+
+            # Trace makit invocation
+            #
+            # @param message [String] invocation message
+            # @return [void]
+            def trace_makit_invocation(message)
+              if makit_related?(message)
+                puts "  [MAKIT] Invoking: #{message}"
+                puts "  [MAKIT] Task: #{name}"
+              end
+            end
+
+            # Trace makit prerequisite
+            #
+            # @param message [String] prerequisite message
+            # @return [void]
+            def trace_makit_prerequisite(message)
+              if makit_related?(message)
+                puts "  [MAKIT] Prerequisite: #{message}"
+                puts "  [MAKIT] Task: #{name}"
+              end
+            end
+
+            # Trace makit syntax
+            #
+            # @param message [String] syntax message
+            # @return [void]
+            def trace_makit_syntax(message)
+              if makit_related?(message)
+                puts "  [MAKIT] Syntax: #{message}"
+              end
+            end
+
+            # Check if message is makit-related
+            #
+            # @param message [String] message to check
+            # @return [Boolean] true if message is makit-related
+            def makit_related?(message)
+              message.downcase.include?('makit') ||
+              message.include?('bundle') ||
+              message.include?('gem') ||
+              message.include?('dotnet') ||
+              message.include?('protoc') ||
+              message.include?('git')
+            end
+
+            # Get makit strategy information safely
+            #
+            # @return [String] strategy information
+            def get_makit_strategy_info
+              begin
+                if defined?(Makit::Commands::Runner)
+                  runner = Makit::Commands::Runner.default
+                  info = runner.strategy_info
+                  "#{info[:type]} (#{info[:class]})"
+                else
+                  "not available"
+                end
+              rescue => e
+                "error: #{e.message}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/rake.rb

@@ -1,25 +1,81 @@
 # frozen_string_literal: true
 
-# This module provides classes for the Makit gem.
+require_relative "rake/trace_controller"
+
 module Makit
-  # This class provide methods for working with the system Environment.
-  #
-  class RakeHelper
-    def self.rake_repository(url, task_name)
-      local_path = File.join(Makit::Directories::HOME, "code", "work", Makit::Directories.get_relative_directory(url))
-      if Dir.exist?(local_path)
-        Dir.chdir(local_path) do
-          puts "  #{local_path.to_s.colorize(:grey)}"
-          "git pull".run
+  module Rake
+    # Enhanced Rake integration for Makit
+    #
+    # This module provides enhanced Rake integration capabilities including
+    # trace enhancement, task monitoring, and debugging utilities.
+    #
+    # @example Basic usage
+    #   require "makit"
+    #   Makit::Rake.setup
+    #
+    # @example With custom options
+    #   Makit::Rake.setup(trace: true, verbose: true)
+    class << self
+      # Set up enhanced Rake integration
+      #
+      # @param trace [Boolean] enable trace enhancement (default: auto-detect)
+      # @param verbose [Boolean] enable verbose output (default: false)
+      # @return [void]
+      def setup(trace: nil, verbose: false)
+        # Set up trace enhancement
+        if trace.nil?
+          TraceController.setup
+        elsif trace
+          ENV['MAKIT_TRACE'] = 'true'
+          TraceController.setup
+        end
+
+        # Set up verbose output if requested
+        if verbose
+          ENV['MAKIT_VERBOSE'] = 'true'
         end
-      else
-        puts "> ".colorize(:grey) + "git clone #{url} #{local_path}".colorize(:green)
-        `git clone #{url} #{local_path}`
+
+        # Log setup completion
+        if defined?(Makit::Logging)
+          Makit::Logging.debug("Makit Rake integration setup completed")
+          Makit::Logging.debug("Trace status: #{TraceController.trace_status}")
+        end
+      end
+
+      # Get current Rake integration status
+      #
+      # @return [Hash] integration status
+      def status
+        {
+          trace_controller: TraceController.trace_status,
+          verbose: ENV['MAKIT_VERBOSE'] == 'true',
+          strategy: get_strategy_info
+        }
+      end
+
+      # Check if enhanced tracing is active
+      #
+      # @return [Boolean] true if enhanced tracing is active
+      def tracing_enabled?
+        TraceController.should_enhance_trace?
       end
-      Dir.chdir(local_path) do
-        puts "  #{local_path.to_s.colorize(:grey)}"
-        "rake #{task_name}".run
+
+      private
+
+      # Get strategy information safely
+      #
+      # @return [Hash] strategy information
+      def get_strategy_info
+        begin
+          if defined?(Makit::Commands::Runner)
+            Makit::Commands::Runner.default.strategy_info
+          else
+            { error: "Commands::Runner not available" }
+          end
+        rescue => e
+          { error: e.message }
+        end
       end
     end
   end
-end
+end

data/lib/makit/setup/gem.rb

@@ -105,18 +105,18 @@ module Makit
       end
 
       def self.create_version_file(project)
-        version_path = "lib/#{project.name}/version.rb"
-        return if File.exist?(version_path)
+        #version_path = "lib/#{project.name}/version.rb"
+        #return if File.exist?(version_path)
 
-        version_content = <<~VERSION
-          # frozen_string_literal: true
+        #version_content = <<~VERSION
+        #  # frozen_string_literal: true
 
-          module #{project.name.capitalize}
-            VERSION = "#{project.version}"
-          end
-        VERSION
+        #  module #{project.name.capitalize}
+         #   VERSION = "#{project.version}"
+        #  end
+        #VERSION
 
-        File.write(version_path, version_content)
+        #File.write(version_path, version_content)
       end
 
       def self.create_rakefile(_project)

data/lib/makit/task_info.rb

@@ -50,7 +50,8 @@ module Makit
     #   end
     def self.track(task_name)
       task = new(task_name)
-      Makit::SHOW.task(task_name)
+      Makit::Logging.default_logger.task_start(task_name)
+      #Makit::SHOW.task(task_name)
       yield(task)
     ensure
       task&.report_and_store_time_taken
@@ -65,7 +66,8 @@ module Makit
     # @return [Object] Result of the yielded block
     def self.track_inferred(&block)
       task_name = infer_task_name
-      Makit::SHOW.task(task_name)
+      Makit::Logging.default_logger.task_start(task_name)
+      #Makit::SHOW.task(task_name)
       track(task_name, &block)
     end
 

data/lib/makit/tasks/hook_manager.rb

@@ -270,13 +270,65 @@ module Makit
         def setup!
           return if @hooks_installed
 
-          Rake::Task.class_eval do
+          ::Rake::Task.class_eval do
             alias_method :makit_original_execute, :execute
 
+            # Check if this task should have enhanced makit tracing
+            #
+            # @return [Boolean] true if task should be traced
+            def should_trace_makit_task?
+              # Check if trace is enabled
+              return false unless ENV['RAKE_TRACE'] || ARGV.include?('--trace') || ENV['MAKIT_TRACE'] == 'true'
+              
+              # Check if task is makit-related
+              makit_related_task?
+            end
+            
+            # Check if task is makit-related
+            #
+            # @return [Boolean] true if task is makit-related
+            def makit_related_task?
+              name.downcase.include?('makit') ||
+              name.include?('bundle') ||
+              name.include?('gem') ||
+              name.include?('dotnet') ||
+              name.include?('protoc') ||
+              name.include?('git') ||
+              name.include?('setup') ||
+              name.include?('build') ||
+              name.include?('test')
+            end
+            
+            # Get makit strategy information safely
+            #
+            # @return [String] strategy information
+            def get_makit_strategy_info
+              begin
+                if defined?(Makit::Commands::Runner)
+                  runner = Makit::Commands::Runner.default
+                  info = runner.strategy_info
+                  "#{info[:type]} (#{info[:class]})"
+                else
+                  "not available"
+                end
+              rescue => e
+                "error: #{e.message}"
+              end
+            end
+
             def execute(args = nil)
               start_time = Time.now
               error = nil
               result = nil
+              
+              # Add enhanced trace output for makit-related tasks
+              if should_trace_makit_task?
+                puts "  [MAKIT] Executing task: #{name}"
+                puts "  [MAKIT] Strategy: #{get_makit_strategy_info}"
+                puts "  [MAKIT] Environment: #{ENV['MAKIT_STRATEGY'] || 'auto'}"
+                puts "  [MAKIT] Working Directory: #{Dir.pwd}"
+                puts "  [MAKIT] Timestamp: #{Time.now.iso8601}"
+              end
 
               begin
                 # Execute pre-hooks

data/lib/makit/version.rb

@@ -1,5 +1,96 @@
 # frozen_string_literal: true
 
 module Makit
-  VERSION = "0.0.130"
-end
+  # Static version for now to avoid circular dependency issues
+  VERSION = "0.0.137"
+
+  # Version management utilities for various file formats
+  #
+  # This class provides methods for detecting, extracting, and updating version
+  # numbers in various file formats including .csproj, .wxs, .yml, .gemspec,
+  # .nuspec, and .toml files.
+  class Version
+    # Find the highest version from an array of version strings
+    #
+    # @param versions [Array<String>] Array of version strings to compare
+    # @return [String] The highest version string using semantic versioning comparison
+    def self.get_highest_version(versions)
+      versions.max { |a, b| Gem::Version.new(a) <=> Gem::Version.new(b) }
+    end
+
+    # Extract version number from a file based on its extension
+    #
+    # Supports multiple file formats:
+    # - .csproj files: `<Version>x.y.z</Version>`
+    # - .wxs files: `Version="x.y.z"`
+    # - .yml files: `VERSION: "x.y.z"`
+    #
+    # @param path [String] Path to the file containing version information
+    # @return [String] The extracted version string
+    # @raise [RuntimeError] If file doesn't exist or has unrecognized extension
+    def self.get_version_from_file(path)
+      raise "file #{path}does not exist" unless File.exist?(path)
+
+      extension = File.extname(path)
+      case extension
+      when ".csproj"
+        Makit::Version.detect_from_file(path, /<Version>([-\w\d.]+)</)
+      when ".wxs"
+        Makit::Version.detect_from_file(path, / Version="([\d.]+)"/)
+      when ".yml"
+        Makit::Version.detect_from_file(path, /VERSION:\s*["']?([\d.]+)["']?/)
+      else
+        raise "unrecognized file type"
+      end
+    end
+
+    # Detect version using a regex pattern in a specific file
+    #
+    # @param filename [String] Path to the file to search
+    # @param regex [Regexp] Regular expression pattern to match version
+    # @return [String, nil] The extracted version or nil if no match found
+    # @raise [RuntimeError] If file doesn't exist
+    def self.detect_from_file(filename, regex)
+      raise "unable to find version in #{filename}" unless File.exist?(filename)
+
+      match = File.read(filename).match(regex)
+      match.captures[0] if !match.nil? && match.captures.length.positive?
+    end
+
+    # Update version number in a file based on its extension
+    #
+    # Supports updating versions in multiple file formats:
+    # - .yml files
+    # - .gemspec files
+    # - .csproj files
+    # - .nuspec files
+    # - .wxs files
+    # - .toml files
+    #
+    # @param filename [String] Path to the file to update
+    # @param version [String] New version string to set
+    # @return [nil]
+    def self.set_version_in_file(filename, version)
+      text = File.read(filename)
+      new_text = text
+      new_text = text.gsub(/VERSION:\s?['|"]([.\d]+)['|"]/, "VERSION: \"#{version}\"") if filename.include?(".yml")
+      new_text = text.gsub(/version\s?=\s?['|"]([.\d]+)['|"]/, "version='#{version}'") if filename.include?(".gemspec")
+      new_text = text.gsub(/<Version>([-\w\d.]+)</, "<Version>#{version}<") if filename.include?(".csproj")
+      new_text = text.gsub(/<version>([-\w\d.]+)</, "<version>#{version}<") if filename.include?(".nuspec")
+      new_text = text.gsub(/ Version="([\d.]+)"/, " Version=\"#{version}\"") if filename.include?(".wxs")
+      new_text = text.gsub(/version\s+=\s+['"]([\w.]+)['"]/, "version=\"#{version}\"") if filename.include?(".toml")
+      File.write(filename, new_text) if new_text != text
+    end
+
+    # Update version number in multiple files matching a glob pattern
+    #
+    # @param glob_pattern [String] Glob pattern to match files (e.g., '**/*.csproj')
+    # @param version [String] New version string to set in all matching files
+    # @return [nil]
+    def self.set_version_in_files(glob_pattern, version)
+      Dir.glob(glob_pattern).each do |filename|
+        set_version_in_file(filename, version)
+      end
+    end
+  end
+end

data/lib/makit.rb

@@ -7,6 +7,7 @@ ENV["LOG_LEVEL"] ||= "info"
 
 require_relative "makit/version"
 require_relative "makit/dotnet"
+require_relative "makit/rake"
 
 # Load essential modules for Rakefile
 require_relative "makit/version_util"
@@ -17,6 +18,7 @@ require_relative "makit/serializer"
 require_relative "makit/humanize"
 require_relative "makit/directories"
 require_relative "makit/files"
+require_relative "makit/task_info"
 require_relative "makit/tasks"
 require_relative "makit/environment"
 require_relative "makit/process"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makit
 version: !ruby/object:Gem::Version
-  version: 0.0.130
+  version: 0.0.137
 platform: ruby
 authors:
 - Your Name
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -57,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: fiddle
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +166,8 @@ dependencies:
 description: A Ruby gem description
 email:
 - your.email@example.com
-executables: []
+executables:
+- makit
 extensions: []
 extra_rdoc_files: []
 files:
@@ -161,6 +176,7 @@ files:
 - lib/makit copy.rb
 - lib/makit.rb
 - lib/makit/apache.rb
+- lib/makit/auto.rb
 - lib/makit/cli/build_commands.rb
 - lib/makit/cli/generators/base_generator.rb
 - lib/makit/cli/generators/dotnet_generator.rb
@@ -182,6 +198,7 @@ files:
 - lib/makit/cli/main.rb
 - lib/makit/cli/project_commands.rb
 - lib/makit/cli/repository_commands.rb
+- lib/makit/cli/strategy_commands.rb
 - lib/makit/cli/utility_commands.rb
 - lib/makit/commands.rb
 - lib/makit/commands/factory.rb
@@ -193,6 +210,8 @@ files:
 - lib/makit/commands/result.rb
 - lib/makit/commands/runner.rb
 - lib/makit/commands/strategies/base.rb
+- lib/makit/commands/strategies/child_process.rb
+- lib/makit/commands/strategies/factory.rb
 - lib/makit/commands/strategies/synchronous.rb
 - lib/makit/configuration.rb
 - lib/makit/configuration/dotnet_project.rb
@@ -259,6 +278,7 @@ files:
 - lib/makit/protoc.rb
 - lib/makit/rake.rb
 - lib/makit/rake/cli.rb
+- lib/makit/rake/trace_controller.rb
 - lib/makit/ruby.rb
 - lib/makit/ruby/cli.rb
 - lib/makit/secrets.rb
@@ -320,7 +340,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A Ruby gem
 test_files: []