igniter-extensions 0.5.2

data/lib/igniter/extensions/contracts/language/formula_pack.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Language
+        module FormulaPack
+          module_function
+
+          def manifest
+            Igniter::Contracts::PackManifest.new(
+              name: :extensions_language_formula,
+              registry_contracts: [Igniter::Contracts::PackManifest.dsl_keyword(:formula)]
+            )
+          end
+
+          def install_into(kernel)
+            kernel.dsl_keywords.register(:formula, formula_keyword)
+            kernel
+          end
+
+          def formula_keyword
+            Igniter::Contracts::DslKeyword.new(:formula) do |name, builder:, trace: nil, &block|
+              raise ArgumentError, "formula :#{name} requires a block" unless block
+
+              trace_name = (trace || :"#{name}_trace").to_sym
+              definition = Definition.new(name: name)
+              definition.instance_eval(&block)
+              definition.validate!
+
+              builder.add_operation(
+                kind: :compute,
+                name: trace_name,
+                depends_on: definition.dependencies,
+                callable: lambda do |**values|
+                  definition.resolve(values)
+                end
+              )
+              builder.add_operation(
+                kind: :compute,
+                name: name,
+                depends_on: [trace_name],
+                callable: lambda do |**values|
+                  values.fetch(trace_name).fetch(:value)
+                end
+              )
+            end
+          end
+
+          class Definition
+            attr_reader :dependencies
+
+            def initialize(name:)
+              @name = name.to_sym
+              @steps = []
+              @dependencies = []
+              @has_start = false
+            end
+
+            def base(value)
+              raise ArgumentError, "formula :#{@name} can define base only once" if @has_start
+
+              @has_start = true
+              @steps << { operation: :base, value: Float(value) }
+            end
+
+            def from(name)
+              raise ArgumentError, "formula :#{@name} can define from only once" if @has_start
+
+              source_name = name.to_sym
+              @has_start = true
+              @dependencies << source_name
+              @steps << { operation: :from, source: source_name }
+            end
+
+            def add(value_or_source)
+              add_numeric_or_source_step(:add, value_or_source)
+            end
+
+            def subtract(value_or_source)
+              add_numeric_or_source_step(:subtract, value_or_source)
+            end
+
+            def multiply_by(value)
+              @steps << { operation: :multiply_by, value: Float(value) }
+            end
+
+            def divide_by(value)
+              raise ArgumentError, "formula :#{@name} divide_by cannot use zero" if Float(value).zero?
+
+              @steps << { operation: :divide_by, value: Float(value) }
+            end
+
+            def clamp(min, max)
+              minimum = Float(min)
+              maximum = Float(max)
+              raise ArgumentError, "formula :#{@name} clamp min cannot exceed max" if minimum > maximum
+
+              @steps << { operation: :clamp, min: minimum, max: maximum }
+            end
+
+            def round(precision = 0)
+              @steps << { operation: :round, precision: Integer(precision) }
+            end
+
+            def validate!
+              raise ArgumentError, "formula :#{@name} requires base or from" unless @has_start
+              raise ArgumentError, "formula :#{@name} requires at least one step" if @steps.empty?
+
+              @dependencies.uniq!
+            end
+
+            def resolve(values)
+              current = nil
+              trace = []
+
+              @steps.each do |step|
+                before = current
+                current = apply_step(current, step, values)
+                trace << step.merge(before: before, after: current)
+              end
+
+              {
+                value: current,
+                dependencies: dependencies,
+                steps: trace.freeze
+              }
+            rescue ArgumentError, TypeError
+              {
+                value: 0.0,
+                dependencies: dependencies,
+                error: :invalid_numeric_formula,
+                steps: trace.freeze
+              }
+            end
+
+            private
+
+            def add_numeric_or_source_step(operation, value_or_source)
+              if value_or_source.is_a?(Symbol)
+                @dependencies << value_or_source
+                @steps << { operation: operation, source: value_or_source }
+              else
+                @steps << { operation: operation, value: Float(value_or_source) }
+              end
+            end
+
+            def apply_step(current, step, values)
+              case step.fetch(:operation)
+              when :base
+                step.fetch(:value)
+              when :from
+                numeric_value(values.fetch(step.fetch(:source)))
+              when :add
+                current + operand(step, values)
+              when :subtract
+                current - operand(step, values)
+              when :multiply_by
+                current * step.fetch(:value)
+              when :divide_by
+                current / step.fetch(:value)
+              when :clamp
+                [[current, step.fetch(:min)].max, step.fetch(:max)].min
+              when :round
+                current.round(step.fetch(:precision))
+              else
+                current
+              end
+            end
+
+            def operand(step, values)
+              return numeric_value(values.fetch(step.fetch(:source))) if step.key?(:source)
+
+              step.fetch(:value)
+            end
+
+            def numeric_value(value)
+              Float(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/language/piecewise_pack.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Language
+        module PiecewisePack
+          UNSET = Object.new.freeze
+
+          module_function
+
+          def manifest
+            Igniter::Contracts::PackManifest.new(
+              name: :extensions_language_piecewise,
+              registry_contracts: [Igniter::Contracts::PackManifest.dsl_keyword(:piecewise)]
+            )
+          end
+
+          def install_into(kernel)
+            kernel.dsl_keywords.register(:piecewise, piecewise_keyword)
+            kernel
+          end
+
+          def piecewise_keyword
+            Igniter::Contracts::DslKeyword.new(:piecewise) do |name, on:, builder:, depends_on: [], decision: nil, &block|
+              raise ArgumentError, "piecewise :#{name} requires a block" unless block
+
+              selector_name = on.to_sym
+              decision_name = (decision || :"#{name}_decision").to_sym
+              dependency_names = [selector_name, *Array(depends_on).map(&:to_sym)].uniq
+              definition = Definition.new(name: name, selector_name: selector_name)
+              definition.instance_eval(&block)
+              definition.validate!
+
+              builder.add_operation(
+                kind: :compute,
+                name: decision_name,
+                depends_on: dependency_names,
+                callable: lambda do |**values|
+                  definition.resolve(values)
+                end
+              )
+              builder.add_operation(
+                kind: :compute,
+                name: name,
+                depends_on: [decision_name],
+                callable: lambda do |**values|
+                  values.fetch(decision_name).fetch(:value)
+                end
+              )
+            end
+          end
+
+          def invoke_value(callable_or_value, kwargs)
+            return callable_or_value unless callable_or_value.respond_to?(:call)
+
+            parameters = callable_or_value.parameters
+            accepts_any_keywords = parameters.any? { |kind, _name| kind == :keyrest }
+            return callable_or_value.call(**kwargs) if accepts_any_keywords
+
+            accepted = parameters.select { |kind, _name| %i[key keyreq].include?(kind) }.map(&:last)
+            callable_or_value.call(**kwargs.slice(*accepted))
+          end
+
+          class Definition
+            def initialize(name:, selector_name:)
+              @name = name.to_sym
+              @selector_name = selector_name.to_sym
+              @cases = []
+              @default_case = nil
+            end
+
+            def eq(match, id: nil, value: UNSET, &block)
+              add_case(:eq, match, id: id, value: value, block: block)
+            end
+
+            def between(range, id: nil, value: UNSET, &block)
+              raise ArgumentError, "piecewise :#{@name} between requires a Range" unless range.is_a?(Range)
+
+              add_case(:between, range, id: id, value: value, block: block)
+            end
+
+            def in(values, id: nil, value: UNSET, &block)
+              array = Array(values)
+              raise ArgumentError, "piecewise :#{@name} in requires a non-empty list" if array.empty?
+
+              add_case(:in, array.freeze, id: id, value: value, block: block)
+            end
+
+            def matches(pattern, id: nil, value: UNSET, &block)
+              raise ArgumentError, "piecewise :#{@name} matches requires a Regexp" unless pattern.is_a?(Regexp)
+
+              add_case(:matches, pattern, id: id, value: value, block: block)
+            end
+
+            def default(id: :default, value: UNSET, &block)
+              raise ArgumentError, "piecewise :#{@name} can define only one default" if @default_case
+
+              @default_case = case_payload(:default, :default, id: id, value: value, block: block)
+            end
+
+            def validate!
+              raise ArgumentError, "piecewise :#{@name} requires at least one case" if @cases.empty?
+              raise ArgumentError, "piecewise :#{@name} requires a default case" unless @default_case
+
+              duplicate_ids = (@cases.map { |entry| entry.fetch(:id) } + [@default_case.fetch(:id)])
+                              .group_by { |id| id }
+                              .select { |_id, group| group.length > 1 }
+                              .keys
+              return if duplicate_ids.empty?
+
+              raise ArgumentError, "piecewise :#{@name} has duplicate case ids: #{duplicate_ids.join(", ")}"
+            end
+
+            def resolve(kwargs)
+              selector_value = kwargs.fetch(@selector_name)
+              selected = @cases.find { |entry| match?(entry, selector_value) } || @default_case
+
+              {
+                case: selected.fetch(:id),
+                value: PiecewisePack.invoke_value(selected.fetch(:value), kwargs),
+                matcher: selected.fetch(:matcher),
+                matched_on: selected.fetch(:match),
+                selector: @selector_name,
+                selector_value: selector_value
+              }
+            end
+
+            private
+
+            def add_case(matcher, match, id:, value:, block:)
+              @cases << case_payload(matcher, match, id: id || :"case_#{@cases.length + 1}", value: value, block: block)
+            end
+
+            def case_payload(matcher, match, id:, value:, block:)
+              raise ArgumentError, "piecewise :#{@name} case cannot combine value: with a block" if !value.equal?(UNSET) && block
+              raise ArgumentError, "piecewise :#{@name} case requires value: or a block" if value.equal?(UNSET) && !block
+
+              {
+                id: id.to_sym,
+                matcher: matcher,
+                match: match,
+                value: block || value
+              }
+            end
+
+            def match?(entry, selector_value)
+              case entry.fetch(:matcher)
+              when :eq
+                selector_value == entry.fetch(:match)
+              when :between
+                entry.fetch(:match).cover?(selector_value)
+              when :in
+                entry.fetch(:match).include?(selector_value)
+              when :matches
+                !!(selector_value.to_s =~ entry.fetch(:match))
+              else
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/language/scale_pack.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Language
+        module ScalePack
+          module_function
+
+          def manifest
+            Igniter::Contracts::PackManifest.new(
+              name: :extensions_language_scale,
+              registry_contracts: [Igniter::Contracts::PackManifest.dsl_keyword(:scale)]
+            )
+          end
+
+          def install_into(kernel)
+            kernel.dsl_keywords.register(:scale, scale_keyword)
+            kernel
+          end
+
+          def scale_keyword
+            Igniter::Contracts::DslKeyword.new(:scale) do |name, from:, builder:, trace: nil, &block|
+              raise ArgumentError, "scale :#{name} requires a block" unless block
+
+              source_name = from.to_sym
+              trace_name = (trace || :"#{name}_trace").to_sym
+              definition = Definition.new(name: name, source_name: source_name)
+              definition.instance_eval(&block)
+              definition.validate!
+
+              builder.add_operation(
+                kind: :compute,
+                name: trace_name,
+                depends_on: [source_name],
+                callable: lambda do |**values|
+                  definition.resolve(values.fetch(source_name))
+                end
+              )
+              builder.add_operation(
+                kind: :compute,
+                name: name,
+                depends_on: [trace_name],
+                callable: lambda do |**values|
+                  values.fetch(trace_name).fetch(:value)
+                end
+              )
+            end
+          end
+
+          class Definition
+            def initialize(name:, source_name:)
+              @name = name.to_sym
+              @source_name = source_name.to_sym
+              @steps = []
+            end
+
+            def divide_by(value)
+              raise ArgumentError, "scale :#{@name} divide_by cannot use zero" if Float(value).zero?
+
+              add_step(:divide_by, value)
+            end
+
+            def multiply_by(value)
+              add_step(:multiply_by, value)
+            end
+
+            def add(value)
+              add_step(:add, value)
+            end
+
+            def subtract(value)
+              add_step(:subtract, value)
+            end
+
+            def clamp(min, max)
+              minimum = Float(min)
+              maximum = Float(max)
+              raise ArgumentError, "scale :#{@name} clamp min cannot exceed max" if minimum > maximum
+
+              @steps << { operation: :clamp, min: minimum, max: maximum }
+            end
+
+            def round(precision = 0)
+              @steps << { operation: :round, precision: Integer(precision) }
+            end
+
+            def validate!
+              raise ArgumentError, "scale :#{@name} requires at least one step" if @steps.empty?
+            end
+
+            def resolve(source_value)
+              current = Float(source_value)
+              trace = []
+
+              @steps.each do |step|
+                before = current
+                current = apply_step(current, step)
+                trace << step.merge(before: before, after: current)
+              end
+
+              {
+                value: current,
+                source: @source_name,
+                source_value: source_value,
+                steps: trace.freeze
+              }
+            rescue ArgumentError, TypeError
+              {
+                value: 0.0,
+                source: @source_name,
+                source_value: source_value,
+                error: :invalid_numeric_source,
+                steps: trace.freeze
+              }
+            end
+
+            private
+
+            def add_step(operation, value)
+              @steps << { operation: operation, value: Float(value) }
+            end
+
+            def apply_step(current, step)
+              case step.fetch(:operation)
+              when :divide_by
+                current / step.fetch(:value)
+              when :multiply_by
+                current * step.fetch(:value)
+              when :add
+                current + step.fetch(:value)
+              when :subtract
+                current - step.fetch(:value)
+              when :clamp
+                [[current, step.fetch(:min)].max, step.fetch(:max)].min
+              when :round
+                current.round(step.fetch(:precision))
+              else
+                current
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/lookup_pack.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module LookupPack
+        module_function
+
+        def manifest
+          Igniter::Contracts::PackManifest.new(
+            name: :extensions_lookup,
+            registry_contracts: [Igniter::Contracts::PackManifest.dsl_keyword(:lookup)]
+          )
+        end
+
+        def install_into(kernel)
+          kernel.dsl_keywords.register(:lookup, lookup_keyword)
+          kernel
+        end
+
+        def lookup_keyword
+          Igniter::Contracts::DslKeyword.new(:lookup) do |name, from:, builder:, key: nil, dig: nil, default: Igniter::Contracts::PathAccess::NO_DEFAULT|
+            source_name = from.to_sym
+            path = Igniter::Contracts::PathAccess.normalize_path(
+              keyword_name: :lookup,
+              key: key,
+              dig: dig
+            )
+
+            builder.add_operation(
+              kind: :compute,
+              name: name,
+              depends_on: [source_name],
+              callable: lambda do |**values|
+                source = values.fetch(source_name)
+                Igniter::Contracts::PathAccess.fetch_path(
+                  source,
+                  path,
+                  source_name: source_name,
+                  keyword_name: :lookup,
+                  default: default
+                )
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/mcp/creator_session.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Mcp
+        class CreatorSession
+          ATTRIBUTES = %i[
+            name
+            kind
+            namespace
+            profile
+            capabilities
+            scope
+            root
+            mode
+            pack
+            target_profile
+          ].freeze
+
+          attr_reader(*ATTRIBUTES)
+
+          def initialize(name: nil, kind: nil, namespace: "MyCompany::IgniterPacks", profile: nil, capabilities: nil,
+                         scope: nil, root: nil, mode: :skip_existing, pack: nil, target_profile: nil)
+            @name = name
+            @kind = kind
+            @namespace = namespace
+            @profile = profile
+            @capabilities = capabilities
+            @scope = scope
+            @root = root
+            @mode = mode
+            @pack = pack
+            @target_profile = target_profile
+            freeze
+          end
+
+          def self.from_h(payload, target_profile: nil)
+            new(
+              name: payload[:name] || payload["name"],
+              kind: payload[:kind] || payload["kind"],
+              namespace: payload[:namespace] || payload["namespace"] || "MyCompany::IgniterPacks",
+              profile: payload[:profile] || payload["profile"],
+              capabilities: payload[:capabilities] || payload["capabilities"],
+              scope: payload[:scope] || payload["scope"],
+              root: payload[:root] || payload["root"],
+              mode: payload[:mode] || payload["mode"] || :skip_existing,
+              pack: payload[:pack] || payload["pack"],
+              target_profile: target_profile
+            )
+          end
+
+          def apply(**updates)
+            self.class.new(
+              **ATTRIBUTES.to_h { |attribute| [attribute, updates.fetch(attribute, public_send(attribute))] }
+            )
+          end
+
+          def wizard
+            CreatorPack.wizard(
+              name: name,
+              kind: kind,
+              namespace: namespace,
+              profile: profile,
+              capabilities: capabilities,
+              scope: scope,
+              root: root,
+              mode: mode,
+              pack: pack,
+              target_profile: target_profile
+            )
+          end
+
+          def workflow_payload
+            wizard.workflow.to_h
+          end
+
+          def write_plan_payload
+            wizard.writer.plan.to_h
+          end
+
+          def write_payload
+            wizard.writer.write.to_h
+          end
+
+          def to_h
+            wizard.to_h.merge(
+              session: {
+                name: name,
+                kind: kind,
+                namespace: namespace,
+                profile: profile,
+                capabilities: Array(capabilities).map(&:to_sym),
+                scope: scope,
+                root: root,
+                mode: mode,
+                target_profile_fingerprint: target_profile&.fingerprint
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/extensions/contracts/mcp/tool_argument.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Extensions
+    module Contracts
+      module Mcp
+        class ToolArgument
+          attr_reader :name, :type, :summary, :required, :default, :enum
+
+          def initialize(name:, type:, summary:, required: false, default: nil, enum: nil)
+            @name = name.to_sym
+            @type = type.to_sym
+            @summary = summary
+            @required = required == true
+            @default = default
+            @enum = Array(enum).map(&:to_sym).freeze
+            freeze
+          end
+
+          def to_h
+            payload = {
+              name: name,
+              type: type,
+              summary: summary,
+              required: required
+            }
+            payload[:default] = default unless default.nil?
+            payload[:enum] = enum unless enum.empty?
+            payload
+          end
+        end
+      end
+    end
+  end
+end