lluminary 0.1.0

data/spec/lluminary/providers/bedrock_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'lluminary/providers/bedrock'
+
+RSpec.describe Lluminary::Providers::Bedrock do
+  let(:config) do
+    {
+      region: 'us-east-1',
+      access_key_id: 'test-key',
+      secret_access_key: 'test-secret'
+    }
+  end
+  let(:provider) { described_class.new(**config) }
+
+  describe '#client' do
+    it 'returns the AWS Bedrock client instance' do
+      expect(provider.client).to be_a(Aws::BedrockRuntime::Client)
+    end
+  end
+
+  describe '#call' do
+    let(:prompt) { 'Test prompt' }
+    let(:task) { 'Test task' }
+    let(:mock_response) do
+      OpenStruct.new(
+        output: OpenStruct.new(
+          message: OpenStruct.new(
+            content: [
+              OpenStruct.new(text: '{"sentiment": "positive"}')
+            ]
+          )
+        )
+      )
+    end
+
+    before do
+      allow_any_instance_of(Aws::BedrockRuntime::Client).to receive(:converse).and_return(mock_response)
+    end
+
+    it 'returns a hash with raw and parsed response' do
+      response = provider.call(prompt, task)
+      expect(response).to eq({
+        raw: '{"sentiment": "positive"}',
+        parsed: { 'sentiment' => 'positive' }
+      })
+    end
+
+    context 'when the response is not valid JSON' do
+      let(:mock_response) do
+        OpenStruct.new(
+          output: OpenStruct.new(
+            message: OpenStruct.new(
+              content: [
+                OpenStruct.new(text: 'not valid json')
+              ]
+            )
+          )
+        )
+      end
+
+      it 'returns raw response with nil parsed value' do
+        response = provider.call(prompt, task)
+        expect(response).to eq({
+          raw: 'not valid json',
+          parsed: nil
+        })
+      end
+    end
+
+    context 'when the response content is nil' do
+      let(:mock_response) do
+        OpenStruct.new(
+          output: OpenStruct.new(
+            message: OpenStruct.new(
+              content: nil
+            )
+          )
+        )
+      end
+
+      it 'returns nil for both raw and parsed values' do
+        response = provider.call(prompt, task)
+        expect(response).to eq({
+          raw: nil,
+          parsed: nil
+        })
+      end
+    end
+
+    context 'when the response content array is empty' do
+      let(:mock_response) do
+        OpenStruct.new(
+          output: OpenStruct.new(
+            message: OpenStruct.new(
+              content: []
+            )
+          )
+        )
+      end
+
+      it 'returns nil for both raw and parsed values' do
+        response = provider.call(prompt, task)
+        expect(response).to eq({
+          raw: nil,
+          parsed: nil
+        })
+      end
+    end
+  end
+end 

data/spec/lluminary/providers/openai_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe Lluminary::Providers::OpenAI do
+  let(:config) { { api_key: 'test-key' } }
+  let(:provider) { described_class.new(**config) }
+
+  describe '#client' do
+    it 'returns the OpenAI client instance' do
+      expect(provider.client).to be_a(OpenAI::Client)
+    end
+  end
+
+  describe '#call' do
+    let(:prompt) { 'Test prompt' }
+    let(:task) { 'Test task' }
+    let(:mock_response) do
+      {
+        'choices' => [
+          {
+            'message' => {
+              'content' => '{"summary": "Test response"}'
+            }
+          }
+        ]
+      }
+    end
+
+    before do
+      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(mock_response)
+    end
+
+    it 'returns a hash with raw and parsed response' do
+      response = provider.call(prompt, task)
+      expect(response).to eq({
+        raw: '{"summary": "Test response"}',
+        parsed: { 'summary' => 'Test response' }
+      })
+    end
+
+    context 'when the response is not valid JSON' do
+      let(:mock_response) do
+        {
+          'choices' => [
+            {
+              'message' => {
+                'content' => 'not valid json'
+              }
+            }
+          ]
+        }
+      end
+
+      it 'returns raw response with nil parsed value' do
+        response = provider.call(prompt, task)
+        expect(response).to eq({
+          raw: 'not valid json',
+          parsed: nil
+        })
+      end
+    end
+  end
+end 

