makit 0.0.98 → 0.0.111

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Makit
+  module Commands
+    module Strategies
+      # Base class for command execution strategies.
+      #
+      # Execution strategies define how commands are actually executed -
+      # synchronously, asynchronously, in parallel, etc. This provides
+      # flexibility in execution patterns while maintaining a consistent
+      # interface.
+      #
+      # @example Creating custom strategy
+      #   class CustomStrategy < Base
+      #     def execute(request)
+      #       # Custom execution logic
+      #       result = Result.new(command: request.to_shell_command)
+      #       # ... perform execution ...
+      #       result.finish!(exit_code: 0, stdout: "success")
+      #     end
+      #   end
+      class Base
+        # Execute a command request.
+        #
+        # This method must be implemented by subclasses to provide the actual
+        # command execution logic. The implementation should create a Result
+        # object and populate it with execution details.
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] the execution result
+        # @raise [NotImplementedError] if not overridden by subclass
+        def execute(request)
+          raise NotImplementedError, "#{self.class.name} must implement #execute"
+        end
+
+        # Execute multiple requests (default: sequential execution).
+        #
+        # Override this method in subclasses to provide optimized batch execution
+        # such as parallel execution.
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results in same order
+        def execute_batch(requests)
+          requests.map { |request| execute(request) }
+        end
+
+        # Check if this strategy can handle the given request.
+        #
+        # Override this method to provide conditional strategy selection
+        # based on request properties.
+        #
+        # @param request [Request] the command request
+        # @return [Boolean] true if strategy can handle the request
+        def supports?(_request)
+          true
+        end
+
+        # Get strategy name for logging and debugging.
+        #
+        # @return [String] strategy name
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Get strategy configuration.
+        #
+        # @return [Hash] strategy configuration
+        def config
+          {}
+        end
+
+        protected
+
+        # Execute command using Open3 for cross-platform compatibility.
+        #
+        # This is a helper method that subclasses can use for actual
+        # system command execution.
+        #
+        # @param request [Request] the command request
+        # @return [Result] execution result
+        def execute_with_open3(request)
+          result = Result.new(
+            command: request.to_shell_command,
+            started_at: Time.now,
+          )
+
+          begin
+            # Change to specified directory if provided
+            Dir.chdir(request.directory) do
+              # Execute command with timeout using Timeout module
+              stdout, stderr, status = if request.timeout&.positive?
+                  Timeout.timeout(request.timeout) do
+                    Open3.capture3(
+                      request.environment,
+                      request.command,
+                      *request.arguments
+                    )
+                  end
+                else
+                  Open3.capture3(
+                    request.environment,
+                    request.command,
+                    *request.arguments
+                  )
+                end
+
+              result.finish!(
+                exit_code: status.exitstatus,
+                stdout: stdout,
+                stderr: stderr,
+              )
+            end
+          rescue Timeout::Error => e
+            result.finish!(
+              exit_code: 124, # timeout exit code
+              stderr: "Command timed out after #{request.timeout} seconds",
+            ).add_metadata(:timeout, true)
+                  .add_metadata(:error, e.message)
+          rescue StandardError => e
+            result.finish!(
+              exit_code: 1,
+              stderr: e.message,
+            ).add_metadata(:error_class, e.class.name)
+                  .add_metadata(:error, e.message)
+          end
+
+          result
+        end
+
+        # Validate that the command exists and is executable.
+        #
+        # @param command [String] command to validate
+        # @return [Boolean] true if command is available
+        def command_available?(command)
+          system("which #{command} > /dev/null 2>&1") ||
+            system("where #{command} > nul 2>&1") # Windows
+        end
+
+        # Get the full path to a command.
+        #
+        # @param command [String] command name
+        # @return [String, nil] full path to command or nil if not found
+        def which(command)
+          # Try Unix-style which first
+          path = `which #{command} 2>/dev/null`.strip
+          return path unless path.empty?
+
+          # Try Windows-style where
+          path = `where #{command} 2>nul`.strip
+          return path unless path.empty?
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../result"
+
+module Makit
+  module Commands
+    module Strategies
+      # Synchronous command execution strategy.
+      #
+      # This strategy executes commands one at a time, blocking until each
+      # command completes. This is the simplest and most reliable execution
+      # pattern, suitable for most use cases.
+      #
+      # @example Using synchronous execution
+      #   strategy = Synchronous.new
+      #   request = Request.new(command: "echo", arguments: ["hello"])
+      #   result = strategy.execute(request)
+      #   puts result.stdout # "hello"
+      class Synchronous < Base
+        # Initialize synchronous execution strategy.
+        #
+        # @param options [Hash] strategy configuration
+        # @option options [Boolean] :validate_commands (true) whether to validate commands exist
+        # @option options [Integer] :max_output_size (1048576) maximum output size in bytes
+        def initialize(**options)
+          @validate_commands = options.fetch(:validate_commands, true)
+          @max_output_size = options.fetch(:max_output_size, 1024 * 1024) # 1MB default
+        end
+
+        # Execute a single command request synchronously.
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] execution result
+        def execute(request)
+          # Skip command validation for basic commands like echo on Windows
+          # This is a simplified approach for demonstration purposes
+          if @validate_commands && !basic_command?(request.command) && !command_available?(request.command)
+            return Result.failure(
+                     command: request.to_shell_command,
+                     error: "Command not found: #{request.command}",
+                   )
+          end
+
+          # Execute using Open3 for cross-platform support
+          result = execute_with_open3(request)
+
+          # Truncate output if too large
+          if result.stdout.bytesize > @max_output_size
+            original_size = result.stdout.bytesize
+            truncated_stdout = result.stdout.byteslice(0, @max_output_size)
+            result.instance_variable_set(:@stdout, "#{truncated_stdout}\n[OUTPUT TRUNCATED]")
+            result.add_metadata(:output_truncated, true)
+            result.add_metadata(:original_stdout_size, original_size)
+          end
+
+          if result.stderr.bytesize > @max_output_size
+            original_size = result.stderr.bytesize
+            truncated_stderr = result.stderr.byteslice(0, @max_output_size)
+            result.instance_variable_set(:@stderr, "#{truncated_stderr}\n[ERROR OUTPUT TRUNCATED]")
+            result.add_metadata(:stderr_truncated, true)
+            result.add_metadata(:original_stderr_size, original_size)
+          end
+
+          # Add strategy metadata
+          result.add_metadata(:execution_strategy, "synchronous")
+          result.add_metadata(:validated_command, @validate_commands)
+
+          result
+        end
+
+        # Execute multiple requests sequentially.
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results in same order
+        def execute_batch(requests)
+          results = []
+
+          requests.each_with_index do |request, index|
+            result = execute(request)
+            result.add_metadata(:batch_index, index)
+            result.add_metadata(:batch_size, requests.size)
+            results << result
+
+            # Stop on first failure if configured
+            break if result.failure? && fail_fast?
+          end
+
+          results
+        end
+
+        # Check if strategy supports the given request.
+        #
+        # Synchronous strategy supports all requests.
+        #
+        # @param request [Request] the command request
+        # @return [Boolean] always true
+        def supports?(_request)
+          true
+        end
+
+        # Get strategy configuration.
+        #
+        # @return [Hash] strategy configuration
+        def config
+          {
+            name: "synchronous",
+            validate_commands: @validate_commands,
+            max_output_size: @max_output_size,
+            fail_fast: fail_fast?,
+          }
+        end
+
+        private
+
+        # Check if command is a basic system command that should always be available.
+        #
+        # @param command [String] command name
+        # @return [Boolean] true if it's a basic command
+        def basic_command?(command)
+          %w[echo ruby bundle rake git].include?(command)
+        end
+
+        # Check if execution should stop on first failure.
+        #
+        # @return [Boolean] whether to fail fast
+        def fail_fast?
+          # Could be configurable in the future
+          false
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands.rb

