igniter 0.5.1 → 0.5.2

data/packages/igniter-extensions/lib/igniter/extensions/differential.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require "igniter/core/differential"
-
-module Igniter
-  module Extensions
-    # Patches Igniter::Contract with:
-    #   - Class method: shadow_with(candidate, async:, on_divergence:, tolerance:)
-    #   - Instance method: diff_against(candidate_class, tolerance:)
-    #   - Automatic shadow execution after resolve_all (when shadow_with is declared)
-    #
-    # This module is applied globally via:
-    #   Igniter::Contract.include(Igniter::Extensions::Differential)
-    #
-    module Differential
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.prepend(InstanceMethods)
-      end
-
-      # ── Class-level DSL ────────────────────────────────────────────────────
-
-      module ClassMethods
-        # Declare a shadow candidate that runs alongside every resolve_all call.
-        #
-        # @param candidate_class [Class<Igniter::Contract>]
-        # @param async [Boolean]  run the shadow in a background Thread
-        # @param on_divergence [#call, nil] invoked with a Report when outputs differ
-        # @param tolerance [Numeric, nil]  passed to the differential runner
-        def shadow_with(candidate_class, async: false, on_divergence: nil, tolerance: nil)
-          @_shadow_candidate = candidate_class
-          @_shadow_async = async
-          @_shadow_on_divergence = on_divergence
-          @_shadow_tolerance = tolerance
-        end
-
-        def shadow_candidate = @_shadow_candidate
-        def shadow_async? = @_shadow_async || false
-        def shadow_on_divergence = @_shadow_on_divergence
-        def shadow_tolerance = @_shadow_tolerance
-      end
-
-      # ── Instance override + new public method ─────────────────────────────
-
-      module InstanceMethods
-        # Intercepts resolve_all to trigger shadow execution when shadow_with
-        # has been declared.  Uses a thread-local flag to prevent recursive
-        # shadow calls when the runner itself invokes resolve_all internally.
-        def resolve_all(...)
-          result = super
-          run_shadow unless Thread.current[:igniter_skip_shadow]
-          result
-        end
-
-        # Compare the already-executed primary contract against +candidate_class+.
-        # Avoids re-running the primary (reads outputs from the existing cache).
-        #
-        # Raises DifferentialError if resolve_all has not been called yet.
-        #
-        # @return [Igniter::Differential::Report]
-        def diff_against(candidate_class, tolerance: nil)
-          unless execution.cache.values.any?
-            raise Igniter::Differential::DifferentialError,
-                  "Contract has not been executed — call resolve_all first"
-          end
-
-          inputs = extract_inputs_from_execution
-          runner = Igniter::Differential::Runner.new(self.class, candidate_class, tolerance: tolerance)
-          runner.run_with_primary_execution(execution, inputs)
-        end
-
-        private
-
-        def run_shadow # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-          candidate = self.class.shadow_candidate
-          return unless candidate
-
-          on_divergence = self.class.shadow_on_divergence
-          tolerance = self.class.shadow_tolerance
-          inputs = extract_inputs_from_execution
-
-          task = lambda do
-            runner = Igniter::Differential::Runner.new(self.class, candidate, tolerance: tolerance)
-            report = runner.run_with_primary_execution(execution, inputs)
-            on_divergence.call(report) if on_divergence && !report.match?
-          end
-
-          if self.class.shadow_async?
-            Thread.new { task.call }
-          else
-            task.call
-          end
-        end
-
-        # Reads input node values from the resolved cache for re-use in
-        # secondary executions (shadow / diff_against).
-        def extract_inputs_from_execution
-          graph = execution.compiled_graph
-          cache = execution.cache
-
-          graph.nodes.each_with_object({}) do |node, acc|
-            next unless node.kind == :input
-
-            state = cache.fetch(node.name)
-            acc[node.name] = state&.value
-          end
-        end
-      end
-    end
-  end
-end
-
-Igniter::Contract.include(Igniter::Extensions::Differential)

