igniter 0.4.5 → 0.5.1

data/examples/mesh_discovery.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+# Igniter Mesh — Phase 2: Dynamic Discovery
+#
+# Demonstrates how peers self-register at startup and how the local node
+# discovers topology without a static add_peer list.
+#
+# This example uses in-process stubs so no real HTTP servers are needed.
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+require "igniter/cluster"
+
+# ─── Shared contract ──────────────────────────────────────────────────────────
+class ProcessOrder < Igniter::Contract
+  define do
+    input :order_id
+    compute :status, depends_on: :order_id do |order_id:|
+      order_id > 0 ? "accepted" : "rejected"
+    end
+    output :status
+  end
+end
+
+# ─── Stub HTTP layer ──────────────────────────────────────────────────────────
+# In production each peer is a separate igniter-stack process. Here we stub
+# the HTTP client so the example runs inline.
+
+module ClientStubs
+  PEERS = {
+    "http://orders-node-1:4567" => {
+      peer_name:    "orders-node-1",
+      capabilities: %i[orders inventory],
+      contracts:    ["ProcessOrder"],
+      alive:        true
+    },
+    "http://orders-node-2:4567" => {
+      peer_name:    "orders-node-2",
+      capabilities: %i[orders],
+      contracts:    ["ProcessOrder"],
+      alive:        true
+    },
+    "http://audit-node:4567" => {
+      peer_name:    "audit-node",
+      capabilities: %i[audit],
+      contracts:    ["WriteAudit"],
+      alive:        false  # <-- offline
+    },
+    "http://seed:4567" => {
+      peer_name:    "seed",
+      capabilities: [],
+      contracts:    [],
+      alive:        true,
+      # What the seed returns for GET /v1/mesh/peers:
+      known_peers: [
+        { name: "orders-node-1", url: "http://orders-node-1:4567", capabilities: ["orders", "inventory"] },
+        { name: "orders-node-2", url: "http://orders-node-2:4567", capabilities: ["orders"] },
+        { name: "audit-node",    url: "http://audit-node:4567",    capabilities: ["audit"] }
+      ]
+    }
+  }.freeze
+
+  def self.install!
+    Igniter::Server::Client.class_eval do
+      alias_method :real_health,        :health
+      alias_method :real_manifest,      :manifest
+      alias_method :real_list_peers,    :list_peers
+      alias_method :real_register_peer, :register_peer
+
+      def health
+        info = ClientStubs::PEERS[@base_url]
+        raise Igniter::Server::Client::ConnectionError, "offline" unless info && info[:alive]
+
+        { "status" => "ok" }
+      end
+
+      def manifest
+        info = ClientStubs::PEERS[@base_url] || {}
+        { peer_name: info[:peer_name], capabilities: info[:capabilities] || [],
+          contracts: info[:contracts] || [], url: @base_url }
+      end
+
+      def list_peers
+        info = ClientStubs::PEERS[@base_url] || {}
+        (info[:known_peers] || []).map do |p|
+          { name: p[:name], url: p[:url], capabilities: Array(p[:capabilities]).map(&:to_sym) }
+        end
+      end
+
+      def register_peer(name: nil, url: nil, capabilities: [], tags: [], metadata: {}, manifest: nil)
+        if manifest
+          peer_name = manifest.respond_to?(:peer_name) ? manifest.peer_name : manifest[:peer_name] || manifest["peer_name"]
+          peer_url = manifest.respond_to?(:url) ? manifest.url : manifest[:url] || manifest["url"]
+          peer_caps = manifest.respond_to?(:capabilities) ? manifest.capabilities : manifest[:capabilities] || manifest["capabilities"]
+          peer_tags = manifest.respond_to?(:tags) ? manifest.tags : manifest[:tags] || manifest["tags"]
+          peer_metadata = manifest.respond_to?(:metadata) ? manifest.metadata : manifest[:metadata] || manifest["metadata"]
+        else
+          peer_name = name
+          peer_url = url
+          peer_caps = capabilities
+          peer_tags = tags
+          peer_metadata = metadata
+        end
+
+        puts "  [seed] registered peer: #{peer_name} @ #{peer_url} caps=#{peer_caps} tags=#{peer_tags} metadata=#{peer_metadata}"
+        { "registered" => true }
+      end
+    end
+  end
+
+  def self.uninstall!
+    Igniter::Server::Client.class_eval do
+      alias_method :health,        :real_health
+      alias_method :manifest,      :real_manifest
+      alias_method :list_peers,    :real_list_peers
+      alias_method :register_peer, :real_register_peer
+    end
+  end
+end
+
+ClientStubs.install!
+
+# ─── Stub execute path ────────────────────────────────────────────────────────
+Igniter::Server::Client.class_eval do
+  alias_method :real_execute, :execute
+  def execute(contract_name, inputs: {})
+    order_id = inputs[:order_id] || inputs["order_id"] || 0
+    contract = ProcessOrder.new(order_id: order_id)
+    contract.resolve_all
+    { status: :succeeded, execution_id: "stub-#{order_id}",
+      outputs: { status: contract.result.status }, waiting_for: [], error: nil }
+  end
+end
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 1 — Dynamic topology discovery at startup
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 1: Dynamic discovery from seed"
+puts "=" * 60
+
+previous_remote_adapter = Igniter::Runtime.remote_adapter
+Igniter::Cluster.activate_remote_adapter!
+
+Igniter::Cluster::Mesh.configure do |c|
+  c.peer_name          = "api-node"
+  c.local_url          = "http://api-node:4567"
+  c.local_capabilities = %i[api]
+  c.seeds              = %w[http://seed:4567]
+  c.discovery_interval = 60
+end
+
+puts "\nBefore start_discovery!:"
+puts "  Dynamic peers: #{Igniter::Cluster::Mesh.config.peer_registry.size}"
+
+Igniter::Cluster::Mesh.start_discovery!
+
+puts "\nAfter start_discovery!:"
+puts "  Dynamic peers: #{Igniter::Cluster::Mesh.config.peer_registry.size}"
+Igniter::Cluster::Mesh.config.peer_registry.all.each do |p|
+  puts "  - #{p.name} @ #{p.url} caps=#{p.capabilities}"
+end
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 2 — Capability routing over discovered peers
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 2: Capability routing to discovered peers"
+puts "=" * 60
+
+class OrderPipeline < Igniter::Contract
+  define do
+    input :order_id
+
+    remote :order_result,
+           contract:   "ProcessOrder",
+           capability: :orders,
+           inputs:     { order_id: :order_id }
+
+    output :order_result
+  end
+end
+
+results = [101, 102, 103].map do |id|
+  contract = OrderPipeline.new(order_id: id)
+  contract.resolve_all
+  status = contract.result.order_result[:status]
+  puts "  order_id=#{id} → status=#{status}"
+  status
+end
+
+puts "\nAll orders accepted: #{results.all? { |r| r == "accepted" }}"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 3 — New peer joins mid-run (simulated via direct registration)
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 3: New peer joins the mesh mid-run"
+puts "=" * 60
+
+# Simulate a new billing-node announcing itself via POST /v1/mesh/peers
+# In production this is done by the new peer calling start_discovery!
+new_peer = Igniter::Cluster::Mesh::Peer.new(
+  name:         "billing-node",
+  url:          "http://billing-node:4567",
+  capabilities: %i[billing]
+)
+Igniter::Cluster::Mesh.config.peer_registry.register(new_peer)
+
+puts "  Registered billing-node into local registry"
+puts "  Peers with :billing capability: #{Igniter::Cluster::Mesh.config.peer_registry.peers_with_capability(:billing).map(&:name)}"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 4 — Deferred when discovered peer is offline
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 4: Capability routing → :pending when peer offline"
+puts "=" * 60
+
+class AuditPipeline < Igniter::Contract
+  define do
+    input :event
+
+    remote :audit_log,
+           contract:   "WriteAudit",
+           capability: :audit,
+           inputs:     { event: :event }
+
+    output :audit_log
+  end
+end
+
+contract = AuditPipeline.new(event: "order_placed")
+begin
+  contract.resolve_all
+rescue Igniter::Error
+  nil
+end
+
+cache = contract.execution.cache
+audit_state = cache.values.find { |s| s.node.name == :audit_log }
+puts "  audit_log node status: #{audit_state&.status || :unknown}"
+puts "  (audit-node is offline → capability routing defers → :pending)"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 5 — Static + dynamic peers merged
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 5: Static add_peer + dynamic discovery merged"
+puts "=" * 60
+
+Igniter::Cluster::Mesh.stop_discovery!
+Igniter::Cluster::Mesh.reset!
+Igniter::Runtime.remote_adapter = previous_remote_adapter
+
+Igniter::Cluster::Mesh.configure do |c|
+  c.peer_name = "api-node"
+  c.local_url = "http://api-node:4567"
+  c.seeds     = %w[http://seed:4567]
+  c.discovery_interval = 60
+  # Static peer declared manually:
+  c.add_peer "legacy-node", url: "http://legacy:4567", capabilities: %i[billing]
+end
+
+Igniter::Cluster::Mesh.start_discovery!
+
+static_names  = Igniter::Cluster::Mesh.config.peers.map(&:name)
+dynamic_names = Igniter::Cluster::Mesh.config.peer_registry.all.map(&:name)
+
+puts "  Static peers:  #{static_names}"
+puts "  Dynamic peers: #{dynamic_names}"
+puts "  Combined (via router):"
+all_orders = Igniter::Cluster::Mesh.router.instance_eval { all_capable_peers(:orders) }.map(&:name)
+puts "    :orders capable peers: #{all_orders}"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Cleanup
+# ─────────────────────────────────────────────────────────────────────────────
+Igniter::Cluster::Mesh.stop_discovery!
+Igniter::Cluster::Mesh.reset!
+ClientStubs.uninstall!
+
+puts "\nDone."

data/examples/mesh_gossip.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# Igniter Mesh — Phase 3: Gossip Protocol
+#
+# Demonstrates how peer topology spreads through gossip even when seeds
+# are unavailable. Three nodes form a mesh: A knows B, C only knows A.
+# After one gossip round C discovers B — without ever contacting a seed.
+#
+# This example uses in-process stubs so no real HTTP servers are needed.
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+require "igniter/cluster"
+
+# ─── Shared contract ──────────────────────────────────────────────────────────
+class CheckInventory < Igniter::Contract
+  define do
+    input :sku
+    compute :available, depends_on: :sku do |sku:|
+      sku.start_with?("VALID") ? true : false
+    end
+    output :available
+  end
+end
+
+# ─── Node registries (in-memory representation of three separate processes) ───
+#
+# node_a: knows B (via seed bootstrap)
+# node_b: fresh node with inventory capability
+# node_c: knows A (via seed bootstrap), does NOT know B yet
+#
+# After node_c gossips with node_a → it will learn about node_b.
+
+NODE_A = {
+  name: "node-a", url: "http://node-a:4567",
+  capabilities: %w[orders],
+  peers: [
+    { name: "node-b", url: "http://node-b:4567", capabilities: ["inventory"] }
+  ]
+}.freeze
+
+NODE_B = {
+  name: "node-b", url: "http://node-b:4567",
+  capabilities: %w[inventory],
+  peers: []
+}.freeze
+
+NODE_C = {
+  name: "node-c", url: "http://node-c:4567",
+  capabilities: %w[api],
+  peers: [
+    { name: "node-a", url: "http://node-a:4567", capabilities: ["orders"] }
+  ]
+}.freeze
+
+# ─── Stub HTTP layer ──────────────────────────────────────────────────────────
+# Stubs GET /v1/mesh/peers (list_peers) for each node URL.
+# No health checks or execute stubs needed for this scenario.
+
+PEER_DB = {
+  NODE_A[:url] => NODE_A,
+  NODE_B[:url] => NODE_B,
+  NODE_C[:url] => NODE_C
+}.freeze
+
+Igniter::Server::Client.class_eval do
+  alias_method :real_list_peers_gossip, :list_peers
+
+  def list_peers
+    info = PEER_DB[@base_url] || {}
+    (info[:peers] || []).map do |p|
+      { name: p[:name], url: p[:url], capabilities: Array(p[:capabilities]).map(&:to_sym) }
+    end
+  end
+end
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 1 — Baseline: C's registry before gossip
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 1: C's registry before gossip"
+puts "=" * 60
+
+Igniter::Cluster::Mesh.configure do |c|
+  c.peer_name          = NODE_C[:name]
+  c.local_url          = NODE_C[:url]
+  c.local_capabilities = NODE_C[:capabilities].map(&:to_sym)
+  c.gossip_fanout      = 3
+  c.discovery_interval = 60
+  c.seeds              = []   # no seeds — gossip only
+end
+
+# C initially knows A (as if bootstrapped from a seed earlier)
+Igniter::Cluster::Mesh.config.peer_registry.register(
+  Igniter::Cluster::Mesh::Peer.new(name: NODE_A[:name], url: NODE_A[:url], capabilities: NODE_A[:capabilities].map(&:to_sym))
+)
+
+puts "\nC's registry before gossip:"
+Igniter::Cluster::Mesh.config.peer_registry.all.each do |p|
+  puts "  - #{p.name} @ #{p.url} caps=#{p.capabilities}"
+end
+
+knows_b_before = !Igniter::Cluster::Mesh.config.peer_registry.peer_named("node-b").nil?
+puts "  C knows node-b? #{knows_b_before}"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 2 — Gossip round: C contacts A, learns about B
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 2: C runs one gossip round → discovers B via A"
+puts "=" * 60
+
+Igniter::Cluster::Mesh::GossipRound.new(Igniter::Cluster::Mesh.config).run
+
+puts "\nC's registry after gossip:"
+Igniter::Cluster::Mesh.config.peer_registry.all.each do |p|
+  puts "  - #{p.name} @ #{p.url} caps=#{p.capabilities}"
+end
+
+knows_b_after = !Igniter::Cluster::Mesh.config.peer_registry.peer_named("node-b").nil?
+puts "\n  C knows node-b? #{knows_b_after}"
+puts "  Convergence achieved without seed: #{knows_b_after}"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Scenario 3 — gossip_fanout = 0 disables gossip
+# ─────────────────────────────────────────────────────────────────────────────
+puts "=" * 60
+puts "Scenario 3: gossip_fanout = 0 disables the gossip round"
+puts "=" * 60
+
+Igniter::Cluster::Mesh.reset!
+
+Igniter::Cluster::Mesh.configure do |c|
+  c.peer_name          = NODE_C[:name]
+  c.local_url          = NODE_C[:url]
+  c.gossip_fanout      = 0   # disabled
+  c.discovery_interval = 60
+  c.seeds              = []
+end
+
+# Seed registry with A
+Igniter::Cluster::Mesh.config.peer_registry.register(
+  Igniter::Cluster::Mesh::Peer.new(name: NODE_A[:name], url: NODE_A[:url], capabilities: NODE_A[:capabilities].map(&:to_sym))
+)
+
+before_size = Igniter::Cluster::Mesh.config.peer_registry.size
+Igniter::Cluster::Mesh::Poller.new(Igniter::Cluster::Mesh.config).poll_once  # no seeds → no seed fetch; gossip disabled
+after_size  = Igniter::Cluster::Mesh.config.peer_registry.size
+
+puts "  gossip_fanout = 0 → registry size unchanged: #{before_size} → #{after_size}"
+puts
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Cleanup
+# ─────────────────────────────────────────────────────────────────────────────
+Igniter::Cluster::Mesh.reset!
+
+Igniter::Server::Client.class_eval do
+  alias_method :list_peers, :real_list_peers_gossip
+end
+
+puts "Done."

data/examples/reactive_auditing.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+require "igniter/extensions/auditing"
+require "igniter/extensions/reactive"
+
+EFFECT_VALUES = []
+INVALIDATIONS = []
+
+class ReactiveAuditQuoteContract < Igniter::Contract
+  define do
+    input :order_total, type: :numeric
+    input :country, type: :string
+
+    compute :vat_rate, with: :country do |country:|
+      country == "UA" ? 0.2 : 0.0
+    end
+
+    compute :gross_total, with: %i[order_total vat_rate] do |order_total:, vat_rate:|
+      (order_total * (1 + vat_rate)).round(2)
+    end
+
+    expose :gross_total, as: :response
+  end
+
+  react_to :node_invalidated, path: "gross_total" do |event:, **|
+    INVALIDATIONS << event.payload[:cause]
+  end
+
+  effect "gross_total" do |value:, **|
+    EFFECT_VALUES << value
+  end
+end
+
+contract = ReactiveAuditQuoteContract.new(order_total: 100, country: "UA")
+
+puts "first_response=#{contract.result.response}"
+
+contract.update_inputs(order_total: 150)
+puts "second_response=#{contract.result.response}"
+
+snapshot = contract.audit_snapshot
+event_types = snapshot[:events].map { |event| event[:type] }.uniq
+
+puts "effect_values=#{EFFECT_VALUES.inspect}"
+puts "invalidations=#{INVALIDATIONS.inspect}"
+puts "event_types=#{event_types.inspect}"
+puts "gross_total_state=#{snapshot[:states][:gross_total].slice(:status, :value).inspect}"
+puts "event_count=#{snapshot[:event_count]}"

data/examples/ringcentral_routing.rb

@@ -123,7 +123,7 @@ class CallConnectedContract < Igniter::Contract
       calls.successes.values.map { |item| item.result.summary }
     end
 
-    aggregate :routing_summary, with: %i[calls call_summaries extension_id telephony_status has_calls] do |calls:, call_summaries:, extension_id:, telephony_status:, has_calls:|
+    compute :routing_summary, with: %i[calls call_summaries extension_id telephony_status has_calls] do |calls:, call_summaries:, extension_id:, telephony_status:, has_calls:|
       has_calls
       {
         extension_id: extension_id,

data/examples/run.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+require "timeout"
+
+require_relative "catalog"
+
+module IgniterExamples
+  class Runner
+    Result = Struct.new(
+      :example,
+      :status,
+      :stdout,
+      :stderr,
+      :exit_status,
+      :elapsed,
+      :reason,
+      keyword_init: true
+    ) do
+      def ok?
+        status == :passed
+      end
+    end
+
+    def run(example, extra_args: nil)
+      unless example.runnable?
+        return Result.new(example: example, status: :skipped, reason: example.skip_reason)
+      end
+
+      argv = extra_args.nil? ? example.command_args : extra_args
+      if !example.autonomous? && argv.empty?
+        return Result.new(example: example, status: :skipped, reason: example.skip_reason)
+      end
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      stdout = +""
+      stderr = +""
+      exit_status = nil
+
+      Timeout.timeout(example.timeout) do
+        stdout, stderr, process_status = Open3.capture3(
+          RbConfig.ruby,
+          example.full_path,
+          *argv
+        )
+        exit_status = process_status.exitstatus
+      end
+
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+      failure_reason = validate_output(example, stdout, exit_status)
+      status = failure_reason ? :failed : :passed
+
+      Result.new(
+        example: example,
+        status: status,
+        stdout: stdout,
+        stderr: stderr,
+        exit_status: exit_status,
+        elapsed: elapsed,
+        reason: failure_reason
+      )
+    rescue Timeout::Error
+      Result.new(
+        example: example,
+        status: :failed,
+        stdout: stdout,
+        stderr: stderr,
+        exit_status: nil,
+        elapsed: Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at,
+        reason: "timed out after #{example.timeout}s"
+      )
+    end
+
+    private
+
+    def validate_output(example, stdout, exit_status)
+      return "exited with status #{exit_status}" unless exit_status == 0
+
+      missing = Array(example.expected_fragments).reject { |fragment| stdout.include?(fragment) }
+      return nil if missing.empty?
+
+      "missing expected output: #{missing.first.inspect}"
+    end
+  end
+end
+
+def print_usage
+  puts "Usage:"
+  puts "  ruby examples/run.rb list"
+  puts "  ruby examples/run.rb smoke"
+  puts "  ruby examples/run.rb all"
+  puts "  ruby examples/run.rb run <example> [example args...]"
+end
+
+def print_list
+  IgniterExamples.all.each do |example|
+    suffix = example.skip_reason ? " (#{example.skip_reason})" : ""
+    puts "#{example.status.to_s.ljust(11)} #{example.id.ljust(24)} #{example.summary}#{suffix}"
+  end
+end
+
+def print_result(result)
+  label = result.status.to_s.upcase.ljust(7)
+  timing = result.elapsed ? format("%0.2fs", result.elapsed) : "--"
+  line = "#{label} #{result.example.id.ljust(24)} #{timing}"
+  line += "  #{result.reason}" if result.reason
+  puts line
+
+  return unless result.status == :failed
+
+  unless result.stderr.to_s.empty?
+    first_error = result.stderr.lines.first.to_s.strip
+    puts "        stderr: #{first_error}" unless first_error.empty?
+  end
+end
+
+def run_examples(examples, extra_args: nil)
+  runner = IgniterExamples::Runner.new
+  results = examples.map do |example|
+    runner.run(example, extra_args: extra_args)
+  end
+
+  results.each { |result| print_result(result) }
+
+  passed = results.count(&:ok?)
+  failed = results.count { |result| result.status == :failed }
+  skipped = results.count { |result| result.status == :skipped }
+
+  puts
+  puts "Summary: #{passed} passed, #{failed} failed, #{skipped} skipped"
+
+  exit(failed.zero? ? 0 : 1)
+end
+
+command = ARGV.shift || "smoke"
+
+case command
+when "list"
+  print_list
+when "smoke"
+  run_examples(IgniterExamples.smoke)
+when "all"
+  run_examples(IgniterExamples.all)
+when "run"
+  name = ARGV.shift
+  unless name
+    print_usage
+    exit 1
+  end
+
+  example = IgniterExamples.find(name)
+  unless example
+    warn "Unknown example: #{name}"
+    exit 1
+  end
+
+  run_examples([example], extra_args: ARGV)
+else
+  print_usage
+  exit 1
+end

data/lib/igniter/monorepo_packages.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+[
+  File.expand_path("../../packages/igniter-core/lib", __dir__),
+  File.expand_path("../../packages/igniter-agents/lib", __dir__),
+  File.expand_path("../../packages/igniter-ai/lib", __dir__),
+  File.expand_path("../../packages/igniter-sdk/lib", __dir__),
+  File.expand_path("../../packages/igniter-extensions/lib", __dir__),
+  File.expand_path("../../packages/igniter-app/lib", __dir__),
+  File.expand_path("../../packages/igniter-server/lib", __dir__),
+  File.expand_path("../../packages/igniter-cluster/lib", __dir__),
+  File.expand_path("../../packages/igniter-rails/lib", __dir__),
+  File.expand_path("../../packages/igniter-frontend/lib", __dir__),
+  File.expand_path("../../packages/igniter-schema-rendering/lib", __dir__)
+].each do |path|
+  $LOAD_PATH.unshift(path) if File.directory?(path) && !$LOAD_PATH.include?(path)
+end