ace-support-config 0.10.2 → 0.16.3

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Config
+      module Molecules
+        class SetupDoctorReporter
+          COLORS = {
+            red: "\e[31m",
+            yellow: "\e[33m",
+            green: "\e[32m",
+            blue: "\e[34m",
+            cyan: "\e[36m",
+            reset: "\e[0m",
+            bold: "\e[1m"
+          }.freeze
+
+          ICONS = {
+            doctor: "🏥",
+            stats: "📊",
+            success: "✅",
+            error: "❌",
+            warning: "⚠️",
+            info: "ℹ️"
+          }.freeze
+
+          STATUS_GLYPHS = {
+            "pass" => "✓",
+            "warn" => "○",
+            "blocker" => "✗",
+            "skip" => "○",
+            "info" => "○"
+          }.freeze
+
+          STATUS_COLORS = {
+            "pass" => :green,
+            "warn" => :yellow,
+            "blocker" => :red,
+            "skip" => :yellow,
+            "info" => :cyan
+          }.freeze
+
+          def self.format_results(results, format: :terminal, hygiene: false, verbose: false, colors: true)
+            case format.to_sym
+            when :json
+              JSON.pretty_generate(results)
+            else
+              new(results, hygiene: hygiene, verbose: verbose, colors: colors).format_terminal
+            end
+          end
+
+          def initialize(results, hygiene:, verbose:, colors:)
+            @results = results
+            @hygiene = hygiene
+            @verbose = verbose
+            @colors = colors
+          end
+
+          def format_terminal
+            output = []
+            output << "\n#{colorize("#{ICONS[:doctor]} Setup Health Check", :bold)}"
+            output << "=" * 40
+            output.concat(format_overview)
+            output.concat(format_readiness)
+            output.concat(format_info)
+            output.concat(format_provider_pings)
+            output.concat(format_issues)
+            output << "=" * 40
+            output << format_summary_line
+            output << "\n#{colorize("Completed in #{format_duration(@results[:duration])}", :blue)}" if @results[:duration]
+            output << final_status_line
+            output.join("\n")
+          end
+
+          private
+
+          def format_overview
+            stats = @results[:stats] || {}
+            [
+              "",
+              colorize("#{ICONS[:stats]} Overview", :cyan),
+              "-" * 20,
+              "  Health checks: #{stats[:health_checks] || health_checks.length}",
+              "  Info checks: #{stats[:info_checks] || info_checks.length}",
+              "  Utility providers checked: #{stats[:provider_targets] || provider_outcomes.length}",
+              "  Hygiene findings: #{stats[:hygiene_findings] || 0}"
+            ]
+          end
+
+          def format_readiness
+            rows = health_checks.reject { |check| check[:id] == "probe-readiness" }
+            return [] if rows.empty?
+
+            output = ["", colorize("Readiness", :cyan), "-" * 20]
+            rows.each do |check|
+              output << "  #{status_glyph(check[:status])} #{check[:message]}"
+              if check[:status] == "blocker" || check[:status] == "warn" || @verbose
+                Array(check[:details]).each { |detail| output << "    - #{detail}" }
+                output << "    Next: #{check[:next_action]}" if check[:next_action]
+              end
+            end
+            output
+          end
+
+          def format_info
+            return [] if info_checks.empty?
+
+            output = ["", colorize("Info", :cyan), "-" * 20]
+            info_checks.each do |check|
+              output << "  #{status_glyph(check[:status])} #{check[:message]}"
+              if @verbose
+                Array(check[:details]).each { |detail| output << "    - #{detail}" }
+                output << "    Next: #{check[:next_action]}" if check[:next_action]
+              end
+            end
+            output
+          end
+
+          def format_provider_pings
+            check = health_checks.find { |row| row[:id] == "probe-readiness" }
+            return [] unless check
+
+            output = ["", colorize("Utility Provider Pings", :cyan), "-" * 20]
+            output << "  #{status_glyph(check[:status])} #{check[:message]}"
+            details = provider_outcomes.any? ? provider_outcomes.map { |outcome| provider_outcome_line(outcome) } : Array(check[:details])
+            details.each { |detail| output << "    #{detail}" }
+            output << "    Next: #{check[:next_action]}" if check[:next_action]
+            output
+          end
+
+          def format_issues
+            blockers = health_checks.select { |check| check[:status] == "blocker" }
+            warnings = health_checks.select { |check| check[:status] == "warn" }
+            hygiene_warnings = hygiene_checks.reject { |check| check[:status] == "pass" }
+
+            if blockers.empty? && warnings.empty? && hygiene_warnings.empty?
+              return ["", colorize("#{ICONS[:success]} No issues found", :green)]
+            end
+
+            output = ["", colorize("Issues Found:", :yellow), "-" * 20]
+            output.concat(format_issue_group("#{ICONS[:error]} Blockers", blockers, :red, include_details: true))
+            output.concat(format_issue_group("#{ICONS[:warning]} Warnings", warnings, :yellow, include_details: true))
+            output.concat(format_hygiene_group(hygiene_warnings))
+            output
+          end
+
+          def format_issue_group(title, checks, color, include_details:)
+            return [] if checks.empty?
+
+            output = ["", colorize("#{title} (#{checks.length})", color)]
+            checks.each_with_index do |check, index|
+              output << "#{index + 1}. #{check[:message]}"
+              if include_details
+                Array(check[:details]).each { |detail| output << "   - #{detail}" }
+              end
+              output << "   Next: #{check[:next_action]}" if check[:next_action]
+            end
+            output
+          end
+
+          def format_hygiene_group(checks)
+            finding_count = @results.dig(:hygiene, :finding_count) || 0
+            return [] if finding_count.zero?
+
+            if !@hygiene && !@verbose
+              return [
+                "",
+                colorize("#{ICONS[:warning]} Hygiene", :yellow),
+                "1. Hygiene findings detected (#{finding_count}); rerun with --hygiene for details"
+              ]
+            end
+
+            output = ["", colorize("#{ICONS[:warning]} Hygiene (#{finding_count})", :yellow)]
+            issue_number = 1
+            checks.each do |check|
+              output << "#{issue_number}. #{check[:message]}"
+              Array(check[:details]).each { |detail| output << "   - #{detail}" }
+              output << "   Next: #{check[:next_action]}" if check[:next_action]
+              issue_number += 1
+            end
+            output
+          end
+
+          def format_summary_line
+            health = @results[:health] || {}
+            hygiene = @results[:hygiene] || {}
+            info = @results[:info] || {}
+            parts = []
+            parts << colorize("#{health[:blocker_count]} blockers", health[:blocker_count].to_i.positive? ? :red : :green)
+            parts << colorize("#{health[:warning_count]} warnings", health[:warning_count].to_i.positive? ? :yellow : :green)
+            parts << colorize("#{info[:count]} info", :cyan)
+            parts << colorize("#{hygiene[:finding_count]} hygiene findings", hygiene[:finding_count].to_i.positive? ? :yellow : :green)
+            parts.join(", ")
+          end
+
+          def final_status_line
+            if @results[:valid]
+              if @results.dig(:health, :warning_count).to_i.positive? || @results.dig(:hygiene, :finding_count).to_i.positive?
+                colorize("Setup check passed with warnings", :yellow)
+              else
+                colorize("Setup check passed", :green)
+              end
+            else
+              colorize("Setup check failed", :red)
+            end
+          end
+
+          def provider_outcome_line(outcome)
+            elapsed = outcome[:elapsed_ms] ? " in #{outcome[:elapsed_ms]}ms" : ""
+            glyph = outcome[:status] == "pass" ? status_glyph(outcome[:status]) : colorize("✗", :red)
+            suffix = if outcome[:status] == "pass"
+              elapsed
+            elsif outcome[:failure_type] == "timeout"
+              " timed out after #{outcome[:timeout_seconds]}s"
+            else
+              " failed"
+            end
+            "#{glyph} #{target_display(outcome)}#{suffix}"
+          end
+
+          def target_display(target)
+            label = target[:label].to_s
+            selector = target[:selector].to_s
+            label = selector if label.empty?
+            selector.empty? || selector == label ? label : "#{label} (#{selector})"
+          end
+
+          def status_glyph(status)
+            glyph = STATUS_GLYPHS.fetch(status.to_s, STATUS_GLYPHS["warn"])
+            colorize(glyph, STATUS_COLORS.fetch(status.to_s, :yellow))
+          end
+
+          def health_checks
+            @health_checks ||= checks.select { |check| check[:kind] == "health" }
+          end
+
+          def hygiene_checks
+            @hygiene_checks ||= checks.select { |check| check[:kind] == "hygiene" }
+          end
+
+          def info_checks
+            @info_checks ||= checks.select { |check| check[:kind] == "info" }
+          end
+
+          def provider_outcomes
+            @provider_outcomes ||= Array(health_checks.find { |row| row[:id] == "probe-readiness" }&.fetch(:outcomes, []))
+          end
+
+          def checks
+            @results[:checks] || []
+          end
+
+          def format_duration(duration)
+            return "0ms" unless duration
+
+            duration < 1 ? "#{(duration * 1000).round}ms" : "#{duration.round(2)}s"
+          end
+
+          def colorize(text, color)
+            return text unless @colors && COLORS[color]
+
+            "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/config/organisms/config_synchronizer.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "../models/config_templates"
+
+module Ace
+  module Support
+    module Config
+      module Organisms
+        class ConfigSynchronizer
+          PROJECT_ROOT_DIR = "project-root"
+          GITIGNORE_ACE_LOCAL_ENTRY = ".ace-local/"
+
+          def initialize(force: false, dry_run: false, global: false, verbose: false)
+            @force = force
+            @dry_run = dry_run
+            @global = global
+            @verbose = verbose
+            @copied_files = []
+            @skipped_files = []
+          end
+
+          def sync_all
+            puts "Syncing all ace-* gem configurations..." if @verbose
+
+            Models::ConfigTemplates.all_gems.each do |gem_name|
+              sync_gem(gem_name)
+            end
+
+            print_summary
+          end
+
+          def sync_gem(gem_name)
+            gem_name = normalize_gem_name(gem_name)
+
+            unless Models::ConfigTemplates.gem_exists?(gem_name)
+              puts "Warning: No configuration found for #{gem_name}"
+              return
+            end
+
+            puts "\nSyncing #{gem_name}..." if @verbose
+
+            source_dir = Models::ConfigTemplates.example_dir_for(gem_name)
+            target_dir = target_directory
+
+            unless File.exist?(source_dir)
+              puts "Warning: No .ace-defaults directory found for #{gem_name}"
+              return
+            end
+
+            show_config_docs_if_needed(gem_name, target_dir)
+            copy_config_files(source_dir, target_dir)
+          end
+
+          private
+
+          def normalize_gem_name(name)
+            name.start_with?("ace-") ? name : "ace-#{name}"
+          end
+
+          def target_directory
+            return File.expand_path("~/.ace") if @global
+
+            File.join(project_root, ".ace")
+          end
+
+          def show_config_docs_if_needed(gem_name, target_dir)
+            config_subdir = gem_name.sub("ace-", "")
+            existing_configs = Dir.glob("#{target_dir}/#{config_subdir}/**/*").reject { |f| File.directory?(f) }
+
+            return if existing_configs.any? || @dry_run
+
+            docs_file = Models::ConfigTemplates.docs_file_for(gem_name)
+            puts "\n#{File.read(docs_file)}\n" if docs_file && File.exist?(docs_file)
+          end
+
+          def copy_config_files(source_dir, target_dir)
+            glob_pattern = File.join(source_dir, "**", "*")
+
+            Dir.glob(glob_pattern, File::FNM_DOTMATCH).each do |source_file|
+              basename = File.basename(source_file)
+              next if basename == "." || basename == ".."
+              next if File.directory?(source_file)
+
+              relative_path = Pathname.new(source_file).relative_path_from(Pathname.new(source_dir))
+              target_file = target_file_for(relative_path, target_dir)
+              next unless target_file
+
+              copy_file(source_file, target_file)
+            end
+          end
+
+          def copy_file(source, target)
+            if File.basename(target) == ".gitignore"
+              merge_gitignore(source, target)
+              return
+            end
+
+            if File.exist?(target) && !@force
+              @skipped_files << target
+              puts "  Skipped: #{target} (already exists)" if @verbose
+              return
+            end
+
+            if @dry_run
+              puts "  Would copy: #{source} -> #{target}"
+            else
+              FileUtils.mkdir_p(File.dirname(target))
+              FileUtils.cp(source, target)
+              @copied_files << target
+              puts "  Copied: #{target}" if @verbose
+            end
+          end
+
+          def target_file_for(relative_path, target_dir)
+            relative_str = relative_path.to_s
+
+            if relative_str.start_with?("#{PROJECT_ROOT_DIR}/")
+              return nil if @global
+
+              return File.join(project_root, relative_str.delete_prefix("#{PROJECT_ROOT_DIR}/"))
+            end
+
+            File.join(target_dir, relative_str)
+          end
+
+          def merge_gitignore(source, target)
+            target_exists = File.exist?(target)
+
+            if target_exists
+              merge_gitignore_entry_if_missing(source, target)
+              return
+            end
+
+            if @dry_run
+              puts "  Would copy: #{source} -> #{target}"
+            else
+              FileUtils.mkdir_p(File.dirname(target))
+              FileUtils.cp(source, target)
+              @copied_files << target
+              puts "  Copied: #{target}" if @verbose
+            end
+          end
+
+          def merge_gitignore_entry_if_missing(source, target)
+            existing_content = File.read(target)
+            return if gitignore_entry_present?(existing_content, GITIGNORE_ACE_LOCAL_ENTRY)
+
+            line = File.readlines(source, chomp: true).find do |entry|
+              entry == GITIGNORE_ACE_LOCAL_ENTRY
+            end
+            return unless line
+
+            if @dry_run
+              puts "  Would append: #{line} -> #{target}"
+              return
+            end
+
+            File.open(target, "a") do |file|
+              file.write("\n") unless existing_content.end_with?("\n") || existing_content.empty?
+              file.puts line
+            end
+
+            @copied_files << target
+            puts "  Appended: #{line} -> #{target}" if @verbose
+          end
+
+          def gitignore_entry_present?(content, entry)
+            content.each_line.any? do |line|
+              normalized = line.strip
+              next false if normalized.empty? || normalized.start_with?("#")
+
+              normalized == entry
+            end
+          end
+
+          def project_root
+            @project_root ||= Ace::Support::Config.find_project_root(start_path: Dir.pwd) || Dir.pwd
+          end
+
+          def print_summary
+            return if @dry_run
+
+            puts "\nConfiguration sync complete:"
+            puts "  Files copied: #{@copied_files.size}"
+            puts "  Files skipped: #{@skipped_files.size}"
+
+            if @skipped_files.any? && !@force
+              puts "\nUse --force to overwrite existing files"
+            end
+          end
+        end
+      end
+    end
+  end
+end