igniter 0.5.1 → 0.5.2

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationHostActivationReadiness
+      attr_reader :receipt_payload, :handoff_payload, :host_exports, :host_capabilities,
+                  :manual_decisions, :load_paths, :providers, :contracts,
+                  :lifecycle, :mount_decisions, :surface_metadata, :metadata
+
+      def self.build(transfer_receipt, handoff_manifest: nil, host_exports: [], host_capabilities: [],
+                     manual_actions: [], load_paths: [], providers: [], contracts: [], lifecycle: {},
+                     mount_decisions: [], surface_metadata: [], metadata: {})
+        new(
+          transfer_receipt: transfer_receipt,
+          handoff_manifest: handoff_manifest,
+          host_exports: host_exports,
+          host_capabilities: host_capabilities,
+          manual_actions: manual_actions,
+          load_paths: load_paths,
+          providers: providers,
+          contracts: contracts,
+          lifecycle: lifecycle,
+          mount_decisions: mount_decisions,
+          surface_metadata: surface_metadata,
+          metadata: metadata
+        )
+      end
+
+      def initialize(transfer_receipt:, handoff_manifest: nil, host_exports: [], host_capabilities: [],
+                     manual_actions: [], load_paths: [], providers: [], contracts: [], lifecycle: {},
+                     mount_decisions: [], surface_metadata: [], metadata: {})
+        @receipt_payload = payload_from(transfer_receipt)
+        @handoff_payload = handoff_manifest ? payload_from(handoff_manifest) : nil
+        @host_exports = Array(host_exports).map { |entry| normalize_hash(entry) }.freeze
+        @host_capabilities = Array(host_capabilities).map { |entry| normalize_scalar(entry) }.freeze
+        @manual_decisions = Array(manual_actions).map { |entry| normalize_hash(entry) }.freeze
+        @load_paths = Array(load_paths).map { |entry| normalize_scalar(entry) }.freeze
+        @providers = Array(providers).map { |entry| normalize_scalar(entry) }.freeze
+        @contracts = Array(contracts).map { |entry| normalize_scalar(entry) }.freeze
+        @lifecycle = normalize_hash(lifecycle).freeze
+        @mount_decisions = Array(mount_decisions).map { |entry| normalize_hash(entry) }.freeze
+        @surface_metadata = Array(surface_metadata).map { |entry| normalize_hash(entry) }.freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def ready?
+        blockers.empty?
+      end
+
+      def to_h
+        {
+          ready: ready?,
+          blockers: blockers,
+          warnings: warnings,
+          decisions: decisions,
+          manual_actions: required_manual_actions,
+          mount_intents: mount_intents,
+          surface_count: surface_count,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def blockers
+        [].tap do |items|
+          items << blocker(:transfer_receipt_incomplete, "Transfer receipt is not complete.", receipt_payload) unless
+            value(receipt_payload, :complete) == true
+          required_host_wiring.each do |entry|
+            items << blocker(:missing_host_export, "Required host export decision is missing.", entry) unless
+              host_export_satisfied?(entry)
+            missing_capabilities(entry).each do |capability|
+              items << blocker(
+                :missing_host_capability,
+                "Required host capability decision is missing.",
+                entry.merge(capability: capability)
+              )
+            end
+          end
+          unresolved_manual_actions.each do |entry|
+            items << blocker(:manual_action_unresolved, "Manual host action is not resolved.", entry)
+          end
+        end
+      end
+
+      def warnings
+        [].tap do |items|
+          items << warning(:handoff_manifest_missing, "Handoff manifest was not supplied.") unless handoff_payload
+          items << warning(:load_paths_unconfirmed, "Host load path decision was not supplied.") if load_paths.empty?
+          items << warning(:providers_unconfirmed, "Host provider decision was not supplied.") if providers.empty?
+          items << warning(:contracts_unconfirmed, "Host contract registration decision was not supplied.") if contracts.empty?
+          items << warning(:lifecycle_unconfirmed, "Host lifecycle decision was not supplied.") if lifecycle.empty?
+          unconfirmed_mount_intents.each do |entry|
+            items << warning(:mount_intent_unconfirmed, "Mount intent remains a host review decision.", entry)
+          end
+        end
+      end
+
+      def decisions
+        {
+          host_exports: host_exports.map(&:dup),
+          host_capabilities: host_capabilities.dup,
+          manual_actions: manual_decisions.map(&:dup),
+          load_paths: load_paths.dup,
+          providers: providers.dup,
+          contracts: contracts.dup,
+          lifecycle: lifecycle.dup,
+          mount_decisions: mount_decisions.map(&:dup)
+        }
+      end
+
+      def required_host_wiring
+        return [] unless handoff_payload
+
+        Array(value(handoff_payload, :suggested_host_wiring)).map { |entry| normalize_hash(entry) }
+      end
+
+      def required_manual_actions
+        Array(value(receipt_payload, :manual_actions)).map { |entry| normalize_hash(entry) }
+      end
+
+      def unresolved_manual_actions
+        required_manual_actions.reject { |entry| manual_action_resolved?(entry) }
+      end
+
+      def manual_action_resolved?(entry)
+        manual_decisions.any? do |decision|
+          same_name?(decision, entry) && resolved_status?(value(decision, :status))
+        end
+      end
+
+      def host_export_satisfied?(entry)
+        host_exports.any? do |host_export|
+          same_name?(host_export, entry) && compatible_kind?(host_export, entry)
+        end
+      end
+
+      def missing_capabilities(entry)
+        Array(value(entry, :capabilities)).reject do |capability|
+          host_capabilities.any? { |host_capability| comparable(host_capability) == comparable(capability) }
+        end
+      end
+
+      def mount_intents
+        return [] unless handoff_payload
+
+        Array(value(handoff_payload, :mount_intents)).map { |entry| normalize_hash(entry) }
+      end
+
+      def unconfirmed_mount_intents
+        mount_intents.reject do |entry|
+          mount_decisions.any? { |decision| same_mount?(decision, entry) && resolved_status?(value(decision, :status)) }
+        end
+      end
+
+      def surface_count
+        supplied_surface_count = surface_metadata.length
+        handoff_surface_count = handoff_payload ? Array(value(handoff_payload, :surfaces)).length : 0
+        receipt_surface_count = value(receipt_payload, :surface_count).to_i
+        [supplied_surface_count, handoff_surface_count, receipt_surface_count].max
+      end
+
+      def same_name?(left, right)
+        comparable(value(left, :name)) == comparable(value(right, :name))
+      end
+
+      def compatible_kind?(left, right)
+        expected = value(right, :kind)
+        actual = value(left, :kind)
+        expected.nil? || actual.nil? || comparable(actual) == comparable(expected)
+      end
+
+      def same_mount?(left, right)
+        comparable(value(left, :capsule)) == comparable(value(right, :capsule)) &&
+          comparable(value(left, :kind)) == comparable(value(right, :kind)) &&
+          value(left, :at).to_s == value(right, :at).to_s
+      end
+
+      def resolved_status?(status)
+        %i[accepted complete completed wired provided ready].include?(status.respond_to?(:to_sym) ? status.to_sym : status)
+      end
+
+      def blocker(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+
+      def warning(code, message, entry = nil)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }.compact
+      end
+
+      def payload_from(source)
+        payload = source.respond_to?(:to_h) ? source.to_h : source
+        payload.to_h
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : value
+        source.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def normalize_scalar(value)
+        value
+      end
+
+      def comparable(value)
+        value.to_s
+      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/application_host_activation_receipt.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Application
+    class ApplicationHostActivationReceipt
+      SCHEMA_VERSION = "activation-receipt-v1"
+
+      attr_reader :verification, :packet, :commit_result, :metadata
+
+      def self.build(verification, evidence_packet:, commit_result:, metadata: {})
+        new(
+          verification: verification,
+          evidence_packet: evidence_packet,
+          commit_result: commit_result,
+          metadata: metadata
+        )
+      end
+
+      def initialize(verification:, evidence_packet:, commit_result:, metadata: {})
+        @verification = normalize_hash(verification.respond_to?(:to_h) ? verification.to_h : verification).freeze
+        @packet = normalize_hash(evidence_packet).freeze
+        @commit_result = normalize_hash(commit_result.respond_to?(:to_h) ? commit_result.to_h : commit_result).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def valid?
+        value(verification, :valid) == true
+      end
+
+      def complete?
+        valid? && value(verification, :complete) == true && committed?
+      end
+
+      def committed?
+        value(verification, :committed) == true && value(commit_result, :committed) == true
+      end
+
+      def to_h
+        {
+          activation_receipt_id: activation_receipt_id,
+          schema_version: SCHEMA_VERSION,
+          transfer_receipt_id: value(packet, :transfer_receipt_id),
+          packet_id: value(packet, :packet_id),
+          result_id: value(commit_result, :result_id),
+          verification_id: value(verification, :verification_id),
+          complete: complete?,
+          valid: valid?,
+          committed: committed?,
+          operation_digest: value(packet, :operation_digest),
+          counts: counts,
+          manual_leftovers: manual_leftovers,
+          host_leftovers: host_leftovers,
+          web_leftovers: web_leftovers,
+          adapter_receipt_refs: adapter_receipt_refs,
+          audit_metadata: audit_metadata,
+          issued_at: Time.now.utc.iso8601,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def activation_receipt_id
+        "activation-receipt:#{value(packet, :transfer_receipt_id)}:#{value(packet, :packet_id)}"
+      end
+
+      def counts
+        verification_counts.merge(
+          applied: applied_operations.length,
+          skipped: skipped_operations.length,
+          adapter_receipts: adapter_receipt_refs.length,
+          manual_leftovers: manual_leftovers.length,
+          host_leftovers: host_leftovers.length,
+          web_leftovers: web_leftovers.length
+        )
+      end
+
+      def verification_counts
+        counts = value(verification, :counts)
+        counts.respond_to?(:to_h) ? normalize_hash(counts) : {}
+      end
+
+      def audit_metadata
+        {
+          receipt_kind: :activation_receipt,
+          transfer_receipt_id: value(packet, :transfer_receipt_id),
+          packet_id: value(packet, :packet_id),
+          result_id: value(commit_result, :result_id),
+          verification_id: value(verification, :verification_id),
+          separate_from_transfer_receipt: true,
+          metadata: metadata.dup
+        }
+      end
+
+      def adapter_receipt_refs
+        adapter_receipts.map do |record|
+          {
+            receipt_id: value(record, :receipt_id),
+            packet_id: value(record, :packet_id),
+            operation_digest: value(record, :operation_digest),
+            idempotency_key: value(record, :idempotency_key),
+            operation_key: value(normalize_hash(value(record, :operation)), :operation_key)
+          }
+        end
+      end
+
+      def manual_leftovers
+        skipped_by_reason(:manual_host_action)
+      end
+
+      def host_leftovers
+        skipped_by_reason(:host_owned_evidence)
+      end
+
+      def web_leftovers
+        skipped_by_reason(:web_or_host_owned_mount)
+      end
+
+      def skipped_by_reason(reason)
+        skipped_operations.select { |entry| value(entry, :reason).to_s == reason.to_s }
+      end
+
+      def applied_operations
+        Array(value(commit_result, :applied_operations)).map { |entry| normalize_hash(entry) }
+      end
+
+      def skipped_operations
+        Array(value(commit_result, :skipped_operations)).map { |entry| normalize_hash(entry) }
+      end
+
+      def adapter_receipts
+        Array(value(commit_result, :adapter_receipts)).map { |entry| normalize_hash(entry) }
+      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/application_layout.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationLayout
+      STANDALONE_PATHS = {
+        contracts: "app/contracts",
+        providers: "app/providers",
+        services: "app/services",
+        effects: "app/effects",
+        packs: "app/packs",
+        executors: "app/executors",
+        tools: "app/tools",
+        agents: "app/agents",
+        skills: "app/skills",
+        support: "app/support",
+        web: "app/web",
+        config: "config/igniter.rb",
+        spec: "spec/igniter"
+      }.freeze
+      CAPSULE_PATHS = {
+        contracts: "contracts",
+        providers: "providers",
+        services: "services",
+        effects: "effects",
+        packs: "packs",
+        executors: "executors",
+        tools: "tools",
+        agents: "agents",
+        skills: "skills",
+        support: "support",
+        web: "web",
+        config: "igniter.rb",
+        spec: "spec"
+      }.freeze
+      EXPANDED_CAPSULE_PATHS = STANDALONE_PATHS
+      PROFILE_PATHS = {
+        standalone: STANDALONE_PATHS,
+        capsule: CAPSULE_PATHS,
+        expanded_capsule: EXPANDED_CAPSULE_PATHS
+      }.freeze
+      DEFAULT_PATHS = STANDALONE_PATHS
+
+      attr_reader :root, :profile, :paths, :metadata
+
+      def initialize(root:, profile: :standalone, paths: {}, metadata: {})
+        @root = File.expand_path(root.to_s)
+        @profile = profile.to_sym
+        @paths = paths_for_profile(@profile).merge(symbolize_hash(paths)).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def path(name)
+        paths.fetch(name.to_sym)
+      end
+
+      def absolute_path(name)
+        File.expand_path(path(name), root)
+      end
+
+      def code_paths
+        paths.reject { |name, _path| %i[config spec].include?(name) }
+      end
+
+      def to_h
+        {
+          root: root,
+          profile: profile,
+          paths: paths.dup,
+          absolute_paths: paths.transform_values { |path| File.expand_path(path, root) },
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def symbolize_hash(value)
+        value.each_with_object({}) do |(key, entry), memo|
+          memo[key.to_sym] = Array(entry).first.to_s
+        end
+      end
+
+      def paths_for_profile(name)
+        PROFILE_PATHS.fetch(name) do
+          raise ArgumentError, "unknown application layout profile #{name.inspect}; expected one of: #{PROFILE_PATHS.keys.join(", ")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationLoadPath
+      attr_reader :group, :path, :absolute_path, :kind, :status, :metadata
+
+      def initialize(group:, path:, absolute_path:, kind:, status:, metadata: {})
+        @group = group.to_sym
+        @path = path.to_s.freeze
+        @absolute_path = absolute_path.to_s.freeze
+        @kind = kind.to_sym
+        @status = status.to_sym
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def present?
+        status == :present
+      end
+
+      def missing?
+        status == :missing
+      end
+
+      def to_h
+        {
+          group: group,
+          path: path,
+          absolute_path: absolute_path,
+          kind: kind,
+          status: status,
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationLoadReport
+      attr_reader :base_dir, :layout, :entries, :metadata
+
+      def self.inspect(base_dir:, layout:, paths:, metadata: {})
+        entries = paths.flat_map do |group, group_paths|
+          Array(group_paths).map do |path|
+            absolute_path = File.expand_path(path.to_s, base_dir.to_s)
+            ApplicationLoadPath.new(
+              group: group,
+              path: path,
+              absolute_path: absolute_path,
+              kind: path_kind(absolute_path),
+              status: File.exist?(absolute_path) ? :present : :missing,
+              metadata: {
+                layout_path: layout.paths[group.to_sym]
+              }.compact
+            )
+          end
+        end
+
+        new(base_dir: base_dir, layout: layout, entries: entries, metadata: metadata)
+      end
+
+      def self.path_kind(absolute_path)
+        return :directory if File.directory?(absolute_path)
+        return :file if File.file?(absolute_path)
+
+        :missing
+      end
+
+      def initialize(base_dir:, layout:, entries:, metadata: {})
+        @base_dir = File.expand_path(base_dir.to_s)
+        @layout = layout
+        @entries = Array(entries).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def present_entries
+        entries.select(&:present?)
+      end
+
+      def missing_entries
+        entries.select(&:missing?)
+      end
+
+      def present_groups
+        present_entries.map(&:group).uniq.sort
+      end
+
+      def missing_groups
+        missing_entries.map(&:group).uniq.sort
+      end
+
+      def to_h
+        {
+          base_dir: base_dir,
+          layout: layout.to_h,
+          entry_count: entries.length,
+          present_count: present_entries.length,
+          missing_count: missing_entries.length,
+          present_groups: present_groups,
+          missing_groups: missing_groups,
+          entries: entries.map(&:to_h),
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationManifest
+      attr_reader :name, :root, :env, :layout, :packs, :contracts, :providers,
+                  :services, :interfaces, :scheduled_jobs, :mounts, :config,
+                  :credentials, :metadata
+
+      def initialize(name:, root:, env:, layout:, packs: [], contracts: [], providers: [], services: [],
+                     interfaces: [], scheduled_jobs: [], mounts: [], config: {}, credentials: {}, metadata: {})
+        @name = name.to_sym
+        @root = File.expand_path(root.to_s)
+        @env = env.to_sym
+        @layout = layout
+        @packs = Array(packs).map(&:to_s).freeze
+        @contracts = Array(contracts).map(&:to_s).freeze
+        @providers = Array(providers).map(&:to_sym).freeze
+        @services = Array(services).map(&:to_sym).freeze
+        @interfaces = Array(interfaces).map(&:to_sym).freeze
+        @scheduled_jobs = Array(scheduled_jobs).map(&:to_sym).freeze
+        @mounts = Array(mounts).map(&:dup).freeze
+        @config = config.dup.freeze
+        @credentials = credentials.dup.freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def to_h
+        {
+          name: name,
+          root: root,
+          env: env,
+          layout: layout.to_h,
+          packs: packs.dup,
+          contracts: contracts.dup,
+          providers: providers.dup,
+          services: services.dup,
+          interfaces: interfaces.dup,
+          scheduled_jobs: scheduled_jobs.dup,
+          mounts: mounts.map(&:dup),
+          config: config.dup,
+          credentials: credentials.dup,
+          metadata: metadata.dup
+        }
+      end
+
+      def exports
+        Array(metadata[:exports]).map(&:dup)
+      end
+
+      def imports
+        Array(metadata[:imports]).map(&:dup)
+      end
+
+      def feature_slices
+        Array(metadata[:feature_slices]).map(&:dup)
+      end
+
+      def flow_declarations
+        Array(metadata[:flow_declarations]).map(&:dup)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Igniter
+  module Application
+    class ApplicationStructureEntry
+      attr_reader :group, :path, :absolute_path, :kind, :status, :action, :metadata
+
+      def initialize(group:, path:, absolute_path:, kind:, status:, action:, metadata: {})
+        @group = group.to_sym
+        @path = path.to_s.freeze
+        @absolute_path = absolute_path.to_s.freeze
+        @kind = kind.to_sym
+        @status = status.to_sym
+        @action = action.to_sym
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def present?
+        status == :present
+      end
+
+      def missing?
+        status == :missing
+      end
+
+      def apply!
+        case action
+        when :keep
+          false
+        when :create_directory
+          FileUtils.mkdir_p(absolute_path)
+          true
+        when :write_file
+          FileUtils.mkdir_p(File.dirname(absolute_path))
+          File.write(absolute_path, metadata.fetch(:default_content, ""))
+          true
+        else
+          raise ArgumentError, "unknown application structure action #{action.inspect}"
+        end
+      end
+
+      def to_h
+        {
+          group: group,
+          path: path,
+          absolute_path: absolute_path,
+          kind: kind,
+          status: status,
+          action: action,
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end