lluminary 0.1.1 → 0.1.3

data/lib/lluminary/schema.rb

@@ -1,13 +1,10 @@
-require 'active_model'
-require_relative 'schema_model'
+# frozen_string_literal: true
+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
-
+  # Represents a JSON schema for validating task inputs and outputs.
+  # Provides methods for defining and validating schemas.
   class Schema
     def initialize
       @fields = {}
@@ -34,12 +31,30 @@ module Lluminary
       @fields[name] = { type: :datetime, description: description }
     end
 
-    def fields
-      @fields
+    def array(name, description: nil, &block)
+      field = { type: :array, description: description }
+
+      if block
+        element_schema = ArrayElementSchema.new
+        field[:element_type] = element_schema.instance_eval(&block)
+      end
+
+      @fields[name] = field
     end
 
+    attr_reader :fields
+
     def validates(*args, **options)
       @validations << [args, options]
+      # Attach the validation to each field it applies to
+      args.each do |field_name|
+        field = @fields[field_name]
+        next unless field # Skip if field doesn't exist yet
+
+        field[:validations] ||= []
+        # Store each validation option separately
+        options.each { |key, value| field[:validations] << { key => value } }
+      end
     end
 
     def validations_for(field_name)
@@ -47,15 +62,44 @@ module Lluminary
     end
 
     def schema_model
-      @schema_model ||= SchemaModel.build(
-        fields: @fields,
-        validations: @validations
-      )
+      @schema_model ||=
+        SchemaModel.build(fields: @fields, validations: @validations)
     end
 
     def validate(values)
       instance = schema_model.new(values)
       instance.valid? ? [] : instance.errors.full_messages
     end
+
+    # Internal class for defining array element types
+    class ArrayElementSchema
+      def string(description: nil)
+        { type: :string, description: description }
+      end
+
+      def integer(description: nil)
+        { type: :integer, description: description }
+      end
+
+      def boolean(description: nil)
+        { type: :boolean, description: description }
+      end
+
+      def float(description: nil)
+        { type: :float, description: description }
+      end
+
+      def datetime(description: nil)
+        { type: :datetime, description: description }
+      end
+
+      def array(description: nil, &block)
+        field = { type: :array, description: description }
+        field[:element_type] = ArrayElementSchema.new.instance_eval(
+          &block
+        ) if block
+        field
+      end
+    end
   end
-end 
+end

data/lib/lluminary/schema_model.rb

@@ -1,6 +1,9 @@
-require 'active_model'
+# frozen_string_literal: true
+require "active_model"
 
 module Lluminary
+  # Base class for models that use JSON schema validation.
+  # Provides ActiveModel integration and schema validation.
   class SchemaModel
     include ActiveModel::Validations
 
@@ -12,7 +15,7 @@ module Lluminary
 
     def to_s
       attrs = attributes.dup
-      attrs.delete('raw_response')
+      attrs.delete("raw_response")
       "#<#{self.class.name} #{attrs.inspect}>"
     end
 
@@ -25,8 +28,10 @@ module Lluminary
         end
 
         # Add raw_response field and validation
-        define_method(:raw_response) { @attributes['raw_response'] }
-        define_method(:raw_response=) { |value| @attributes['raw_response'] = value }
+        define_method(:raw_response) { @attributes["raw_response"] }
+        define_method(:raw_response=) do |value|
+          @attributes["raw_response"] = value
+        end
 
         validate do |record|
           if record.raw_response
@@ -40,8 +45,60 @@ module Lluminary
 
         # Add type validations
         validate do |record|
