igniter 0.4.5 → 0.5.1

data/packages/igniter-core/lib/igniter/core/diagnostics/capability_contributor.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../capabilities"
+
+module Igniter
+  module Diagnostics
+    module CapabilityContributor
+      class << self
+        def augment(report:, execution:)
+          entries = capability_entries(execution)
+          return report if entries.empty?
+
+          unique_capabilities = entries.flat_map { |entry| entry[:capabilities] }.uniq.sort
+          report[:capabilities] = {
+            total_nodes: entries.size,
+            pure_nodes: entries.count { |entry| entry[:pure] },
+            impure_nodes: entries.count { |entry| !entry[:pure] },
+            unique_capabilities: unique_capabilities,
+            by_capability: unique_capabilities.each_with_object({}) do |capability, memo|
+              memo[capability] = entries.count { |entry| entry[:capabilities].include?(capability) }
+            end,
+            nodes: entries,
+            policy: policy_summary(entries)
+          }
+          report
+        end
+
+        def append_text(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << "Capabilities: #{summary(capabilities)}"
+          lines << "Capability Policy: #{policy_text_summary(capabilities[:policy])}"
+        end
+
+        def append_markdown_summary(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << "- Capabilities: #{summary(capabilities)}"
+          lines << "- Capability Policy: #{policy_text_summary(capabilities[:policy])}"
+        end
+
+        def append_markdown_sections(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << ""
+          lines << "## Capabilities"
+          lines << "- Summary: nodes=#{capabilities[:total_nodes]}, pure=#{capabilities[:pure_nodes]}, impure=#{capabilities[:impure_nodes]}, unique=#{list_or_none(capabilities[:unique_capabilities])}"
+          capabilities[:nodes].each do |entry|
+            lines << "- `#{entry[:node_name]}` executor=`#{entry[:executor_class] || "anonymous"}` capabilities=#{entry[:capabilities].join(", ")} pure=#{entry[:pure]}"
+          end
+          lines << ""
+          lines << "## Capability Policy"
+          lines << "- Summary: #{policy_text_summary(capabilities[:policy])}"
+          return unless capabilities[:policy][:configured]
+
+          capabilities[:policy][:nodes].each do |entry|
+            lines << "- `#{entry[:node_name]}` status=#{entry[:status]} allowed=#{list_or_none(entry[:allowed_capabilities])} denied=#{list_or_none(entry[:denied_capabilities])} risky=#{list_or_none(entry[:risky_capabilities])}"
+          end
+        end
+
+        private
+
+        def capability_entries(execution)
+          compiled_graph = execution.compiled_graph
+          nodes = compiled_graph.nodes + compiled_graph.outputs
+
+          nodes.each_with_object([]) do |node, memo|
+            executor_class = executor_for(node)
+            next unless executor_class
+
+            capabilities = Array(executor_class.declared_capabilities).map(&:to_sym).uniq.sort
+            next if capabilities.empty?
+
+            memo << {
+              node_name: node.name,
+              executor_class: executor_class.name,
+              capabilities: capabilities,
+              pure: executor_class.pure?
+            }
+          end
+        end
+
+        def executor_for(node)
+          callable = node.respond_to?(:callable) ? node.callable : nil
+          callable ||= node.respond_to?(:adapter_class) ? node.adapter_class : nil
+          return nil unless callable.is_a?(Class) && callable <= Igniter::Executor
+
+          callable
+        end
+
+        def policy_summary(entries)
+          policy = Igniter::Capabilities.policy
+          return { configured: false } unless policy
+
+          nodes = entries.map { |entry| classify_entry(entry, policy) }
+          {
+            configured: true,
+            denied_capabilities: Array(policy.denied).map(&:to_sym).sort,
+            on_unknown: policy.on_unknown.to_sym,
+            allowed_nodes: nodes.count { |entry| entry[:status] == :allowed },
+            denied_nodes: nodes.count { |entry| entry[:status] == :denied },
+            risky_nodes: nodes.count { |entry| entry[:status] == :risky },
+            nodes: nodes
+          }
+        end
+
+        def classify_entry(entry, policy)
+          denied_capabilities = entry[:capabilities] & Array(policy.denied).map(&:to_sym)
+          unknown_capabilities = entry[:capabilities] - Igniter::Capabilities::KNOWN
+          risky_capabilities = policy.on_unknown.to_sym == :warn ? unknown_capabilities : []
+          allowed_capabilities = entry[:capabilities] - denied_capabilities - risky_capabilities
+          status = if denied_capabilities.any?
+                     :denied
+                   elsif risky_capabilities.any?
+                     :risky
+                   else
+                     :allowed
+                   end
+
+          {
+            node_name: entry[:node_name],
+            status: status,
+            allowed_capabilities: allowed_capabilities.sort,
+            denied_capabilities: denied_capabilities.sort,
+            risky_capabilities: risky_capabilities.sort
+          }
+        end
+
+        def summary(capabilities)
+          [
+            "nodes=#{capabilities[:total_nodes]}",
+            "pure=#{capabilities[:pure_nodes]}",
+            "impure=#{capabilities[:impure_nodes]}",
+            "unique=#{list_or_none(capabilities[:unique_capabilities])}"
+          ].join(", ")
+        end
+
+        def policy_text_summary(policy)
+          return "configured=false" unless policy[:configured]
+
+          [
+            "configured=true",
+            "allowed=#{policy[:allowed_nodes]}",
+            "denied=#{policy[:denied_nodes]}",
+            "risky=#{policy[:risky_nodes]}",
+            "on_unknown=#{policy[:on_unknown]}"
+          ].join(", ")
+        end
+
+        def list_or_none(values)
+          array = Array(values)
+          return "none" if array.empty?
+
+          array.join("|")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module OrchestrationContributor
+      class << self
+        def augment(report:, execution:)
+          orchestration = execution.orchestration_plan
+          return report unless orchestration && orchestration[:total].positive?
+
+          report[:orchestration] = orchestration
+          report
+        end
+
+        def append_text(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << "Orchestration: #{orchestration_overview(orchestration)}"
+          return if orchestration[:actions].empty?
+
+          lines << "Orchestration Actions: #{orchestration[:actions].map { |action| orchestration_action_text(action) }.join(', ')}"
+        end
+
+        def append_markdown_summary(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << "- Orchestration: #{orchestration_overview(orchestration)}"
+        end
+
+        def append_markdown_sections(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << ""
+          lines << "## Orchestration"
+          lines << "- Summary: #{orchestration_overview(orchestration)}"
+          return if orchestration[:actions].empty?
+
+          lines << "- Actions: #{orchestration[:actions].map { |action| "`#{action[:action]}`(#{action[:node]})" }.join(', ')}"
+          orchestration[:actions].each do |action|
+            lines << "- `#{action[:node]}` `#{action[:action]}`: #{action[:guidance]} reason=`#{action[:reason]}`"
+          end
+        end
+
+        private
+
+        def orchestration_overview(orchestration)
+          parts = [
+            "total=#{orchestration[:total]}",
+            "attention_required=#{orchestration[:attention_required]}",
+            "resumable=#{orchestration[:resumable]}",
+            "interactive_sessions=#{orchestration[:interactive_sessions]}",
+            "manual_sessions=#{orchestration[:manual_sessions]}",
+            "single_turn_sessions=#{orchestration[:single_turn_sessions]}",
+            "deferred_calls=#{orchestration[:deferred_calls]}",
+            "actions=#{Array(orchestration[:actions]).size}"
+          ]
+          if Array(orchestration[:attention_nodes]).any?
+            parts << "attention_nodes=#{orchestration[:attention_nodes].join(',')}"
+          end
+          if orchestration[:by_action] && !orchestration[:by_action].empty?
+            parts << "by_action=#{orchestration[:by_action].map { |key, value| "#{key}=#{value}" }.join(',')}"
+          end
+          parts.join(", ")
+        end
+
+        def orchestration_action_text(action)
+          "#{action[:node]}(#{action[:action]} reason=#{action[:reason]})"
+        end
+      end
+    end
+  end
+end

data/{lib/igniter → packages/igniter-core/lib/igniter/core}/diagnostics/report.rb

@@ -10,7 +10,7 @@ module Igniter
       def to_h
         safely_resolve_execution
 
-        {
+        report = {
           graph: execution.compiled_graph.name,
           execution_id: execution.events.execution_id,
           status: status,
@@ -20,6 +20,8 @@ module Igniter
           collection_nodes: summarize_collection_nodes,
           events: summarize_events
         }
+
+        Diagnostics.augment_report(report: report, execution: execution)
       end
 
       def as_json(*)
@@ -36,6 +38,7 @@ module Igniter
         lines << format_nodes(report[:nodes])
         lines << format_collection_nodes(report[:collection_nodes])
         lines << format_errors(report[:errors])
+        Diagnostics.append_text(report: report, lines: lines)
         lines << format_events(report[:events])
         lines.compact.join("\n")
       end
@@ -52,6 +55,7 @@ module Igniter
         unless report[:collection_nodes].empty?
           lines << "- Collections: #{report[:collection_nodes].map { |node| "#{node[:node_name]} total=#{node[:total]} succeeded=#{node[:succeeded]} failed=#{node[:failed]} status=#{node[:status]}" }.join('; ')}"
         end
+        Diagnostics.append_markdown_summary(report: report, lines: lines)
         lines << "- Events: total=#{report[:events][:total]}, latest=#{report[:events][:latest_type] || 'none'}"
 
         unless report[:errors].empty?
@@ -73,6 +77,7 @@ module Igniter
           end
         end
 
+        Diagnostics.append_markdown_sections(report: report, lines: lines)
         lines.join("\n")
       end
 
@@ -80,10 +85,6 @@ module Igniter
 
       attr_reader :execution
 
-      def execution_result
-        @execution_result ||= Runtime::Result.new(execution)
-      end
-
       def safely_resolve_execution
         execution.resolve_all
       rescue Igniter::Error
@@ -178,7 +179,6 @@ module Igniter
       end
 
       def format_nodes(nodes)
-        line = "Nodes: total=#{nodes[:total]}, succeeded=#{nodes[:succeeded]}, failed=#{nodes[:failed]}, stale=#{nodes[:stale]}"
         line = "Nodes: total=#{nodes[:total]}, succeeded=#{nodes[:succeeded]}, failed=#{nodes[:failed]}, pending=#{nodes[:pending]}, stale=#{nodes[:stale]}"
         return line if nodes[:failed_nodes].empty?
 
@@ -235,6 +235,8 @@ module Igniter
 
       def serialize_value(value)
         case value
+        when Runtime::StreamResult
+          value.as_json
         when Runtime::DeferredResult
           value.as_json
         when Runtime::Result
@@ -251,6 +253,8 @@ module Igniter
       def inline_value(value)
         case value
         when Hash
+          return summarize_serialized_deferred_hash(value) if serialized_deferred_hash?(value)
+          return summarize_serialized_failed_output_hash(value) if serialized_failed_output_hash?(value)
           return summarize_serialized_collection_hash(value) if serialized_collection_hash?(value)
           return summarize_serialized_collection_items_hash(value) if serialized_collection_items_hash?(value)
 
@@ -291,6 +295,70 @@ module Igniter
         "{mode=#{value[:mode].inspect}, total=#{summary[:total]}, succeeded=#{summary[:succeeded]}, failed=#{summary[:failed]}, status=#{summary[:status].inspect}, keys=#{items.keys.inspect}, failed_keys=#{failed_keys.inspect}}"
       end
 
+      def serialized_deferred_hash?(value)
+        (value.key?(:token) || value.key?("token")) &&
+          (value.key?(:waiting_on) || value.key?("waiting_on"))
+      end
+
+      def summarize_serialized_deferred_hash(value)
+        token = hash_value(value, :token)
+        waiting_on = hash_value(value, :waiting_on)
+        payload = hash_value(value, :payload)
+        type = hash_value(value, :type)
+        phase = hash_value(value, :phase)
+        event_count = hash_value(value, :event_count)
+        tool_call_count = hash_value(value, :tool_call_count)
+        tool_result_count = hash_value(value, :tool_result_count)
+        tool_interaction_count = hash_value(value, :tool_interaction_count)
+        pending_tool_interaction_count = hash_value(value, :pending_tool_interaction_count)
+        completed_tool_interaction_count = hash_value(value, :completed_tool_interaction_count)
+        orphan_tool_interaction_count = hash_value(value, :orphan_tool_interaction_count)
+        tool_loop_status = hash_value(value, :tool_loop_status)
+        tool_loop_complete = hash_value(value, :tool_loop_complete)
+        status_count = hash_value(value, :status_count)
+        artifact_count = hash_value(value, :artifact_count)
+        chunks = hash_value(value, :chunks)
+        routing_summary = hash_value(value, :routing_trace_summary)
+        agent_summary = hash_value(value, :agent_trace_summary)
+
+        parts = ["token=#{token.inspect}", "waiting_on=#{waiting_on.inspect}"]
+        parts << "type=#{type.inspect}" if type
+        parts << "phase=#{phase.inspect}" if phase
+        parts << "events=#{event_count}" if event_count
+        parts << "statuses=#{status_count}" if status_count.to_i.positive?
+        parts << "tool_calls=#{tool_call_count}" if tool_call_count.to_i.positive?
+        parts << "tool_results=#{tool_result_count}" if tool_result_count.to_i.positive?
+        parts << "tool_interactions=#{tool_interaction_count}" if tool_interaction_count.to_i.positive?
+        parts << "open_tool_interactions=#{pending_tool_interaction_count}" if pending_tool_interaction_count.to_i.positive?
+        parts << "completed_tool_interactions=#{completed_tool_interaction_count}" if completed_tool_interaction_count.to_i.positive?
+        parts << "orphan_tool_interactions=#{orphan_tool_interaction_count}" if orphan_tool_interaction_count.to_i.positive?
+        parts << "tool_loop=#{tool_loop_status}" if tool_loop_status
+        parts << "tool_loop_complete=#{tool_loop_complete}" unless tool_loop_complete.nil?
+        parts << "artifacts=#{artifact_count}" if artifact_count.to_i.positive?
+        parts << "chunks=#{chunks.inspect}" if chunks.is_a?(Array) && !chunks.empty?
+        parts << "payload_keys=#{payload.keys.inspect}" if payload.is_a?(Hash) && !payload.empty?
+        parts << "routing=#{routing_summary}" if routing_summary
+        parts << "agent=#{agent_summary}" if agent_summary
+        "{#{parts.join(', ')}}"
+      end
+
+      def serialized_failed_output_hash?(value)
+        (value.key?(:error) || value.key?("error")) &&
+          (value.key?(:status) || value.key?("status"))
+      end
+
+      def summarize_serialized_failed_output_hash(value)
+        status = hash_value(value, :status)
+        error = hash_value(value, :error)
+        routing_summary = hash_value(value, :routing_trace_summary)
+        agent_summary = hash_value(value, :agent_trace_summary)
+
+        parts = ["status=#{status.inspect}", "error=#{error.inspect}"]
+        parts << "routing=#{routing_summary}" if routing_summary
+        parts << "agent=#{agent_summary}" if agent_summary
+        "{#{parts.join(', ')}}"
+      end
+
       def serialized_collection_items_hash?(value)
         return false if value.empty?
 
@@ -344,6 +412,13 @@ module Igniter
           }
         end
       end
+
+      def hash_value(hash, key)
+        return hash[key] if hash.key?(key)
+        return hash[key.to_s] if hash.key?(key.to_s)
+
+        nil
+      end
     end
   end
 end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "diagnostics/report"
+require_relative "diagnostics/agent_contributor"
+require_relative "diagnostics/capability_contributor"
+require_relative "diagnostics/orchestration_contributor"
+
+module Igniter
+  module Diagnostics
+    class << self
+      def report_contributors
+        @report_contributors ||= {}
+      end
+
+      def register_report_contributor(name, contributor)
+        report_contributors[name.to_sym] = contributor
+      end
+
+      def augment_report(report:, execution:)
+        report_contributors.each_value do |contributor|
+          next unless contributor.respond_to?(:augment)
+
+          contributor.augment(report: report, execution: execution)
+        end
+
+        report
+      end
+
+      def append_text(report:, lines:)
+        report_contributors.each_value do |contributor|
+          next unless contributor.respond_to?(:append_text)
+
+          contributor.append_text(report: report, lines: lines)
+        end
+      end
+
+      def append_markdown_summary(report:, lines:)
+        report_contributors.each_value do |contributor|
+          next unless contributor.respond_to?(:append_markdown_summary)
+
+          contributor.append_markdown_summary(report: report, lines: lines)
+        end
+      end
+
+      def append_markdown_sections(report:, lines:)
+        report_contributors.each_value do |contributor|
+          next unless contributor.respond_to?(:append_markdown_sections)
+
+          contributor.append_markdown_sections(report: report, lines: lines)
+        end
+      end
+    end
+
+    register_report_contributor(:core_agents, AgentContributor)
+    register_report_contributor(:core_capabilities, CapabilityContributor)
+    register_report_contributor(:core_orchestration, OrchestrationContributor)
+  end
+end