igniter 0.5.0 → 0.5.1

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

@@ -0,0 +1,121 @@
+# 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

@@ -0,0 +1,68 @@
+# 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

@@ -0,0 +1,200 @@
+# 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

@@ -0,0 +1,68 @@
+# 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

@@ -0,0 +1,72 @@
+# 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