igniter 0.5.1 → 0.5.2

data/packages/igniter-frontend/lib/igniter/frontend/tailwind.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-require_relative "../frontend"
-require_relative "tailwind/ui"
-require_relative "tailwind/realtime"
-require_relative "tailwind/surfaces"
-
-module Igniter
-  module Frontend
-    module Tailwind
-      PLAY_CDN_URL = "https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4".freeze
-      MERMAID_CDN_URL = "https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js".freeze
-      DEFAULT_BODY_CLASS = "min-h-screen bg-slate-950 text-slate-100 antialiased".freeze
-      DEFAULT_MAIN_CLASS = "mx-auto flex min-h-screen w-full max-w-6xl flex-col gap-10 px-6 py-10 lg:px-10".freeze
-      DEFAULT_TAILWIND_CONFIG = {
-        theme: {
-          extend: {
-            fontFamily: {
-              display: ["Fraunces", "Iowan Old Style", "Palatino Linotype", "serif"],
-              body: ["IBM Plex Sans", "Avenir Next", "system-ui", "sans-serif"],
-              mono: ["IBM Plex Mono", "SFMono-Regular", "Menlo", "monospace"]
-            }
-          }
-        }
-      }.freeze
-      THEMES = {
-        default: {
-          body_class: DEFAULT_BODY_CLASS,
-          main_class: DEFAULT_MAIN_CLASS,
-          tailwind_config: DEFAULT_TAILWIND_CONFIG
-        },
-        ops: {
-          body_class: "min-h-screen bg-stone-950 text-stone-100 antialiased selection:bg-amber-300/30 selection:text-white",
-          main_class: "mx-auto flex min-h-screen w-full max-w-7xl flex-col gap-6 px-4 py-6 sm:px-6 lg:px-8",
-          tailwind_config: {
-            theme: {
-              extend: {
-                fontFamily: {
-                  display: ["Fraunces", "Iowan Old Style", "Palatino Linotype", "serif"],
-                  body: ["IBM Plex Sans", "Avenir Next", "system-ui", "sans-serif"],
-                  mono: ["IBM Plex Mono", "SFMono-Regular", "Menlo", "monospace"]
-                },
-                colors: {
-                  lab: {
-                    accent: "#D97706",
-                    canvas: "#0c0a09",
-                    panel: "#1c1917",
-                    line: "#292524"
-                  }
-                },
-                boxShadow: {
-                  glow: "0 20px 80px rgba(217, 119, 6, 0.10)"
-                }
-              }
-            }
-          }
-        },
-        companion: {
-          body_class: "min-h-screen bg-[#160f0d] text-stone-100 antialiased selection:bg-orange-300/30 selection:text-white",
-          main_class: "mx-auto flex min-h-screen w-full max-w-7xl flex-col gap-6 px-4 py-6 sm:px-6 lg:px-8",
-          tailwind_config: {
-            theme: {
-              extend: {
-                fontFamily: {
-                  display: ["Fraunces", "Iowan Old Style", "Palatino Linotype", "serif"],
-                  body: ["IBM Plex Sans", "Avenir Next", "system-ui", "sans-serif"],
-                  mono: ["IBM Plex Mono", "SFMono-Regular", "Menlo", "monospace"]
-                },
-                colors: {
-                  companion: {
-                    accent: "#c26b3d",
-                    panel: "#2a1914"
-                  }
-                }
-              }
-            }
-          }
-        },
-        schema: {
-          body_class: "min-h-screen bg-stone-950 text-stone-100 antialiased selection:bg-orange-300/30 selection:text-white",
-          main_class: "mx-auto flex min-h-screen w-full max-w-4xl flex-col gap-5 px-4 py-6 sm:px-6 lg:px-8",
-          tailwind_config: DEFAULT_TAILWIND_CONFIG
-        }
-      }.freeze
-
-      module_function
-
-      def render_page(title:, lang: "en", theme: nil, body_class: DEFAULT_BODY_CLASS, main_class: DEFAULT_MAIN_CLASS,
-                      include_play_cdn: true, tailwind_config: nil, head_content: nil, &block)
-        raise ArgumentError, "render_page requires a block" unless block
-        resolved = resolve_page_options(theme: theme, body_class: body_class, main_class: main_class, tailwind_config: tailwind_config)
-
-        Frontend.render do |view|
-          view.doctype
-          view.tag(:html, lang: lang) do |html|
-            html.tag(:head) do |head|
-              head.tag(:meta, charset: "utf-8")
-              head.tag(:meta, name: "viewport", content: "width=device-width, initial-scale=1")
-              head.tag(:title, title)
-              head.tag(:script, src: PLAY_CDN_URL) if include_play_cdn
-              render_config_script(head, resolved.fetch(:tailwind_config)) if resolved[:tailwind_config]
-              head_content&.call(head)
-            end
-
-            html.tag(:body, class: resolved.fetch(:body_class)) do |body|
-              body.tag(:main, class: resolved.fetch(:main_class)) do |main|
-                block.call(main)
-              end
-            end
-          end
-        end
-      end
-
-      def render_message_page(title:, eyebrow:, message:, back_label:, back_path:, detail: nil,
-                              lang: "en", theme: nil, body_class: DEFAULT_BODY_CLASS, main_class: DEFAULT_MAIN_CLASS,
-                              include_play_cdn: true, tailwind_config: nil, head_content: nil, **message_page_options)
-        render_page(
-          title: title,
-          lang: lang,
-          theme: theme,
-          body_class: body_class,
-          main_class: main_class,
-          include_play_cdn: include_play_cdn,
-          tailwind_config: tailwind_config,
-          head_content: head_content
-        ) do |main|
-          main.component(
-            UI::MessagePage.new(
-              title: title,
-              eyebrow: eyebrow,
-              message: message,
-              back_label: back_label,
-              back_path: back_path,
-              detail: detail,
-              **message_page_options
-            )
-          )
-        end
-      end
-
-      def theme(theme_name)
-        THEMES.fetch(theme_name.to_sym)
-      end
-
-      def resolve_page_options(theme:, body_class:, main_class:, tailwind_config:)
-        preset = theme ? self.theme(theme) : {}
-
-        {
-          body_class: body_class == DEFAULT_BODY_CLASS ? preset.fetch(:body_class, body_class) : body_class,
-          main_class: main_class == DEFAULT_MAIN_CLASS ? preset.fetch(:main_class, main_class) : main_class,
-          tailwind_config: if tailwind_config
-                             deep_merge(preset.fetch(:tailwind_config, {}), tailwind_config)
-                           else
-                             preset[:tailwind_config]
-                           end
-        }
-      end
-      private_class_method :resolve_page_options
-
-      def render_config_script(view, config)
-        payload = config.is_a?(String) ? config : "tailwind.config = #{JSON.generate(config)};"
-        view.tag(:script, type: "text/javascript") do |script|
-          script.raw(payload)
-        end
-      end
-      private_class_method :render_config_script
-
-      def deep_merge(base, override)
-        return override unless base.is_a?(Hash) && override.is_a?(Hash)
-
-        base.merge(override) do |_key, left, right|
-          left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
-        end
-      end
-      private_class_method :deep_merge
-    end
-  end
-end