@@ -8,14 +8,35 @@ require "logger"
 
 # This module provides classes for the Makit gem.
 module Makit
+  # Commands module provides a modern, flexible command execution framework
+  # with middleware support, validation, caching, and structured logging.
+  module Commands
+    # Custom exception for security-related command validation failures
+    class SecurityError < StandardError; end
+
+    # Custom exception for command execution failures
+    class ExecutionError < StandardError
+      attr_reader :exit_code, :stderr
+
+      def initialize(message, exit_code: nil, stderr: nil)
+        @exit_code = exit_code
+        @stderr = stderr
+        super(message)
+      end
+    end
+  end
+
   # This class provide methods running commands.
   #
-  class Commands < Array
-
+  class LegacyCommands < Array
     # Generate the commands based on the current directory.
     def auto_generate
       self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["install"]) if File.exist?("Gemfile")
-      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["exec", "rake"]) if File.exist?("Rakefile")
+      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: %w[exec rake]) if File.exist?("Rakefile")
     end
   end
 end
+
+# Load command system components (load existing components only)
+require_relative "commands/result"
+require_relative "commands/middleware/validator"

data/lib/makit/configuration/gitlab_helper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Makit
+  module Configuration
+    # Helper for GitLab CI YAML conversion
+    class GitLabHelper
+      def self.to_yaml(project, path)
+        yaml_content = generate_yaml(project)
+        File.write(path, yaml_content)
+      end
+
+      def self.from_yaml(path)
+        content = File.read(path)
+        data = YAML.safe_load(content, symbolize_names: true, permitted_classes: [Symbol])
+
+        project = Project.new(name: data[:name] || "Unknown", version: data[:version] || "1.0.0")
+
+        # Extract steps from GitLab CI jobs
+        data.each do |key, value|
+          next unless value.is_a?(Hash) && value[:script]
+
+          step_name = key.to_s.gsub(/_job$/, "")
+          step = Step.new(
+            name: step_name,
+            description: value[:description] || "GitLab CI job: #{step_name}",
+            commands: value[:script],
+          )
+          project.add_step(step)
+        end
+
+        project
+      end
+
+      private
+
+      def self.generate_yaml(project)
+        yaml = {
+          stages: project.steps.map(&:name),
+          variables: {
+            project_name: project.name,
+            project_version: project.version,
+          },
+        }
+
+        project.steps.each do |step|
+          job_name = "#{step.name}_job"
+          yaml[job_name.to_sym] = {
+            stage: step.name,
+            script: step.commands,
+            description: step.description,
+          }
+        end
+
+        yaml.to_yaml
+      end
+    end
+  end
+end

