igniter 0.5.0 → 0.5.1

data/{lib/igniter/integrations/llm → packages/igniter-ai/lib/igniter/ai}/transcription/providers/deepgram.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Igniter
-  module LLM
+  module AI
     module Transcription
       module Providers
         # Deepgram transcription provider (Nova-3 and others).
@@ -146,13 +146,13 @@ module Igniter
 
             handle_response(http.request(request))
           rescue Errno::ECONNREFUSED, SocketError, Net::OpenTimeout => e
-            raise Igniter::LLM::ProviderError, "Cannot connect to Deepgram API: #{e.message}"
+            raise Igniter::AI::ProviderError, "Cannot connect to Deepgram API: #{e.message}"
           end
 
           def validate_api_key!
             return if @api_key && !@api_key.empty?
 
-            raise Igniter::LLM::ConfigurationError,
+            raise Igniter::AI::ConfigurationError,
                   "Deepgram API key not configured. Set DEEPGRAM_API_KEY or pass api_key: to the provider."
           end
         end

data/{lib/igniter/integrations/llm → packages/igniter-ai/lib/igniter/ai}/transcription/providers/openai.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Igniter
-  module LLM
+  module AI
     module Transcription
       module Providers
         # OpenAI Whisper transcription provider.
@@ -86,13 +86,13 @@ module Igniter
 
             handle_response(http.request(request))
           rescue Errno::ECONNREFUSED, SocketError, Net::OpenTimeout => e
-            raise Igniter::LLM::ProviderError, "Cannot connect to OpenAI API: #{e.message}"
+            raise Igniter::AI::ProviderError, "Cannot connect to OpenAI API: #{e.message}"
           end
 
           def validate_api_key!
             return if @api_key && !@api_key.empty?
 
-            raise Igniter::LLM::ConfigurationError,
+            raise Igniter::AI::ConfigurationError,
                   "OpenAI API key not configured. Set OPENAI_API_KEY or pass api_key: to the provider."
           end
         end

data/{lib/igniter/integrations/llm → packages/igniter-ai/lib/igniter/ai}/transcription/transcriber.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Igniter
-  module LLM
+  module AI
     # Base class for audio transcription executors.
     #
     # A Transcriber is a fully-fledged Igniter::Executor — it can be used as a
     # compute node in a Contract graph, paired with cache_ttl:, and composed
-    # with downstream LLM::Executor skills:
+    # with downstream AI::Executor skills:
     #
-    #   class CallTranscriber < Igniter::LLM::Transcriber
+    #   class CallTranscriber < Igniter::AI::Transcriber
     #     transcription_provider :deepgram
     #     model "nova-3"
     #     language "ru"
@@ -126,18 +126,18 @@ module Igniter
       def provider_instance
         pname = self.class.transcription_provider
         unless pname
-          raise Igniter::LLM::ConfigurationError,
+          raise Igniter::AI::ConfigurationError,
                 "#{self.class.name}: transcription_provider not configured. " \
                 "Call transcription_provider :openai, :deepgram, or :assemblyai in your class."
         end
 
-        @provider_instance ||= Igniter::LLM.transcription_provider_instance(pname)
+        @provider_instance ||= Igniter::AI.transcription_provider_instance(pname)
       end
 
       def current_model
         self.class.model ||
           Transcriber::DEFAULT_MODELS[self.class.transcription_provider] ||