data/packages/igniter-frontend/lib/igniter/frontend/version.rb

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

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/app"
-
-require_relative "frontend/version"
-require_relative "frontend/javascript"
-require_relative "frontend/assets"
-require_relative "frontend/builder"
-require_relative "frontend/component"
-require_relative "frontend/form_builder"
-require_relative "frontend/page"
-require_relative "frontend/request"
-require_relative "frontend/response"
-require_relative "frontend/app_access"
-require_relative "frontend/context"
-require_relative "frontend/handler"
-require_relative "frontend/app"
-require_relative "frontend/tailwind"
-require_relative "frontend/arbre"
-require_relative "frontend/arbre_page"
-require_relative "frontend/components"
-
-module Igniter
-  module Frontend
-    module_function
-
-    def render(&block)
-      builder = Builder.new
-      block.call(builder)
-      builder.to_s
-    end
-
-    alias fragment render
-  end
-end

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

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

data/packages/igniter-rails/README.md

@@ -1,96 +0,0 @@
-# igniter-rails
-
-Local monorepo gem that owns Igniter's Rails integration surface:
-
-- `Igniter::Rails`
-- `Igniter::Rails::ContractJob`
-- `Igniter::Rails::WebhookHandler`
-- `Igniter::Rails::CableAdapter`
-- `Igniter::Rails::Railtie`
-
-Primary entrypoints:
-
-- `require "igniter-rails"`
-- `require "igniter/plugins/rails"`
-
-## Embedded Rails Profile
-
-The canonical Rails scenario is still an embedded Igniter runtime inside an
-existing Rails app:
-
-```ruby
-require "igniter"
-require "igniter/plugins/rails"
-```
-
-Use this when Rails already owns:
-
-- boot lifecycle
-- HTTP/controller flow
-- background jobs
-- Action Cable or other Rails framework surfaces
-
-And Igniter only needs to provide:
-
-- contracts
-- compile-time validation
-- lazy runtime execution
-- resumable executions through a configured store
-
-## What The Rails Plugin Loads
-
-`require "igniter/plugins/rails"` loads the embedded kernel plus the Rails
-adapter package. It does not implicitly load:
-
-- `igniter/app`
-- `igniter/server`
-- `igniter/cluster`
-
-Those layers stay opt-in. If a Rails app later wants Igniter's app/server or
-cluster runtime, require those entrypoints explicitly.
-
-`require "igniter/rails"` is not a public entrypoint.
-
-## Typical Setup
-
-```ruby
-# config/initializers/igniter.rb
-require "igniter/plugins/rails"
-
-Igniter.execution_store =
-  Igniter::Runtime::Stores::ActiveRecordStore.new(
-    record_class: ContractExecutionRecord
-  )
-```
-
-Example integration points:
-
-```ruby
-class ProcessOrderJob < ApplicationJob
-  include Igniter::Rails::ContractJob::Perform
-end
-
-class WebhooksController < ApplicationController
-  include Igniter::Rails::WebhookHandler
-end
-
-class OrderChannel < ApplicationCable::Channel
-  include Igniter::Rails::CableAdapter
-end
-```
-
-## Boundary Contract
-
-- `igniter-rails` owns the `Igniter::Rails` namespace.
-- It is an integration package, not part of the runtime hosting pyramid.
-- It should remain usable from the embedded kernel without silently promoting
-  the app into `app`, `server`, or `cluster` mode.
-- Framework glue belongs here; generic runtime or hosting behavior belongs in
-  the runtime packages.
-
-Docs:
-
-- [Guide](../../docs/guide/README.md)
-- [Deployment Modes](../../docs/guide/deployment-modes.md)
-- [Integrations](../../docs/guide/integrations.md)
-- [Dev](../../docs/dev/README.md)