data/lib/makit/configuration/project.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Makit
+  module Configuration
+    # Project configuration management
+    class Project
+      attr_accessor :git_remote_url, :name, :version, :project_type, :steps
+
+      def initialize(name, version = nil, project_type = nil)
+        # Support both keyword arguments and positional arguments for compatibility
+        if name.is_a?(Hash)
+          # Keyword arguments: Project.new(name: "test", version: "1.0.0")
+          @name = name[:name]
+          @version = name[:version]
+          @project_type = name[:project_type]
+        else
+          # Positional arguments: Project.new("test", "1.0.0", "nuget")
+          @name = name
+          @version = version
+          @project_type = project_type
+        end
+
+        @steps = []
+      end
+
+      def add_step(step)
+        raise ArgumentError, "Step must be a Makit::Configuration::Step instance" unless step.is_a?(Step)
+        @steps << step
+      end
+
+      def to_json(*args)
+        {
+          name: @name,
+          version: @version,
+          project_type: @project_type,
+          steps: @steps.map(&:to_h),
+        }.to_json(*args)
+      end
+
+      def to_json_pretty
+        JSON.pretty_generate({
+          name: @name,
+          version: @version,
+          project_type: @project_type,
+          steps: @steps.map(&:to_h),
+        })
+      end
+
+      def self.from_json(path)
+        content = File.read(path)
+        data = JSON.parse(content, symbolize_names: true)
+
+        project = new(data[:name], data[:version], data[:project_type])
+        data[:steps].each do |step_data|
+          step = Step.new(
+            name: step_data[:name],
+            description: step_data[:description],
+            commands: step_data[:commands],
+          )
+          project.add_step(step)
+        end
+
+        project
+      end
+
+      # Class method for deserializing from JSON string (used by serializer)
+      def self.decode_json(json_string)
+        data = JSON.parse(json_string, symbolize_names: true)
+
+        project = new(data[:name], data[:version], data[:project_type])
+        data[:steps].each do |step_data|
+          step = Step.new(
+            name: step_data[:name],
+            description: step_data[:description],
+            commands: step_data[:commands],
+          )
+          project.add_step(step)
+        end
+
+        project
+      end
+
+      def to_gitlab_ci(path)
+        GitLabHelper.to_yaml(self, path)
+      end
+
+      def to_rakefile
+        RakefileHelper.generate(self)
+      end
+
+      # Save the project to a specific path as pretty JSON
+      def save_as(path)
+        File.write(path, to_json_pretty)
+      end
+
+      def save
+        save_as(".makit.json")
+      end
+
+      # Display the project configuration in YAML format
+      def show
+        require "yaml"
+
+        project_data = {
+          name: @name,
+          version: @version,
+          project_type: @project_type,
+          git_remote_url: @git_remote_url,
+          steps: @steps.map(&:to_h),
+        }
+
+        puts YAML.dump(project_data)
+      end
+
+      # Load a project from the default .makit.json file
+      def self.default
+        if File.exist?(".makit.json")
+          from_json(".makit.json")
+        else
+          new(name: "", version: "0.0.0", project_type: "")
+        end
+      end
+    end
+  end
+end

