igniter 0.5.0 → 0.5.2

data/lib/igniter/integrations/llm/transcription/providers/openai.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module LLM
-    module Transcription
-      module Providers
-        # OpenAI Whisper transcription provider.
-        #
-        # API: POST /v1/audio/transcriptions (multipart/form-data)
-        # Docs: https://platform.openai.com/docs/api-reference/audio
-        #
-        # Limitations vs other providers:
-        #   - No speaker diarization (speakers will be nil in result)
-        #   - 20 MB file size limit
-        #   - Only word-level granularity (no sentence-level)
-        #
-        # Extra options passed through:
-        #   prompt:          String  — context hint to guide spelling/vocabulary
-        #   response_format: Symbol  — :srt or :vtt stores raw subtitles in result.raw[:subtitle_text]
-        class OpenAI < Base
-          API_BASE = "https://api.openai.com"
-
-          def initialize(api_key: ENV["OPENAI_API_KEY"], base_url: API_BASE, timeout: 120)
-            super()
-            @api_key  = api_key
-            @base_url = base_url.to_s.chomp("/")
-            @timeout  = timeout
-          end
-
-          def transcribe(audio_source, model:, language: nil, _diarize: false, # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
-                         word_timestamps: true, **options)
-            validate_api_key!
-
-            audio = read_audio(audio_source)
-            fname = filename_from(audio_source)
-            ctype = audio_content_type(fname)
-
-            fields = {
-              "file" => { data: audio, filename: fname, content_type: ctype },
-              "model" => model,
-              "response_format" => "verbose_json"
-            }
-            fields["language"] = language if language
-            fields["prompt"]   = options[:prompt] if options[:prompt]
-            # Request word-level timestamps
-            fields["timestamp_granularities[]"] = "word" if word_timestamps
-
-            body, boundary = build_multipart(fields)
-            raw = post_multipart("/v1/audio/transcriptions", body, boundary)
-            build_result(raw, model: model)
-          end
-
-          private
-
-          def build_result(raw, model:) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-            words = (raw["words"] || []).map do |w|
-              TranscriptWord.new(
-                word: w["word"].to_s.strip,
-                start_time: w["start"].to_f,
-                end_time: w["end"].to_f,
-                confidence: w["confidence"]&.to_f,
-                speaker: nil # Whisper has no diarization
-              )
-            end
-
-            TranscriptResult.new(
-              text: raw["text"].to_s,
-              words: words,
-              speakers: nil,
-              language: raw["language"],
-              duration: raw["duration"]&.to_f,
-              provider: :openai,
-              model: model,
-              raw: raw
-            )
-          end
-
-          def post_multipart(path, body, boundary)
-            uri  = URI.parse("#{@base_url}#{path}")
-            http = http_for(uri)
-
-            request = Net::HTTP::Post.new(uri.path)
-            request["Authorization"] = "Bearer #{@api_key}"
-            request["Content-Type"]  = "multipart/form-data; boundary=#{boundary}"
-            request.body             = body
-
-            handle_response(http.request(request))
-          rescue Errno::ECONNREFUSED, SocketError, Net::OpenTimeout => e
-            raise Igniter::LLM::ProviderError, "Cannot connect to OpenAI API: #{e.message}"
-          end
-
-          def validate_api_key!
-            return if @api_key && !@api_key.empty?
-
-            raise Igniter::LLM::ConfigurationError,
-                  "OpenAI API key not configured. Set OPENAI_API_KEY or pass api_key: to the provider."
-          end
-        end
-      end
-    end
-  end
-end

data/lib/igniter/integrations/llm/transcription/transcriber.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module LLM
-    # 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:
-    #
-    #   class CallTranscriber < Igniter::LLM::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::LLM::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)
-      end
-
-      def current_model
-        self.class.model ||
-          Transcriber::DEFAULT_MODELS[self.class.transcription_provider] ||
-          raise(Igniter::LLM::ConfigurationError,
-                "No model configured for provider #{self.class.transcription_provider}")
-      end
-    end
-  end
-end

