makit 0.0.99 → 0.0.112

data/lib/makit/commands/factory.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module Makit
+  module Commands
+    # Factory for creating common command requests.
+    #
+    # This factory provides convenient methods for creating Request objects
+    # for common operations like git commands, bundle operations, rake tasks,
+    # and system utilities.
+    #
+    # @example Creating git commands
+    #   request = Factory.git_clone("https://github.com/user/repo.git", "/path/to/clone")
+    #   request = Factory.git_status("/path/to/repo")
+    #
+    # @example Creating Ruby commands
+    #   request = Factory.bundle_install("/path/to/project")
+    #   request = Factory.rake_task("test", "/path/to/project")
+    class Factory
+      # Create a git clone request.
+      #
+      # @param repository_url [String] git repository URL
+      # @param target_directory [String, nil] target directory (optional)
+      # @param options [Hash] additional options
+      # @option options [Integer] :timeout (300) timeout in seconds
+      # @option options [Hash] :metadata additional metadata
+      # @return [Request] git clone request
+      def self.git_clone(repository_url, target_directory = nil, **options)
+        arguments = ["clone", repository_url]
+        arguments << target_directory if target_directory
+
+        Request.new(
+          command: "git",
+          arguments: arguments,
+          timeout: options.fetch(:timeout, 300),
+          metadata: {
+            operation: "git_clone",
+            repository: repository_url,
+            target: target_directory,
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a git pull request.
+      #
+      # @param directory [String] repository directory
+      # @param options [Hash] additional options
+      # @option options [String] :remote ("origin") remote name
+      # @option options [String] :branch (nil) specific branch
+      # @option options [Integer] :timeout (120) timeout in seconds
+      # @return [Request] git pull request
+      def self.git_pull(directory = Dir.pwd, **options)
+        arguments = ["pull"]
+        arguments << options[:remote] if options[:remote]
+        arguments << options[:branch] if options[:branch]
+
+        Request.new(
+          command: "git",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 120),
+          metadata: {
+            operation: "git_pull",
+            remote: options[:remote] || "origin",
+            branch: options[:branch],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a git status request.
+      #
+      # @param directory [String] repository directory
+      # @param options [Hash] additional options
+      # @option options [Boolean] :porcelain (false) use porcelain format
+      # @option options [Boolean] :short (false) use short format
+      # @return [Request] git status request
+      def self.git_status(directory = Dir.pwd, **options)
+        arguments = ["status"]
+        arguments << "--porcelain" if options[:porcelain]
+        arguments << "--short" if options[:short]
+
+        Request.new(
+          command: "git",
+          arguments: arguments,
+          directory: directory,
+          metadata: {
+            operation: "git_status",
+            porcelain: options[:porcelain],
+            short: options[:short],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a git log request.
+      #
+      # @param directory [String] repository directory
+      # @param options [Hash] additional options
+      # @option options [Integer] :limit (nil) limit number of commits
+      # @option options [String] :format (nil) log format
+      # @option options [String] :since (nil) since date/commit
+      # @return [Request] git log request
+      def self.git_log(directory = Dir.pwd, **options)
+        arguments = ["log"]
+        arguments.push("-n", options[:limit].to_s) if options[:limit]
+        arguments.push("--format", options[:format]) if options[:format]
+        arguments.push("--since", options[:since]) if options[:since]
+
+        Request.new(
+          command: "git",
+          arguments: arguments,
+          directory: directory,
+          metadata: {
+            operation: "git_log",
+            limit: options[:limit],
+            format: options[:format],
+            since: options[:since],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a bundle install request.
+      #
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Integer] :jobs (nil) number of parallel jobs
+      # @option options [String] :path (nil) install path
+      # @option options [Boolean] :deployment (false) deployment mode
+      # @option options [Integer] :timeout (300) timeout in seconds
+      # @return [Request] bundle install request
+      def self.bundle_install(directory = Dir.pwd, **options)
+        arguments = ["install"]
+        arguments.push("--jobs", options[:jobs].to_s) if options[:jobs]
+        arguments.push("--path", options[:path]) if options[:path]
+        arguments << "--deployment" if options[:deployment]
+
+        Request.new(
+          command: "bundle",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 300),
+          metadata: {
+            operation: "bundle_install",
+            jobs: options[:jobs],
+            path: options[:path],
+            deployment: options[:deployment],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a bundle exec request.
+      #
+      # @param command_string [String] command to execute with bundle exec
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Integer] :timeout (120) timeout in seconds
+      # @return [Request] bundle exec request
+      def self.bundle_exec(command_string, directory = Dir.pwd, **options)
+        # Parse the command string to get command and arguments
+        parts = command_string.strip.split(/\s+/)
+        arguments = ["exec"] + parts
+
+        Request.new(
+          command: "bundle",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 120),
+          metadata: {
+            operation: "bundle_exec",
+            exec_command: command_string,
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a rake task request.
+      #
+      # @param task_name [String] rake task name
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Array<String>] :arguments additional task arguments
+      # @option options [Hash] :environment environment variables
+      # @option options [Integer] :timeout (300) timeout in seconds
+      # @return [Request] rake task request
+      def self.rake_task(task_name, directory = Dir.pwd, **options)
+        arguments = [task_name]
+        arguments.concat(options[:arguments]) if options[:arguments]
+
+        Request.new(
+          command: "rake",
+          arguments: arguments,
+          directory: directory,
+          environment: options[:environment] || {},
+          timeout: options.fetch(:timeout, 300),
+          metadata: {
+            operation: "rake_task",
+            task: task_name,
+            arguments: options[:arguments],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a gem build request.
+      #
+      # @param gemspec_file [String, nil] gemspec file (optional, will auto-detect)
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Integer] :timeout (120) timeout in seconds
+      # @return [Request] gem build request
+      def self.gem_build(gemspec_file = nil, directory = Dir.pwd, **options)
+        arguments = ["build"]
+        arguments << gemspec_file if gemspec_file
+
+        Request.new(
+          command: "gem",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 120),
+          metadata: {
+            operation: "gem_build",
+            gemspec: gemspec_file,
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a gem install request.
+      #
+      # @param gem_name [String] gem name or gem file
+      # @param options [Hash] additional options
+      # @option options [String] :version specific version
+      # @option options [Boolean] :local (false) install from local file
+      # @option options [String] :source gem source
+      # @option options [Integer] :timeout (180) timeout in seconds
+      # @return [Request] gem install request
+      def self.gem_install(gem_name, **options)
+        arguments = ["install", gem_name]
+        arguments.push("--version", options[:version]) if options[:version]
+        arguments << "--local" if options[:local]
+        arguments.push("--source", options[:source]) if options[:source]
+
+        Request.new(
+          command: "gem",
+          arguments: arguments,
+          timeout: options.fetch(:timeout, 180),
+          metadata: {
+            operation: "gem_install",
+            gem: gem_name,
+            version: options[:version],
+            local: options[:local],
+            source: options[:source],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a Ruby script execution request.
+      #
+      # @param script_file [String] Ruby script file to execute
+      # @param directory [String] working directory
+      # @param options [Hash] additional options
+      # @option options [Array<String>] :arguments script arguments
+      # @option options [Hash] :environment environment variables
+      # @option options [Integer] :timeout (120) timeout in seconds
+      # @return [Request] Ruby script execution request
+      def self.ruby_script(script_file, directory = Dir.pwd, **options)
+        arguments = [script_file]
+        arguments.concat(options[:arguments]) if options[:arguments]
+
+        Request.new(
+          command: "ruby",
+          arguments: arguments,
+          directory: directory,
+          environment: options[:environment] || {},
+          timeout: options.fetch(:timeout, 120),
+          metadata: {
+            operation: "ruby_script",
+            script: script_file,
+            arguments: options[:arguments],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a system command request with validation.
+      #
+      # @param command [String] system command
+      # @param arguments [Array<String>] command arguments
+      # @param options [Hash] additional options
+      # @option options [String] :directory working directory
+      # @option options [Hash] :environment environment variables
+      # @option options [Integer] :timeout (60) timeout in seconds
+      # @return [Request] system command request
+      def self.system_command(command, arguments = [], **options)
+        Request.new(
+          command: command,
+          arguments: Array(arguments),
+          directory: options[:directory] || Dir.pwd,
+          environment: options[:environment] || {},
+          timeout: options.fetch(:timeout, 60),
+          metadata: {
+            operation: "system_command",
+            system_command: command,
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a dotnet CLI request.
+      #
+      # @param subcommand [String] dotnet subcommand (build, test, run, etc.)
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Array<String>] :arguments additional arguments
+      # @option options [String] :configuration (nil) build configuration
+      # @option options [String] :framework (nil) target framework
+      # @option options [Integer] :timeout (300) timeout in seconds
+      # @return [Request] dotnet CLI request
+      def self.dotnet_command(subcommand, directory = Dir.pwd, **options)
+        arguments = [subcommand]
+        arguments.concat(options[:arguments]) if options[:arguments]
+        arguments.push("--configuration", options[:configuration]) if options[:configuration]
+        arguments.push("--framework", options[:framework]) if options[:framework]
+
+        Request.new(
+          command: "dotnet",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 300),
+          metadata: {
+            operation: "dotnet_#{subcommand}",
+            subcommand: subcommand,
+            configuration: options[:configuration],
+            framework: options[:framework],
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+
+      # Create a Node.js/npm command request.
+      #
+      # @param subcommand [String] npm subcommand (install, test, run, etc.)
+      # @param directory [String] project directory
+      # @param options [Hash] additional options
+      # @option options [Array<String>] :arguments additional arguments
+      # @option options [Integer] :timeout (300) timeout in seconds
+      # @return [Request] npm command request
+      def self.npm_command(subcommand, directory = Dir.pwd, **options)
+        arguments = [subcommand]
+        arguments.concat(options[:arguments]) if options[:arguments]
+
+        Request.new(
+          command: "npm",
+          arguments: arguments,
+          directory: directory,
+          timeout: options.fetch(:timeout, 300),
+          metadata: {
+            operation: "npm_#{subcommand}",
+            subcommand: subcommand,
+          }.merge(options.fetch(:metadata, {})),
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Makit
+  module Commands
+    module Middleware
+      # Base class for all command execution middleware.
+      #
+      # Middleware provides a way to add cross-cutting concerns like logging,
+      # caching, validation, and timing to command execution without modifying
+      # the core execution logic.
+      #
+      # @example Creating custom middleware
+      #   class CustomMiddleware < Base
+      #     def call(request, &block)
+      #       # Pre-execution logic
+      #       puts "About to execute: #{request.command}"
+      #
+      #       # Execute the command
+      #       result = block.call(request)
+      #
+      #       # Post-execution logic
+      #       puts "Execution completed: #{result.success? ? 'SUCCESS' : 'FAILED'}"
+      #
+      #       result
+      #     end
+      #   end
+      class Base
+        # Execute middleware logic.
+        #
+        # This method must be implemented by subclasses to provide the actual
+        # middleware functionality. The pattern is to perform any pre-execution
+        # logic, call the block to continue the middleware chain, then perform
+        # any post-execution logic.
+        #
+        # @param request [Request] the command request to process
+        # @yield [Request] yields the processed request to the next middleware
+        # @yieldreturn [Result] the execution result
+        # @return [Result] the final execution result
+        # @raise [NotImplementedError] if not overridden by subclass
+        def call(request, &block)
+          raise NotImplementedError, "#{self.class.name} must implement #call"
+        end
+
+        # Check if this middleware should be applied to the given request.
+        #
+        # Override this method to provide conditional middleware application
+        # based on request properties.
+        #
+        # @param request [Request] the command request
+        # @return [Boolean] true if middleware should be applied
+        def applicable?(_request)
+          true
+        end
+
+        # Get middleware name for logging and debugging.
+        #
+        # @return [String] middleware name
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Get middleware configuration.
+        #
+        # Override this method to provide middleware-specific configuration.
+        #
+        # @return [Hash] middleware configuration
+        def config
+          {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+
+module Makit
+  module Commands
+    module Middleware
+      # Caching middleware for command execution results
+      #
+      # This middleware provides caching functionality for command execution,
+      # allowing commands to be cached based on their content and timestamp.
+      #
+      # @example Basic usage
+      #   runner = Commands::Runner.new(middleware: [Cache.new])
+      #   result = runner.execute("git --version")
+      #
+      # @example With custom cache directory
+      #   cache = Cache.new(cache_dir: "custom/cache")
+      #   runner = Commands::Runner.new(middleware: [cache])
+      class Cache < Base
+        # @!attribute [r] cache_dir
+        #   @return [String] cache directory path
+        attr_reader :cache_dir
+
+        # @!attribute [r] enabled
+        #   @return [Boolean] whether caching is enabled
+        attr_reader :enabled
+
+        # Initialize caching middleware
+        #
+        # @param cache_dir [String] directory to store cache files
+        # @param enabled [Boolean] whether caching is enabled
+        # @param options [Hash] additional options
+        def initialize(cache_dir: nil, enabled: true, **options)
+          @cache_dir = cache_dir || default_cache_dir
+          @enabled = enabled
+          @options = options
+
+          # Ensure cache directory exists
+          FileUtils.mkdir_p(@cache_dir) if @enabled
+        end
+
+        # Check if this middleware applies to the given request
+        #
+        # @param request [Request] command request
+        # @return [Boolean] true if caching should be applied
+        def applicable?(request)
+          @enabled && request.metadata[:cache_key].present?
+        end
+
+        # Execute the middleware chain with caching
+        #
+        # @param request [Request] command request
+        # @yield [Request] yields to next middleware or execution
+        # @return [Result] execution result
+        def call(request, &block)
+          return block.call(request) unless applicable?(request)
+
+          cache_key = request.metadata[:cache_key]
+          cache_timestamp = request.metadata[:cache_timestamp]
+          cache_file = get_cache_file(cache_key)
+
+          # Check if we have a valid cached result
+          if cache_file && File.exist?(cache_file) && cache_timestamp
+            cached_result = load_cached_result(cache_file, cache_timestamp)
+            return cached_result if cached_result
+          end
+
+          # Execute the command
+          result = block.call(request)
+
+          # Cache the result if successful
+          cache_result(cache_file, result) if result.success?
+
+          result
+        end
+
+        # Get middleware configuration
+        #
+        # @return [Hash] configuration hash
+        def config
+          {
+            cache_dir: @cache_dir,
+            enabled: @enabled,
+            options: @options,
+          }
+        end
+
+        private
+
+        # Get the default cache directory
+        #
+        # @return [String] default cache directory path
+        def default_cache_dir
+          File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands", "cache")
+        end
+
+        # Get cache file path for a given key
+        #
+        # @param cache_key [String] cache key
+        # @return [String] cache file path
+        def get_cache_file(cache_key)
+          return nil unless cache_key
+
+          File.join(@cache_dir, "#{cache_key}.pb")
+        end
+
+        # Load cached result if it's newer than the timestamp
+        #
+        # @param cache_file [String] path to cache file
+        # @param timestamp [Time] minimum timestamp for cache validity
+        # @return [Result, nil] cached result or nil if not valid
+        def load_cached_result(cache_file, timestamp)
+          return nil unless File.exist?(cache_file)
+
+          cache_mtime = File.mtime(cache_file)
+          return nil if cache_mtime <= timestamp
+
+          begin
+            # Load the cached command result
+            cached_command = Makit::Serializer.open(cache_file, Makit::V1::Command)
+
+            # Convert to new Result format
+            convert_cached_command_to_result(cached_command)
+          rescue => e
+            Makit::Logging.debug("Failed to load cached result", {
+              cache_file: cache_file,
+              error: e.message,
+            })
+            nil
+          end
+        end
+
+        # Cache a successful result
+        #
+        # @param cache_file [String] path to cache file
+        # @param result [Result] result to cache
+        def cache_result(cache_file, result)
+          return unless cache_file && result.success?
+
+          begin
+            # Convert Result to legacy Command format for caching
+            legacy_command = convert_result_to_legacy_command(result)
+
+            # Save to cache
+            Makit::Serializer.save_as(cache_file, legacy_command)
+
+            Makit::Logging.debug("Cached command result", {
+              cache_file: cache_file,
+              command: result.command,
+              success: result.success?,
+            })
+          rescue => e
+            Makit::Logging.warn("Failed to cache result", {
+              cache_file: cache_file,
+              error: e.message,
+            })
+          end
+        end
+
+        # Convert cached Command to Result format
+        #
+        # @param cached_command [Makit::V1::Command] cached command
+        # @return [Result] converted result
+        def convert_cached_command_to_result(cached_command)
+          # Create a Result object from the cached command
+          Result.new(
+            command: "#{cached_command.name} #{cached_command.arguments.join(" ")}",
+            exit_code: cached_command.exit_code,
+            stdout: cached_command.output,
+            stderr: cached_command.error,
+            started_at: convert_protobuf_timestamp_to_time(cached_command.started_at),
+            duration: convert_protobuf_duration_to_float(cached_command.duration),
+            metadata: {
+              cached: true,
+              directory: cached_command.directory,
+            },
+          )
+        end
+
+        # Convert Result to legacy Command format for caching
+        #
+        # @param result [Result] result to convert
+        # @return [Makit::V1::Command] legacy command object
+        def convert_result_to_legacy_command(result)
+          command_parts = result.command.split
+          name = command_parts.first
+          arguments = command_parts[1..] || []
+
+          Makit::V1::Command.new(
+            name: name,
+            arguments: arguments,
+            exit_code: result.exit_code,
+            output: result.stdout,
+            error: result.stderr,
+            started_at: convert_time_to_protobuf_timestamp(result.started_at),
+            duration: convert_duration_to_protobuf(result.duration),
+            directory: result.metadata[:directory] || Dir.pwd,
+          )
+        end
+
+        # Convert protobuf timestamp to Time
+        #
+        # @param timestamp [Google::Protobuf::Timestamp] protobuf timestamp
+        # @return [Time, nil] converted time
+        def convert_protobuf_timestamp_to_time(timestamp)
+          return nil unless timestamp
+
+          Time.at(timestamp.seconds, timestamp.nanos, :nsec)
+        end
+
+        # Convert protobuf duration to float seconds
+        #
+        # @param duration [Google::Protobuf::Duration] protobuf duration
+        # @return [Float, nil] duration in seconds
+        def convert_protobuf_duration_to_float(duration)
+          return nil unless duration
+
+          duration.seconds + (duration.nanos / 1_000_000_000.0)
+        end
+
+        # Convert Time to protobuf timestamp
+        #
+        # @param time [Time] time to convert
+        # @return [Google::Protobuf::Timestamp] protobuf timestamp
+        def convert_time_to_protobuf_timestamp(time)
+          return nil unless time
+
+          Google::Protobuf::Timestamp.new(seconds: time.to_i, nanos: time.nsec)
+        end
+
+        # Convert duration to protobuf duration
+        #
+        # @param duration [Float] duration in seconds
+        # @return [Google::Protobuf::Duration] protobuf duration
+        def convert_duration_to_protobuf(duration)
+          return nil unless duration
+
+          seconds = duration.to_i
+          nanos = ((duration - seconds) * 1_000_000_000).to_i
+
+          Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
+        end
+      end
+    end
+  end
+end