igniter 0.5.1 → 0.5.2

data/packages/igniter-core/lib/igniter/core/runtime/stores/sqlite_store.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "json"
-
-module Igniter
-  module Runtime
-    module Stores
-      class SQLiteStore
-        def initialize(path:)
-          require "sqlite3"
-        rescue LoadError
-          raise Igniter::Runtime::ConfigurationError,
-                "`igniter` now ships with a required `sqlite3` dependency. " \
-                "If it is missing in this environment, run bundle install or reinstall the gem."
-        else
-          prepare_path!(path)
-          @mutex = Mutex.new
-          @db = ::SQLite3::Database.new(path)
-          @db.results_as_hash = true
-          create_schema!
-        end
-
-        def save(snapshot, correlation: nil, graph: nil)
-          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
-          resolved_graph = graph || snapshot[:graph] || snapshot["graph"]
-          correlation_json = normalized_correlation_json(correlation)
-          pending = pending_snapshot?(snapshot) ? 1 : 0
-
-          @mutex.synchronize do
-            @db.execute(
-              <<~SQL,
-                INSERT OR REPLACE INTO execution_snapshots
-                  (execution_id, graph, correlation_json, pending, snapshot_json, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?)
-              SQL
-              [execution_id, resolved_graph, correlation_json, pending, JSON.generate(snapshot), Time.now.to_i]
-            )
-          end
-
-          execution_id
-        end
-
-        def find_by_correlation(graph:, correlation:)
-          @mutex.synchronize do
-            row = @db.get_first_row(
-              "SELECT execution_id FROM execution_snapshots WHERE graph = ? AND correlation_json = ?",
-              [graph, normalized_correlation_json(correlation)]
-            )
-            row && row["execution_id"]
-          end
-        end
-
-        def list_all(graph: nil)
-          @mutex.synchronize do
-            rows =
-              if graph
-                @db.execute(
-                  "SELECT execution_id FROM execution_snapshots WHERE graph = ? ORDER BY updated_at ASC",
-                  [graph]
-                )
-              else
-                @db.execute("SELECT execution_id FROM execution_snapshots ORDER BY updated_at ASC")
-              end
-            rows.map { |row| row["execution_id"] }
-          end
-        end
-
-        def list_pending(graph: nil)
-          @mutex.synchronize do
-            rows =
-              if graph
-                @db.execute(
-                  "SELECT execution_id FROM execution_snapshots WHERE graph = ? AND pending = 1 ORDER BY updated_at ASC",
-                  [graph]
-                )
-              else
-                @db.execute("SELECT execution_id FROM execution_snapshots WHERE pending = 1 ORDER BY updated_at ASC")
-              end
-            rows.map { |row| row["execution_id"] }
-          end
-        end
-
-        def fetch(execution_id)
-          @mutex.synchronize do
-            row = @db.get_first_row(
-              "SELECT snapshot_json FROM execution_snapshots WHERE execution_id = ?",
-              [execution_id]
-            )
-            raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'" unless row
-
-            JSON.parse(row["snapshot_json"])
-          end
-        end
-
-        def delete(execution_id)
-          @mutex.synchronize do
-            @db.execute("DELETE FROM execution_snapshots WHERE execution_id = ?", [execution_id])
-          end
-        end
-
-        def exist?(execution_id)
-          @mutex.synchronize do
-            row = @db.get_first_row(
-              "SELECT 1 FROM execution_snapshots WHERE execution_id = ? LIMIT 1",
-              [execution_id]
-            )
-            !row.nil?
-          end
-        end
-
-        private
-
-        def create_schema!
-          @db.execute_batch(<<~SQL)
-            CREATE TABLE IF NOT EXISTS execution_snapshots (
-              execution_id TEXT PRIMARY KEY,
-              graph TEXT,
-              correlation_json TEXT,
-              pending INTEGER NOT NULL DEFAULT 0,
-              snapshot_json TEXT NOT NULL,
-              updated_at INTEGER NOT NULL
-            );
-            CREATE INDEX IF NOT EXISTS idx_execution_snapshots_graph
-              ON execution_snapshots(graph);
-            CREATE INDEX IF NOT EXISTS idx_execution_snapshots_pending
-              ON execution_snapshots(pending, updated_at);
-            CREATE INDEX IF NOT EXISTS idx_execution_snapshots_graph_correlation
-              ON execution_snapshots(graph, correlation_json);
-          SQL
-        end
-
-        def normalized_correlation_json(correlation)
-          return nil if correlation.nil? || correlation.empty?
-
-          JSON.generate(correlation.transform_keys(&:to_s).sort.to_h)
-        end
-
-        def pending_snapshot?(snapshot)
-          states = snapshot[:states] || snapshot["states"] || {}
-          states.any? do |_name, state|
-            status = state[:status] || state["status"]
-            status.to_s == "pending"
-          end
-        end
-
-        def prepare_path!(path)
-          return if path.to_s.empty? || path == ":memory:"
-
-          FileUtils.mkdir_p(::File.dirname(path))
-        end
-      end
-    end
-  end
-end

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

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Runtime
-    class StreamResult < DeferredResult
-      def self.build(token: nil, payload: {}, source_node: nil, waiting_on: nil)
-        new(
-          token: token || SecureRandom.uuid,
-          payload: payload,
-          source_node: source_node,
-          waiting_on: waiting_on
-        )
-      end
-
-      def session
-        data = agent_session_data
-        return nil unless data
-
-        Runtime::AgentSession.from_h(data)
-      end
-
-      def agent_result_contract
-        Runtime::AgentResultContract.from_result(self, kind: :stream)
-      end
-
-      def phase
-        session&.phase || :streaming
-      end
-
-      def chunks
-        session&.chunks || []
-      end
-
-      def events
-        session&.events || []
-      end
-
-      def last_event
-        events.last
-      end
-
-      def status_events
-        events.select { |event| event[:type] == :status }
-      end
-
-      def statuses
-        status_events.filter_map { |event| event[:status] }
-      end
-
-      def tool_calls
-        events.select { |event| event[:type] == :tool_call }
-      end
-
-      def tool_results
-        events.select { |event| event[:type] == :tool_result }
-      end
-
-      def artifacts
-        events.select { |event| event[:type] == :artifact }
-      end
-
-      def final_event
-        events.reverse.find { |event| event[:type] == :final }
-      end
-
-      def tool_interactions
-        session&.tool_interactions || []
-      end
-
-      def pending_tool_interactions
-        session&.pending_tool_interactions || []
-      end
-
-      def completed_tool_interactions
-        session&.completed_tool_interactions || []
-      end
-
-      def orphan_tool_interactions
-        session&.orphan_tool_interactions || []
-      end
-
-      def all_tool_calls_resolved?
-        session ? session.all_tool_calls_resolved? : true
-      end
-
-      def tool_loop_consistent?
-        session ? session.tool_loop_consistent? : true
-      end
-
-      def tool_loop_complete?
-        session ? session.tool_loop_complete? : true
-      end
-
-      def tool_loop_status
-        session&.tool_loop_status || :idle
-      end
-
-      def tool_loop_summary
-        session&.tool_loop_summary || {
-          status: :idle,
-          total: 0,
-          pending: 0,
-          completed: 0,
-          orphaned: 0,
-          resolved: true,
-          consistent: true,
-          complete: true,
-          open_keys: [],
-          orphan_keys: []
-        }
-      end
-
-      def tool_runtime
-        session&.tool_runtime || {
-          status: :idle,
-          policy: nil,
-          finalizer: nil,
-          waiting_on: waiting_on,
-          interaction_count: 0,
-          pending_count: 0,
-          completed_count: 0,
-          orphaned_count: 0,
-          resolved: true,
-          consistent: true,
-          complete: true,
-          open_keys: [],
-          orphan_keys: [],
-          open_tools: [],
-          completed_tools: [],
-          orphan_tools: []
-        }.freeze
-      end
-
-      def last_chunk
-        chunks.last
-      end
-
-      def complete?
-        phase == :completed
-      end
-
-      def streaming?
-        !complete?
-      end
-
-      def to_h
-        super.merge(
-          type: :stream,
-          agent_result_contract: agent_result_contract&.to_h,
-          phase: phase,
-          events: events,
-          event_count: events.size,
-          status_count: status_events.size,
-          tool_call_count: tool_calls.size,
-          tool_result_count: tool_results.size,
-          tool_interaction_count: tool_interactions.size,
-          pending_tool_interaction_count: pending_tool_interactions.size,
-          completed_tool_interaction_count: completed_tool_interactions.size,
-          orphan_tool_interaction_count: orphan_tool_interactions.size,
-          tool_loop_status: tool_loop_status,
-          tool_loop_complete: tool_loop_complete?,
-          tool_loop_summary: tool_loop_summary,
-          tool_runtime: tool_runtime,
-          artifact_count: artifacts.size,
-          chunks: chunks,
-          chunk_count: chunks.size
-        )
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "runtime/node_state"
-require_relative "runtime/cache"
-require_relative "runtime/deferred_result"
-require_relative "runtime/stream_result"
-require_relative "runtime/agent_session"
-require_relative "runtime/agent_result_contract"
-require_relative "runtime/agent_session_query"
-require_relative "runtime/orchestration_runtime_state"
-require_relative "runtime/orchestration_transition_query"
-require_relative "runtime/orchestration_overview"
-require_relative "runtime/collection_result"
-require_relative "runtime/input_validator"
-require_relative "runtime/planner"
-require_relative "runtime/job_worker"
-require_relative "runtime/runners/inline_runner"
-require_relative "runtime/runners/store_runner"
-require_relative "runtime/runners/thread_pool_runner"
-require_relative "runtime/stores/active_record_store"
-require_relative "runtime/stores/file_store"
-require_relative "runtime/stores/memory_store"
-require_relative "runtime/stores/redis_store"
-require_relative "runtime/stores/sqlite_store"
-require_relative "runtime/runner_factory"
-require_relative "runtime/remote_adapter"
-require_relative "runtime/agent_adapter"
-require_relative "runtime/agent_route"
-require_relative "runtime/agent_route_resolver"
-require_relative "runtime/agent_transport"
-require_relative "runtime/proxy_agent_adapter"
-require_relative "runtime/resolver"
-require_relative "runtime/invalidator"
-require_relative "runtime/result"
-require_relative "runtime/execution"
-
-module Igniter
-  module Runtime
-    ConfigurationError = Class.new(Igniter::Error)
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Saga
-    # Declares the compensating action for a named compute node.
-    #
-    # The block is called with keyword arguments:
-    #   inputs: Hash{ Symbol => value }  — dependency values the node consumed
-    #   value:  Object                   — the value the node produced
-    #
-    # Example:
-    #   compensate :charge_card do |inputs:, value:|
-    #     PaymentService.refund(value[:charge_id])
-    #   end
-    class Compensation
-      attr_reader :node_name, :block
-
-      def initialize(node_name, &block)
-        raise ArgumentError, "compensate :#{node_name} requires a block" unless block
-
-        @node_name = node_name.to_sym
-        @block = block
-        freeze
-      end
-
-      def run(inputs:, value:)
-        block.call(inputs: inputs, value: value)
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Saga
-    # Immutable record of a single compensation that was attempted.
-    class CompensationRecord
-      attr_reader :node_name, :error
-
-      def initialize(node_name:, success:, error: nil)
-        @node_name = node_name
-        @success = success
-        @error = error
-        freeze
-      end
-
-      def success? = @success
-      def failed?  = !@success
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Saga
-    # Runs declared compensations for all successfully completed nodes,
-    # in reverse topological order.
-    #
-    # A node is eligible for compensation if:
-    #   1. Its state in the cache is `succeeded?`
-    #   2. A compensation is declared for it, via one of:
-    #      a. Contract-level `compensate :node_name do ... end`  (takes precedence)
-    #      b. Built-in compensation defined on the Igniter::Effect adapter class
-    #
-    # Compensation failures are captured as failed CompensationRecords and
-    # do NOT halt the rollback of other nodes.
-    class Executor
-      def initialize(contract)
-        @contract = contract
-        @graph    = contract.execution.compiled_graph
-        @cache    = contract.execution.cache
-      end
-
-      # @return [Array<CompensationRecord>]
-      def run_compensations
-        eligible_nodes_reversed.filter_map do |node|
-          compensation = find_compensation(node)
-          next unless compensation
-
-          attempt(compensation, node)
-        end
-      end
-
-      # Find the first node whose state is :failed in the cache.
-      # @return [Symbol, nil]
-      def failed_node_name
-        @cache.to_h.find { |_name, state| state.failed? }&.first
-      end
-
-      private
-
-      # Resolve the compensation to use for a node, if any.
-      #
-      # Contract-level `compensate :node_name` takes precedence over built-in
-      # compensation declared on an Igniter::Effect subclass.
-      #
-      # @return [Igniter::Saga::Compensation, nil]
-      def find_compensation(node)
-        declared = @contract.class.compensations
-        return declared[node.name] if declared.key?(node.name)
-
-        return nil unless node.kind == :effect
-
-        built_in = node.adapter_class.built_in_compensation
-        return nil unless built_in
-
-        Compensation.new(node.name, &built_in)
-      end
-
-      # Nodes that succeeded, in reverse resolution order.
-      def eligible_nodes_reversed
-        @graph.resolution_order
-              .select { |node| @cache.fetch(node.name)&.succeeded? }
-              .reverse
-      end
-
-      def attempt(compensation, node)
-        inputs = extract_inputs(node)
-        value  = @cache.fetch(node.name)&.value
-
-        compensation.run(inputs: inputs, value: value)
-        CompensationRecord.new(node_name: compensation.node_name, success: true)
-      rescue StandardError => e
-        CompensationRecord.new(node_name: compensation.node_name, success: false, error: e)
-      end
-
-      # Gather the resolved values of the node's direct dependencies.
-      def extract_inputs(node)
-        node.dependencies.each_with_object({}) do |dep_name, acc|
-          state = @cache.fetch(dep_name)
-          acc[dep_name.to_sym] = state&.value
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Saga
-    # Formats a SagaResult as a human-readable text block.
-    #
-    # Example:
-    #
-    #   Contract: OrderWorkflow
-    #   Status:   FAILED
-    #   Error:    Insufficient funds
-    #   At node:  :charge_card
-    #
-    #   COMPENSATIONS (1):
-    #     [ok]    :reserve_stock
-    #
-    module Formatter
-      class << self
-        def format(result)
-          lines = []
-          lines << "Contract: #{result.contract.class.name}"
-          lines << "Status:   #{result.success? ? "SUCCESS" : "FAILED"}"
-
-          if result.failed?
-            lines << "Error:    #{result.error&.message}"
-            lines << "At node:  :#{result.failed_node}" if result.failed_node
-          end
-
-          append_compensations(result, lines)
-          lines.join("\n")
-        end
-
-        private
-
-        def append_compensations(result, lines)
-          return if result.compensations.empty?
-
-          lines << ""
-          lines << "COMPENSATIONS (#{result.compensations.size}):"
-          result.compensations.each do |rec|
-            tag = rec.success? ? "[ok]   " : "[fail] "
-            lines << "  #{tag} :#{rec.node_name}"
-            lines << "    error: #{rec.error.message}" if rec.failed?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Saga
-    # Immutable result of a saga execution (resolve_saga call).
-    #
-    # Attributes:
-    #   contract      — the contract instance that was executed
-    #   error         — Igniter::Error that caused failure (nil on success)
-    #   failed_node   — Symbol name of the first node that failed (nil on success)
-    #   compensations — Array<CompensationRecord> for all attempted compensations
-    class Result
-      attr_reader :contract, :error, :failed_node, :compensations
-
-      def initialize(success:, contract:, error: nil, failed_node: nil, compensations: [])
-        @success       = success
-        @contract      = contract
-        @error         = error
-        @failed_node   = failed_node
-        @compensations = compensations.freeze
-        freeze
-      end
-
-      def success? = @success
-      def failed?  = !@success
-
-      # Human-readable saga report.
-      def explain
-        Formatter.format(self)
-      end
-
-      alias to_s explain
-
-      # Structured (serialisable) representation.
-      def to_h
-        {
-          success: success?,
-          failed_node: failed_node,
-          error: error&.message,
-          compensations: compensations.map do |rec|
-            { node: rec.node_name, success: rec.success?, error: rec.error&.message }
-          end
-        }
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "errors"
-require_relative "saga/compensation"
-require_relative "saga/compensation_record"
-require_relative "saga/formatter"
-require_relative "saga/result"
-require_relative "saga/executor"
-
-module Igniter
-  # Saga pattern — compensating transactions for Igniter contracts.
-  #
-  # When a contract execution fails partway through, the saga system
-  # automatically runs the compensating actions for all previously
-  # SUCCEEDED nodes, in reverse topological order.
-  #
-  # Usage:
-  #
-  #   require "igniter/extensions/saga"
-  #
-  #   class OrderWorkflow < Igniter::Contract
-  #     define do
-  #       input  :order_id
-  #       input  :amount
-  #
-  #       compute :reserve_stock, depends_on: :order_id do |order_id:|
-  #         InventoryService.reserve(order_id)
-  #       end
-  #
-  #       compute :charge_card, depends_on: %i[order_id amount reserve_stock] do |amount:, **|
-  #         raise "Declined" if amount > 1000
-  #         PaymentService.charge(amount)
-  #       end
-  #
-  #       output :charge_card
-  #     end
-  #
-  #     compensate :charge_card do |inputs:, value:|
-  #       PaymentService.refund(value[:charge_id])
-  #     end
-  #
-  #     compensate :reserve_stock do |inputs:, value:|
-  #       InventoryService.release(value[:reservation_id])
-  #     end
-  #   end
-  #
-  #   result = OrderWorkflow.new(order_id: "x1", amount: 1500).resolve_saga
-  #   result.success?            # => false
-  #   result.failed_node         # => :charge_card
-  #   result.compensations.map(&:node_name)  # => [:reserve_stock]
-  #   puts result.explain
-  #
-  module Saga
-    class SagaError < Igniter::Error; end
-  end
-end