RubyGems - ace-git-commit - Versions diffs - 0.23.0 - Mend

ace-git-commit 0.23.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

checksums.yaml +7 -0
data/.ace-defaults/git/commit.yml +22 -0
data/.ace-defaults/nav/protocols/guide-sources/ace-git-commit.yml +10 -0
data/.ace-defaults/nav/protocols/prompt-sources/ace-git-commit.yml +19 -0
data/.ace-defaults/nav/protocols/wfi-sources/ace-git-commit.yml +19 -0
data/CHANGELOG.md +404 -0
data/COMPARISON.md +176 -0
data/LICENSE +21 -0
data/README.md +44 -0
data/Rakefile +14 -0
data/exe/ace-git-commit +13 -0
data/handbook/guides/version-control-system-message.g.md +507 -0
data/handbook/prompts/git-commit.md +22 -0
data/handbook/prompts/git-commit.system.md +150 -0
data/handbook/skills/as-git-commit/SKILL.md +57 -0
data/handbook/workflow-instructions/git/commit.wf.md +75 -0
data/lib/ace/git_commit/atoms/git_executor.rb +62 -0
data/lib/ace/git_commit/atoms/gitignore_checker.rb +118 -0
data/lib/ace/git_commit/cli/commands/commit.rb +147 -0
data/lib/ace/git_commit/cli.rb +23 -0
data/lib/ace/git_commit/models/commit_group.rb +53 -0
data/lib/ace/git_commit/models/commit_options.rb +75 -0
data/lib/ace/git_commit/models/split_commit_result.rb +60 -0
data/lib/ace/git_commit/models/stage_result.rb +71 -0
data/lib/ace/git_commit/molecules/commit_grouper.rb +123 -0
data/lib/ace/git_commit/molecules/commit_summarizer.rb +43 -0
data/lib/ace/git_commit/molecules/diff_analyzer.rb +111 -0
data/lib/ace/git_commit/molecules/file_stager.rb +153 -0
data/lib/ace/git_commit/molecules/message_generator.rb +438 -0
data/lib/ace/git_commit/molecules/path_resolver.rb +365 -0
data/lib/ace/git_commit/molecules/split_commit_executor.rb +272 -0
data/lib/ace/git_commit/organisms/commit_orchestrator.rb +330 -0
data/lib/ace/git_commit/version.rb +7 -0
data/lib/ace/git_commit.rb +41 -0
metadata +149 -0

data/handbook/prompts/git-commit.system.md ADDED Viewed

