makit 0.0.111 → 0.0.126

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56e3287d3978140fa097d4cc0153fce0d4436143ed6bb99e158dd3efbabf367e
-  data.tar.gz: 5dbce59aef132210271e23ed583b390a0b028d2fabf20ae80504b103313f03c9
+  metadata.gz: 6a002343e64c5e7dd72227c9a46010c8189e2413fac4a4175c50dd1da7afdc2a
+  data.tar.gz: bd27c52620a9df3198ac6be328294bb1935c9fbd6b6b33a270a45c562e52d19a
 SHA512:
-  metadata.gz: 0300f6b2bb01ba096872ae12321161f781c4e6db5daa3f598927f6aa0103d5d5acadff514a4646649ab3db2cef435c39a036baaf95d244db1ccd83feeb75bde6
-  data.tar.gz: 87503380f8fa712f4b4a019424f84d02cc77925eea34e9579c57fdd0552143115ac7f4dd9a5fa664a00f2e1a597f80a0583f8ebb43d1577c9156f65eb438d991
+  metadata.gz: 34d51c894957bfca45e42968b8eb74e2fe32f710b0687ea30c33a878ca0b125b2a641b961e38a0ef7a9a027142221e2b9bc5bdd125ff035dd7f9d49db834d33b
+  data.tar.gz: 9942166a1f8be21948d029a5b1058942a8637fb1e565d7ee28ec2d58dd5c40f9cf10cbff18cee4ec712e4ebbe54c4873065eef8b29cc4131fa3f2bbc51b57ec2

data/lib/makit/cli/repository_commands.rb

