releasehx 0.1.0

data/lib/releasehx/ops/draft_ops.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module ReleaseHx
+  # The DraftOps module provides methods for creating Release objects and
+  # generating draft files from source data like API payloads.
+  module DraftOps
+    # Converts a raw JSON payload from an issue management system into a
+    # ReleaseHx::RHYML::Release object.
+    #
+    # @param payload [Hash, Array] The raw payload from the API.
+    # @param config [ReleaseHx::Configuration] The application configuration.
+    # @param mapping [Hash] The mapping definition for converting payload fields.
+    # @param release_code [String] The version code for the release.
+    # @param release_date [Date, String, nil] The date for the release.
+    # @param scan [Boolean] Indicates if this is a scan-only operation.
+    # @return [ReleaseHx::RHYML::Release] The generated Release object.
+    def self.from_payload payload:, config:, mapping:, release_code:, release_date: nil, scan: false
+      adapter = ReleaseHx::RHYML::Adapter.new(mapping: mapping, config: config)
+
+      adapter.to_release(
+        payload,
+        release_code: release_code,
+        release_date: release_date || Date.today,
+        scan: scan)
+    end
+
+    # Shared method for preparing RHYML object template context
+    def self.prepare_template_context release:, config:
+      raise ArgumentError, 'release is nil' if release.nil?
+
+      # Establish available datasets
+      all_changes = release.changes.select { |ch| ch.respond_to?(:to_h) }
+      changes_mapped = all_changes.map(&:to_h)
+
+      sorted = build_sorted_changes(changes_mapped, config)
+
+      context_scope = {
+        'release' => release.to_h,
+        'changes' => changes_mapped,
+        'sorted'  => sorted,
+        'config'  => config
+      }
+
+      SchemaGraphy::Templating.render_all_templated_fields!(config, context_scope)
+
+      {
+        variables: {
+          'release' => release.to_h,
+          'changes' => changes_mapped,
+          'config'  => config,
+          'sorted'  => sorted
+        },
+        context_scope: context_scope
+      }
+    end
+
+    # Generates a string of content for a draft file (e.g., Markdown, YAML)
+    # from a Release object using the configured Liquid templates.
+    #
+    # @param release [ReleaseHx::RHYML::Release] The release object.
+    # @param config [ReleaseHx::Configuration] The application configuration.
+    # @param format [Symbol] The output format (:yaml, :md, :adoc, :html).
+    # @return [String] The rendered content.
+    def self.process_template_content release:, config:, format:
+      context = prepare_template_context(release: release, config: config)
+
+      tplt = case format.to_sym
+             when :yaml, :yml then 'rhyml.yaml.liquid'
+             when :md         then 'release.md.liquid'
+             when :adoc       then 'release.adoc.liquid'
+             when :html       then 'release.html.liquid'
+             else raise ArgumentError, "Unsupported format: #{format}"
+             end
+
+      tplt_path = WriteOps.resolve_template_path(tplt, config)
+      ReleaseHx.logger.debug "Using template: #{tplt_path}"
+
+      WriteOps.process_template(tplt_path, { 'vars' => context[:variables] }, config)
+    end
+
+    # Builds sorted changes structure (moved from EnrichOps)
+    def self.build_sorted_changes changes_mapped, config
+      sorted = {
+        'by' => {
+          'tag'  => {},
+          'type' => {},
+          'part' => {}
+        }
+      }
+
+      changes_mapped.each do |ch|
+        Array(ch['tags']).each do |tag|
+          sorted['by']['tag'][tag] ||= []
+          sorted['by']['tag'][tag] << ch
+        end
+
+        type = ch['type']
+        if type
+          sorted['by']['type'][type] ||= []
+          sorted['by']['type'][type] << ch
+        end
+
+        # treat 'parts' differently from type or tags as it is an Array in all cases
+        parts = ch['parts']
+        next unless parts
+
+        Array(parts).each do |part|
+          sorted['by']['part'][part] ||= []
+          sorted['by']['part'][part] << ch
+        end
+      end
+
+      # Ensures all config-defined parts/types/tags are initialized
+      Array(config['types']&.keys).each do |type|
+        sorted['by']['type'][type] ||= []
+      end
+
+      Array(config['parts']&.keys).each do |part|
+        sorted['by']['part'][part] ||= []
+      end
+
+      Array(config['tags']&.keys).each do |tag|
+        next if %w[_include _exclude].include?(tag)
+
+        sorted['by']['tag'][tag] ||= []
+      end
+
+      sorted
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def self.append_changes yaml_file_path:, version_code:, config:, mapping:, source_type:, payload: nil, force: false
+      # NOTE: force parameter is currently unused but kept for API consistency
+      # Load existing YAML Release
+      existing_release = ReleaseHx::RHYML::ReleaseLoader.load(yaml_file_path)
+      existing_tick_ids = existing_release.changes.map(&:tick).compact
+
+      ReleaseHx.logger.debug "Found #{existing_tick_ids.size} existing changes with tick IDs: #{existing_tick_ids}"
+
+      # Use provided payload or default to API fetch
+      payload ||= fetch_payload_for_version(version_code, source_type, config)
+
+      new_release = from_payload(
+        payload: payload,
+        config: config,
+        mapping: mapping,
+        release_code: version_code,
+        release_date: existing_release.date)
+
+      # Find new changes that weren't in the existing YAML
+      new_changes = new_release.changes.select do |change|
+        change.tick && !existing_tick_ids.include?(change.tick)
+      end
+
+      return 0 if new_changes.empty?
+
+      ReleaseHx.logger.info "Found #{new_changes.size} new changes to append"
+
+      # Generate append content and write it
+      WriteOps.append_changes_to_yaml(yaml_file_path, new_changes, config)
+
+      new_changes.size
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Legacy method kept for backward compatibility
+    def self.draft_output release:, config:, format:, outpath:
+      content = process_template_content(release: release, config: config, format: format)
+      WriteOps.safe_write(outpath, content) if outpath
+      content
+    end
+  end
+end