data/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/rails/generators/contract/templates/contract.rb.tt

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class <%= class_name %>Contract < Igniter::Contract
-<% if options[:correlate_by].any? -%>
-  correlate_by <%= options[:correlate_by].map { |k| ":#{k}" }.join(", ") %>
-
-<% end -%>
-  define do
-<% (options[:inputs].any? ? options[:inputs] : ["id"]).each do |input| -%>
-    input :<%= input %>
-<% end -%>
-
-    # TODO: add compute nodes
-    # compute :result, depends_on: :id do |id:|
-    #   { id: id }
-    # end
-
-<% options[:outputs].each do |output| -%>
-    # output :<%= output %>, from: :<%= output %>
-<% end -%>
-  end
-end

data/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/rails/generators/install/templates/igniter.rb.tt

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Igniter configuration
-# See: https://github.com/your-org/igniter
-
-Igniter.configure do |config|
-  # Store: persists execution state for long-running and distributed workflows.
-  # Defaults to MemoryStore (in-process, no persistence).
-  #
-  # For production, use Redis:
-  #   config.execution_store = Igniter::Runtime::Stores::RedisStore.new(Redis.new(url: ENV["REDIS_URL"]))
-  #
-  # Or ActiveRecord (requires igniter-active_record migration):
-  #   config.execution_store = Igniter::Runtime::Stores::ActiveRecordStore.new
-  config.execution_store = Igniter::Runtime::Stores::MemoryStore.new
-end

data/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/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/packages/igniter-rails/lib/igniter/plugins/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

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

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

data/packages/igniter-schema-rendering/README.md

@@ -1,27 +0,0 @@
-# igniter-schema-rendering
-
-`igniter-schema-rendering` is a local monorepo gem for agent-facing and
-schema-driven rendering on top of Igniter.
-
-It groups the schema-specific surface that does not belong in the human-first
-frontend package:
-
-- schema page rendering
-- schema renderer/runtime
-- schema storage and patching
-- submission normalization/validation/processing
-
-The intent is to keep `igniter-frontend` focused on developer-authored human UI,
-while this package owns the machine-authored or agent-oriented schema lane.
-
-This package now owns the schema runtime directly inside the monorepo:
-
-- schema loading and validation
-- schema rendering
-- schema storage and patching
-- submission normalization, validation, and processing
-
-Docs:
-
-- [Guide](../../docs/guide/README.md)
-- [Dev](../../docs/dev/README.md)