makit 0.0.143 → 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

data/lib/makit/version.rb

@@ -2,7 +2,7 @@
 
 module Makit
   # Static version for now to avoid circular dependency issues
-  VERSION = "0.0.143"
+  VERSION = "0.0.145"
 
   # Version management utilities for various file formats
   #

data/lib/makit.rb

@@ -5,6 +5,10 @@ require "colorize"
 # Set default LOG_LEVEL if not already set
 ENV["LOG_LEVEL"] ||= "info"
 
+# Add generated directory to load path for protobuf files
+generated_path = File.join(__dir__, "generated")
+$LOAD_PATH.unshift(generated_path) if File.exist?(generated_path)
+
 require_relative "makit/version"
 require_relative "makit/dotnet"
 require_relative "makit/rake"
@@ -18,16 +22,80 @@ require_relative "makit/serializer"
 require_relative "makit/secrets"
 require_relative "makit/humanize"
 require_relative "makit/directories"
+require_relative "makit/exceptions"
+
+# Load generated protobuf files only if they exist
+if File.exist?(File.join(__dir__, "generated", "makit", "v1", "configuration", "project_pb.rb"))
+  require_relative "generated/makit/v1/configuration/project_pb"
+  require_relative "generated/makit/v1/configuration/project_service_pb"
+  require_relative "generated/makit/v1/configuration/project_service_services_pb"
+end
+
+if File.exist?(File.join(__dir__, "generated", "makit", "v1", "git", "git_repository_model_pb.rb"))
+  require_relative "generated/makit/v1/git/git_repository_model_pb"
+  require_relative "generated/makit/v1/git/git_repository_service_pb"
+  require_relative "generated/makit/v1/git/git_repository_service_services_pb"
+end
+
+if File.exist?(File.join(__dir__, "generated", "makit", "gitlab", "pipeline_pb.rb"))
+  require_relative "generated/makit/gitlab/pipeline_pb"
+  require_relative "generated/makit/gitlab/pipeline_service_pb"
+  require_relative "generated/makit/gitlab/pipeline_service_services_pb"
+  require_relative "generated/makit/gitlab/pipeline_result_pb"
+end
+
+if File.exist?(File.join(__dir__, "generated", "makit", "podman", "podman_service_pb.rb"))
+  require_relative "generated/makit/podman/podman_service_pb"
+  require_relative "generated/makit/podman/podman_service_services_pb"
+end
+
+# Load specification protobuf files
+if File.exist?(File.join(__dir__, "generated", "makit", "protos", "spec", "message_spec_pb.rb"))
+  require_relative "generated/makit/protos/spec/message_spec_pb"
+  require_relative "generated/makit/protos/spec/message_spec_suite_pb"
+  require_relative "generated/makit/protos/spec/message_spec_test_pb"
+  require_relative "generated/makit/protos/spec/proto_service_pb"
+  require_relative "generated/makit/protos/spec/spec_manifest_pb"
+  require_relative "generated/makit/protos/spec/message_proto_generator_pb"
+end
+
+if File.exist?(File.join(__dir__, "generated", "makit", "io", "filesystem_pb.rb"))
+  require_relative "generated/makit/io/filesystem_pb"
+  require_relative "generated/makit/io/filesystem_services_pb"
+end
 require_relative "makit/files"
 require_relative "makit/task_info"
 require_relative "makit/tasks"
 require_relative "makit/environment"
 require_relative "makit/process"
+
+# Load GitLab pipeline modules
+require_relative "makit/gitlab/pipeline"
+require_relative "makit/gitlab/pipeline_service_impl"
+
+# Load Podman modules
+require_relative "makit/podman/podman"
+require_relative "makit/podman/podman_service_impl"
+
+# Load IO modules
+require_relative "makit/io/filesystem"
+require_relative "makit/io/filesystem_service_impl"
 require_relative "makit/mp/string_mp"
 require_relative "makit/git"
 require_relative "makit/protoc"
 require_relative "makit/zip"
 
+# Load services modules
+# Note: RepositoryManager intermediate classes removed after Phase 4 cleanup
+
+# Load generated protobuf files only if they exist
+if File.exist?(File.join(__dir__, "generated", "makit", "v1", "services", "repository_manager_model_pb.rb"))
+  require_relative "generated/makit/v1/services/repository_manager_model_pb"
+  require_relative "generated/makit/v1/services/repository_manager_service_pb"
+  require_relative "generated/makit/v1/services/repository_manager_service_services_pb"
+  require_relative "makit/v1/services/repository_manager_service_impl"
+end
+
 module Makit
   class Error < StandardError; end