@@ -62,7 +62,7 @@ module Makit
           %r{^https?://\w+[\w.-]*\w+/[\w.-]+/[\w.-]+(?:\.git)?/?$}, # HTTPS
           %r{^git@[\w.-]+:[\w.-]+/[\w.-]+(?:\.git)?$},              # SSH
           %r{^ssh://git@[\w.-]+/[\w.-]+/[\w.-]+(?:\.git)?$},        # SSH with ssh://
-          %r{^[\w.-]+@[\w.-]+:[\w.-]+/[\w.-]+(?:\.git)?$},           # Generic SSH
+          %r{^[\w.-]+@[\w.-]+:[\w.-]+/[\w.-]+(?:\.git)?$}, # Generic SSH
         ]
 
         unless valid_patterns.any? { |pattern| url.match?(pattern) }

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

@@ -8,7 +8,7 @@ module Makit
     module Middleware
       # Caching middleware for command execution results
       #
-      # This middleware provides caching functionality similar to the legacy CommandRunner,
+      # This middleware provides caching functionality for command execution,
       # allowing commands to be cached based on their content and timestamp.
       #
       # @example Basic usage
@@ -123,7 +123,7 @@ module Makit
 
             # Convert to new Result format
             convert_cached_command_to_result(cached_command)
-          rescue => e
+          rescue StandardError => e
             Makit::Logging.debug("Failed to load cached result", {
               cache_file: cache_file,
               error: e.message,
@@ -151,7 +151,7 @@ module Makit
               command: result.command,
               success: result.success?,
             })
-          rescue => e
+          rescue StandardError => e
             Makit::Logging.warn("Failed to cache result", {
               cache_file: cache_file,
               error: e.message,

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

@@ -32,31 +32,23 @@ module Makit
 
         # Initialize command logging middleware.
         #
-        # @param logger [Makit::Logging::Logger, nil] custom logger instance
         # @param log_stdout [Boolean] whether to log stdout output
         # @param log_stderr [Boolean] whether to log stderr output
         # @param log_performance [Boolean] whether to log performance metrics
         # @param max_output_lines [Integer] maximum lines of output to log
-        # @param log_level [Symbol] log level for command events
         def initialize(
-          logger: nil,
           log_stdout: false,
           log_stderr: true,
           log_performance: true,
-          max_output_lines: 100,
-          log_level: nil
+          max_output_lines: 100
         )
           @log_stdout = log_stdout
           @log_stderr = log_stderr
           @log_performance = log_performance
           @max_output_lines = max_output_lines
-          @log_level = log_level || Makit::Logging.current_log_level
 
-          # Use the provided logger or create a new one with the specified log level
-          @logger = logger || Makit::Logging::Logger.new(
-            level: @log_level,
-            sinks: Makit::Logging.default_logger.sinks,
-          )
+          # Use the default logger for all logging
+          @logger = Makit::Logging.default_logger
         end
 
         # Execute command with enhanced logging.
@@ -83,11 +75,11 @@ module Makit
             log_command_output(request, result, command_id)
 
             result
-          rescue => error
+          rescue StandardError => e
             duration = Time.now - start_time
 
             # Log command error with full context
-            log_command_error(request, error, duration, command_id)
+            log_command_error(request, e, duration, command_id)
 
             raise
           end
@@ -97,7 +89,7 @@ module Makit
         #
         # @param request [Request] command request
         # @return [Boolean] true if middleware applies
-        def applicable?(request)
+        def applicable?(_request)
           # Apply to all requests
           true
         end
@@ -108,12 +100,11 @@ module Makit
         def config
           {
             name: "CommandLogger",
-            description: "Enhanced command execution logging with output handling",
+            description: "Command execution logging with performance tracking and output handling",
             log_stdout: @log_stdout,
             log_stderr: @log_stderr,
             log_performance: @log_performance,
             max_output_lines: @max_output_lines,
-            log_level: @log_level,
             logger_class: @logger.class.name,
           }
         end
@@ -135,7 +126,7 @@ module Makit
             timestamp: Time.now.iso8601,
           }
 
-          @logger.public_send(@log_level, "Command execution started", log_data)
+          @logger.debug("Command execution started", log_data)
         end
 
         # Log command execution completion with performance data.
@@ -162,12 +153,9 @@ module Makit
             )
           end
 
-          # Log at appropriate level based on success
-          if result.success?
-            @logger.info("Command completed successfully", log_data)
-          else
-            @logger.warn("Command completed with errors", log_data)
-          end
+          # Log detailed information at debug level
+          @logger.debug("Command completed successfully", log_data) if result.success?
+          @logger.debug("Command completed with errors", log_data) unless result.success?
 
           # Log performance warnings
           log_performance_warnings(request, result, duration, command_id) if @log_performance
@@ -196,20 +184,20 @@ module Makit
           end
 
           # Log stderr if enabled and present
-          if @log_stderr && result.stderr && !result.stderr.empty?
-            output_lines = result.stderr.split("\n")
-            truncated = output_lines.length > @max_output_lines
+          return unless @log_stderr && result.stderr && !result.stderr.empty?
 
-            log_data = {
-              command_id: command_id,
-              command: request.command,
-              output: truncated ? output_lines.first(@max_output_lines).join("\n") : result.stderr,
-              total_lines: output_lines.length,
-              truncated: truncated,
-            }
+          output_lines = result.stderr.split("\n")
+          truncated = output_lines.length > @max_output_lines
 
-            @logger.warn("Command stderr", log_data)
-          end
+          {
+            command_id: command_id,
+            command: request.command,
+            output: truncated ? output_lines.first(@max_output_lines).join("\n") : result.stderr,
+            total_lines: output_lines.length,
+            truncated: truncated,
+          }
+
+          # @logger.warn("Command stderr", log_data)
         end
 
         # Log command execution error with full context.
@@ -262,13 +250,13 @@ module Makit
           end
 
           # Log commands with high exit codes (potential errors)
-          if result.exit_code > 0
-            @logger.info("Command completed with non-zero exit code",
-                         command_id: command_id,
-                         command: request.command,
-                         exit_code: result.exit_code,
-                         success: result.success?)
-          end
+          return unless result.exit_code.positive?
+
+          @logger.debug("Command completed with non-zero exit code",
+                        command_id: command_id,
+                        command: request.command,
+                        exit_code: result.exit_code,
+                        success: result.success?)
         end
 
         # Calculate total output size (stdout + stderr).
@@ -299,7 +287,7 @@ module Makit
             begin
               # This is a simplified approach for Windows
               "Unknown"
-            rescue
+            rescue StandardError
               nil
             end
           else
@@ -308,11 +296,11 @@ module Makit
               # Try to get memory usage from /proc/self/status
               if File.exist?("/proc/self/status")
                 status = File.read("/proc/self/status")
-                if match = status.match(/VmRSS:\s+(\d+)\s+kB/)
+                if (match = status.match(/VmRSS:\s+(\d+)\s+kB/))
                   "#{match[1].to_i / 1024}MB"
                 end
               end
-            rescue
+            rescue StandardError
               nil
             end
           end

data/lib/makit/commands/request.rb

@@ -39,6 +39,7 @@ module Makit
       # @!attribute [r] metadata
       #   @return [Hash] additional metadata for logging/tracking
       attr_reader :command, :arguments, :environment, :directory, :timeout, :metadata
+      attr_writer :exit_on_failure, :show_stderr, :show_stdout
 
       # Initialize a new command request.
       #
@@ -56,7 +57,9 @@ module Makit
         @directory = options[:directory] || Dir.pwd
         @timeout = options[:timeout] || 30
         @metadata = options[:metadata] || {}
-
+        @exit_on_failure = options[:exit_on_failure] || true
+        @show_stderr = options[:show_stderr] || true
+        @show_stdout = options[:show_stdout] || false
         validate_directory(@directory)
         validate_timeout(@timeout)
       end
@@ -80,6 +83,9 @@ module Makit
           directory: directory,
           timeout: timeout,
           metadata: metadata,
+          exit_on_failure: exit_on_failure?,
+          show_stderr: show_stderr?,
+          show_stdout: show_stdout?,
         }
       end
 
