igniter 0.5.1 → 0.5.2

data/packages/igniter-core/lib/igniter/core/stream_loop.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  # Runs an Igniter contract in a continuous tick-loop.
-  #
-  # Each tick resolves the contract with the current inputs and delivers the
-  # result to the on_result callback. Useful for sensor polling, feed
-  # processing, or any recurring computation.
-  #
-  #   stream = Igniter::StreamLoop.new(
-  #     contract:      SensorContract,
-  #     tick_interval: 0.1,
-  #     inputs:        { sensor_id: "temp-1", threshold: 25.0 },
-  #     on_result:     ->(result) { puts result.status },
-  #     on_error:      ->(err)    { warn err.message }
-  #   )
-  #
-  #   stream.start
-  #   stream.update_inputs(threshold: 30.0)  # hot-swap inputs between ticks
-  #   stream.stop
-  #
-  class StreamLoop
-    def initialize(contract:, tick_interval: 1.0, inputs: {}, on_result: nil, on_error: nil)
-      @contract_class = contract
-      @tick_interval  = tick_interval.to_f
-      @on_result      = on_result
-      @on_error       = on_error
-      @mutex          = Mutex.new
-      @current_inputs = inputs.dup
-      @running        = false
-      @thread         = nil
-    end
-
-    # Start the loop in a background thread. Returns self.
-    def start
-      @running = true
-      @thread  = Thread.new { loop_body }
-      @thread.abort_on_exception = false
-      self
-    end
-
-    # Stop the loop and wait for the current tick to finish.
-    def stop(timeout: 5)
-      @running = false
-      @thread&.join(timeout)
-      self
-    end
-
-    # Merge +new_inputs+ into the current input set. Takes effect on the next tick.
-    def update_inputs(new_inputs)
-      @mutex.synchronize { @current_inputs.merge!(new_inputs) }
-      self
-    end
-
-    def alive?
-      @thread&.alive? || false
-    end
-
-    private
-
-    def loop_body
-      while @running
-        tick_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        run_tick
-        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - tick_start
-        sleep_for = [@tick_interval - elapsed, 0].max
-        sleep(sleep_for) if sleep_for.positive? && @running
-      end
-    end
-
-    def run_tick
-      inputs   = @mutex.synchronize { @current_inputs.dup }
-      contract = @contract_class.new(**inputs)
-      contract.resolve_all
-      @on_result&.call(contract.result)
-    rescue StandardError => e
-      @on_error&.call(e)
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/temporal.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  # Mixin for time-aware contracts.
-  #
-  # Including Igniter::Temporal in a Contract automatically injects an `as_of`
-  # input (default: Time.now) and provides the `temporal_compute` DSL helper,
-  # which adds `:as_of` to a node's dependencies automatically.
-  #
-  # The key property of a temporal contract: if ALL time-varying nodes depend on
-  # `as_of`, any historical execution is fully reproducible — just supply the
-  # original timestamp as the `as_of` input.
-  #
-  # == Usage
-  #
-  #   require "igniter/core/temporal"
-  #
-  #   class TaxRateContract < Igniter::Contract
-  #     include Igniter::Temporal
-  #
-  #     define do
-  #       input :country
-  #       # `as_of` is injected automatically (default: Time.now)
-  #
-  #       temporal_compute :tax_rate, depends_on: :country do |country:, as_of:|
-  #         HistoricalTaxRates.lookup(country: country, date: as_of.to_date)
-  #       end
-  #
-  #       output :tax_rate
-  #     end
-  #   end
-  #
-  #   # Current rates:
-  #   TaxRateContract.new(country: "UA").result.tax_rate
-  #
-  #   # Reproduce a historical result:
-  #   TaxRateContract.new(country: "UA", as_of: Time.new(2024, 1, 1)).result.tax_rate
-  #
-  # == TemporalExecutor
-  #
-  # For class-based executors in temporal contracts, inherit from
-  # Igniter::Temporal::Executor. It ensures `as_of:` is always passed as
-  # a keyword argument by the resolver.
-  #
-  #   class TaxRateExecutor < Igniter::Temporal::Executor
-  #     def call(country:, as_of:)
-  #       HistoricalTaxRates.lookup(country: country, date: as_of.to_date)
-  #     end
-  #   end
-  module Temporal
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      # Returns true for contracts that include Temporal.
-      def temporal? = true
-
-      # Override define to inject `as_of` and the `temporal_compute` builder helper
-      # before the user's block runs.
-      def define(&user_block)
-        super do
-          # Inject temporal input first so it can be used as a dependency.
-          input :as_of, default: -> { Time.now }
-
-          # Add `temporal_compute` as a convenience method on this builder instance.
-          # It behaves like `compute` but automatically adds `:as_of` to depends_on.
-          define_singleton_method(:temporal_compute) do |name, depends_on: [], **opts, &blk|
-            deps = (Array(depends_on) | [:as_of])
-            compute(name, depends_on: deps, **opts, &blk)
-          end
-
-          instance_eval(&user_block)
-        end
-      end
-    end
-
-    # Base executor for temporal compute nodes.
-    # Inheriting from this signals that the executor expects `as_of:` among its kwargs.
-    class Executor < Igniter::Executor
-      # Subclasses must implement: def call(**deps_including_as_of)
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/tool/discoverable.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class Tool
-    # Shared discovery DSL included by both +Igniter::Tool+ and +Igniter::AI::Skill+.
-    #
-    # Provides: +description+, +param+, +requires_capability+, +tool_name+,
-    # +to_schema+, and the instance-side +call_with_capability_check!+.
-    #
-    # Classes that include this module must call +copy_discoverable_state_to(subclass)+
-    # inside their own +inherited+ hook so the metadata propagates to subclasses.
-    module Discoverable
-      # Ruby type → JSON Schema type string
-      JSON_TYPES = {
-        string: "string", str: "string",
-        integer: "integer", int: "integer",
-        float: "number", number: "number",
-        boolean: "boolean", bool: "boolean",
-        array: "array",
-        object: "object",
-      }.freeze
-
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.instance_variable_set(:@tool_params, [])
-        base.instance_variable_set(:@required_capabilities, [].freeze)
-      end
-
-      # ── Class-level DSL ────────────────────────────────────────────────────
-      module ClassMethods
-        # Describe what the tool/skill does. Sent to the LLM as part of its schema.
-        def description(text = nil)
-          text ? (@tool_description = text.freeze) : @tool_description
-        end
-
-        # Declare an LLM-visible input parameter.
-        #
-        # @param name     [Symbol]  parameter name (keyword arg in #call)
-        # @param type     [Symbol]  :string, :integer, :float, :boolean, :array, :object
-        # @param required [Boolean] whether the LLM must supply this value
-        # @param default  [Object]  informational default (not enforced at call-time)
-        # @param desc     [String]  short description for the LLM
-        def param(name, type:, required: false, default: nil, desc: nil)
-          tool_params << {
-            name:     name.to_sym,
-            type:     type.to_sym,
-            required: required,
-            default:  default,
-            desc:     desc.to_s,
-          }.freeze
-        end
-
-        # Declare capabilities the calling agent must have before this tool/skill
-        # is allowed to run. +CapabilityError+ is raised before +#call+ if any
-        # required capability is missing from the agent's +declared_capabilities+.
-        def requires_capability(*caps)
-          @required_capabilities = caps.flatten.map(&:to_sym).freeze
-        end
-
-        # ── Read-only accessors ──────────────────────────────────────────────
-
-        def tool_params
-          @tool_params ||= []
-        end
-
-        def required_capabilities
-          @required_capabilities || [].freeze
-        end
-
-        # Snake-case name derived from the class name (last namespace component).
-        #
-        #   class SearchWebTool < Igniter::Tool  →  "search_web_tool"
-        #   class ResearchSkill < Igniter::AI::Skill →  "research_skill"
-        def tool_name
-          n = name.to_s.split("::").last
-          return "anonymous" if n.nil? || n.empty?
-
-          n.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-           .downcase
-        end
-
-        # Generate a tool schema for the given provider.
-        # With no argument returns the provider-agnostic intermediate format
-        # (used internally and processed by each provider's +normalize_tools+).
-        #
-        # @param provider [Symbol, nil] :anthropic, :openai, or nil for intermediate
-        # @return [Hash]
-        def to_schema(provider = nil)
-          case provider&.to_sym
-          when :anthropic
-            { name: tool_name, description: description.to_s, input_schema: json_schema }
-          when :openai
-            {
-              type: "function",
-              function: { name: tool_name, description: description.to_s, parameters: json_schema },
-            }
-          else
-            { name: tool_name, description: description.to_s, parameters: json_schema }
-          end
-        end
-
-        # Call this in +inherited+ to propagate discoverable metadata to subclasses.
-        # Each class using this module is responsible for calling this in its own
-        # +inherited+ hook (alongside any chain-specific super calls).
-        def copy_discoverable_state_to(subclass)
-          subclass.instance_variable_set(:@tool_params, @tool_params&.dup || [])
-          subclass.instance_variable_set(:@required_capabilities, @required_capabilities&.dup || [].freeze)
-          subclass.instance_variable_set(:@tool_description, @tool_description)
-        end
-
-        private
-
-        def json_schema
-          required_names = tool_params.select { |p| p[:required] }.map { |p| p[:name].to_s }
-          properties = tool_params.each_with_object({}) do |p, h|
-            prop = { "type" => JSON_TYPES.fetch(p[:type], "string") }
-            prop["description"] = p[:desc] unless p[:desc].empty?
-            prop["default"] = p[:default] unless p[:default].nil?
-            h[p[:name].to_s] = prop
-          end
-
-          schema = { "type" => "object", "properties" => properties }
-          schema["required"] = required_names unless required_names.empty?
-          schema
-        end
-      end
-
-      # ── Instance — capability-guarded call ──────────────────────────────────
-
-      # Verify the agent has all required capabilities, then invoke +#call+.
-      # Called by +AI::Executor+ during the tool-use loop for every tool/skill invocation.
-      #
-      # @param allowed_capabilities [Array<Symbol>] capabilities the calling agent has
-      # @raise [Igniter::Tool::CapabilityError] if a required capability is missing
-      def call_with_capability_check!(allowed_capabilities:, **kwargs)
-        required = self.class.required_capabilities
-        unless required.empty?
-          allowed = allowed_capabilities.map(&:to_sym)
-          missing = required.reject { |c| allowed.include?(c) }
-          unless missing.empty?
-            raise Igniter::Tool::CapabilityError,
-                  "Tool #{self.class.tool_name.inspect} requires capabilities " \
-                  "#{missing.inspect} but agent only has #{allowed.inspect}"
-          end
-        end
-        call(**kwargs)
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/tool.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "errors"
-require_relative "runtime/deferred_result"
-require_relative "executor"
-
-module Igniter
-  # Base class for AI-callable tools.
-  #
-  # Extends +Igniter::Executor+ with declarative metadata for LLM function-calling
-  # (Anthropic, OpenAI) and capability-based access guards.
-  # Shares the discovery DSL with +Igniter::AI::Skill+ via +Tool::Discoverable+.
-  #
-  # == Defining a tool
-  #
-  #   class SearchWeb < Igniter::Tool
-  #     description "Search the internet for current information"
-  #
-  #     param :query,       type: :string,  required: true,  desc: "The search query"
-  #     param :max_results, type: :integer, default: 5,      desc: "Max results to return"
-  #
-  #     requires_capability :web_access
-  #
-  #     def call(query:, max_results: 5)
-  #       [{ title: "...", url: "...", snippet: "..." }]
-  #     end
-  #   end
-  #
-  # == Schema generation
-  #
-  #   SearchWeb.tool_name             # => "search_web"
-  #   SearchWeb.to_schema             # => { name:, description:, parameters: { ... } }
-  #   SearchWeb.to_schema(:anthropic) # => { name:, description:, input_schema: { ... } }
-  #   SearchWeb.to_schema(:openai)    # => { type: "function", function: { ... } }
-  #
-  # == Compatibility
-  #
-  # Tool inherits +Igniter::Executor+ — usable as a compute node in any Contract graph.
-  class Tool < Executor
-    # Raised when a tool or skill requires a capability the calling agent does not have.
-    # Also aliased as +Igniter::AI::Skill::CapabilityError+.
-    class CapabilityError < Igniter::Error; end
-
-    require_relative "tool/discoverable"
-    include Discoverable
-
-    def self.inherited(subclass)
-      super
-      # Tool subclasses always start with empty params and capabilities —
-      # each concrete tool declares its own. Only the description carries forward.
-      subclass.instance_variable_set(:@tool_params, [])
-      subclass.instance_variable_set(:@required_capabilities, [].freeze)
-      subclass.instance_variable_set(:@tool_description, @tool_description)
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/type_system.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module TypeSystem
-    SUPPORTED_TYPES = {
-      integer: Integer,
-      float: Float,
-      numeric: Numeric,
-      string: String,
-      boolean: :boolean,
-      array: Array,
-      hash: Hash,
-      symbol: Symbol,
-      result: :result
-    }.freeze
-
-    module_function
-
-    def supported?(type)
-      return false unless type
-
-      SUPPORTED_TYPES.key?(type.to_sym)
-    end
-
-    def compatible?(source_type, target_type)
-      return true if source_type.nil? || target_type.nil?
-
-      source = source_type.to_sym
-      target = target_type.to_sym
-      return true if source == target
-      return true if %i[integer float].include?(source) && target == :numeric
-
-      false
-    end
-
-    def match?(type, value)
-      matcher = SUPPORTED_TYPES.fetch(type.to_sym)
-      return false if matcher == :result
-      return value == true || value == false if matcher == :boolean
-
-      value.is_a?(matcher)
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  VERSION = "0.5.1"
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "core/version"
-require_relative "core/errors"
-require_relative "core/type_system"
-require_relative "core/executor"
-require_relative "core/executor_registry"
-require_relative "core/effect"
-require_relative "core/effect_registry"
-require_relative "core/model"
-require_relative "core/compiler"
-require_relative "core/events"
-require_relative "core/runtime"
-require_relative "core/dto"
-require_relative "core/dsl"
-require_relative "core/extensions"
-require_relative "core/diagnostics"
-require_relative "core/contract"
-require_relative "core/stream_loop"
-require_relative "core/tool"
-
-module Igniter
-end

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

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

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

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

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/capabilities"
-
-# Patches CompiledGraph with capability introspection methods.
-# The Resolver integration is handled via guard-claused hooks in resolver.rb.
-module Igniter
-  module Compiler
-    class CompiledGraph
-      # Returns a Hash of { node_name => [capabilities] } for every compute/effect
-      # node whose executor declares at least one capability.
-      def required_capabilities
-        (nodes + outputs).each_with_object({}) do |node, memo|
-          caps = node_capabilities(node)
-          memo[node.name] = caps unless caps.empty?
-        end
-      end
-
-      # Returns declared capabilities for a single node by name.
-      def capabilities_for(node_name)
-        sym    = node_name.to_sym
-        target = (nodes + outputs).find { |n| n.name == sym }
-        return [] unless target
-
-        node_capabilities(target)
-      end
-
-      private
-
-      def node_capabilities(node)
-        callable = node.respond_to?(:callable) ? node.callable : nil
-        callable ||= node.respond_to?(:adapter_class) ? node.adapter_class : nil
-        return [] unless callable.is_a?(Class) && callable <= Igniter::Executor
-
-        callable.declared_capabilities
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-# Loading this file activates content-addressed caching for pure executors.
-# The Resolver picks up content addressing via a guard clause when this constant is defined.
-require "igniter/core/content_addressing"

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter"
-require "igniter/core/dataflow"
-
-# Activates incremental dataflow support for all contracts.
-#
-# After requiring this file:
-#
-#   - `collection` DSL accepts `mode: :incremental` and `window:` options.
-#   - Contracts gain `#feed_diff` — push event-style diffs instead of full arrays.
-#   - Contracts gain `#collection_diff` — inspect what changed after the last resolve.
-#
-# == Usage
-#
-#   require "igniter/extensions/dataflow"
-#
-#   class SensorPipeline < Igniter::Contract
-#     define do
-#       input :readings, type: :array
-#
-#       collection :processed,
-#                  with: :readings,
-#                  each: SensorContract,
-#                  key: :sensor_id,
-#                  mode: :incremental,
-#                  window: { last: 500 }
-#
-#       output :processed
-#     end
-#   end
-#
-#   contract = SensorPipeline.new(readings: initial_readings)
-#   contract.resolve_all
-#
-#   # Push new events without replacing the full array
-#   contract.feed_diff(:readings, add: [new_reading], remove: [:sensor_old])
-#   contract.resolve_all
-#
-#   # Inspect what changed
-#   diff = contract.collection_diff(:processed)
-#   diff.added     # => [:sensor_42]
-#   diff.removed   # => [:sensor_old]
-#   diff.changed   # => []
-#   diff.unchanged # => [:sensor_1, :sensor_2, ...]
-#
-module Igniter
-  module Extensions
-    module Dataflow
-      module InstanceMethods
-        # Push a diff to a collection input without replacing the full array.
-        #
-        # Automatically finds the incremental collection node that uses +input_name+
-        # as its source dependency, uses its key_name to merge the diff into the
-        # current input array, then calls update_inputs.
-        #
-        # @param input_name [Symbol, String]  the contract input holding the collection
-        # @param add        [Array<Hash>]     new items to append
-        # @param remove     [Array]           keys or Hash items to remove (matched by key_name)
-        # @param update     [Array<Hash>]     updated versions of existing items (replace by key)
-        # @return [self]
-        #
-        # @raise [ArgumentError] if no incremental collection node uses the given input
-        def feed_diff(input_name, add: [], remove: [], update: [])
-          sym      = input_name.to_sym
-          key_name = _incremental_node_for(sym).key_name
-          current  = execution.inputs[sym].dup || []
-          items    = _apply_diff(current, key_name, add: add, remove: remove, update: update)
-          execution.update_inputs(sym => items)
-          self
-        end
-
-        # Returns the Diff from the last resolve for a named collection node.
-        #
-        # @param collection_name [Symbol, String]  the collection node name
-        # @return [Igniter::Dataflow::Diff, nil]  nil if not yet resolved or not incremental
-        def collection_diff(collection_name)
-          state = execution.cache.fetch(collection_name.to_sym)
-          value = state&.value
-          value.respond_to?(:diff) ? value.diff : nil
-        end
-
-        private
-
-        def _apply_diff(items, key_name, add:, remove:, update:)
-          remove_keys = Array(remove).map { |e| e.is_a?(Hash) ? e.fetch(key_name) : e }.to_set
-          result = items.reject { |item| remove_keys.include?(item.fetch(key_name)) }
-          _apply_updates(result, key_name, update)
-          result.concat(Array(add))
-        end
-
-        def _apply_updates(items, key_name, updates)
-          Array(updates).each do |updated|
-            k   = updated.fetch(key_name)
-            idx = items.index { |item| item.fetch(key_name) == k }
-            idx ? items[idx] = updated : items << updated
-          end
-        end
-
-        def _incremental_node_for(input_name)
-          node = execution.compiled_graph.nodes.find do |n|
-            n.kind == :collection &&
-              n.mode == :incremental &&
-              n.source_dependency == input_name
-          end
-          return node if node
-
-          raise ArgumentError,
-                "No incremental collection node found for input '#{input_name}'. " \
-                "Ensure the collection is declared with mode: :incremental."
-        end
-      end
-    end
-  end
-end
-
-Igniter::Contract.include(Igniter::Extensions::Dataflow::InstanceMethods)