igniter 0.5.1 → 0.5.2

data/packages/igniter-agents/lib/igniter/ai/agents.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/agent"
-require_relative "agents/router_agent"
-require_relative "agents/critic_agent"
-require_relative "agents/planner_agent"
-require_relative "agents/chain_agent"
-require_relative "agents/self_reflection_agent"
-require_relative "agents/observer_agent"
-require_relative "agents/evaluator_agent"
-require_relative "agents/evolution_agent"
-
-module Igniter
-  module AI
-    module Agents
-      # Convenience method — list all built-in AI agents.
-      #
-      # @return [Array<Class>]
-      def self.all
-        [RouterAgent, CriticAgent, PlannerAgent, ChainAgent,
-         SelfReflectionAgent, ObserverAgent, EvaluatorAgent, EvolutionAgent]
-      end
-    end
-  end
-end

data/packages/igniter-agents/lib/igniter/registry.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/errors"
-
-module Igniter
-  # Thread-safe process registry mapping names to agent Refs.
-  #
-  # Names can be any object that is a valid Hash key (Symbols recommended).
-  #
-  #   Igniter::Registry.register(:counter, ref)
-  #   Igniter::Registry.find(:counter)    # => ref
-  #   Igniter::Registry.unregister(:counter)
-  #
-  module Registry
-    class RegistryError < Igniter::Error; end
-
-    @store = {}
-    @mutex = Mutex.new
-
-    class << self
-      # Register +ref+ under +name+. Raises RegistryError if the name is taken.
-      def register(name, ref)
-        @mutex.synchronize do
-          raise RegistryError, "Name '#{name}' is already registered" if @store.key?(name)
-
-          @store[name] = ref
-        end
-        ref
-      end
-
-      # Register (or replace) +ref+ under +name+ without uniqueness check.
-      def register!(name, ref)
-        @mutex.synchronize { @store[name] = ref }
-        ref
-      end
-
-      # Return the Ref registered under +name+, or nil if not found.
-      def find(name)
-        @mutex.synchronize { @store[name] }
-      end
-
-      # Return the Ref or raise RegistryError if not found.
-      def fetch(name)
-        @mutex.synchronize do
-          @store.fetch(name) { raise RegistryError, "No agent registered as '#{name}'" }
-        end
-      end
-
-      # Remove and return the Ref registered under +name+.
-      def unregister(name)
-        @mutex.synchronize { @store.delete(name) }
-      end
-
-      def registered?(name)
-        @mutex.synchronize { @store.key?(name) }
-      end
-
-      # Snapshot of the current name→Ref map.
-      def all
-        @mutex.synchronize { @store.dup }
-      end
-
-      # Remove all registrations (useful in tests).
-      def clear
-        @mutex.synchronize { @store.clear }
-      end
-    end
-  end
-end

