igniter 0.5.1 → 0.5.2

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module IgniteContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            context = Igniter::App::RuntimeContext.current
-            return report unless context
-
-            app_class = context.fetch(:app_class)
-            stack_class = app_class.stack_class
-            return report unless stack_class
-
-            ignition_plan = stack_class.ignition_plan
-            return report if ignition_plan.empty?
-
-            report[:app_ignite] = stack_class.ignition_report.to_h.merge(
-              app: app_class.name,
-              stack: stack_class.name || "anonymous",
-              history: stack_class.ignition_history(limit: 10)
-            )
-            report
-          rescue ArgumentError
-            report
-          end
-
-          def append_text(report:, lines:)
-            ignite = report[:app_ignite]
-            return unless ignite
-
-            lines << "App Ignite: #{summary(ignite)}"
-            lines << "App Ignite Progress: #{progress_summary(ignite)}" if ignite[:progress]
-            lines << "App Ignite History: #{history_summary(ignite)}" if ignite[:history]
-          end
-
-          def append_markdown_summary(report:, lines:)
-            ignite = report[:app_ignite]
-            return unless ignite
-
-            lines << "- App Ignite: #{summary(ignite)}"
-            lines << "- App Ignite Progress: #{progress_summary(ignite)}" if ignite[:progress]
-            lines << "- App Ignite History: #{history_summary(ignite)}" if ignite[:history]
-          end
-
-          def append_markdown_sections(report:, lines:)
-            ignite = report[:app_ignite]
-            return unless ignite
-
-            lines << ""
-            lines << "## App Ignite"
-            lines << "- Summary: #{summary(ignite)}"
-            lines << "- Progress: #{progress_summary(ignite)}" if ignite[:progress]
-            lines << "- History: #{history_summary(ignite)}" if ignite[:history]
-
-            Array(ignite[:entries]).each do |entry|
-              lines << "- `#{entry[:target_id]}` `#{entry[:action]}`: status=`#{entry[:status]}` kind=`#{entry[:kind]}` admission=`#{entry.dig(:admission, :status)}` join=`#{entry.dig(:join, :status)}`"
-            end
-
-            Array(ignite.dig(:progress, :recent_events)).each do |event|
-              lines << "- Event `#{event[:type]}`: target=`#{event[:target_id] || "n/a"}` at=`#{event[:timestamp] || "n/a"}`"
-            end
-
-            Array(ignite.dig(:history, :events)).each do |event|
-              lines << "- History `#{event[:type]}` from `#{event[:source]}`: target=`#{event.dig(:payload, :target_id) || "n/a"}` at=`#{event[:timestamp] || "n/a"}`"
-            end
-          end
-
-          private
-
-          def summary(ignite)
-            summary = ignite[:summary]
-
-            parts = []
-            parts << "status=#{ignite[:status]}"
-            parts << "total=#{summary[:total]}"
-            parts << "actionable=#{summary[:actionable]}"
-            parts << "local_replicas=#{summary[:local_replicas]}"
-            parts << "remote_targets=#{summary[:remote_targets]}"
-            parts << "admission_required=#{summary[:admission_required]}"
-            parts << "join_required=#{summary[:join_required]}"
-            parts << "by_status=#{inline_counts(summary[:by_status])}" unless summary[:by_status].empty?
-            parts << "by_admission=#{inline_counts(summary[:by_admission_status])}" unless summary[:by_admission_status].empty?
-            parts << "by_join=#{inline_counts(summary[:by_join_status])}" unless summary[:by_join_status].empty?
-            parts.join(", ")
-          end
-
-          def progress_summary(ignite)
-            progress = ignite[:progress]
-            return "none" unless progress
-
-            latest = progress[:latest_event]
-            parts = []
-            parts << "events=#{progress[:total_events]}"
-            parts << "latest=#{latest[:type]}" if latest
-            parts << "targets=#{progress[:targets].size}"
-            parts << "by_event=#{inline_counts(progress[:by_event_type])}" unless progress[:by_event_type].empty?
-            parts.join(", ")
-          end
-
-          def history_summary(ignite)
-            history = ignite[:history]
-            return "none" unless history
-
-            parts = []
-            parts << "events=#{history[:total]}"
-            parts << "latest=#{history[:latest_type]}" if history[:latest_type]
-            parts << "targets=#{inline_counts(history[:by_target])}" unless history[:by_target].nil? || history[:by_target].empty?
-            parts << "persisted=#{history.dig(:persistence, :enabled)}"
-            parts.join(", ")
-          end
-
-          def inline_counts(counts)
-            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module LoaderContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            app = report[:app]
-            return report unless app
-
-            loader_runtime = Hash(app[:loader_runtime] || {})
-            code_paths = Hash(loader_runtime[:code_paths] || {})
-
-            report[:app_loader] = {
-              mode: app[:loader],
-              adapter_class: loader_runtime[:adapter_class],
-              root_dir: app[:root_dir],
-              path_groups: Array(loader_runtime[:path_groups]).map(&:to_sym).sort,
-              total_paths: loader_runtime[:total_paths].to_i,
-              code_paths: code_paths.transform_values { |paths| Array(paths) }
-            }
-            report
-          end
-
-          def append_text(report:, lines:)
-            loader = report[:app_loader]
-            return unless loader
-
-            lines << "Loader: #{summary(loader)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            loader = report[:app_loader]
-            return unless loader
-
-            lines << "- Loader: #{summary(loader)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            loader = report[:app_loader]
-            return unless loader
-
-            lines << ""
-            lines << "## Loader"
-            lines << "- Mode: `#{loader[:mode]}` adapter=`#{loader[:adapter_class] || "unknown"}`"
-            lines << "- Root Dir: `#{loader[:root_dir]}`"
-            lines << "- Paths: total=#{loader[:total_paths]}, groups=#{loader[:path_groups].join(", ")}"
-            loader[:code_paths].each do |group, paths|
-              lines << "- `#{group}`: #{paths.empty? ? "none" : paths.join(", ")}"
-            end
-          end
-
-          private
-
-          def summary(loader)
-            [
-              "mode=#{loader[:mode]}",
-              "paths=#{loader[:total_paths]}",
-              "groups=#{loader[:path_groups].join("|")}",
-              "adapter=#{loader[:adapter_class] || "unknown"}"
-            ].join(", ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module OrchestrationContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            context = Igniter::App::RuntimeContext.current
-            return report unless context
-            return report unless report[:orchestration]
-
-            app_class = context.fetch(:app_class)
-            plan = app_class.orchestration_plan(report)
-            orchestration_runtime = app_class.orchestration_runtime_overview(execution)
-            report[:app_orchestration] = plan.to_h.merge(
-              inbox: app_class.orchestration_inbox.snapshot(limit: 20)
-            )
-            report[:app_orchestration_runtime] = orchestration_runtime if orchestration_runtime
-            report[:app_operator] = app_class.operator_overview(execution, limit: 20)
-            report
-          end
-
-          def append_text(report:, lines:)
-            orchestration = report[:app_orchestration]
-            orchestration_runtime = report[:app_orchestration_runtime]
-            operator = report[:app_operator]
-            return unless orchestration || orchestration_runtime || operator
-
-            lines << "App Orchestration: #{summary(orchestration)}" if orchestration
-            lines << "App Orchestration Inbox: #{inbox_summary(orchestration[:inbox])}" if orchestration[:inbox]
-            lines << "App Orchestration Runtime: #{runtime_summary(orchestration_runtime)}" if orchestration_runtime
-            lines << "App Orchestration Runtime Results: #{runtime_results_summary(orchestration_runtime[:results])}" if orchestration_runtime&.dig(:results)
-            lines << "App Operator: #{operator_summary(operator)}" if operator
-          end
-
-          def append_markdown_summary(report:, lines:)
-            orchestration = report[:app_orchestration]
-            orchestration_runtime = report[:app_orchestration_runtime]
-            operator = report[:app_operator]
-            return unless orchestration || orchestration_runtime || operator
-
-            lines << "- App Orchestration: #{summary(orchestration)}" if orchestration
-            lines << "- App Orchestration Inbox: #{inbox_summary(orchestration[:inbox])}" if orchestration[:inbox]
-            lines << "- App Orchestration Runtime: #{runtime_summary(orchestration_runtime)}" if orchestration_runtime
-            lines << "- App Orchestration Runtime Results: #{runtime_results_summary(orchestration_runtime[:results])}" if orchestration_runtime&.dig(:results)
-            lines << "- App Operator: #{operator_summary(operator)}" if operator
-          end
-
-          def append_markdown_sections(report:, lines:)
-            orchestration = report[:app_orchestration]
-            orchestration_runtime = report[:app_orchestration_runtime]
-            operator = report[:app_operator]
-            return unless orchestration || orchestration_runtime || operator
-
-            followup = orchestration[:followup] if orchestration
-
-            if orchestration
-              lines << ""
-              lines << "## App Orchestration"
-              lines << "- Summary: #{summary(orchestration)}"
-              lines << "- Inbox: #{inbox_summary(orchestration[:inbox])}" if orchestration[:inbox]
-
-              unless followup[:actions].empty?
-                lines << "- Follow-up: total=#{followup.dig(:summary, :total)}, manual_completion=#{followup.dig(:summary, :manual_completion)}, deferred_replies=#{followup.dig(:summary, :deferred_replies)}, interactive_sessions=#{followup.dig(:summary, :interactive_sessions)}, by_policy=#{inline_counts(followup.dig(:summary, :by_policy) || {})}, by_lane=#{inline_counts(followup.dig(:summary, :by_lane) || {})}, by_queue=#{inline_counts(followup.dig(:summary, :by_queue) || {})}"
-                followup[:actions].each do |action|
-                  lines << "- `#{action[:node]}` `#{action[:action]}`: #{action[:guidance]} reason=`#{action[:reason]}` policy=`#{action.dig(:policy, :name)}` lane=`#{action.dig(:lane, :name) || "none"}` default=`#{action.dig(:policy, :default_operation)}` queue=`#{action.dig(:routing, :queue) || "none"}` channel=`#{action.dig(:routing, :channel) || "none"}`"
-                end
-              end
-            end
-
-            if orchestration_runtime
-              lines << ""
-              lines << "## App Orchestration Runtime"
-              lines << "- Summary: #{runtime_summary(orchestration_runtime)}"
-              lines << "- Results: #{runtime_results_summary(orchestration_runtime[:results])}" if orchestration_runtime[:results]
-              Array(orchestration_runtime[:records]).each do |record|
-                lines << "- `#{record[:node]}` action=`#{record[:action]}` runtime=`#{record[:runtime_status]}` session=`#{record[:session_lifecycle_state] || "none"}` inbox=`#{record[:inbox_status] || "none"}` waiting_on=`#{record[:waiting_on] || "none"}`"
-              end
-            end
-
-            return unless operator
-
-            lines << ""
-            lines << "## App Operator"
-            lines << "- Summary: #{operator_summary(operator)}"
-            Array(operator[:records]).each do |record|
-              lines << "- `#{record[:node]}` state=`#{record[:combined_state]}` status=`#{record[:status] || "none"}` phase=`#{record[:phase] || "none"}` lane=`#{record.dig(:lane, :name) || "none"}` queue=`#{record[:queue] || "none"}` assignee=`#{record[:assignee] || "none"}`"
-            end
-          end
-
-          private
-
-          def summary(orchestration)
-            summary = orchestration[:summary]
-            followup = orchestration[:followup]
-
-            parts = []
-            parts << "total=#{summary[:total]}"
-            parts << "attention_required=#{summary[:attention_required]}"
-            parts << "manual_completion=#{summary[:manual_completion]}"
-            parts << "deferred_replies=#{summary[:deferred_replies]}"
-            parts << "interactive_sessions=#{summary[:interactive_sessions]}"
-            parts << "single_turn_sessions=#{summary[:single_turn_sessions]}"
-            parts << "followups=#{followup.dig(:summary, :total)}"
-            parts << "attention_nodes=#{Array(summary[:attention_nodes]).join(",")}" if Array(summary[:attention_nodes]).any?
-            parts << "by_action=#{inline_counts(summary[:by_action])}" unless summary[:by_action].empty?
-            parts << "by_policy=#{inline_counts(summary[:by_policy])}" unless summary[:by_policy].empty?
-            parts << "by_lane=#{inline_counts(summary[:by_lane])}" unless summary[:by_lane].empty?
-            parts << "by_queue=#{inline_counts(summary[:by_queue])}" unless summary[:by_queue].empty?
-            parts << "by_channel=#{inline_counts(summary[:by_channel])}" unless summary[:by_channel].empty?
-            parts.join(", ")
-          end
-
-          def inbox_summary(inbox)
-            parts = []
-            parts << "total=#{inbox[:total]}"
-            parts << "open=#{inbox[:open]}"
-            parts << "acknowledged=#{inbox[:acknowledged]}"
-            parts << "resolved=#{inbox[:resolved]}"
-            parts << "dismissed=#{inbox[:dismissed]}"
-            parts << "actionable=#{inbox[:actionable]}"
-            parts << "latest_action=#{inbox[:latest_action] || "none"}"
-            parts << "latest_node=#{inbox[:latest_node] || "none"}"
-            parts << "latest_policy=#{inbox[:latest_policy] || "none"}"
-            parts << "latest_lane=#{inbox[:latest_lane] || "none"}"
-            parts << "latest_assignee=#{inbox[:latest_assignee] || "none"}"
-            parts << "latest_queue=#{inbox[:latest_queue] || "none"}"
-            parts << "latest_channel=#{inbox[:latest_channel] || "none"}"
-            parts << "latest_status=#{inbox[:latest_status] || "none"}"
-            parts << "by_status=#{inline_counts(inbox[:by_status])}" unless inbox[:by_status].empty?
-            parts << "by_action=#{inline_counts(inbox[:by_action])}" unless inbox[:by_action].empty?
-            parts << "by_policy=#{inline_counts(inbox[:by_policy])}" unless inbox[:by_policy].empty?
-            parts << "by_lane=#{inline_counts(inbox[:by_lane])}" unless inbox[:by_lane].empty?
-            parts << "by_assignee=#{inline_counts(inbox[:by_assignee])}" unless inbox[:by_assignee].empty?
-            parts << "by_queue=#{inline_counts(inbox[:by_queue])}" unless inbox[:by_queue].empty?
-            parts << "by_channel=#{inline_counts(inbox[:by_channel])}" unless inbox[:by_channel].empty?
-            parts.join(", ")
-          end
-
-          def runtime_summary(orchestration_runtime)
-            summary = orchestration_runtime[:summary]
-
-            parts = []
-            parts << "total=#{summary[:total]}"
-            parts << "with_session=#{summary[:with_session]}"
-            parts << "with_inbox_items=#{summary[:with_inbox_items]}"
-            parts << "attention_required=#{summary[:attention_required]}"
-            parts << "resumable=#{summary[:resumable]}"
-            parts << "interactive_sessions=#{summary[:interactive_sessions]}"
-            parts << "manual_sessions=#{summary[:manual_sessions]}"
-            parts << "deferred_calls=#{summary[:deferred_calls]}"
-            parts << "by_action=#{inline_counts(summary[:by_action])}" unless summary[:by_action].empty?
-            parts << "by_runtime_status=#{inline_counts(summary[:by_runtime_status])}" unless summary[:by_runtime_status].empty?
-            parts << "by_inbox_status=#{inline_counts(summary[:by_inbox_status])}" unless summary[:by_inbox_status].empty?
-            parts << "by_session_lifecycle_state=#{inline_counts(summary[:by_session_lifecycle_state])}" unless summary[:by_session_lifecycle_state].empty?
-            parts.join(", ")
-          end
-
-          def runtime_results_summary(results)
-            parts = []
-            parts << "terminal_records=#{results[:terminal_records]}"
-            parts << "completed_runtime_records=#{results[:completed_runtime_records]}"
-            parts << "failed_runtime_records=#{results[:failed_runtime_records]}"
-            latest = Array(results[:latest_records]).map do |record|
-              "#{record[:node]}:#{record[:runtime_status] || "none"}/#{record[:inbox_status] || "none"}@#{record[:latest_event]}"
-            end
-            parts << "latest_records=#{latest.join(",")}" if latest.any?
-            parts.join(", ")
-          end
-
-          def operator_summary(operator)
-            summary = operator[:summary]
-
-            parts = []
-            parts << "total=#{summary[:total]}"
-            parts << "live_sessions=#{summary[:live_sessions]}"
-            parts << "inbox_items=#{summary[:inbox_items]}"
-            parts << "joined=#{summary[:joined_records]}"
-            parts << "ignite=#{summary[:ignition_records]}"
-            parts << "session_only=#{summary[:session_only]}"
-            parts << "inbox_only=#{summary[:inbox_only]}"
-            parts << "handed_off=#{summary[:handed_off]}"
-            parts << "attention_required=#{summary[:attention_required]}"
-            parts << "resumable=#{summary[:resumable]}"
-            parts << "by_state=#{inline_counts(summary[:by_combined_state])}" unless summary[:by_combined_state].empty?
-            parts << "by_phase=#{inline_counts(summary[:by_phase])}" unless summary[:by_phase].empty?
-            parts << "by_lane=#{inline_counts(summary[:by_lane])}" unless summary[:by_lane].empty?
-            parts << "by_queue=#{inline_counts(summary[:by_queue])}" unless summary[:by_queue].empty?
-            parts.join(", ")
-          end
-
-          def inline_counts(counts)
-            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module RuntimeContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            context = Igniter::App::RuntimeContext.current
-            return report unless context
-
-            report[:app] = context
-            report
-          end
-
-          def append_text(report:, lines:)
-            app = report[:app]
-            return unless app
-
-            lines << "App: #{runtime_summary(app)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            app = report[:app]
-            return unless app
-
-            lines << "- App: #{runtime_summary(app)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            app = report[:app]
-            return unless app
-
-            lines << ""
-            lines << "## App"
-            lines << "- Runtime: `#{app[:app_name] || "anonymous"}` host=`#{app[:host]}` loader=`#{app[:loader]}` scheduler=`#{app[:scheduler]}`"
-            lines << "- Contracts: total=#{app[:registration_count]}, names=#{app[:registrations].join(", ")}"
-            lines << "- Routes: total=#{app[:routes]}, hooks(before=#{app.dig(:hooks, :before_request)}, after=#{app.dig(:hooks, :after_request)}, around=#{app.dig(:hooks, :around_request)})"
-            lines << "- Metrics: configured=#{app.dig(:metrics, :configured)}"
-            lines << "- Store: configured=#{app.dig(:store, :configured)}"
-            if app[:stack]
-              lines << "- Stack: root_app=#{app[:stack][:root_app] || "n/a"}, node=#{app[:stack][:node] || "n/a"}, env=#{app[:stack][:environment] || "n/a"}"
-            end
-          end
-
-          private
-
-          def runtime_summary(app)
-            parts = []
-            parts << "runtime=#{app[:app_name] || "anonymous"}"
-            parts << "host=#{app[:host]}"
-            parts << "loader=#{app[:loader]}"
-            parts << "scheduler=#{app[:scheduler]}"
-            parts << "contracts=#{app[:registration_count]}"
-            parts << "routes=#{app[:routes]}"
-            parts << "metrics=#{app.dig(:metrics, :configured)}"
-            parts << "store=#{app.dig(:store, :configured)}"
-            if app[:stack]
-              parts << "root_app=#{app[:stack][:root_app]}" if app[:stack][:root_app]
-              parts << "node=#{app[:stack][:node]}" if app[:stack][:node]
-            end
-            parts.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class App
-    module Diagnostics
-      module SchedulerContributor
-        class << self
-          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
-            app = report[:app]
-            return report unless app
-
-            scheduler_runtime = Hash(app[:scheduler_runtime] || {})
-            jobs = Array(scheduler_runtime[:scheduled_jobs]).map do |job|
-              {
-                name: job[:name]&.to_sym,
-                every: job[:every],
-                at: job[:at]
-              }
-            end
-
-            report[:app_scheduler] = {
-              mode: app[:scheduler],
-              adapter_class: scheduler_runtime[:adapter_class],
-              job_count: scheduler_runtime[:job_count].to_i,
-              jobs: jobs
-            }
-            report
-          end
-
-          def append_text(report:, lines:)
-            scheduler = report[:app_scheduler]
-            return unless scheduler
-
-            lines << "Scheduler: #{summary(scheduler)}"
-          end
-
-          def append_markdown_summary(report:, lines:)
-            scheduler = report[:app_scheduler]
-            return unless scheduler
-
-            lines << "- Scheduler: #{summary(scheduler)}"
-          end
-
-          def append_markdown_sections(report:, lines:)
-            scheduler = report[:app_scheduler]
-            return unless scheduler
-
-            lines << ""
-            lines << "## Scheduler"
-            lines << "- Mode: `#{scheduler[:mode]}` adapter=`#{scheduler[:adapter_class] || "deferred"}`"
-            lines << "- Jobs: total=#{scheduler[:job_count]}"
-            scheduler[:jobs].each do |job|
-              lines << "- `#{job[:name]}` every=#{job[:every]}#{job[:at] ? ", at=#{job[:at]}" : ""}"
-            end
-          end
-
-          private
-
-          def summary(scheduler)
-            names = scheduler[:jobs].map { |job| job[:name] }.compact
-            [
-              "mode=#{scheduler[:mode]}",
-              "jobs=#{scheduler[:job_count]}",
-              "names=#{names.join("|")}",
-              "adapter=#{scheduler[:adapter_class] || "deferred"}"
-            ].join(", ")
-          end
-        end
-      end
-    end
-  end
-end