makit 0.0.144 → 0.0.145

data/lib/makit/v1/services/repository_manager_service_impl.rb

@@ -0,0 +1,572 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Makit
+  module V1
+    module Services
+      # Implementation of the RepositoryManagerService gRPC service
+      class RepositoryManagerServiceImpl < RepositoryManagerService::Service
+
+        # Initialize a new git repository in the specified directory
+        def initialize_repository(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = initialize_repository_impl(model, request.directory)
+          convert_to_proto_model(result_model)
+        end
+
+        # Clone a git repository to a local directory
+        def clone_repository(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = clone_repository_impl(model, request.git_repository)
+          convert_to_proto_model(result_model)
+        end
+
+        # Pull the latest changes from the remote repository
+        def pull_repository(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = pull_repository_impl(model, request.git_repository)
+          convert_to_proto_model(result_model)
+        end
+
+        # Clone repository if it doesn't exist, otherwise pull latest changes
+        def clone_or_pull_repository(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = clone_or_pull_repository_impl(model, request.git_repository)
+          convert_to_proto_model(result_model)
+        end
+
+        # Get git log information for a repository
+        def get_repository_log(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = get_repository_log_impl(model, request.git_repository, request.limit, request.skip)
+          convert_to_proto_model(result_model)
+        end
+
+        # Set up a work directory for a repository
+        def setup_work_directory(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = setup_work_directory_impl(model, request.repository)
+          convert_to_proto_model(result_model)
+        end
+
+        # Get the latest commit hash from a repository
+        def get_latest_commit(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = get_latest_commit_impl(model, request.clone_dir)
+          convert_to_proto_model(result_model)
+        end
+
+        # Validate that a clone directory exists for the given repository
+        def validate_clone_directory(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = validate_clone_directory_impl(model, request.url)
+          convert_to_proto_model(result_model)
+        end
+
+        # Create a new repository manager model with default values
+        def create_repository_model(request, _unused_call)
+          model = create_repository_model_impl(
+            repository_url: request.repository_url,
+            clone_directory: request.clone_directory,
+            work_directory: request.work_directory,
+            is_initialized: request.is_initialized,
+            is_cloned: request.is_cloned,
+            has_work_directory: request.has_work_directory,
+            latest_commit_hash: request.latest_commit_hash,
+            last_pull_time: convert_timestamp_from_proto(request.last_pull_time),
+            last_clone_time: convert_timestamp_from_proto(request.last_clone_time),
+            git_log_entries: convert_git_log_entries_from_proto(request.git_log_entries),
+            command_results: convert_command_results_from_proto(request.command_results),
+            validation_errors: request.validation_errors.to_a,
+            configuration: request.configuration.to_h
+          )
+          convert_to_proto_model(model)
+        end
+
+        # Update an existing repository model
+        def update_repository_model(request, _unused_call)
+          model = convert_from_proto_model(request.model)
+          result_model = update_repository_model_impl(model, request.updates.to_h)
+          convert_to_proto_model(result_model)
+        end
+
+        private
+
+        # Implementation methods that directly execute git commands
+        def initialize_repository_impl(model, directory)
+          model[:clone_directory] = directory
+          model[:validation_errors] = []
+
+          begin
+            FileUtils.mkdir_p(directory)
+            raise Makit::DirectoryError, "directory does not exist: #{directory}" unless Dir.exist?(directory)
+
+            Dir.chdir(directory) do
+              File.write(".gitignore", Makit::Content::GITIGNORE) unless File.exist?(".gitignore")
+              init_command = Makit::Commands::Runner.default.execute("git init")
+
+              command_result = {
+                exit_code: init_command.exit_code,
+                output: init_command.output,
+                error: init_command.error
+              }
+              model[:command_results] << command_result
+
+              if init_command.exit_code != 0
+                error_msg = "failed to initialize local repository: #{directory}\n#{Makit::Humanize.get_command_summary(init_command)}"
+                model[:validation_errors] << error_msg
+                raise Makit::GitError, error_msg
+              end
+
+              model[:is_initialized] = true
+            end
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def clone_repository_impl(model, git_repository)
+          model[:repository_url] = git_repository
+          model[:validation_errors] = []
+
+          begin
+            clone_dir = Directories.get_clone_directory(git_repository)
+            model[:clone_directory] = clone_dir
+
+            unless Dir.exist?(clone_dir)
+              clone_command = Makit::Commands::Runner.default.execute("git clone #{git_repository} #{clone_dir}")
+              
+              command_result = {
+                exit_code: clone_command.exit_code,
+                output: clone_command.output,
+                error: clone_command.error
+              }
+              model[:command_results] << command_result
+
+              if clone_command.exit_code != 0
+                error_msg = "failed to clone repository: #{git_repository}\n#{Makit::Humanize.get_command_summary(clone_command)}"
+                model[:validation_errors] << error_msg
+                raise Makit::GitError, error_msg
+              end
+
+              model[:is_cloned] = true
+              model[:last_clone_time] = Time.now
+            else
+              model[:is_cloned] = true
+            end
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def pull_repository_impl(model, git_repository)
+          model[:repository_url] = git_repository
+          model[:validation_errors] = []
+
+          begin
+            clone_dir = Directories.get_clone_directory(git_repository)
+            model[:clone_directory] = clone_dir
+
+            raise Makit::DirectoryError, "clone directory does not exist: #{clone_dir}" unless Dir.exist?(clone_dir)
+
+            Dir.chdir(clone_dir) do
+              pull_command = execute_git_pull(clone_dir)
+              
+              command_result = {
+                exit_code: pull_command.exit_code,
+                output: pull_command.output,
+                error: pull_command.error
+              }
+              model[:command_results] << command_result
+
+              model[:last_pull_time] = Time.now
+            end
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def clone_or_pull_repository_impl(model, git_repository)
+          model[:repository_url] = git_repository
+          clone_dir = Directories.get_clone_directory(git_repository)
+          model[:clone_directory] = clone_dir
+
+          if Dir.exist?(clone_dir)
+            pull_repository_impl(model, git_repository)
+          else
+            clone_repository_impl(model, git_repository)
+          end
+
+          model
+        end
+
+        def get_repository_log_impl(model, git_repository, limit, skip)
+          model[:repository_url] = git_repository
+          model[:validation_errors] = []
+
+          begin
+            clone_dir = Directories.get_clone_directory(git_repository)
+            model[:clone_directory] = clone_dir
+
+            raise Makit::DirectoryError, "clone directory does not exist: #{clone_dir}" unless Dir.exist?(clone_dir)
+
+            Dir.chdir(clone_dir) do
+              log_command = Makit::Commands::Runner.default.execute("git log -n #{limit} --skip #{skip} --date=iso")
+              
+              command_result = {
+                exit_code: log_command.exit_code,
+                output: log_command.output,
+                error: log_command.error
+              }
+              model[:command_results] << command_result
+
+              if log_command.exit_code == 0
+                model[:git_log_entries] = parse_git_log_output(log_command)
+              else
+                model[:validation_errors] << "failed to get git log: #{log_command.error}"
+              end
+            end
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def setup_work_directory_impl(model, repository)
+          model[:repository_url] = repository
+          model[:validation_errors] = []
+
+          begin
+            clone_or_pull_repository_impl(model, repository)
+            create_work_directory_impl(model, repository)
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def get_latest_commit_impl(model, clone_dir)
+          model[:clone_directory] = clone_dir
+          model[:validation_errors] = []
+
+          begin
+            Dir.chdir(clone_dir) do
+              git_log = Makit::Commands::Runner.default.execute("git log -n 1 --date=iso")
+              
+              command_result = {
+                exit_code: git_log.exit_code,
+                output: git_log.output,
+                error: git_log.error
+              }
+              model[:command_results] << command_result
+
+              if git_log.exit_code == 0
+                commit = git_log.output.match(/^commit ([0-9a-f]{40})$/i)&.captures&.first
+
+                if commit.nil? || commit.empty? || !commit.match?(/\A[0-9a-f]{40}\z/i)
+                  error_msg = "invalid commit: #{commit}"
+                  model[:validation_errors] << error_msg
+                  raise Makit::InvalidCommitError, error_msg
+                end
+
+                model[:latest_commit_hash] = commit
+              else
+                model[:validation_errors] << "failed to get latest commit: #{git_log.error}"
+              end
+            end
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def validate_clone_directory_impl(model, url)
+          model[:repository_url] = url
+          model[:validation_errors] = []
+
+          begin
+            clone_dir = Directories.get_clone_directory(url)
+            model[:clone_directory] = clone_dir
+
+            raise Makit::DirectoryError, "clone directory does not exist: #{clone_dir}" unless Dir.exist?(clone_dir)
+          rescue StandardError => e
+            model[:validation_errors] << e.message
+            raise
+          end
+
+          model
+        end
+
+        def create_repository_model_impl(**params)
+          {
+            repository_url: params[:repository_url],
+            clone_directory: params[:clone_directory],
+            work_directory: params[:work_directory],
+            is_initialized: params[:is_initialized] || false,
+            is_cloned: params[:is_cloned] || false,
+            has_work_directory: params[:has_work_directory] || false,
+            latest_commit_hash: params[:latest_commit_hash],
+            last_pull_time: params[:last_pull_time],
+            last_clone_time: params[:last_clone_time],
+            git_log_entries: params[:git_log_entries] || [],
+            command_results: params[:command_results] || [],
+            validation_errors: params[:validation_errors] || [],
+            configuration: params[:configuration] || {}
+          }
+        end
+
+        def update_repository_model_impl(model, updates)
+          updates.each do |key, value|
+            case key.to_sym
+            when :repository_url
+              model[:repository_url] = value
+            when :clone_directory
+              model[:clone_directory] = value
+            when :work_directory
+              model[:work_directory] = value
+            when :is_initialized
+              model[:is_initialized] = (value == "true" || value == true)
+            when :is_cloned
+              model[:is_cloned] = (value == "true" || value == true)
+            when :has_work_directory
+              model[:has_work_directory] = (value == "true" || value == true)
+            when :latest_commit_hash
+              model[:latest_commit_hash] = value
+            when :last_pull_time
+              model[:last_pull_time] = value
+            when :last_clone_time
+              model[:last_clone_time] = value
+            when :git_log_entries
+              model[:git_log_entries] = value
+            when :command_results
+              model[:command_results] = value
+            when :validation_errors
+              model[:validation_errors] = value
+            when :configuration
+              model[:configuration] = value
+            end
+          end
+          model
+        end
+
+        # Helper methods
+        def execute_git_pull(clone_dir)
+          request = Makit::V1::CommandRequest.new(
+            name: "git",
+            arguments: ["pull"],
+            directory: clone_dir,
+          )
+          pull_command = Makit::Commands::Runner.default.execute(request)
+
+          raise Makit::PullError, Makit::Humanize.get_command_details(pull_command) if pull_command.exit_code != 0
+
+          pull_command
+        end
+
+        def create_work_directory_impl(model, repository)
+          work_dir = Makit::Directories.get_work_directory(repository)
+          clone_dir = Makit::Directories.get_clone_directory(repository)
+          model[:work_directory] = work_dir
+
+          unless Dir.exist?(work_dir)
+            FileUtils.mkdir_p(File.dirname(work_dir))
+            clone_command = Makit::Commands::Runner.default.execute("git clone #{clone_dir} #{work_dir}")
+            
+            command_result = {
+              exit_code: clone_command.exit_code,
+              output: clone_command.output,
+              error: clone_command.error
+            }
+            model[:command_results] << command_result
+
+            if clone_command.exit_code != 0
+              error_msg = "failed to create work directory: #{work_dir}\n#{Makit::Humanize.get_command_summary(clone_command)}"
+              model[:validation_errors] << error_msg
+              raise Makit::GitError, error_msg
+            end
+
+            model[:has_work_directory] = true
+          else
+            model[:has_work_directory] = true
+          end
+
+          Dir.chdir(work_dir) do
+            File.write(".gitignore", Makit::Content::GITIGNORE) unless File.exist?(".gitignore")
+          end
+        end
+
+        def parse_git_log_output(log_command)
+          entries = []
+          return entries if log_command.exit_code != 0
+
+          lines = log_command.output.split("\n")
+          current_entry = nil
+
+          lines.each do |line|
+            current_entry = process_git_log_line(line, current_entry, entries)
+          end
+
+          entries
+        end
+
+        def process_git_log_line(line, current_entry, entries)
+          case line
+          when /^commit/
+            create_new_log_entry(line, entries)
+          when /^Author:/
+            current_entry ? update_entry_author(line, current_entry) : current_entry
+          when /^Date:/
+            current_entry ? update_entry_date(line, current_entry) : current_entry
+          when /^    /
+            current_entry ? update_entry_message(line, current_entry) : current_entry
+          else
+            current_entry
+          end
+        end
+
+        def create_new_log_entry(line, entries)
+          current_entry = {
+            commit_hash: line.split[1],
+            author: nil,
+            date: nil,
+            message: ""
+          }
+          entries << current_entry
+          current_entry
+        end
+
+        def update_entry_author(line, current_entry)
+          current_entry[:author] = line.split[1..].join(" ")
+          current_entry
+        end
+
+        def update_entry_date(line, current_entry)
+          current_entry[:date] = line.split[1..].join(" ")
+          current_entry
+        end
+
+        def update_entry_message(line, current_entry)
+          current_entry[:message] += line[4..]
+          current_entry
+        end
+
+        # Convert Ruby RepositoryManagerModel to Protobuf RepositoryManagerModel
+        def convert_to_proto_model(ruby_model)
+          Makit::V1::Services::RepositoryManagerModel.new(
+            repository_url: ruby_model[:repository_url],
+            clone_directory: ruby_model[:clone_directory],
+            work_directory: ruby_model[:work_directory],
+            is_initialized: ruby_model[:is_initialized],
+            is_cloned: ruby_model[:is_cloned],
+            has_work_directory: ruby_model[:has_work_directory],
+            latest_commit_hash: ruby_model[:latest_commit_hash],
+            last_pull_time: convert_timestamp_to_proto(ruby_model[:last_pull_time]),
+            last_clone_time: convert_timestamp_to_proto(ruby_model[:last_clone_time]),
+            git_log_entries: convert_git_log_entries_to_proto(ruby_model[:git_log_entries]),
+            command_results: convert_command_results_to_proto(ruby_model[:command_results]),
+            validation_errors: ruby_model[:validation_errors],
+            configuration: ruby_model[:configuration]
+          )
+        end
+
+        # Convert Protobuf RepositoryManagerModel to Ruby RepositoryManagerModel
+        def convert_from_proto_model(proto_model)
+          {
+            repository_url: proto_model.repository_url,
+            clone_directory: proto_model.clone_directory,
+            work_directory: proto_model.work_directory,
+            is_initialized: proto_model.is_initialized,
+            is_cloned: proto_model.is_cloned,
+            has_work_directory: proto_model.has_work_directory,
+            latest_commit_hash: proto_model.latest_commit_hash,
+            last_pull_time: convert_timestamp_from_proto(proto_model.last_pull_time),
+            last_clone_time: convert_timestamp_from_proto(proto_model.last_clone_time),
+            git_log_entries: convert_git_log_entries_from_proto(proto_model.git_log_entries),
+            command_results: convert_command_results_from_proto(proto_model.command_results),
+            validation_errors: proto_model.validation_errors.to_a,
+            configuration: proto_model.configuration.to_h
+          }
+        end
+
+        # Convert Ruby Time to Protobuf Timestamp
+        def convert_timestamp_to_proto(time)
+          return nil if time.nil?
+          
+          Google::Protobuf::Timestamp.new(
+            seconds: time.to_i,
+            nanos: time.nsec
+          )
+        end
+
+        # Convert Protobuf Timestamp to Ruby Time
+        def convert_timestamp_from_proto(timestamp)
+          return nil if timestamp.nil?
+          
+          Time.at(timestamp.seconds, timestamp.nanos, :nsec)
+        end
+
+        # Convert Ruby GitLogEntry array to Protobuf GitLogEntry array
+        def convert_git_log_entries_to_proto(ruby_entries)
+          ruby_entries.map do |entry|
+            Makit::V1::Services::GitLogEntry.new(
+              commit_hash: entry[:commit_hash],
+              author: entry[:author],
+              date: entry[:date],
+              message: entry[:message]
+            )
+          end
+        end
+
+        # Convert Protobuf GitLogEntry array to Ruby GitLogEntry array
+        def convert_git_log_entries_from_proto(proto_entries)
+          proto_entries.map do |entry|
+            {
+              commit_hash: entry.commit_hash,
+              author: entry.author,
+              date: entry.date,
+              message: entry.message
+            }
+          end
+        end
+
+        # Convert Ruby CommandResult array to Protobuf CommandResult array
+        def convert_command_results_to_proto(ruby_results)
+          ruby_results.map do |result|
+            Makit::V1::Services::CommandResult.new(
+              exit_code: result[:exit_code],
+              output: result[:output],
+              error: result[:error]
+            )
+          end
+        end
+
+        # Convert Protobuf CommandResult array to Ruby CommandResult array
+        def convert_command_results_from_proto(proto_results)
+          proto_results.map do |result|
+            {
+              exit_code: result.exit_code,
+              output: result.output,
+              error: result.error
+            }
+          end
+        end
+      end
+    end
+  end
+end