igniter 0.5.1 → 0.5.2

data/packages/igniter-application/lib/igniter/application/feature_slice.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class FeatureSlice
+      attr_reader :name, :groups, :paths, :contracts, :services, :interfaces,
+                  :exports, :imports, :flows, :surfaces, :metadata
+
+      def initialize(name:, groups: [], paths: {}, contracts: [], services: [], interfaces: [],
+                     exports: [], imports: [], flows: [], surfaces: [], metadata: {})
+        @name = name.to_sym
+        @groups = Array(groups).map(&:to_sym).uniq.sort.freeze
+        @paths = symbolize_paths(paths).freeze
+        @contracts = Array(contracts).map(&:to_s).freeze
+        @services = Array(services).map(&:to_sym).freeze
+        @interfaces = Array(interfaces).map(&:to_sym).freeze
+        @exports = Array(exports).map(&:to_sym).freeze
+        @imports = Array(imports).map(&:to_sym).freeze
+        @flows = Array(flows).map(&:to_sym).freeze
+        @surfaces = Array(surfaces).map(&:to_sym).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.from(value)
+        return value if value.is_a?(self)
+
+        new(**symbolize_keys(value))
+      end
+
+      def to_h
+        {
+          name: name,
+          groups: groups.dup,
+          paths: paths.dup,
+          contracts: contracts.dup,
+          services: services.dup,
+          interfaces: interfaces.dup,
+          exports: exports.dup,
+          imports: imports.dup,
+          flows: flows.dup,
+          surfaces: surfaces.dup,
+          metadata: metadata.dup
+        }
+      end
+
+      def self.symbolize_keys(value)
+        value.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+      private_class_method :symbolize_keys
+
+      private
+
+      def symbolize_paths(value)
+        value.to_h.each_with_object({}) do |(key, path), result|
+          result[key.to_sym] = path.to_s
+        end
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/feature_slice_report.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class FeatureSliceReport
+      attr_reader :application_name, :root, :layout_profile, :slices, :metadata
+
+      def initialize(application_name:, root:, layout_profile:, slices: [], metadata: {})
+        @application_name = application_name.to_sym
+        @root = File.expand_path(root.to_s)
+        @layout_profile = layout_profile.to_sym
+        @slices = Array(slices).map { |entry| FeatureSlice.from(entry) }.freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.for_blueprint(blueprint, metadata: {})
+        new(
+          application_name: blueprint.name,
+          root: blueprint.root,
+          layout_profile: blueprint.layout_profile,
+          slices: blueprint.feature_slices,
+          metadata: metadata
+        )
+      end
+
+      def empty?
+        slices.empty?
+      end
+
+      def to_h
+        {
+          application_name: application_name,
+          root: root,
+          layout_profile: layout_profile,
+          slice_count: slices.length,
+          slices: slices.map(&:to_h),
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/file_backed_host_activation_ledger_adapter.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module Igniter
+  module Application
+    class FileBackedHostActivationLedgerAdapter
+      SUPPORTED_OPERATION_TYPES = %i[
+        confirm_load_path
+        confirm_provider
+        confirm_contract
+        confirm_lifecycle
+      ].freeze
+
+      attr_reader :root, :name, :kind
+
+      def self.build(root:, name: :file_backed_host_activation_ledger)
+        new(root: root, name: name)
+      end
+
+      def initialize(root:, name: :file_backed_host_activation_ledger)
+        @root = File.expand_path(root.to_s)
+        @name = name.to_sym
+        @kind = :application_host_adapter
+        freeze
+      end
+
+      def to_h
+        {
+          name: name,
+          kind: kind,
+          adapter_fingerprint: adapter_fingerprint,
+          supported_operation_types: SUPPORTED_OPERATION_TYPES,
+          dry_run_compatible: true,
+          readback_supported: true,
+          root: root
+        }
+      end
+
+      def supports?(operation_type)
+        SUPPORTED_OPERATION_TYPES.include?(operation_type.to_sym)
+      end
+
+      def acknowledge(packet_id:, operation:, operation_digest:, idempotency_key:, caller_metadata: {})
+        conflict = readback(idempotency_key: idempotency_key).find do |record|
+          value(record, :operation_digest) != operation_digest
+        end
+        return conflicting_idempotency_key(conflict) if conflict
+
+        existing = readback(idempotency_key: idempotency_key, operation_digest: operation_digest).find do |record|
+          value(value(record, :operation), :operation_key) == operation_key(operation)
+        end
+        return { status: :acknowledged, duplicate: true, record: existing } if existing
+
+        FileUtils.mkdir_p(ledger_dir)
+        record = {
+          receipt_id: receipt_id(idempotency_key, operation_digest, operation),
+          packet_id: packet_id,
+          operation_digest: operation_digest,
+          idempotency_key: idempotency_key,
+          operation: normalize_hash(operation).merge(operation_key: operation_key(operation)),
+          adapter: to_h,
+          caller_metadata: normalize_hash(caller_metadata),
+          acknowledged_at: Time.now.utc.iso8601
+        }
+        File.write(record_path(idempotency_key, operation), "#{JSON.pretty_generate(record)}\n")
+        { status: :acknowledged, duplicate: false, record: record }
+      end
+
+      def readback(idempotency_key:, operation_digest: nil)
+        pattern = File.join(ledger_dir, "#{safe_key(idempotency_key)}--*.json")
+        Dir.glob(pattern).sort.filter_map do |path|
+          record = normalize_hash(JSON.parse(File.read(path)))
+          next if operation_digest && value(record, :operation_digest) != operation_digest
+
+          record
+        end
+      end
+
+      private
+
+      def conflicting_idempotency_key(existing)
+        {
+          status: :refused,
+          duplicate: true,
+          refusal: {
+            code: :idempotency_key_reused,
+            message: "Idempotency key was already used with a different operation digest.",
+            entry: existing
+          }
+        }
+      end
+
+      def ledger_dir
+        File.join(root, "activation-ledger")
+      end
+
+      def record_path(idempotency_key, operation)
+        File.join(ledger_dir, "#{safe_key(idempotency_key)}--#{safe_key(operation_key(operation))}.json")
+      end
+
+      def safe_key(value)
+        value.to_s.gsub(/[^a-zA-Z0-9_.-]/, "_")
+      end
+
+      def receipt_id(idempotency_key, operation_digest, operation)
+        type = value(operation, :type) || "operation"
+        "activation-ledger:#{safe_key(idempotency_key)}:#{safe_key(operation_digest)}:#{safe_key(type)}:#{safe_key(operation_key(operation))}"
+      end
+
+      def operation_key(operation)
+        [
+          value(operation, :type),
+          value(operation, :destination),
+          value(operation, :source)
+        ].join(":")
+      end
+
+      def adapter_fingerprint
+        "file-backed-host-activation-ledger:v1"
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : {}
+        source.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def value(hash, key)
+        return nil unless hash.respond_to?(:key?)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/file_backed_installed_capsule_registry.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module Igniter
+  module Application
+    class FileBackedInstalledCapsuleRegistry
+      attr_reader :root
+
+      def self.build(root:)
+        new(root: root)
+      end
+
+      def initialize(root:)
+        @root = File.expand_path(root.to_s)
+        freeze
+      end
+
+      def record(name, receipt:, source: nil, version: nil, metadata: {})
+        installed_at = Time.now.utc.iso8601
+        entry = InstalledCapsuleEntry.new(
+          name: name,
+          receipt: receipt,
+          source: source,
+          version: version,
+          metadata: metadata,
+          installed_at: installed_at
+        )
+        FileUtils.mkdir_p(registry_dir)
+        File.write(entry_path(name), "#{JSON.pretty_generate(entry.to_h)}\n")
+        append_history(entry, installed_at: installed_at)
+        entry
+      end
+
+      def entries
+        Dir.glob(File.join(registry_dir, "*.json")).sort.map do |path|
+          payload = JSON.parse(File.read(path), symbolize_names: true)
+          InstalledCapsuleEntry.new(
+            name: payload.fetch(:name),
+            receipt: payload.fetch(:receipt),
+            source: payload[:source],
+            version: payload[:version],
+            metadata: payload.fetch(:metadata, {}),
+            installed_at: payload[:installed_at]
+          )
+        end.freeze
+      end
+
+      def fetch(name)
+        entries.find { |entry| entry.name == name.to_sym } || raise(KeyError, "unknown installed capsule #{name.inspect}")
+      end
+
+      def installed?(name)
+        fetch(name).installed?
+      rescue KeyError
+        false
+      end
+
+      def history(name = nil)
+        paths = if name
+                  Dir.glob(File.join(history_dir, "#{safe_key(name)}--*.json"))
+                else
+                  Dir.glob(File.join(history_dir, "*.json"))
+                end
+        paths.sort.map do |path|
+          JSON.parse(File.read(path), symbolize_names: true)
+        end.freeze
+      end
+
+      def to_h
+        {
+          root: root,
+          entries: entries.map(&:to_h),
+          history_count: history.length
+        }
+      end
+
+      private
+
+      def registry_dir
+        File.join(root, "installed-capsules")
+      end
+
+      def entry_path(name)
+        File.join(registry_dir, "#{safe_key(name)}.json")
+      end
+
+      def append_history(entry, installed_at:)
+        FileUtils.mkdir_p(history_dir)
+        sequence = next_history_sequence(entry.name)
+        event = {
+          event_id: history_event_id(entry, sequence),
+          event_type: :installed_capsule_recorded,
+          capsule: entry.name,
+          sequence: sequence,
+          status: entry.status,
+          source: entry.source,
+          version: entry.version,
+          complete: entry.complete,
+          valid: entry.valid,
+          committed: entry.committed,
+          receipt: entry.receipt,
+          metadata: entry.metadata,
+          recorded_at: installed_at
+        }.compact
+        File.write(history_path(entry, sequence), "#{JSON.pretty_generate(event)}\n")
+      end
+
+      def history_dir
+        File.join(root, "installed-capsule-history")
+      end
+
+      def history_path(entry, sequence)
+        File.join(history_dir, "#{safe_key(entry.name)}--#{sequence.to_s.rjust(6, "0")}.json")
+      end
+
+      def history_event_id(entry, sequence)
+        "installed-capsule:#{safe_key(entry.name)}:#{sequence}"
+      end
+
+      def next_history_sequence(name)
+        history(name).map { |event| event.fetch(:sequence, 0).to_i }.max.to_i + 1
+      end
+
+      def safe_key(value)
+        value.to_s.gsub(/[^a-zA-Z0-9_.-]/, "_")
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/flow_declaration.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class FlowDeclaration
+      attr_reader :name, :purpose, :initial_status, :current_step, :pending_inputs,
+                  :pending_actions, :artifacts, :contracts, :services, :interfaces,
+                  :surfaces, :exports, :imports, :metadata
+
+      def initialize(name:, purpose: nil, initial_status: :active, current_step: nil,
+                     pending_inputs: [], pending_actions: [], artifacts: [],
+                     contracts: [], services: [], interfaces: [], surfaces: [],
+                     exports: [], imports: [], metadata: {})
+        @name = name.to_sym
+        @purpose = purpose&.to_s
+        @initial_status = initial_status.to_sym
+        @current_step = current_step&.to_sym
+        @pending_inputs = Array(pending_inputs).map { |entry| PendingInput.from(entry) }.freeze
+        @pending_actions = Array(pending_actions).map { |entry| PendingAction.from(entry) }.freeze
+        @artifacts = Array(artifacts).map { |entry| ArtifactReference.from(entry) }.freeze
+        @contracts = Array(contracts).map(&:to_s).freeze
+        @services = Array(services).map(&:to_sym).freeze
+        @interfaces = Array(interfaces).map(&:to_sym).freeze
+        @surfaces = Array(surfaces).map(&:to_sym).freeze
+        @exports = Array(exports).map(&:to_sym).freeze
+        @imports = Array(imports).map(&:to_sym).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.from(value)
+        return value if value.is_a?(self)
+
+        new(**symbolize_keys(value))
+      end
+
+      def to_h
+        {
+          name: name,
+          purpose: purpose,
+          initial_status: initial_status,
+          current_step: current_step,
+          pending_inputs: pending_inputs.map(&:to_h),
+          pending_actions: pending_actions.map(&:to_h),
+          artifacts: artifacts.map(&:to_h),
+          contracts: contracts.dup,
+          services: services.dup,
+          interfaces: interfaces.dup,
+          surfaces: surfaces.dup,
+          exports: exports.dup,
+          imports: imports.dup,
+          metadata: metadata.dup
+        }
+      end
+
+      def self.symbolize_keys(value)
+        value.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+      private_class_method :symbolize_keys
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/flow_event.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Igniter
+  module Application
+    class FlowEvent
+      attr_reader :id, :session_id, :type, :source, :target, :payload, :timestamp, :metadata
+
+      def initialize(type:, session_id:, source: :system, target: nil, payload: {}, id: nil,
+                     timestamp: Time.now.utc, metadata: {})
+        @id = (id || SecureRandom.uuid).to_s
+        @session_id = session_id.to_s
+        @type = type.to_sym
+        @source = source.to_sym
+        @target = target&.to_sym
+        @payload = payload.dup.freeze
+        @timestamp = timestamp.is_a?(String) ? Time.parse(timestamp).utc : timestamp.utc
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.from(value, session_id:)
+        return value if value.is_a?(self)
+
+        value = symbolize_keys(value)
+        new(**value.merge(session_id: value.fetch(:session_id, session_id)))
+      end
+
+      def to_h
+        {
+          id: id,
+          session_id: session_id,
+          type: type,
+          source: source,
+          target: target,
+          payload: payload.dup,
+          timestamp: timestamp.iso8601,
+          metadata: metadata.dup
+        }
+      end
+
+      def self.symbolize_keys(value)
+        value.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+      private_class_method :symbolize_keys
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/flow_session_snapshot.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Application
+    class FlowSessionSnapshot
+      attr_reader :session_id, :flow_name, :status, :current_step, :pending_inputs,
+                  :pending_actions, :events, :artifacts, :metadata, :created_at, :updated_at
+
+      def initialize(session_id:, flow_name:, status: :active, current_step: nil, pending_inputs: [],
+                     pending_actions: [], events: [], artifacts: [], metadata: {},
+                     created_at: Time.now.utc, updated_at: created_at)
+        @session_id = session_id.to_s
+        @flow_name = flow_name.to_sym
+        @status = status.to_sym
+        @current_step = current_step&.to_sym
+        @pending_inputs = Array(pending_inputs).map { |entry| PendingInput.from(entry) }.freeze
+        @pending_actions = Array(pending_actions).map { |entry| PendingAction.from(entry) }.freeze
+        @events = Array(events).map { |entry| FlowEvent.from(entry, session_id: @session_id) }.freeze
+        @artifacts = Array(artifacts).map { |entry| ArtifactReference.from(entry) }.freeze
+        @metadata = metadata.dup.freeze
+        @created_at = normalize_time(created_at)
+        @updated_at = normalize_time(updated_at)
+        freeze
+      end
+
+      def self.from_h(value)
+        value = symbolize_keys(value)
+        new(
+          session_id: value.fetch(:session_id),
+          flow_name: value.fetch(:flow_name),
+          status: value.fetch(:status),
+          current_step: value[:current_step],
+          pending_inputs: value.fetch(:pending_inputs, []),
+          pending_actions: value.fetch(:pending_actions, []),
+          events: value.fetch(:events, []),
+          artifacts: value.fetch(:artifacts, []),
+          metadata: value.fetch(:metadata, {}),
+          created_at: value.fetch(:created_at),
+          updated_at: value.fetch(:updated_at)
+        )
+      end
+
+      def self.from_entry(entry)
+        raise ArgumentError, "session #{entry.id.inspect} is not a flow session" unless entry.kind == :flow
+
+        from_h(entry.payload)
+      end
+
+      def with_event(event, status: self.status, current_step: self.current_step,
+                     pending_inputs: self.pending_inputs, pending_actions: self.pending_actions,
+                     artifacts: self.artifacts, metadata: self.metadata,
+                     updated_at: Time.now.utc)
+        self.class.new(
+          session_id: session_id,
+          flow_name: flow_name,
+          status: status,
+          current_step: current_step,
+          pending_inputs: pending_inputs,
+          pending_actions: pending_actions,
+          events: events + [event],
+          artifacts: artifacts,
+          metadata: metadata,
+          created_at: created_at,
+          updated_at: updated_at
+        )
+      end
+
+      def to_h
+        {
+          session_id: session_id,
+          flow_name: flow_name,
+          status: status,
+          current_step: current_step,
+          pending_inputs: pending_inputs.map(&:to_h),
+          pending_actions: pending_actions.map(&:to_h),
+          events: events.map(&:to_h),
+          artifacts: artifacts.map(&:to_h),
+          metadata: metadata.dup,
+          created_at: created_at.iso8601,
+          updated_at: updated_at.iso8601
+        }
+      end
+
+      private
+
+      def self.symbolize_keys(value)
+        value.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+      private_class_method :symbolize_keys
+
+      def normalize_time(value)
+        value.is_a?(String) ? Time.parse(value).utc : value.utc
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/installed_capsule_entry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    InstalledCapsuleEntry = Struct.new(
+      :name, :status, :source, :version, :complete, :valid, :committed,
+      :receipt, :metadata, :installed_at,
+      keyword_init: true
+    ) do
+      def initialize(name:, receipt:, source: nil, version: nil, metadata: {}, installed_at: nil)
+        receipt_payload = receipt.to_h
+        super(
+          name: name.to_sym,
+          status: receipt_payload.fetch(:complete, false) ? :installed : :blocked,
+          source: source,
+          version: version,
+          complete: receipt_payload.fetch(:complete, false),
+          valid: receipt_payload.fetch(:valid, false),
+          committed: receipt_payload.fetch(:committed, false),
+          receipt: receipt_payload.freeze,
+          metadata: metadata.dup.freeze,
+          installed_at: installed_at
+        )
+        freeze
+      end
+
+      def installed?
+        status == :installed
+      end
+
+      def to_h
+        {
+          name: name,
+          status: status,
+          source: source,
+          version: version,
+          complete: complete,
+          valid: valid,
+          committed: committed,
+          receipt: receipt,
+          metadata: metadata.dup,
+          installed_at: installed_at
+        }.compact
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/interface.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class Interface < ServiceDefinition
+      def initialize(name:, callable:, metadata: {}, source: :application)
+        super(name: name, callable: callable, metadata: metadata, source: source)
+      end
+    end
+  end
+end