+          def validate_array_field(
+            record,
+            name,
+            value,
+            element_type,
+            path = nil
+          )
+            field_name = path || name
+
+            unless value.is_a?(Array)
+              record.errors.add(field_name, "must be an Array")
+              return
+            end
+
+            return unless element_type # untyped array
+
+            value.each_with_index do |element, index|
+              current_path = "#{field_name}[#{index}]"
+
+              case element_type[:type]
+              when :array
+                validate_array_field(
+                  record,
+                  name,
+                  element,
+                  element_type[:element_type],
+                  current_path
+                )
+              when :string
+                unless element.is_a?(String)
+                  record.errors.add(current_path, "must be a String")
+                end
+              when :integer
+                unless element.is_a?(Integer)
+                  record.errors.add(current_path, "must be an Integer")
+                end
+              when :boolean
+                unless [true, false].include?(element)
+                  record.errors.add(current_path, "must be true or false")
+                end
+              when :float
+                unless element.is_a?(Float)
+                  record.errors.add(current_path, "must be a float")
+                end
+              when :datetime
+                unless element.is_a?(DateTime)
+                  record.errors.add(current_path, "must be a DateTime")
+                end
+              end
+            end
+          end
+
           record.attributes.each do |name, value|
-            next if name == 'raw_response'
+            next if name == "raw_response"
             next if value.nil?
 
             field = fields[name.to_sym]
@@ -57,7 +114,7 @@ module Lluminary
                 record.errors.add(name, "must be an Integer")
               end
             when :boolean
-              unless value == true || value == false
+              unless [true, false].include?(value)
                 record.errors.add(name, "must be true or false")
               end
             when :float
@@ -68,14 +125,14 @@ module Lluminary
               unless value.is_a?(DateTime)
                 record.errors.add(name, "must be a DateTime")
               end
+            when :array
+              validate_array_field(record, name, value, field[:element_type])
             end
           end
         end
 
         # Add ActiveModel validations
-        validations.each do |args, options|
-          validates(*args, **options)
-        end
+        validations.each { |args, options| validates(*args, **options) }
 
         # Set model name for error messages
         define_singleton_method(:model_name) do
@@ -84,4 +141,4 @@ module Lluminary
       end
     end
   end
-end 
+end

data/lib/lluminary/task.rb

@@ -1,10 +1,15 @@
-require 'ostruct'
-require_relative 'schema'
-require_relative 'validation_error'
-require_relative 'field_description'
-require 'json'
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+require_relative "schema"
+require_relative "validation_error"
+require_relative "models/base"
+require_relative "models/openai/gpt35_turbo"
+require_relative "models/bedrock/anthropic_claude_instant_v1"
 
 module Lluminary
+  # Base class for all Lluminary tasks.
+  # Provides the core functionality for defining and running LLM-powered tasks.
   class Task
     class << self
       def input_schema(&block)
@@ -18,25 +23,22 @@ module Lluminary
       end
 
       def use_provider(provider_name, **config)
-        provider_class = case provider_name
-        when :openai
-          require_relative 'providers/openai'
-          Providers::OpenAI
-        when :test
-          require_relative 'providers/test'
-          Providers::Test
-        when :bedrock
-          require_relative 'providers/bedrock'
-          Providers::Bedrock
-        else
-          raise ArgumentError, "Unknown provider: #{provider_name}"
-        end
-
-        # Merge global config with task-specific config
-        global_config = Lluminary.config.provider_config(provider_name)
-        merged_config = global_config.merge(config)
+        provider_class =
+          case provider_name
+          when :openai
+            require_relative "providers/openai"
+            Providers::OpenAI
+          when :test
+            require_relative "providers/test"
+            Providers::Test
+          when :bedrock
+            require_relative "providers/bedrock"
+            Providers::Bedrock
+          else
+            raise ArgumentError, "Unknown provider: #{provider_name}"
+          end
 
-        @provider = provider_class.new(**merged_config)
+        @provider = provider_class.new(**config)
       end
 
       def call(input = {})
@@ -48,15 +50,14 @@ module Lluminary
       end
 
       def provider
-        @provider ||= begin
-          require_relative 'providers/test'
-          Providers::Test.new
-        end
+        @provider ||=
+          begin
+            require_relative "providers/test"
+            Providers::Test.new
+          end
       end
 
-      def provider=(provider)
-        @provider = provider
-      end
+      attr_writer :provider
 
       def input_fields
         @input_schema&.fields || {}
@@ -98,7 +99,7 @@ module Lluminary
       validate_input!
       response = self.class.provider.call(prompt, self)
       process_response(response)
-      
+
       self
     end
 
