lluminary 0.1.0

data/lib/lluminary/task.rb

@@ -0,0 +1,224 @@
+require 'ostruct'
+require_relative 'schema'
+require_relative 'validation_error'
+require_relative 'field_description'
+require 'json'
+
+module Lluminary
+  class Task
+    class << self
+      def input_schema(&block)
+        @input_schema = Schema.new
+        @input_schema.instance_eval(&block)
+      end
+
+      def output_schema(&block)
+        @output_schema = Schema.new
+        @output_schema.instance_eval(&block)
+      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 = provider_class.new(**merged_config)
+      end
+
+      def call(input = {})
+        new(input).call
+      end
+
+      def call!(input = {})
+        new(input).call!
+      end
+
+      def provider
+        @provider ||= begin
+          require_relative 'providers/test'
+          Providers::Test.new
+        end
+      end
+
+      def provider=(provider)
+        @provider = provider
+      end
+
+      def input_fields
+        @input_schema&.fields || {}
+      end
+
+      def output_fields
+        @output_schema&.fields || {}
+      end
+
+      def input_schema_model
+        @input_schema&.schema_model || Schema.new.schema_model
+      end
+
+      def output_schema_model
+        @output_schema&.schema_model || Schema.new.schema_model
+      end
+    end
+
+    attr_reader :input, :output, :parsed_response
+
+    def initialize(input = {})
+      @input = self.class.input_schema_model.new(input)
+      define_input_methods
+    end
+
+    def call
+      if valid?
+        response = self.class.provider.call(prompt, self)
+        process_response(response)
+      else
+        @parsed_response = nil
+        @output = nil
+      end
+
+      self
+    end
+
+    def call!
+      validate_input!
+      response = self.class.provider.call(prompt, self)
+      process_response(response)
+      
+      self
+    end
+
+    def valid?
+      @input.valid?
+    end
+
+    def validate_input!
+      unless @input.valid?
+        raise ValidationError, @input.errors.full_messages.join(", ")
+      end
+    end
+
+    def prompt
+      base_prompt = <<~PROMPT
+        #{task_prompt}
+
+        #{json_schema_example}
+      PROMPT
+    end
+
+    private
+
+    def validate_input
+      validate_input!
+    end
+
+    def process_response(response)
+      @parsed_response = response[:parsed]
+      @output = self.class.output_schema_model.new
+      @output.raw_response = response[:raw]
+
+      # 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
+
+        # 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
+          end
+        end
+
+        @output.attributes.merge!(converted_response)
+      end
+      
+      # Validate after merging
+      @output.valid?
+
+      @prompt = prompt
+    end
+
+    def define_input_methods
+      self.class.input_fields.each_key do |name|
+        define_singleton_method(name) { @input.attributes[name.to_s] }
+      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
+      )
+    end
+  end
+end

data/lib/lluminary/validation_error.rb

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

data/lib/lluminary/version.rb

@@ -0,0 +1,3 @@
+module Lluminary
+  VERSION = '0.1.0'
+end 

data/lib/lluminary.rb

@@ -0,0 +1,18 @@
+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'
+
+module Lluminary
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end 

data/spec/examples/analyze_text_spec.rb

@@ -0,0 +1,21 @@
+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." }
+
+  it "analyzes text" do
+    result = described_class.call(text: text)
+    expect(result.output.analysis).to be_a(String)
+    expect(result.output.analysis).not_to be_empty
+  end
+
+  it "returns JSON response" do
+    result = described_class.call(text: text)
+    expect(result.output.raw_response).to be_a(String)
+    expect { JSON.parse(result.output.raw_response) }.not_to raise_error
+    json = JSON.parse(result.output.raw_response)
+    expect(json).to have_key("analysis")
+    expect(json["analysis"]).to eq(result.output.analysis)
+  end
+end 

