igniter 0.5.0 → 0.5.1

data/packages/igniter-app/lib/igniter/app/diagnostics/sdk_contributor.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Diagnostics
+      module SdkContributor
+        INTRINSIC_EXECUTOR_CAPABILITIES = %i[pure].freeze
+
+        class << self
+          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
+            app = report[:app]
+            return report unless app
+
+            requested = Array(app[:sdk_capabilities]).map(&:to_sym).sort
+            available = Igniter::SDK.capabilities(layer: :app).map { |capability| serialize_capability(capability) }
+            requested_details = requested.map { |name| requested_detail(name) }
+            activated_capabilities = requested.select { |name| Igniter::SDK.activated?(name) }
+            coverage = coverage_summary(
+              requested_details: requested_details,
+              activated_capabilities: activated_capabilities,
+              required_capabilities: report.dig(:capabilities, :unique_capabilities)
+            )
+
+            report[:app_sdk] = {
+              requested_capabilities: requested,
+              requested_details: requested_details,
+              activated_capabilities: activated_capabilities,
+              available_capabilities: available,
+              available_count: available.size,
+              coverage: coverage,
+              packs: {
+                hosts: Igniter::App::HostRegistry.names.map(&:to_sym).sort,
+                loaders: Igniter::App::LoaderRegistry.names.map(&:to_sym).sort,
+                schedulers: Igniter::App::SchedulerRegistry.names.map(&:to_sym).sort
+              }
+            }
+            report
+          end
+
+          def append_text(report:, lines:)
+            sdk = report[:app_sdk]
+            return unless sdk
+
+            lines << "SDK: #{summary(sdk)}"
+          end
+
+          def append_markdown_summary(report:, lines:)
+            sdk = report[:app_sdk]
+            return unless sdk
+
+            lines << "- SDK: #{summary(sdk)}"
+          end
+
+          def append_markdown_sections(report:, lines:)
+            sdk = report[:app_sdk]
+            return unless sdk
+
+            lines << ""
+            lines << "## SDK"
+            lines << "- Requested: total=#{sdk[:requested_capabilities].size}, names=#{list_or_none(sdk[:requested_capabilities])}"
+            lines << "- Activated: total=#{sdk[:activated_capabilities].size}, names=#{list_or_none(sdk[:activated_capabilities])}"
+            lines << "- Available For App: total=#{sdk[:available_count]}"
+            sdk[:requested_details].each do |detail|
+              lines << "- Capability `#{detail[:name]}` entrypoint=`#{detail[:entrypoint]}` layers=#{detail[:allowed_layers].join(", ")}"
+            end
+            lines << "- Coverage: #{coverage_summary_text(sdk[:coverage])}"
+            sdk[:coverage][:entries].each do |entry|
+              lines << "- Executor Capability `#{entry[:capability]}` status=#{entry[:status]} providers=#{list_or_none(entry[:providers])} suggestions=#{list_or_none(entry[:suggested_sdk_capabilities])}"
+            end
+            lines << "- Coverage Remediation: #{coverage_remediation_text(sdk[:coverage])}"
+            lines << "- Coverage Plans: #{coverage_plan_text(sdk[:coverage])}"
+            lines << "- Packs: hosts=#{list_or_none(sdk.dig(:packs, :hosts))}; loaders=#{list_or_none(sdk.dig(:packs, :loaders))}; schedulers=#{list_or_none(sdk.dig(:packs, :schedulers))}"
+          end
+
+          private
+
+          def coverage_summary(requested_details:, activated_capabilities:, required_capabilities:)
+            activated_details = requested_details.select { |detail| activated_capabilities.include?(detail[:name]) }
+            requested_coverage = requested_details.each_with_object({}) do |detail, memo|
+              Array(detail[:provides_capabilities]).each do |capability|
+                memo[capability] ||= []
+                memo[capability] << detail[:name]
+              end
+            end
+            active_coverage = activated_details.each_with_object({}) do |detail, memo|
+              Array(detail[:provides_capabilities]).each do |capability|
+                memo[capability] ||= []
+                memo[capability] << detail[:name]
+              end
+            end
+            available_coverage = Igniter::SDK.capabilities(layer: :app).each_with_object({}) do |detail, memo|
+              Array(detail.provides_capabilities).each do |capability|
+                memo[capability] ||= []
+                memo[capability] << detail.name
+              end
+            end
+
+            entries = Array(required_capabilities).map(&:to_sym).uniq.sort.map do |capability|
+              providers = Array(active_coverage[capability]).map(&:to_sym).sort
+              requested_providers = Array(requested_coverage[capability]).map(&:to_sym).sort
+              suggested_sdk_capabilities = Array(available_coverage[capability]).map(&:to_sym).sort - providers
+              status = if INTRINSIC_EXECUTOR_CAPABILITIES.include?(capability)
+                         :intrinsic
+                       elsif providers.empty?
+                         :uncovered
+                       else
+                         :covered
+                       end
+
+              {
+                capability: capability,
+                status: status,
+                providers: providers,
+                requested_providers: requested_providers,
+                suggested_sdk_capabilities: suggested_sdk_capabilities,
+                remediation: remediation_for(
+                  capability: capability,
+                  status: status,
+                  providers: providers,
+                  suggested_sdk_capabilities: suggested_sdk_capabilities
+                )
+              }
+            end
+
+            {
+              required_capabilities: Array(required_capabilities).map(&:to_sym).uniq.sort,
+              covered_capabilities: entries.filter_map { |entry| entry[:capability] if entry[:status] == :covered },
+              uncovered_capabilities: entries.filter_map { |entry| entry[:capability] if entry[:status] == :uncovered },
+              intrinsic_capabilities: entries.filter_map { |entry| entry[:capability] if entry[:status] == :intrinsic },
+              entries: entries,
+              remediation: entries.filter_map { |entry| entry[:remediation] if entry[:remediation] },
+              plans: summarize_coverage_plans(entries),
+              facets: summarize_coverage_facets(entries)
+            }
+          end
+
+          def summarize_coverage_plans(entries)
+            plans = {}
+
+            entries.each do |entry|
+              remediation = entry[:remediation]
+              next unless remediation
+
+              plan = remediation[:plan]
+              next unless plan
+
+              key = [plan[:action], plan[:scope], plan[:automated], plan[:requires_approval], plan[:params]].hash
+              plans[key] ||= plan.merge(sources: [])
+              plans[key][:sources] << {
+                capability: entry[:capability],
+                suggested_sdk_capabilities: remediation[:suggested_sdk_capabilities]
+              }
+            end
+
+            plans.values.each { |plan| plan[:sources] = plan[:sources].uniq.freeze }
+            plans.values.freeze
+          end
+
+          def summarize_coverage_facets(entries)
+            remediations = entries.filter_map { |entry| entry[:remediation] }
+            {
+              by_status: count_many(entries) { |entry| entry[:status] },
+              by_remediation_code: count_many(remediations) { |remediation| remediation[:code] },
+              by_plan_action: count_many(remediations) { |remediation| remediation.dig(:plan, :action) }
+            }
+          end
+
+          def requested_detail(name)
+            capability = Igniter::SDK.fetch(name)
+            serialize_capability(capability)
+          rescue Igniter::SDK::UnknownCapabilityError
+            {
+              name: name.to_sym,
+              entrypoint: nil,
+              allowed_layers: [],
+              provides_capabilities: [],
+              unknown: true
+            }
+          end
+
+          def serialize_capability(capability)
+            {
+              name: capability.name,
+              entrypoint: capability.entrypoint,
+              allowed_layers: capability.allowed_layers,
+              provides_capabilities: capability.provides_capabilities
+            }
+          end
+
+          def summary(sdk)
+            [
+              "requested=#{sdk[:requested_capabilities].size}",
+              "activated=#{sdk[:activated_capabilities].size}",
+              "available=#{sdk[:available_count]}",
+              "coverage=#{coverage_summary_text(sdk[:coverage])}",
+              "remediation=#{coverage_remediation_text(sdk[:coverage])}",
+              "plans=#{coverage_plan_text(sdk[:coverage])}",
+              "packs=hosts(#{list_or_none(sdk.dig(:packs, :hosts))})/loaders(#{list_or_none(sdk.dig(:packs, :loaders))})/schedulers(#{list_or_none(sdk.dig(:packs, :schedulers))})"
+            ].join(", ")
+          end
+
+          def coverage_summary_text(coverage)
+            return "required=none" if coverage[:required_capabilities].empty?
+
+            [
+              "required=#{list_or_none(coverage[:required_capabilities])}",
+              "covered=#{list_or_none(coverage[:covered_capabilities])}",
+              "uncovered=#{list_or_none(coverage[:uncovered_capabilities])}",
+              "intrinsic=#{list_or_none(coverage[:intrinsic_capabilities])}"
+            ].join(", ")
+          end
+
+          def coverage_remediation_text(coverage)
+            remediations = Array(coverage[:remediation])
+            return "none" if remediations.empty?
+
+            remediations.map do |remediation|
+              "#{remediation[:capability]}->#{list_or_none(remediation[:suggested_sdk_capabilities])}"
+            end.join("; ")
+          end
+
+          def coverage_plan_text(coverage)
+            plans = Array(coverage[:plans])
+            return "none" if plans.empty?
+
+            plans.map do |plan|
+              "#{plan[:action]}(#{list_or_none(plan[:params][:sdk_capabilities])})"
+            end.join("; ")
+          end
+
+          def remediation_for(capability:, status:, providers:, suggested_sdk_capabilities:)
+            return nil unless status == :uncovered
+            return nil unless providers.empty?
+            return nil if suggested_sdk_capabilities.empty?
+
+            {
+              code: :activate_sdk_capability,
+              capability: capability,
+              suggested_sdk_capabilities: suggested_sdk_capabilities,
+              message: "Activate an SDK capability that provides #{capability}.",
+              plan: build_plan(
+                :activate_sdk_capability,
+                scope: :app_sdk,
+                automated: false,
+                requires_approval: true,
+                params: {
+                  capability: capability,
+                  sdk_capabilities: suggested_sdk_capabilities
+                }
+              )
+            }
+          end
+
+          def build_plan(action, scope:, automated:, requires_approval:, params: {})
+            {
+              action: action,
+              scope: scope,
+              automated: automated,
+              requires_approval: requires_approval,
+              params: params.compact
+            }
+          end
+
+          def count_many(entries)
+            entries.each_with_object(Hash.new(0)) do |entry, memo|
+              Array(yield(entry)).each do |key|
+                next if key.nil?
+
+                memo[key] += 1
+              end
+            end
+          end
+
+          def list_or_none(values)
+            array = Array(values)
+            return "none" if array.empty?
+
+            array.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/diagnostics.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "igniter/core/diagnostics"
+
+require_relative "runtime_context"
+require_relative "diagnostics/runtime_contributor"
+require_relative "diagnostics/app_host_contributor"
+require_relative "diagnostics/cluster_app_host_contributor"
+require_relative "diagnostics/loader_contributor"
+require_relative "diagnostics/scheduler_contributor"
+require_relative "diagnostics/sdk_contributor"
+require_relative "diagnostics/evolution_contributor"
+require_relative "diagnostics/ignite_contributor"
+require_relative "diagnostics/credential_contributor"
+require_relative "diagnostics/orchestration_contributor"
+
+module Igniter
+  class App
+    module Diagnostics
+      Igniter::Diagnostics.register_report_contributor(
+        :app_runtime,
+        RuntimeContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_host,
+        AppHostContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :cluster_app_host,
+        ClusterAppHostContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_loader,
+        LoaderContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_scheduler,
+        SchedulerContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_sdk,
+        SdkContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_evolution,
+        EvolutionContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_ignite,
+        IgniteContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_credentials,
+        CredentialContributor
+      )
+      Igniter::Diagnostics.register_report_contributor(
+        :app_orchestration,
+        OrchestrationContributor
+      )
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/evolution/approval_decision.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Igniter
+  class App
+    module Evolution
+      class ApprovalDecision
+        attr_reader :mode, :approved_action_ids, :denied_action_ids, :selections, :metadata
+
+        class << self
+          def approve_all(selections: {}, metadata: {})
+            new(mode: :approve_all, selections: selections, metadata: metadata)
+          end
+
+          def build(approved_action_ids: [], denied_action_ids: [], selections: {}, metadata: {})
+            new(
+              mode: :selective,
+              approved_action_ids: approved_action_ids,
+              denied_action_ids: denied_action_ids,
+              selections: selections,
+              metadata: metadata
+            )
+          end
+
+          def normalize(value, selections: {})
+            case value
+            when nil
+              nil
+            when true
+              approve_all(selections: selections)
+            when false
+              nil
+            when self
+              merged_selections = value.selections.merge(normalize_selections(selections))
+              new(
+                mode: value.mode,
+                approved_action_ids: value.approved_action_ids.to_a,
+                denied_action_ids: value.denied_action_ids.to_a,
+                selections: merged_selections,
+                metadata: value.metadata
+              )
+            when Hash
+              normalized = symbolize_hash(value)
+              if normalized[:approve_all]
+                approve_all(
+                  selections: normalize_selections(normalized[:selections]).merge(normalize_selections(selections)),
+                  metadata: normalized[:metadata] || {}
+                )
+              else
+                build(
+                  approved_action_ids: normalized[:approved_action_ids] || normalized[:approved] || [],
+                  denied_action_ids: normalized[:denied_action_ids] || normalized[:denied] || [],
+                  selections: normalize_selections(normalized[:selections]).merge(normalize_selections(selections)),
+                  metadata: normalized[:metadata] || {}
+                )
+              end
+            else
+              raise ArgumentError, "Unsupported approval decision #{value.inspect}"
+            end
+          end
+
+          private
+
+          def normalize_selections(selections)
+            symbolize_hash(selections).transform_values do |value|
+              Array(value).map(&:to_sym).uniq.sort.freeze
+            end
+          end
+
+          def symbolize_hash(value)
+            Array(value).each_with_object({}) do |(key, nested), memo|
+              memo[key.to_sym] = nested
+            end
+          end
+        end
+
+        def initialize(mode:, approved_action_ids: [], denied_action_ids: [], selections: {}, metadata: {})
+          @mode = mode.to_sym
+          @approved_action_ids = Set.new(Array(approved_action_ids).map(&:to_s)).freeze
+          @denied_action_ids = Set.new(Array(denied_action_ids).map(&:to_s)).freeze
+          @selections = self.class.send(:normalize_selections, selections).freeze
+          @metadata = self.class.send(:symbolize_hash, metadata).freeze
+          freeze
+        end
+
+        def approve_action?(action_id)
+          action_key = action_id.to_s
+          return false if denied_action_ids.include?(action_key)
+          return true if mode == :approve_all
+
+          approved_action_ids.include?(action_key)
+        end
+
+        def deny_action?(action_id)
+          denied_action_ids.include?(action_id.to_s)
+        end
+
+        def selection_for(capability)
+          selections[capability.to_sym] || selections[capability.to_s.to_sym] || []
+        end
+
+        def to_h
+          {
+            mode: mode,
+            approved_action_ids: approved_action_ids.to_a.sort,
+            denied_action_ids: denied_action_ids.to_a.sort,
+            selections: selections,
+            metadata: metadata
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/evolution/approval_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Evolution
+      class ApprovalRequest
+        attr_reader :app_class, :source, :actions, :summary
+
+        def initialize(app_class:, source:, actions:, summary: {})
+          @app_class = app_class
+          @source = source.to_sym
+          @actions = Array(actions).map { |action| action.freeze }.freeze
+          @summary = summary.freeze
+          freeze
+        end
+
+        def empty?
+          @actions.empty?
+        end
+
+        def action_ids
+          @actions.map { |action| action[:id] }
+        end
+
+        def to_h
+          {
+            app: app_class.name,
+            source: source,
+            actions: actions,
+            summary: summary
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/evolution/plan.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Evolution
+      class Plan
+        attr_reader :app_class, :actions, :source, :summary
+
+        def initialize(app_class:, actions:, source:, summary: {})
+          @app_class = app_class
+          @actions = Array(actions).map { |action| action.freeze }.freeze
+          @source = source.to_sym
+          @summary = summary.freeze
+          freeze
+        end
+
+        def empty?
+          @actions.empty?
+        end
+
+        def approval_required?
+          @actions.any? { |action| action[:requires_approval] }
+        end
+
+        def automated_actions
+          @actions.select { |action| action[:automated] }
+        end
+
+        def manual_actions
+          @actions.reject { |action| action[:automated] }
+        end
+
+        def approval_request
+          approval_actions = actions.select { |action| action[:requires_approval] }
+
+          ApprovalRequest.new(
+            app_class: app_class,
+            source: source,
+            actions: approval_actions.map do |action|
+              {
+                id: action[:id],
+                action: action[:action],
+                scope: action[:scope],
+                capability: action.dig(:params, :capability),
+                candidates: Array(action.dig(:params, :sdk_capabilities)).map(&:to_sym).uniq.sort,
+                constraints: action[:constraints],
+                automated: action[:automated],
+                requires_approval: action[:requires_approval]
+              }.freeze
+            end,
+            summary: {
+              total: approval_actions.size,
+              constrained: approval_actions.count { |action| Array(action[:constraints]).any? },
+              by_action: approval_actions.each_with_object(Hash.new(0)) do |action, memo|
+                memo[action[:action]] += 1
+              end
+            }
+          )
+        end
+
+        def to_h
+          {
+            app: app_class.name,
+            source: source,
+            actions: actions,
+            summary: summary
+          }
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/evolution/planner.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Evolution
+      class Planner
+        def initialize(app_class:)
+          @app_class = app_class
+        end
+
+        def plan(target)
+          report = extract_report(target)
+          coverage = report.fetch(:app_sdk, {}).fetch(:coverage, {})
+          actions = Array(coverage[:plans]).map { |action| normalize_action(action) }
+
+          Plan.new(
+            app_class: app_class,
+            source: :app_sdk_coverage,
+            actions: actions,
+            summary: summarize(actions, coverage)
+          )
+        end
+
+        private
+
+        attr_reader :app_class
+
+        def extract_report(target)
+          return target if target.is_a?(Hash)
+          return target.to_h if target.class.name == "Igniter::Diagnostics::Report"
+          return target.diagnostics.to_h if target.respond_to?(:diagnostics)
+
+          raise ArgumentError,
+                "evolution plan target must be a diagnostics hash, diagnostics report, execution, or contract instance"
+        end
+
+        def normalize_action(action)
+          capability = action.dig(:params, :capability)&.to_sym
+          sdk_capabilities = Array(action.dig(:params, :sdk_capabilities)).map(&:to_sym).uniq.sort
+          constraints = []
+          constraints << :selection_required if action[:action].to_sym == :activate_sdk_capability && sdk_capabilities.size > 1
+
+          {
+            id: action_id(action, capability),
+            action: action[:action].to_sym,
+            scope: action[:scope].to_sym,
+            automated: !!action[:automated],
+            requires_approval: !!action[:requires_approval],
+            params: (action[:params] || {}).merge(
+              capability: capability,
+              sdk_capabilities: sdk_capabilities
+            ).freeze,
+            sources: Array(action[:sources]).freeze,
+            constraints: constraints.freeze
+          }.freeze
+        end
+
+        def action_id(action, capability)
+          [action[:scope], action[:action], capability].compact.map(&:to_s).join(":")
+        end
+
+        def summarize(actions, coverage)
+          {
+            total: actions.size,
+            automated: actions.count { |action| action[:automated] },
+            approval_required: actions.count { |action| action[:requires_approval] },
+            constrained: actions.count { |action| action[:constraints].any? },
+            uncovered_capabilities: Array(coverage[:uncovered_capabilities]).map(&:to_sym).uniq.sort,
+            by_action: count_many(actions) { |action| action[:action] }
+          }
+        end
+
+        def count_many(entries)
+          entries.each_with_object(Hash.new(0)) do |entry, memo|
+            Array(yield(entry)).each do |key|
+              next if key.nil?
+
+              memo[key] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/evolution/result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Evolution
+      class Result
+        attr_reader :app_class, :applied, :blocked, :skipped
+
+        def initialize(app_class:, applied:, blocked:, skipped: [])
+          @app_class = app_class
+          @applied = Array(applied).map { |entry| entry.freeze }.freeze
+          @blocked = Array(blocked).map { |entry| entry.freeze }.freeze
+          @skipped = Array(skipped).map { |entry| entry.freeze }.freeze
+          freeze
+        end
+
+        def status
+          return :applied if @blocked.empty? && @applied.any?
+          return :blocked if @blocked.any? && @applied.empty?
+          return :partial if @blocked.any? && @applied.any?
+
+          :noop
+        end
+
+        def applied?
+          !@applied.empty?
+        end
+
+        def blocked?
+          !@blocked.empty?
+        end
+
+        def to_h
+          {
+            app: app_class.name,
+            status: status,
+            applied: applied,
+            blocked: blocked,
+            skipped: skipped
+          }
+        end
+      end
+    end
+  end
+end