lluminary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a50b739f7e9ea0f069d17bc94d74f284e38546bd1a8abbda0a6084548803756
+  data.tar.gz: db0bb01c407511d3bb1e34796aae68c823c33e9da6d4b556a0e4d3a09ef16ee3
+SHA512:
+  metadata.gz: 78891cbbe5940fe7685a33080c3cd5dd62afd3864c143a49a9ea4a1e63f5a390097ec1d863a93f47af44edded688b2c5b77068d5761198d3ae057dbcdb5d5c54
+  data.tar.gz: 6e0c48f4d4ce3c25756e611a3506e2bd44aa32ef3643be35f9c6312bb519c23dd1fc3ad2c273db6421eccb2c96895958f6a31d0d1ebf9bcd7cada876ab99b444

data/lib/lluminary/config.rb

@@ -0,0 +1,23 @@
+module Lluminary
+  class Config
+    def initialize
+      @providers = {}
+    end
+
+    def configure
+      yield self
+    end
+
+    def provider(name, **options)
+      @providers[name.to_sym] = options
+    end
+
+    def provider_config(provider_name)
+      @providers[provider_name.to_sym] || {}
+    end
+
+    def reset!
+      @providers = {}
+    end
+  end
+end 

data/lib/lluminary/field_description.rb

@@ -0,0 +1,148 @@
+module Lluminary
+  class FieldDescription
+    def initialize(name, field)
+      @name = name
+      @type = field[:type]
+      @description = field[:description]
+      @validations = field[:validations] || []
+    end
+
+    def to_s
+      parts = []
+      parts << "#{@name} (#{type_description})"
+      parts << ": #{@description}" if @description
+      parts << " (#{validation_descriptions.join(', ')})" if validation_descriptions.any?
+      parts.join
+    end
+
+    def to_schema_s
+      parts = []
+      parts << "#{@name} (#{type_description})"
+      parts << ": #{@description}" if @description
+      parts << "\nValidation: #{validation_descriptions.join(', ')}" if validation_descriptions.any?
+      parts << "\nExample: #{example_value}"
+      parts.join
+    end
+
+    private
+
+    def type_description
+      case @type
+      when :datetime
+        "datetime in ISO8601 format"
+      else
+        @type.to_s
+      end
+    end
+
+    def validation_descriptions
+      @validations.map do |_, options|
+        case options.keys.first
+        when :absence
+          "must be absent"
+        when :comparison
+          comparison_descriptions(options[:comparison])
+        when :exclusion
+          "must not be one of: #{options[:exclusion][:in].join(', ')}"
+        when :format
+          "must match format: #{options[:format][:with]}"
+        when :inclusion
+          "must be one of: #{options[:inclusion][:in].join(', ')}"
+        when :length
+          length_descriptions(options[:length])
+        when :numericality
+          numericality_descriptions(options[:numericality])
+        when :presence
+          "must be present"
+        end
+      end.compact
+    end
+
+    def comparison_descriptions(options)
+      descriptions = []
+      if options[:greater_than]
+        descriptions << "must be greater than #{options[:greater_than]}"
+      end
+      if options[:greater_than_or_equal_to]
+        descriptions << "must be greater than or equal to #{options[:greater_than_or_equal_to]}"
+      end
+      if options[:equal_to]
+        descriptions << "must be equal to #{options[:equal_to]}"
+      end
+      if options[:less_than]
+        descriptions << "must be less than #{options[:less_than]}"
+      end
+      if options[:less_than_or_equal_to]
+        descriptions << "must be less than or equal to #{options[:less_than_or_equal_to]}"
+      end
+      if options[:other_than]
+        descriptions << "must be other than #{options[:other_than]}"
+      end
+      descriptions.join(", ")
+    end
+
+    def length_descriptions(options)
+      descriptions = []
+      if options[:minimum]
+        descriptions << "must be at least #{options[:minimum]} characters"
+      end
+      if options[:maximum]
+        descriptions << "must be at most #{options[:maximum]} characters"
+      end
+      if options[:is]
+        descriptions << "must be exactly #{options[:is]} characters"
+      end
+      if options[:in]
+        descriptions << "must be between #{options[:in].min} and #{options[:in].max} characters"
+      end
+      descriptions.join(", ")
+    end
+
+    def numericality_descriptions(options)
+      descriptions = []
+      if options[:greater_than]
+        descriptions << "must be greater than #{options[:greater_than]}"
+      end
+      if options[:greater_than_or_equal_to]
+        descriptions << "must be greater than or equal to #{options[:greater_than_or_equal_to]}"
+      end
+      if options[:equal_to]
+        descriptions << "must be equal to #{options[:equal_to]}"
+      end
+      if options[:less_than]
+        descriptions << "must be less than #{options[:less_than]}"
+      end
+      if options[:less_than_or_equal_to]
+        descriptions << "must be less than or equal to #{options[:less_than_or_equal_to]}"
+      end
+      if options[:other_than]
+        descriptions << "must be other than #{options[:other_than]}"
+      end
+      if options[:in]
+        descriptions << "must be in: #{options[:in].to_a.join(', ')}"
+      end
+      if options[:odd]
+        descriptions << "must be odd"
+      end
+      if options[:even]
+        descriptions << "must be even"
+      end
+      descriptions.join(", ")
+    end
+
+    def example_value
+      case @type
+      when :string
+        "\"your #{@name} here\""
+      when :integer
+        "0"
+      when :datetime
+        "\"2024-01-01T12:00:00+00:00\""
+      when :boolean
+        "true"
+      when :float
+        "0.0"
+      end
+    end
+  end
+end 

