makit 0.0.111 → 0.0.112

data/lib/makit/commands/compatibility.rb

@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require "ostruct"
-require "fileutils"
-require_relative "runner"
-require_relative "request"
-require_relative "result"
-
-module Makit
-  module Commands
-    # Compatibility layer that provides legacy interface methods for the new Commands::Runner
-    #
-    # This class bridges the gap between the old CommandRunner interface and the new
-    # Commands::Runner architecture, allowing existing code to work without modification
-    # while benefiting from the improved architecture.
-    class Compatibility
-      # @!attribute [r] runner
-      #   @return [Runner] the underlying Commands::Runner instance
-      attr_reader :runner
-
-      # Initialize compatibility layer
-      #
-      # @param runner [Runner] the Commands::Runner instance to wrap
-      def initialize(runner = nil)
-        @runner = runner || create_runner_with_caching
-      end
-
-      # Parse command request from various input types (legacy interface)
-      #
-      # @param source [String, Hash, Request] command source
-      # @return [Request] normalized request
-      def parse_command_request(source)
-        case source
-        when String
-          Request.from_string(source)
-        when Hash
-          Request.from_hash(source)
-        when Request
-          source
-        when Makit::V1::CommandRequest
-          # Convert legacy CommandRequest to new Request
-          Request.new(
-            command: source.name,
-            arguments: source.arguments.to_a,
-            directory: source.directory,
-            timeout: source.timeout,
-            environment: {},
-            metadata: { legacy: true },
-          )
-        else
-          raise ArgumentError, "Invalid source type: #{source.class}"
-        end
-      end
-
-      # Parse arguments (legacy interface)
-      #
-      # @param args [String, Array, Hash, Request] arguments to parse
-      # @return [Request] parsed request
-      def parse_args(args)
-        parse_command_request(args)
-      end
-
-      # Execute command (legacy run interface)
-      #
-      # @param request_or_string [Request, String, Hash] command to run
-      # @return [Result] execution result converted to legacy format
-      def run(request_or_string)
-        request = parse_command_request(request_or_string)
-        result = @runner.execute(request)
-        # Store directory in result metadata for legacy compatibility
-        result.metadata[:directory] = request.directory
-        convert_to_legacy_command(result)
-      end
-
-      # Execute command with caching (legacy cache_run interface)
-      #
-      # @param request_or_string [Request, String, Hash] command to run
-      # @param timestamp [Time, nil] cache timestamp
-      # @return [Result] execution result converted to legacy format
-      def cache_run(request_or_string, timestamp = nil)
-        request = parse_command_request(request_or_string)
-
-        # Add cache metadata
-        cache_key = generate_cache_key(request)
-        request.metadata[:cache_key] = cache_key
-        request.metadata[:cache_timestamp] = timestamp || default_timestamp
-
-        # Execute with caching middleware
-        result = @runner.execute(request)
-        # Store directory in result metadata for legacy compatibility
-        result.metadata[:directory] = request.directory
-        convert_to_legacy_command(result)
-      end
-
-      # Execute command with caching without raising on error (legacy cache_try interface)
-      #
-      # @param request_or_string [Request, String, Hash] command to try
-      # @param timestamp [Time, nil] cache timestamp
-      # @return [Result] execution result converted to legacy format
-      def cache_try(request_or_string, timestamp = nil)
-        request = parse_command_request(request_or_string)
-        request.metadata[:exit_on_error] = false
-
-        # Add cache metadata
-        cache_key = generate_cache_key(request)
-        request.metadata[:cache_key] = cache_key
-        request.metadata[:cache_timestamp] = timestamp || default_timestamp
-
-        # Execute with caching middleware
-        result = @runner.execute(request)
-        # Store directory in result metadata for legacy compatibility
-        result.metadata[:directory] = request.directory
-        convert_to_legacy_command(result)
-      end
-
-      # Execute command without raising on error (legacy try interface)
-      #
-      # @param request_or_string [Request, String, Hash] command to try
-      # @return [Result] execution result converted to legacy format
-      def try(request_or_string)
-        request = parse_command_request(request_or_string)
-        request.metadata[:exit_on_error] = false
-
-        result = @runner.execute(request)
-        # Store directory in result metadata for legacy compatibility
-        result.metadata[:directory] = request.directory
-        convert_to_legacy_command(result)
-      end
-
-      # Show command information (legacy show interface)
-      #
-      # @param request_or_string [Request, String, Hash] command to show
-      # @return [Result] execution result converted to legacy format
-      def show(request_or_string)
-        request = parse_command_request(request_or_string)
-        request.metadata[:show_output] = true
-
-        result = @runner.execute(request)
-        # Store directory in result metadata for legacy compatibility
-        result.metadata[:directory] = request.directory
-        show_command(convert_to_legacy_command(result))
-        convert_to_legacy_command(result)
-      end
-
-      # Search command history for matching commands (legacy interface)
-      #
-      # @param query [String] search query
-      # @return [Array<Object>] matching command results
-      def search(query)
-        # For now, return empty array since we don't have command history in new architecture
-        # This could be enhanced with a command history middleware
-        []
-      end
-
-      # Get cache filename for a command (legacy interface)
-      #
-      # @param command [Object] command object
-      # @return [String] cache filename
-      def get_cache_filename(command)
-        require "digest"
-        if command.respond_to?(:name) && command.respond_to?(:arguments)
-          content = "#{command.name} #{command.arguments.join(" ")}"
-        else
-          content = command.to_s
-        end
-        hash = Digest::SHA256.hexdigest(content)
-        cache_dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands", "cache")
-        FileUtils.mkdir_p(cache_dir)
-        File.join(cache_dir, "#{hash}.pb")
-      end
-
-      # Log rake commands to file (legacy interface)
-      #
-      # @return [void]
-      def log_rake_commands
-        dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-        FileUtils.mkdir_p(dir)
-
-        # For now, create empty file since we don't have command history
-        # This could be enhanced with a command history middleware
-        File.open(File.join(dir, "rake.commands.txt"), "w") do |file|
-          file.puts "# No command history available in new architecture"
-          file.puts "# This functionality will be restored with command history middleware"
-        end
-      end
-
-      # Log slowest commands to file (legacy interface)
-      #
-      # @return [void]
-      def log_slowest_commands
-        dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-        FileUtils.mkdir_p(dir)
-
-        # For now, create empty file since we don't have command history
-        # This could be enhanced with a command history middleware
-        File.open(File.join(dir, "slow.commands.txt"), "w") do |file|
-          file.puts "# No command history available in new architecture"
-          file.puts "# This functionality will be restored with command history middleware"
-        end
-      end
-
-      # Display command summary (legacy show_command interface)
-      #
-      # @param command [Makit::V1::Command, Result] command result to display
-      def show_command(command)
-        # Convert new Result to legacy format if needed
-        legacy_command = command.is_a?(Result) ? convert_to_legacy_command(command) : command
-
-        if legacy_command.exit_code.zero?
-          puts get_command_summary(legacy_command) + " (#{legacy_command.duration&.seconds || 0} seconds)".colorize(:cyan)
-          puts indent_string(legacy_command.output, 2).colorize(:default) if should_show_output_on_success?
-        else
-          puts get_command_summary(legacy_command) + " (exit code #{legacy_command.exit_code})".colorize(:default)
-          puts "  directory: #{legacy_command.directory}\n"
-          puts "  duration: #{legacy_command.duration&.seconds || 0} seconds\n"
-          puts indent_string(legacy_command.output, 2) if legacy_command.output&.length&.positive?
-          puts indent_string(legacy_command.error, 2) if legacy_command.error&.length&.positive?
-        end
-      end
-
-      private
-
-      # Create a runner with caching middleware
-      #
-      # @return [Runner] runner with caching middleware
-      def create_runner_with_caching
-        require_relative "middleware/cache"
-
-        Runner.new(
-          middleware: [
-            Middleware::Cache.new,
-            Middleware::CommandLogger.new(
-              log_stdout: true,
-              log_stderr: true,
-              log_performance: true,
-              max_output_lines: 50,
-            ),
-          ],
-        )
-      end
-
-      # Convert new Result to legacy Makit::V1::Command format
-      #
-      # @param result [Result] result to convert
-      # @return [Makit::V1::Command] legacy command object
-      def convert_to_legacy_command(result)
-        # Create a legacy command object that duck-types with Makit::V1::Command
-        legacy_command = OpenStruct.new
-        legacy_command.name = result.command.split.first
-        legacy_command.arguments = result.command.split[1..] || []
-        # Get directory from metadata if available, otherwise use current directory
-        legacy_command.directory = result.metadata[:directory] || Dir.pwd
-        legacy_command.exit_code = result.exit_code
-        legacy_command.output = result.stdout
-        legacy_command.error = result.stderr
-        legacy_command.started_at = convert_time_to_protobuf_timestamp(result.started_at)
-        legacy_command.duration = convert_duration_to_protobuf(result.duration)
-
-        # Add success? method for compatibility
-        def legacy_command.success?
-          exit_code.zero?
-        end
-
-        legacy_command
-      end
-
-      # Generate cache key for a request
-      #
-      # @param request [Request] request to generate key for
-      # @return [String] cache key
-      def generate_cache_key(request)
-        require "digest"
-        content = "#{request.command} #{request.arguments.join(" ")}"
-        Digest::SHA256.hexdigest(content)
-      end
-
-      # Get default timestamp for caching
-      #
-      # @return [Time] default timestamp
-      def default_timestamp
-        if defined?(Makit::GIT_FILE_INFOS) && Makit::GIT_FILE_INFOS.any?
-          Makit::GIT_FILE_INFOS.first.mtime
-        else
-          Time.now
-        end
-      end
-
-      # Get command summary string (legacy interface)
-      #
-      # @param command [Object] command object
-      # @return [String] command summary
-      def get_command_summary(command)
-        symbol = "⚠️" # warning by default
-        symbol = "✓" if command.exit_code&.zero?
-        symbol = "✗" if command.exit_code != 0
-
-        summary = "#{symbol} #{command.name} #{command.arguments.join(" ")}"
-
-        # Apply line wrapping if available
-        if summary.respond_to?(:to_lines) && summary.length > 80
-          summary.to_lines(80, command.name.length + 3)
-        else
-          summary
-        end
-      end
-
-      # Indent string helper
-      #
-      # @param input_string [String] string to indent
-      # @param indent_spaces [Integer] number of spaces to indent
-      # @return [String] indented string
-      def indent_string(input_string, indent_spaces)
-        return "" unless input_string
-
-        indentation = " " * indent_spaces
-        input_string.lines.map { |line| indentation + line }.join
-      end
-
-      # Check if output should be shown on success
-      #
-      # @return [Boolean] true if output should be shown
-      def should_show_output_on_success?
-        # Check if the legacy runner has this setting
-        if defined?(Makit::RUNNER) && Makit::RUNNER.respond_to?(:show_output_on_success)
-          Makit::RUNNER.show_output_on_success
-        else
-          false
-        end
-      end
-
-      # Convert Time to protobuf timestamp format
-      #
-      # @param time [Time] time to convert
-      # @return [Google::Protobuf::Timestamp] protobuf timestamp
-      def convert_time_to_protobuf_timestamp(time)
-        return nil unless time
-
-        if defined?(Google::Protobuf::Timestamp)
-          Google::Protobuf::Timestamp.new(seconds: time.to_i, nanos: time.nsec)
-        else
-          # Fallback object with same interface
-          OpenStruct.new(seconds: time.to_i, nanos: time.nsec)
-        end
-      end
-
-      # Convert duration to protobuf duration format
-      #
-      # @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
-
-        if defined?(Google::Protobuf::Duration)
-          Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
-        else
-          # Fallback object with same interface
-          OpenStruct.new(seconds: seconds, nanos: nanos)
-        end
-      end
-    end
-  end
-end