data/lib/releasehx/ops/enrich_ops.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module ReleaseHx
+  # Provides rich-text output generation from Release objects and draft source files.
+  #
+  # The EnrichOps module handles the conversion of Release data and various draft formats
+  #  (YAML, Markdown, AsciiDoc) into rich output formats (HTML, PDF) using appropriate
+  #  rendering engines and template processing.
+  module EnrichOps
+    # Generates rich-text output directly from a Release object.
+    #
+    # Processes Release data through Liquid templates to produce HTML or PDF output.
+    # HTML generation uses direct template rendering, while PDF generation creates
+    #  intermediate AsciiDoc content before conversion.
+    #
+    # @param release [ReleaseHx::RHYML::Release] The Release object to enrich.
+    # @param config [ReleaseHx::Configuration] The application configuration.
+    # @param format [Symbol] The output format (:html or :pdf).
+    # @param outpath [String, nil] The explicit output file path; auto-resolved if nil.
+    # @param force [Boolean] Whether to overwrite existing output files.
+    # @return [String] The path to the generated output file.
+    def self.enrich_from_rhyml release:, config:, format:, outpath: nil, force: false
+      # Use proper config-based output path resolution if not provided
+      outpath ||= resolve_enrich_path(release.code, format, config)
+
+      if File.exist?(outpath) && !force
+        ReleaseHx.logger.warn("File exists: #{outpath}. Use --force to overwrite.")
+        return outpath
+      end
+
+      ReleaseHx.logger.debug("Enriching release #{release.code} to #{outpath} (format: #{format.to_s.upcase})")
+
+      case format
+      when :html
+        # Direct Liquid template rendering to HTML
+        html_content = DraftOps.process_template_content(release: release, config: config, format: :html)
+        WriteOps.safe_write(outpath, html_content)
+      when :pdf
+        # Two-stage process: RHYML → AsciiDoc → PDF
+        asciidoc_content = DraftOps.process_template_content(release: release, config: config, format: :adoc)
+        convert_asciidoc(asciidoc_content, format: :pdf, outpath: outpath)
+      else
+        raise ArgumentError, "Unsupported enrich format: #{format}"
+      end
+
+      outpath
+    end
+
+    # Generates rich-text output from source draft files of various formats.
+    #
+    # Automatically detects the input file type and applies the appropriate conversion
+    #  strategy, supporting YAML (via RHYML), Markdown, and AsciiDoc source formats.
+    #
+    # @param file_path [String] The path to the source draft file.
+    # @param format [Symbol] The target output format (:html or :pdf).
+    # @param config [ReleaseHx::Configuration] The application configuration.
+    # @param outpath [String, nil] The explicit output file path; inferred if nil.
+    # @param force [Boolean] Whether to overwrite existing output files.
+    # @return [String] The path to the generated output file.
+    def self.enrich_from_file file_path, format:, config:, outpath: nil, force: false
+      raise "File not found: #{file_path}" unless File.exist?(file_path)
+
+      file_ext = File.extname(file_path).downcase
+      outpath ||= file_path.sub(/\.[^.]+$/, ".#{format}")
+
+      # Prevent accidental file overwrites
+      if File.exist?(outpath) && !force
+        ReleaseHx.logger.warn("File exists: #{outpath}. Use --force to overwrite.")
+        return outpath
+      end
+
+      # Route to appropriate conversion method based on source format
+      case file_ext
+      when '.yml', '.yaml'
+        # RHYML/YAML files: load as Release object and use Liquid templates
+        release = load_rhyml_from_yaml(file_path, config: config)
+        enrich_from_rhyml(release: release, config: config, format: format, outpath: outpath, force: true)
+      when '.md'
+        # Markdown files: use native converter
+        convert_markdown(file_path, format: format, config: config, outpath: outpath, force: true)
+      when '.adoc'
+        # AsciiDoc files: use native converter
+        convert_asciidoc(file_path, format: format, config: config, outpath: outpath, force: true)
+      else
+        raise "Unsupported source file format: #{file_ext}"
+      end
+    end
+
+    # Converts Markdown files to rich-text formats using native converters.
+    #
+    # Uses Kramdown for HTML generation and Tilt with Pandoc for PDF conversion.
+    # Note: Some parameters are reserved for API consistency across conversion methods.
+    #
+    # @param file_path [String] The path to the source Markdown file.
+    # @param format [Symbol] The target output format (:html or :pdf).
+    # @param config [ReleaseHx::Configuration] Reserved for future use.
+    # @param outpath [String] The target output file path.
+    # @param force [Boolean] Reserved for future use.
+    # @return [String] The path to the generated output file.
+    # rubocop:disable Lint/UnusedMethodArgument
+    def self.convert_markdown file_path, format:, config:, outpath:, force:
+      # NOTE: config and force parameters are currently unused but kept for API consistency
+      content = File.read(file_path)
+
+      case format.to_sym
+      when :html
+        require 'kramdown'
+        enriched = Kramdown::Document.new(content).to_html
+        WriteOps.safe_write(outpath, enriched)
+      when :pdf
+        # Use Tilt with Pandoc for direct Markdown to PDF conversion
+        require 'tilt'
+        require 'tilt/pandoc'
+
+        template = Tilt::PandocTemplate.new(file_path)
+        enriched = template.render(nil, to: 'pdf')
+        WriteOps.safe_write(outpath, enriched)
+        ReleaseHx.logger.info("PDF generated via Tilt/Pandoc: #{outpath}")
+      else
+        raise "Unsupported format for Markdown: #{format}"
+      end
+
+      outpath
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Converts AsciiDoc content or files to rich-text formats using Asciidoctor.
+    #
+    # Accepts either file paths or raw content strings as input. Uses Asciidoctor
+    # for HTML generation and Asciidoctor-PDF for direct PDF output.
+    #
+    # @param file_path_or_content [String] File path or raw AsciiDoc content.
+    # @param format [Symbol] The target output format (:html or :pdf).
+    # @param outpath [String] The target output file path.
+    # @param config [ReleaseHx::Configuration] Reserved for future use.
+    # @param force [Boolean] Reserved for future use.
+    # @return [String] The path to the generated output file.
+    # rubocop:disable Lint/UnusedMethodArgument
+    def self.convert_asciidoc file_path_or_content, format:, outpath:, config: nil, force: nil
+      # NOTE: config and force parameters are currently unused but kept for API consistency
+      # Determine if input is file path or raw content
+      is_file = file_path_or_content.is_a?(String) && File.exist?(file_path_or_content)
+      content = is_file ? File.read(file_path_or_content) : file_path_or_content
+
+      case format.to_sym
+      when :html
+        require 'asciidoctor'
+        enriched = Asciidoctor.convert(content, safe: :safe, backend: 'html5')
+      when :pdf
+        require 'asciidoctor'
+        require 'asciidoctor-pdf'
+        Asciidoctor.convert(content, to_file: outpath, safe: :safe, backend: 'pdf')
+        return outpath
+      else
+        raise "Unsupported format for AsciiDoc: #{format}"
+      end
+
+      # Prevent accidental file overwrites for HTML output
+      if File.exist?(outpath) && !force
+        ReleaseHx.logger.warn("File exists: #{outpath}. Use --force to overwrite.")
+        return outpath
+      end
+      WriteOps.safe_write(outpath, enriched)
+      outpath
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Loads RHYML data from a YAML file and creates a Release object.
+    #
+    # Processes YAML files containing either a single Release or a collection
+    # of Releases, extracting the first Release for processing.
+    #
+    # @param file_path [String] Path to the YAML file containing RHYML data.
+    # @param config [ReleaseHx::Configuration] Reserved for future use.
+    # @return [ReleaseHx::RHYML::Release] The constructed Release object.
+    # rubocop:disable Lint/UnusedMethodArgument
+    def self.load_rhyml_from_yaml file_path, config:
+      # NOTE: config parameter is currently unused but kept for API consistency
+      # Load RHYML data using SchemaGraphy for tag processing
+      rhyml_data = SchemaGraphy::Loader.load_yaml_with_tags(file_path)
+
+      # Extract Release data: first item from 'releases' array or single Release hash
+      release_data = rhyml_data['releases'] ? rhyml_data['releases'].first : rhyml_data
+
+      # Construct Release object with keyword arguments
+      ReleaseHx::RHYML::Release.new(
+        code: release_data['code'],
+        date: release_data['date'],
+        hash: release_data['hash'],
+        memo: release_data['memo'],
+        changes: release_data['changes'] || [])
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Resolves the output file path using configuration-based templated filenames.
+    #
+    # Constructs the full output path by combining configured directories and
+    # processing template variables in the filename pattern.
+    #
+    # @param version [String] The release version code for template substitution.
+    # @param format [Symbol] The output format for file extension determination.
+    # @param config [ReleaseHx::Configuration] Configuration containing path templates.
+    # @return [String] The resolved absolute output file path.
+    def self.resolve_enrich_path version, format, config
+      # Extract path configuration from config
+      output_dir = config.dig('paths', 'output_dir')
+      enrich_dir = config.dig('paths', 'enrich_dir')
+      filename_template = config.dig('paths', 'enrich_filename')
+
+      # Build template context for filename processing
+      context = {
+        'version' => version,
+        'format_ext' => format.to_s
+      }
+
+      # Process templated filename and construct full path
+      filename = SchemaGraphy::Templating.render_field_if_template(filename_template, context)
+      File.join(output_dir, enrich_dir, filename.strip)
+    end
+  end
+end