data/spec/lluminary/providers/test_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'lluminary/providers/test'
+
+RSpec.describe Lluminary::Providers::Test do
+  let(:provider) { described_class.new }
+  let(:prompt) { "Test prompt" }
+  let(:task_class) { double("TaskClass", output_fields: { summary: { type: :string } }) }
+  let(:task) { double("Task", class: task_class) }
+
+  describe '#call' do
+    it 'returns a hash with raw and parsed response' do
+      response = provider.call(prompt, task)
+
+      expect(response).to be_a(Hash)
+      expect(response[:raw]).to eq('{"summary": "Test string value"}')
+      expect(response[:parsed]).to eq({ "summary" => "Test string value" })
+    end
+
+    it 'handles prompts with schema descriptions' do
+      prompt_with_schema = <<~PROMPT
+        Test prompt
+
+        You must respond with a valid JSON object with the following fields:
+
+        summary (string): A brief summary of the message
+        Example: "your summary here"
+
+        Your response should look like this:
+        {
+          "summary": "your summary here"
+        }
+      PROMPT
+
+      response = provider.call(prompt_with_schema, task)
+      expect(response[:raw]).to eq('{"summary": "Test string value"}')
+      expect(response[:parsed]).to eq({ "summary" => "Test string value" })
+    end
+
+    it 'generates integer values for integer fields' do
+      task_class = double("TaskClass", output_fields: { count: { type: :integer } })
+      task = double("Task", class: task_class)
+      
+      response = provider.call(prompt, task)
+      expect(response[:raw]).to eq('{"count": 0}')
+      expect(response[:parsed]).to eq({ "count" => 0 })
+    end
+
+    it 'raises error for unsupported types' do
+      task_class = double("TaskClass", output_fields: { value: { type: :unsupported } })
+      task = double("Task", class: task_class)
+      
+      expect {
+        provider.call(prompt, task)
+      }.to raise_error("Unsupported type: unsupported")
+    end
+  end
+end 

data/spec/lluminary/result_spec.rb

@@ -0,0 +1,31 @@
+require 'lluminary'
+
+RSpec.describe Lluminary::Result do
+  let(:raw_response) { "Test response" }
+  let(:output) { { summary: "Test summary" } }
+  let(:prompt) { "Test prompt" }
+  let(:result) { described_class.new(raw_response: raw_response, output: output, prompt: prompt) }
+
+  describe '#raw_response' do
+    it 'returns the raw response' do
+      expect(result.raw_response).to eq(raw_response)
+    end
+  end
+
+  describe '#output' do
+    it 'returns an OpenStruct with the output data' do
+      expect(result.output).to be_a(OpenStruct)
+      expect(result.output.summary).to eq(output[:summary])
+    end
+
+    it 'allows accessing output fields as methods' do
+      expect(result.output.summary).to eq(output[:summary])
+    end
+  end
+
+  describe '#prompt' do
+    it 'returns the prompt' do
+      expect(result.prompt).to eq(prompt)
+    end
+  end
+end 

data/spec/lluminary/schema_model_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe Lluminary::SchemaModel do
+  describe '.build' do
+    let(:fields) do
+      {
+        name: { type: :string, description: "The user's name" },
+        age: { type: :integer, description: "The user's age" }
+      }
+    end
+
+    let(:validations) do
+      [
+        [[:name], { presence: true }],
+        [[:age], { numericality: { greater_than: 0 } }]
+      ]
+    end
+
+    let(:model_class) { described_class.build(fields: fields, validations: validations) }
+
+    it 'creates a class that inherits from SchemaModel' do
+      expect(model_class.ancestors).to include(described_class)
+    end
+
+    it 'includes ActiveModel::Validations' do
+      expect(model_class.ancestors).to include(ActiveModel::Validations)
+    end
+
+    it 'adds accessors for fields' do
+      instance = model_class.new(name: "John", age: 30)
+      expect(instance.name).to eq("John")
+      expect(instance.age).to eq(30)
+    end
+
+    it 'validates presence' do
+      instance = model_class.new(age: 30)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Name can't be blank")
+    end
+
+    it 'validates numericality' do
+      instance = model_class.new(name: "John", age: 0)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Age must be greater than 0")
+    end
+
+    it 'validates types' do
+      instance = model_class.new(name: 123, age: "30")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Name must be a String",
+        "Age must be an Integer"
+      )
+    end
+
+    it 'validates float types' do
+      fields = {
+        price: { type: :float, description: "The price" }
+      }
+      model_class = described_class.build(fields: fields, validations: [])
+      
+      # Test that nil is allowed
+      instance = model_class.new(price: nil)
+      expect(instance.valid?).to be true
+      
+      # Test invalid float value
+      instance = model_class.new(price: "not a float")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Price must be a float")
+      
+      # Test valid float value
+      instance = model_class.new(price: 12.34)
+      expect(instance.valid?).to be true
+    end
+
+    it 'accepts valid attributes' do
+      instance = model_class.new(name: "John", age: 30)
+      expect(instance.valid?).to be true
+    end
+
+    it 'provides access to raw attributes' do
+      instance = model_class.new(name: "John", age: 30)
+      expect(instance.attributes).to eq({ "name" => "John", "age" => 30 })
+    end
+  end
+end 