data/lib/makit/task_hooks.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "rake"
-
-module Makit
-  # Task hooks for automatic timing, logging, and lifecycle management
-  # This provides optional instrumentation for Rake tasks
-  class TaskHooks
-    class << self
-      attr_reader :enabled, :task_stack, :performance_log
-
-      def initialize!
-        @enabled = false # Start disabled - must be explicitly enabled
-        @task_stack = []
-        @performance_log = "artifacts/task_performance.log"
-        @hooks_installed = false
-      end
-
-      def setup!
-        return if @hooks_installed
-
-        initialize! unless defined?(@enabled)
-
-        Rake::Task.class_eval do
-          alias_method :makit_original_execute, :execute
-
-          def execute(args = nil)
-            if Makit::TaskHooks.enabled?
-              Makit::TaskHooks.before_execute(name, args)
-              result = makit_original_execute(args)
-              Makit::TaskHooks.after_execute(name, args, result)
-              result
-            else
-              makit_original_execute(args)
-            end
-          rescue StandardError => e
-            Makit::TaskHooks.on_error(name, args, e) if Makit::TaskHooks.enabled?
-            raise
-          end
-        end
-
-        @hooks_installed = true
-      end
-
-      def enable!
-        initialize! unless defined?(@enabled)
-        @enabled = true
-        puts "🔧 Task timing enabled".colorize(:grey) if defined?(String.instance_method(:colorize))
-      end
-
-      def disable!
-        @enabled = false
-      end
-
-      def enabled?
-        @enabled == true
-      end
-
-      def before_execute(name, _args)
-        return unless enabled?
-
-        @task_stack.push({
-                           name: name,
-                           start_time: Time.now,
-                           level: @task_stack.length,
-                         })
-      end
-
-      def after_execute(name, _args, _result)
-        return unless enabled?
-
-        task_info = @task_stack.pop
-        return unless task_info && task_info[:name] == name
-
-        duration = Time.now - task_info[:start_time]
-        log_task_performance(name, duration, task_info[:level]) if duration > 0.1
-      end
-
-      def on_error(name, _args, error)
-        return unless enabled?
-
-        task_info = @task_stack.pop
-        return unless task_info
-
-        duration = Time.now - task_info[:start_time]
-        log_task_failure(name, duration, error, task_info[:level])
-      end
-
-      def clear_performance_logs
-        FileUtils.rm_f(@performance_log)
-        FileUtils.rm_f("artifacts/task_failures.log")
-      end
-
-      private
-
-      def log_task_performance(name, duration, level)
-        return if ENV["CI"] == "true" && duration < 1.0
-
-        FileUtils.mkdir_p("artifacts")
-        File.open(@performance_log, "a") do |f|
-          f.puts "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")},#{name},#{duration.round(4)},#{level}"
-        end
-      rescue StandardError
-        # Silently fail performance logging to not interrupt tasks
-      end
-
-      def log_task_failure(name, duration, error, _level)
-        failure_log = "artifacts/task_failures.log"
-        FileUtils.mkdir_p("artifacts")
-
-        File.open(failure_log, "a") do |f|
-          timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
-          message = error.message.gsub(",", ";")
-          f.puts "#{timestamp},#{name},#{duration.round(4)},#{error.class.name},#{message}"
-        end
-      rescue StandardError
-        # Silently fail error logging
-      end
-    end
-
-    # Initialize when loaded
-    initialize!
-  end
-end