ace-support-core 0.29.0

data/lib/ace/core/molecules/file_aggregator.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/file_reader"
+require_relative "../atoms/glob_expander"
+require "ace/support/fs"
+
+module Ace
+  module Core
+    module Molecules
+      # Aggregates file contents from multiple sources using atoms
+      class FileAggregator
+        def initialize(options = {})
+          @max_size = options[:max_size] || Atoms::FileReader::MAX_FILE_SIZE
+          @base_dir = options[:base_dir] || Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+          @exclude_patterns = options[:exclude] || []
+        end
+
+        # Aggregate files from patterns
+        # @param patterns [Array<String>] File patterns to aggregate
+        # @return [Hash] {files: Array, errors: Array, stats: Hash}
+        def aggregate(patterns)
+          result = {
+            files: [],
+            errors: [],
+            stats: {
+              total_size: 0,
+              file_count: 0,
+              error_count: 0,
+              skipped_count: 0
+            }
+          }
+
+          patterns = Array(patterns).compact
+          return result if patterns.empty?
+
+          # Expand all patterns
+          all_files = expand_patterns(patterns)
+
+          # Apply exclusions
+          filtered_files = filter_exclusions(all_files)
+
+          # Track skipped files
+          skipped_count = all_files.size - filtered_files.size
+          result[:stats][:skipped_count] = skipped_count
+
+          # Read each file
+          filtered_files.each do |file_path|
+            process_file(file_path, result)
+          end
+
+          result
+        end
+
+        # Aggregate specific files (no pattern expansion)
+        # @param file_paths [Array<String>] Direct file paths
+        # @return [Hash] {files: Array, errors: Array, stats: Hash}
+        def aggregate_files(file_paths)
+          result = {
+            files: [],
+            errors: [],
+            stats: {
+              total_size: 0,
+              file_count: 0,
+              error_count: 0,
+              skipped_count: 0
+            }
+          }
+
+          file_paths = Array(file_paths).compact
+          return result if file_paths.empty?
+
+          file_paths.each do |file_path|
+            # Apply exclusions even to direct paths
+            if excluded?(file_path)
+              result[:stats][:skipped_count] += 1
+              next
+            end
+
+            process_file(file_path, result)
+          end
+
+          result
+        end
+
+        # Find and aggregate files by name pattern
+        # @param pattern [String] File name pattern
+        # @param max_depth [Integer] Maximum directory depth
+        # @return [Hash] {files: Array, errors: Array, stats: Hash}
+        def find_and_aggregate(pattern, max_depth: nil)
+          files = Atoms::GlobExpander.find_files(
+            pattern,
+            base_dir: @base_dir,
+            max_depth: max_depth
+          )
+
+          aggregate_files(files)
+        end
+
+        private
+
+        # Expand patterns to file paths
+        # @param patterns [Array<String>] Patterns to expand
+        # @return [Array<String>] Expanded file paths
+        def expand_patterns(patterns)
+          Atoms::GlobExpander.expand_multiple(
+            patterns,
+            base_dir: @base_dir
+          )
+        end
+
+        # Filter out excluded files
+        # @param files [Array<String>] Files to filter
+        # @return [Array<String>] Filtered files
+        def filter_exclusions(files)
+          return files if @exclude_patterns.empty?
+
+          Atoms::GlobExpander.filter_excluded(
+            files,
+            @exclude_patterns
+          )
+        end
+
+        # Check if file is excluded
+        # @param file_path [String] File path to check
+        # @return [Boolean] true if excluded
+        def excluded?(file_path)
+          return false if @exclude_patterns.empty?
+
+          Atoms::GlobExpander.matches?(
+            file_path,
+            @exclude_patterns
+          )
+        end
+
+        # Process a single file
+        # @param file_path [String] File path
+        # @param result [Hash] Result hash to update
+        def process_file(file_path, result)
+          # Resolve file path relative to base directory if not absolute
+          resolved_path = File.absolute_path?(file_path) ? file_path : File.join(@base_dir, file_path)
+
+          # Make path relative to base directory for display
+          display_path = make_relative_path(resolved_path)
+
+          # Check if file is readable
+          unless Atoms::FileReader.readable?(resolved_path)
+            result[:errors] << "File not readable: #{display_path}"
+            result[:stats][:error_count] += 1
+            return
+          end
+
+          # Check if file is binary
+          if Atoms::FileReader.binary?(resolved_path)
+            result[:errors] << "Binary file skipped: #{display_path}"
+            result[:stats][:skipped_count] += 1
+            return
+          end
+
+          # Read file content
+          read_result = Atoms::FileReader.read(resolved_path, max_size: @max_size)
+
+          if read_result[:success]
+            result[:files] << {
+              path: display_path,
+              absolute_path: File.expand_path(resolved_path),
+              content: read_result[:content],
+              size: read_result[:size]
+            }
+
+            result[:stats][:file_count] += 1
+            result[:stats][:total_size] += read_result[:size]
+          else
+            result[:errors] << "Failed to read #{display_path}: #{read_result[:error]}"
+            result[:stats][:error_count] += 1
+          end
+        end
+
+        # Make path relative to base directory
+        # @param path [String] Path to make relative
+        # @return [String] Relative path if possible
+        def make_relative_path(path)
+          absolute = File.expand_path(path)
+          base_absolute = File.expand_path(@base_dir)
+
+          if absolute.start_with?(base_absolute)
+            Pathname.new(absolute).relative_path_from(Pathname.new(base_absolute)).to_s
+          else
+            path
+          end
+        rescue
+          path
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/molecules/frontmatter_free_policy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ace
+  module Core
+    module Molecules
+      # Shared frontmatter-free policy for path matching and config defaults.
+      class FrontmatterFreePolicy
+        MATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+        DEFAULT_PATTERNS = ["README.md", "*/README.md"].freeze
+
+        def self.patterns(config:, key: "frontmatter_free", default_patterns: DEFAULT_PATTERNS)
+          patterns = config[key]
+          return patterns if patterns.is_a?(Array) && !patterns.empty?
+
+          default_patterns
+        end
+
+        def self.match?(path, patterns:, project_root: Dir.pwd)
+          return false if path.nil? || path.to_s.empty?
+          return false if patterns.nil? || patterns.empty?
+
+          absolute_path = File.expand_path(path)
+          root = File.expand_path(project_root || Dir.pwd)
+          relative_path = absolute_path.sub(/^#{Regexp.escape(root)}\/?/, "")
+
+          patterns.any? do |pattern|
+            File.fnmatch?(pattern, relative_path, MATCH_FLAGS) ||
+              File.fnmatch?(pattern, absolute_path, MATCH_FLAGS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/core/molecules/output_formatter.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ace
+  module Core
+    module Molecules
+      # Formats aggregated content into various output formats
+      class OutputFormatter
+        # Supported output formats
+        FORMATS = %w[markdown yaml xml markdown-xml json].freeze
+
+        def initialize(format = "markdown")
+          @format = validate_format(format)
+        end
+
+        # Format aggregated content
+        # @param data [Hash] Aggregated data with files and commands
+        # @return [String] Formatted output
+        def format(data)
+          case @format
+          when "markdown"
+            format_markdown(data)
+          when "yaml"
+            format_yaml(data)
+          when "xml"
+            format_xml(data)
+          when "markdown-xml"
+            format_markdown_xml(data)
+          when "json"
+            format_json(data)
+          else
+            format_markdown(data)
+          end
+        end
+
+        # Format as pure markdown
+        # @param data [Hash] Data to format
+        # @return [String] Markdown formatted output
+        def format_markdown(data)
+          # If we have source content (embed_document_source mode), use raw content + XML blocks format
+          if data[:content] && !data[:content].to_s.empty?
+            return format_embedded_source(data)
+          end
+
+          output = []
+
+          # Add header
+          output << "# Context"
+          output << ""
+
+          # Add metadata if present
+          if data[:metadata]
+            # If we have original frontmatter YAML, output it as-is
+            if data[:metadata][:frontmatter_yaml]
+              output << "---"
+              output << data[:metadata][:frontmatter_yaml]
+              output << "---"
+              output << ""
+            else
+              # Otherwise use bulleted format
+              output << "## Metadata"
+              output << ""
+              data[:metadata].each do |key, value|
+                output << "- **#{key}**: #{value}"
+              end
+              output << ""
+            end
+          end
+
+          # Add files section
+          if data[:files] && !data[:files].empty?
+            output << "## Files"
+            output << ""
+
+            data[:files].each do |file|
+              output << "### #{file[:path]}"
+              output << ""
+              output << "```"
+              output << file[:content]
+              output << "```"
+              output << ""
+            end
+          end
+
+          # Add commands section
+          if data[:commands] && !data[:commands].empty?
+            output << "## Commands"
+            output << ""
+
+            data[:commands].each do |cmd|
+              output << "### Command: `#{cmd[:command]}`"
+              output << ""
+
+              if cmd[:success]
+                output << "**Output:**"
+                output << "```"
+                output << cmd[:output]
+                output << "```"
+              else
+                output << "**Error:** #{cmd[:error]}"
+              end
+              output << ""
+            end
+          end
+
+          # Add diffs section
+          if data[:diffs] && !data[:diffs].empty?
+            output << "## Git Diffs"
+            output << ""
+
+            data[:diffs].each do |diff|
+              output << "### Diff: `#{diff[:range]}`"
+              output << ""
+
+              if diff[:success]
+                output << "```diff"
+                output << diff[:output]
+                output << "```"
+              else
+                output << "**Error:** #{diff[:error]}"
+              end
+              output << ""
+            end
+          end
+
+          # Add errors section
+          if data[:errors] && !data[:errors].empty?
+            output << "## Errors"
+            output << ""
+            data[:errors].each do |error|
+              output << "- #{error}"
+            end
+            output << ""
+          end
+
+          output.join("\n").strip
+        end
+
+        # Format as YAML
+        # @param data [Hash] Data to format
+        # @return [String] YAML formatted output
+        def format_yaml(data)
+          clean_data = prepare_for_serialization(data)
+          YAML.dump(clean_data)
+        end
+
+        # Format as JSON
+        # @param data [Hash] Data to format
+        # @return [String] JSON formatted output
+        def format_json(data)
+          require "json"
+          clean_data = prepare_for_serialization(data)
+          JSON.pretty_generate(clean_data)
+        end
+
+        # Format as XML
+        # @param data [Hash] Data to format
+        # @return [String] XML formatted output
+        def format_xml(data)
+          output = []
+          output << '<?xml version="1.0" encoding="UTF-8"?>'
+          output << "<context>"
+
+          # Add metadata
+          if data[:metadata]
+            output << "  <metadata>"
+            data[:metadata].each do |key, value|
+              output << "    <#{key}>#{escape_xml(value.to_s)}</#{key}>"
+            end
+            output << "  </metadata>"
+          end
+
+          # Add files
+          if data[:files] && !data[:files].empty?
+            output << "  <files>"
+            data[:files].each do |file|
+              output << "    <file path=\"#{escape_xml(file[:path])}\" size=\"#{file[:size]}\">"
+              output << "      <content><![CDATA[#{file[:content]}]]></content>"
+              output << "    </file>"
+            end
+            output << "  </files>"
+          end
+
+          # Add commands
+          if data[:commands] && !data[:commands].empty?
+            output << "  <commands>"
+            data[:commands].each do |cmd|
+              output << "    <command name=\"#{escape_xml(cmd[:command])}\" success=\"#{cmd[:success]}\">"
+              if cmd[:output]
+                output << "      <output><![CDATA[#{cmd[:output]}]]></output>"
+              end
+              if cmd[:error]
+                output << "      <error>#{escape_xml(cmd[:error])}</error>"
+              end
+              output << "    </command>"
+            end
+            output << "  </commands>"
+          end
+
+          # Add diffs
+          if data[:diffs] && !data[:diffs].empty?
+            output << "  <diffs>"
+            data[:diffs].each do |diff|
+              output << "    <diff range=\"#{escape_xml(diff[:range])}\" success=\"#{diff[:success]}\">"
+              if diff[:output]
+                output << "      <output><![CDATA[#{diff[:output]}]]></output>"
+              end
+              if diff[:error]
+                output << "      <error>#{escape_xml(diff[:error])}</error>"
+              end
+              output << "    </diff>"
+            end
+            output << "  </diffs>"
+          end
+
+          # Add errors
+          if data[:errors] && !data[:errors].empty?
+            output << "  <errors>"
+            data[:errors].each do |error|
+              output << "    <error>#{escape_xml(error)}</error>"
+            end
+            output << "  </errors>"
+          end
+
+          output << "</context>"
+          output.join("\n")
+        end
+
+        # Format as markdown with embedded XML (hybrid format)
+        # @param data [Hash] Data to format
+        # @return [String] Markdown-XML formatted output
+        def format_markdown_xml(data)
+          # If we have source content (embed_document_source mode), use raw content + XML blocks format
+          if data[:content] && !data[:content].to_s.empty?
+            return format_embedded_source(data)
+          end
+
+          output = []
+
+          output << "# Context"
+          output << ""
+
+          # Add metadata
+          if data[:metadata]
+            # If we have original frontmatter YAML, output it as-is
+            if data[:metadata][:frontmatter_yaml]
+              output << "---"
+              output << data[:metadata][:frontmatter_yaml]
+              output << "---"
+              output << ""
+            else
+              # Otherwise use bulleted format
+              output << "## Metadata"
+              output << ""
+              data[:metadata].each do |key, value|
+                output << "- **#{key}**: #{value}"
+              end
+              output << ""
+            end
+          end
+
+          # Add files as XML blocks
+          if data[:files] && !data[:files].empty?
+            output << "## Files"
+            output << ""
+
+            data[:files].each do |file|
+              size_info = file[:size] ? " size=\"#{file[:size]}\"" : ""
+              output << "<file path=\"#{escape_xml(file[:path])}\"#{size_info}>"
+              output << file[:content]
+              output << "</file>"
+              output << ""
+            end
+          end
+
+          # Add commands
+          if data[:commands] && !data[:commands].empty?
+            output << "## Commands"
+            output << ""
+
+            data[:commands].each do |cmd|
+              success_attr = cmd[:success] ? "true" : "false"
+              error_attr = cmd[:error] ? " error=\"#{escape_xml(cmd[:error])}\"" : ""
+
+              output << "<output command=\"#{escape_xml(cmd[:command])}\" success=\"#{success_attr}\"#{error_attr}>"
+              output << ""
+              output << cmd[:output] if cmd[:output]
+              output << "</output>"
+              output << ""
+            end
+          end
+
+          # Add diffs
+          if data[:diffs] && !data[:diffs].empty?
+            output << "## Git Diffs"
+            output << ""
+
+            data[:diffs].each do |diff|
+              success_attr = diff[:success] ? "true" : "false"
+              error_attr = diff[:error] ? " error=\"#{escape_xml(diff[:error])}\"" : ""
+
+              output << "<diff range=\"#{escape_xml(diff[:range])}\" success=\"#{success_attr}\"#{error_attr}>"
+              output << ""
+              output << diff[:output] if diff[:output]
+              output << "</diff>"
+              output << ""
+            end
+          end
+
+          # Add errors
+          if data[:errors] && !data[:errors].empty?
+            output << "## Errors"
+            output << ""
+            data[:errors].each do |error|
+              output << "- #{error}"
+            end
+          end
+
+          output.join("\n").strip
+        end
+
+        private
+
+        # Validate and normalize format
+        # @param format [String] Format to validate
+        # @return [String] Valid format
+        def validate_format(format)
+          normalized = format.to_s.downcase
+          FORMATS.include?(normalized) ? normalized : "markdown"
+        end
+
+        # Prepare data for serialization (YAML/JSON)
+        # @param data [Hash] Data to prepare
+        # @return [Hash] Clean data for serialization
+        def prepare_for_serialization(data)
+          {
+            "metadata" => data[:metadata],
+            "files" => data[:files]&.map do |f|
+              {
+                "path" => f[:path],
+                "content" => f[:content],
+                "size" => f[:size]
+              }.compact
+            end,
+            "commands" => data[:commands]&.map do |c|
+              {
+                "command" => c[:command],
+                "output" => c[:output],
+                "success" => c[:success],
+                "error" => c[:error]
+              }.compact
+            end,
+            "errors" => data[:errors],
+            "stats" => data[:stats]
+          }.compact
+        end
+
+        # Format with embedded source content (raw document + XML blocks)
+        # @param data [Hash] Data to format
+        # @return [String] Raw content with appended XML blocks
+        def format_embedded_source(data)
+          output = []
+
+          # Output raw source content (includes frontmatter and markdown body)
+          output << data[:content]
+          output << ""
+
+          # Append files as XML block
+          if data[:files] && !data[:files].empty?
+            output << "<files>"
+            data[:files].each do |file|
+              output << "<file path=\"#{escape_xml(file[:path])}\">"
+              output << file[:content]
+              output << "</file>"
+              output << ""
+            end
+            output << "</files>"
+            output << ""
+          end
+
+          # Append commands as XML block
+          if data[:commands] && !data[:commands].empty?
+            output << "<commands>"
+            data[:commands].each do |cmd|
+              success_attr = cmd[:success] ? "true" : "false"
+              output << "<command name=\"#{escape_xml(cmd[:command])}\" success=\"#{success_attr}\">"
+              output << cmd[:output] if cmd[:output]
+              if cmd[:error]
+                output << "<error>#{escape_xml(cmd[:error])}</error>"
+              end
+              output << "</command>"
+              output << ""
+            end
+            output << "</commands>"
+            output << ""
+          end
+
+          # Append diffs as XML block
+          if data[:diffs] && !data[:diffs].empty?
+            output << "<diffs>"
+            data[:diffs].each do |diff|
+              success_attr = diff[:success] ? "true" : "false"
+              output << "<diff range=\"#{escape_xml(diff[:range])}\" success=\"#{success_attr}\">"
+              output << diff[:output] if diff[:output]
+              if diff[:error]
+                output << "<error>#{escape_xml(diff[:error])}</error>"
+              end
+              output << "</diff>"
+              output << ""
+            end
+            output << "</diffs>"
+            output << ""
+          end
+
+          output.join("\n").strip
+        end
+
+        # Escape XML special characters
+        # @param text [String] Text to escape
+        # @return [String] Escaped text
+        def escape_xml(text)
+          text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&apos;")
+        end
+      end
+    end
+  end
+end