makit 0.0.111 → 0.0.126

data/lib/makit/mp/string_mp.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
 require "json"
-# monkey patch String class with a run method
+require "fileutils"
+# monkey patch String class with command execution methods
 
 class String
   def run(args = nil)
     command = self
     if args.nil?
-      Makit::COMMANDS_COMPAT.run(Makit::COMMANDS_COMPAT.parse_command_request(command))
+      request = Makit::Commands::Request.from_string(command)
     else
       # Parse initial request
-      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
+      base_request = Makit::Commands::Request.from_string(command)
 
       if args.is_a?(Hash)
         # Create new request with combined options
@@ -28,321 +29,163 @@ class String
           case key.to_s
           when "arguments"
             # Append additional arguments
-            request_options[:arguments] = request_options[:arguments] + Array(value)
+            request_options[:arguments] = (request_options[:arguments] + Array(value)).flatten
           when "directory"
             request_options[:directory] = value
           when "timeout"
             request_options[:timeout] = value
           when "environment"
-            request_options[:environment] = request_options[:environment].merge(value || {})
+            request_options[:environment] = (request_options[:environment] || {}).merge(value)
+          when "metadata"
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(value)
           else
-            # Store other options in metadata
-            request_options[:metadata][key] = value
+            # Add unknown keys to metadata
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(key.to_s => value)
           end
         end
 
-        # Create new request with updated options
+        # Create new request with combined options
         request = Makit::Commands::Request.new(**request_options)
       else
-        request = base_request
-      end
-
-      Makit::COMMANDS_COMPAT.run(request)
-    end
-  end
-
-  def cache_run(timestamp = nil)
-    command = self
-    if timestamp.nil?
-      # Use default timestamp from compatibility layer
-      Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command))
-    else
-      Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
-    end
-  end
-
-  def try(args = nil)
-    command = self
-    if args.nil?
-      Makit::COMMANDS_COMPAT.try(command)
-    else
-      # Parse initial request
-      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
-
-      if args.is_a?(Hash)
-        # Create new request with combined options
-        request_options = {
+        # args is an array of additional arguments
+        request = Makit::Commands::Request.new(
           command: base_request.command,
-          arguments: base_request.arguments || [],
+          arguments: (base_request.arguments || []) + Array(args),
           directory: base_request.directory,
           timeout: base_request.timeout,
           environment: base_request.environment || {},
           metadata: base_request.metadata || {},
-        }
-
-        # Apply args to the request options
-        args.each do |key, value|
-          case key.to_s
-          when "arguments"
-            # Append additional arguments
-            request_options[:arguments] = request_options[:arguments] + Array(value)
-          when "directory"
-            request_options[:directory] = value
-          when "timeout"
-            request_options[:timeout] = value
-          when "environment"
-            request_options[:environment] = request_options[:environment].merge(value || {})
-          else
-            # Store other options in metadata
-            request_options[:metadata][key] = value
-          end
-        end
-
-        # Create new request with updated options
-        request = Makit::Commands::Request.new(**request_options)
-      else
-        request = base_request
+        )
       end
-
-      Makit::COMMANDS_COMPAT.try(request)
     end
+    Makit::Commands::Runner.default.execute(request)
   end
 
-  def show(args = nil)
+  def cache_run(timestamp = nil)
+    puts "cache_run: #{self}"
     command = self
-    if args.nil?
-      Makit::COMMANDS_COMPAT.show(command)
+    request = Makit::Commands::Request.from_string(command)
+    if timestamp
+      # Add timestamp to metadata for cache key generation
+      request = Makit::Commands::Request.new(
+        command: request.command,
+        arguments: request.arguments,
+        directory: request.directory,
+        timeout: request.timeout,
+        environment: request.environment || {},
+        metadata: (request.metadata || {}).merge(timestamp: timestamp),
+      )
+      puts "timestamp: #{timestamp}"
     else
