makit 0.0.111 → 0.0.112

data/lib/makit/mp/string_mp.rb

@@ -1,348 +1,193 @@
-# frozen_string_literal: true
-
-require "json"
-# monkey patch String class with a run method
-
-class String
-  def run(args = nil)
-    command = self
-    if args.nil?
-      Makit::COMMANDS_COMPAT.run(Makit::COMMANDS_COMPAT.parse_command_request(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 = {
-          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.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 = {
-          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.try(request)
-    end
-  end
-
-  def show(args = nil)
-    command = self
-    if args.nil?
-      Makit::COMMANDS_COMPAT.show(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 = {
-          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)
-    end
-  end
-
-  def log(filename)
-    # Ensure directory exists if filename contains path
-    if filename.include?("/")
-      directory = File.dirname(filename)
-      FileUtils.mkdir_p(directory)
-    end
-    command = self
-
-    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))
-
-    # Write the cmd output and error to the file
-    File.write(filename, cmd.output + cmd.error)
-
-    # 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,
-      })
-    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,
-      })
-    end
-
-    Makit::COMMANDS_COMPAT.show_command(cmd)
-  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
-    command = self
-
-    #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
-    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
-      # })
-    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,
-      })
-    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)
-    command = self
-
-    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,
-      })
-    else
-      Makit::Logging.warn("Cached command failed", {
-        command: command,
-        exit_code: result.exit_code,
-        cached: true,
-      })
-    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
-  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))
-  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 to_lines(max_length = 80, indent_length = 5)
-    return self if length <= max_length
-
-    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")
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+# monkey patch String class with command execution methods
+
+class String
+  def run(args = nil)
+    command = self
+    if args.nil?
+      request = Makit::Commands::Request.from_string(command)
+      Makit::Commands::Runner.default.execute(request)
+    else
+      # Parse initial request
+      base_request = Makit::Commands::Request.from_string(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)).flatten
+          when "directory"
+            request_options[:directory] = value
+          when "timeout"
+            request_options[:timeout] = value
+          when "environment"
+            request_options[:environment] = (request_options[:environment] || {}).merge(value)
+          when "metadata"
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(value)
+          else
+            # Add unknown keys to metadata
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(key.to_s => value)
+          end
+        end
+
+        # Create new request with combined options
+        request = Makit::Commands::Request.new(**request_options)
+        Makit::Commands::Runner.default.execute(request)
+      else
+        # args is an array of additional arguments
+        request = Makit::Commands::Request.new(
+          command: base_request.command,
+          arguments: (base_request.arguments || []) + Array(args),
+          directory: base_request.directory,
+          timeout: base_request.timeout,
+          environment: base_request.environment || {},
+          metadata: base_request.metadata || {},
+        )
+        Makit::Commands::Runner.default.execute(request)
+      end
+    end
+  end
+
+  def cache_run(timestamp = nil)
+    puts "cache_run: #{self}"
+    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),
+      )
+      puts "timestamp: #{timestamp}"
+    else
+      puts "no timestamp"
+    end
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def try
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def show
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def log
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    # Log the command execution result
+    if result.success?
+      Makit::Logging.info("Command completed successfully: #{command}")
+    else
+      Makit::Logging.error("Command failed: #{command} (exit code: #{result.exit_code})")
+    end
+
+    result
+  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
+
+  def show_command(cmd)
+    if cmd.success?
+      puts "✅ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:green)
+    else
+      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
+  end
+
+  def to_markdown
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    if result.success?
+      "```\n#{result.stdout}\n```"
+    else
+      "```\nError: #{result.stderr}\n```"
+    end
+  end
+
+  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
+
+  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
+
+  def cache_log(log_file)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    # 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?
+
+    result
+  end
+end