igniter 0.5.0 → 0.5.1

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Frontend
+    module App
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def frontend_assets(path: Assets::DEFAULT_SOURCE_PATH, mount: Assets::DEFAULT_MOUNT_PATH)
+          @frontend_assets_config = Assets.build_config(
+            root_dir: root_dir || Dir.pwd,
+            source_path: path,
+            mount_path: mount
+          )
+
+          route("GET", Assets.runtime_path(mount_path: @frontend_assets_config.fetch(:mount_path)), with: Assets.runtime_handler)
+          route(
+            "GET",
+            Assets.javascript_route_pattern(mount_path: @frontend_assets_config.fetch(:mount_path)),
+            with: Assets.javascript_handler(@frontend_assets_config)
+          )
+        end
+
+        def frontend_assets_config
+          @frontend_assets_config
+        end
+
+        def get(path, to: nil, with: nil, &block)
+          frontend_route("GET", path, to: to || with, &block)
+        end
+
+        def post(path, to: nil, with: nil, &block)
+          frontend_route("POST", path, to: to || with, &block)
+        end
+
+        def put(path, to: nil, with: nil, &block)
+          frontend_route("PUT", path, to: to || with, &block)
+        end
+
+        def patch(path, to: nil, with: nil, &block)
+          frontend_route("PATCH", path, to: to || with, &block)
+        end
+
+        def delete(path, to: nil, with: nil, &block)
+          frontend_route("DELETE", path, to: to || with, &block)
+        end
+
+        def scope(path, &block)
+          raise ArgumentError, "scope requires a block" unless block
+
+          current_frontend_scope_stack << path.to_s
+          instance_eval(&block)
+        ensure
+          current_frontend_scope_stack.pop
+        end
+
+        private
+
+        def frontend_route(method, path, to: nil, &block)
+          handler = to || block
+          raise ArgumentError, "#{method} #{path} requires `to:` or a block" unless handler
+
+          route(method, scoped_frontend_path(path), with: normalize_frontend_handler(handler))
+        end
+
+        def normalize_frontend_handler(handler)
+          return handler if handler.respond_to?(:call)
+
+          raise ArgumentError, "frontend route target must respond to #call"
+        end
+
+        def current_frontend_scope_stack
+          @frontend_scope_stack ||= []
+        end
+
+        def scoped_frontend_path(path)
+          segments = current_frontend_scope_stack + [path.to_s]
+          normalized = segments.join("/")
+          normalized = normalized.gsub(%r{/+}, "/")
+          normalized = "/#{normalized}" unless normalized.start_with?("/")
+          return "/" if normalized == "/"
+
+          normalized.sub(%r{/\z}, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "igniter/app/diagnostics"
+
+module Igniter
+  module Frontend
+    class AppAccess
+      attr_reader :request, :config
+
+      def initialize(request:, config:)
+        @request = request
+        @config = config
+      end
+
+      def runtime_context
+        Igniter::App::RuntimeContext.current || {}
+      end
+
+      def stack
+        runtime_context[:stack] || {}
+      end
+
+      def stack?
+        !stack.empty?
+      end
+
+      def app_name
+        runtime_context[:app_name]
+      end
+
+      def mount_path
+        request.script_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Frontend
+    module Arbre
+      FallbackComponent = Class.new do
+        def self.builder_method(*)
+          nil
+        end
+      end
+
+      class Component < (Arbre.available? ? Arbre.component_class : FallbackComponent)
+        def build(attributes = {})
+          super(attributes)
+        rescue NoMethodError => error
+          raise unless error.name == :build
+
+          attributes.each do |name, value|
+            next if value.nil?
+
+            set_attribute(name, value) if respond_to?(:set_attribute)
+          end
+
+          self
+        end
+
+        private
+
+        def extract_options!(args)
+          args.last.is_a?(Hash) ? args.pop.dup : {}
+        end
+
+        def render_build_block(block)
+          return unless block
+
+          if block.arity.zero?
+            instance_exec(&block)
+          else
+            block.call(self)
+          end
+        end
+
+        def ui_theme(theme_name = :companion)
+          Igniter::Frontend::Tailwind::UI::Theme.fetch(theme_name)
+        end
+
+        def merge_classes(*values)
+          values.flatten.compact.reject(&:empty?).join(" ")
+        end
+
+        def humanize_label(label)
+          label.to_s.gsub(/[_-]+/, " ").split.map(&:capitalize).join(" ")
+        end
+
+        def controller_target(controller, name, **attributes)
+          attributes.merge(:"data-ig-#{dashize(controller)}-target" => dashize(name))
+        end
+
+        def controller_scope(*controllers, **attributes)
+          names = [attributes.delete(:"data-ig-controller"), controllers]
+                  .flatten
+                  .compact
+                  .flat_map { |value| value.to_s.split(/\s+/) }
+                  .map { |value| dashize(value) }
+                  .reject(&:empty?)
+                  .uniq
+
+          attributes.merge(:"data-ig-controller" => names.join(" "))
+        end
+
+        def stream_scope(**attributes)
+          controller_scope(:stream, **attributes)
+        end
+
+        def stream_target(name, **attributes)
+          controller_target(:stream, name, **attributes)
+        end
+
+        def controller_value(controller, name, value, **attributes)
+          serialized = serialize_controller_value(value)
+          return attributes if serialized.nil?
+
+          attributes.merge(:"data-ig-#{dashize(controller)}-#{dashize(name)}-value" => serialized)
+        end
+
+        def stream_value(name, value, **attributes)
+          controller_value(:stream, name, value, **attributes)
+        end
+
+        def dashize(value)
+          value.to_s
+               .gsub(/([a-z0-9])([A-Z])/, '\1-\2')
+               .tr("_", "-")
+               .downcase
+        end
+
+        def serialize_controller_value(value)
+          case value
+          when nil
+            nil
+          when String
+            value
+          when Symbol, Numeric
+            value.to_s
+          when true
+            "true"
+          when false
+            "false"
+          when Array, Hash
+            JSON.generate(value)
+          else
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/action_group.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class ActionGroup < Arbre::Component
+          builder_method :action_group
+
+          def build(*args, &block)
+            options = extract_options!(args)
+            class_name = options.delete(:class_name)
+            stacked = options.delete(:stacked)
+
+            super(options.merge(class: merge_classes("actions action-group", stacked ? "stacked" : nil, class_name)))
+            render_build_block(block)
+          end
+
+          def link(label, href:, class_name: nil, **attributes, &block)
+            attributes[:class] = merge_classes(class_name, attributes[:class])
+            render_element(:a, label, href: href, **attributes, &block)
+          end
+
+          def button(label, type: "button", class_name: nil, **attributes, &block)
+            attributes[:class] = merge_classes(class_name, attributes[:class])
+            attributes[:type] = type
+            render_element(:button, label, **attributes, &block)
+          end
+
+          private
+
+          def current_builder
+            respond_to?(:current_arbre_element) ? current_arbre_element : self
+          end
+
+          def render_element(name, content = nil, **attributes, &block)
+            if current_builder.respond_to?(:tag)
+              current_builder.tag(name, content, **attributes, &block)
+            else
+              current_builder.public_send(name, content, **attributes, &block)
+            end
+          end
+
+          def tag_name
+            "div"
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/badge.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class Badge < Arbre::Component
+          builder_method :badge
+
+          TONE_CLASS = {
+            neutral: "pill inline-flex items-center rounded-full border border-white/10 bg-white/5 text-stone-200",
+            healthy: "pill inline-flex items-center rounded-full border border-emerald-300/20 bg-emerald-300/10 text-emerald-100",
+            warning: "pill warn inline-flex items-center rounded-full border border-amber-300/20 bg-amber-300/10 text-amber-100",
+            danger: "pill danger inline-flex items-center rounded-full border border-rose-300/20 bg-rose-300/10 text-rose-100",
+            info: "pill info inline-flex items-center rounded-full border border-cyan-300/20 bg-cyan-300/10 text-cyan-100",
+            accent: "pill accent inline-flex items-center rounded-full border border-orange-300/20 bg-orange-300/10 text-orange-100"
+          }.freeze
+
+          SIZE_CLASS = {
+            xs: "px-2 py-0.5 text-[10px] font-mono uppercase tracking-[0.18em]",
+            sm: "px-2.5 py-1 text-[11px] font-mono uppercase tracking-[0.18em]",
+            md: "px-3 py-1 text-xs font-mono uppercase tracking-[0.18em]",
+            lg: "px-4 py-1.5 text-sm font-semibold tracking-[0.12em]"
+          }.freeze
+
+          def build(label, *args)
+            options = extract_options!(args)
+            tone = options.delete(:tone) || options.delete(:state)
+            size = (options.delete(:size) || :md).to_sym
+            titleize = options.key?(:titleize) ? options.delete(:titleize) : true
+            class_name = options.delete(:class_name)
+            normalized = normalize_label(label, titleize: titleize)
+            inferred_tone = tone ? tone.to_sym : infer_tone(label, normalized)
+            badge_class = merge_classes(
+              TONE_CLASS.fetch(inferred_tone, TONE_CLASS[:neutral]),
+              SIZE_CLASS.fetch(size, SIZE_CLASS[:md]),
+              class_name
+            )
+            super(options.merge(class: badge_class))
+            text_node(normalized.to_s)
+          end
+
+          private
+
+          def normalize_label(label, titleize:)
+            value = label.respond_to?(:name) ? label.name : label
+
+            case value
+            when true, "true", 1, "1"
+              "Yes"
+            when false, "false", 0, "0"
+              "No"
+            when Symbol
+              titleize ? humanize_label(value) : value.to_s
+            when String
+              titleize ? humanize_label(value) : value
+            else
+              value.to_s
+            end
+          end
+
+          def infer_tone(original, normalized)
+            return :healthy if [true, "true", 1, "1"].include?(original)
+            return :danger if [false, "false", 0, "0"].include?(original)
+
+            token = normalized.to_s.downcase.strip.gsub(/\s+/, "_")
+
+            case token
+            when "healthy", "active", "online", "running", "joined", "success", "resolved", "yes", "ready"
+              :healthy
+            when "warning", "stale", "pending", "queued", "awaiting", "paused", "degraded", "draft", "planned"
+              :warning
+            when "danger", "failed", "failure", "error", "offline", "blocked", "rejected", "dismissed", "no"
+              :danger
+            when "info", "detached", "idle", "neutral"
+              :info
+            else
+              :neutral
+            end
+          end
+
+          def tag_name
+            "span"
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/boolean.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class Boolean < Arbre::Component
+          builder_method :boolean
+
+          def build(value, *args)
+            options = extract_options!(args)
+            size = (options.delete(:size) || :sm).to_sym
+            class_name = options.delete(:class_name)
+            label = normalize_label(value)
+            tone = truthy?(value) ? :healthy : (falsy?(value) ? :danger : :neutral)
+
+            badge_class = merge_classes(
+              Badge::TONE_CLASS.fetch(tone, Badge::TONE_CLASS[:neutral]),
+              Badge::SIZE_CLASS.fetch(size, Badge::SIZE_CLASS[:sm]),
+              class_name
+            )
+
+            super(options.merge(class: badge_class))
+            text_node(label)
+          end
+
+          private
+
+          def normalize_label(value)
+            return "Yes" if truthy?(value)
+            return "No" if falsy?(value)
+
+            "Unknown"
+          end
+
+          def truthy?(value)
+            [true, "true", 1, "1", :true, :yes, "yes"].include?(value)
+          end
+
+          def falsy?(value)
+            [false, "false", 0, "0", :false, :no, "no"].include?(value)
+          end
+
+          def tag_name
+            "span"
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/breadcrumbs.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class Breadcrumbs < Arbre::Component
+          builder_method :breadcrumbs
+
+          DEFAULT_NAV_CLASS = "mb-4".freeze
+          DEFAULT_LIST_CLASS = "inline-flex flex-wrap items-center gap-2 rounded-full border border-white/10 bg-white/[0.04] px-4 py-2 text-sm text-stone-400".freeze
+          DEFAULT_ITEM_CLASS = "inline-flex items-center gap-2".freeze
+          DEFAULT_LINK_CLASS = "transition hover:text-orange-100".freeze
+          DEFAULT_CURRENT_CLASS = "font-medium text-stone-100".freeze
+          DEFAULT_SEPARATOR_CLASS = "text-stone-600".freeze
+
+          def build(*args, &block)
+            options = extract_options!(args)
+            theme = options.delete(:theme) || :companion
+            class_name = options.delete(:class_name)
+            list_class = options.delete(:list_class)
+            ui_theme(theme)
+            @item_class = merge_classes(DEFAULT_ITEM_CLASS, options.delete(:item_class))
+            @link_class = merge_classes(DEFAULT_LINK_CLASS, options.delete(:link_class))
+            @current_class = merge_classes(DEFAULT_CURRENT_CLASS, options.delete(:current_class))
+            @separator_class = merge_classes(DEFAULT_SEPARATOR_CLASS, options.delete(:separator_class))
+            @index = 0
+
+            super(options.merge(class: merge_classes(DEFAULT_NAV_CLASS, class_name), "aria-label": "Breadcrumb"))
+            @list_class = merge_classes(DEFAULT_LIST_CLASS, list_class)
+            @crumbs = ol(class: @list_class)
+            render_build_block(block) if block&.arity.to_i <= 0
+          end
+
+          def crumb(label, value = nil, current: false)
+            rendered_label = humanize_label(label)
+            index = @index
+            separator_class = @separator_class
+            current_class = @current_class
+            link_class = @link_class
+            item_class = @item_class
+
+            ensure_crumbs!.li(class: item_class) do
+              span("/", class: separator_class) if index.positive?
+
+              if current || value.nil?
+                span(rendered_label, class: current_class, "aria-current": current ? "page" : nil)
+              else
+                a(rendered_label, href: value, class: link_class)
+              end
+            end
+
+            @index += 1
+          end
+
+          private
+
+          def ensure_crumbs!
+            @crumbs ||= ol(class: @list_class || DEFAULT_LIST_CLASS)
+          end
+
+          def tag_name
+            "nav"
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/card.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+require_relative "display_value_support"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class Card < Arbre::Component
+          builder_method :card
+          include DisplayValueSupport
+
+          DEFAULT_LINE_LIST_CLASS = "mt-4 grid grid-cols-1 gap-x-6 gap-y-4 sm:grid-cols-[minmax(140px,190px)_1fr]".freeze
+
+          def build(*args, &block)
+            options = extract_options!(args)
+            title = options.delete(:title)
+            subtitle = options.delete(:subtitle)
+            theme = options.delete(:theme) || :companion
+            class_name = options.delete(:class_name)
+            @theme_name = theme
+            @theme = ui_theme(theme)
+            wrapper_class = merge_classes(@theme.surface(:schema_card_class), class_name)
+
+            super(options.merge(class: wrapper_class))
+            render_header(title, subtitle)
+            @lines = dl(class: DEFAULT_LINE_LIST_CLASS)
+            render_build_block(block)
+          end
+
+          def line(label, value = nil, as_code: false, as: nil, placeholder: nil,
+                   label_class: nil, value_class: nil, badge: nil, &block)
+            value = block.call if block_given?
+            rendered_label = humanize_label(label)
+            field_label_class = @theme.field_label_class
+            body_text_class = @theme.body_text_class
+            content = normalize_value(value, placeholder: placeholder)
+
+            @lines.dt(rendered_label, class: merge_classes(field_label_class, label_class))
+            @lines.dd(class: merge_classes(body_text_class, value_class)) do
+              render_value(content, as: (as_code ? :code : as), badge_options: badge)
+            end
+          end
+
+          def subcard(*args, &block)
+            options = extract_options!(args)
+            title = args.shift || options.delete(:title)
+            subtitle = options.delete(:subtitle)
+            class_name = options.delete(:class_name)
+
+            card(title: title, subtitle: subtitle, theme: @theme_name, class_name: class_name, **options, &block)
+          end
+
+          private
+
+          def normalize_value(value, placeholder:)
+            if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+              return placeholder unless placeholder.nil?
+            end
+
+            value
+          end
+
+          def render_value(value, as:, badge_options:)
+            case value
+            when Array
+              render_array(value, as: as, badge_options: badge_options)
+            else
+              render_scalar(value, as: as, badge_options: badge_options)
+            end
+          end
+
+          def render_array(values, as:, badge_options:)
+            compact_values = values.compact
+            return if compact_values.empty?
+
+            if as == :badge
+              div(class: "flex flex-wrap gap-2") do |container|
+                compact_values.each do |entry|
+                  container.badge(entry, **(badge_options || {}))
+                end
+              end
+            else
+              text_node(compact_values.map(&:to_s).join(", "))
+            end
+          end
+
+          def render_scalar(value, as:, badge_options:)
+            return if value.nil?
+
+            render_semantic_scalar(self, value, as: as, badge_options: badge_options, theme: @theme)
+          end
+
+          def render_header(title, subtitle)
+            return if title.nil? && subtitle.nil?
+
+            title_class = @theme.section_heading_class(extra: "mt-0")
+            subtitle_class = @theme.muted_text_class
+
+            div(class: "mb-5 grid gap-2") do
+              h2(title, class: title_class) if title
+              div(subtitle, class: subtitle_class) if subtitle
+            end
+          end
+
+          def tag_name
+            "article"
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-frontend/lib/igniter/frontend/arbre/components/conversation_panel.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../component"
+
+module Igniter
+  module Frontend
+    module Arbre
+      module Components
+        class ConversationPanel < Arbre::Component
+          builder_method :conversation_panel
+
+          def build(*args, &block)
+            options = extract_options!(args)
+            title = options.delete(:title)
+            subtitle = options.delete(:subtitle)
+            span = options.delete(:span)
+            class_name = options.delete(:class_name)
+            span_class = span ? "span-#{span}" : nil
+
+            super(options.merge(class: merge_classes("panel", span_class, class_name)))
+            h2(title) if title
+            div(subtitle, class: "caption") if subtitle
+            render_build_block(block)
+          end
+
+          def notice(message, tone: :ok)
+            css_class = tone.to_sym == :error ? "error" : "ok"
+            div(message, class: css_class)
+          end
+
+          def transcript(messages:, id: nil, empty_role: "assistant", empty_message: "No chat yet.", class_name: nil, **attributes)
+            div(attributes.merge(id: id, class: merge_classes("chat-log", class_name))) do |chat_log|
+              if Array(messages).empty?
+                chat_log.div class: "chat-turn" do |turn|
+                  turn.strong empty_role
+                  turn.div empty_message, class: "caption"
+                end
+              else
+                Array(messages).each do |message|
+                  chat_log.div class: "chat-turn" do |turn|
+                    turn.strong message.fetch("role")
+                    turn.div message.fetch("content")
+                    next unless message.dig("metadata", "action_status")
+
+                    turn.div "action=#{message.dig("metadata", "action_status")}", class: "caption"
+                  end
+                end
+              end
+            end
+          end
+
+          private
+
+          def tag_name
+            "article"
+          end
+        end
+      end
+    end
+  end
+end