-      # Parse initial request
-      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
-
-      if args.is_a?(Hash)
-        # Create new request with combined options
-        request_options = {
-          command: base_request.command,
-          arguments: base_request.arguments || [],
-          directory: base_request.directory,
-          timeout: base_request.timeout,
-          environment: base_request.environment || {},
-          metadata: base_request.metadata || {},
-        }
-
-        # Apply args to the request options
-        args.each do |key, value|
-          case key.to_s
-          when "arguments"
-            # Append additional arguments
-            request_options[:arguments] = request_options[:arguments] + Array(value)
-          when "directory"
-            request_options[:directory] = value
-          when "timeout"
-            request_options[:timeout] = value
-          when "environment"
-            request_options[:environment] = request_options[:environment].merge(value || {})
-          else
-            # Store other options in metadata
-            request_options[:metadata][key] = value
-          end
-        end
-
-        # Create new request with updated options
-        request = Makit::Commands::Request.new(**request_options)
-      else
-        request = base_request
-      end
-
-      Makit::COMMANDS_COMPAT.show(request)
+      puts "no timestamp"
     end
+    Makit::Commands::Runner.default.execute(request)
   end
 
-  def log(filename)
-    # Ensure directory exists if filename contains path
-    if filename.include?("/")
-      directory = File.dirname(filename)
-      FileUtils.mkdir_p(directory)
-    end
+  def try
     command = self
+    request = Makit::Commands::Request.from_string(command).exit_on_failure(false)
+    Makit::Commands::Runner.default.execute(request)
+  end
 
-    Makit::Logging.info("Logging command output to file", {
-      command: command,
-      log_file: filename,
-    })
-
-    cmd = Makit::COMMANDS_COMPAT.run(Makit::COMMANDS_COMPAT.parse_command_request(command))
+  def show
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    Makit::Commands::Runner.default.execute(request)
+  end
 
-    # Write the cmd output and error to the file
-    File.write(filename, cmd.output + cmd.error)
+  def log
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
 
-    # Log the result
-    if cmd.success?
-      Makit::Logging.success("Command logged successfully", {
-        command: command,
-        log_file: filename,
-        output_length: cmd.output.length,
-        error_length: cmd.error.length,
-      })
+    # Log the command execution result
+    if result.success?
+      Makit::Logging.info("Command completed successfully: #{command}")
     else
-      Makit::Logging.error("Command failed and logged", {
-        command: command,
-        log_file: filename,
-        exit_code: cmd.exit_code,
-        output_length: cmd.output.length,
-        error_length: cmd.error.length,
-      })
+      Makit::Logging.error("Command failed: #{command} (exit code: #{result.exit_code})")
     end
 
-    Makit::COMMANDS_COMPAT.show_command(cmd)
+    result
   end
 
-  def cache_log(filename, timestamp = nil)
-    # Ensure directory exists if filename contains path
-    if filename.include?("/")
-      directory = File.dirname(filename)
-      FileUtils.mkdir_p(directory)
-    end
+  def cache_try(timestamp = nil)
     command = self
+    request = Makit::Commands::Request.from_string(command)
+    if timestamp
+      # Add timestamp to metadata for cache key generation
+      request = Makit::Commands::Request.new(
+        command: request.command,
+        arguments: request.arguments,
+        directory: request.directory,
+        timeout: request.timeout,
+        environment: request.environment || {},
+        metadata: (request.metadata || {}).merge(timestamp: timestamp),
+      )
+    end
+    Makit::Commands::Runner.default.execute(request)
+  end
 
-    #Makit::Logging.info("Cache logging command output", {
-    #  command: command,
-    #  log_file: filename,
-    #  timestamp: timestamp ? Makit::Humanize.get_humanized_timestamp(timestamp) : nil
-    #})
-
-    # Use cache_run with optional timestamp
-    cmd = if timestamp.nil?
-        Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command))
-      else
-        Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
-      end
-
-    # Write the cached command output and error to the file
-    File.write(filename, cmd.output + cmd.error)
-
-    # Log the execution result
+  def show_command(cmd)
     if cmd.success?
-      Makit::Logging.success(command)
-      #Makit::Logging.success("Command executed and cached", {
-      #  command: command,
-      #  log_file: filename,
-      #  cached: true,
-      #  output_length: cmd.output.length,
-      #   error_length: cmd.error.length
-      # })
+      puts "✅ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:green)
     else