@@ -0,0 +1,150 @@
+# Git Commit Message Generator System Prompt
+You are an expert git commit message generator. Your task is to create clear, concise, and informative commit messages based on git diffs and optional context provided by the developer.
+## Commit Message Format
+Follow the Conventional Commits specification:
+```
+<type>(<scope>): <subject>
+<body>
+<footer>
+```
+### Types
+- **feat**: A new feature
+- **fix**: A bug fix
+- **docs**: Documentation OF the software (user guides, API docs, README)
+- **style**: Changes that do not affect the meaning of the code (white-space, formatting, etc)
+- **refactor**: A code change that neither fixes a bug nor adds a feature
+- **perf**: A code change that improves performance
+- **test**: Adding missing tests or correcting existing tests
+- **build**: Changes that affect the build system or external dependencies
+- **ci**: Changes to CI configuration files and scripts
+- **chore**: Other changes that don't modify src or test files
+- **revert**: Reverts a previous commit
+- **spec**: Specifications and artifacts from making software (task specs, planning docs, retros, ideas)
+### Scope
+The scope should be the name of the component, module, or area affected. Examples:
+- For Ruby gems: gem name (e.g., `ace-llm`, `ace-core`)
+- For specific features: feature name (e.g., `auth`, `api`, `cli`)
+- For directories: directory name (e.g., `docs`, `config`)
+### Subject
+- Use imperative mood ("add" not "adds" or "added")
+- Don't capitalize the first letter
+- No period at the end
+- Maximum 72 characters
+### Body (optional)
+- Explain the motivation for the change
+- Explain what and why, not how
+- Wrap at 72 characters
+- Separate from subject with a blank line
+### Footer (optional)
+- Reference issues and pull requests
+- Note breaking changes with "BREAKING CHANGE:"
+## Analysis Process
+1. **Analyze the diff** to understand:
+   - What files were changed
+   - What type of changes were made (additions, deletions, modifications)
+   - The nature of the changes (feature, fix, refactor, etc.)
+2. **Determine the type** based on the changes:
+   - New functionality → feat
+   - Bug fixes → fix
+   - Code cleanup without changing behavior → refactor
+   - Documentation of the software → docs
+   - Task specs, planning docs, retros, ideas → spec
+   - Use `chore` only for maintenance/build/config-only changes
+3. **Identify the scope** from:
+   - File paths and directories
+   - Component or module names
+   - Affected areas of the codebase
+4. **Craft the subject** that:
+   - Clearly describes what was done
+   - Is concise and specific
+   - Uses imperative mood
+   - Passes the "This commit will..." test — the subject must describe the action performed on the codebase, not the content of the changed files
+5. **Add body if needed** when:
+   - The change is complex
+   - The motivation isn't obvious
+   - There are important details to note
+## Examples
+### Simple feature addition
+```
+feat(auth): add JWT token validation
+Implement token validation middleware to secure API endpoints.
+Tokens are validated against the secret key stored in environment variables.
+```
+### Bug fix
+```
+fix(api): handle null values in user profile response
+Prevent crashes when optional profile fields are missing by adding
+null checks before accessing nested properties.
+```
+### Refactoring
+```
+refactor(database): extract connection logic to separate module
+Improve code organization by moving database connection handling
+to a dedicated module. This makes the code more testable and
+reduces coupling between components.
+```
+### Documentation update
+```
+docs(readme): update installation instructions
+Add details about Ruby version requirements and bundle installation steps.
+Include troubleshooting section for common setup issues.
+```
+## Guidelines
+1. **Be specific**: Avoid vague messages like "fix bug" or "update code"
+2. **Be concise**: Get to the point without unnecessary words
+3. **Be consistent**: Follow the same format and style throughout the project
+4. **Focus on why**: The diff shows what changed, the message should explain why
+5. **One logical change**: Each commit should represent one logical change
+6. **Avoid generic chore drift**: If code behavior changes, prefer `feat`, `fix`, or `refactor` over `chore`
+## Special Considerations
+When intention/context is provided by the developer:
+- Use it to better understand the purpose of the changes
+- Incorporate relevant details into the commit message
+- Maintain consistency with the developer's intent
+When multiple files are changed:
+- Look for the common theme or purpose
+- If changes span multiple components, use a broader scope or omit it
+- Consider if the changes should be in separate commits (mention if so)
+Describe the action, not the content:
+- The subject must describe what this commit DOES to the codebase
+- Do NOT summarize the content of changed files as if that content is the change itself
+- Example: deleting a task spec about "rename X to Y" → `spec(task-272): remove specflow-rename task` NOT `spec(taskflow-rename): rename ace-taskflow to ace-specflow`
+- Example: deleting a deprecated module → `refactor(auth): remove legacy OAuth handler` NOT `refactor(auth): OAuth 1.0 authentication flow`
+When all changes are deletions:
+- Use action verbs like "remove", "delete", "drop" in the subject
+- Explain WHY the files were removed in the body if not obvious
+Generate only the commit message, without any additional commentary, explanation, or markdown formatting.

data/handbook/skills/as-git-commit/SKILL.md ADDED Viewed

