igniter 0.5.0 → 0.5.1

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/submission_validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class SubmissionValidator
+      def initialize(schema)
+        @schema = schema.is_a?(Schema) ? schema : Schema.load(schema)
+      end
+
+      def validate(payload, action_id:)
+        form = schema.form_for_action(action_id)
+        return { "_form" => "form not found for action #{action_id}" } unless form
+
+        each_form_field(form).each_with_object({}) do |field, errors|
+          name = field.fetch("name")
+          value = payload[name]
+
+          if field["required"] && blank?(value)
+            errors[name] = "is required"
+            next
+          end
+
+          validate_options(field, value, errors) if field["type"] == "select"
+        end
+      end
+
+      private
+
+      attr_reader :schema
+
+      def field_node?(node)
+        %w[input textarea select checkbox].include?(node["type"])
+      end
+
+      def each_form_field(node, result = [])
+        return result unless node.is_a?(Hash)
+
+        if field_node?(node)
+          result << node
+          return result
+        end
+
+        Array(node["children"]).each do |child|
+          each_form_field(child, result)
+        end
+
+        result
+      end
+
+      def blank?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      def validate_options(field, value, errors)
+        return if blank?(value)
+
+        values = Array(field["options"]).map { |option| option.fetch("value") }
+        errors[field.fetch("name")] = "must be one of the allowed options" unless values.include?(value)
+      end
+    end
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "igniter/core/version"
+
+module Igniter
+  module SchemaRendering
+    VERSION = Igniter::VERSION
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "igniter-frontend"
+
+require_relative "schema_rendering/version"
+require_relative "schema_rendering/schema"
+require_relative "schema_rendering/patcher"
+require_relative "schema_rendering/store"
+require_relative "schema_rendering/submission_normalizer"
+require_relative "schema_rendering/submission_validator"
+require_relative "schema_rendering/submission_processor"
+require_relative "schema_rendering/renderer"
+require_relative "schema_rendering/page"
+
+module Igniter
+  module SchemaRendering
+    Store = SchemaStore unless const_defined?(:Store, false)
+    Patcher = SchemaPatcher unless const_defined?(:Patcher, false)
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter-schema-rendering.rb

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

data/packages/igniter-sdk/README.md

@@ -0,0 +1,25 @@
+# igniter-sdk
+
+Local monorepo gem that owns Igniter's SDK registry plus non-AI optional packs:
+
+- `Igniter::SDK`
+- `Igniter::Channels`
+- `Igniter::Data`
+- built-in tools under `require "igniter/sdk/tools"`
+
+AI now lives in `igniter-ai`, agents live in `igniter-agents`, and
+`igniter-sdk` remains the capability registry and umbrella for pack activation.
+
+Primary entrypoints:
+
+- `require "igniter-sdk"`
+- `require "igniter/sdk"`
+- `require "igniter/sdk/channels"`
+- `require "igniter/sdk/data"`
+- `require "igniter/sdk/tools"`
+
+Docs:
+
+- [Guide](../../docs/guide/README.md)
+- [SDK guide](../../docs/guide/sdk.md)
+- [Dev](../../docs/dev/README.md)

