makit 0.0.129 → 0.0.135

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15584e2a283563b4b5dedc1f44ee95f7ecce6dc9bb906764726181c4b10c3e49
-  data.tar.gz: ddb61c19e66718669ebea95d0246f885dc9767f49db82ecc4331234159bd900d
+  metadata.gz: 04fddef2bfe206d137c1f4181f5ebaad085ecb2e449817c66fb839174d91779b
+  data.tar.gz: e40f4f909e1b073da28702e2ef78d32270ab8e3e8a59b012181d981c2f972b5a
 SHA512:
-  metadata.gz: b884215dea782f28428386e4b540a8d2d1443c371ddbd45ee333eb9b6dd70fe3ecbc192bcf2ecffcd232a2e4c52667902be6b871043ca3a7c9fbffd4f586c069
-  data.tar.gz: bee457e60325c56c67f5d40e1c17f4d28bbffc27b0079b4bcd225229e3176066284c88e0546c40512c73c8a80fbe69416487b2f286918aecb493cc5c677a6395
+  metadata.gz: 16324ca4ea5dffd8083f960783298e9ccb0ba238e919a1ea683f4232d84fdf9d3a01938b4f13ecc992c811c42cad6dfc0d3569d7fbc21aadad7f785c6b9afc36
+  data.tar.gz: 6a52c596632122e783d4df5d4bb2c1ad9e78cd3810c43b90d6d2c3f6569c7e8f36e3105f07cb059ff01ea72be1fc6773da761d5eb2686a3f58a56307db1cfdd9

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,47 @@
+# 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"
+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,7 @@ 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)
           rake        - Manage rake tasks
 
         Common usage examples:
@@ -56,6 +58,7 @@ 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 "rake", "Manage rake tasks", Makit::Rake::CliCommand
     end
   end

data/lib/makit/cli/strategy_commands.rb

@@ -0,0 +1,102 @@
+# 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
+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"
 
@@ -64,7 +65,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 +315,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,135 @@
+# 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
+          
+          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")
+            create_open3_strategy(options)
+          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)
+          # For now, always use Open3 until ChildProcess gem is installed
+          Makit::Logging.debug("Using Open3 strategy (ChildProcess not yet installed)")
+          Synchronous.new(**options)
+          
+          # TODO: Uncomment this when ChildProcess gem is installed
+          # begin
+          #   require_relative 'child_process'
+          #   Makit::Logging.debug("Using ChildProcess strategy")
+          #   ChildProcess.new(**options)
+          # rescue LoadError, StandardError => e
+          #   Makit::Logging.debug("ChildProcess not available: #{e.message}")
+          #   Makit::Logging.debug("Using Open3 strategy")
+          #   Synchronous.new(**options)
+          # 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/configuration/dotnet_project.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Makit
+  module Configuration
+    # Project configuration management
+    class DotNetProject
+      attr_accessor :name, :output_dir, :frameworks, :template
+    end
+  end
+end

data/lib/makit/configuration/project.rb

@@ -7,6 +7,7 @@ module Makit
     # Project configuration management
     class Project
       attr_accessor :git_remote_url, :name, :version, :project_type, :steps, :authors, :description, :license_expression
+      attr_accessor :dotnet_projects
 
       def initialize(name, version = nil, project_type = nil)
         # Support both keyword arguments and positional arguments for compatibility

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/setup/classlib.rb

@@ -9,6 +9,13 @@ module Makit
         # puts "Setting up Nuget project..."
         project = Makit::Configuration::Project.default
 
+        dotnet_project_directory = "source/#{project.name}"
+        dotnet_project = Makit::Configuration::DotNetProject.new
+        dotnet_project.name = project.name
+        dotnet_project.template = "classlib"
+        dotnet_project.output_dir = dotnet_project_directory
+        dotnet_project.frameworks = ["net8.0", "net8.0-browser"]
+
         project_filename = "source/#{project.name}/#{project.name}.csproj"
         if (!File.exist?(project_filename))
           Makit::DotNet::Project.new_project("classlib", project.name, "source/#{project.name}", "--framework net8.0")

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/setup/razorclasslib.rb

@@ -8,38 +8,48 @@ module Makit
       def self.run
         # puts "Setting up Nuget project..."
         project = Makit::Configuration::Project.default