data/lib/igniter/integrations/llm/transcription/transcript_result.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module LLM
-    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/lib/igniter/integrations/llm.rb

@@ -1,95 +0,0 @@
-# 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"
-
-module Igniter
-  module LLM
-    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/lib/igniter/integrations/rails/cable_adapter.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Rails
-    # ActionCable channel mixin for streaming contract execution events.
-    #
-    # Usage:
-    #   class OrderChannel < ApplicationCable::Channel
-    #     include Igniter::Rails::CableAdapter
-    #
-    #     subscribed do
-    #       stream_contract(OrderContract, execution_id: params[:execution_id])
-    #     end
-    #   end
-    #
-    # Broadcasts events as:
-    #   { type: "node_succeeded", node: "payment", status: "succeeded", payload: { ... } }
-    module CableAdapter
-      def stream_contract(contract_class, execution_id:, store: nil)
-        resolved_store = store || Igniter.execution_store
-        snapshot = resolved_store.fetch(execution_id)
-        instance = contract_class.restore(snapshot)
-
-        instance.subscribe do |event|
-          broadcast_igniter_event(event, execution_id)
-        end
-
-        @_igniter_executions ||= []
-        @_igniter_executions << instance
-      rescue Igniter::ResolutionError => e
-        transmit({ type: "error", message: e.message })
-      end
-
-      private
-
-      def broadcast_igniter_event(event, execution_id)
-        transmit({
-          type: event.type.to_s,
-          execution_id: execution_id,
-          node: event.node_name,
-          path: event.path,
-          status: event.status,
-          payload: event.payload,
-          timestamp: event.timestamp&.iso8601
-        }.compact)
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails/contract_job.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Rails
-    # Base ActiveJob class for async contract execution.
-    #
-    # Usage:
-    #   class ProcessOrderJob < Igniter::Rails::ContractJob
-    #     contract OrderContract
-    #   end
-    #
-    #   ProcessOrderJob.perform_later(order_id: "ord-123")
-    #   ProcessOrderJob.perform_now(order_id: "ord-123")
-    #
-    # The job starts the contract and persists it to the configured store.
-    # If the contract has correlation keys, the execution can be resumed
-    # later via Contract.deliver_event.
-    class ContractJob
-      # No dependency on ActiveJob here — this class acts as a blueprint.
-      # When Rails is present, subclasses inherit from ApplicationJob automatically
-      # if the user adds `< ApplicationJob` (the recommended pattern).
-
-      class << self
-        def contract(klass = nil)
-          @contract_class = klass if klass
-          @contract_class
-        end
-
-        def store(store_instance = nil)
-          @store = store_instance if store_instance
-          @store || Igniter.execution_store
-        end
-
-        # Wraps perform in an ActiveJob-compatible interface.
-        # Call this when Rails is available to get ActiveJob queueing.
-        def perform_later(**inputs)
-          if defined?(::ActiveJob::Base)
-            ActiveJobAdapter.perform_later(contract_class: contract, inputs: inputs, store: store)
-          else
-            perform_now(**inputs)
-          end
-        end
-
-        def perform_now(**inputs)
-          contract.start(inputs, store: store)
-        end
-      end
-
-      # Included by ActiveJobAdapter to bridge ActiveJob lifecycle.
-      module Perform
-        def perform(contract_class_name:, inputs:, store_class: nil, store_config: nil)
-          klass = Object.const_get(contract_class_name)
-          resolved_store = resolve_store(store_class, store_config)
-          klass.start(inputs.transform_keys(&:to_sym), store: resolved_store)
-        end
-
-        private
-
-        def resolve_store(store_class, _store_config)
-          return Igniter.execution_store unless store_class
-
-          Object.const_get(store_class).new
-        end
-      end
-    end
-
-    # ActiveJob adapter — only defined when ActiveJob is available.
-    if defined?(::ActiveJob::Base)
-      class ActiveJobAdapter < ::ActiveJob::Base
-        include ContractJob::Perform
-
-        queue_as :igniter
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails/generators/contract/contract_generator.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module Igniter
-  module Rails
-    module Generators
-      class ContractGenerator < ::Rails::Generators::NamedBase
-        source_root File.expand_path("templates", __dir__)
-        desc "Creates an Igniter contract."
-
-        class_option :correlate_by, type: :array, default: [], desc: "Correlation key names"
-        class_option :inputs, type: :array, default: [], desc: "Input names"
-        class_option :outputs, type: :array, default: ["result"], desc: "Output names"
-
-        def create_contract
-          template "contract.rb.tt", File.join("app/contracts", class_path, "#{file_name}_contract.rb")
-        end
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails/generators/install/install_generator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module Igniter
-  module Rails
-    module Generators
-      class InstallGenerator < ::Rails::Generators::Base
-        source_root File.expand_path("templates", __dir__)
-        desc "Creates an Igniter initializer in your application."
-
-        def copy_initializer
-          template "igniter.rb.tt", "config/initializers/igniter.rb"
-        end
-
-        def create_contracts_directory
-          empty_directory "app/contracts"
-          create_file "app/contracts/.keep"
-        end
-
-        def show_readme
-          say "", :green
-          say "✓ Igniter installed!", :green
-          say ""
-          say "Next steps:"
-          say "  1. Configure your store in config/initializers/igniter.rb"
-          say "  2. Generate a contract: rails g igniter:contract YourContractName"
-          say ""
-        end
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails/railtie.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Rails
-    class Railtie < ::Rails::Railtie
-      initializer "igniter.configure_store" do
-        # Auto-configure store based on available adapters unless already set
-        next if Igniter.instance_variable_defined?(:@execution_store)
-
-        Igniter.execution_store =
-          if defined?(Redis) && ::Rails.application.config.respond_to?(:redis)
-            Igniter::Runtime::Stores::RedisStore.new(::Redis.current)
-          else
-            Igniter::Runtime::Stores::MemoryStore.new
-          end
-      end
-
-      initializer "igniter.load_contracts" do
-        ::Rails.autoloaders.main.on_load("ApplicationContract") do
-          # Hook point for future eager loading of compiled contracts
-        end
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails/webhook_concern.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Rails
-    # Controller mixin for delivering external events to running contracts.
-    #
-    # Usage:
-    #   class WebhooksController < ApplicationController
-    #     include Igniter::Rails::WebhookHandler
-    #
-    #     def stripe
-    #       deliver_event_for(
-    #         OrderContract,
-    #         event:            :stripe_payment_succeeded,
-    #         correlation_from: { order_id: params[:metadata][:order_id] },
-    #         payload:          params.to_unsafe_h
-    #       )
-    #     end
-    #   end
-    module WebhookHandler
-      def deliver_event_for(contract_class, event:, correlation_from:, payload: nil, store: nil) # rubocop:disable Metrics/MethodLength
-        payload_data = payload || (respond_to?(:params) ? params.to_unsafe_h : {})
-        correlation = extract_correlation(correlation_from)
-
-        contract_class.deliver_event(
-          event,
-          correlation: correlation,
-          payload: payload_data,
-          store: store || Igniter.execution_store
-        )
-
-        head :ok
-      rescue Igniter::ResolutionError => e
-        render json: { error: e.message }, status: :unprocessable_entity
-      end
-
-      private
-
-      def extract_correlation(source)
-        case source
-        when Hash then source.transform_keys(&:to_sym)
-        when Symbol then { source => params[source] }
-        when Array then source.each_with_object({}) { |k, h| h[k.to_sym] = params[k] }
-        else source.to_h.transform_keys(&:to_sym)
-        end
-      end
-    end
-  end
-end

data/lib/igniter/integrations/rails.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require_relative "rails/railtie" if defined?(::Rails::Railtie)
-require_relative "rails/contract_job"
-require_relative "rails/webhook_concern"
-require_relative "rails/cable_adapter"
-
-module Igniter
-  module Rails
-  end
-end