makit 0.0.143 → 0.0.145

data/lib/makit/humanize.rb

@@ -133,5 +133,86 @@ module Makit
       parts << "0 seconds" if parts.empty?
       parts.join(", ")
     end
+
+    def self.get_pipeline_execution_summary(execution_result)
+      summary = "Pipeline Execution Summary\n"
+      summary += "  Execution ID: #{execution_result.execution_id}\n"
+      summary += "  Status: #{execution_result.status}\n"
+      summary += "  Started: #{execution_result.started_at}\n"
+      summary += "  Finished: #{execution_result.finished_at}\n" if execution_result.finished_at
+      
+      if execution_result.respond_to?(:total_duration_seconds) && execution_result.total_duration_seconds
+        summary += "  Duration: #{get_humanized_duration(execution_result.total_duration_seconds)}\n"
+      end
+      
+      if execution_result.respond_to?(:podman_version) && execution_result.podman_version
+        summary += "  Podman Version: #{execution_result.podman_version}\n"
+      end
+      
+      if execution_result.respond_to?(:execution_host) && execution_result.execution_host
+        summary += "  Host: #{execution_result.execution_host}\n"
+      end
+      
+      summary += "  Jobs: (#{execution_result.job_results.length})\n"
+      execution_result.job_results.each do |job_result|
+        summary += "\n"
+        summary += indent_string(get_job_execution_details(job_result), 4)
+        summary += "\n"
+      end
+      
+      if execution_result.errors && execution_result.errors.any?
+        summary += "\n  Errors:\n"
+        execution_result.errors.each do |error|
+          summary += "    - #{error}\n"
+        end
+      end
+      
+      if execution_result.warnings && execution_result.warnings.any?
+        summary += "\n  Warnings:\n"
+        execution_result.warnings.each do |warning|
+          summary += "    - #{warning}\n"
+        end
+      end
+      
+      summary
+    end
+
+    def self.get_job_execution_details(job_result)
+      details = "Job: #{job_result.job_name}\n"
+      details += "  Status: #{job_result.status}\n"
+      details += "  Started: #{job_result.started_at}\n"
+      details += "  Finished: #{job_result.finished_at}\n" if job_result.finished_at
+      details += "  Exit Code: #{job_result.exit_code}\n" if job_result.exit_code
+      
+      if job_result.errors && job_result.errors.any?
+        details += "  Errors:\n"
+        job_result.errors.each do |error|
+          details += "    - #{error}\n"
+        end
+      end
+      
+      if job_result.logs && job_result.logs.any?
+        details += "  Logs:\n"
+        job_result.logs.each do |log|
+          details += "    #{log}\n"
+        end
+      end
+      
+      if job_result.respond_to?(:stdout) && job_result.stdout && !job_result.stdout.empty?
+        details += "  Stdout:\n"
+        job_result.stdout.split("\n").each do |line|
+          details += "    #{line}\n"
+        end
+      end
+      
+      if job_result.respond_to?(:stderr) && job_result.stderr && !job_result.stderr.empty?
+        details += "  Stderr:\n"
+        job_result.stderr.split("\n").each do |line|
+          details += "    #{line}\n"
+        end
+      end
+      
+      details
+    end
   end
 end

