igniter 0.4.5 → 0.5.1

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Igniter
+  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 AI::Executor skills:
+    #
+    #   class CallTranscriber < Igniter::AI::Transcriber
+    #     transcription_provider :deepgram
+    #     model "nova-3"
+    #     language "ru"
+    #     diarize true
+    #
+    #     def call(audio_path:)
+    #       transcribe(audio_path)
+    #     end
+    #   end
+    #
+    #   # Standalone
+    #   result = CallTranscriber.call(audio_path: "call_123.mp3")
+    #   result.text          # => "Добрый день, чем могу помочь?"
+    #   result.speakers      # => [#<SpeakerSegment speaker=0 ...>, ...]
+    #
+    #   # Inside a Contract graph
+    #   compute :transcript, call: CallTranscriber, with: :audio_path, cache_ttl: 3600
+    class Transcriber < Igniter::Executor
+      PROVIDERS = %i[openai deepgram assemblyai].freeze
+      DEFAULT_MODELS = { openai: "whisper-1", deepgram: "nova-3", assemblyai: "universal-2" }.freeze
+
+      class << self
+        def inherited(subclass)
+          super
+          TRANSCRIBER_IVARS.each do |ivar|
+            subclass.instance_variable_set(ivar, instance_variable_get(ivar))
+          end
+        end
+
+        # ── Provider DSL ───────────────────────────────────────────────────
+
+        def transcription_provider(name = nil)
+          return @transcription_provider if name.nil?
+
+          name = name.to_sym
+          unless PROVIDERS.include?(name)
+            raise ArgumentError, "Unknown transcription provider #{name.inspect}. Available: #{PROVIDERS.inspect}"
+          end
+
+          @transcription_provider = name
+        end
+
+        def model(name = nil)
+          return @transcription_model if name.nil?
+
+          @transcription_model = name.to_s
+        end
+
+        def language(lang = nil)
+          return @language if lang.nil?
+
+          @language = lang.to_s
+        end
+
+        def diarize(bool = nil)
+          return @diarize.nil? ? false : @diarize if bool.nil?
+
+          @diarize = bool
+        end
+        alias diarize? diarize
+
+        def word_timestamps(bool = nil)
+          return @word_timestamps.nil? || @word_timestamps if bool.nil?
+
+          @word_timestamps = bool
+        end
+
+        # ── Polling DSL (AssemblyAI) ───────────────────────────────────────
+
+        # Seconds between poll attempts (uses exponential backoff up to 30s).
+        def poll_interval(secs = nil)
+          return @poll_interval || 2 if secs.nil?
+
+          @poll_interval = secs.to_f
+        end
+
+        # Maximum total seconds to wait for async transcription.
+        def poll_timeout(secs = nil)
+          return @poll_timeout || 300 if secs.nil?
+
+          @poll_timeout = secs.to_f
+        end
+      end
+
+      # All instance variables the DSL manages — copied in inherited hook.
+      TRANSCRIBER_IVARS = %i[
+        @transcription_provider @transcription_model @language
+        @diarize @word_timestamps @poll_interval @poll_timeout
+      ].freeze
+      private_constant :TRANSCRIBER_IVARS
+
+      protected
+
+      # Transcribe audio and return a TranscriptResult.
+      # Call this from your #call implementation.
+      #
+      # @param audio_source [String, Pathname, IO] File path or IO object.
+      # @param options [Hash] Provider-specific extras forwarded verbatim.
+      # @return [Transcription::TranscriptResult]
+      def transcribe(audio_source, **options)
+        provider_instance.transcribe(
+          audio_source,
+          model: current_model,
+          language: self.class.language,
+          diarize: self.class.diarize?,
+          word_timestamps: self.class.word_timestamps,
+          poll_interval: self.class.poll_interval,
+          poll_timeout: self.class.poll_timeout,
+          **options
+        )
+      end
+
+      private
+
+      def provider_instance
+        pname = self.class.transcription_provider
+        unless pname
+          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::AI.transcription_provider_instance(pname)
+      end
+
+      def current_model
+        self.class.model ||
+          Transcriber::DEFAULT_MODELS[self.class.transcription_provider] ||
+          raise(Igniter::AI::ConfigurationError,
+                "No model configured for provider #{self.class.transcription_provider}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Igniter
+  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.
+      TranscriptWord = Struct.new(:word, :start_time, :end_time, :confidence, :speaker, keyword_init: true)
+
+      # A contiguous block of speech from one speaker.
+      SpeakerSegment = Struct.new(:speaker, :start_time, :end_time, :text, keyword_init: true)
+
+      # Normalised result returned by every Transcription provider.
+      #
+      # @attr text      [String]                   Full transcript text.
+      # @attr words     [Array<TranscriptWord>]     Word-level timestamps (empty Array if not requested).
+      # @attr speakers  [Array<SpeakerSegment>, nil] Speaker segments or nil when diarization was not requested.
+      # @attr language  [String, nil]               BCP-47 language code detected/specified (e.g. "en", "ru").
+      # @attr duration  [Float, nil]                Audio duration in seconds.
+      # @attr provider  [Symbol]                    Provider used (:openai, :deepgram, :assemblyai).
+      # @attr model     [String]                    Model string (e.g. "whisper-1", "nova-3").
+      # @attr raw       [Hash]                      Original provider response — provider-specific extras live here.
+      TranscriptResult = Struct.new(
+        :text, :words, :speakers, :language, :duration, :provider, :model, :raw,
+        keyword_init: true
+      )
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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 AI
+    class Error < Igniter::Error; end
+    class ProviderError < Error; end
+    class ConfigurationError < Error; end
+
+    AVAILABLE_PROVIDERS = Config::PROVIDERS
+
+    class << self
+      def config
+        @config ||= Config.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Returns a memoized provider instance for the given provider name.
+      def provider_instance(name)
+        @provider_instances ||= {}
+        @provider_instances[name.to_sym] ||= build_provider(name.to_sym)
+      end
+
+      # Returns a memoized transcription provider instance.
+      def transcription_provider_instance(name)
+        @transcription_provider_instances ||= {}
+        @transcription_provider_instances[name.to_sym] ||= build_transcription_provider(name.to_sym)
+      end
+
+      # Reset cached provider instances (useful after reconfiguration).
+      def reset_providers!
+        @provider_instances = nil
+        @transcription_provider_instances = nil
+      end
+
+      private
+
+      def build_provider(name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        case name
+        when :ollama
+          cfg = config.ollama
+          Providers::Ollama.new(base_url: cfg.base_url, timeout: cfg.timeout)
+        when :anthropic
+          cfg = config.anthropic
+          Providers::Anthropic.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        when :openai
+          cfg = config.openai
+          Providers::OpenAI.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        else
+          raise ConfigurationError, "Unknown LLM provider: #{name}. Available: #{AVAILABLE_PROVIDERS.inspect}"
+        end
+      end
+
+      def build_transcription_provider(name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        case name
+        when :openai
+          cfg = config.openai
+          Transcription::Providers::OpenAI.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        when :deepgram
+          cfg = config.deepgram
+          Transcription::Providers::Deepgram.new(api_key: cfg.api_key, base_url: cfg.base_url, timeout: cfg.timeout)
+        when :assemblyai
+          cfg = config.assemblyai
+          Transcription::Providers::AssemblyAI.new(
+            api_key: cfg.api_key,
+            base_url: cfg.base_url,
+            timeout: cfg.timeout,
+            poll_interval: cfg.poll_interval,
+            poll_timeout: cfg.poll_timeout
+          )
+        else
+          raise ConfigurationError,
+                "Unknown transcription provider: #{name}. Available: #{Config::TRANSCRIPTION_PROVIDERS.inspect}"
+        end
+      end
+    end
+  end
+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/packages/igniter-app/lib/igniter/app/autoloader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    # Eagerly loads all .rb files matching a glob path.
+    # Used by App#executors_path / #contracts_path.
+    class Autoloader
+      def initialize(base_dir:)
+        @base_dir = File.expand_path(base_dir)
+      end
+
+      def load_path(path)
+        full = File.expand_path(path, @base_dir)
+        Dir.glob("#{full}/**/*.rb").sort.each { |f| require f }
+      end
+    end
+  end
+end

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