data/packages/igniter-extensions/lib/igniter/extensions/execution_report.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require "igniter/core/execution_report"
-
-module Igniter
-  module Extensions
-    # Adds execution_report method to all Igniter contracts.
-    #
-    # Applied globally via:
-    #   Igniter::Contract.include(Igniter::Extensions::ExecutionReport)
-    #
-    module ExecutionReport
-      # Build a structured execution report from the current execution state.
-      #
-      # Can be called after resolve_all succeeds OR after it raises — in both
-      # cases the cache contains partial or full execution state.
-      #
-      # @return [Igniter::ExecutionReport::Report]
-      def execution_report
-        Igniter::ExecutionReport::Builder.build(self)
-      end
-    end
-  end
-end
-
-Igniter::Contract.include(Igniter::Extensions::ExecutionReport)

data/packages/igniter-extensions/lib/igniter/extensions/incremental.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require "igniter/core/incremental"
-
-module Igniter
-  module Extensions
-    # Patches Igniter::Contract with:
-    #   - Instance method: resolve_incrementally(new_inputs = {}) → Incremental::Result
-    #
-    # The method updates inputs, re-resolves, and returns a structured report
-    # of which nodes changed, were memoized, or were backdated.
-    #
-    # Applied globally via:
-    #   Igniter::Contract.include(Igniter::Extensions::Incremental)
-    #
-    module Incremental
-      def self.included(base)
-        base.include(InstanceMethods)
-      end
-
-      module InstanceMethods
-        # Update inputs and re-resolve, returning a detailed incremental result.
-        #
-        # If called without arguments on an already-resolved contract, it
-        # re-resolves with current inputs (useful for observing memoization).
-        #
-        # @param new_inputs [Hash] input values to update before re-resolving
-        # @return [Igniter::Incremental::Result]
-        def resolve_incrementally(new_inputs = {})
-          unless execution.cache.values.any?
-            raise Igniter::Incremental::IncrementalError,
-                  "Contract has not been executed yet — call resolve_all first, " \
-                  "then resolve_incrementally to get incremental results"
-          end
-
-          tracker = Igniter::Incremental::Tracker.new(execution)
-          tracker.start!
-
-          update_inputs(new_inputs) if new_inputs.any?
-          resolve_all
-
-          tracker.build_result
-        end
-      end
-    end
-  end
-end
-
-Igniter::Contract.include(Igniter::Extensions::Incremental)

data/packages/igniter-extensions/lib/igniter/extensions/introspection.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/extensions/introspection"

data/packages/igniter-extensions/lib/igniter/extensions/invariants.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/extensions/invariants"

data/packages/igniter-extensions/lib/igniter/extensions/provenance.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/provenance"
-
-module Igniter
-  module Extensions
-    # Adds runtime provenance (data lineage) methods to Igniter::Contract.
-    #
-    # After requiring this file, every resolved contract gains two new methods:
-    #
-    #   contract.resolve_all
-    #
-    #   # Full Lineage object — query API
-    #   lin = contract.lineage(:grand_total)
-    #   lin.contributing_inputs        # => { base_price: 100.0, quantity: 2 }
-    #   lin.sensitive_to?(:base_price) # => true
-    #   lin.path_to(:base_price)       # => [:grand_total, :subtotal, :base_price]
-    #   lin.to_h                        # serialisable Hash
-    #
-    #   # Shorthand: human-readable ASCII tree printed to stdout
-    #   contract.explain(:grand_total)
-    #
-    module Provenance
-      # Return a Lineage object for the named output.
-      # Raises ProvenanceError if the output is unknown or the contract has not
-      # been executed (resolve_all has not been called).
-      def lineage(output_name)
-        unless execution
-          raise Igniter::Provenance::ProvenanceError,
-                "Contract has not been executed — call resolve_all first"
-        end
-
-        Igniter::Provenance::Builder.build(output_name, execution)
-      end
-
-      # Return a human-readable ASCII tree explaining how +output_name+ was derived.
-      def explain(output_name)
-        lineage(output_name).explain
-      end
-    end
-  end
-end
-
-# Patch Igniter::Contract so every contract instance gains the methods.
-Igniter::Contract.include(Igniter::Extensions::Provenance)

data/packages/igniter-extensions/lib/igniter/extensions/reactive.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/extensions/reactive"