@@ -91,6 +97,10 @@ module Makit
         JSON.generate(to_h, *args)
       end
 
+      def to_json_pretty(*args)
+        JSON.pretty_generate(to_h, *args)
+      end
+
       # Create a request from a shell command string.
       #
       # @param command_string [String] shell command string to parse
@@ -135,6 +145,9 @@ module Makit
           directory: hash[:directory] || hash["directory"],
           timeout: hash[:timeout] || hash["timeout"],
           metadata: hash[:metadata] || hash["metadata"] || {},
+          exit_on_failure: hash[:exit_on_failure] || hash["exit_on_failure"],
+          show_stderr: hash[:show_stderr] || hash["show_stderr"],
+          show_stdout: hash[:show_stdout] || hash["show_stdout"],
         )
       end
 
@@ -170,6 +183,55 @@ module Makit
         Digest::SHA256.hexdigest(content)[0..16]
       end
 
+      def exit_on_failure?
+        @exit_on_failure
+      end
+
+      def exit_on_failure(exit_on_failure)
+        @exit_on_failure = exit_on_failure
+        self
+      end
+
+      def show_stderr?
+        @show_stderr
+      end
+
+      def show_stderr(show_stderr)
+        @show_stderr = show_stderr
+        self
+      end
+
+      def show_stdout?
+        @show_stdout
+      end
+
+      def show_stdout(show_stdout)
+        @show_stdout = show_stdout
+        self
+      end
+
+      # Execute the command.
+      #
+      # @return [Result] execution result
+      # @raise [ArgumentError] if runner is not set
+      def run
+        # self.exit_on_failure = exit_on_failure
+        # self.show_stderr = true
+        result = Makit::Commands::Runner.default.execute(show_stderr(true))
+
+        # Display stderr if the command failed and show_stderr is enabled
+        puts result.stderr if result.failure? && show_stderr? && !result.stderr.empty?
+
+        # Exit with the command's exit code if it failed and exit_on_failure is enabled
+        exit result.exit_code if result.failure? && exit_on_failure?
+
+        result
+      end
+
+      def try
+        Makit::Commands::Runner.default.execute(exit_on_failure(false))
+      end
+
       private
 
       # Validate command parameter.

data/lib/makit/commands/runner.rb

@@ -4,7 +4,6 @@ require_relative "request"
 require_relative "result"
 require_relative "strategies/synchronous"
 require_relative "middleware/base"
-require_relative "middleware/unified_logger"
 require_relative "middleware/command_logger"
 
 module Makit
@@ -81,13 +80,27 @@ module Makit
       # @return [Result] execution result
       # @raise [ArgumentError] if request is invalid
       def execute(request)
+        Makit::Logging.debug("Makit::Commands::Runner.execute starting")
+        # Makit::Logging.debug("Executing request: #{request.to_json_pretty}")
         # Normalize request to Request object
         normalized_request = normalize_request(request)
 
         # Apply middleware chain
-        execute_with_middleware(normalized_request) do |processed_request|
-          @strategy.execute(processed_request)
+        Makit::Logging.debug("Makit::Commands::Runner.execute applying middleware chain")
+        result = execute_with_middleware(normalized_request) do |processed_request|
+          Makit::Logging.debug("Makit::Commands::Runner.execute executing strategy")
+          result = @strategy.execute(processed_request)
+          Makit::Logging.debug("Makit::Commands::Runner.execute strategy returned result")
+          result
         end
