makit 0.0.99 → 0.0.111

data/lib/makit/services/error_handler.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Makit
+  module Services
+    # Service class responsible for handling and formatting errors
+    # Provides user-friendly error messages and recovery suggestions
+    class ErrorHandler
+      # Error message templates with suggestions
+      ERROR_MESSAGES = {
+        invalid_url: {
+          message: "The repository URL '%<url>s' is not valid.",
+          suggestions: [
+            "Use HTTPS format: https://github.com/user/repo.git",
+            "Use SSH format: git@github.com:user/repo.git",
+            "Use simple format: user/repo",
+            "Ensure the URL points to a git repository",
+          ],
+        },
+        invalid_directory: {
+          message: "The directory path '%<directory>s' is not valid.",
+          suggestions: [
+            "Use absolute paths like /path/to/directory",
+            "Use relative paths like ./relative/path",
+            "Ensure the path doesn't contain null characters",
+            "Keep directory paths under 255 characters",
+          ],
+        },
+        invalid_commit: {
+          message: "The commit '%<commit>s' is not valid.",
+          suggestions: [
+            "Use 'latest' for the most recent commit",
+            "Use a full 40-character commit hash",
+            "Use a short 7+ character commit hash",
+            "Verify the commit exists in the repository",
+          ],
+        },
+        directory_not_found: {
+          message: "The directory '%<directory>s' does not exist or is not accessible.",
+          suggestions: [
+            "Check that the directory path is correct",
+            "Verify you have read permissions for the directory",
+            "Create the directory first if it doesn't exist",
+            "Use 'makit init' to create a new project directory",
+          ],
+        },
+        git_command_failed: {
+          message: "Git command failed: %<command>s",
+          suggestions: [
+            "Check that git is installed and available in PATH",
+            "Verify you have network connectivity for remote operations",
+            "Ensure you have proper permissions for the repository",
+            "Check that the remote repository URL is accessible",
+          ],
+        },
+        clone_failed: {
+          message: "Failed to clone repository '%<url>s'.",
+          suggestions: [
+            "Check that the repository URL is correct and accessible",
+            "Verify your network connectivity",
+            "Ensure you have proper authentication (SSH keys, tokens)",
+            "Check that you have write permissions to the destination directory",
+          ],
+        },
+        pull_failed: {
+          message: "Failed to pull changes from repository.",
+          suggestions: [
+            "Check that you have network connectivity",
+            "Verify the remote repository is accessible",
+            "Ensure your local repository is in a clean state",
+            "Try 'git status' to check for conflicts",
+          ],
+        },
+        build_failed: {
+          message: "Build process failed for repository '%<url>s' at commit '%<commit>s'.",
+          suggestions: [
+            "Check the build logs for specific error messages",
+            "Verify all dependencies are installed",
+            "Ensure the commit hash is valid and exists",
+            "Try building manually to isolate the issue",
+          ],
+        },
+      }.freeze
+
+      class << self
+        # Format an error with user-friendly message and suggestions
+        #
+        # @param error_type [Symbol] the type of error from ERROR_MESSAGES
+        # @param details [Hash] details to interpolate into the message
+        # @param original_error [Exception] the original exception (optional)
+        # @return [String] formatted error message with suggestions
+        def format_error(error_type, details = {}, original_error = nil)
+          error_config = ERROR_MESSAGES[error_type]
+          return "Unknown error type: #{error_type}" unless error_config
+
+          message = error_config[:message] % details
+          suggestions = error_config[:suggestions]
+
+          formatted_message = ["❌ Error: #{message}"]
+
+          if suggestions && !suggestions.empty?
+            formatted_message << ""
+            formatted_message << "💡 Suggestions:"
+            suggestions.each_with_index do |suggestion, index|
+              formatted_message << "  #{index + 1}. #{suggestion}"
+            end
+          end
+
+          if original_error && !original_error.message.empty?
+            formatted_message << ""
+            formatted_message << "🔍 Technical details:"
+            formatted_message << "  #{original_error.class}: #{original_error.message}"
+          end
+
+          formatted_message.join("\n")
+        end
+
+        # Handle ArgumentError exceptions with user-friendly formatting
+        #
+        # @param error [ArgumentError] the argument error to format
+        # @param context [Hash] additional context about where the error occurred
+        # @return [String] formatted error message
+        def handle_argument_error(error, context = {})
+          case error.message
+          when /URL parameter cannot be nil|URL parameter cannot be empty|Invalid URL format/
+            format_error(:invalid_url, { url: context[:url] || "unknown" }, error)
+          when /directory parameter cannot be nil|directory parameter cannot be empty|directory path/
+            format_error(:invalid_directory, { directory: context[:directory] || "unknown" }, error)
+          when /commit parameter cannot be nil|commit parameter cannot be empty|Invalid commit format/
+            format_error(:invalid_commit, { commit: context[:commit] || "unknown" }, error)
+          else
+            "❌ Error: #{error.message}\n💡 Please check your input parameters and try again."
+          end
+        end
+
+        # Handle Makit-specific exceptions with user-friendly formatting
+        #
+        # @param error [Makit::Error] the Makit error to format
+        # @param context [Hash] additional context about where the error occurred
+        # @return [String] formatted error message
+        def handle_makit_error(error, context = {})
+          case error
+          when Makit::DirectoryError
+            format_error(:directory_not_found, { directory: context[:directory] || "unknown" }, error)
+          when Makit::CloneError
+            format_error(:clone_failed, { url: context[:url] || "unknown" }, error)
+          when Makit::PullError
+            format_error(:pull_failed, {}, error)
+          when Makit::BuildError
+            format_error(:build_failed, { url: context[:url] || "unknown", commit: context[:commit] || "unknown" },
+                         error)
+          when Makit::GitError
+            format_error(:git_command_failed, { command: context[:command] || "unknown" }, error)
+          else
+            "❌ Error: #{error.message}\n💡 Please refer to the documentation or run with --verbose for more details."
+          end
+        end
+
+        # Log error with context for debugging
+        #
+        # @param error [Exception] the error to log
+        # @param context [Hash] additional context information
+        def log_error(error, context = {})
+          return unless defined?(Makit::LOGGER) && Makit::LOGGER
+
+          Makit::LOGGER.error "Error occurred: #{error.class} - #{error.message}"
+          Makit::LOGGER.error "Context: #{context.inspect}" unless context.empty?
+          Makit::LOGGER.debug "Backtrace: #{error.backtrace&.join("\n")}" if error.backtrace
+        end
+
+        # Wrap a block with comprehensive error handling
+        #
+        # @param context [Hash] context information for error messages
+        # @yield block to execute with error handling
+        # @return [Object] the result of the block
+        def with_error_handling(context = {})
+          yield
+        rescue ArgumentError => e
+          log_error(e, context)
+          formatted_message = handle_argument_error(e, context)
+          raise Makit::ValidationError, formatted_message
+        rescue Makit::Error => e
+          log_error(e, context)
+          formatted_message = handle_makit_error(e, context)
+          raise e.class, formatted_message
+        rescue StandardError => e
+          log_error(e, context)
+          formatted_message = "❌ An unexpected error occurred: #{e.message}\n💡 Please check the logs or run with --verbose for more details."
+          raise Makit::Error, formatted_message
+        end
+
+        # Validate input and provide helpful error messages
+        #
+        # @param validations [Array<Hash>] array of validation rules
+        # @example
+        #   validate_inputs([
+        #     { value: url, validator: :url, name: 'repository URL' },
+        #     { value: commit, validator: :commit, name: 'commit hash' }
+        #   ])
+        def validate_inputs(validations)
+          validations.each do |validation|
+            value = validation[:value]
+            validator = validation[:validator]
+            name = validation[:name] || "parameter"
+
+            case validator
+            when :url
+              Validator.validate_url_parameter(value)
+            when :directory
+              Validator.validate_directory_parameter(value)
+            when :commit
+              Validator.validate_commit_parameter(value)
+            when :required_string
+              Validator.validate_required_string(value, name)
+            when :boolean
+              Validator.validate_boolean_parameter(value, name)
+            end
+          rescue ArgumentError => e
+            context = { validator => value }
+            formatted_message = handle_argument_error(e, context)
+            raise Makit::ValidationError, formatted_message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/services/repository_manager.rb

