igniter 0.5.0 → 0.5.1

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

@@ -0,0 +1,180 @@
+# 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

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

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

data/packages/igniter-rails/README.md

@@ -0,0 +1,96 @@
+# 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/generators/contract/templates/contract.rb.tt

@@ -0,0 +1,22 @@
+# 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/templates/igniter.rb.tt

@@ -0,0 +1,16 @@
+# 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-rails.rb

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

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

@@ -0,0 +1,27 @@
+# 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)

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class Page
+      class << self
+        def render(**kwargs)
+          new(**kwargs).render
+        end
+      end
+
+      def render(**overrides)
+        render_schema(schema, **schema_render_options.merge(overrides))
+      end
+
+      def render_schema(schema_definition, **kwargs)
+        renderer_class.render(schema: schema_definition, **kwargs)
+      end
+
+      private
+
+      def renderer_class
+        Igniter::SchemaRendering::Renderer
+      end
+
+      def schema
+        raise NotImplementedError, "#{self.class} must implement #schema"
+      end
+
+      def schema_render_options
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    module SchemaPatcher
+      module_function
+
+      def apply(base, patch)
+        deep_merge(deep_copy(base), patch)
+      end
+
+      def deep_merge(base, patch)
+        return nil if patch.nil?
+        return deep_copy(patch) unless base.is_a?(Hash) && patch.is_a?(Hash)
+
+        patch.each do |key, value|
+          key_s = key.to_s
+
+          if value.nil?
+            base.delete(key_s)
+          elsif base[key_s].is_a?(Hash) && value.is_a?(Hash)
+            base[key_s] = deep_merge(base[key_s], stringify_keys(value))
+          else
+            base[key_s] = deep_copy(value)
+          end
+        end
+
+        base
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, entry), memo| memo[key.to_s] = stringify_keys(entry) }
+        when Array
+          value.map { |entry| stringify_keys(entry) }
+        else
+          value
+        end
+      end
+
+      def deep_copy(value)
+        Marshal.load(Marshal.dump(stringify_keys(value)))
+      end
+    end
+  end
+end