@@ -107,17 +108,16 @@ module Lluminary
     end
 
     def validate_input!
-      unless @input.valid?
-        raise ValidationError, @input.errors.full_messages.join(", ")
-      end
+      return if @input.valid?
+      raise ValidationError, @input.errors.full_messages.join(", ")
     end
 
     def prompt
-      base_prompt = <<~PROMPT
-        #{task_prompt}
+      @prompt ||= self.class.provider.model.format_prompt(self)
+    end
 
-        #{json_schema_example}
-      PROMPT
+    def task_prompt
+      raise NotImplementedError, "Subclasses must implement task_prompt"
     end
 
     private
@@ -134,27 +134,36 @@ module Lluminary
       # Merge the parsed response first, then validate
       if @parsed_response.is_a?(Hash)
         # Get datetime fields from schema
-        datetime_fields = self.class.output_fields.select { |_, field| field[:type] == :datetime }.keys
+        datetime_fields =
+          self
+            .class
+            .output_fields
+            .select { |_, field| field[:type] == :datetime }
+            .keys
 
         # Convert datetime fields
         converted_response = @parsed_response.dup
         datetime_fields.each do |field_name|
-          if converted_response.key?(field_name.to_s) && converted_response[field_name.to_s].is_a?(String)
-            begin
-              converted_response[field_name.to_s] = DateTime.parse(converted_response[field_name.to_s])
-            rescue ArgumentError
-              # Leave as string, validation will fail
-            end
+          unless converted_response.key?(field_name.to_s) &&
+                   converted_response[field_name.to_s].is_a?(String)
+            next
+          end
+          begin
+            converted_response[field_name.to_s] = DateTime.parse(
+              converted_response[field_name.to_s]
+            )
+          rescue ArgumentError
+            # Leave as string, validation will fail
           end
         end
 
         @output.attributes.merge!(converted_response)
       end
-      
+
       # Validate after merging
       @output.valid?
 
-      @prompt = prompt
+      prompt
     end
 
     def define_input_methods
@@ -163,62 +172,12 @@ module Lluminary
       end
     end
 