data/lib/makit/io/filesystem.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "filesystem_service_impl"
+
+module Makit
+  module IO
+    class FileSystem
+      def initialize
+        @service = FileSystemServiceImpl.new
+      end
+
+      # Get a single file's content and/or metadata
+      def get_file(path, include_metadata: true, include_content: true)
+        request = {
+          path: path,
+          include_metadata: include_metadata,
+          include_content: include_content
+        }
+        
+        result = @service.get_file(request)
+        
+        if result.respond_to?(:file)
+          # gRPC mode
+          result.file
+        else
+          # Fallback mode
+          result[:file]
+        end
+      end
+
+      # Create or update a file
+      def save_file(path, binary_data: nil, text_lines: nil)
+        request = {
+          path: path,
+          binary_data: binary_data,
+          text_lines: text_lines
+        }
+        
+        result = @service.save_file(request)
+        
+        if result.respond_to?(:file)
+          # gRPC mode
+          result.file
+        else
+          # Fallback mode
+          result[:file]
+        end
+      end
+
+      # Delete a file by path
+      def delete_file(path)
+        request = { path: path }
+        @service.delete_file(request)
+      end
+
+      # List files in a directory according to query flags
+      def list_files(directory, recursive: false, pattern: nil, respect_gitignore: false, include_metadata: true, include_content: false)
+        request = {
+          directory: directory,
+          recursive: recursive,
+          pattern: pattern,
+          respect_gitignore: respect_gitignore,
+          include_metadata: include_metadata,
+          include_content: include_content
+        }
+        
+        result = @service.list_files(request)
+        
+        if result.respond_to?(:files)
+          # gRPC mode
+          result.files
+        else
+          # Fallback mode
+          result[:files]
+        end
+      end
+
+      # Create a directory
+      def create_directory(path)
+        request = { path: path }
+        @service.create_directory(request)
+      end
+
+      # Delete a directory
+      def delete_directory(path)
+        request = { path: path }
+        @service.delete_directory(request)
+      end
+
+      # Upload large files in chunks
+      def upload(chunks)
+        request = { chunks: chunks }
+        result = @service.upload(request)
+        
+        if result.respond_to?(:file)
+          # gRPC mode
+          result.file
+        else
+          # Fallback mode
+          result[:file]
+        end
+      end
+
+      # Download a file in chunks
+      def download(path)
+        request = { path: path }
+        @service.download(request)
+      end
+    end
+  end
+end