-        Makit::DotNet::Project.new_project("razorclasslib", project.name, "source/#{project.name}",
-                                           "--framework net8.0")
-        dotnet_project = Makit::DotNet::Project.new("source/#{project.name}/#{project.name}.csproj")
-        # set the version to project.version
-        dotnet_project.set_version(project.version)
-        # set the frameworks = ["net8.0","net8.0-browser"]
-        dotnet_project.set_target_frameworks(["net8.0", "net8.0-browser"])
-        # set the nuget metadata
-        dotnet_project.set_nuget_metadata(project.name, project.authors, project.description,
-                                          project.license_expression)
-        Makit::DotNet::Project.new_project("TUnit", "#{project.name}.Tests", "tests/#{project.name}")
-        dotnet_project = Makit::DotNet::Project.new("tests/#{project.name}/#{project.name}.Tests.csproj")
-        # set the version to project.version
-        dotnet_project.set_version(project.version)
-        # set the frameworks = ["net8.0","net8.0-browser"]
-        dotnet_project.set_target_frameworks(["net8.0", "net8.0-browser"])
-        # set the nuget metadata
-        dotnet_project.set_nuget_metadata("#{project.name}.Tests", project.authors, project.description,
-                                          project.license_expression)
-        Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj",
-                                             "source/#{project.name}/#{project.name}.csproj")
+
+        project_filename = "source/#{project.name}/#{project.name}.csproj"
+        if (!File.exist?(project_filename))
+          Makit::DotNet::Project.new_project("razorclasslib", project.name, "source/#{project.name}",
+                                             "--framework net8.0")
+          dotnet_project = Makit::DotNet::Project.new("source/#{project.name}/#{project.name}.csproj")
+          # set the version to project.version
+          dotnet_project.set_version(project.version)
+          # set the frameworks = ["net8.0","net8.0-browser"]
+          dotnet_project.set_target_frameworks(["net8.0", "net8.0-browser"])
+          # set the nuget metadata
+          dotnet_project.set_nuget_metadata(project.name, project.authors, project.description,
+                                            project.license_expression)
+        end
+
+        test_project_filename = "tests/#{project.name}.Tests/#{project.name}.Tests.csproj"
+        if (File.exist?(test_project_filename))
+          Makit::DotNet::Project.new_project("TUnit", "#{project.name}.Tests", "tests/#{project.name}")
+          dotnet_project = Makit::DotNet::Project.new("tests/#{project.name}/#{project.name}.Tests.csproj")
+          # set the version to project.version
+          dotnet_project.set_version(project.version)
+          # set the frameworks = ["net8.0","net8.0-browser"]
+          dotnet_project.set_target_frameworks(["net8.0", "net8.0-browser"])
+          # set the nuget metadata
+          dotnet_project.set_nuget_metadata("#{project.name}.Tests", project.authors, project.description,
+                                            project.license_expression)
+          Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj",
+                                               "source/#{project.name}/#{project.name}.csproj")
+        end
         update_build_step(project)
         update_test_step(project)
 
         project.save
 
         # Setup the sln, then slnx
-        Makit::DotNet.new_solution(project.name)
-        Makit::DotNet.sln_add_projects(project.name)
-        # migrate the sln to slnx
-        "dotnet sln migrate #{project.name}.sln".run
-        FileUtils.rm_f("#{project.name}.sln") if File.exist?("#{project.name}.slnx")
+        if (!File.exist?("#{project.name}.slnx"))
+          Makit::DotNet.new_solution(project.name)
+          Makit::DotNet.sln_add_projects(project.name)
+          # migrate the sln to slnx
+          "dotnet sln migrate #{project.name}.sln".run
+          FileUtils.rm_f("#{project.name}.sln") if File.exist?("#{project.name}.slnx")
+        end
         Makit::Logging.default_logger.debug("Project setup completed")
       end
 

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/version.rb

@@ -1,5 +1,96 @@
 # frozen_string_literal: true
 
 module Makit
-  VERSION = "0.0.129"
-end
+  # Static version for now to avoid circular dependency issues
+  VERSION = "0.0.135"
+
+  # 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

@@ -17,6 +17,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.129
+  version: 0.0.135
 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,8 +210,11 @@ 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
 - lib/makit/configuration/gitlab_helper.rb
 - lib/makit/configuration/project.rb
 - lib/makit/configuration/rakefile_helper.rb
@@ -319,7 +339,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: []