data/lib/lluminary/provider_error.rb

@@ -0,0 +1,4 @@
+module Lluminary
+  class ProviderError < StandardError
+  end
+end 

data/lib/lluminary/providers/base.rb

@@ -0,0 +1,15 @@
+module Lluminary
+  module Providers
+    class Base
+      attr_reader :config
+
+      def initialize(**config)
+        @config = config
+      end
+
+      def call(prompt, task)
+        raise NotImplementedError, "Subclasses must implement #call"
+      end
+    end
+  end
+end 

data/lib/lluminary/providers/bedrock.rb

@@ -0,0 +1,51 @@
+require 'aws-sdk-bedrockruntime'
+require 'json'
+require_relative '../provider_error'
+
+require 'pry-byebug'
+
+module Lluminary
+  module Providers
+    class Bedrock < Base
+      DEFAULT_MODEL_ID = 'anthropic.claude-instant-v1'
+
+      attr_reader :client, :config
+
+      def initialize(**config)
+        super
+        @config = config
+
+        @client = Aws::BedrockRuntime::Client.new(
+          region: config[:region],
+          credentials: Aws::Credentials.new(
+            config[:access_key_id],
+            config[:secret_access_key]
+          )
+        )
+      end
+
+      def call(prompt, task)
+        response = @client.converse(
+          model_id: config[:model_id] || DEFAULT_MODEL_ID,
+          messages: [
+            {
+              role: 'user',
+              content: [{text: prompt}]
+            }
+          ]
+        )
+
+        content = response.dig(:output, :message, :content, 0, :text)
+        
+        { 
+          raw: content,
+          parsed: begin
+            JSON.parse(content) if content
+          rescue JSON::ParserError
+            nil
+          end
+        }
+      end
+    end
+  end
+end 

data/lib/lluminary/providers/openai.rb

@@ -0,0 +1,40 @@
+require 'openai'
+require 'json'
+require_relative '../provider_error'
+
+module Lluminary
+  module Providers
+    class OpenAI < Base
+      DEFAULT_MODEL = "gpt-3.5-turbo"
+
+      attr_reader :client, :config
+
+      def initialize(**config)
+        super
+        @config = config
+        @client = ::OpenAI::Client.new(access_token: config[:api_key])
+      end
+
+      def call(prompt, task)
+        response = @client.chat(
+          parameters: {
+            model: config[:model] || DEFAULT_MODEL,
+            messages: [{ role: "user", content: prompt }],
+            response_format: { type: "json_object" }
+          }
+        )
+
+        content = response.dig('choices', 0, 'message', 'content')
+        
+        { 
+          raw: content,
+          parsed: begin
+            JSON.parse(content) if content
+          rescue JSON::ParserError
+            nil
+          end
+        }
+      end
+    end
+  end
+end 

data/lib/lluminary/providers/test.rb

@@ -0,0 +1,37 @@
+module Lluminary
+  module Providers
+    class Test < Base
+      def initialize(**config)
+        super
+      end
+
+      def call(prompt, task)
+        response = generate_response(task.class.output_fields)
+        raw_response = JSON.pretty_generate(response).gsub(/\n\s*/, '')
+        {
+          raw: raw_response,
+          parsed: JSON.parse(raw_response)
+        }
+      end
+
+      private
+
+      def generate_response(fields)
+        fields.each_with_object({}) do |(name, field), hash|
+          hash[name] = generate_value(field[:type])
+        end
+      end
+
+      def generate_value(type)
+        case type
+        when :string
+          "Test #{type} value"
+        when :integer
+          0
+        else
+          raise "Unsupported type: #{type}"
+        end
+      end
+    end
+  end
+end 