data/spec/examples/color_analyzer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require_relative '../../examples/color_analyzer'
+
+RSpec.describe ColorAnalyzer 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."
+      )
+
+      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
+      # 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."
+      )
+
+      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")
+    end
+
+    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"
+      )
+
+      expect(result.output.valid?).to be true
+      expect(result.output.color_name).to eq(result.output.color_name.downcase)
+    end
+  end
+end 

data/spec/examples/content_analyzer_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require_relative '../../examples/content_analyzer'
+
+RSpec.describe ContentAnalyzer do
+  let(:technical_text) do
+    <<~TEXT
+      The revolutionary new quantum processor leverages advanced photonic circuits to achieve unprecedented computational speeds. 
+      By utilizing entangled photon pairs, it can perform complex calculations in parallel, significantly reducing processing time.
+      This breakthrough technology represents a major advancement in quantum computing.
+    TEXT
+  end
+
+  let(:emotional_text) do
+    <<~TEXT
+      I can't believe how amazing this experience was! My heart was racing with excitement as I watched the performance. 
+      The raw emotion and passion in every movement brought tears to my eyes. It was truly a transformative moment that I'll never forget.
+    TEXT
+  end
+
+  describe '#call' do
+    it 'correctly identifies technical content' do
+      result = described_class.call(
+        text: technical_text,
+        content_type: "technical"
+      )
+
+      expect(result.output.contains_type).to be true
+    end
+
+    it 'correctly identifies non-technical content' do
+      result = described_class.call(
+        text: emotional_text,
+        content_type: "technical"
+      )
+
+      expect(result.output.contains_type).to be false
+    end
+
+    it 'correctly identifies emotional content' do
+      result = described_class.call(
+        text: emotional_text,
+        content_type: "emotional"
+      )
+
+      expect(result.output.contains_type).to be true
+    end
+
+    it 'correctly identifies non-emotional content' do
+      result = described_class.call(
+        text: technical_text,
+        content_type: "emotional"
+      )
+
+      expect(result.output.contains_type).to be false
+    end
+
+    it 'validates presence of text' do
+      expect {
+        described_class.call!(
+          text: "",
+          content_type: "technical"
+        )
+      }.to raise_error(Lluminary::ValidationError)
+    end
+
+    it 'validates presence of content_type' do
+      expect {
+        described_class.call!(
+          text: technical_text,
+          content_type: ""
+        )
+      }.to raise_error(Lluminary::ValidationError)
+    end
+  end
+end 

data/spec/examples/historical_event_analyzer_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require_relative '../../examples/historical_event_analyzer'
+require 'pry-byebug'
+
+RSpec.describe HistoricalEventAnalyzer do
+  describe '#call' do
+    context 'with events that have known exact times' do
+      it 'returns the exact time of the human step on the moon' do
+        result = described_class.call(
+          event_description: "Neil Armstrong's first step onto the Moon"
+        )
+
+        expect(result.output.valid?).to be true
+        expect(result.output.event_datetime).to be_a(DateTime)
+        # LLMs are too flaky to get the exact date and time correct, at least with my prompt.
+        expect(result.output.event_datetime.year).to eq(1969)
+        expect(result.output.event_datetime.month).to eq(7)
+        expect(result.output.exact_time_is_known).to be true
+      end
+    end
+
+    context 'with events that have approximate times' do
+      it 'returns midnight for the fall of the Roman Empire' do
+        result = described_class.call(
+          event_description: "Assassination of Julius Caesar"
+        )
+
+        expect(result.output.valid?).to be true
+        expect(result.output.event_datetime).to be_a(DateTime)
+        expect(result.output.event_datetime.year).to eq(44)
+        expect(result.output.event_datetime.month).to eq(3)
+        expect(result.output.event_datetime.day).to eq(15)
+        expect(result.output.exact_time_is_known).to be false
+      end
+    end
+  end
+end 