@@ -0,0 +1,57 @@
+---
+name: as-git-commit
+description: Generate intelligent git commit message from staged or all changes
+# bundle: wfi://git/commit
+# agent: Bash
+user-invocable: true
+allowed-tools:
+  - Bash(ace-git-commit:*)
+  - Bash(ace-git:*)
+  - Bash(ace-bundle:*)
+  - Read
+argument-hint: [intention]
+last_modified: 2026-01-10
+source: ace-git-commit
+integration:
+  targets:
+    - claude
+    - codex
+    - gemini
+    - opencode
+    - pi
+  providers:
+    claude:
+      frontmatter:
+        context: fork
+        model: haiku
+assign:
+  source: wfi://git/commit
+  steps:
+    - name: commit
+      description: Generate and create a commit with a descriptive message
+      tags: [git, versioning]
+skill:
+  kind: workflow
+  execution:
+    workflow: wfi://git/commit
+---
+## Arguments
+Use the skill `argument-hint` values as the explicit inputs for this skill.
+## Variables
+- INTENTION
+- CHANGED_FILES
+## Execution
+- You are working in the current project.
+- Run `ace-bundle wfi://git/commit` in the current project to load the workflow instructions.
+- Read the loaded workflow and execute it end-to-end in this project.
+- Follow the workflow as the source of truth.
+- If `INTENTION` is provided explicitly, use it. Otherwise derive it from recent changes.
+- If `CHANGED_FILES` are provided explicitly, use them. Otherwise derive them from changed files in this session.
+- Do the work described by the workflow instead of only summarizing it.
+- When the workflow requires edits, tests, or commits, perform them in this project.

data/handbook/workflow-instructions/git/commit.wf.md ADDED Viewed

@@ -0,0 +1,75 @@
+---
+doc-type: workflow
+title: Commit Workflow
+purpose: commit workflow instruction
+ace-docs:
+  last-updated: 2026-03-15
+  last-checked: 2026-03-21
+---
+# Commit Workflow
+## Purpose
+Create atomic Git commits with conventional format messages using ace-git-commit.
+## Context
+ace-git-commit automatically:
+- Stages ALL changes by default (monorepo-friendly)
+- Generates conventional commit messages via LLM
+- Uses `glite` model (Gemini 2.0 Flash Lite) by default
+## Variables
+- `$intention`: Optional description to guide message generation (from argument)
+## Instructions
+1. **Repository status is embedded above** in `<current_repository_status>`.
+   The current git state (status + diff summary) is already loaded in this workflow.
+   Review it to understand what will be committed:
+   - Which files are modified? (from status output)
+   - How significant are the changes? (from diff --stat)
+   - Is this the right scope for a single commit?
+   No need to run git commands - the context is already provided.
+   **Important**: Untracked files (`??` in status) ARE committable changes — `ace-git-commit` stages them by default.
+   If status shows ANY modifications or untracked files, proceed to step 2.
+   Only report "nothing to commit" if status is truly empty (no lines beyond the branch header).
+2. **Execute commit** based on scope:
+   - All changes: `ace-git-commit`
+   - With intention: `ace-git-commit -i "$intention"`
+   - Specific files: `ace-git-commit file1 file2`
+   - Only staged: `ace-git-commit --only-staged`
+   - Dry run first: `ace-git-commit --dry-run -i "$intention"`
+3. **Verify result**:
+   ```bash
+   ace-git status
+   ```
+## Options Reference
+- `-i, --intention`: Provide context for better messages
+- `-m, --message`: Use direct message (bypass LLM)
+- `--model MODEL`: Override LLM model (e.g., gflash)
+- `-s, --only-staged`: Commit only staged changes
+- `-n, --dry-run`: Preview without committing
+- `-d, --debug`: Enable debug output
+## Success Criteria
+- Commit created with conventional format
+- Only intended changes included
+- Working directory in expected state
+## Response Template
+**Changes Committed:** [Brief summary of what was committed]
+**Commit Message:** [The generated/used message]
+**Files Modified:** [Number of files and brief description]
+**Status:** ✓ Complete | ✗ Failed with [reason]

