ace-bundle 0.40.0

data/lib/ace/bundle/atoms/boundary_finder.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Pure functions to find semantic boundaries in XML-structured content
+      # Used by ContextChunker to split content at clean boundaries
+      # (between </file> and <file>, between </output> and <output>)
+      #
+      # ## Whitespace Handling
+      #
+      # Whitespace-only content between XML elements is intentionally dropped.
+      # This means the sum of block line counts may be less than the total
+      # content line count. This is acceptable because:
+      # - The primary goal is preserving XML element integrity, not exact line counting
+      # - Chunk limits are approximate; slightly exceeding is better than splitting elements
+      # - Typical variance is ~2-5% of content lines
+      #
+      # @example Whitespace between elements
+      #   content = "<file>a</file>\n\n<file>b</file>"
+      #   blocks = BoundaryFinder.parse_blocks(content)
+      #   # => 2 blocks (whitespace between them is dropped)
+      #   # Block line sum: 2, Content lines: 3
+      #
+      module BoundaryFinder
+        # XML element patterns for semantic blocks
+        # These elements should never be split in the middle
+        FILE_ELEMENT_PATTERN = %r{<file\s+[^>]*>.*?</file>}m
+        OUTPUT_ELEMENT_PATTERN = %r{<output\s+[^>]*>.*?</output>}m
+
+        module_function
+
+        # Parse content into semantic blocks
+        # Each block represents a unit that should not be split
+        #
+        # @param content [String] Content to parse
+        # @return [Array<Hash>] Array of blocks, each with :content, :type, :lines
+        #
+        # @example Parse content with file elements
+        #   blocks = BoundaryFinder.parse_blocks("# Header\n<file path='a.rb'>code</file>")
+        #   # => [{content: "# Header\n", type: :text, lines: 1},
+        #   #     {content: "<file path='a.rb'>code</file>", type: :file, lines: 1}]
+        def parse_blocks(content)
+          return [] if content.nil? || content.empty?
+
+          blocks = []
+          remaining = content
+
+          while remaining && !remaining.empty?
+            # Find the next XML element (file or output)
+            file_match = remaining.match(FILE_ELEMENT_PATTERN)
+            output_match = remaining.match(OUTPUT_ELEMENT_PATTERN)
+
+            # Determine which comes first
+            next_match = nil
+            match_type = nil
+
+            if file_match && output_match
+              if file_match.begin(0) <= output_match.begin(0)
+                next_match = file_match
+                match_type = :file
+              else
+                next_match = output_match
+                match_type = :output
+              end
+            elsif file_match
+              next_match = file_match
+              match_type = :file
+            elsif output_match
+              next_match = output_match
+              match_type = :output
+            end
+
+            if next_match
+              # Add text before the match as a text block (if non-whitespace)
+              if next_match.begin(0) > 0
+                text_content = remaining[0...next_match.begin(0)]
+                # Only add text blocks with actual content (not just whitespace)
+                blocks << create_block(text_content, :text) unless text_content.strip.empty?
+              end
+
+              # Add the XML element as a block
+              blocks << create_block(next_match[0], match_type)
+
+              # Move past this match
+              remaining = remaining[next_match.end(0)..]
+            else
+              # No more XML elements, add remaining as text (if non-whitespace)
+              blocks << create_block(remaining, :text) unless remaining.strip.empty?
+              break
+            end
+          end
+
+          blocks
+        end
+
+        # Check if content contains XML elements that require semantic chunking
+        # @param content [String] Content to check
+        # @return [Boolean] true if content has file or output elements
+        def has_semantic_elements?(content)
+          return false if content.nil? || content.empty?
+
+          content.match?(FILE_ELEMENT_PATTERN) || content.match?(OUTPUT_ELEMENT_PATTERN)
+        end
+
+        private_class_method
+
+        # Create a block hash
+        # @param content [String] Block content
+        # @param type [Symbol] Block type (:file, :output, :text)
+        # @return [Hash] Block with content, type, and line count
+        def create_block(content, type)
+          {
+            content: content,
+            type: type,
+            lines: content.lines.size
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/bundle_normalizer.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Normalizes bundle configuration into ace-bundle compatible structure
+      #
+      # Handles various input formats and ensures proper structure for ace-bundle:
+      # - String inputs (preset names) wrapped in bundle.presets array
+      # - Hashes with top-level base: key moved to bundle.base
+      # - Hashes with both base: and bundle: keys properly merged
+      # - Properly structured configs passed through unchanged
+      # - Normalizes all input to bundle: key structure for ace-bundle compatibility
+      #
+      class BundleNormalizer
+        # Normalize various input types to proper ace-bundle structure
+        #
+        # @param input [String, Hash, nil] Bundle configuration input
+        # @return [Hash] Normalized bundle configuration
+        #
+        # @example String input (preset name)
+        #   normalize_config("project")
+        #   #=> { "bundle" => { "presets" => ["project"] } }
+        #
+        # @example Hash with top-level base key
+        #   normalize_config({ "base" => "custom content", "files" => ["README.md"] })
+        #   #=> { "bundle" => { "base" => "custom content", "files" => ["README.md"] } }
+        #
+        # @example Hash with both base and bundle keys
+        #   normalize_config({ "base" => "content", "bundle" => { "presets" => ["project"] } })
+        #   #=> { "bundle" => { "base" => "content", "presets" => ["project"] } }
+        #
+        # @example Properly structured config (unchanged)
+        #   normalize_config({ "bundle" => { "base" => "content" } })
+        #   #=> { "bundle" => { "base" => "content" } }
+        def self.normalize_config(input)
+          case input
+          when String
+            # String input (e.g., "project", "staged") -> wrap as preset
+            {"bundle" => {"presets" => [input]}}
+          when Hash
+            normalize_hash_config(input)
+          when NilClass
+            # Return empty config for nil
+            {}
+          else
+            # Fallback for unexpected types
+            {}
+          end
+        end
+
+        # Normalize hash-based bundle configuration
+        #
+        # @param input [Hash] Bundle configuration hash
+        # @return [Hash] Normalized configuration
+        # @api private
+        def self.normalize_hash_config(input)
+          # Check if this config has a top-level "base" key that needs to be moved
+          has_base = input.key?("base") || input.key?(:base)
+          # Check for bundle: configuration key
+          has_bundle_config = input.key?("bundle") || input.key?(:bundle)
+
+          if has_base && !has_bundle_config
+            # Case 1: Config has base: at top level but no bundle: key
+            # Need to move base under bundle.base and wrap other keys
+            wrap_base_in_bundle(input)
+          elsif has_base && has_bundle_config
+            # Case 2: Config has both base: and bundle: at top level
+            # Move base under bundle.base
+            merge_base_into_bundle(input)
+          else
+            # Case 3: Config already properly structured or doesn't need normalization
+            input
+          end
+        end
+
+        # Wrap top-level base and other keys under bundle
+        #
+        # @param input [Hash] Configuration with top-level base
+        # @return [Hash] Configuration with base under bundle.base
+        # @api private
+        def self.wrap_base_in_bundle(input)
+          normalized = {"bundle" => {}}
+
+          input.each do |key, value|
+            key_str = key.to_s
+            if key_str == "base"
+              # Move top-level base to bundle.base
+              normalized["bundle"]["base"] = value
+            else
+              # Other top-level keys go under bundle
+              normalized["bundle"][key_str] = value
+            end
+          end
+
+          normalized
+        end
+
+        # Merge top-level base into existing bundle.base
+        #
+        # @param input [Hash] Configuration with both base and bundle keys
+        # @return [Hash] Configuration with base merged into bundle
+        # @api private
+        def self.merge_base_into_bundle(input)
+          normalized = {}
+          base_value = input["base"] || input[:base]
+
+          input.each do |key, value|
+            key_str = key.to_s
+            if key_str == "base"
+              # Skip - will add under bundle.base below
+              next
+            elsif key_str == "bundle"
+              # Merge base value into existing bundle
+              bundle_hash = value.is_a?(Hash) ? value.dup : {}
+              bundle_hash["base"] = base_value
+              normalized["bundle"] = bundle_hash
+            else
+              normalized[key_str] = value
+            end
+          end
+
+          normalized
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/content_checker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Pure functions for checking section content types
+      # Used by both SectionProcessor and ContextLoader
+      module ContentChecker
+        class << self
+          # Checks if section has diffs content
+          # Note: For _processed_diffs, we check for non-empty arrays to avoid treating
+          # empty arrays as valid diff content (which would trigger merge logic unnecessarily)
+          # @param section_data [Hash] section data with symbol or string keys
+          # @return [Boolean] true if section has ranges, diffs, or non-empty _processed_diffs
+          def has_diffs_content?(section_data)
+            ranges = section_data[:ranges] || section_data["ranges"]
+            diffs = section_data[:diffs] || section_data["diffs"]
+            processed_diffs = section_data[:_processed_diffs] || section_data["_processed_diffs"]
+            !!(ranges || diffs || (processed_diffs.is_a?(Array) && processed_diffs.any?))
+          end
+
+          # Checks if section has files content
+          # @param section_data [Hash] section data with symbol or string keys
+          # @return [Boolean] true if section has files
+          def has_files_content?(section_data)
+            !!(section_data[:files] || section_data["files"])
+          end
+
+          # Checks if section has commands content
+          # @param section_data [Hash] section data with symbol or string keys
+          # @return [Boolean] true if section has commands
+          def has_commands_content?(section_data)
+            !!(section_data[:commands] || section_data["commands"])
+          end
+
+          # Checks if section has inline content
+          # @param section_data [Hash] section data with symbol or string keys
+          # @return [Boolean] true if section has content
+          def has_content_content?(section_data)
+            !!(section_data[:content] || section_data["content"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/line_counter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Pure function to count lines in content
+      # Follows ATOM architecture: no side effects, single purpose
+      module LineCounter
+        class << self
+          # Count the number of lines in content
+          # @param content [String, nil] Content to count lines in
+          # @return [Integer] Number of lines (0 for empty/nil content)
+          #
+          # @example Empty content
+          #   LineCounter.count("")  # => 0
+          #
+          # @example Single line
+          #   LineCounter.count("hello")  # => 1
+          #
+          # @example Multiple lines
+          #   LineCounter.count("a\nb\nc")  # => 3
+          #
+          # @example Trailing newline (does not add extra line)
+          #   LineCounter.count("a\nb\n")  # => 2
+          def count(content)
+            return 0 if content.nil? || content.empty?
+
+            # Count actual lines of content
+            # "a\nb\nc" => 3 lines
+            # "a\nb\n" => 2 lines (trailing newline doesn't add a line)
+            content.count("\n") + (content.end_with?("\n") ? 0 : 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/preset_list_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Formats preset list for display
+      #
+      # Pure function that takes preset data and returns formatted strings.
+      # Used by the List command to display available presets.
+      module PresetListFormatter
+        # Format a list of presets for display
+        #
+        # @param presets [Array<Hash>] Array of preset data hashes
+        # @return [Array<String>] Formatted lines ready for output
+        def self.format(presets)
+          return empty_message if presets.empty?
+
+          lines = ["Available presets:"]
+
+          presets.each do |preset|
+            lines << "  #{preset[:name]}"
+            lines << "    Description: #{preset[:description]}" if preset[:description]
+            lines << "    Default output: #{preset[:output] || "stdio"}"
+            lines << "    Source: #{preset[:source_file]}" if preset[:source_file]
+            lines << ""
+          end
+
+          lines
+        end
+
+        # Message when no presets are found
+        #
+        # @return [Array<String>] Help message lines
+        def self.empty_message
+          [
+            "No presets found in .ace/bundle/presets/",
+            "Create markdown files with YAML frontmatter in .ace/bundle/presets/ to define presets.",
+            "Example presets are available in the ace-bundle gem at .ace-defaults/bundle/"
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/preset_validator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Validates preset references and detects circular dependencies
+      class PresetValidator
+        MAX_DEPTH = 10  # Maximum recursion depth for preset composition
+
+        # Check if a preset exists in the preset manager
+        def self.preset_exists?(preset_name, preset_manager)
+          preset_manager.preset_exists?(preset_name)
+        end
+
+        # Detect circular dependencies in preset composition
+        # Returns { success: true } if no circular dependency
+        # Returns { success: false, error: "..." } if circular dependency found
+        def self.check_circular_dependency(preset_name, preset_chain)
+          if preset_chain.include?(preset_name)
+            {
+              success: false,
+              error: "Circular dependency detected: #{(preset_chain + [preset_name]).join(" -> ")}"
+            }
+          elsif preset_chain.size >= MAX_DEPTH
+            {
+              success: false,
+              error: "Maximum preset nesting depth (#{MAX_DEPTH}) exceeded: #{preset_chain.join(" -> ")}"
+            }
+          else
+            {success: true}
+          end
+        end
+
+        # Validate a list of preset names
+        # Returns { success: true, valid: [], missing: [] }
+        def self.validate_presets(preset_names, preset_manager)
+          valid = []
+          missing = []
+
+          preset_names.each do |name|
+            if preset_exists?(name, preset_manager)
+              valid << name
+            else
+              missing << name
+            end
+          end
+
+          {
+            success: missing.empty?,
+            valid: valid,
+            missing: missing
+          }
+        end
+
+        # Extract preset references from a preset's configuration
+        # Returns array of preset names referenced in the 'presets:' key
+        def self.extract_preset_references(preset_data)
+          return [] unless preset_data
+
+          bundle_config = preset_data[:bundle] || preset_data["bundle"] || {}
+          presets = bundle_config["presets"] || bundle_config[:presets] || []
+
+          # Ensure we return an array of strings
+          Array(presets).map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/atoms/section_validator.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Ace
+  module Bundle
+    module Atoms
+      # Validates section definitions and ensures section integrity
+      class SectionValidator
+        SectionValidationError = Ace::Bundle::SectionValidationError
+
+        # Required section fields (none - all fields are optional)
+        REQUIRED_FIELDS = [].freeze
+
+        def initialize
+          @errors = []
+        end
+
+        # Validates section definitions from configuration
+        # @param sections [Hash] section definitions hash
+        # @return [Boolean] true if valid, false otherwise
+        def validate_sections(sections)
+          @errors.clear
+          return true if sections.nil? || sections.empty?
+
+          validate_section_names(sections)
+          validate_required_fields(sections)
+          validate_section_content(sections)
+
+          @errors.empty?
+        end
+
+        # Returns validation errors
+        # @return [Array<String>] list of validation errors
+        attr_reader :errors
+
+        # Validates a single section
+        # @param name [String] section name
+        # @param section [Hash] section definition
+        # @return [Boolean] true if valid, false otherwise
+        def validate_section(name, section)
+          @errors.clear
+          return true if section.nil? || section.empty?
+
+          validate_section_name(name)
+          validate_required_fields_for_section(name, section)
+          validate_content_for_section(name, section)
+
+          @errors.empty?
+        end
+
+        private
+
+        # Validates section names are unique and valid
+        def validate_section_names(sections)
+          section_names = sections.keys
+          duplicates = section_names.group_by(&:itself).select { |_, v| v.size > 1 }.keys
+
+          duplicates.each do |duplicate|
+            @errors << "Duplicate section name: #{duplicate}"
+          end
+
+          section_names.each do |name|
+            validate_section_name(name)
+          end
+        end
+
+        # Validates a single section name
+        def validate_section_name(name)
+          if name.nil? || name.to_s.strip.empty?
+            @errors << "Section name cannot be empty"
+          elsif !name.to_s.match?(/\A[a-zA-Z0-9_-]+\z/)
+            @errors << "Section name '#{name}' contains invalid characters. Use letters, numbers, underscores, and hyphens only."
+          end
+        end
+
+        # Validates required fields for all sections
+        def validate_required_fields(sections)
+          sections.each do |name, section|
+            validate_required_fields_for_section(name, section)
+          end
+        end
+
+        # Validates required fields for a single section
+        def validate_required_fields_for_section(name, section)
+          REQUIRED_FIELDS.each do |field|
+            unless section.key?(field) && !section[field].nil? && !section[field].to_s.strip.empty?
+              @errors << "Section '#{name}' missing required field: #{field}"
+            end
+          end
+        end
+
+        # Validates content for all sections
+        def validate_section_content(sections)
+          sections.each do |name, section|
+            validate_content_for_section(name, section)
+          end
+        end
+
+        # Validates content for a single section
+        def validate_content_for_section(name, section)
+          # Validate all content types that are present
+          validate_files_content(name, section)
+          validate_commands_content(name, section)
+          validate_diffs_content(name, section)
+          validate_presets_content(name, section)
+          validate_inline_content(name, section)
+        end
+
+        # Validates files content for a section
+        def validate_files_content(name, section)
+          files = section[:files] || section["files"]
+
+          # Only validate if files are present
+          return if files.nil? || files.empty?
+
+          unless files.is_a?(Array)
+            @errors << "Section '#{name}' files must be an array"
+            return
+          end
+
+          files.each_with_index do |file, index|
+            validate_file_item(name, file, index)
+          end
+        end
+
+        # Validates a single file item
+        def validate_file_item(section_name, file, index)
+          if file.is_a?(Hash)
+            path = file[:path] || file["path"]
+            if path.nil? || path.to_s.strip.empty?
+              @errors << "Section '#{section_name}' file at index #{index} missing path"
+            end
+          elsif file.is_a?(String)
+            if file.strip.empty?
+              @errors << "Section '#{section_name}' file at index #{index} cannot be empty string"
+            end
+          else
+            @errors << "Section '#{section_name}' file at index #{index} must be string or hash"
+          end
+        end
+
+        # Validates commands content for a section
+        def validate_commands_content(name, section)
+          commands = section[:commands] || section["commands"]
+
+          # Only validate if commands are present
+          return if commands.nil? || commands.empty?
+
+          unless commands.is_a?(Array)
+            @errors << "Section '#{name}' commands must be an array"
+            return
+          end
+
+          commands.each_with_index do |command, index|
+            if command.to_s.strip.empty?
+              @errors << "Section '#{name}' command at index #{index} cannot be empty"
+            end
+          end
+        end
+
+        # Validates diffs content for a section
+        def validate_diffs_content(name, section)
+          ranges = section[:ranges] || section["ranges"]
+
+          # Only validate if ranges are present
+          return if ranges.nil? || ranges.empty?
+
+          unless ranges.is_a?(Array)
+            @errors << "Section '#{name}' ranges must be an array"
+            return
+          end
+
+          ranges.each_with_index do |range, index|
+            if range.to_s.strip.empty?
+              @errors << "Section '#{name}' range at index #{index} cannot be empty"
+            end
+          end
+        end
+
+        # Validates presets content for a section
+        def validate_presets_content(name, section)
+          presets = section[:presets] || section["presets"]
+
+          # Only validate if presets are present
+          return if presets.nil? || presets.empty?
+
+          unless presets.is_a?(Array)
+            @errors << "Section '#{name}' presets must be an array"
+            return
+          end
+
+          presets.each_with_index do |preset, index|
+            if preset.is_a?(String)
+              if preset.strip.empty?
+                @errors << "Section '#{name}' preset at index #{index} cannot be empty string"
+              end
+            else
+              @errors << "Section '#{name}' preset at index #{index} must be a string"
+            end
+          end
+        end
+
+        # Validates inline content for a section
+        def validate_inline_content(name, section)
+          content = section[:content] || section["content"]
+
+          # Only validate if content is present
+          nil if content.nil? || content.to_s.strip.empty?
+
+          # Content validation (if needed in future)
+          # Currently just ensures content is present if specified
+        end
+      end
+    end
+  end
+end