data/packages/igniter-extensions/lib/igniter/extensions/saga.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require "igniter/core/saga"
-
-module Igniter
-  module Extensions
-    # Adds saga/compensating-transaction support to all Igniter contracts.
-    #
-    # Class-level DSL:
-    #   compensate :node_name do |inputs:, value:| ... end
-    #
-    # Instance methods added:
-    #   resolve_saga → Igniter::Saga::Result
-    #
-    # Applied globally via:
-    #   Igniter::Contract.include(Igniter::Extensions::Saga)
-    #
-    module Saga
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      # ── Class-level DSL ────────────────────────────────────────────────────
-
-      module ClassMethods
-        # Declare a compensating action for a compute node.
-        #
-        # The block is called with:
-        #   inputs: — Hash of the node's dependency values
-        #   value:  — the value the node produced (now being rolled back)
-        #
-        # @param node_name [Symbol]
-        def compensate(node_name, &block)
-          @_compensations ||= {}
-          @_compensations[node_name.to_sym] = Igniter::Saga::Compensation.new(node_name, &block)
-        end
-
-        # @return [Hash{ Symbol => Compensation }]
-        def compensations
-          @_compensations || {}
-        end
-      end
-
-      # ── Instance methods ───────────────────────────────────────────────────
-
-      # Execute the contract and handle compensations on failure.
-      #
-      # Unlike `resolve_all` (which raises on failure), `resolve_saga`:
-      #   - Returns a successful Result when execution completes
-      #   - Catches Igniter::Error, runs compensations, returns a failed Result
-      #
-      # @return [Igniter::Saga::Result]
-      def resolve_saga # rubocop:disable Metrics/MethodLength
-        resolve_all
-        Igniter::Saga::Result.new(success: true, contract: self)
-      rescue Igniter::Error => e
-        executor = Igniter::Saga::Executor.new(self)
-        compensations_ran = executor.run_compensations
-        failed_node = executor.failed_node_name
-
-        Igniter::Saga::Result.new(
-          success: false,
-          contract: self,
-          error: e,
-          failed_node: failed_node,
-          compensations: compensations_ran
-        )
-      end
-    end
-  end
-end
-
-Igniter::Contract.include(Igniter::Extensions::Saga)

data/packages/igniter-frontend/README.md

