igniter 0.5.1 → 0.5.2

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

@@ -1,162 +0,0 @@
-# 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/introspection/formatters/mermaid_formatter.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Diagnostics
-    module Introspection
-      module Formatters
-        class MermaidFormatter
-          def self.call(structure)
-            new(structure).call
-          end
-
-          def initialize(structure)
-            @structure = structure
-            @output = StringIO.new
-          end
-
-          def call
-            # Устанавливаем направление диаграммы слева направо
-            @output.puts "graph LR"
-            @output.puts "classDef default fill:#fff,stroke:#333,stroke-width:2px;"
-
-            # Запускаем рекурсивную отрисовку
-            draw_nodes_and_links(@structure)
-
-            @output.string
-          end
-
-          private
-
-          def draw_nodes_and_links(nodes)
-            nodes.each do |node|
-              # 1. Если узел - это Namespace, создаем для него subgraph
-              if node[:type] == "Namespace"
-                @output.puts "  subgraph #{node[:name]}"
-                # Рекурсивно отрисовываем всех детей внутри подграфа
-                draw_nodes_and_links(node[:children])
-                @output.puts "  end"
-              else
-                # 2. Если это обычный узел, просто объявляем его
-                node_text = "\"#{node[:name]}<br>[#{node[:details]}]\""
-                @output.puts "  #{node[:path]}(#{node_text})"
-
-                # У обычного узла тоже могут быть дети (например, проекции у композиции),
-                # их тоже нужно отрисовать.
-                draw_nodes_and_links(node[:children])
-              end
-
-              # 3. После объявления узла (или целого подграфа) рисуем его зависимости
-              node[:dependencies].each do |dep_path|
-                @output.puts "  #{dep_path} --> #{node[:path]}"
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/diagnostics/introspection/formatters/text_tree_formatter.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Diagnostics
-    module Introspection
-      module Formatters
-        class TextTreeFormatter
-          def self.call(structure)
-            new(structure).call
-          end
-
-          def initialize(structure)
-            @structure = structure
-            @output = StringIO.new
-          end
-
-          def call
-            @structure.each_with_index do |node, index|
-              is_last = index == @structure.size - 1
-              print_node(node, "", is_last)
-            end
-            @output.string
-          end
-
-          private
-
-          def print_node(node, prefix, is_last)
-            connector = is_last ? "└── " : "├── "
-            @output << "#{prefix}#{connector}#{node[:name]} [#{node[:type]}] #{node[:details]}\n"
-
-            children_prefix = prefix + (is_last ? "    " : "│   ")
-            if node[:dependencies].any?
-              @output << "#{children_prefix}  └─ depends_on: [#{node[:dependencies].join(', ')}]\n"
-            end
-
-            node[:children].each_with_index do |child, index|
-              print_node(child, children_prefix, index == node[:children].size - 1)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

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