makit 0.0.144 → 0.0.145

data/lib/makit/services/repository_manager.rb

@@ -1,231 +1,367 @@
-# frozen_string_literal: true
-
-require_relative "validator"
-
-module Makit
-  module Services
-    # Service class responsible for git repository management operations
-    # Handles cloning, pulling, logging, and working directory setup
-    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)
-          Validator.validate_directory_parameter(directory)
-          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")
-
-            if init_command.exit_code != 0
-              raise Makit::GitError, "failed to initialize local repository: #{directory}\\n#{Makit::Humanize.get_command_summary(init_command)}"
-            end
-
-            init_command
-          end
-        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)
-          Validator.validate_url_parameter(git_repository)
-          commands = []
-
-          clone_dir = Directories.get_clone_directory(git_repository)
-          unless Dir.exist?(clone_dir)
-            commands << Makit::Commands::Runner.default.execute("git clone #{git_repository} #{clone_dir}")
-          end
-
-          commands
-        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)
-          Validator.validate_url_parameter(git_repository)
-          clone_dir = Directories.get_clone_directory(git_repository)
-
-          Validator.validate_directory_exists(clone_dir, "clone directory")
-
-          Dir.chdir(clone_dir) do
-            execute_git_pull(clone_dir)
-          end
-        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)
-          commands = []
-          clone_dir = Directories.get_clone_directory(git_repository)
-
-          commands << if Dir.exist?(clone_dir)
-            pull_repository(git_repository)
-          else
-            clone_repository(git_repository)
-          end
-          commands
-        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)
-          Validator.validate_url_parameter(git_repository)
-          Validator.validate_pagination_parameters(limit, skip)
-
-          clone_dir = Directories.get_clone_directory(git_repository)
-          Validator.validate_directory_exists(clone_dir, "clone directory")
-
-          Dir.chdir(clone_dir) do
-            log_command = Makit::Commands::Runner.default.execute("git log -n #{limit} --skip #{skip} --date=iso")
-            parse_git_log_output(log_command)
-          end
-        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)
-          Validator.validate_url_parameter(repository)
-          clone_or_pull_repository(repository)
-          create_work_directory(repository)
-          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)
-          Dir.chdir(clone_dir) do
-            git_log = Makit::Commands::Runner.default.execute("git log -n 1 --date=iso")
-            commands << git_log
-
-            commit = git_log.output.match(/^commit ([0-9a-f]{#{Validator::COMMIT_HASH_LENGTH}})$/i)&.captures&.first
-
-            if commit.nil? || commit.empty? || !commit.match?(/\\A[0-9a-f]{#{Validator::COMMIT_HASH_LENGTH}}\\z/i)
-              raise Makit::InvalidCommitError, "invalid commit: #{commit}"
-            end
-
-            commit
-          end
-        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)
-          clone_dir = Directories.get_clone_directory(url)
-          Validator.validate_directory_exists(clone_dir, "clone directory")
-          clone_dir
-        end
-
-        private
-
-        # Execute git pull command with proper error handling
-        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
-
-        # Create work directory for development
-        def create_work_directory(repository)
-          work_dir = Makit::Directories.get_work_directory(repository)
-          clone_dir = Makit::Directories.get_clone_directory(repository)
-
-          unless Dir.exist?(work_dir)
-            FileUtils.mkdir_p(File.dirname(work_dir))
-            Makit::Commands::Runner.default.execute("git clone #{clone_dir} #{work_dir}")
-          end
-
-          Dir.chdir(work_dir) do
-            File.write(".gitignore", Makit::Content::GITIGNORE) unless File.exist?(".gitignore")
-          end
-        end
-
-        # Parse git log output into structured log entries
-        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
-
-        # Process a single line from git log output
-        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
-
-        # Create new git log entry from commit line
-        def create_new_log_entry(line, entries)
-          current_entry = GitLogEntry.new(line.split[1])
-          entries << current_entry
-          current_entry
-        end
-
-        # Update log entry with author information
-        def update_entry_author(line, current_entry)
-          current_entry.author = line.split[1..].join(" ")
-          current_entry
-        end
-
-        # Update log entry with date information
-        def update_entry_date(line, current_entry)
-          current_entry.date = line.split[1..].join(" ")
-          current_entry
-        end
-
-        # Update log entry with commit message
-        def update_entry_message(line, current_entry)
-          current_entry.message += line[4..]
-          current_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