data/spec/examples/price_analyzer_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require_relative '../../examples/price_analyzer'
+
+RSpec.describe PriceAnalyzer do
+  describe '#call' do
+    it 'returns a competitiveness score between 0.0 and 1.0 for a high-priced item' do
+      result = described_class.call(
+        product_name: "Entry LevelLuxury Watch",
+        price: 999.99
+      )
+
+      expect(result.output.competitiveness_score).to be_a(Float)
+      expect(result.output.competitiveness_score).to be_between(0.0, 1.0)
+      expect(result.output.competitiveness_score).to be >= 0.5 # Lower priced luxury watch is more competitive
+    end
+
+    it 'returns a higher competitiveness score for a reasonably priced item' do
+      result = described_class.call(
+        product_name: "Basic Watch",
+        price: 10049.99
+      )
+
+      expect(result.output.competitiveness_score).to be_a(Float)
+      expect(result.output.competitiveness_score).to be_between(0.0, 1.0)
+      expect(result.output.competitiveness_score).to be <= 0.5 # Higher priced basic watch is less competitive
+    end
+
+    it 'validates presence of product_name' do
+      expect {
+        described_class.call!(
+          product_name: "",
+          price: 49.99
+        )
+      }.to raise_error(Lluminary::ValidationError)
+    end
+
+    it 'validates presence of price' do
+      expect {
+        described_class.call!(
+          product_name: "Basic Watch",
+          price: nil
+        )
+      }.to raise_error(Lluminary::ValidationError)
+    end
+  end
+end 

data/spec/examples/quote_task_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require_relative '../../examples/quote_task'
+
+RSpec.describe QuoteTask do
+  describe '.call' do
+    it 'returns a quote and its author' do
+      result = described_class.call
+
+      expect(result.output.quote).to be_a(String)
+      expect(result.output.quote).not_to be_empty
+      
+      expect(result.output.author).to be_a(String)
+      expect(result.output.author).not_to be_empty
+    end
+
+    it 'can be called without any input parameters' do
+      expect { described_class.call }.not_to raise_error
+    end
+
+    it 'returns a valid result object' do
+      result = described_class.call
+      expect(result).to be_a(Lluminary::Task)
+      expect(result.input).to be_a(Lluminary::SchemaModel)
+      expect(result.input.valid?).to be true
+    end
+  end
+end 

data/spec/examples/sentiment_analysis_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require_relative '../../examples/sentiment_analysis'
+
+RSpec.describe SentimentAnalysis do
+  let(:text) { "I absolutely love this new feature!" }
+
+  describe '.call' do
+    it 'analyzes sentiment of given text' do
+      result = described_class.call(text: text)
+      
+      expect(result.output.sentiment).to be_a(String)
+      expect(result.output.sentiment).not_to be_empty
+      expect(result.output.explanation).to be_a(String)
+      expect(result.output.explanation).not_to be_empty
+      expect(result.output.confidence).to be_a(Integer)
+      expect(result.output.confidence).to be_between(0, 100)
+    end
+
+    it 'returns valid JSON response' do
+      result = described_class.call(text: text)
+      expect(result.output.raw_response).to be_a(String)
+      expect { JSON.parse(result.output.raw_response) }.not_to raise_error
+      json = JSON.parse(result.output.raw_response)
+      expect(json).to have_key("sentiment")
+      expect(json).to have_key("explanation")
+      expect(json).to have_key("confidence")
+      expect(json["sentiment"]).to eq(result.output.sentiment)
+      expect(json["explanation"]).to eq(result.output.explanation)
+      expect(json["confidence"]).to eq(result.output.confidence)
+    end
+
+    it 'requires text input' do
+      result = described_class.call({})
+      expect(result.valid?).to be false
+      expect(result.input.errors.full_messages).to include("Text can't be blank")
+    end
+
+    it 'returns a valid result object' do
+      result = described_class.call(text: text)
+      expect(result).to be_a(Lluminary::Task)
+      expect(result.input).to be_a(Lluminary::SchemaModel)
+      expect(result.input.valid?).to be true
+    end
+  end
+end 