data/lib/releasehx/ops/template_ops.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module ReleaseHx
+  # Provides Liquid template rendering services with extended Jekyll integration and configurable template paths.
+  #
+  # The TemplateOps module handles the complex setup required for Liquid template processing, including
+  #  Jekyll plugin loading, template path resolution, and Sourcerer Jekyll runtime initialization for
+  #  advanced template features and includes.
+  module TemplateOps
+    # Renders a Liquid template string with provided variables and configuration context.
+    #
+    # Sets up a complete, enhanced Liquid rendering environment with plugin support,
+    #  configurable template include paths, and proper site context for advanced template features.
+    # Supports both user-defined and gem-bundled template directories with fallback resolution.
+    #
+    # @param input [String] The raw Liquid template string to process.
+    # @param vars [Hash] Variable context for template variable substitution.
+    # @param config [ReleaseHx::Configuration] Configuration object containing template path settings.
+    # @return [String] The fully rendered template output.
+    # @raise [StandardError] If template rendering fails due to syntax errors or missing variables.
+    def self.render_liquid_string input, vars, config
+      plugin_dirs = [File.expand_path('../../../jekyll_plugins', __dir__)]
+      user_templates_dir = config.dig('paths', 'templates_dir')
+      gem_templates_dir  = File.expand_path('../rhyml/templates', __dir__)
+
+      # Build template include path hierarchy: user templates take precedence over gem defaults
+      includes = []
+      if user_templates_dir
+        unless Pathname.new(user_templates_dir).absolute?
+          user_templates_dir = File.expand_path(user_templates_dir, Dir.pwd)
+        end
+        includes << user_templates_dir if File.directory?(user_templates_dir)
+      end
+      includes << gem_templates_dir
+
+      Sourcerer::Jekyll.initialize_liquid_runtime
+
+      # Bootstrap an ephemeral Jekyll site context for template processing with full feature support
+      site = Sourcerer::Jekyll::Bootstrapper.fake_site(
+        includes_load_paths: includes,
+        plugin_dirs: plugin_dirs)
+
+      # Parse template and render with comprehensive register context
+      tpl = ::Liquid::Template.parse(input)
+      rendered = tpl.render(
+        vars,
+        registers: {
+          site: site,
+          file_system: Sourcerer::Jekyll::Liquid::FileSystem.new(includes.first),
+          includes_load_paths: includes,
+          releasehx_debug: true
+        })
+
+      raise "Template rendering failed:\n#{rendered}" if rendered.include?('Liquid error')
+
+      rendered
+    end
+  end
+end