+        Makit::Logging.debug("Makit::Commands::Runner.execute returning result")
+        Makit::Logging.debug("Makit::Commands::Runner request.exit_on_failure?: #{request.exit_on_failure?}")
+        # stderr often contains warnings that we don't want to exit on
+        if request.exit_on_failure? && (result.failure?)
+          Makit::Logging.error("exiting with exit code: #{result.exit_code}")
+          exit result.exit_code
+        end
+        result
       end
 
       # Execute multiple command requests.
@@ -174,6 +187,9 @@ module Makit
         # Execute chain
         result = chain.call(request, &block)
 
+        # Log high-level success/error using the default logger
+        log_command_result(request, result)
+
         # Update statistics
         update_stats(result)
 
@@ -298,12 +314,47 @@ module Makit
         raise ArgumentError, "Strategy must respond to #supports?: #{@strategy.class}"
       end
 
+      # Log command execution result using the default logger.
+      #
+      # @param request [Request] the executed request
+      # @param result [Result] the execution result
+      # @return [void]
+      def log_command_result(request, result)
+        # Build the full command string
+        command_string = "#{request.command} #{request.arguments&.join(" ")}".strip
+
+        # Log success or error using the default logger
+        if result.success?
+          Makit::Logging.success(command_string)
+        else
+          Makit::Logging.error(command_string)
+        end
+
+        # Log the stdout, if there is an error or stdout is enabled
+        if result.failure? || request.show_stdout?
+          if (!result.stdout.empty?)
+            # split the stdout into lines and print each line
+            result.stdout.split("\n").each do |line|
+              Makit::Logging.info(line)
+            end
+          end
+        end
+
+        # Log the stderr
+        return unless request.show_stderr? && !result.stderr.empty?
+
+        # split the stderr into lines and print each line
+        result.stderr.split("\n").each do |line|
+          Makit::Logging.info(line)
+        end
+      end
+
       # Log runner initialization for debugging.
       #
       # @return [void]
       def log_runner_initialization
-        # Only log if we have a unified logger middleware
-        logger_middleware = @middleware.find { |m| m.is_a?(Middleware::UnifiedLogger) }
+        # Only log if we have a command logger middleware
+        logger_middleware = @middleware.find { |m| m.is_a?(Middleware::CommandLogger) }
         return unless logger_middleware
 
         logger_middleware.logger.debug("Command runner initialized",

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

@@ -135,8 +135,19 @@ module Makit
         # @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
+          # Skip validation for dotnet commands on Windows due to path issues
+          return true if command == "dotnet" && RUBY_PLATFORM.match?(/mswin|mingw/)
+
+          # Try Unix-style which first
+          return true if system("which #{command} > /dev/null 2>&1")
+
+          # Try Windows-style where with proper quoting
+          return true if system("where \"#{command}\" > nul 2>&1")
+
+          # Fallback: try to execute the command directly
+          system("#{command} --version > nul 2>&1") ||
+            system("#{command} --help > nul 2>&1") ||
+            system("#{command} /? > nul 2>&1")
         end
 
         # Get the full path to a command.

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

@@ -24,7 +24,7 @@ module Makit
         # @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)
+          @validate_commands = false # Always disable validation to avoid path issues
           @max_output_size = options.fetch(:max_output_size, 1024 * 1024) # 1MB default
         end
 
@@ -36,10 +36,15 @@ module Makit
           # 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}",
-                   )
+            # For dotnet commands, try to execute anyway as validation might be unreliable
+            if request.command == "dotnet"
+              Makit::Logging.debug("Skipping validation for dotnet command due to potential path issues")
+            else
+              return Result.failure(
+                       command: request.to_shell_command,
+                       error: "Command not found: #{request.command}",
+                     )
+            end
           end
 
           # Execute using Open3 for cross-platform support
@@ -118,7 +123,7 @@ module Makit
         # @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)
+          %w[echo ruby bundle rake git dotnet].include?(command)
         end
 
         # Check if execution should stop on first failure.

data/lib/makit/commands.rb

@@ -39,4 +39,12 @@ end
 
 # Load command system components (load existing components only)
 require_relative "commands/result"
+require_relative "commands/request"
+require_relative "commands/runner"
+require_relative "commands/factory"
 require_relative "commands/middleware/validator"