data/packages/igniter-sdk/lib/igniter/sdk/channels/base.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Channels
+    class Base < Igniter::Effect
+      effect_type :messaging
+
+      class << self
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@channel_name, @channel_name)
+        end
+
+        def channel_name(value = nil)
+          return @channel_name || infer_channel_name if value.nil?
+
+          @channel_name = value.to_sym
+        end
+
+        private
+
+        def infer_channel_name
+          name.to_s.split("::").last
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+              .to_sym
+        end
+      end
+
+      def call(message: nil, **attrs)
+        deliver(message, **attrs)
+      end
+
+      def deliver(message = nil, **attrs)
+        resolved_message = Message.coerce(message, **attrs)
+        coerce_result(deliver_message(resolved_message), resolved_message)
+      rescue Igniter::Channels::Error
+        raise
+      rescue StandardError => e
+        raise DeliveryError.new(
+          e.message,
+          context: {
+            channel: self.class.channel_name,
+            recipient: resolved_message&.to
+          }.compact
+        )
+      end
+
+      private
+
+      def deliver_message(_message)
+        raise NotImplementedError, "#{self.class.name} must implement #deliver_message"
+      end
+
+      def coerce_result(result, message)
+        case result
+        when DeliveryResult
+          result
+        when Hash
+          DeliveryResult.new(
+            **{ provider: self.class.channel_name, recipient: message.to }
+              .merge(result.transform_keys(&:to_sym))
+          )
+        when String
+          DeliveryResult.new(
+            provider: self.class.channel_name,
+            recipient: message.to,
+            external_id: result,
+            status: :sent
+          )
+        when nil
+          DeliveryResult.new(
+            provider: self.class.channel_name,
+            recipient: message.to,
+            status: :sent
+          )
+        else
+          raise ArgumentError, "Expected DeliveryResult, Hash, String, or nil from #deliver_message"
+        end
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/channels/delivery_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Channels
+    class DeliveryResult
+      SUCCESS_STATUSES = %i[queued sent delivered].freeze
+      FAILURE_STATUSES = %i[failed rejected].freeze
+
+      attr_reader :status, :provider, :recipient, :message_id,
+                  :external_id, :payload, :error, :delivered_at
+
+      def initialize(
+        status: :sent,
+        provider: nil,
+        recipient: nil,
+        message_id: nil,
+        external_id: nil,
+        payload: {},
+        error: nil,
+        delivered_at: Time.now.utc
+      )
+        @status = status.to_sym
+        @provider = provider&.to_sym
+        @recipient = recipient
+        @message_id = message_id
+        @external_id = external_id
+        @payload = (payload || {}).dup.freeze
+        @error = error
+        @delivered_at = delivered_at.is_a?(String) ? Time.iso8601(delivered_at) : delivered_at
+        freeze
+      end
+
+      def success?
+        SUCCESS_STATUSES.include?(status)
+      end
+
+      def failure?
+        FAILURE_STATUSES.include?(status)
+      end
+
+      def to_h
+        {
+          status: status,
+          provider: provider,
+          recipient: recipient,
+          message_id: message_id,
+          external_id: external_id,
+          payload: payload,
+          error: error,
+          delivered_at: delivered_at
+        }
+      end
+
+      def as_json(*)
+        to_h.transform_values { |value| value.is_a?(Time) ? value.iso8601 : value }
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/channels/message.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Channels
+    class Message
+      attr_reader :to, :body, :subject, :sender, :reply_to,
+                  :attachments, :metadata, :content_type,
+                  :template, :template_vars, :idempotency_key,
+                  :correlation_id, :created_at
+
+      def self.coerce(message = nil, **attrs)
+        case message
+        when nil
+          new(**attrs)
+        when self
+          attrs.empty? ? message : message.with(**attrs)
+        when Hash
+          new(**message.transform_keys(&:to_sym).merge(attrs))
+        when String
+          new(body: message, **attrs)
+        else
+          raise ArgumentError, "Expected Igniter::Channels::Message, Hash, String, or nil"
+        end
+      end
+
+      def initialize(
+        to: nil,
+        body: nil,
+        subject: nil,
+        sender: nil,
+        reply_to: nil,
+        attachments: [],
+        metadata: {},
+        content_type: :text,
+        template: nil,
+        template_vars: {},
+        idempotency_key: nil,
+        correlation_id: nil,
+        created_at: Time.now.utc
+      )
+        @to = to
+        @body = body
+        @subject = subject
+        @sender = sender
+        @reply_to = reply_to
+        @attachments = Array(attachments).dup.freeze
+        @metadata = (metadata || {}).dup.freeze
+        @content_type = content_type&.to_sym
+        @template = template&.to_sym
+        @template_vars = (template_vars || {}).dup.freeze
+        @idempotency_key = idempotency_key
+        @correlation_id = correlation_id
+        @created_at = created_at.is_a?(String) ? Time.iso8601(created_at) : created_at
+        freeze
+      end
+
+      def with(**attrs)
+        self.class.new(**to_h.merge(attrs))
+      end
+
+      def to_h
+        {
+          to: to,
+          body: body,
+          subject: subject,
+          sender: sender,
+          reply_to: reply_to,
+          attachments: attachments,
+          metadata: metadata,
+          content_type: content_type,
+          template: template,
+          template_vars: template_vars,
+          idempotency_key: idempotency_key,
+          correlation_id: correlation_id,
+          created_at: created_at
+        }
+      end
+
+      def as_json(*)
+        to_h.transform_values { |value| serialize_value(value) }
+      end
+
+      private
+
+      def serialize_value(value)
+        case value
+        when Time
+          value.iso8601
+        when Hash
+          value.each_with_object({}) { |(key, nested), memo| memo[key] = serialize_value(nested) }
+        when Array
+          value.map { |item| serialize_value(item) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/channels/telegram.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Igniter
+  module Channels
+    class Telegram < Base
+      DEFAULT_API_BASE_URL = "https://api.telegram.org"
+      DEFAULT_OPEN_TIMEOUT = 10
+      DEFAULT_READ_TIMEOUT = 30
+
+      effect_type :telegram
+      channel_name :telegram
+
+      def initialize(bot_token: ENV["TELEGRAM_BOT_TOKEN"],
+                     default_chat_id: ENV["TELEGRAM_CHAT_ID"],
+                     api_base_url: DEFAULT_API_BASE_URL,
+                     parse_mode: nil,
+                     disable_notification: false,
+                     disable_web_page_preview: nil,
+                     open_timeout: DEFAULT_OPEN_TIMEOUT,
+                     read_timeout: DEFAULT_READ_TIMEOUT)
+        @bot_token = bot_token
+        @default_chat_id = default_chat_id
+        @api_base_url = api_base_url
+        @parse_mode = parse_mode
+        @disable_notification = disable_notification
+        @disable_web_page_preview = disable_web_page_preview
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+      end
+
+      private
+
+      def deliver_message(message)
+        raise ArgumentError, "Telegram bot token is required" if blank?(@bot_token)
+
+        chat_id = resolve_chat_id(message)
+        uri = endpoint_uri
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(payload_for(message, chat_id))
+
+        response = perform_request(uri, request)
+        parsed = parse_response(response.body)
+
+        unless response.is_a?(Net::HTTPSuccess) && parsed.fetch("ok", false)
+          raise DeliveryError.new(
+            "Telegram delivery failed: #{parsed["description"] || "HTTP #{response.code}"}",
+            context: {
+              channel: self.class.channel_name,
+              recipient: chat_id,
+              status_code: response.code.to_i,
+              response_body: response.body.to_s[0, 300]
+            }
+          )
+        end
+
+        telegram_message = parsed["result"] || {}
+
+        DeliveryResult.new(
+          status: :delivered,
+          provider: self.class.channel_name,
+          recipient: chat_id,
+          message_id: telegram_message["message_id"],
+          external_id: telegram_message["message_id"]&.to_s,
+          payload: parsed
+        )
+      rescue URI::InvalidURIError => e
+        raise DeliveryError.new(
+          "Invalid Telegram API URL: #{e.message}",
+          context: { channel: self.class.channel_name }
+        )
+      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+        raise DeliveryError.new(
+          "Cannot deliver Telegram message: #{e.message}",
+          context: { channel: self.class.channel_name, recipient: message.to || @default_chat_id }
+        )
+      end
+
+      def resolve_chat_id(message)
+        chat_id = message.metadata[:chat_id] || message.to || @default_chat_id
+        raise ArgumentError, "Telegram chat_id is required" if blank?(chat_id)
+
+        chat_id.to_s.sub(/\Atelegram:/, "")
+      end
+
+      def endpoint_uri
+        base = @api_base_url.to_s.sub(%r{/+\z}, "")
+        URI.parse("#{base}/bot#{@bot_token}/sendMessage")
+      end
+
+      def payload_for(message, chat_id)
+        raise ArgumentError, "Telegram attachments are not supported yet" if message.attachments.any?
+
+        text = render_text(message)
+        raise ArgumentError, "Telegram message body is required" if blank?(text)
+
+        payload = {
+          chat_id: chat_id,
+          text: text,
+          disable_notification: resolve_disable_notification(message)
+        }
+
+        parse_mode = message.metadata[:parse_mode] || @parse_mode
+        payload[:parse_mode] = parse_mode if parse_mode
+
+        preview = resolve_preview_flag(message)
+        payload[:link_preview_options] = { is_disabled: true } unless preview.nil? || !preview
+
+        thread_id = message.metadata[:message_thread_id]
+        payload[:message_thread_id] = thread_id if thread_id
+
+        reply_to_message_id = message.metadata[:reply_to_message_id]
+        payload[:reply_to_message_id] = reply_to_message_id if reply_to_message_id
+
+        reply_markup = message.metadata[:reply_markup]
+        payload[:reply_markup] = reply_markup if reply_markup
+
+        payload
+      end
+
+      def render_text(message)
+        parts = [message.subject, message.body].compact.map(&:to_s).reject(&:empty?)
+        parts.join("\n\n")
+      end
+
+      def resolve_disable_notification(message)
+        return message.metadata[:disable_notification] unless message.metadata[:disable_notification].nil?
+
+        @disable_notification
+      end
+
+      def resolve_preview_flag(message)
+        return message.metadata[:disable_web_page_preview] unless message.metadata[:disable_web_page_preview].nil?
+
+        @disable_web_page_preview
+      end
+
+      def perform_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        http.request(request)
+      end
+
+      def parse_response(body)
+        JSON.parse(body.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end