-          raise(Igniter::LLM::ConfigurationError,
+          raise(Igniter::AI::ConfigurationError,
                 "No model configured for provider #{self.class.transcription_provider}")
       end
     end

data/{lib/igniter/integrations/llm → packages/igniter-ai/lib/igniter/ai}/transcription/transcript_result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Igniter
-  module LLM
+  module AI
     module Transcription
       # Single word with timing and optional speaker label.
       # end_time is used instead of `end` to avoid the Ruby keyword conflict.

data/{lib/igniter/integrations/llm.rb → packages/igniter-ai/lib/igniter/ai.rb}

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
-require "igniter"
-require_relative "llm/config"
-require_relative "llm/context"
-require_relative "llm/providers/base"
-require_relative "llm/providers/ollama"
-require_relative "llm/providers/anthropic"
-require_relative "llm/providers/openai"
-require_relative "llm/executor"
-require_relative "llm/transcription/transcript_result"
-require_relative "llm/transcription/providers/base"
-require_relative "llm/transcription/providers/openai"
-require_relative "llm/transcription/providers/deepgram"
-require_relative "llm/transcription/providers/assemblyai"
-require_relative "llm/transcription/transcriber"
+require "igniter/core/errors"
+require "igniter/core/tool"
+require_relative "ai/config"
+require_relative "ai/context"
+require_relative "ai/providers/base"
+require_relative "ai/providers/ollama"
+require_relative "ai/providers/anthropic"
+require_relative "ai/providers/openai"
+require_relative "ai/executor"
+require_relative "ai/transcription/transcript_result"
+require_relative "ai/transcription/providers/base"
+require_relative "ai/transcription/providers/openai"
+require_relative "ai/transcription/providers/deepgram"
+require_relative "ai/transcription/providers/assemblyai"
+require_relative "ai/transcription/transcriber"
+require_relative "ai/skill"
+require_relative "ai/tool_registry"
 
 module Igniter
-  module LLM
+  module AI
     class Error < Igniter::Error; end
     class ProviderError < Error; end
     class ConfigurationError < Error; end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "igniter/ai"

data/packages/igniter-app/README.md

@@ -0,0 +1,19 @@
+# igniter-app
+
+Local monorepo gem that owns Igniter's application runtime layer:
+
+- `Igniter::App`
+- app hosts, loaders, schedulers, diagnostics, evolution, and generators
+
+Primary entrypoints:
+
+- `require "igniter-app"`
+- `require "igniter/app"`
+- `require "igniter/app/runtime"`
+- `require "igniter/app/scaffold_pack"`
+
+Docs:
+
+- [Guide](../../docs/guide/README.md)
+- [App guide](../../docs/guide/app.md)
+- [Dev](../../docs/dev/README.md)

data/packages/igniter-app/lib/igniter/app/app_config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "host_config"
+require_relative "app_host_config"
+require_relative "cluster_app_host_config"
+
+module Igniter
+  class App
+    # Unified configuration object for an Igniter::App.
+    # Captures application-owned hosting settings before a concrete host adapter
+    # maps them into a runtime-specific config object.
+    class AppConfig
+      attr_accessor :store, :metrics_collector,
+                    :custom_routes, :before_request_hooks, :after_request_hooks, :around_request_hooks
+
+      attr_reader :app_host, :cluster_app_host
+
+      def initialize
+        @app_host          = AppHostConfig.new
+        @cluster_app_host  = ClusterAppHostConfig.new
+        @store             = nil
+        @metrics_collector = nil
+        @custom_routes     = []
+        @before_request_hooks = []
+        @after_request_hooks = []
+        @around_request_hooks = []
+      end
+
+      def to_host_config
+        HostConfig.new.tap do |config|
+          config.store                = store
+          config.metrics_collector    = metrics_collector
+          config.custom_routes        = custom_routes.dup
+          config.before_request_hooks = before_request_hooks.dup
+          config.after_request_hooks  = after_request_hooks.dup
+          config.around_request_hooks = around_request_hooks.dup
+          config.configure_host(:app, app_host.to_h)
+          config.configure_host(:cluster_app, cluster_app_host.to_h)
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/app_host.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "host_adapter"
+
+module Igniter
+  class App
+    # Default server-backed host adapter for Igniter::App.
+    #
+    # This class belongs to the application layer's host model. It happens to be
+    # implemented on top of Igniter::Server today, but the host decision is now
+    # expressed explicitly from the application side.
+    class AppHost < HostAdapter
+      def build_config(host_config)
+        ensure_server_loaded!
+        app_settings = host_config.host_settings_for(:app)
+
+        Igniter::Server::Config.new.tap do |config|
+          config.host                 = app_settings.fetch(:host, "0.0.0.0")
+          config.port                 = app_settings.fetch(:port, 4567)
+          config.store                = host_config.store if host_config.store
+          config.log_format           = app_settings.fetch(:log_format, :text)
+          config.drain_timeout        = app_settings.fetch(:drain_timeout, 30)
+          config.metrics_collector    = host_config.metrics_collector
+          config.custom_routes        = host_config.custom_routes
+          config.before_request_hooks = host_config.before_request_hooks
+          config.after_request_hooks  = host_config.after_request_hooks
+          config.around_request_hooks = host_config.around_request_hooks
+          host_config.registrations.each do |name, klass|
+            config.register(name, klass)
+          end
+        end
+      end
+
+      def activate_transport!
+        ensure_server_loaded!
+        Igniter::Server.activate_remote_adapter!
+      end
+
+      def start(config:)
+        ensure_server_loaded!
+        Igniter::Server::HttpServer.new(config).start
+      end
+
+      def rack_app(config:)
+        ensure_server_loaded!
+        Igniter::Server::RackApp.new(config)
+      end
+
+      private
+
+      def ensure_server_loaded!
+        require "igniter/server" unless defined?(Igniter::Server::Config)
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/app_host_config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    # Server-specific host settings owned by the application layer but scoped
+    # under the default server host instead of AppConfig's top level.
+    class AppHostConfig
+      attr_accessor :host, :port, :log_format, :drain_timeout
+
+      def initialize
+        @host = "0.0.0.0"
+        @port = 4567
+        @log_format = :text
+        @drain_timeout = 30
+      end
+
+      def to_h
+        {
+          host: host,
+          port: port,
+          log_format: log_format,
+          drain_timeout: drain_timeout
+        }
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/app_host_pack.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "host_registry"
+require_relative "app_host"
+require_relative "cluster_app_host"
+
+Igniter::App::HostRegistry.register(:app) do
+  Igniter::App::AppHost.new
+end
+
+Igniter::App::HostRegistry.register(:cluster_app) do
+  Igniter::App::ClusterAppHost.new
+end

data/{lib/igniter/application → packages/igniter-app/lib/igniter/app}/autoloader.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Igniter
-  class Application
+  class App
     # Eagerly loads all .rb files matching a glob path.
-    # Used by Application#executors_path / #contracts_path.
+    # Used by App#executors_path / #contracts_path.
     class Autoloader
       def initialize(base_dir:)
         @base_dir = File.expand_path(base_dir)

data/packages/igniter-app/lib/igniter/app/cluster_app_host.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "app_host"
+
+module Igniter
+  class App
+    # Cluster-backed host adapter for Igniter::App.
+    #
+    # It reuses the server host for HTTP serving, while layering in cluster
+    # transport activation plus mesh/bootstrap configuration on the application side.
+    class ClusterAppHost < AppHost
+      def build_config(host_config)
+        ensure_cluster_loaded!
+        config = super
+        apply_cluster_settings!(config, host_config.host_settings_for(:cluster_app))
+        config
+      end
+
+      def activate_transport!
+        ensure_cluster_loaded!
+        Igniter::Cluster.activate_remote_adapter!
+      end
+
+      def start(config:)
+        ensure_cluster_loaded!
+        start_discovery_if_needed!
+        super
+      end
+
+      def rack_app(config:)
+        ensure_cluster_loaded!
+        start_discovery_if_needed!
+        super
+      end
+
+      private
+
+      def apply_cluster_settings!(server_config, cluster_settings)
+        @cluster_settings = cluster_settings
+        return if cluster_settings.nil? || cluster_settings.empty?
+
+        local_capabilities = Array(cluster_settings[:local_capabilities]).map(&:to_sym)
+        local_tags = Array(cluster_settings[:local_tags]).map(&:to_sym)
+        local_metadata = Hash(cluster_settings[:local_metadata] || {})
+        trust_store = cluster_settings[:trust_store] || Igniter::Cluster::Trust::TrustStore.new
+        server_config.peer_name = cluster_settings[:peer_name]
+        server_config.peer_capabilities = local_capabilities
+        server_config.peer_tags = local_tags
+        server_config.peer_metadata = local_metadata
+        server_config.peer_identity = cluster_settings[:identity]
+        server_config.peer_trust_store = trust_store
+
+        Igniter::Cluster::Mesh.reset!
+        Igniter::Cluster::Mesh.configure do |c|
+          c.peer_name = cluster_settings[:peer_name]
+          c.local_capabilities = local_capabilities
+          c.local_tags = local_tags
+          c.local_metadata = local_metadata
+          c.seeds = Array(cluster_settings[:seeds])
+          c.discovery_interval = cluster_settings[:discovery_interval]
+          c.auto_announce = cluster_settings[:auto_announce]
+          c.local_url = cluster_settings[:local_url]
+          c.gossip_fanout = cluster_settings[:gossip_fanout]
+          c.identity = cluster_settings[:identity]
+          c.trust_store = trust_store
+          c.auto_self_heal = cluster_settings[:auto_self_heal]
+          c.self_heal_interval = cluster_settings[:self_heal_interval] if cluster_settings.key?(:self_heal_interval)
+          c.self_heal_limit = cluster_settings[:self_heal_limit] if cluster_settings.key?(:self_heal_limit)
+          c.self_heal_report_provider = cluster_settings[:self_heal_report_provider] if cluster_settings.key?(:self_heal_report_provider)
+
+          Array(cluster_settings[:peers]).each do |peer|
+            c.add_peer(
+              peer[:name],
+              url: peer[:url],
+              capabilities: peer[:capabilities],
+              tags: peer[:tags],
+              metadata: peer[:metadata]
+            )
+          end
+        end
+      end
+
+      def start_discovery_if_needed!
+        return unless @cluster_settings
+        return unless @cluster_settings[:start_discovery]
+
+        Igniter::Cluster::Mesh.start_discovery!
+      end
+
+      def ensure_cluster_loaded!
+        require "igniter/cluster" unless defined?(Igniter::Cluster::Mesh)
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/cluster_app_host_config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    # Cluster-specific host settings owned by the application layer.
+    class ClusterAppHostConfig
+      Peer = Struct.new(:name, :url, :capabilities, :tags, :metadata, keyword_init: true)
+
+      attr_accessor :peer_name, :local_capabilities, :local_tags, :local_metadata, :seeds,
+                    :discovery_interval, :auto_announce, :local_url, :gossip_fanout, :start_discovery,
+                    :identity, :trust_store, :auto_self_heal, :self_heal_interval,
+                    :self_heal_limit, :self_heal_report_provider
+
+      attr_reader :peers
+
+      def initialize
+        @peer_name          = nil
+        @local_capabilities = []
+        @local_tags         = []
+        @local_metadata     = {}
+        @seeds              = []
+        @discovery_interval = 30
+        @auto_announce      = true
+        @local_url          = nil
+        @gossip_fanout      = 3
+        @start_discovery    = false
+        @auto_self_heal     = false
+        @self_heal_interval = 15
+        @self_heal_limit    = nil
+        @self_heal_report_provider = nil
+        @identity           = nil
+        @trust_store        = nil
+        @peers              = []
+      end
+
+      def add_peer(name, url:, capabilities: [], tags: [], metadata: {})
+        @peers << Peer.new(
+          name: name.to_s,
+          url: url,
+          capabilities: Array(capabilities).map(&:to_sym),
+          tags: Array(tags).map(&:to_sym),
+          metadata: Hash(metadata)
+        )
+        self
+      end
+
+      def to_h
+        {
+          peer_name: peer_name,
+          local_capabilities: Array(local_capabilities).map(&:to_sym),
+          local_tags: Array(local_tags).map(&:to_sym),
+          local_metadata: Hash(local_metadata),
+          seeds: Array(seeds),
+          discovery_interval: discovery_interval,
+          auto_announce: auto_announce,
+          local_url: local_url,
+          gossip_fanout: gossip_fanout,
+          start_discovery: start_discovery,
+          auto_self_heal: auto_self_heal,
+          self_heal_interval: self_heal_interval,
+          self_heal_limit: self_heal_limit,
+          self_heal_report_provider: self_heal_report_provider,
+          identity: identity,
+          trust_store: trust_store,
+          peers: peers.map do |peer|
+            {
+              name: peer.name,
+              url: peer.url,
+              capabilities: peer.capabilities,
+              tags: peer.tags,
+              metadata: peer.metadata
+            }
+          end
+        }
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/credentials/config_loader.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Igniter
+  class App
+    module Credentials
+      class ConfigLoader
+        PROVIDER_ENV_KEYS = {
+          openai: {
+            api_key: "OPENAI_API_KEY",
+            base_url: "OPENAI_BASE_URL",
+            default_model: "OPENAI_DEFAULT_MODEL"
+          },
+          anthropic: {
+            api_key: "ANTHROPIC_API_KEY",
+            base_url: "ANTHROPIC_BASE_URL",
+            default_model: "ANTHROPIC_DEFAULT_MODEL"
+          },
+          deepgram: {
+            api_key: "DEEPGRAM_API_KEY",
+            base_url: "DEEPGRAM_BASE_URL"
+          },
+          assemblyai: {
+            api_key: "ASSEMBLYAI_API_KEY",
+            base_url: "ASSEMBLYAI_BASE_URL"
+          }
+        }.freeze
+
+        attr_reader :path, :override
+
+        def initialize(path:, override: false)
+          @path = path.to_s
+          @override = !!override
+        end
+
+        def self.load(path, override: false)
+          new(path: path, override: override).load
+        end
+
+        def self.apply(path, override: false, env: ENV)
+          new(path: path, override: override).apply(env: env)
+        end
+
+        def self.status(path, applied_keys: [], override: false, env: ENV)
+          new(path: path, override: override).status(applied_keys: applied_keys, env: env)
+        end
+
+        def load
+          return {} unless File.exist?(path)
+
+          YAML.safe_load(File.read(path)) || {}
+        end
+
+        def apply(env: ENV)
+          data = load
+          mappings = extract_mappings(data)
+
+          applied = mappings.each_with_object({}) do |(key, value), memo|
+            next if value.nil?
+            next if !override && present?(env[key])
+
+            env[key] = value.to_s
+            memo[key] = value.to_s
+          end
+
+          {
+            path: path,
+            applied: applied.freeze,
+            loaded: File.exist?(path)
+          }.freeze
+        end
+
+        def status(applied_keys: [], env: ENV)
+          data = load
+          normalized = symbolize_keys(data)
+          normalized_env = normalize_env_map(normalized[:env])
+          applied_key_set = Array(applied_keys).map(&:to_s)
+
+          providers = PROVIDER_ENV_KEYS.each_with_object({}) do |(provider, keys), memo|
+            provider_values = symbolize_keys(normalized[provider] || {})
+            api_env_key = keys.fetch(:api_key)
+            configured_in_file = !provider_values[:api_key].to_s.strip.empty? || normalized_env.key?(api_env_key)
+            env_present = present?(env[api_env_key])
+            source =
+              if applied_key_set.include?(api_env_key)
+                :local_file
+              elsif env_present
+                :environment
+              elsif configured_in_file
+                :file_present_not_loaded
+              else
+                :missing
+              end
+
+            memo[provider] = {
+              env_key: api_env_key,
+              configured_in_file: configured_in_file,
+              env_present: env_present,
+              source: source
+            }.freeze
+          end
+
+          {
+            path: path,
+            loaded: File.exist?(path),
+            override: override,
+            applied_keys: applied_key_set.freeze,
+            providers: providers.freeze
+          }.freeze
+        end
+
+        private
+
+        def extract_mappings(data)
+          normalized = symbolize_keys(data)
+          mappings = {}
+
+          mappings.merge!(normalize_env_map(normalized[:env]))
+
+          PROVIDER_ENV_KEYS.each do |provider, keys|
+            provider_values = symbolize_keys(normalized[provider] || {})
+            keys.each do |field, env_key|
+              value = provider_values[field]
+              mappings[env_key] = value unless value.nil?
+            end
+          end
+
+          mappings.freeze
+        end
+
+        def normalize_env_map(value)
+          (value || {}).each_with_object({}) do |(key, entry), memo|
+            next if entry.nil?
+
+            memo[key.to_s] = entry
+          end
+        end
+
+        def symbolize_keys(hash)
+          (hash || {}).each_with_object({}) do |(key, value), memo|
+            memo[key.to_sym] = value
+          end
+        end
+
+        def present?(value)
+          !value.to_s.strip.empty?
+        end
+      end
+    end
+  end
+end