data/lib/makit/configuration/rakefile_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Makit
+  module Configuration
+    # Helper for Rakefile generation
+    class RakefileHelper
+      def self.generate(project)
+        rakefile_content = []
+
+        # Add header comment
+        rakefile_content << "# Generated Rakefile for #{project.name} v#{project.version}"
+        rakefile_content << "# Generated by Makit::Configuration::RakefileHelper"
+        rakefile_content << ""
+
+        # Add default task
+        if project.steps.any?
+          default_tasks = project.steps.map(&:name).join(",")
+          rakefile_content << "desc 'Run all project steps'"
+          rakefile_content << "task :default => [:#{default_tasks}]"
+          rakefile_content << ""
+        end
+
+        # Add individual step tasks
+        project.steps.each do |step|
+          rakefile_content << "desc '#{step.description}'"
+          rakefile_content << "task :#{step.name} do"
+          step.commands.each do |command|
+            rakefile_content << "  sh '#{command}'"
+          end
+          rakefile_content << "end"
+          rakefile_content << ""
+        end
+
+        rakefile_content.join("\n")
+      end
+
+      def self.write(project, path)
+        content = generate(project)
+        File.write(path, content)
+      end
+    end
+  end
+end

data/lib/makit/configuration/step.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Makit
+  module Configuration
+    # Individual step in a project configuration
+    class Step
+      attr_accessor :name, :description, :commands
+
+      def initialize(name:, description:, commands:)
+        @name = name
+        @description = description
+        @commands = commands.is_a?(Array) ? commands : [commands]
+
+        validate_commands
+      end
+
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          commands: @commands,
+        }
+      end
+
+      private
+
+      def validate_commands
+        unless @commands.is_a?(Array) && @commands.all? { |cmd| cmd.is_a?(String) }
+          raise ArgumentError, "Commands must be an array of strings"
+        end
+      end
+    end
+  end
+end

data/lib/makit/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Load all configuration classes
+require_relative "configuration/project"
+require_relative "configuration/step"
+require_relative "configuration/gitlab_helper"
+require_relative "configuration/rakefile_helper"
+
+# Main configuration module that loads all configuration classes
+module Makit
+  module Configuration
+    # All configuration classes are now loaded above
+  end
+end

data/lib/makit/content/default_gitignore.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Makit
   module Content
     GITIGNORE = File.read(File.join(__dir__, "default_gitignore.txt"))
-  end # module Content
-end # module Makit
+  end
+end

data/lib/makit/content/default_rakefile.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Makit
   module Content
     RAKEFILE = <<~HEREDOC
@@ -7,5 +9,5 @@ module Makit
       end
 
     HEREDOC
-  end # module Content
-end # module Makit
+  end
+end

data/lib/makit/content/gem_rakefile.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Makit
   module Content
     GEM_RAKEFILE = <<~HEREDOC
@@ -10,5 +12,5 @@ module Makit
       end
 
     HEREDOC
-  end # module Content
-end # module Makit
+  end
+end

data/lib/makit/context.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true