igniter 0.5.0 → 0.5.2

data/lib/igniter/contract.rb

@@ -1,328 +1,3 @@
 # frozen_string_literal: true
 
-module Igniter
-  class Contract
-    class << self
-      def correlate_by(*keys)
-        @correlation_keys = keys.map(&:to_sym).freeze
-      end
-
-      def correlation_keys
-        @correlation_keys || []
-      end
-
-      def define(&block)
-        @compiled_graph = DSL::ContractBuilder.compile(
-          name: contract_name,
-          correlation_keys: correlation_keys,
-          &block
-        )
-      end
-
-      def run_with(runner:, max_workers: nil)
-        @execution_options = { runner: runner, max_workers: max_workers }.compact
-      end
-
-      # Ergonomic alias for run_with. Accepts pool_size: as a clearer name for
-      # max_workers: when using the thread_pool runner.
-      #
-      #   class MyContract < Igniter::Contract
-      #     runner :thread_pool, pool_size: 4
-      #     define do ... end
-      #   end
-      def runner(strategy, pool_size: nil, max_workers: nil, **opts)
-        workers = pool_size || max_workers
-        @execution_options = { runner: strategy, max_workers: workers }.merge(opts).compact
-      end
-
-      def restore_from_store(execution_id, store: nil)
-        snapshot = (store || Igniter.execution_store).fetch(execution_id)
-        restore(snapshot)
-      end
-
-      def resume_from_store(execution_id, token:, value:, store: nil)
-        Runtime::JobWorker.new(self, store: store || Igniter.execution_store).resume(
-          execution_id: execution_id,
-          token: token,
-          value: value
-        )
-      end
-
-      def define_schema(schema)
-        @compiled_graph = DSL::SchemaBuilder.compile(schema, name: contract_name)
-      end
-
-      def start(inputs = {}, store: nil, **keyword_inputs)
-        resolved_store = store || Igniter.execution_store
-        all_inputs = inputs.merge(keyword_inputs)
-
-        instance = new(all_inputs, runner: :store, store: resolved_store)
-        instance.resolve_all
-
-        correlation = correlation_keys.each_with_object({}) do |key, hash|
-          hash[key] = all_inputs[key] || all_inputs[key.to_s]
-        end
-
-        resolved_store.save(instance.snapshot, correlation: correlation.compact, graph: contract_name)
-        instance
-      end
-
-      def deliver_event(event_name, correlation:, payload:, store: nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        resolved_store = store || Igniter.execution_store
-        execution_id = resolved_store.find_by_correlation(
-          graph: contract_name,
-          correlation: correlation.transform_keys(&:to_sym)
-        )
-        unless execution_id
-          raise ResolutionError,
-                "No pending execution found for #{contract_name} with given correlation"
-        end
-
-        instance = restore_from_store(execution_id, store: resolved_store)
-
-        await_node = instance.execution.compiled_graph.await_nodes
-                             .find { |n| n.event_name == event_name.to_sym }
-        raise ResolutionError, "No await node found for event '#{event_name}' in #{contract_name}" unless await_node
-
-        instance.execution.resume(await_node.name, value: payload)
-        instance.resolve_all
-
-        resolved_store.save(instance.snapshot, correlation: correlation.transform_keys(&:to_sym), graph: contract_name)
-        instance
-      end
-
-      def restore(snapshot)
-        instance = new(
-          snapshot[:inputs] || snapshot["inputs"] || {},
-          runner: snapshot[:runner] || snapshot["runner"],
-          max_workers: snapshot[:max_workers] || snapshot["max_workers"]
-        )
-        instance.restore_execution(snapshot)
-      end
-
-      def react_to(event_type, path: nil, once_per_execution: false, &block)
-        raise CompileError, "react_to requires a block" unless block
-
-        reactions << Extensions::Reactive::Reaction.new(
-          event_type: event_type,
-          path: path,
-          action: block,
-          once_per_execution: once_per_execution
-        )
-      end
-
-      def effect(path = nil, event_type: :node_succeeded, &block)
-        react_to(event_type, path: path, &block)
-      end
-
-      def on_success(target, &block)
-        graph = compiled_graph
-        if graph&.output?(target)
-          react_to(:execution_finished, once_per_execution: true) do |event:, contract:, execution:|
-            next if execution.cache.values.any?(&:failed?)
-            next if execution.cache.values.any?(&:pending?)
-
-            block.call(
-              event: event,
-              contract: contract,
-              execution: execution,
-              value: contract.result.public_send(target)
-            )
-          end
-        else
-          effect(target.to_s, event_type: :node_succeeded, &block)
-        end
-      end
-
-      def on_failure(&block)
-        react_to(:execution_failed, once_per_execution: true) do |event:, contract:, execution:|
-          block.call(
-            event: event,
-            contract: contract,
-            execution: execution,
-            status: :failed,
-            errors: terminal_errors(execution),
-            error: terminal_errors(execution).values.first
-          )
-        end
-      end
-
-      def on_exit(&block)
-        terminal_hook = proc do |event:, contract:, execution:|
-          status = event.type == :execution_failed ? :failed : :succeeded
-          errors = status == :failed ? terminal_errors(execution) : {}
-
-          block.call(
-            event: event,
-            contract: contract,
-            execution: execution,
-            status: status,
-            errors: errors,
-            error: errors.values.first
-          )
-        end
-
-        react_to(:execution_finished, once_per_execution: true, &terminal_hook)
-        react_to(:execution_failed, once_per_execution: true, &terminal_hook)
-      end
-
-      def present(output_name, with: nil, &block)
-        raise CompileError, "present requires a block or `with:`" unless block || with
-        raise CompileError, "present cannot use both a block and `with:`" if block && with
-
-        own_output_presenters[output_name.to_sym] = with || block
-      end
-
-      def compiled_graph
-        @compiled_graph || superclass_compiled_graph
-      end
-      alias graph compiled_graph
-
-      def reactions
-        @reactions ||= []
-      end
-
-      def execution_options
-        @execution_options || superclass_execution_options || {}
-      end
-
-      def output_presenters
-        inherited = superclass.respond_to?(:output_presenters) ? superclass.output_presenters : {}
-        inherited.merge(own_output_presenters)
-      end
-
-      private
-
-      def own_output_presenters
-        @output_presenters ||= {}
-      end
-
-      def contract_name
-        name || "AnonymousContract"
-      end
-
-      def superclass_compiled_graph
-        return unless superclass.respond_to?(:compiled_graph)
-
-        superclass.compiled_graph
-      end
-
-      def superclass_execution_options
-        return unless superclass.respond_to?(:execution_options)
-
-        superclass.execution_options
-      end
-
-      def terminal_errors(execution)
-        execution.cache.values.each_with_object({}) do |state, memo|
-          next unless state.failed?
-
-          memo[state.node.name] = state.error
-        end
-      end
-    end
-
-    attr_reader :execution, :result, :reactive
-
-    def initialize(inputs = nil, runner: nil, max_workers: nil, store: nil, **keyword_inputs)
-      graph = self.class.compiled_graph
-      raise CompileError, "#{self.class.name} has no compiled graph. Use `define`." unless graph
-
-      normalized_inputs =
-        if inputs.nil?
-          keyword_inputs
-        elsif keyword_inputs.empty?
-          inputs
-        else
-          inputs.to_h.merge(keyword_inputs)
-        end
-
-      execution_options = self.class.execution_options.merge(
-        { runner: runner, max_workers: max_workers, store: store }.compact
-      )
-      execution_options[:store] ||= Igniter.execution_store if execution_options[:runner]&.to_sym == :store
-
-      @execution = Runtime::Execution.new(
-        compiled_graph: graph,
-        contract_instance: self,
-        inputs: normalized_inputs,
-        **execution_options
-      )
-      @reactive = Extensions::Reactive::Engine.new(
-        execution: @execution,
-        contract: self,
-        reactions: self.class.reactions
-      )
-      @execution.events.subscribe(@reactive)
-      @result = Runtime::Result.new(@execution)
-    end
-
-    def resolve
-      execution.resolve_all
-      self
-    end
-
-    def resolve_all
-      resolve
-    end
-
-    def update_inputs(inputs)
-      execution.update_inputs(inputs)
-      self
-    end
-
-    def events
-      execution.events.events
-    end
-
-    def audit
-      execution.audit
-    end
-
-    def audit_snapshot
-      execution.audit.snapshot
-    end
-
-    def subscribe(subscriber = nil, &block)
-      execution.events.subscribe(subscriber, &block)
-      self
-    end
-
-    def diagnostics
-      Diagnostics::Report.new(execution)
-    end
-
-    def snapshot
-      execution.snapshot
-    end
-
-    def restore_execution(snapshot)
-      execution.restore!(snapshot)
-      self
-    end
-
-    def diagnostics_text
-      diagnostics.to_text
-    end
-
-    def diagnostics_markdown
-      diagnostics.to_markdown
-    end
-
-    def explain_plan(output_names = nil)
-      execution.explain_plan(output_names)
-    end
-
-    def success?
-      execution.success?
-    end
-
-    def failed?
-      execution.failed?
-    end
-
-    def pending?
-      execution.pending?
-    end
-  end
-end
+raise LoadError, "igniter/contract is archived; use igniter-contracts or require \"igniter\""

data/lib/igniter/monorepo_packages.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+[
+  File.expand_path("../../packages/igniter-contracts/lib", __dir__),
+  File.expand_path("../../packages/igniter-embed/lib", __dir__),
+  File.expand_path("../../packages/igniter-extensions/lib", __dir__),
+  File.expand_path("../../packages/igniter-application/lib", __dir__),
+  File.expand_path("../../packages/igniter-ai/lib", __dir__),
+  File.expand_path("../../packages/igniter-agents/lib", __dir__),
+  File.expand_path("../../packages/igniter-hub/lib", __dir__),
+  File.expand_path("../../packages/igniter-web/lib", __dir__),
+  File.expand_path("../../packages/igniter-cluster/lib", __dir__),
+  File.expand_path("../../packages/igniter-mcp-adapter/lib", __dir__)
+].each do |path|
+  $LOAD_PATH.unshift(path) if File.directory?(path) && !$LOAD_PATH.include?(path)
+end

data/lib/igniter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Igniter
-  VERSION = "0.5.0"
+  VERSION = "0.5.2" unless const_defined?(:VERSION)
 end

data/lib/igniter/web.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "igniter-web"

data/lib/igniter.rb

@@ -1,74 +1,82 @@
 # frozen_string_literal: true
 
+require_relative "igniter/monorepo_packages"
 require_relative "igniter/version"
-require_relative "igniter/errors"
-require_relative "igniter/type_system"
-require_relative "igniter/executor"
-require_relative "igniter/executor_registry"
-require_relative "igniter/effect"
-require_relative "igniter/effect_registry"
-require_relative "igniter/model"
-require_relative "igniter/compiler"
-require_relative "igniter/events"
-require_relative "igniter/runtime"
-require_relative "igniter/dsl"
-require_relative "igniter/extensions"
-require_relative "igniter/diagnostics"
-require_relative "igniter/contract"
+require "igniter/contracts"
+require "igniter/embed"
+require "igniter/application"
+require "igniter/ai"
+require "igniter/agents"
+require "igniter/hub"
 
 module Igniter
   class << self
-    def executor_registry
-      @executor_registry ||= ExecutorRegistry.new
+    def build_kernel(*packs)
+      Contracts.build_kernel(*packs)
     end
 
-    def execution_store
-      @execution_store ||= Runtime::Stores::MemoryStore.new
+    def build_profile(*packs)
+      Contracts.build_profile(*packs)
     end
 
-    def execution_store=(store)
-      @execution_store = store
+    def with(*packs)
+      Contracts.with(*packs)
     end
 
-    # TTL cache backend for compute nodes. nil = disabled (default).
-    # Set to Igniter::NodeCache::Memory.new (or a Redis-backed equivalent).
-    def node_cache
-      defined?(Igniter::NodeCache) ? Igniter::NodeCache.cache : nil
+    def compile(...)
+      Contracts.compile(...)
     end
 
-    def node_cache=(cache)
-      require_relative "igniter/node_cache"
-      Igniter::NodeCache.cache = cache
+    def validation_report(...)
+      Contracts.validation_report(...)
     end
 
-    # When true, auto-creates a CoalescingLock alongside the configured node cache.
-    def node_coalescing=(enabled)
-      require_relative "igniter/node_cache"
-      Igniter::NodeCache.coalescing_lock = enabled ? Igniter::NodeCache::CoalescingLock.new : nil
+    def compilation_report(...)
+      Contracts.compilation_report(...)
     end
 
-    def register_executor(key, executor_class, **metadata)
-      executor_registry.register(key, executor_class, **metadata)
+    def execute(...)
+      Contracts.execute(...)
     end
 
-    def effect_registry
-      @effect_registry ||= EffectRegistry.new
+    def embed(...)
+      Embed.configure(...)
     end
 
-    def register_effect(key, adapter_class, **metadata)
-      effect_registry.register(key, adapter_class, **metadata)
+    def execute_with(...)
+      Contracts.execute_with(...)
     end
 
-    def compile(&block)
-      DSL::ContractBuilder.compile(&block)
+    def diagnose(...)
+      Contracts.diagnose(...)
     end
 
-    def compile_schema(schema, name: nil)
-      DSL::SchemaBuilder.compile(schema, name: name)
+    def apply_effect(...)
+      Contracts.apply_effect(...)
     end
 
-    def configure
-      yield self
+    def build_application_kernel(*packs)
+      Application.build_kernel(*packs)
+    end
+
+    def build_application_profile(*packs)
+      Application.build_profile(*packs)
+    end
+
+    def application(*packs)
+      Application.with(*packs)
+    end
+
+    def ai_client(...)
+      AI.client(...)
+    end
+
+    def agent(...)
+      Agents.agent(...)
+    end
+
+    def hub_catalog(...)
+      Hub.local_catalog(...)
     end
   end
 end

data/packages/igniter-agents/README.md

@@ -0,0 +1,44 @@
+# igniter-agents
+
+Minimal agent runtime state for Igniter.
+
+Status: first package slice, not stable API.
+
+## Owns
+
+- agent definitions
+- agent runs, turns, and trace events
+- single-turn assistant execution over `igniter-ai`
+- serializable run state for app/web rendering
+
+## Does Not Own
+
+- provider-specific HTTP clients
+- application boot/configuration
+- web rendering
+- distributed scheduling
+
+## Example
+
+```ruby
+require "igniter-agents"
+
+client = Igniter::AI.client(
+  provider: Igniter::AI::Providers::Fake.new(text: "Close one reminder.")
+)
+
+agent = Igniter::Agents.agent(
+  :daily_companion,
+  model: "fake",
+  instructions: "Give one practical next action."
+)
+
+run = Igniter::Agents.run(agent, ai_client: client, input: "Two reminders are open.")
+
+run.success?          # true
+run.turns.first.text  # "Close one reminder."
+run.to_h              # serializable state for apps and web
+```
+
+Future slices should add contracts-first tool calls, memory, handoff, and human
+gates without moving provider or web concerns into this package.

data/packages/igniter-agents/lib/igniter/agents/agent_definition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Agents
+    AgentDefinition = Struct.new(:name, :model, :instructions, :metadata, keyword_init: true) do
+      def initialize(name, model:, instructions: nil, metadata: {})
+        super(
+          name: name.to_sym,
+          model: model.to_s,
+          instructions: instructions&.to_s,
+          metadata: metadata.transform_keys(&:to_sym).freeze
+        )
+        freeze
+      end
+
+      def to_h
+        {
+          name: name,
+          model: model,
+          instructions: instructions,
+          metadata: metadata
+        }.compact
+      end
+    end
+  end
+end

data/packages/igniter-agents/lib/igniter/agents/agent_run.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Agents
+    AgentRun = Struct.new(
+      :id, :agent_name, :status, :input, :context, :turns, :trace, :metadata, :error,
+      keyword_init: true
+    ) do
+      def initialize(id:, agent_name:, status:, input:, context: {}, turns: [], trace: [], metadata: {}, error: nil)
+        super(
+          id: id.to_s,
+          agent_name: agent_name.to_sym,
+          status: status.to_sym,
+          input: input.to_s,
+          context: context.transform_keys(&:to_sym).freeze,
+          turns: turns.freeze,
+          trace: trace.freeze,
+          metadata: metadata.transform_keys(&:to_sym).freeze,
+          error: error
+        )
+        freeze
+      end
+
+      def success?
+        status == :succeeded
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def to_h
+        {
+          id: id,
+          agent_name: agent_name,
+          status: status,
+          input: input,
+          context: context,
+          turns: turns.map(&:to_h),
+          trace: trace.map(&:to_h),
+          metadata: metadata,
+          error: error
+        }
+      end
+    end
+  end
+end

data/packages/igniter-agents/lib/igniter/agents/agent_turn.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Agents
+    AgentTurn = Struct.new(:index, :request, :response, :tool_calls, keyword_init: true) do
+      def initialize(index:, request:, response:, tool_calls: [])
+        super(
+          index: Integer(index),
+          request: request,
+          response: response,
+          tool_calls: tool_calls.freeze
+        )
+        freeze
+      end
+
+      def text
+        response.text
+      end
+
+      def success?
+        response.success?
+      end
+
+      def to_h
+        {
+          index: index,
+          request: request.to_h,
+          response: response.to_h,
+          tool_calls: tool_calls.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/packages/igniter-agents/lib/igniter/agents/runner.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Agents
+    class Runner
+      attr_reader :ai_client, :clock
+
+      def initialize(ai_client:, clock: Time)
+        @ai_client = ai_client
+        @clock = clock
+      end
+
+      def run(definition, input:, context: {}, metadata: {}, id: nil)
+        run_id = id || "agent-run-#{SecureRandom.hex(8)}"
+        started_at = timestamp
+        request = Igniter::AI.request(
+          model: definition.model,
+          instructions: definition.instructions,
+          input: input,
+          metadata: metadata.merge(agent: definition.name, run_id: run_id)
+        )
+        response = ai_client.complete(request)
+        finished_at = timestamp
+
+        AgentRun.new(
+          id: run_id,
+          agent_name: definition.name,
+          status: response.success? ? :succeeded : :failed,
+          input: input,
+          context: context,
+          turns: [AgentTurn.new(index: 0, request: request, response: response)],
+          trace: trace_for(started_at, finished_at, response),
+          metadata: metadata.merge(started_at: started_at, finished_at: finished_at),
+          error: response.error
+        )
+      end
+
+      private
+
+      def trace_for(started_at, finished_at, response)
+        [
+          TraceEvent.new(type: :agent_started, at: started_at),
+          TraceEvent.new(
+            type: response.success? ? :agent_succeeded : :agent_failed,
+            at: finished_at,
+            data: { error: response.error }.compact
+          )
+        ]
+      end
+
+      def timestamp
+        clock.now.utc.iso8601
+      end
+    end
+  end
+end