makit 0.0.144 → 0.0.145

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