data/lib/lluminary/result.rb

@@ -0,0 +1,13 @@
+require 'ostruct'
+
+module Lluminary
+  class Result
+    attr_reader :raw_response, :output, :prompt
+
+    def initialize(raw_response:, output:, prompt:)
+      @raw_response = raw_response
+      @output = OpenStruct.new(output)
+      @prompt = prompt
+    end
+  end
+end 

data/lib/lluminary/schema.rb

@@ -0,0 +1,61 @@
+require 'active_model'
+require_relative 'schema_model'
+
+module Lluminary
+  class JsonValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      record.errors.add(:base, "Response must be valid JSON") unless value.is_a?(Hash)
+    end
+  end
+
+  class Schema
+    def initialize
+      @fields = {}
+      @validations = []
+    end
+
+    def string(name, description: nil)
+      @fields[name] = { type: :string, description: description }
+    end
+
+    def integer(name, description: nil)
+      @fields[name] = { type: :integer, description: description }
+    end
+
+    def boolean(name, description: nil)
+      @fields[name] = { type: :boolean, description: description }
+    end
+
+    def float(name, description: nil)
+      @fields[name] = { type: :float, description: description }
+    end
+
+    def datetime(name, description: nil)
+      @fields[name] = { type: :datetime, description: description }
+    end
+
+    def fields
+      @fields
+    end
+
+    def validates(*args, **options)
+      @validations << [args, options]
+    end
+
+    def validations_for(field_name)
+      @validations.select { |args, _| args.include?(field_name) }
+    end
+
+    def schema_model
+      @schema_model ||= SchemaModel.build(
+        fields: @fields,
+        validations: @validations
+      )
+    end
+
+    def validate(values)
+      instance = schema_model.new(values)
+      instance.valid? ? [] : instance.errors.full_messages
+    end
+  end
+end 

data/lib/lluminary/schema_model.rb

@@ -0,0 +1,87 @@
+require 'active_model'
+
+module Lluminary
+  class SchemaModel
+    include ActiveModel::Validations
+
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes.transform_keys(&:to_s)
+    end
+
+    def to_s
+      attrs = attributes.dup
+      attrs.delete('raw_response')
+      "#<#{self.class.name} #{attrs.inspect}>"
+    end
+
+    def self.build(fields:, validations:)
+      Class.new(self) do
+        # Add accessors for each field
+        fields.each_key do |name|
+          define_method(name) { @attributes[name.to_s] }
+          define_method("#{name}=") { |value| @attributes[name.to_s] = value }
+        end
+
+        # Add raw_response field and validation
+        define_method(:raw_response) { @attributes['raw_response'] }
+        define_method(:raw_response=) { |value| @attributes['raw_response'] = value }
+
+        validate do |record|
+          if record.raw_response
+            begin
+              JSON.parse(record.raw_response)
+            rescue JSON::ParserError
+              record.errors.add(:raw_response, "must be valid JSON")
+            end
+          end
+        end
+
+        # Add type validations
+        validate do |record|
+          record.attributes.each do |name, value|
+            next if name == 'raw_response'
+            next if value.nil?
+
+            field = fields[name.to_sym]
+            next unless field
+
+            case field[:type]
+            when :string
+              unless value.is_a?(String)
+                record.errors.add(name, "must be a String")
+              end
+            when :integer
+              unless value.is_a?(Integer)
+                record.errors.add(name, "must be an Integer")
+              end
+            when :boolean
+              unless value == true || value == false
+                record.errors.add(name, "must be true or false")
+              end
+            when :float
+              unless value.is_a?(Float)
+                record.errors.add(name, "must be a float")
+              end
+            when :datetime
+              unless value.is_a?(DateTime)
+                record.errors.add(name, "must be a DateTime")
+              end
+            end
+          end
+        end
+
+        # Add ActiveModel validations
+        validations.each do |args, options|
+          validates(*args, **options)
+        end
+
+        # Set model name for error messages
+        define_singleton_method(:model_name) do
+          ActiveModel::Name.new(self, nil, "SchemaModel")
+        end
+      end
+    end
+  end
+end