@@ -1,224 +0,0 @@
-# igniter-frontend
-
-`igniter-frontend` is a local monorepo gem for developer-facing app web surfaces on top of Igniter.
-
-It now ships with `arbre` as a standard dependency. The intent is simple:
-
-- `Igniter Frontend` should feel as simple and powerful for Ruby-authored app UI
-  as `ActiveAdmin` feels for admin UI
-- Arbre is no longer a side adapter you add by hand later
-- Arbre is part of the default developer-authoring lane for `igniter-frontend`
-
-It groups high-level concerns that belong together in app development:
-
-- route authoring
-- handler/controller lifecycle
-- request/response helpers
-- mounted-app aware contexts
-- Arbre page rendering
-- semantic Arbre components
-- optional JavaScript runtime and app-owned entrypoints
-
-Schema-driven agent rendering intentionally lives outside this package. Use a
-separate package for that lane so the human-first app surface stays simple.
-
-The goal is not to re-create Rails.
-The goal is to give Igniter apps a small, coherent, HTML-first framework for
-building dashboards, chats, operator tools, decentralized personal apps, and
-other rich mounted web surfaces.
-
-The frontend direction is now explicitly:
-
-- Arbre for developer-authored page composition
-- Tailwind surfaces for shared UI language
-- stronger UX/UI semantics on top of that Arbre lane over time
-
-That “stronger semantics” line now includes richer Arbre primitives such as:
-
-- `badge` with inferred status tone and compact sizing
-- `card#line` with `as: :badge` / `as: :code`
-- placeholder-aware schema rows and nested `subcard` composition
-- `table_with` for logs, events, history, and other collection-heavy operator views
-- `viz` for raw hashes, arrays, objects, and runtime payload inspection
-- `filters` for mounted-safe search and narrowing lanes above tables and feeds
-- `pagination` for mounted-safe browsing lanes across notes, history, logs, and other long collections
-- `sidebar_shell` for app-level operator/admin navigation and stable content chrome
-- `breadcrumbs` for compact in-app location trails above operator/admin content
-- semantic value primitives such as `boolean`, `datetime`, `indicator`, `number`, and `percentage`
-- state primitives such as `empty_state` and `loading_state`
-- `shell_columns` for main/aside dashboard composition inside an app shell
-
-Authoring guide:
-
-- [Frontend Authoring](../../docs/guide/frontend-authoring.md)
-- [Frontend Components](../../docs/guide/frontend-components.md)
-- [Guide](../../docs/guide/README.md)
-- [Dev](../../docs/dev/README.md)
-
-## First-cut API
-
-```ruby
-require "igniter/app"
-require "igniter-frontend"
-
-class WebApp < Igniter::App
-  include Igniter::Frontend::App
-
-  root_dir __dir__
-  config_file "app.yml"
-  frontend_assets path: "frontend"
-
-  get "/", to: Web::Handlers::HomeHandler
-
-  scope "/notes" do
-    post "/", to: Web::Handlers::NotesCreateHandler
-  end
-end
-```
-
-```ruby
-module Web
-  module Handlers
-    class HomeHandler < Igniter::Frontend::Handler
-      def call
-        render Views::HomePage,
-               context: build_context(Contexts::HomeContext, title: "Home")
-      end
-    end
-  end
-end
-```
-
-```ruby
-module Web
-  module Views
-    class HomePage < Igniter::Frontend::ArbrePage
-      template_root __dir__
-      template "home"
-      layout "layout"
-
-      def initialize(context:)
-        @context = context
-      end
-
-      def template_locals
-        { page_context: @context }
-      end
-    end
-  end
-end
-```
-
-## Status
-
-This package now owns the human-facing web surface directly inside the monorepo:
-
-- route DSL and handler lifecycle
-- HTML builder/page abstractions
-- Arbre page pipeline
-- Tailwind shell and semantic UI components
-- optional frontend JavaScript runtime with app-owned assets under `frontend/`
-
-It is no longer just a facade over `lib/igniter/plugins/view`.
-
-## Optional JavaScript
-
-Use `frontend_assets` when the app wants a small built-in runtime plus its own
-JavaScript entrypoints.
-
-```ruby
-class DashboardApp < Igniter::App
-  include Igniter::Frontend::App
-
-  root_dir __dir__
-  frontend_assets path: "frontend"
-end
-```
-
-App structure:
-
-```text
-apps/dashboard/
-  app.rb
-  frontend/
-    application.js
-    controllers/
-```
-
-Layout usage:
-
-```ruby
-body do
-  render_template_content
-  render_frontend_javascript "application"
-end
-```
-
-This serves:
-
-- built-in runtime at `/__frontend/runtime.js`
-- app entrypoints like `/__frontend/assets/application.js`
-
-Both URLs stay mounted-app aware when rendered through `ArbrePage` helpers.
-
-Built-in controllers currently include:
-
-- `tabs` for semantic tab panels
-- `stream` for `EventSource` lifecycle, JSON parsing, and app-level hooks
-
-Example stream wiring:
-
-```ruby
-main(
-  "data-ig-controller": "stream",
-  "data-ig-stream-url-value": page_context.route("/api/overview/stream"),
-  "data-ig-stream-events-value": "[\"overview\",\"activity\"]",
-  "data-ig-stream-hook-value": "homeLabOverviewStream"
-) do
-  render_template_content
-end
-```
-
-```js
-window.homeLabOverviewStream = {
-  overview({ controller, payload }) {
-    controller.setTextTarget("generatedAt", payload.generated_at);
-  }
-};
-```
-
-For repeated updates, prefer marking DOM zones with `data-ig-stream-target` and
-using the small helpers exposed by `stream`:
-
-- `setTextTarget(name, value)`
-- `setHtmlTarget(name, html)`
-- `setJsonTarget(name, payload)`
-- `prependHtmlTarget(name, html, { limit: ... })`
-
-In Arbre pages and components, prefer the helper:
-
-```ruby
-span current_value, **stream_target(:generated_at, id: "generated-at")
-```
-
-That keeps `data-ig-*` details out of app templates.
-
-The same applies to controller values:
-
-```ruby
-main(
-  **stream_scope,
-  **stream_value(:url, page_context.route("/api/overview/stream")),
-  **stream_value(:events, %w[overview activity]),
-  **stream_value(:hook, "homeLabOverviewStream")
-) do
-  render_template_content
-end
-```
-
-Use `controller_value(:tabs, :active_id, "routing")` when you need the generic
-form outside the `stream` lane.
-
-For the controller name itself, prefer `stream_scope` or the generic
-`controller_scope(:stream, :operator_panel)` over raw `data-ig-controller`
-strings.

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

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

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