makit 0.0.168 → 0.0.169

data/lib/makit/services/repository_manager.rb

@@ -1,367 +1,367 @@
-# frozen_string_literal: true
-
-require_relative "validator"
-# Note: RepositoryManagerService intermediate class removed after Phase 4 cleanup
-
-module Makit
-  module Services
-    # Service class responsible for git repository management operations
-    # Handles cloning, pulling, logging, and working directory setup
-    # 
-    # This class now acts as a Ruby wrapper around the gRPC service implementation,
-    # maintaining backward compatibility while providing the benefits of the new architecture.
-    class RepositoryManager
-      class << self
-        # Initialize a new git repository in the specified directory
-        #
-        # @param directory [String] the directory path to initialize
-        # @return [Makit::V1::Command] the git init command result
-        # @raise [Makit::DirectoryError] if the directory cannot be created
-        # @raise [Makit::GitError] if git initialization fails
-        def initialize_repository(directory)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::InitializeRepositoryRequest.new(
-            model: convert_to_proto_model(model),
-            directory: directory
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.initialize_repository(request, nil)
-          
-          # Convert back to Ruby model and extract the command result
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Return the last command result as a Makit::V1::Command
-          return create_command_from_result(ruby_model.command_results.last) if ruby_model.command_results.any?
-          
-          # Fallback: create a mock command if no results
-          create_mock_command(0, "Repository initialized", "")
-        end
-
-        # Clone a git repository to a local directory
-        #
-        # @param git_repository [String] the git repository URL
-        # @return [Array<Makit::V1::Command>] array of command results
-        def clone_repository(git_repository)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::CloneRepositoryRequest.new(
-            model: convert_to_proto_model(model),
-            git_repository: git_repository
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.clone_repository(request, nil)
-          
-          # Convert back to Ruby model and extract command results
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Convert command results to Makit::V1::Command objects
-          ruby_model.command_results.map { |result| create_command_from_result(result) }
-        end
-
-        # Pull the latest changes from the remote repository
-        #
-        # @param git_repository [String] the git repository URL
-        # @return [Makit::V1::Command] the git pull command result
-        def pull_repository(git_repository)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::PullRepositoryRequest.new(
-            model: convert_to_proto_model(model),
-            git_repository: git_repository
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.pull_repository(request, nil)
-          
-          # Convert back to Ruby model and extract the command result
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Return the last command result as a Makit::V1::Command
-          return create_command_from_result(ruby_model.command_results.last) if ruby_model.command_results.any?
-          
-          # Fallback: create a mock command if no results
-          create_mock_command(0, "Repository pulled", "")
-        end
-
-        # Clone repository if it doesn't exist, otherwise pull latest changes
-        #
-        # @param git_repository [String] the git repository URL
-        # @return [Array<Makit::V1::Command>] array of command results
-        def clone_or_pull_repository(git_repository)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::CloneOrPullRepositoryRequest.new(
-            model: convert_to_proto_model(model),
-            git_repository: git_repository
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.clone_or_pull_repository(request, nil)
-          
-          # Convert back to Ruby model and extract command results
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Convert command results to Makit::V1::Command objects
-          ruby_model.command_results.map { |result| create_command_from_result(result) }
-        end
-
-        # Get git log information for a repository
-        #
-        # @param git_repository [String] the git repository URL
-        # @param limit [Integer] maximum number of commits to retrieve
-        # @param skip [Integer] number of commits to skip
-        # @return [Array<Makit::V1::GitLogEntry>] array of log entries
-        def get_repository_log(git_repository, limit, skip)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::GetRepositoryLogRequest.new(
-            model: convert_to_proto_model(model),
-            git_repository: git_repository,
-            limit: limit,
-            skip: skip
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.get_repository_log(request, nil)
-          
-          # Convert back to Ruby model and extract git log entries
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Convert to Makit::V1::GitLogEntry objects
-          ruby_model.git_log_entries.map { |entry| create_git_log_entry_from_model(entry) }
-        end
-
-        # Set up a work directory for a repository
-        #
-        # @param repository [String] the git repository URL
-        # @return [nil] always returns nil
-        def setup_work_directory(repository)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::SetupWorkDirectoryRequest.new(
-            model: convert_to_proto_model(model),
-            repository: repository
-          )
-          
-          Makit::V1::Services::RepositoryManagerServiceImpl.new.setup_work_directory(request, nil)
-          
-          # Always return nil as per original API
-          nil
-        end
-
-        # Get the latest commit hash from a repository
-        #
-        # @param clone_dir [String] the local clone directory
-        # @param commands [Array] array to append command results to
-        # @return [String] the latest commit hash
-        def get_latest_commit(clone_dir, commands)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::GetLatestCommitRequest.new(
-            model: convert_to_proto_model(model),
-            clone_dir: clone_dir
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.get_latest_commit(request, nil)
-          
-          # Convert back to Ruby model
-          ruby_model = convert_from_proto_model(result_model)
-          
-          # Append command results to the provided commands array
-          ruby_model.command_results.each { |result| commands << create_command_from_result(result) }
-          
-          # Return the latest commit hash
-          ruby_model.latest_commit_hash || ""
-        end
-
-        # Validate that a clone directory exists for the given repository
-        #
-        # @param url [String] the git repository URL
-        # @return [String] the clone directory path
-        def validate_clone_directory(url)
-          # Create a new repository model directly
-          model = create_empty_repository_model
-          
-          # Call the gRPC service
-          request = Makit::V1::Services::ValidateCloneDirectoryRequest.new(
-            model: convert_to_proto_model(model),
-            url: url
-          )
-          
-          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.validate_clone_directory(request, nil)
-          
-          # Convert back to Ruby model and return clone directory
-          ruby_model = convert_from_proto_model(result_model)
-          ruby_model.clone_directory || ""
-        end
-
-        private
-
-        # Create an empty repository model for gRPC service calls
-        def create_empty_repository_model
-          # Create a simple hash-based model since we removed the intermediate classes
-          {
-            repository_url: nil,
-            clone_directory: nil,
-            work_directory: nil,
-            is_initialized: false,
-            is_cloned: false,
-            has_work_directory: false,
-            latest_commit_hash: nil,
-            last_pull_time: nil,
-            last_clone_time: nil,
-            git_log_entries: [],
-            command_results: [],
-            validation_errors: [],
-            configuration: {}
-          }
-        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_time_to_timestamp(ruby_model[:last_pull_time]),
-            last_clone_time: convert_time_to_timestamp(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_to_time(proto_model.last_pull_time),
-            last_clone_time: convert_timestamp_to_time(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_time_to_timestamp(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_to_time(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
-
-        # Create a Makit::V1::Command from a CommandResult
-        def create_command_from_result(result)
-          # Create a mock Makit::V1::Command object
-          # This maintains compatibility with the original API
-          command = Object.new
-          command.define_singleton_method(:exit_code) { result[:exit_code] }
-          command.define_singleton_method(:output) { result[:output] }
-          command.define_singleton_method(:error) { result[:error] }
-          command
-        end
-
-        # Create a mock Makit::V1::Command for fallback cases
-        def create_mock_command(exit_code, output, error)
-          command = Object.new
-          command.define_singleton_method(:exit_code) { exit_code }
-          command.define_singleton_method(:output) { output }
-          command.define_singleton_method(:error) { error }
-          command
-        end
-
-        # Create a Makit::V1::GitLogEntry from a GitLogEntry model
-        def create_git_log_entry_from_model(entry)
-          # Create a mock Makit::V1::GitLogEntry object
-          # This maintains compatibility with the original API
-          git_log_entry = Object.new
-          git_log_entry.define_singleton_method(:commit_hash) { entry[:commit_hash] }
-          git_log_entry.define_singleton_method(:author) { entry[:author] }
-          git_log_entry.define_singleton_method(:date) { entry[:date] }
-          git_log_entry.define_singleton_method(:message) { entry[:message] }
-          git_log_entry
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "validator"
+# Note: RepositoryManagerService intermediate class removed after Phase 4 cleanup
+
+module Makit
+  module Services
+    # Service class responsible for git repository management operations
+    # Handles cloning, pulling, logging, and working directory setup
+    # 
+    # This class now acts as a Ruby wrapper around the gRPC service implementation,
+    # maintaining backward compatibility while providing the benefits of the new architecture.
+    class RepositoryManager
+      class << self
+        # Initialize a new git repository in the specified directory
+        #
+        # @param directory [String] the directory path to initialize
+        # @return [Makit::V1::Command] the git init command result
+        # @raise [Makit::DirectoryError] if the directory cannot be created
+        # @raise [Makit::GitError] if git initialization fails
+        def initialize_repository(directory)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::InitializeRepositoryRequest.new(
+            model: convert_to_proto_model(model),
+            directory: directory
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.initialize_repository(request, nil)
+          
+          # Convert back to Ruby model and extract the command result
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Return the last command result as a Makit::V1::Command
+          return create_command_from_result(ruby_model.command_results.last) if ruby_model.command_results.any?
+          
+          # Fallback: create a mock command if no results
+          create_mock_command(0, "Repository initialized", "")
+        end
+
+        # Clone a git repository to a local directory
+        #
+        # @param git_repository [String] the git repository URL
+        # @return [Array<Makit::V1::Command>] array of command results
+        def clone_repository(git_repository)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::CloneRepositoryRequest.new(
+            model: convert_to_proto_model(model),
+            git_repository: git_repository
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.clone_repository(request, nil)
+          
+          # Convert back to Ruby model and extract command results
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Convert command results to Makit::V1::Command objects
+          ruby_model.command_results.map { |result| create_command_from_result(result) }
+        end
+
+        # Pull the latest changes from the remote repository
+        #
+        # @param git_repository [String] the git repository URL
+        # @return [Makit::V1::Command] the git pull command result
+        def pull_repository(git_repository)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::PullRepositoryRequest.new(
+            model: convert_to_proto_model(model),
+            git_repository: git_repository
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.pull_repository(request, nil)
+          
+          # Convert back to Ruby model and extract the command result
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Return the last command result as a Makit::V1::Command
+          return create_command_from_result(ruby_model.command_results.last) if ruby_model.command_results.any?
+          
+          # Fallback: create a mock command if no results
+          create_mock_command(0, "Repository pulled", "")
+        end
+
+        # Clone repository if it doesn't exist, otherwise pull latest changes
+        #
+        # @param git_repository [String] the git repository URL
+        # @return [Array<Makit::V1::Command>] array of command results
+        def clone_or_pull_repository(git_repository)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::CloneOrPullRepositoryRequest.new(
+            model: convert_to_proto_model(model),
+            git_repository: git_repository
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.clone_or_pull_repository(request, nil)
+          
+          # Convert back to Ruby model and extract command results
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Convert command results to Makit::V1::Command objects
+          ruby_model.command_results.map { |result| create_command_from_result(result) }
+        end
+
+        # Get git log information for a repository
+        #
+        # @param git_repository [String] the git repository URL
+        # @param limit [Integer] maximum number of commits to retrieve
+        # @param skip [Integer] number of commits to skip
+        # @return [Array<Makit::V1::GitLogEntry>] array of log entries
+        def get_repository_log(git_repository, limit, skip)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::GetRepositoryLogRequest.new(
+            model: convert_to_proto_model(model),
+            git_repository: git_repository,
+            limit: limit,
+            skip: skip
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.get_repository_log(request, nil)
+          
+          # Convert back to Ruby model and extract git log entries
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Convert to Makit::V1::GitLogEntry objects
+          ruby_model.git_log_entries.map { |entry| create_git_log_entry_from_model(entry) }
+        end
+
+        # Set up a work directory for a repository
+        #
+        # @param repository [String] the git repository URL
+        # @return [nil] always returns nil
+        def setup_work_directory(repository)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::SetupWorkDirectoryRequest.new(
+            model: convert_to_proto_model(model),
+            repository: repository
+          )
+          
+          Makit::V1::Services::RepositoryManagerServiceImpl.new.setup_work_directory(request, nil)
+          
+          # Always return nil as per original API
+          nil
+        end
+
+        # Get the latest commit hash from a repository
+        #
+        # @param clone_dir [String] the local clone directory
+        # @param commands [Array] array to append command results to
+        # @return [String] the latest commit hash
+        def get_latest_commit(clone_dir, commands)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::GetLatestCommitRequest.new(
+            model: convert_to_proto_model(model),
+            clone_dir: clone_dir
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.get_latest_commit(request, nil)
+          
+          # Convert back to Ruby model
+          ruby_model = convert_from_proto_model(result_model)
+          
+          # Append command results to the provided commands array
+          ruby_model.command_results.each { |result| commands << create_command_from_result(result) }
+          
+          # Return the latest commit hash
+          ruby_model.latest_commit_hash || ""
+        end
+
+        # Validate that a clone directory exists for the given repository
+        #
+        # @param url [String] the git repository URL
+        # @return [String] the clone directory path
+        def validate_clone_directory(url)
+          # Create a new repository model directly
+          model = create_empty_repository_model
+          
+          # Call the gRPC service
+          request = Makit::V1::Services::ValidateCloneDirectoryRequest.new(
+            model: convert_to_proto_model(model),
+            url: url
+          )
+          
+          result_model = Makit::V1::Services::RepositoryManagerServiceImpl.new.validate_clone_directory(request, nil)
+          
+          # Convert back to Ruby model and return clone directory
+          ruby_model = convert_from_proto_model(result_model)
+          ruby_model.clone_directory || ""
+        end
+
+        private
+
+        # Create an empty repository model for gRPC service calls
+        def create_empty_repository_model
+          # Create a simple hash-based model since we removed the intermediate classes
+          {
+            repository_url: nil,
+            clone_directory: nil,
+            work_directory: nil,
+            is_initialized: false,
+            is_cloned: false,
+            has_work_directory: false,
+            latest_commit_hash: nil,
+            last_pull_time: nil,
+            last_clone_time: nil,
+            git_log_entries: [],
+            command_results: [],
+            validation_errors: [],
+            configuration: {}
+          }
+        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_time_to_timestamp(ruby_model[:last_pull_time]),
+            last_clone_time: convert_time_to_timestamp(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_to_time(proto_model.last_pull_time),
+            last_clone_time: convert_timestamp_to_time(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_time_to_timestamp(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_to_time(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
+
+        # Create a Makit::V1::Command from a CommandResult
+        def create_command_from_result(result)
+          # Create a mock Makit::V1::Command object
+          # This maintains compatibility with the original API
+          command = Object.new
+          command.define_singleton_method(:exit_code) { result[:exit_code] }
+          command.define_singleton_method(:output) { result[:output] }
+          command.define_singleton_method(:error) { result[:error] }
+          command
+        end
+
+        # Create a mock Makit::V1::Command for fallback cases
+        def create_mock_command(exit_code, output, error)
+          command = Object.new
+          command.define_singleton_method(:exit_code) { exit_code }
+          command.define_singleton_method(:output) { output }
+          command.define_singleton_method(:error) { error }
+          command
+        end
+
+        # Create a Makit::V1::GitLogEntry from a GitLogEntry model
+        def create_git_log_entry_from_model(entry)
+          # Create a mock Makit::V1::GitLogEntry object
+          # This maintains compatibility with the original API
+          git_log_entry = Object.new
+          git_log_entry.define_singleton_method(:commit_hash) { entry[:commit_hash] }
+          git_log_entry.define_singleton_method(:author) { entry[:author] }
+          git_log_entry.define_singleton_method(:date) { entry[:date] }
+          git_log_entry.define_singleton_method(:message) { entry[:message] }
+          git_log_entry
+        end
+      end
+    end
+  end
+end