data/lib/makit/io/filesystem_service_impl.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "mime/types"
+require "digest"
+require "time"
+
+module Makit
+  module IO
+    class FileSystemServiceImpl
+      def initialize
+        # Initialize any required state
+      end
+
+      # Check if gRPC service is available
+      def self.grpc_available?
+        defined?(Makit::Io::FileSystemService)
+      end
+
+      # Get a single file's content and/or metadata
+      def get_file(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        include_metadata = request.respond_to?(:include_metadata) ? request.include_metadata : request[:include_metadata]
+        include_content = request.respond_to?(:include_content) ? request.include_content : request[:include_content]
+        
+        # Default to metadata only if not specified
+        include_metadata = true if include_metadata.nil?
+        include_content = false if include_content.nil?
+        
+        unless File.exist?(path)
+          raise Errno::ENOENT, "No such file or directory: #{path}"
+        end
+        
+        file_data = {
+          path: path
+        }
+        
+        if include_content
+          if binary_file?(path)
+            file_data[:binary_data] = File.binread(path)
+          else
+            file_data[:text_lines] = File.readlines(path).map(&:chomp)
+          end
+        end
+        
+        if include_metadata
+          file_data[:metadata] = get_file_metadata(path)
+        end
+        
+        if self.class.grpc_available?
+          Makit::Io::FileResponse.new(file: Makit::Io::File.new(file_data))
+        else
+          { file: file_data }
+        end
+      end
+
+      # Create or update a file
+      def save_file(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        binary_data = request.respond_to?(:binary_data) ? request.binary_data : request[:binary_data]
+        text_lines = request.respond_to?(:text_lines) ? request.text_lines : request[:text_lines]
+        
+        # Ensure directory exists
+        FileUtils.mkdir_p(File.dirname(path))
+        
+        if binary_data && !binary_data.empty?
+          File.binwrite(path, binary_data)
+        elsif text_lines && !text_lines.empty?
+          File.write(path, text_lines.join("\n") + "\n")
+        else
+          raise ArgumentError, "Either binary_data or text_lines must be provided"
+        end
+        
+        file_data = {
+          path: path,
+          metadata: get_file_metadata(path)
+        }
+        
+        if binary_data && !binary_data.empty?
+          file_data[:binary_data] = binary_data
+        elsif text_lines && !text_lines.empty?
+          file_data[:text_lines] = text_lines
+        end
+        
+        if self.class.grpc_available?
+          Makit::Io::FileResponse.new(file: Makit::Io::File.new(file_data))
+        else
+          { file: file_data }
+        end
+      end
+
+      # Delete a file by path
+      def delete_file(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        
+        unless File.exist?(path)
+          raise Errno::ENOENT, "No such file or directory: #{path}"
+        end
+        
+        File.delete(path)
+        
+        if self.class.grpc_available?
+          Google::Protobuf::Empty.new
+        else
+          {}
+        end
+      end
+
+      # List files in a directory according to query flags
+      def list_files(request, _unused_call = nil)
+        directory = request.respond_to?(:directory) ? request.directory : request[:directory]
+        recursive = request.respond_to?(:recursive) ? request.recursive : request[:recursive]
+        pattern = request.respond_to?(:pattern) ? request.pattern : request[:pattern]
+        respect_gitignore = request.respond_to?(:respect_gitignore) ? request.respect_gitignore : request[:respect_gitignore]
+        include_metadata = request.respond_to?(:include_metadata) ? request.include_metadata : request[:include_metadata]
+        include_content = request.respond_to?(:include_content) ? request.include_content : request[:include_content]
+        
+        # Default values
+        recursive = false if recursive.nil?
+        respect_gitignore = false if respect_gitignore.nil?
+        include_metadata = true if include_metadata.nil?
+        include_content = false if include_content.nil?
+        
+        unless Dir.exist?(directory)
+          raise Errno::ENOENT, "No such file or directory: #{directory}"
+        end
+        
+        files = []
+        
+        # Get gitignore patterns if requested
+        gitignore_patterns = []
+        if respect_gitignore
+          gitignore_file = File.join(directory, ".gitignore")
+          if File.exist?(gitignore_file)
+            gitignore_patterns = File.readlines(gitignore_file).map(&:strip).reject(&:empty?)
+          end
+        end
+        
+        # Find files
+        if recursive
+          Dir.glob(File.join(directory, "**", "*")).each do |file_path|
+            next if File.directory?(file_path)
+            next if should_ignore_file?(file_path, gitignore_patterns)
+            next if pattern && !File.fnmatch(pattern, File.basename(file_path))
+            
+            files << build_file_data(file_path, include_metadata, include_content)
+          end
+        else
+          Dir.entries(directory).each do |entry|
+            next if entry == "." || entry == ".."
+            
+            file_path = File.join(directory, entry)
+            next if File.directory?(file_path)
+            next if should_ignore_file?(file_path, gitignore_patterns)
+            next if pattern && !File.fnmatch(pattern, entry)
+            
+            files << build_file_data(file_path, include_metadata, include_content)
+          end
+        end
+        
+        if self.class.grpc_available?
+          Makit::Io::FileList.new(files: files.map { |f| Makit::Io::File.new(f) })
+        else
+          { files: files }
+        end
+      end
+
+      # Create a directory
+      def create_directory(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        
+        FileUtils.mkdir_p(path)
+        
+        if self.class.grpc_available?
+          Google::Protobuf::Empty.new
+        else
+          {}
+        end
+      end
+
+      # Delete a directory
+      def delete_directory(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        
+        unless Dir.exist?(path)
+          raise Errno::ENOENT, "No such file or directory: #{path}"
+        end
+        
+        Dir.rmdir(path)
+        
+        if self.class.grpc_available?
+          Google::Protobuf::Empty.new
+        else
+          {}
+        end
+      end
+
+      # Upload large files in chunks
+      def upload(request, _unused_call = nil)
+        chunks = request.respond_to?(:chunks) ? request.chunks : request[:chunks]
+        
+        raise ArgumentError, "No chunks provided" if chunks.nil? || chunks.empty?
+        
+        # Group chunks by path
+        chunks_by_path = {}
+        chunks.each do |chunk|
+          path = chunk.respond_to?(:path) ? chunk.path : chunk[:path]
+          data = chunk.respond_to?(:data) ? chunk.data : chunk[:data]
+          metadata = chunk.respond_to?(:metadata) ? chunk.metadata : chunk[:metadata]
+          is_final = chunk.respond_to?(:is_final) ? chunk.is_final : chunk[:is_final]
+          
+          chunks_by_path[path] ||= { data: "", metadata: metadata }
+          chunks_by_path[path][:data] += data
+        end
+        
+        # Save each file
+        results = []
+        chunks_by_path.each do |path, file_info|
+          File.binwrite(path, file_info[:data])
+          
+          file_data = {
+            path: path,
+            binary_data: file_info[:data],
+            metadata: get_file_metadata(path)
+          }
+          
+          results << file_data
+        end
+        
+        # Return the first (or only) file result
+        result = results.first
+        
+        if self.class.grpc_available?
+          Makit::Io::FileResponse.new(file: Makit::Io::File.new(result))
+        else
+          { file: result }
+        end
+      end
+
+      # Download a file in chunks
+      def download(request, _unused_call = nil)
+        path = request.respond_to?(:path) ? request.path : request[:path]
+        
+        unless File.exist?(path)
+          raise Errno::ENOENT, "No such file or directory: #{path}"
+        end
+        
+        content = File.binread(path)
+        chunk_size = 1024  # 1KB chunks
+        chunks = []
+        
+        (0...content.length).step(chunk_size) do |i|
+          chunk_data = content[i, chunk_size]
+          is_final = (i + chunk_size >= content.length)
+          
+          chunk = {
+            path: path,
+            data: chunk_data,
+            metadata: is_final ? get_file_metadata(path) : nil,
+            is_final: is_final
+          }
+          
+          chunks << chunk
+        end
+        
+        if self.class.grpc_available?
+          chunks.map { |c| Makit::Io::FileChunk.new(c) }
+        else
+          chunks
+        end
+      end
+
+      private
+
+      def get_file_metadata(path)
+        stat = File.stat(path)
+        
+        {
+          mime_type: get_mime_type(path),
+          size_bytes: stat.size,
+          created_at: stat.birthtime.iso8601,
+          modified_at: stat.mtime.iso8601,
+          owner: stat.uid.to_s,
+          is_directory: stat.directory?,
+          checksum: calculate_checksum(path)
+        }
+      end
+
+      def get_mime_type(path)
+        mime_type = MIME::Types.type_for(path).first
+        mime_type ? mime_type.content_type : "application/octet-stream"
+      end
+
+      def calculate_checksum(path)
+        Digest::SHA256.file(path).hexdigest
+      end
+
+      def binary_file?(path)
+        # Simple heuristic: check if file contains null bytes or high bytes
+        File.open(path, "rb") do |file|
+          chunk = file.read(1024)
+          return true if chunk.nil? || chunk.include?("\x00") || chunk.bytes.any? { |b| b > 127 }
+        end
+        false
+      rescue
+        true  # If we can't read it, assume it's binary
+      end
+
+      def should_ignore_file?(file_path, gitignore_patterns)
+        return false if gitignore_patterns.empty?
+        
+        relative_path = file_path
+        gitignore_patterns.any? do |pattern|
+          File.fnmatch(pattern, relative_path) || File.fnmatch(pattern, File.basename(relative_path))
+        end
+      end
+
+      def build_file_data(file_path, include_metadata, include_content)
+        file_data = { path: file_path }
+        
+        if include_content
+          if binary_file?(file_path)
+            file_data[:binary_data] = File.binread(file_path)
+          else
+            file_data[:text_lines] = File.readlines(file_path).map(&:chomp)
+          end
+        end
+        
+        if include_metadata
+          file_data[:metadata] = get_file_metadata(file_path)
+        end
+        
+        file_data
+      end
+    end
+  end
+end

data/lib/makit/mp/string_mp.rb

@@ -61,24 +61,30 @@ class String
     Makit::Commands::Runner.default.execute(request)
   end
 
-  def cache_run(timestamp = nil)
+  def cache_run(timestamp = nil, timeout: nil)
     #puts "cache_run: #{self}"
     command = self
     request = Makit::Commands::Request.from_string(command)
+    
+    # Build request options
+    request_options = {
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: timeout || request.timeout,
+      environment: request.environment || {},
+      metadata: request.metadata || {},
+    }
+    
     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),
-      )
+      request_options[:metadata] = request_options[:metadata].merge(timestamp: timestamp)
       #puts "timestamp: #{timestamp}"
     else
       #puts "no timestamp"
     end
+    
+    request = Makit::Commands::Request.new(**request_options)
     Makit::Commands::Runner.default.execute(request)
   end