-      Makit::Logging.error("Command failed and cached", {
-        command: command,
-        log_file: filename,
-        exit_code: cmd.exit_code,
-        cached: true,
-        output_length: cmd.output.length,
-        error_length: cmd.error.length,
-      })
+      puts "❌ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:red)
+      puts "   Exit code: #{cmd.exit_code}".colorize(:red)
+      puts "   Error: #{cmd.stderr}".colorize(:red) if cmd.stderr && !cmd.stderr.empty?
     end
-
-    # Display detailed output and log location only if it failed
-    return if cmd.success?
-
-    Makit::COMMANDS_COMPAT.show_command(cmd)
-    Makit::Logging.info("Log written to file", {
-      log_file: File.expand_path(filename),
-    })
   end
 
-  def cache_try(timestamp = nil)
+  def to_markdown
     command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
 
-    Makit::Logging.info("Trying cached command execution", {
-      command: command,
-      timestamp: timestamp ? Makit::Humanize.get_humanized_timestamp(timestamp) : nil,
-    })
-
-    result = if timestamp.nil?
-        # Use default timestamp from compatibility layer
-        Makit::COMMANDS_COMPAT.cache_try(Makit::COMMANDS_COMPAT.parse_command_request(command))
-      else
-        Makit::COMMANDS_COMPAT.cache_try(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
-      end
-
-    # Log the result
     if result.success?
-      Makit::Logging.success("Cached command executed successfully", {
-        command: command,
-        cached: true,
-        duration: result.duration,
-      })
+      "```\n#{result.stdout}\n```"
     else
-      Makit::Logging.warn("Cached command failed", {
-        command: command,
-        exit_code: result.exit_code,
-        cached: true,
-      })
+      "```\nError: #{result.stderr}\n```"
     end
-
-    result
   end
 
-  # Read a value from a JSON file
-  # key is a string with the key to read, e.g. "AzureAd.Authority"
-  def get_json_value(key)
-    json = File.read(self)
-    data = JSON.parse(json)
-
-    # key delimiter is '.' so we can access nested keys
-    key.split(".").each do |k|
-      data = data[k]
-    end
-    data
+  def cache_run_with_timestamp(timestamp)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    request = Makit::Commands::Request.new(
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: request.timeout,
+      environment: request.environment || {},
+      metadata: (request.metadata || {}).merge(timestamp: timestamp),
+    )
+    Makit::Commands::Runner.default.execute(request)
   end
 
-  alias retrieve get_json_value
-
-  # Set a value in a JSON file
-  # key is a string with the key to set, e.g. "AzureAd.Authority"
-  def set_json_value(key, value)
-    file = File.read(self)
-    data = JSON.parse(file)
-    keys = key.split(".")
-    current = data
-
-    # Traverse and create any missing keys
-    keys[0..-2].each do |k|
-      current[k] ||= {} # Create a new hash if the key doesn't exist
-      current = current[k]
-    end
-
-    # Set the value for the final key
-    current[keys[-1]] = value
-
-    # Write the JSON back to the file
-    File.write(self, JSON.pretty_generate(data))
+  def cache_try_with_timestamp(timestamp)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    request = Makit::Commands::Request.new(
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: request.timeout,
+      environment: request.environment || {},
+      metadata: (request.metadata || {}).merge(timestamp: timestamp),
+    )
+    Makit::Commands::Runner.default.execute(request)
   end
 
-  # Alias for set_json_value
-  alias assign set_json_value
-
-  def strip_color_codes
-    # Regular expression to remove ANSI color codes
-    gsub(/\e\[[\d;]+m/, "")
-  end
+  def cache_log(log_file)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
 
-  def to_lines(max_length = 80, indent_length = 5)
-    return self if length <= max_length
+    # Write output to log file
+    FileUtils.mkdir_p(File.dirname(log_file))
+    File.write(log_file, result.stdout) if result.stdout && !result.stdout.empty?
+    File.write(log_file, result.stderr, mode: "a") if result.stderr && !result.stderr.empty?
 
-    indent = " " * indent_length
-    words = split(" ")
-    lines = []
-    line = ""
-    words.each do |word|
-      if (line + word).length > max_length
-        lines << line
-        line = indent + word
-      elsif line.empty?
-        line = word
-      else
-        line += " #{word}"
-      end
-    end
-    lines << line
-    lines.join("\n")
+    result
   end
 end

data/lib/makit/serializer.rb

@@ -1,6 +1,19 @@
 # frozen_string_literal: true
 
-require "google/protobuf"
+begin
+  require "google/protobuf"
+rescue LoadError
+  # google-protobuf gem not available, define a minimal protobuf interface
+  module Google
+    module Protobuf
+      class Message
+        def to_json(*_args)
+          {}
+        end
+      end
+    end
+  end
+end
 # This module provides classes for the Makit gem.
 module Makit
   module Proto3Formats

data/lib/makit/services/builder.rb

@@ -110,7 +110,7 @@ module Makit
           make_dir = Directories.get_make_commit_directory(url, commit)
           FileUtils.rm_rf(make_dir)
 
-          clone_command = Makit::RUNNER.execute("git clone #{clone_dir} #{make_dir}")
+          clone_command = Makit::Commands::Runner.default.execute("git clone #{clone_dir} #{make_dir}")
           commands << clone_command
 
           return if Dir.exist?(make_dir)
@@ -132,17 +132,17 @@ module Makit
 
         # Execute git-specific commands for the build
         def execute_git_commands(commit, commands)
-          commands << Makit::RUNNER.execute("git reset --hard #{commit}")
-          commands << Makit::RUNNER.execute("git log -n 1")
+          commands << Makit::Commands::Runner.default.execute("git reset --hard #{commit}")
+          commands << Makit::Commands::Runner.default.execute("git log -n 1")
         end
 
         # Execute build commands (bundle, rake, etc.)
         def execute_build_commands(commands)
-          commands << Makit::RUNNER.execute("bundle install") if File.exist?("Gemfile")
+          commands << Makit::Commands::Runner.default.execute("bundle install") if File.exist?("Gemfile")
 
           return unless File.exist?("Rakefile") || File.exist?("rakefile.rb")
 
-          commands << Makit::RUNNER.execute("rake default")
+          commands << Makit::Commands::Runner.default.execute("rake default")
         end
 
         # Create the make result object

data/lib/makit/services/repository_manager.rb

@@ -22,7 +22,7 @@ module Makit
 
           Dir.chdir(directory) do
             File.write(".gitignore", Makit::Content::GITIGNORE) unless File.exist?(".gitignore")
-            init_command = Makit::RUNNER.execute("git init")
+            init_command = Makit::Commands::Runner.default.execute("git init")
 
             if init_command.exit_code != 0
               raise Makit::GitError, "failed to initialize local repository: #{directory}\\n#{Makit::Humanize.get_command_summary(init_command)}"
@@ -41,7 +41,9 @@ module Makit
           commands = []
 
           clone_dir = Directories.get_clone_directory(git_repository)
-          commands << Makit::RUNNER.execute("git clone #{git_repository} #{clone_dir}") unless Dir.exist?(clone_dir)
+          unless Dir.exist?(clone_dir)
+            commands << Makit::Commands::Runner.default.execute("git clone #{git_repository} #{clone_dir}")
+          end
 
           commands
         end
@@ -91,7 +93,7 @@ module Makit
           Validator.validate_directory_exists(clone_dir, "clone directory")
 
           Dir.chdir(clone_dir) do
-            log_command = Makit::RUNNER.execute("git log -n #{limit} --skip #{skip} --date=iso")
+            log_command = Makit::Commands::Runner.default.execute("git log -n #{limit} --skip #{skip} --date=iso")
             parse_git_log_output(log_command)
           end
         end
@@ -114,7 +116,7 @@ module Makit
         # @return [String] the latest commit hash
         def get_latest_commit(clone_dir, commands)
           Dir.chdir(clone_dir) do
-            git_log = Makit::RUNNER.execute("git log -n 1 --date=iso")
+            git_log = Makit::Commands::Runner.default.execute("git log -n 1 --date=iso")
             commands << git_log
 
             commit = git_log.output.match(/^commit ([0-9a-f]{#{Validator::COMMIT_HASH_LENGTH}})$/i)&.captures&.first
@@ -146,7 +148,7 @@ module Makit
             arguments: ["pull"],
             directory: clone_dir,
           )
-          pull_command = Makit::RUNNER.execute(request)
+          pull_command = Makit::Commands::Runner.default.execute(request)
 
           raise Makit::PullError, Makit::Humanize.get_command_details(pull_command) if pull_command.exit_code != 0
 
@@ -160,7 +162,7 @@ module Makit
 
           unless Dir.exist?(work_dir)
             FileUtils.mkdir_p(File.dirname(work_dir))
-            Makit::RUNNER.execute("git clone #{clone_dir} #{work_dir}")
+            Makit::Commands::Runner.default.execute("git clone #{clone_dir} #{work_dir}")
           end
 
           Dir.chdir(work_dir) do

data/lib/makit/setup/classlib.rb

@@ -1,31 +1,67 @@
 # frozen_string_literal: true
+
 require_relative "../configuration/project"
 
 module Makit
   module Setup
     class ClassLib
       def self.run
-        #puts "Setting up Nuget project..."
+        # puts "Setting up Nuget project..."
         project = Makit::Configuration::Project.default
         Makit::DotNet::Project.new_project("classlib", 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}")
-        Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj", "source/#{project.name}/#{project.name}.csproj")
+        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")
         update_build_step(project)
         update_test_step(project)
 
         project.save
-        Makit::Logging.default_logger.info("Project setup completed")
+
+        # 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")
+        Makit::Logging.default_logger.debug("Project setup completed")
       end
 
       def self.update_build_step(project)
-        build_commands = Array.new
+        build_commands = []
+        build_commands << "dotnet restore #{project.name}.slnx" if File.exist?("#{project.name}.slnx")
         build_commands << "dotnet build source/#{project.name}/#{project.name}.csproj --configuration Release"
+        build_commands << "dotnet build tests/#{project.name}/#{project.name}.Tests.csproj --configuration Release"
+        build_commands << "dotnet pack source/#{project.name}/#{project.name}.csproj --configuration Release --output artifacts/Packages"
+        build_commands << "dotnet pack tests/#{project.name}/#{project.name}.Tests.csproj --configuration Release --output artifacts/Packages"
+        if File.exist?("source/#{project.name}.Pages/#{project.name}.Pages.csproj")
+          build_commands << "dotnet build source/#{project.name}.Pages/#{project.name}.Pages.csproj --configuration Release"
+        end
+        if File.exist?("source/#{project.name}.Pages/#{project.name}.Pages.csproj")
+          build_commands << "dotnet publish source/#{project.name}.Pages/#{project.name}.Pages.csproj --configuration Release --output artifacts/Pages"
+        end
         steps = project.steps
         if steps.any? { |step| step.name == "build" }
           build_step = steps.find { |step| step.name == "build" }
           build_step.commands = build_commands
         else
-          build_step = Makit::Configuration::Step.new(name: "build", description: "Build the project artifacts", commands: build_commands)
+          build_step = Makit::Configuration::Step.new(name: "build", description: "Build the project artifacts",
+                                                      commands: build_commands)
           build_step.commands = build_commands
           project.add_step(build_step)
         end
@@ -35,14 +71,15 @@ module Makit
       end
 
       def self.update_test_step(project)
-        test_commands = Array.new
+        test_commands = []
         test_commands << "dotnet test tests/#{project.name}/#{project.name}.Tests.csproj"
         steps = project.steps
         if steps.any? { |step| step.name == "test" }
           test_step = steps.find { |step| step.name == "test" }
           test_step.commands = test_commands
         else
-          test_step = Makit::Configuration::Step.new(name: "test", description: "Run the project tests", commands: test_commands)
+          test_step = Makit::Configuration::Step.new(name: "test", description: "Run the project tests",
+                                                     commands: test_commands)
           test_step.commands = test_commands
           project.add_step(test_step)
         end