-    def task_prompt
-      raise NotImplementedError, "Subclasses must implement task_prompt"
-    end
-
-    def json_schema_example
-      return "{}" if fields.empty?
-
-      <<~SCHEMA.chomp
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        #{generate_field_descriptions}
-
-        Your response must be ONLY this JSON object:
-        #{example_json}
-      SCHEMA
-    end
-
-    def fields
-      @fields ||= self.class.output_fields
-    end
-
-    def generate_field_descriptions
-      fields.map do |name, field|
-        # Get validations for this field
-        validations = self.class.instance_variable_get(:@output_schema)&.validations_for(name) || []
-        field_with_validations = field.merge(validations: validations)
-        FieldDescription.new(name, field_with_validations).to_schema_s
-      end.join("\n\n")
-    end
-
-    def example_json
-      json = fields.each_with_object({}) do |(name, field), hash|
-        hash[name] = case field[: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
-
-      JSON.pretty_generate(json)
-    end
-
     def to_result
       Result.new(
         raw_response: @output&.raw_response,
         output: @parsed_response,
-        prompt: @prompt
+        prompt: prompt
       )
     end
   end
-end
+end

data/lib/lluminary/validation_error.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
 module Lluminary
   class ValidationError < StandardError
   end
-end 
+end

data/lib/lluminary/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Lluminary
-  VERSION = '0.1.0'
-end 
+  VERSION = "0.1.0"
+end

data/lib/lluminary.rb

@@ -1,10 +1,24 @@
-require_relative 'lluminary/version'
-require_relative 'lluminary/result'
-require_relative 'lluminary/task'
-require_relative 'lluminary/providers/base'
-require_relative 'lluminary/providers/openai'
-require_relative 'lluminary/config'
+# frozen_string_literal: true
 
+require_relative "lluminary/version"
+require_relative "lluminary/result"
+require_relative "lluminary/task"
+# automatically require all providers
+Dir[File.join(__dir__, "lluminary/providers/*.rb")].each { |file| require file }
+# automatically require all models
+Dir[File.join(__dir__, "lluminary/models/**/*.rb")].each { |file| require file }
+require_relative "lluminary/config"
+
+# Lluminary is a framework for building and running LLM-powered tasks.
+# It provides a structured way to define tasks, their inputs and outputs,
+# and handles the interaction with various LLM providers.
+#
+# @example Creating a simple task
+#   class MyTask < Lluminary::Task
+#     def run
+#       # Task implementation
+#     end
+#   end
 module Lluminary
   class << self
     def config
@@ -14,5 +28,9 @@ module Lluminary
     def configure
       yield config
     end
+
+    def reset_configuration
+      @config = Config.new
+    end
   end
-end 
+end

data/spec/examples/analyze_text_spec.rb

@@ -1,8 +1,11 @@
-require 'spec_helper'
-require_relative '../../examples/analyze_text'
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../examples/analyze_text"
 
 RSpec.describe AnalyzeText do
-  let(:text) { "Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write." }
+  let(:text) { <<~TEXT }
+      Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
+    TEXT
 
   it "analyzes text" do
     result = described_class.call(text: text)
@@ -18,4 +21,4 @@ RSpec.describe AnalyzeText do
     expect(json).to have_key("analysis")
     expect(json["analysis"]).to eq(result.output.analysis)
   end
-end 
+end

data/spec/examples/color_analyzer_spec.rb

@@ -1,42 +1,42 @@
-require 'spec_helper'
-require_relative '../../examples/color_analyzer'
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../examples/color_analyzer"
 
 RSpec.describe ColorAnalyzer do
-  describe '#call' do
+  describe "#call" do
     it 'returns "red" for a description strongly suggesting the color red' do
-      result = described_class.call(
-        image_description: "A bright red sports car parked in front of a red brick building at sunset. The car's glossy red paint reflects the warm light, making it appear even more vibrant. A red stop sign stands nearby, and red roses bloom in a garden beside the building."
-      )
+      result = described_class.call(image_description: <<~DESCRIPTION)
+              A bright red sports car parked in front of a red brick building at sunset. The car's glossy red paint reflects the warm light, making it appear even more vibrant. A red stop sign stands nearby, and red roses bloom in a garden beside the building.
+            DESCRIPTION
 
       expect(result.output.color_name).to eq("red")
       expect(result.output.valid?).to be true
     end
 
-    it 'returns invalid output when description strongly suggests orange' do
+    it "returns invalid output when description strongly suggests orange" do
       # This should fail validation because "orange" is not a CSS Level 1 color
-      result = described_class.call(
-        image_description: "A field of ripe oranges under a bright orange sunset. The fruit glows with a warm orange hue, and the sky is painted in shades of orange and gold. Orange butterflies flutter among the trees, and orange flowers bloom throughout the scene."
-      )
+      result = described_class.call(image_description: <<~DESCRIPTION)
+              A field of ripe oranges under a bright orange sunset. The fruit glows with a warm orange hue, and the sky is painted in shades of orange and gold. Orange butterflies flutter among the trees, and orange flowers bloom throughout the scene.
+            DESCRIPTION
 
       expect(result.output.valid?).to be false
-      expect(result.output.errors.full_messages).to include("Color name must be a valid CSS level 1 color name")
+      expect(result.output.errors.full_messages).to include(
+        "Color name must be a valid CSS level 1 color name"
+      )
     end
 
-    it 'validates presence of image_description' do
-      expect {
-        described_class.call!(
-          image_description: ""
-        )
-      }.to raise_error(Lluminary::ValidationError)
+    it "validates presence of image_description" do
+      expect { described_class.call!(image_description: "") }.to raise_error(
+        Lluminary::ValidationError
+      )
     end
 
-    it 'validates that color_name is lowercase' do
-      result = described_class.call(
-        image_description: "A bright red sports car"
-      )
+    it "validates that color_name is lowercase" do
+      result =
+        described_class.call(image_description: "A bright red sports car")
 
       expect(result.output.valid?).to be true
       expect(result.output.color_name).to eq(result.output.color_name.downcase)
     end
   end
-end 
+end