ace-bundle 0.40.0

data/lib/ace/bundle/molecules/bundle_merger.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Ace
+  module Bundle
+    module Molecules
+      # BundleMerger merges multiple bundle results into a single combined result
+      class BundleMerger
+        # Merge multiple bundle results into one
+        def merge_bundles(bundles)
+          return empty_merge_result if bundles.nil? || bundles.empty?
+          return bundles.first if bundles.size == 1
+
+          {
+            success: true,
+            files: merge_files(bundles),
+            commands: merge_commands(bundles),
+            errors: merge_errors(bundles),
+            sources: extract_sources(bundles),
+            metadata: merge_metadata(bundles),
+            merged: true,
+            total_bundles: bundles.size,
+            total_files: bundles.sum { |c| c[:total_files] || c[:files]&.size || 0 },
+            total_commands: bundles.sum { |c| c[:total_commands] || c[:commands]&.size || 0 },
+            total_errors: bundles.sum { |c| c[:total_errors] || c[:errors]&.size || 0 },
+            total_size: bundles.sum { |c| c[:total_size] || 0 }
+          }
+        end
+
+        # Determine output path from multiple presets
+        def resolve_output_path(presets, command_output = nil)
+          # Command-line flag has highest priority
+          return command_output if command_output
+
+          # Extract output paths from presets
+          output_paths = presets.map { |p| p[:output] }.compact
+
+          # If any preset wants stdout (no output), use stdout
+          return nil if output_paths.size < presets.size
+
+          # If all presets have the same output path, use it
+          return output_paths.first if output_paths.uniq.size == 1
+
+          # Different output paths = conflict, default to stdout
+          nil
+        end
+
+        # Merge data structures with source attribution
+        def merge_with_attribution(bundles, source_key = nil)
+          merged_data = {
+            files: [],
+            commands: [],
+            errors: [],
+            metadata: {}
+          }
+
+          bundles.each do |bundle|
+            source = extract_source(bundle, source_key)
+
+            # Add files with source
+            if bundle[:files]
+              bundle[:files].each do |file|
+                file_with_source = file.dup
+                file_with_source[:source] = source if source
+                merged_data[:files] << file_with_source
+              end
+            end
+
+            # Add commands with source
+            if bundle[:commands]
+              bundle[:commands].each do |cmd|
+                cmd_with_source = cmd.dup
+                cmd_with_source[:source] = source if source
+                merged_data[:commands] << cmd_with_source
+              end
+            end
+
+            # Collect errors
+            if bundle[:errors]
+              merged_data[:errors].concat(bundle[:errors])
+            end
+
+            # Merge metadata
+            if bundle[:metadata]
+              merged_data[:metadata] = deep_merge(merged_data[:metadata], bundle[:metadata])
+            end
+          end
+
+          merged_data
+        end
+
+        private
+
+        # Return empty hash structure for nil/empty bundle inputs
+        # This ensures consistent return type with multi-bundle merge results
+        def empty_merge_result
+          {
+            success: true,
+            files: [],
+            commands: [],
+            errors: [],
+            sources: [],
+            metadata: {merged_at: Time.now.iso8601},
+            merged: false,
+            total_bundles: 0,
+            total_files: 0,
+            total_commands: 0,
+            total_errors: 0,
+            total_size: 0
+          }
+        end
+
+        # Merge files from multiple bundles, deduplicating by path
+        def merge_files(bundles)
+          seen_paths = Set.new
+          merged = []
+
+          bundles.each do |bundle|
+            next unless bundle[:files]
+
+            bundle[:files].each do |file|
+              path = file[:path]
+              unless seen_paths.include?(path)
+                seen_paths.add(path)
+                # Add source attribution if available
+                file[:source] = bundle[:source_input] || bundle[:preset_name] if bundle[:source_input] || bundle[:preset_name]
+                merged << file
+              end
+            end
+          end
+
+          merged
+        end
+
+        # Merge commands from multiple bundles
+        def merge_commands(bundles)
+          merged = []
+
+          bundles.each do |bundle|
+            next unless bundle[:commands]
+
+            bundle[:commands].each do |cmd|
+              # Add source attribution
+              cmd[:source] = bundle[:source_input] || bundle[:preset_name] if bundle[:source_input] || bundle[:preset_name]
+              merged << cmd
+            end
+          end
+
+          merged
+        end
+
+        # Merge errors from multiple bundles
+        def merge_errors(bundles)
+          errors = []
+
+          bundles.each do |bundle|
+            next unless bundle[:errors]
+
+            bundle[:errors].each do |error|
+              # Add source information to error if not present
+              if error.is_a?(String)
+                source = bundle[:source_input] || bundle[:preset_name]
+                errors << (source ? "[#{source}] #{error}" : error)
+              else
+                errors << error
+              end
+            end
+          end
+
+          errors.uniq
+        end
+
+        # Extract source information from bundles
+        def extract_sources(bundles)
+          sources = []
+
+          bundles.each do |bundle|
+            if bundle[:preset_name]
+              sources << {type: "preset", name: bundle[:preset_name]}
+            elsif bundle[:source_input]
+              sources << {type: "input", path: bundle[:source_input]}
+            elsif bundle[:file_path]
+              sources << {type: "file", path: bundle[:file_path]}
+            end
+          end
+
+          sources
+        end
+
+        # Merge metadata from multiple bundles
+        def merge_metadata(bundles)
+          metadata = {}
+
+          bundles.each do |bundle|
+            next unless bundle[:metadata]
+
+            metadata = deep_merge(metadata, bundle[:metadata])
+          end
+
+          # Add merge timestamp
+          metadata[:merged_at] = Time.now.iso8601
+
+          metadata
+        end
+
+        # Extract source identifier from bundle
+        def extract_source(bundle, source_key = nil)
+          if source_key && bundle[source_key]
+            bundle[source_key]
+          elsif bundle[:preset_name]
+            "preset:#{bundle[:preset_name]}"
+          elsif bundle[:source_input]
+            "input:#{bundle[:source_input]}"
+          elsif bundle[:file_path]
+            "file:#{bundle[:file_path]}"
+          end
+        end
+
+        # Deep merge two hashes
+        def deep_merge(hash1, hash2)
+          return hash2 if hash1.nil?
+          return hash1 if hash2.nil?
+
+          merged = hash1.dup
+
+          hash2.each do |key, value2|
+            if merged.key?(key)
+              value1 = merged[key]
+
+              merged[key] = if value1.is_a?(Hash) && value2.is_a?(Hash)
+                deep_merge(value1, value2)
+              elsif value1.is_a?(Array) && value2.is_a?(Array)
+                (value1 + value2).uniq
+              else
+                value2
+              end
+            else
+              merged[key] = value2
+            end
+          end
+
+          merged
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/molecules/preset_manager.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "ace/support/config"
+require "yaml"
+require_relative "../atoms/preset_validator"
+require_relative "../atoms/section_validator"
+
+module Ace
+  module Bundle
+    module Molecules
+      # Manages context presets from markdown files in .ace/bundle/presets/
+      class PresetManager
+        attr_reader :presets
+
+        def initialize
+          @section_validator = Atoms::SectionValidator.new
+          @presets = load_presets
+          @preset_cache = {}  # Cache for composed presets during single execution
+        end
+
+        def list_presets
+          @presets.values.map(&:dup)
+        end
+
+        def get_preset(name)
+          preset = @presets[name.to_s]
+          preset&.dup
+        end
+
+        def preset_exists?(name)
+          @presets.key?(name.to_s)
+        end
+
+        # Load a preset with composition support
+        # Returns fully composed preset data with all dependent presets merged
+        def load_preset_with_composition(name, visited = Set.new)
+          # Check circular dependency
+          validation = Atoms::PresetValidator.check_circular_dependency(name, visited.to_a)
+          unless validation[:success]
+            return {
+              error: validation[:error],
+              success: false
+            }
+          end
+
+          # Check if preset exists
+          preset = get_preset(name)
+          unless preset
+            return {
+              error: "Preset '#{name}' not found. Available presets: #{@presets.keys.join(", ")}",
+              success: false
+            }
+          end
+
+          # Mark this preset as visited
+          new_visited = visited.dup.add(name)
+
+          # Extract preset references
+          preset_refs = Atoms::PresetValidator.extract_preset_references(preset)
+
+          # If no references, return preset as-is
+          if preset_refs.empty?
+            preset[:success] = true
+            return preset
+          end
+
+          # Load all referenced presets recursively
+          composed_presets = []
+          errors = []
+
+          preset_refs.each do |ref_name|
+            composed = load_preset_with_composition(ref_name, new_visited)
+            if composed[:success]
+              composed_presets << composed
+            else
+              errors << composed[:error]
+            end
+          end
+
+          # If there were errors loading dependencies, return error
+          if errors.any?
+            return {
+              error: "Failed to load preset dependencies: #{errors.join(", ")}",
+              success: false,
+              partial_presets: composed_presets
+            }
+          end
+
+          # Merge all composed presets with current preset
+          # Order: dependencies first, then current preset
+          merged = merge_preset_data(composed_presets + [preset])
+          merged[:success] = true
+          merged[:composed] = true
+          merged[:composed_from] = preset_refs + [name]
+
+          merged
+        end
+
+        # Merge multiple preset data structures
+        # Arrays are concatenated and deduplicated (first occurrence wins)
+        # Scalars follow "last wins" strategy
+        def merge_preset_data(presets)
+          return presets.first if presets.size == 1
+
+          merged = {
+            description: nil,
+            params: {},
+            bundle: {},
+            body: "",
+            # Don't set format here - let BundleLoader determine the default
+            output: nil,
+            cache: false,
+            metadata: {}
+          }
+
+          # Collect all sections for merging
+          all_sections = []
+
+          presets.each do |preset|
+            # Merge bundle configuration
+            if preset[:bundle]
+              bundle_config = preset[:bundle]
+
+              # Merge params (scalar override)
+              if bundle_config["params"]
+                merged[:bundle]["params"] ||= {}
+                merged[:bundle]["params"].merge!(bundle_config["params"])
+              end
+
+              # Merge files array (deduplicate)
+              if bundle_config["files"]
+                merged[:bundle]["files"] ||= []
+                merged[:bundle]["files"].concat(bundle_config["files"])
+              end
+
+              # Merge commands array (deduplicate)
+              if bundle_config["commands"]
+                merged[:bundle]["commands"] ||= []
+                merged[:bundle]["commands"].concat(bundle_config["commands"])
+              end
+
+              # Collect sections for separate processing
+              if bundle_config["sections"]
+                all_sections << bundle_config["sections"]
+              end
+
+              # Copy other bundle keys
+              bundle_config.each do |key, value|
+                next if %w[params files commands sections].include?(key)
+                merged[:bundle][key] = value
+              end
+            end
+
+            # Scalar overrides (last wins)
+            merged[:description] = preset[:description] if preset[:description]
+            # Don't override format from preset - let ContextLoader handle defaults based on embed_document_source
+            merged[:output] = preset[:output] if preset[:output]
+            merged[:compressor_mode] = preset[:compressor_mode] if preset[:compressor_mode]
+            merged[:compressor_source_scope] = preset[:compressor_source_scope] if preset[:compressor_source_scope]
+            merged[:cache] = preset[:cache] if preset[:cache]
+
+            # Merge params at root level for direct access
+            if preset[:params]
+              merged[:params].merge!(preset[:params])
+            end
+
+            # Concatenate body content
+            if preset[:body] && !preset[:body].empty?
+              merged[:body] += "\n\n" unless merged[:body].empty?
+              merged[:body] += preset[:body]
+            end
+
+            # Deep merge metadata
+            if preset[:metadata]
+              merged[:metadata] = deep_merge_hash(merged[:metadata], preset[:metadata])
+            end
+          end
+
+          # Merge sections using SectionProcessor if any exist
+          if all_sections.any?
+            require_relative "section_processor"
+            section_processor = Molecules::SectionProcessor.new
+            merged_sections = section_processor.merge_sections(*all_sections)
+            merged[:bundle]["sections"] = merged_sections
+          end
+
+          # Deduplicate arrays
+          if merged[:bundle]["files"]
+            merged[:bundle]["files"].uniq!
+          end
+
+          if merged[:bundle]["commands"]
+            merged[:bundle]["commands"].uniq!
+          end
+
+          # Extract all merged params to root level
+          # This ensures params like output, format, timeout, max_size are accessible at root
+          if merged[:bundle]["params"]
+            merged_params = merged[:bundle]["params"]
+
+            # Store params hash at root level
+            merged[:params] = merged_params
+
+            # Extract ALL param keys to root level
+            merged_params.each do |key, value|
+              merged[key.to_sym] = value
+            end
+
+            # Derive cache boolean from output param
+            merged[:cache] = (merged_params["output"] == "cache")
+          end
+
+          merged
+        end
+
+        private
+
+        # Deep merge two hashes (similar to BundleMerger but simpler)
+        def deep_merge_hash(hash1, hash2)
+          merged = hash1.dup
+
+          hash2.each do |key, value2|
+            if merged.key?(key)
+              value1 = merged[key]
+              merged[key] = if value1.is_a?(Hash) && value2.is_a?(Hash)
+                deep_merge_hash(value1, value2)
+              elsif value1.is_a?(Array) && value2.is_a?(Array)
+                (value1 + value2).uniq
+              else
+                value2  # Last wins
+              end
+            else
+              merged[key] = value2
+            end
+          end
+
+          merged
+        end
+
+        def load_presets
+          presets = {}
+
+          # Use ace-config VirtualConfigResolver to find all context/*.md files
+          resolver = Ace::Support::Config.virtual_resolver
+
+          # Get all bundle/presets/*.md files from virtual map
+          resolver.glob("bundle/presets/*.md").each do |relative_path, absolute_path|
+            name = File.basename(absolute_path, ".md")
+            preset_data = load_preset_from_file(absolute_path)
+
+            if preset_data
+              preset_data[:name] = name
+              preset_data[:source_file] = absolute_path
+              presets[name] = preset_data
+            end
+          end
+
+          presets
+        end
+
+        def load_preset_from_file(file)
+          content = File.read(file)
+          frontmatter, body = parse_frontmatter(content)
+
+          return nil unless frontmatter
+
+          # Use 'bundle' key for preset configuration
+          bundle_config = frontmatter["bundle"] || {}
+          params = bundle_config["params"] || {}
+
+          # Validate sections if present
+          if bundle_config["sections"]
+            unless @section_validator.validate_sections(bundle_config["sections"])
+              errors = @section_validator.errors
+              warn "Warning: Section validation failed in #{file}:\n  #{errors.join("\n  ")}\n\nPlease review the sections configuration in this file. The preset will continue to load, but section functionality may be limited."
+              # Don't fail loading, just warn - allow users to fix configuration
+            end
+          end
+
+          preset_data = {
+            description: frontmatter["description"] || "#{File.basename(file, ".md")} preset",
+            params: params,
+            bundle: bundle_config,
+            body: body.strip,
+            format: params["format"], # Don't set default here - let BundleLoader handle defaults
+            output: params["output"],  # nil allows auto-format to determine output mode
+            cache: params["output"] == "cache",
+            metadata: frontmatter["metadata"] || {}
+          }
+
+          # Add section validation metadata if sections were validated
+          if bundle_config["sections"]
+            preset_data[:metadata][:sections_validated] = true
+            preset_data[:metadata][:section_validation_errors] = @section_validator.errors unless @section_validator.errors.empty?
+          end
+
+          # Extract all params to root level for direct access
+          params.each do |key, value|
+            preset_data[key.to_sym] = value
+          end
+
+          # Re-derive cache from output param (in case it was set via params extraction)
+          preset_data[:cache] = (params["output"] == "cache")
+
+          preset_data
+        rescue => e
+          warn "Error loading preset from #{file}: #{e.message}"
+          nil
+        end
+
+        def parse_frontmatter(content)
+          # Match YAML frontmatter between --- markers
+          if content =~ /\A---\s*\n(.*?)\n---\s*\n(.*)\z/m
+            yaml_content = $1
+            body_content = $2
+
+            begin
+              frontmatter = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+              [frontmatter, body_content]
+            rescue => e
+              warn "Error parsing YAML frontmatter: #{e.message}"
+              [nil, content]
+            end
+          else
+            [nil, content]
+          end
+        end
+      end
+    end
+  end
+end