data/packages/igniter-agents/lib/igniter/runtime/registry_agent_adapter.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/runtime/agent_adapter"
-
-module Igniter
-  module Runtime
-    # Default agent-node adapter backed by the local process registry.
-    #
-    # This keeps core independent from actor runtime details while still giving
-    # embedded/app usage a straightforward execution model for agent nodes.
-    class RegistryAgentAdapter < AgentAdapter
-      def call(node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
-        ref = fetch_ref(node)
-        return ref if ref.is_a?(Hash)
-
-        {
-          status: :succeeded,
-          output: ref.call(node.message_name, inputs, timeout: node.timeout),
-          agent_trace: success_trace(node, outcome: :replied)
-        }
-      rescue Igniter::PendingDependencyError => e
-        pending(node, e)
-      rescue Igniter::Agent::TimeoutError => e
-        failure(node, e.message, reason: :timeout)
-      end
-
-      def cast(node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
-        ref = fetch_ref(node)
-        return ref if ref.is_a?(Hash)
-
-        ref.send(node.message_name, inputs)
-        { status: :succeeded, output: nil, agent_trace: success_trace(node, outcome: :sent) }
-      end
-
-      private
-
-      def fetch_ref(node)
-        ref = Igniter::Registry.find(node.agent_name)
-        return failure(node, "No registered agent #{node.agent_name.inspect} is available", reason: :not_registered, registered: false, alive: false) unless ref
-        return failure(node, "Registered agent #{node.agent_name.inspect} is not alive", reason: :not_alive, registered: true, alive: false) unless ref.alive?
-
-        ref
-      end
-
-      def success_trace(node, outcome:)
-        {
-          adapter: :registry,
-          mode: node.mode,
-          via: node.agent_name,
-          message: node.message_name,
-          local: true,
-          registered: true,
-          alive: true,
-          outcome: outcome
-        }
-      end
-
-      def failure(node, message, reason:, registered: nil, alive: nil)
-        {
-          status: :failed,
-          error: { message: message },
-          agent_trace: compact_trace({
-            adapter: :registry,
-            mode: node.mode,
-            via: node.agent_name,
-            message: node.message_name,
-            local: true,
-            registered: registered,
-            alive: alive,
-            reason: reason
-          })
-        }
-      end
-
-      def pending(node, error)
-        {
-          status: :pending,
-          message: error.message,
-          deferred_result: error.deferred_result,
-          payload: error.deferred_result&.payload || {},
-          agent_trace: success_trace(node, outcome: :pending)
-        }
-      end
-
-      def compact_trace(trace)
-        trace.each_with_object({}) do |(key, value), memo|
-          memo[key] = value unless value.nil?
-        end
-      end
-    end
-
-    class << self
-      def activate_agent_adapter!
-        self.agent_adapter = RegistryAgentAdapter.new
-      end
-
-      def deactivate_agent_adapter!
-        self.agent_adapter = AgentAdapter.new
-      end
-    end
-  end
-end

data/packages/igniter-agents/lib/igniter/supervisor.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/errors"
-require_relative "agent"
-
-module Igniter
-  # Supervises a group of agents and restarts them when they crash.
-  #
-  # Subclass Supervisor and declare children with the class-level DSL:
-  #
-  #   class AppSupervisor < Igniter::Supervisor
-  #     strategy     :one_for_one   # default
-  #     max_restarts 5, within: 60  # default
-  #
-  #     children do |c|
-  #       c.worker :counter, CounterAgent
-  #       c.worker :logger,  LoggerAgent, initial_state: { level: :info }
-  #     end
-  #   end
-  #
-  #   sup = AppSupervisor.start
-  #   sup.child(:counter).send(:increment, by: 1)
-  #   sup.stop
-  #
-  # Restart strategies:
-  #   :one_for_one  — restart only the crashed agent (default)
-  #   :one_for_all  — stop all agents and restart them all when any one crashes
-  #
-  # Restart budget: if more than +max_restarts+ crashes happen within +within+
-  # seconds, the supervisor logs the failure and stops trying to restart.
-  #
-  class Supervisor
-    class RestartBudgetExceeded < Igniter::Error; end
-
-    # ── ChildSpec ────────────────────────────────────────────────────────────
-
-    ChildSpec = Struct.new(:name, :agent_class, :init_opts, keyword_init: true)
-
-    class ChildSpecBuilder
-      attr_reader :specs
-
-      def initialize
-        @specs = []
-      end
-
-      def worker(name, agent_class, **opts)
-        @specs << ChildSpec.new(name: name.to_sym, agent_class: agent_class, init_opts: opts)
-      end
-    end
-
-    # ── Class-level defaults ─────────────────────────────────────────────────
-
-    @strategy        = :one_for_one
-    @max_restarts    = 5
-    @restart_window  = 60
-    @spec_builder    = ChildSpecBuilder.new
-
-    class << self
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@strategy,       :one_for_one)
-        subclass.instance_variable_set(:@max_restarts,   5)
-        subclass.instance_variable_set(:@restart_window, 60)
-        subclass.instance_variable_set(:@spec_builder,   ChildSpecBuilder.new)
-      end
-
-      def strategy(sym)
-        @strategy = sym
-      end
-
-      def max_restarts(count, within:)
-        @max_restarts   = count
-        @restart_window = within
-      end
-
-      def children(&block)
-        block.call(@spec_builder)
-      end
-
-      def child_specs
-        @spec_builder.specs
-      end
-
-      def start
-        new.tap(&:start_all)
-      end
-    end
-
-    # ── Instance ─────────────────────────────────────────────────────────────
-
-    def initialize
-      @refs          = {}
-      @specs_by_name = {}
-      @restart_log   = []
-      @mutex         = Mutex.new
-    end
-
-    def start_all
-      self.class.child_specs.each do |spec|
-        @specs_by_name[spec.name] = spec
-        start_child(spec)
-      end
-    end
-
-    # Return the Ref for a named child. Returns nil if not found.
-    def child(name)
-      @mutex.synchronize { @refs[name.to_sym] }
-    end
-
-    # Stop all children gracefully.
-    def stop
-      refs = @mutex.synchronize { @refs.values.dup }
-      refs.each do |ref|
-        ref.stop
-      rescue StandardError
-        nil
-      end
-      self
-    end
-
-    private
-
-    def start_child(spec)
-      opts = spec.init_opts.dup
-      opts[:on_crash] = ->(error) { handle_crash(spec, error) }
-      ref = spec.agent_class.start(**opts)
-      @mutex.synchronize { @refs[spec.name] = ref }
-      ref
-    end
-
-    def handle_crash(spec, _error)
-      check_restart_budget!
-
-      case self.class.instance_variable_get(:@strategy)
-      when :one_for_one
-        start_child(spec)
-      when :one_for_all
-        stop_all_children
-        self.class.child_specs.each { |s| start_child(s) }
-      end
-    rescue RestartBudgetExceeded => e
-      warn "Igniter::Supervisor #{self.class.name}: #{e.message}"
-    end
-
-    def check_restart_budget! # rubocop:disable Metrics/MethodLength
-      now    = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      window = self.class.instance_variable_get(:@restart_window).to_f
-      max    = self.class.instance_variable_get(:@max_restarts)
-
-      @mutex.synchronize do
-        @restart_log.reject! { |t| now - t > window }
-        @restart_log << now
-
-        if @restart_log.size > max
-          raise RestartBudgetExceeded,
-                "#{@restart_log.size} crashes in #{window}s (max=#{max})"
-        end
-      end
-    end
-
-    def stop_all_children
-      refs = @mutex.synchronize { @refs.values.dup }
-      refs.each do |ref|
-        ref.stop(timeout: 2)
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end

data/packages/igniter-ai/lib/igniter/ai/config.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module AI
-    class Config
-      class OllamaConfig
-        attr_accessor :base_url, :default_model, :timeout
-
-        def initialize
-          @base_url = "http://localhost:11434"
-          @default_model = "llama3.2"
-          @timeout = 120
-        end
-      end
-
-      class AnthropicConfig
-        attr_accessor :api_key, :base_url, :default_model, :timeout
-
-        def initialize
-          @api_key = ENV["ANTHROPIC_API_KEY"]
-          @base_url = "https://api.anthropic.com"
-          @default_model = "claude-sonnet-4-6"
-          @timeout = 120
-        end
-      end
-
-      class OpenAIConfig
-        attr_accessor :api_key, :base_url, :default_model, :timeout
-
-        def initialize
-          @api_key = ENV["OPENAI_API_KEY"]
-          @base_url = "https://api.openai.com"
-          @default_model = "gpt-4o"
-          @timeout = 120
-        end
-      end
-
-      class DeepgramConfig
-        attr_accessor :api_key, :base_url, :timeout
-
-        def initialize
-          @api_key  = ENV["DEEPGRAM_API_KEY"]
-          @base_url = "https://api.deepgram.com"
-          @timeout  = 300
-        end
-      end
-
-      class AssemblyAIConfig
-        attr_accessor :api_key, :base_url, :timeout, :poll_interval, :poll_timeout
-
-        def initialize
-          @api_key       = ENV["ASSEMBLYAI_API_KEY"]
-          @base_url      = "https://api.assemblyai.com"
-          @timeout       = 60
-          @poll_interval = 2
-          @poll_timeout  = 300
-        end
-      end
-
-      PROVIDERS                 = %i[ollama anthropic openai].freeze
-      TRANSCRIPTION_PROVIDERS   = %i[openai deepgram assemblyai].freeze
-
-      attr_accessor :default_provider
-      attr_reader :providers, :transcription_providers
-
-      def initialize # rubocop:disable Metrics/MethodLength
-        @default_provider = :ollama
-        @providers = {
-          ollama: OllamaConfig.new,
-          anthropic: AnthropicConfig.new,
-          openai: OpenAIConfig.new
-        }
-        @transcription_providers = {
-          openai: @providers[:openai], # reuse existing OpenAI config
-          deepgram: DeepgramConfig.new,
-          assemblyai: AssemblyAIConfig.new
-        }
-      end
-
-      def ollama
-        @providers[:ollama]
-      end
-
-      def anthropic
-        @providers[:anthropic]
-      end
-
-      def openai
-        @providers[:openai]
-      end
-
-      def deepgram
-        @transcription_providers[:deepgram]
-      end
-
-      def assemblyai
-        @transcription_providers[:assemblyai]
-      end
-
-      def provider_config(name)
-        @providers.fetch(name.to_sym) do
-          raise ArgumentError, "Unknown LLM provider: #{name}. Available: #{PROVIDERS.inspect}"
-        end
-      end
-
-      def transcription_provider_config(name)
-        @transcription_providers.fetch(name.to_sym) do
-          raise ArgumentError, "Unknown transcription provider: #{name}. Available: #{TRANSCRIPTION_PROVIDERS.inspect}"
-        end
-      end
-    end
-  end
-end

data/packages/igniter-ai/lib/igniter/ai/context.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module AI
-    # Manages a conversation message history for multi-turn LLM interactions.
-    # Immutable — each operation returns a new Context.
-    #
-    # Usage:
-    #   ctx = Igniter::AI::Context.empty(system: "You are a helpful assistant.")
-    #   ctx = ctx.append_user("What is Ruby?")
-    #   ctx = ctx.append_assistant("Ruby is a dynamic language...")
-    #   ctx.messages  # => [{role: :system, ...}, {role: :user, ...}, {role: :assistant, ...}]
-    class Context
-      attr_reader :messages
-
-      def initialize(messages = [])
-        @messages = messages.freeze
-      end
-
-      def self.empty(system: nil)
-        initial = system ? [{ role: :system, content: system }] : []
-        new(initial)
-      end
-
-      def self.from_h(data)
-        msgs = (data[:messages] || data["messages"] || []).map do |m|
-          { role: (m[:role] || m["role"]).to_sym, content: (m[:content] || m["content"]).to_s }
-        end
-        new(msgs)
-      end
-
-      def append_user(content)
-        append(role: :user, content: content)
-      end
-
-      def append_assistant(content)
-        append(role: :assistant, content: content)
-      end
-
-      def append_tool_result(tool_name, content)
-        append(role: :tool, content: content.to_s, name: tool_name.to_s)
-      end
-
-      def append(message)
-        self.class.new(@messages + [message.transform_keys(&:to_sym)])
-      end
-
-      def with_system(content)
-        existing = @messages.reject { |m| m[:role] == :system }
-        self.class.new([{ role: :system, content: content }] + existing)
-      end
-
-      def last_assistant_message
-        @messages.reverse.find { |m| m[:role] == :assistant }
-      end
-
-      def length
-        @messages.length
-      end
-
-      def empty?
-        @messages.empty?
-      end
-
-      def to_a
-        @messages.map { |m| { "role" => m[:role].to_s, "content" => m[:content].to_s } }
-      end
-
-      def to_h
-        { messages: @messages }
-      end
-    end
-  end
-end