ace-support-config 0.9.0

data/lib/ace/support/config/molecules/file_config_resolver.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ace
+  module Support
+    module Config
+      module Molecules
+        # Resolve effective config for a given file path using distributed configs and path rules
+        class FileConfigResolver
+          attr_reader :config_dir, :defaults_dir, :gem_path, :merge_strategy
+
+          def initialize(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults",
+            gem_path: nil,
+            merge_strategy: :replace
+          )
+            @config_dir = config_dir
+            @defaults_dir = defaults_dir
+            @gem_path = gem_path
+            @merge_strategy = merge_strategy
+          end
+
+          # Resolve config for a file
+          # @param file_path [String] File path (relative or absolute)
+          # @param namespace [String] Config namespace (default: "git")
+          # @param filename [String] Config filename without extension (default: "commit")
+          # @param project_root [String, nil] Explicit project root (overrides auto-detection)
+          # @return [Models::ConfigGroup] Resolved config group for the file
+          def resolve(file_path, namespace: "git", filename: "commit", project_root: nil)
+            raise ArgumentError, "file_path cannot be nil or empty" if file_path.nil? || file_path.to_s.empty?
+
+            start_path = resolve_start_path(file_path)
+            project_root = normalize_path(project_root || detect_project_root(start_path) || start_path)
+            relative_path = to_relative_path(file_path, project_root)
+
+            distributed_config_path = find_distributed_config(start_path, project_root, namespace, filename)
+            if distributed_config_path && project_root
+              root_config_dir = File.join(project_root, config_dir.to_s)
+              root_prefix = normalize_path(root_config_dir) + File::SEPARATOR
+              if normalize_path(distributed_config_path).start_with?(root_prefix)
+                distributed_config_path = nil
+              end
+            end
+            config = load_cascade_config(start_path, project_root, namespace, filename)
+            base_data = extract_config_data(config)
+
+            # Check path rules FIRST (before distributed config scope)
+            matched = match_path_rule(base_data, relative_path, project_root)
+            if matched
+              resolved = merge_rule_overrides(strip_paths_section(base_data), matched.config)
+              return Models::ConfigGroup.new(
+                name: matched.name,
+                source: primary_source_path(config, namespace, filename, start_path, project_root),
+                config: resolved,
+                rule_config: matched.config, # Raw rule config for grouping (ignores cascade differences)
+                files: [relative_path]
+              )
+            end
+
+            # Fall back to distributed config scope if present
+            if distributed_config_path
+              resolved = strip_paths_section(base_data)
+              scope_name = scope_name_from_config_path(distributed_config_path, project_root)
+              return Models::ConfigGroup.new(
+                name: scope_name,
+                source: distributed_config_path,
+                config: resolved,
+                files: [relative_path]
+              )
+            end
+
+            Models::ConfigGroup.new(
+              name: Models::ConfigGroup::DEFAULT_SCOPE_NAME,
+              source: primary_source_path(config, namespace, filename, start_path, project_root),
+              config: strip_paths_section(base_data),
+              files: [relative_path]
+            )
+          end
+
+          private
+
+          def resolve_start_path(file_path)
+            path = file_path.to_s
+            absolute = Pathname.new(path).absolute? ? path : File.expand_path(path, Dir.pwd)
+            File.directory?(absolute) ? absolute : File.dirname(absolute)
+          end
+
+          def to_relative_path(file_path, project_root)
+            path = file_path.to_s.sub(%r{\A\./}, "")
+            return path unless project_root
+
+            absolute = Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+            root = File.expand_path(project_root)
+            if absolute.start_with?(root + File::SEPARATOR)
+              absolute.sub("#{root}/", "")
+            else
+              path
+            end
+          end
+
+          def find_distributed_config(start_path, project_root, namespace, filename)
+            patterns = config_patterns(namespace, filename)
+            root = project_root || start_path
+            current = File.expand_path(start_path.to_s)
+            root = File.expand_path(root.to_s)
+
+            loop do
+              config_path = File.join(current, config_dir)
+              if project_root
+                root_config = File.join(File.expand_path(project_root.to_s), config_dir.to_s)
+                config_path = nil if File.expand_path(config_path) == File.expand_path(root_config)
+              end
+
+              if config_path && Dir.exist?(config_path)
+                patterns.each do |pattern|
+                  candidate = File.join(config_path, pattern)
+                  return candidate if File.exist?(candidate)
+                end
+              end
+
+              break if current == root
+
+              parent = File.dirname(current)
+              break if parent == current
+
+              current = parent
+            end
+
+            nil
+          end
+
+          def config_patterns(namespace, filename)
+            [
+              File.join(namespace, "#{filename}.yml"),
+              File.join(namespace, "#{filename}.yaml")
+            ]
+          end
+
+          def load_cascade_config(start_path, project_root, namespace, filename)
+            patterns = config_patterns(namespace, filename)
+            cascade_paths = find_cascade_paths(start_path, project_root, patterns)
+            if cascade_paths.empty?
+              return Models::Config.new({}, source: "no_config_found", merge_strategy: merge_strategy)
+            end
+
+            configs = cascade_paths.map do |path|
+              Molecules::YamlLoader.load_file(path)
+            end
+
+            # Merge configs in reverse order (root first, then nested)
+            merged_data = configs.reverse.reduce({}) do |result, config|
+              Atoms::DeepMerger.merge(
+                result,
+                config.data,
+                array_strategy: merge_strategy
+              )
+            end
+
+            # Collect paths with source tracking
+            # Process in reverse (root first) so more specific configs override
+            paths_with_sources = collect_paths_with_sources(cascade_paths.reverse, project_root)
+            if paths_with_sources.any?
+              # Replace merged scopes/paths with source-tracked paths
+              merged_data = merged_data.dup
+              merged_data.delete("scopes")
+              merged_data.delete(:scopes)
+              merged_data.delete("paths")
+              merged_data.delete(:paths)
+              merged_data.delete("path_rules")
+              merged_data.delete(:path_rules)
+
+              # Check if scopes/paths were in git section
+              if merged_data["git"].is_a?(Hash)
+                merged_data["git"] = merged_data["git"].dup
+                merged_data["git"].delete("scopes")
+                merged_data["git"].delete(:scopes)
+                merged_data["git"].delete("paths")
+                merged_data["git"].delete(:paths)
+                merged_data["git"].delete("path_rules")
+                merged_data["git"].delete(:path_rules)
+              end
+
+              merged_data["scopes"] = paths_with_sources
+            end
+
+            sources = cascade_paths.join(" -> ")
+            Models::Config.new(
+              merged_data,
+              source: sources,
+              merge_strategy: merge_strategy
+            )
+          end
+
+          # Collect path rules from all configs, tracking source directory
+          # @param cascade_paths [Array<String>] Config paths from root to nested
+          # @param project_root [String, nil] Project root directory
+          # @return [Hash] Path rules with _config_root metadata
+          def collect_paths_with_sources(cascade_paths, project_root)
+            all_paths = {}
+
+            cascade_paths.each do |config_path|
+              config = Molecules::YamlLoader.load_file(config_path)
+              data = config.data || {}
+
+              # Config root is the directory containing the .ace/ folder
+              # e.g., /project/ace-bundle/.ace/git/commit.yml → /project/ace-bundle
+              config_root = config_root_from_path(config_path)
+
+              # Look for scopes/paths in both git section and root
+              paths = data.dig("git", "scopes") || data.dig("git", :scopes) ||
+                data.dig("git", "paths") || data.dig("git", :paths) ||
+                data["scopes"] || data[:scopes] ||
+                data["paths"] || data[:paths] ||
+                data.dig("git", "path_rules") || data.dig("git", :path_rules) ||
+                data["path_rules"] || data[:path_rules]
+
+              next unless paths.is_a?(Hash)
+
+              paths.each do |name, rule|
+                next unless rule.is_a?(Hash)
+
+                # Clone rule and add source tracking
+                tracked_rule = rule.dup
+                tracked_rule["_config_root"] = config_root
+                all_paths[name.to_s] = tracked_rule
+              end
+            end
+
+            # All inherited rules should be relative to closest (most nested) config
+            # This ensures inherited path rules like ".ace/**" match from the nested config's location
+            if cascade_paths.any? && all_paths.any?
+              closest_root = config_root_from_path(cascade_paths.last)
+              all_paths.each_value { |rule| rule["_config_root"] = closest_root }
+            end
+
+            all_paths
+          end
+
+          # Extract config root directory from config file path
+          # @param config_path [String] Path to config file (e.g., /project/.ace/git/commit.yml)
+          # @return [String] Directory containing .ace/ folder
+          def config_root_from_path(config_path)
+            # Split on .ace/ and take the first part
+            parts = config_path.to_s.split("#{File::SEPARATOR}#{config_dir}#{File::SEPARATOR}")
+            if parts.length >= 2
+              normalize_path(parts.first)
+            else
+              # Fallback: go up from config file
+              normalize_path(File.dirname(config_path, 3))
+            end
+          end
+
+          def extract_config_data(config)
+            data = config.data || {}
+            git_data = data["git"] || data[:git]
+            return data unless git_data.is_a?(Hash)
+
+            root_overrides = data.reject { |key, _| key.to_s == "git" }
+            Atoms::DeepMerger.merge(
+              git_data,
+              root_overrides,
+              array_strategy: merge_strategy
+            )
+          end
+
+          def match_path_rule(base_data, relative_path, project_root)
+            rules = base_data["scopes"] || base_data[:scopes] ||
+              base_data["paths"] || base_data[:paths] ||
+              base_data["path_rules"] || base_data[:path_rules]
+            matcher = Atoms::PathRuleMatcher.new(normalize_path_rules(rules), project_root: project_root)
+            matcher.match(relative_path)
+          end
+
+          def merge_rule_overrides(base_data, overrides)
+            Atoms::DeepMerger.merge(
+              base_data,
+              overrides || {},
+              array_strategy: merge_strategy
+            )
+          end
+
+          def strip_paths_section(base_data)
+            return {} if base_data.nil?
+
+            stripped = base_data.dup
+            stripped.delete("scopes")
+            stripped.delete(:scopes)
+            stripped.delete("paths")
+            stripped.delete(:paths)
+            stripped.delete("path_rules")
+            stripped.delete(:path_rules)
+            stripped
+          end
+
+          def normalize_path_rules(rules)
+            return {} if rules.nil?
+            return rules if rules.is_a?(Hash)
+
+            Array(rules).each_with_index.each_with_object({}) do |(rule, index), acc|
+              next unless rule.is_a?(Hash)
+
+              name = rule["name"] || rule[:name] || "rule-#{index + 1}"
+              acc[name.to_s] = rule
+            end
+          end
+
+          def scope_name_from_config_path(config_path, project_root)
+            config_path_str = config_path.to_s
+            scope_root = config_path_str.split("#{File::SEPARATOR}#{config_dir}#{File::SEPARATOR}").first
+            scope_root = File.dirname(config_path_str) if scope_root.nil? || scope_root.empty?
+
+            if project_root
+              root = File.expand_path(project_root.to_s)
+              scope = File.expand_path(scope_root.to_s)
+              return Models::ConfigGroup::DEFAULT_SCOPE_NAME if scope == root
+              return scope.sub("#{root}/", "") if scope.start_with?(root + File::SEPARATOR)
+
+              root_real = normalize_path(project_root)
+              scope_real = normalize_path(scope_root)
+              return Models::ConfigGroup::DEFAULT_SCOPE_NAME if scope_real == root_real
+              return scope_real.sub("#{root_real}/", "") if scope_real.start_with?(root_real + File::SEPARATOR)
+            end
+
+            scope_root
+          end
+
+          def find_cascade_paths(start_path, project_root, patterns)
+            paths = []
+            root = project_root || start_path
+            current = File.expand_path(start_path.to_s)
+            root = File.expand_path(root.to_s)
+
+            loop do
+              config_path = File.join(current, config_dir)
+              if Dir.exist?(config_path)
+                patterns.each do |pattern|
+                  candidate = File.join(config_path, pattern)
+                  paths << candidate if File.exist?(candidate)
+                end
+              end
+
+              break if current == root
+
+              parent = File.dirname(current)
+              break if parent == current
+
+              current = parent
+            end
+
+            home_config = File.expand_path("~/#{config_dir}")
+            if Dir.exist?(home_config)
+              patterns.each do |pattern|
+                candidate = File.join(home_config, pattern)
+                paths << candidate if File.exist?(candidate)
+              end
+            end
+
+            if gem_path
+              defaults_path = File.join(gem_path, defaults_dir)
+              if Dir.exist?(defaults_path)
+                patterns.each do |pattern|
+                  candidate = File.join(defaults_path, pattern)
+                  paths << candidate if File.exist?(candidate)
+                end
+              end
+            end
+
+            paths
+          end
+
+          def normalize_path(path)
+            File.realpath(path)
+          rescue Errno::ENOENT, Errno::EACCES
+            File.expand_path(path.to_s)
+          end
+
+          def detect_project_root(start_path)
+            markers = Ace::Support::Fs::Molecules::ProjectRootFinder::DEFAULT_MARKERS
+            current = File.expand_path(start_path.to_s)
+            fallback_root = nil
+
+            # .git is definitive - keep searching for it even after finding weaker markers
+            loop do
+              return current if File.exist?(File.join(current, ".git"))
+
+              # Remember first match of any marker as fallback
+              if fallback_root.nil?
+                markers.each do |marker|
+                  next if marker == ".git"
+                  if File.exist?(File.join(current, marker))
+                    fallback_root = current
+                    break
+                  end
+                end
+              end
+
+              parent = File.dirname(current)
+              break if parent == current
+
+              current = parent
+            end
+
+            fallback_root
+          end
+
+          def primary_source_path(config, namespace, filename, start_path, project_root)
+            return config.source if config.source && config.source != "no_config_found"
+
+            patterns = config_patterns(namespace, filename)
+            found = find_cascade_paths(start_path, project_root, patterns).first
+            found || "no_config_found"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/config/molecules/project_config_scanner.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Config
+      module Molecules
+        # Scan project tree downward to find all config folders (.ace)
+        #
+        # Complements ConfigFinder's upward traversal by scanning the entire project
+        # tree for all config directories. Useful for monorepos where multiple packages
+        # have distributed configurations.
+        #
+        # @example Scan all .ace folders
+        #   scanner = ProjectConfigScanner.new(project_root: Dir.pwd)
+        #   scanner.scan
+        #   # => { "." => ["git/commit.yml"], "ace-bundle" => ["git/commit.yml"] }
+        #
+        # @example Find specific config across project
+        #   scanner.find_all(namespace: "git", filename: "commit")
+        #   # => { "." => "/project/.ace/git/commit.yml" }
+        class ProjectConfigScanner
+          # Directories to skip during traversal
+          SKIP_DIRS = %w[.git .cache vendor node_modules tmp coverage
+            .bundle _legacy .ace-local .ace-tasks .ace-taskflow].freeze
+
+          # @param project_root [String, nil] Root directory to scan (default: Dir.pwd)
+          # @param config_dir [String] Config folder name (default: ".ace")
+          def initialize(project_root: nil, config_dir: ".ace")
+            @project_root = File.expand_path(project_root || Dir.pwd)
+            @config_dir = config_dir
+          end
+
+          # Scan project tree for all config folders and their files
+          #
+          # Results are memoized so multiple calls reuse one traversal.
+          #
+          # @return [Hash{String => Array<String>}] Map of relative location => config file list
+          def scan
+            @scan_result ||= perform_scan
+          end
+
+          # Find all instances of a specific config file across the project
+          #
+          # @param namespace [String] Config namespace (e.g., "git")
+          # @param filename [String] Config filename without extension (e.g., "commit")
+          # @return [Hash{String => String}] Map of relative location => absolute file path
+          def find_all(namespace:, filename:)
+            result = {}
+
+            scan.each do |location, files|
+              yml_target = "#{namespace}/#{filename}.yml"
+              yaml_target = "#{namespace}/#{filename}.yaml"
+
+              matched = if files.include?(yml_target)
+                yml_target
+              elsif files.include?(yaml_target)
+                yaml_target
+              end
+
+              next unless matched
+
+              ace_dir = location_to_ace_dir(location)
+              result[location] = File.join(ace_dir, matched)
+            end
+
+            result
+          end
+
+          private
+
+          # Perform the actual filesystem scan (called once; result memoized by scan)
+          def perform_scan
+            return {} unless Dir.exist?(@project_root)
+
+            result = {}
+
+            find_ace_dirs.each do |ace_dir_abs|
+              location = relative_location(ace_dir_abs)
+              result[location] = enumerate_config_files(ace_dir_abs)
+            end
+
+            result
+          end
+
+          # Find all .ace directories in the project tree
+          def find_ace_dirs
+            seen_real = {}
+            dirs = []
+
+            # Check root config dir first
+            root_ace = File.join(@project_root, @config_dir)
+            if Dir.exist?(root_ace)
+              real = File.realpath(root_ace)
+              seen_real[real] = true
+              dirs << root_ace
+            end
+
+            # Find nested config dirs (Dir.glob with FNM_DOTMATCH to match hidden dirs)
+            glob_results = begin
+              Dir.glob("**/#{@config_dir}", File::FNM_DOTMATCH, base: @project_root).sort
+            rescue Errno::EACCES
+              []
+            end
+
+            glob_results.each do |rel|
+              next if rel == @config_dir # already handled root
+              next if skip_path?(rel)
+
+              begin
+                abs = File.join(@project_root, rel)
+                next unless Dir.exist?(abs)
+
+                real = File.realpath(abs)
+                next if seen_real[real]
+
+                seen_real[real] = true
+                dirs << abs
+              rescue Errno::EACCES
+                next # skip this one path, continue scanning
+              end
+            end
+
+            dirs
+          end
+
+          # Enumerate config files within an .ace directory
+          def enumerate_config_files(ace_dir_abs)
+            return [] unless Dir.exist?(ace_dir_abs)
+
+            begin
+              Dir.glob("**/*", base: ace_dir_abs).select do |f|
+                File.file?(File.join(ace_dir_abs, f))
+              end.sort
+            rescue Errno::EACCES
+              []
+            end
+          end
+
+          # Convert absolute .ace dir path to relative location key
+          def relative_location(ace_dir_abs)
+            parent = File.dirname(ace_dir_abs)
+            rel = parent.delete_prefix(@project_root).delete_prefix("/")
+            rel.empty? ? "." : rel
+          end
+
+          # Convert relative location key back to absolute .ace dir path
+          def location_to_ace_dir(location)
+            if location == "."
+              File.join(@project_root, @config_dir)
+            else
+              File.join(@project_root, location, @config_dir)
+            end
+          end
+
+          # Check if a relative path should be skipped
+          def skip_path?(rel_path)
+            components = rel_path.split(File::SEPARATOR)
+            components.any? { |c| SKIP_DIRS.include?(c) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/config/molecules/yaml_loader.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Support
+    module Config
+      module Molecules
+        # YAML file loading with error handling
+        class YamlLoader
+          # Load YAML from file
+          # @param filepath [String] Path to YAML file
+          # @return [Models::Config] Loaded configuration
+          # @raise [ConfigNotFoundError] if file doesn't exist
+          # @raise [YamlParseError] if YAML is invalid
+          def self.load_file(filepath)
+            unless File.exist?(filepath)
+              raise ConfigNotFoundError, "Configuration file not found: #{filepath}"
+            end
+
+            content = File.read(filepath)
+            data = Atoms::YamlParser.parse(content)
+
+            Models::Config.new(data, source: filepath)
+          rescue IOError, SystemCallError => e
+            raise ConfigNotFoundError, "Failed to read file #{filepath}: #{e.message}"
+          end
+
+          # Load YAML from file, return empty config if not found
+          # @param filepath [String] Path to YAML file
+          # @return [Models::Config] Loaded configuration or empty config
+          def self.load_file_safe(filepath)
+            load_file(filepath)
+          rescue ConfigNotFoundError
+            Models::Config.new({}, source: "#{filepath} (not found)")
+          end
+
+          # Save configuration to YAML file
+          # @param config [Models::Config, Hash] Configuration to save
+          # @param filepath [String] Path to save to
+          # @raise [IOError] if save fails
+          def self.save_file(config, filepath)
+            data = config.is_a?(Models::Config) ? config.data : config
+            yaml_content = Atoms::YamlParser.dump(data)
+
+            # Create directory if it doesn't exist
+            dir = File.dirname(filepath)
+            FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+            File.write(filepath, yaml_content)
+          rescue IOError, SystemCallError => e
+            raise IOError, "Failed to save file #{filepath}: #{e.message}"
+          end
+
+          # Load and merge multiple YAML files
+          # @param filepaths [Array<String>] Paths to YAML files
+          # @param merge_strategy [Symbol] How to merge arrays (:replace, :concat, :union)
+          # @return [Models::Config] Merged configuration
+          def self.load_and_merge(*filepaths, merge_strategy: :replace)
+            configs = filepaths.flatten.map do |filepath|
+              load_file_safe(filepath)
+            end
+
+            return Models::Config.new({}, source: "empty") if configs.empty?
+
+            # Merge all configs using the specified strategy
+            merged_data = configs.map(&:data).reduce({}) do |result, data|
+              Atoms::DeepMerger.merge(result, data, array_strategy: merge_strategy)
+            end
+
+            Models::Config.new(
+              merged_data,
+              source: "merged(#{filepaths.join(", ")})",
+              merge_strategy: merge_strategy
+            )
+          end
+        end
+      end
+    end
+  end
+end