@@ -0,0 +1,229 @@
+# 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::RUNNER.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)
+          commands << Makit::RUNNER.execute("git clone #{git_repository} #{clone_dir}") unless Dir.exist?(clone_dir)
+
+          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::RUNNER.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::RUNNER.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::RUNNER.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::RUNNER.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

data/lib/makit/services/validator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Makit
+  module Services
+    # Service class responsible for validating all input parameters
+    # Used by various Makit operations to ensure data integrity
+    class Validator
+      # Git-related validation constants
+      COMMIT_HASH_LENGTH = 40
+      COMMIT_LATEST = "latest"
+      MAX_PAGINATION_LIMIT = 1000
+      MAX_DIRECTORY_PATH_LENGTH = 255
+
+      class << self
+        # Validate directory parameter for initialization operations
+        #
+        # @param directory [String] the directory path to validate
+        # @raise [ArgumentError] if directory parameter is invalid
+        def validate_directory_parameter(directory)
+          raise ArgumentError, "directory parameter cannot be nil" if directory.nil?
+          raise ArgumentError, "directory parameter cannot be empty" if directory.to_s.strip.empty?
+          raise ArgumentError, "directory path contains invalid characters" if directory.to_s.include?("\0")
+          raise ArgumentError, "directory path is too long" if directory.to_s.length > MAX_DIRECTORY_PATH_LENGTH
+        end
+
+        # Validate URL parameter for git repository operations
+        #
+        # @param url [String] the repository URL to validate
+        # @raise [ArgumentError] if URL parameter is invalid
+        def validate_url_parameter(url)
+          raise ArgumentError, "URL parameter cannot be nil" if url.nil?
+          raise ArgumentError, "URL parameter cannot be empty" if url.to_s.strip.empty?
+
+          url_str = url.to_s.strip
+          # Basic URL format validation - accept git@, https://, http://, and simple names like "user/repo"
+          valid_patterns = [
+            %r{\Agit@[\w.-]+:[\w._/-]+\.git\z}, # SSH format: git@github.com:user/repo.git
+            %r{\Ahttps?://[\w.-]+/[\w._/-]+(\.git)?\z}, # HTTPS format: https://github.com/user/repo
+            %r{\A[\w.-]+/[\w._-]+\z}, # Simple format: user/repo
+          ]
+
+          return if valid_patterns.any? { |pattern| url_str.match?(pattern) }
+
+          raise ArgumentError, "Invalid URL format: #{url_str}"
+        end
+
+        # Validate commit parameter for git operations
+        #
+        # @param commit [String] the commit hash or "latest" to validate
+        # @raise [ArgumentError] if commit parameter is invalid
+        def validate_commit_parameter(commit)
+          raise ArgumentError, "commit parameter cannot be nil" if commit.nil?
+
+          commit_str = commit.to_s.strip
+          raise ArgumentError, "commit parameter cannot be empty" if commit_str.empty?
+
+          # Allow "latest" or valid commit hash formats
+          return if commit_str == COMMIT_LATEST
+          return if commit_str.match?(/\A[0-9a-f]{7,#{COMMIT_HASH_LENGTH}}\z/i)
+
+          raise ArgumentError, "Invalid commit format: #{commit_str}. Must be 'latest' or a valid git commit hash."
+        end
+
+        # Validate pagination parameters for log operations
+        #
+        # @param limit [Integer] maximum number of items to retrieve
+        # @param skip [Integer] number of items to skip
+        # @raise [ArgumentError] if pagination parameters are invalid
+        def validate_pagination_parameters(limit, skip)
+          unless limit.is_a?(Integer) && limit.positive?
+            raise ArgumentError,
+                  "limit parameter must be a positive integer"
+          end
+          raise ArgumentError, "skip parameter must be a non-negative integer" unless skip.is_a?(Integer) && skip >= 0
+          raise ArgumentError, "limit parameter is too large" if limit > MAX_PAGINATION_LIMIT
+        end
+
+        # Validate that a directory exists and is accessible
+        #
+        # @param directory [String] the directory path to check
+        # @param description [String] human-readable description for error messages
+        # @raise [Makit::DirectoryError] if directory doesn't exist or isn't accessible
+        def validate_directory_exists(directory, description = "directory")
+          return if Dir.exist?(directory)
+
+          raise Makit::DirectoryError, "#{description} does not exist: #{directory}"
+        end
+
+        # Validate boolean parameters
+        #
+        # @param value [Object] the value to check
+        # @param parameter_name [String] the parameter name for error messages
+        # @raise [ArgumentError] if value is not boolean
+        def validate_boolean_parameter(value, parameter_name)
+          return if [true, false].include?(value)
+
+          raise ArgumentError, "#{parameter_name} must be true or false, got #{value.class}"
+        end
+
+        # Validate string parameters that cannot be empty
+        #
+        # @param value [String] the string value to validate
+        # @param parameter_name [String] the parameter name for error messages
+        # @raise [ArgumentError] if string is nil or empty
+        def validate_required_string(value, parameter_name)
+          raise ArgumentError, "#{parameter_name} cannot be nil" if value.nil?
+          raise ArgumentError, "#{parameter_name} cannot be empty" if value.to_s.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/makit/setup/classlib.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require_relative "../configuration/project"
+
+module Makit
+  module Setup
+    class ClassLib
+      def self.run
+        #puts "Setting up Nuget project..."
+        project = Makit::Configuration::Project.default
+        Makit::DotNet::Project.new_project("classlib", project.name, "source/#{project.name}", "--framework net8.0")
+        Makit::DotNet::Project.new_project("TUnit", "#{project.name}.Tests", "tests/#{project.name}")
+        Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj", "source/#{project.name}/#{project.name}.csproj")
+        update_build_step(project)
+        update_test_step(project)
+
+        project.save
+        Makit::Logging.default_logger.info("Project setup completed")
+      end
+
+      def self.update_build_step(project)
+        build_commands = Array.new
+        build_commands << "dotnet build source/#{project.name}/#{project.name}.csproj --configuration Release"
+        steps = project.steps
+        if steps.any? { |step| step.name == "build" }
+          build_step = steps.find { |step| step.name == "build" }
+          build_step.commands = build_commands
+        else
+          build_step = Makit::Configuration::Step.new(name: "build", description: "Build the project artifacts", commands: build_commands)
+          build_step.commands = build_commands
+          project.add_step(build_step)
+        end
+        build_step.commands = build_commands
+
+        project.save
+      end
+
+      def self.update_test_step(project)
+        test_commands = Array.new
+        test_commands << "dotnet test tests/#{project.name}/#{project.name}.Tests.csproj"
+        steps = project.steps
+        if steps.any? { |step| step.name == "test" }
+          test_step = steps.find { |step| step.name == "test" }
+          test_step.commands = test_commands
+        else
+          test_step = Makit::Configuration::Step.new(name: "test", description: "Run the project tests", commands: test_commands)
+          test_step.commands = test_commands
+          project.add_step(test_step)
+        end
+        project.save
+      end
+    end
+  end
+end