data/lib/releasehx/ops/write_ops.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tilt'
+require_relative 'template_ops'
+
+module ReleaseHx
+  # Provides file writing operations and template processing utilities for output generation.
+  #
+  # The WriteOps module handles safe file creation with directory management, template resolution
+  # with user/gem fallback paths, and content post-processing for consistent output formatting.
+  module WriteOps
+    # Safely writes content to a file, creating parent directories as needed.
+    #
+    # Ensures parent directory structure exists before writing and provides
+    #  logging feedback for successful file creation operations.
+    #
+    # @param path [String] The target file path for writing.
+    # @param content [String] The content to write to the file.
+    # @return [Symbol] Returns :written to indicate successful completion.
+    def self.safe_write path, content
+      dirname = File.dirname(path)
+      FileUtils.mkdir_p(dirname)
+      File.write(path, content)
+      ReleaseHx.logger.info "Wrote file: #{path}"
+      :written
+    end
+
+    # Establishes the absolute path to the gem's bundled template directory.
+    #
+    # @return [String] The path to the default gem template directory.
+    def self.gem_template_root
+      File.expand_path('../rhyml/templates', __dir__)
+    end
+
+    # Resolves template file path using hierarchical search with user directory precedence.
+    #
+    # Searches for templates first in user-configured directories, then falls back to
+    #  gem-bundled templates, providing clear error messages when templates are not found.
+    #
+    # @param name [String] The template filename to locate.
+    # @param config [ReleaseHx::Configuration] Configuration object containing template path settings.
+    # @return [String] The absolute path to the located template file.
+    # @raise [StandardError] If the template cannot be found in any search path.
+    def self.resolve_template_path name, config
+      user_dir = config.dig('paths', 'templates_dir')
+      fallback_dir = gem_template_root
+
+      search_paths = []
+      search_paths << File.expand_path(name, user_dir) if user_dir
+      search_paths << File.join(fallback_dir, name)
+
+      found = search_paths.find { |p| File.exist?(p) }
+
+      return found if found
+
+      raise "Template not found: #{name} (searched #{search_paths.join(' , ')})"
+    end
+
+    # Processes a Liquid template file with variable substitution and content post-processing.
+    #
+    # Loads and renders templates using the TemplateOps system, then applies configurable
+    # post-processing rules such as excess line removal for consistent output formatting.
+    #
+    # @param template_path [String] The absolute path to the template file.
+    # @param vars [Hash] Variable context for template rendering.
+    # @param config [ReleaseHx::Configuration] Configuration object with processing settings.
+    # @return [String] The fully processed template output.
+    def self.process_template template_path, vars, config
+      template_content = File.read(template_path)
+      includes_load_paths = []
+      user_templates_dir = config.dig('paths', 'templates_dir')
+      gem_templates_dir  = File.expand_path('../../rhyml/templates', __dir__)
+
+      if user_templates_dir
+        unless Pathname.new(user_templates_dir).absolute?
+          user_templates_dir = File.expand_path(user_templates_dir, Dir.pwd)
+        end
+        includes_load_paths << user_templates_dir
+      end
+
+      includes_load_paths << gem_templates_dir
+
+      rendered = TemplateOps.render_liquid_string(template_content, vars, config)
+
+      # Apply configurable post-processing for line spacing control
+      blank_lines = config.dig('modes', 'remove_excess_lines')
+      if blank_lines.zero?
+        rendered = rendered.gsub(/\n{2,}/, "\n")
+      elsif blank_lines
+        rendered = rendered.gsub(/\n{#{blank_lines + 1},}/, "\n" * (blank_lines + 1))
+      end
+
+      rendered
+    end
+
+    # Appends new changes to an existing YAML file using template-based formatting.
+    #
+    # Generates properly formatted YAML content for new changes using a template,
+    #  then appends it to the specified file while maintaining file structure.
+    #
+    # @param yaml_file_path [String] The path to the target YAML file for appending.
+    # @param new_changes [Array<ReleaseHx::RHYML::Change>] Array of Change objects to append.
+    # @param config [ReleaseHx::Configuration] Configuration object for template processing.
+    # @return [void]
+    def self.append_changes_to_yaml yaml_file_path, new_changes, config
+      # Generate properly formatted YAML content using template
+      context = {
+        'changes' => new_changes.map(&:to_h),
+        'config' => config
+      }
+
+      template_path = resolve_template_path('rhyml-change-append.yaml.liquid', config)
+      append_content = process_template(template_path, { 'vars' => context }, config)
+
+      # Append to existing file maintaining structure
+      File.open(yaml_file_path, 'a') do |file|
+        file.write(append_content)
+      end
+
+      ReleaseHx.logger.debug "Appended #{new_changes.size} changes to #{yaml_file_path}"
+    end
+  end
+end

data/lib/releasehx/rest/clients/github.yml

@@ -0,0 +1,46 @@
+# GitHub REST API Client Configuration  
+# For GitHub v3 API - Issues endpoint
+name: github
+desc: |
+  GitHub REST API client for fetching issues and pull requests.
+  Supports GitHub v3 API with token-based authentication.
+  Includes dynamic milestone resolution.
+
+auth:
+  mode: header
+  header: Authorization
+  format: "Bearer {{ env[auth.key_env] | default: env.GITHUB_TOKEN }}"
+
+# GitHub API endpoint template  
+# Variables available: project, version, env (flattened from api config)
+href: "{{ env.GITHUB_API_HOST | default: 'https://api.github.com' }}/repos/{{ project | default: env.GITHUB_REPO }}/issues"
+query_type: key_value
+
+# Dynamic resolution for milestone titles -> numbers
+resolutions:
+  milestone:
+    endpoint: "/repos/{{ project | default: env.GITHUB_REPO }}/milestones"
+    query_param: "milestone"     # which param in main query needs resolution
+    lookup_field: "title"        # field to match against (milestone title)
+    return_field: "number"       # field to use as resolved value
+    match_value: "{{ version }}"  # what to match (template)
+
+# Structured query parameters - much cleaner than query_string!
+# The {{ milestone }} template will be resolved to the milestone number
+query_params:
+  milestone: "{{ milestone }}"    # will be resolved to milestone number
+  state: "closed"
+  sort: "updated" 
+  direction: "desc"
+  per_page: 100
+
+# Pagination settings using GitHub's Link header
+pagination:
+  param: page
+  page_size_param: per_page
+  page_size: 100
+  max_pages: 10
+
+# Response format expectation
+response_format: json
+root_issues_path: "."

data/lib/releasehx/rest/clients/gitlab.yml

@@ -0,0 +1,31 @@
+# GitLab REST API Client Configuration
+# For GitLab v4 API - Issues endpoint  
+name: gitlab
+desc: |
+  GitLab REST API client for fetching issues and merge requests.
+  Supports GitLab v4 API with token-based authentication.
+
+auth:
+  mode: header
+  header: PRIVATE-TOKEN
+  format: "{{ env.GITLAB_TOKEN }}"
+
+# GitLab API endpoint template  
+# Variables available: origin.project, version, env
+href: "{{ env.GITLAB_API_HOST | default: 'https://gitlab.com' }}/api/v4/projects/{{ origin.project | default: env.GITLAB_PROJECT_ID }}/issues"
+query_type: key_value
+
+# Query parameters for filtering issues
+query_string: |
+  milestone={{ version }}&state=closed&per_page=100
+
+# Pagination settings using GitLab's offset pagination
+pagination:
+  param: page
+  page_size_param: per_page
+  page_size: 100
+  max_pages: 10
+
+# Response format expectation
+response_format: json
+root_issues_path: "."

data/lib/releasehx/rest/clients/jira.yml

@@ -0,0 +1,31 @@
+# Jira REST API Client Configuration
+# Jira Cloud API with ADF (Atlassian Document Format) support
+name: jira
+desc: |
+  Jira Cloud REST API client for fetching issues and creating release notes.
+  Supports ADF format in description and custom fields.
+
+auth:
+  mode: basic
+  header: Authorization
+  format: "Basic {{ env.JIRA_USERNAME | append: ':' | append: env.JIRA_API_TOKEN | base64 }}"
+
+# Jira REST API endpoint template
+# Variables available: origin.project, version, env
+href: "{{ env.JIRA_HOST | default: 'https://your-domain.atlassian.net' }}/rest/api/3/search/jql"
+
+# Query parameters for filtering issues
+query_params:
+  jql: 'project="{{ origin.project | default: env.JIRA_PROJECT }}" AND fixVersion="{{ version }}" ORDER BY updated DESC'
+  fields: "key,summary,description,issuetype,components,labels,fixVersions,assignee"
+
+# Pagination settings for large result sets
+pagination:
+  param: startAt
+  page_size_param: maxResults
+  page_size: 50
+  max_pages: 20
+
+# Response format expectation
+response_format: json
+root_issues_path: issues