data/spec/examples/summarize_text_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require_relative '../../examples/summarize_text'
+
+RSpec.describe SummarizeText 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." }
+
+  it "summarizes text" do
+    result = described_class.call(text: text)
+    expect(result.output.summary).to be_a(String)
+    expect(result.output.summary).not_to be_empty
+  end
+
+  it "returns JSON response" do
+    result = described_class.call(text: text)
+    expect(result.output.raw_response).to be_a(String)
+    expect { JSON.parse(result.output.raw_response) }.not_to raise_error
+    json = JSON.parse(result.output.raw_response)
+    expect(json).to have_key("summary")
+    expect(json["summary"]).to eq(result.output.summary)
+  end
+end 

data/spec/lluminary/config_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe Lluminary::Config do
+  let(:config) { described_class.new }
+
+  describe '#configure' do
+    it 'allows setting provider configurations' do
+      config.configure do |c|
+        c.provider(:openai, api_key: 'global-key')
+        c.provider(:bedrock, 
+          access_key_id: 'global-access-key',
+          secret_access_key: 'global-secret-key',
+          region: 'us-east-1'
+        )
+      end
+
+      expect(config.provider_config(:openai)).to eq({ api_key: 'global-key' })
+      expect(config.provider_config(:bedrock)).to eq({
+        access_key_id: 'global-access-key',
+        secret_access_key: 'global-secret-key',
+        region: 'us-east-1'
+      })
+    end
+  end
+
+  describe '#provider_config' do
+    it 'returns empty hash for unconfigured providers' do
+      expect(config.provider_config(:unknown)).to eq({})
+    end
+
+    it 'returns the configuration for a configured provider' do
+      config.configure do |c|
+        c.provider(:openai, api_key: 'test-key')
+      end
+
+      expect(config.provider_config(:openai)).to eq({ api_key: 'test-key' })
+    end
+  end
+
+  describe '#reset!' do
+    it 'clears all provider configurations' do
+      config.configure do |c|
+        c.provider(:openai, api_key: 'test-key')
+        c.provider(:bedrock, access_key_id: 'test-access-key')
+      end
+
+      config.reset!
+
+      expect(config.provider_config(:openai)).to eq({})
+      expect(config.provider_config(:bedrock)).to eq({})
+    end
+  end
+end 

data/spec/lluminary/field_description_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe Lluminary::FieldDescription do
+  describe '#to_s' do
+    it 'generates a description for a string field' do
+      field = {
+        type: :string,
+        description: 'A test field'
+      }
+      description = described_class.new('test_field', field)
+      expect(description.to_s).to eq('test_field (string): A test field')
+    end
+
+    it 'generates a description for a field without a description' do
+      field = {
+        type: :integer
+      }
+      description = described_class.new('count', field)
+      expect(description.to_s).to eq('count (integer)')
+    end
+
+    it 'includes validation descriptions when present' do
+      field = {
+        type: :string,
+        description: 'A test field',
+        validations: [
+          [{}, { length: { minimum: 5, maximum: 10 } }],
+          [{}, { format: { with: '/^[A-Z]+$/' } }]
+        ]
+      }
+      description = described_class.new('test_field', field)
+      expected = 'test_field (string): A test field (must be at least 5 characters, must be at most 10 characters, must match format: /^[A-Z]+$/)'
+      expect(description.to_s).to eq(expected)
+    end
+  end
+end 

data/spec/lluminary/providers/base_spec.rb

@@ -0,0 +1,17 @@
+require 'lluminary'
+
+RSpec.describe Lluminary::Providers::Base do
+  describe '#initialize' do
+    it 'accepts configuration options' do
+      config = { api_key: 'test_key', model: 'test_model' }
+      provider = described_class.new(**config)
+      expect(provider.config).to eq(config)
+    end
+  end
+
+  describe '#call' do
+    it 'raises NotImplementedError' do
+      expect { described_class.new.call('test', double('Task')) }.to raise_error(NotImplementedError)
+    end
+  end
+end