+require_relative "commands/middleware/cache"
+require_relative "commands/middleware/command_logger"
+require_relative "commands/middleware/base"
+require_relative "commands/strategies/base"
+require_relative "commands/strategies/synchronous"

data/lib/makit/configuration/gitlab_helper.rb

@@ -33,8 +33,6 @@ module Makit
         project
       end
 
-      private
-
       def self.generate_yaml(project)
         yaml = {
           stages: project.steps.map(&:name),

data/lib/makit/configuration/project.rb

@@ -6,7 +6,7 @@ module Makit
   module Configuration
     # Project configuration management
     class Project
-      attr_accessor :git_remote_url, :name, :version, :project_type, :steps
+      attr_accessor :git_remote_url, :name, :version, :project_type, :steps, :authors, :description, :license_expression
 
       def initialize(name, version = nil, project_type = nil)
         # Support both keyword arguments and positional arguments for compatibility
@@ -21,12 +21,15 @@ module Makit
           @version = version
           @project_type = project_type
         end
-
+        @authors = "authors"
+        @description = "description"
+        @license_expression = "MIT"
         @steps = []
       end
 
       def add_step(step)
         raise ArgumentError, "Step must be a Makit::Configuration::Step instance" unless step.is_a?(Step)
+
         @steps << step
       end
 
@@ -35,17 +38,23 @@ module Makit
           name: @name,
           version: @version,
           project_type: @project_type,
+          authors: @authors,
+          description: @description,
+          license_expression: @license_expression,
           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),
-        })
+                               name: @name,
+                               version: @version,
+                               project_type: @project_type,
+                               authors: @authors,
+                               description: @description,
+                               license_expression: @license_expression,
+                               steps: @steps.map(&:to_h),
+                             })
       end
 
       def self.from_json(path)
@@ -53,6 +62,12 @@ module Makit
         data = JSON.parse(content, symbolize_names: true)
 
         project = new(data[:name], data[:version], data[:project_type])
+
+        # Set additional fields if they exist in the JSON
+        project.authors = data[:authors] if data[:authors]
+        project.description = data[:description] if data[:description]
+        project.license_expression = data[:license_expression] if data[:license_expression]
+
         data[:steps].each do |step_data|
           step = Step.new(
             name: step_data[:name],
@@ -70,6 +85,12 @@ module Makit
         data = JSON.parse(json_string, symbolize_names: true)
 
         project = new(data[:name], data[:version], data[:project_type])
+
+        # Set additional fields if they exist in the JSON
+        project.authors = data[:authors] if data[:authors]
+        project.description = data[:description] if data[:description]
+        project.license_expression = data[:license_expression] if data[:license_expression]
+
         data[:steps].each do |step_data|
           step = Step.new(
             name: step_data[:name],
@@ -92,10 +113,20 @@ module Makit
 
       # Save the project to a specific path as pretty JSON
       def save_as(path)
+        # Validate that the project has a non-empty name before saving
+        if @name.nil? || @name.strip.empty?
+          raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
+        end
+
         File.write(path, to_json_pretty)
       end
 
       def save
+        # Validate that the project has a non-empty name before saving
+        if @name.nil? || @name.strip.empty?
+          raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
+        end
+
         save_as(".makit.json")
       end
 
@@ -119,7 +150,16 @@ module Makit
         if File.exist?(".makit.json")
           from_json(".makit.json")
         else
-          new(name: "", version: "0.0.0", project_type: "")
+          # Makit::Logging.default_logger.warn("Project not configured")
+          #          #if defined?(NAME) && defined?(VERSION) && defined?(PROJECT_TYPE)
+          #  project = new(name: NAME, version: VERSION, project_type: PROJECT_TYPE)
+          #  project.save
+          # else
+          project = new(name: "", version: "0.0.0", project_type: "")
+          Makit::Logging.default_logger.warn("Project not configured")
+          # Makit::Logging.default_logger.warn("Define NAME, VERSION, and PROJECT_TYPE in the Rakefile")
+          # end
+          project
         end
       end
     end

data/lib/makit/configuration/step.rb

@@ -25,9 +25,9 @@ module Makit
       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
+        return if @commands.is_a?(Array) && @commands.all? { |cmd| cmd.is_a?(String) }
+
+        raise ArgumentError, "Commands must be an array of strings"
       end
     end
   end