data/lib/ace/git_commit/atoms/git_executor.rb ADDED Viewed

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require "ace/git"
+module Ace
+  module GitCommit
+    module Atoms
+      # GitExecutor handles low-level git command execution
+      # Delegates to ace-git for command execution
+      class GitExecutor
+        # Execute a git command and return output
+        # @param args [Array<String>] Git command arguments
+        # @param capture_stderr [Boolean] Whether to capture stderr (ignored, always captured)
+        # @return [String] Command output
+        # @raise [GitError] If command fails
+        def execute(*args, capture_stderr: false)
+          cmd = ["git"] + args
+          result = Ace::Git::Atoms::CommandExecutor.execute(*cmd)
+          unless result[:success]
+            error_msg = "Git command failed: #{cmd.join(" ")}"
+            error_msg += "\nError: #{result[:error]}" if result[:error] && !result[:error].empty?
+            raise GitError, error_msg
+          end
+          # Combine output and error if capture_stderr is true
+          if capture_stderr && result[:error] && !result[:error].empty?
+            result[:output] + result[:error]
+          else
+            result[:output]
+          end
+        end
+        # Check if we're in a git repository
+        # @return [Boolean] True if in a git repo
+        def in_repository?
+          Ace::Git::Atoms::CommandExecutor.in_git_repo?
+        end
+        # Get repository root
+        # @return [String] Repository root path
+        def repository_root
+          Ace::Git::Atoms::CommandExecutor.repo_root
+        end
+        # Check if there are any changes
+        # @return [Boolean] True if there are changes
+        def has_changes?
+          Ace::Git::Atoms::CommandExecutor.has_unstaged_changes? ||
+            Ace::Git::Atoms::CommandExecutor.has_staged_changes? ||
+            Ace::Git::Atoms::CommandExecutor.has_untracked_changes?
+        end
+        # Check if there are staged changes
+        # @return [Boolean] True if there are staged changes
+        def has_staged_changes?
+          Ace::Git::Atoms::CommandExecutor.has_staged_changes?
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/atoms/gitignore_checker.rb ADDED Viewed

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+module Ace
+  module GitCommit
+    module Atoms
+      # GitignoreChecker detects files that match gitignore patterns
+      # Uses git check-ignore to determine if paths are ignored
+      class GitignoreChecker
+        # Check if a single file/path is gitignored
+        # @param path [String] File or directory path to check
+        # @param git_executor [GitExecutor] Git executor instance
+        # @return [Boolean] True if path is gitignored
+        def ignored?(path, git_executor)
+          result = check_ignore(path, git_executor)
+          result[:ignored]
+        end
+        # Check if a file is tracked in git (exists in the index)
+        # @param path [String] File path to check
+        # @param git_executor [GitExecutor] Git executor instance
+        # @return [Boolean] True if file is tracked
+        def tracked?(path, git_executor)
+          # git ls-files returns the path if it's tracked, empty if not
+          result = git_executor.execute("ls-files", "--error-unmatch", path)
+          !result.nil? && !result.strip.empty?
+        rescue GitError
+          false
+        end
+        # Categorize paths into: valid (not gitignored), force_add (gitignored but tracked), skipped (gitignored and untracked)
+        # @param paths [Array<String>] Paths to check
+        # @param git_executor [GitExecutor] Git executor instance
+        # @return [Hash] {:valid => [...], :force_add => [...], :skipped => [...]}
+        #   - :valid - paths that are NOT gitignored
+        #   - :force_add - paths that ARE gitignored but are tracked in git (use git add -f)
+        #   - :skipped - paths that ARE gitignored and NOT tracked (skip these)
+        def categorize_paths(paths, git_executor)
+          return {valid: [], force_add: [], skipped: []} if paths.nil? || paths.empty?
+          valid = []
+          force_add = []
+          skipped = []
+          paths.each do |path|
+            result = check_ignore(path, git_executor)
+            if result[:ignored]
+              # Path matches gitignore - check if it's tracked
+              if tracked?(path, git_executor)
+                # Tracked file in gitignored location - force add it
+                force_add << {path: path, pattern: result[:pattern]}
+              else
+                # Untracked and gitignored - skip it
+                skipped << {path: path, pattern: result[:pattern]}
+              end
+            else
+              valid << path
+            end
+          end
+          {valid: valid, force_add: force_add, skipped: skipped}
+        end
+        # Legacy method for backward compatibility
+        # @param paths [Array<String>] Paths to check
+        # @param git_executor [GitExecutor] Git executor instance
+        # @return [Hash] {:valid => [...], :ignored => [...]}
+        def filter_ignored(paths, git_executor)
+          result = categorize_paths(paths, git_executor)
+          {
+            valid: result[:valid] + result[:force_add].map { |f| f[:path] },
+            ignored: result[:skipped]
+          }
+        end
+        private
+        # Check a single path with git check-ignore
+        # @param path [String] Path to check
+        # @param git_executor [GitExecutor] Git executor instance
+        # @return [Hash] {:ignored => Boolean, :pattern => String|nil}
+        def check_ignore(path, git_executor)
+          # git check-ignore returns:
+          # - exit 0 and the matching pattern if path IS ignored
+          # - exit 1 (non-zero) if path is NOT ignored
+          # Use -v to get verbose output including the pattern that matched
+          cmd = ["check-ignore", "-v", path]
+          begin
+            output = git_executor.execute(*cmd)
+            # If we get here, the file IS ignored
+            # Output format: "<pattern>:<line>:<source>:<path>"
+            pattern = extract_pattern(output)
+            {ignored: true, pattern: pattern}
+          rescue GitError
+            # If command fails (exit 1), file is NOT ignored
+            {ignored: false, pattern: nil}
+          end
+        end
+        # Extract the gitignore pattern from check-ignore -v output
+        # @param output [String] Output from git check-ignore -v
+        # @return [String, nil] The pattern that matched, or nil
+        def extract_pattern(output)
+          return nil if output.nil? || output.strip.empty?
+          # Format: ".gitignore:3:.ace-taskflow/**/reviews/    .ace-taskflow/v.0.9.0/reviews/review-report-gpro.md"
+          # We want the third field (the pattern)
+          parts = output.strip.split("\t")
+          if parts.length >= 2
+            # Pattern is in the third colon-separated field of the first part
+            source_parts = parts[0].split(":")
+            source_parts[2] if source_parts.length >= 3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/cli/commands/commit.rb ADDED Viewed

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+module Ace
+  module GitCommit
+    module CLI
+      module Commands
+        # ace-support-cli Command class for the commit command
+        #
+        # This command generates and executes git commits with LLM-generated
+        # or user-provided messages, maintaining complete parity with the
+        # Thor implementation.
+        class Commit < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+          desc <<~DESC.strip
+            Generate and execute git commit
+            Generate a commit message using LLM or use a provided message,
+            then stage files and commit.
+            When no files are specified, all changes are staged.
+            When files are provided, only those files are staged and committed.
+            Configuration:
+              Global config:  ~/.ace/git/commit.yml
+              Project config: .ace/git/commit.yml
+              Package config: {package}/.ace/git/commit.yml
+          DESC
+          example [
+            "                             # Commit all changes",
+            "src/auth.rb                  # Commit specific file",
+            "-i 'fix bug'                # With intention",
+            "-m 'feat: add'              # With explicit message",
+            "--only-staged                # Only staged changes",
+            "--no-split                   # Force a single commit"
+          ]
+          # Define files as variadic argument (can be 0 or more)
+          argument :files, required: false, type: :array, desc: "Files to commit"
+          # Commit options
+          option :intention, type: :string, aliases: %w[-i], desc: "Provide context for LLM message generation"
+          option :message, type: :string, aliases: %w[-m], desc: "Use provided message directly (no LLM)"
+          option :model, type: :string, desc: "Override default LLM model (e.g., glite, gflash)"
+          option :only_staged, type: :boolean, aliases: %w[-s], desc: "Commit only currently staged changes"
+          option :staged, type: :boolean, desc: "Alias for --only-staged"
+          option :dry_run, type: :boolean, aliases: %w[-n], desc: "Show what would be committed without doing it"
+          option :force, type: :boolean, aliases: %w[-f], desc: "Force operation (for future use)"
+          option :no_split, type: :boolean, desc: "Force a single commit even when multiple config scopes are detected"
+          # Standard options (inherited from Base but need explicit definition for ace-support-cli)
+          option :version, type: :boolean, desc: "Show version information"
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+          def call(**options)
+            # Extract files array from options (ace-support-cli passes args as :files)
+            @files = Array(options[:files] || [])
+            # Remove ace-support-cli specific keys (args is leftover arguments)
+            @options = options.reject { |k, _| k == :files || k == :args }
+            if @options[:version]
+              puts "ace-git-commit #{Ace::GitCommit::VERSION}"
+              return 0
+            end
+            execute
+          end
+          private
+          def execute
+            display_config_summary
+            orchestrator = Organisms::CommitOrchestrator.new
+            success = orchestrator.execute(commit_options)
+            raise Ace::Support::Cli::Error.new("Commit failed") unless success
+          rescue GitError => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          rescue Interrupt
+            raise Ace::Support::Cli::Error.new("Commit cancelled", exit_code: 130)
+          end
+          def display_config_summary
+            return if @options[:quiet]
+            require "ace/core"
+            Ace::Core::Atoms::ConfigSummary.display(
+              command: "commit",
+              config: load_effective_config,
+              defaults: default_config,
+              options: @options,
+              quiet: false  # Don't suppress ConfigSummary itself
+            )
+          end
+          def commit_options
+            Models::CommitOptions.new(
+              intention: @options[:intention],
+              message: @options[:message],
+              model: @options[:model],
+              files: @files,
+              only_staged: @options[:only_staged] || @options[:staged] || false,
+              dry_run: @options[:dry_run] || false,
+              debug: @options[:debug] || false,
+              force: @options[:force] || false,
+              verbose: @options[:verbose] != false,  # Default true
+              quiet: @options[:quiet] || false,
+              no_split: @options[:no_split] || false
+            )
+          end
+          def load_effective_config
+            gem_root = Gem.loaded_specs["ace-git-commit"]&.gem_dir ||
+              File.expand_path("../../../../../..", __dir__)
+            resolver = Ace::Support::Config.create(
+              config_dir: ".ace",
+              defaults_dir: ".ace-defaults",
+              gem_path: gem_root
+            )
+            config = resolver.resolve_namespace("git", filename: "commit")
+            config.data["git"] || config.data
+          end
+          def default_config
+            gem_root = Gem.loaded_specs["ace-git-commit"]&.gem_dir ||
+              File.expand_path("../../../../../..", __dir__)
+            defaults_path = File.join(gem_root, ".ace-defaults", "git", "commit.yml")
+            if File.exist?(defaults_path)
+              require "yaml"
+              YAML.safe_load_file(defaults_path, permitted_classes: [Symbol], aliases: true) || {}
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git_commit/cli.rb ADDED Viewed

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require "ace/support/cli"
+require_relative "../git_commit"
+# Commands
+require_relative "cli/commands/commit"
+module Ace
+  module GitCommit
+    # CLI namespace for ace-git-commit command loading.
+    #
+    # ace-git-commit now uses a single-command ace-support-cli entrypoint that calls
+    # CLI::Commands::Commit directly from the executable.
+    module CLI
+      # Entry point for CLI invocation (used by tests via cli_helpers)
+      #
+      # @param args [Array<String>] Command-line arguments
+      def self.start(args)
+        Ace::Support::Cli::Runner.new(Commands::Commit).call(args: args)
+      end
+    end
+  end
+end

data/lib/ace/git_commit/models/commit_group.rb ADDED Viewed

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require "json"
+require "digest"
+module Ace
+  module GitCommit
+    module Models
+      # CommitGroup represents a group of files that share the same effective config
+      class CommitGroup
+        attr_reader :scope_name, :source, :config, :files
+        def initialize(scope_name:, source:, config:, files: [])
+          @scope_name = scope_name
+          @source = source
+          @config = config || {}
+          @files = Array(files)
+        end
+        def add_file(file)
+          @files << file
+          self
+        end
+        def file_count
+          @files.length
+        end
+        def config_signature
+          self.class.signature_for(@config)
+        end
+        def self.signature_for(config)
+          normalized = normalize_config(config || {})
+          Digest::SHA256.hexdigest(JSON.generate(normalized))
+        end
+        def self.normalize_config(value)
+          case value
+          when Hash
+            value.keys.sort.each_with_object({}) do |key, acc|
+              acc[key.to_s] = normalize_config(value[key])
+            end
+          when Array
+            value.map { |item| normalize_config(item) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end