data/spec/lluminary/schema_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+
+RSpec.describe Lluminary::Schema do
+  let(:schema) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates an empty fields hash' do
+      expect(schema.fields).to eq({})
+    end
+  end
+
+  describe '#string' do
+    it 'adds a string field to the schema' do
+      schema.string(:name)
+      expect(schema.fields).to eq({ name: { type: :string, description: nil } })
+    end
+
+    it 'adds a string field with description' do
+      schema.string(:name, description: "The user's full name")
+      expect(schema.fields).to eq({ 
+        name: { 
+          type: :string,
+          description: "The user's full name"
+        } 
+      })
+    end
+  end
+
+  describe '#integer' do
+    it 'adds an integer field to the schema' do
+      schema.integer(:count)
+      expect(schema.fields).to eq({ count: { type: :integer, description: nil } })
+    end
+
+    it 'adds an integer field with description' do
+      schema.integer(:count, description: "The total number of items")
+      expect(schema.fields).to eq({ 
+        count: { 
+          type: :integer,
+          description: "The total number of items"
+        } 
+      })
+    end
+  end
+
+  describe '#boolean' do
+    it 'adds a boolean field to the schema' do
+      schema.boolean(:active)
+      expect(schema.fields).to eq({ active: { type: :boolean, description: nil } })
+    end
+
+    it 'adds a boolean field with description' do
+      schema.boolean(:active, description: "Whether the item is active")
+      expect(schema.fields).to eq({ 
+        active: { 
+          type: :boolean,
+          description: "Whether the item is active"
+        } 
+      })
+    end
+  end
+
+  describe '#float' do
+    it 'adds a float field to the schema' do
+      schema.float(:price)
+      expect(schema.fields).to eq({ price: { type: :float, description: nil } })
+    end
+
+    it 'adds a float field with description' do
+      schema.float(:price, description: "The price of the item")
+      expect(schema.fields).to eq({ 
+        price: { 
+          type: :float,
+          description: "The price of the item"
+        } 
+      })
+    end
+  end
+
+  describe '#datetime' do
+    it 'adds a datetime field to the schema' do
+      schema.datetime(:start_time)
+      expect(schema.fields).to eq({ start_time: { type: :datetime, description: nil } })
+    end
+
+    it 'adds a datetime field with description' do
+      schema.datetime(:start_time, description: "When the event starts")
+      expect(schema.fields).to eq({ 
+        start_time: { 
+          type: :datetime,
+          description: "When the event starts"
+        } 
+      })
+    end
+  end
+
+  describe '#fields' do
+    it 'returns the fields hash' do
+      schema.string(:name)
+      expect(schema.fields).to eq({ name: { type: :string, description: nil } })
+    end
+
+    it 'returns the same hash instance' do
+      schema.string(:name)
+      first_call = schema.fields
+      second_call = schema.fields
+      expect(first_call).to be(second_call)
+    end
+
+    context 'with datetime fields' do
+      let(:schema) do
+        described_class.new.tap do |s|
+          s.datetime(:start_time)
+        end
+      end
+
+      it 'accepts DateTime values' do
+        errors = schema.validate(start_time: DateTime.now)
+        expect(errors).to be_empty
+      end
+
+      it 'accepts nil values' do
+        errors = schema.validate(start_time: nil)
+        expect(errors).to be_empty
+      end
+
+      it 'returns errors for non-DateTime values' do
+        errors = schema.validate(start_time: "2024-01-01")
+        expect(errors).to contain_exactly("Start time must be a DateTime")
+      end
+
+      it 'can be required using presence validation' do
+        schema.validates :start_time, presence: true
+        errors = schema.validate(start_time: nil)
+        expect(errors).to contain_exactly("Start time can't be blank")
+      end
+    end
+  end
+
+  describe '#validate' do
+    let(:schema) do
+      described_class.new.tap do |s|
+        s.string(:name)
+        s.integer(:age)
+      end
+    end
+
+    it 'returns no errors when all values match their field types' do
+      errors = schema.validate(name: "John", age: 30)
+      expect(errors).to be_empty
+    end
+
+    it 'returns errors for type mismatches' do
+      errors = schema.validate(name: 123, age: "30")
+      expect(errors).to contain_exactly(
+        "Name must be a String",
+        "Age must be an Integer"
+      )
+    end
+
+    context 'with boolean fields' do
+      let(:schema) do
+        described_class.new.tap do |s|
+          s.boolean(:active)
+        end
+      end
+
+      it 'accepts true values' do
+        errors = schema.validate(active: true)
+        expect(errors).to be_empty
+      end
+
+      it 'accepts false values' do
+        errors = schema.validate(active: false)
+        expect(errors).to be_empty
+      end
+
+      it 'accepts nil values' do
+        errors = schema.validate(active: nil)
+        expect(errors).to be_empty
+      end
+
+      it 'returns errors for non-boolean values' do
+        errors = schema.validate(active: 'true')
+        expect(errors).to contain_exactly("Active must be true or false")
+
+        errors = schema.validate(active: 1)
+        expect(errors).to contain_exactly("Active must be true or false")
+      end
+
+      it 'can be required using presence validation' do
+        schema.validates :active, presence: true
+        errors = schema.validate(active: nil)
+        expect(errors).to contain_exactly("Active can't be blank")
+      end
+    end
+
+    context 'with string fields' do
+      let(:schema) do
+        described_class.new.tap do |s|
+          s.string(:name)
+        end
+      end
+
+      it 'accepts string values' do
+        errors = schema.validate(name: "John")
+        expect(errors).to be_empty
+      end
+
+      it 'accepts nil values' do
+        errors = schema.validate(name: nil)
+        expect(errors).to be_empty
+      end
+
+      it 'returns errors for non-string values' do
+        errors = schema.validate(name: 123)
+        expect(errors).to contain_exactly("Name must be a String")
+      end
+
+      it 'can be required using presence validation' do
+        schema.validates :name, presence: true
+        errors = schema.validate(name: nil)
+        expect(errors).to contain_exactly("Name can't be blank")
+      end
+    end
+
+    context 'with integer fields' do
+      let(:schema) do
+        described_class.new.tap do |s|
+          s.integer(:age)
+        end
+      end
+
+      it 'accepts integer values' do
+        errors = schema.validate(age: 30)
+        expect(errors).to be_empty
+      end
+
+      it 'accepts nil values' do
+        errors = schema.validate(age: nil)
+        expect(errors).to be_empty
+      end
+
+      it 'returns errors for non-integer values' do
+        errors = schema.validate(age: "30")
+        expect(errors).to contain_exactly("Age must be an Integer")
+      end
+
+      it 'can be required using presence validation' do
+        schema.validates :age, presence: true
+        errors = schema.validate(age: nil)
+        expect(errors).to contain_exactly("Age can't be blank")
+      end
+    end
+  end
+
+  describe 'ActiveModel validations' do
+    let(:schema) do
+      described_class.new.tap do |s|
+        s.string(:name)
+        s.integer(:age)
+
+        s.validates :name, presence: true
+        s.validates :age, numericality: { greater_than: 0 }
+      end
+    end
+
+    it 'generates a class that includes ActiveModel::Validations' do
+      schema_model = schema.schema_model
+      expect(schema_model.ancestors).to include(ActiveModel::Validations)
+    end
+
+    it 'adds accessors for defined fields' do
+      schema_model = schema.schema_model
+      instance = schema_model.new
+      instance.name = "John"
+      instance.age = 30
+      expect(instance.name).to eq("John")
+      expect(instance.age).to eq(30)
+    end
+
+    it 'validates presence' do
+      schema_model = schema.schema_model
+      instance = schema_model.new
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Name can't be blank")
+    end
+
+    it 'validates numericality' do
+      schema_model = schema.schema_model
+      instance = schema_model.new(name: "John", age: 0)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Age must be greater than 0")
+    end
+
+    it 'returns true for valid instances' do
+      schema_model = schema.schema_model
+      instance = schema_model.new(name: "John", age: 30)
+      expect(instance.valid?).to be true
+    end
+  end
+end