vibe_if 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5fdd14e739691bac5fe7835d8a9fbd5c408e78dec3cdca5105747b964938df06
+  data.tar.gz: 9ed1e59682dfd53a5d4ff57b750ab41f442cb3cb8f6bf3fd195eecf0f3606c01
+SHA512:
+  metadata.gz: a812c63278cacfb65fb9388da8a311678f033397353d59aca46e16a9fbae12bd3259171050045b867786061fe2ff53e2055657881e706e022b0061feaf0b9387
+  data.tar.gz: fc0663882a1ab0d2447e4f746a9bf3aef38069c13e0cce900708c6024d6f25c78edcfaa689b2ad27c068d8147364353ccebd34288665a1ac1240b38f67fb51d9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VibeIf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# VibeIf
+
+A Ruby gem that uses OpenAI to evaluate your instance variables and conditionally execute code blocks based on natural language descriptions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vibe_if'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install vibe_if
+```
+
+## Setup
+
+Create an initializer (e.g., `config/initializers/vibe_if.rb` for Rails) or configure at the top of your script:
+
+```ruby
+require 'vibe_if'
+
+VibeIf.configure do |config|
+  config.openai_api_key = ENV['OPENAI_API_KEY'] # or your API key
+  config.model = 'gpt-3.5-turbo' # optional, defaults to gpt-3.5-turbo
+end
+```
+
+## Usage
+
+Use the `vibe_if` method on any object to conditionally execute code based on natural language conditions:
+
+```ruby
+class User
+  def initialize(name, age, status)
+    @name = name
+    @age = age
+    @status = status
+  end
+
+  def check_eligibility
+    vibe_if "user is an adult and active" do
+      puts "#{@name} is eligible!"
+    end
+
+    vibe_if "user seems unhappy or inactive" do
+      puts "Reaching out to #{@name}..."
+    end
+  end
+end
+
+user = User.new("Alice", 25, "active")
+user.check_eligibility
+```
+
+The gem will send your instance variables to OpenAI, which evaluates the condition and returns true/false to determine whether the block should execute.
+
+## Environment Variables
+
+Set your OpenAI API key:
+```bash
+export OPENAI_API_KEY="your-openai-api-key-here"
+```
+
+## Inspiration
+
+This gem was inspired by [vibesort](https://github.com/abyesilyurt/vibesort), a Python library that uses GPT for AI-powered array sorting.
+
+## License
+
+The gem is available as open source under the [MIT License](LICENSE).

data/lib/vibe_if/configuration.rb

@@ -0,0 +1,23 @@
+module VibeIf
+  # Configuration class for VibeIf settings.
+  # Manages OpenAI API credentials and model parameters.
+  class Configuration
+    # @!attribute [rw] openai_api_key
+    #   @return [String, nil] the OpenAI API key for authentication
+    # @!attribute [rw] model
+    #   @return [String] the OpenAI model to use for evaluation (default: "gpt-3.5-turbo")
+    # @!attribute [rw] max_tokens
+    #   @return [Integer] maximum tokens for the AI response (default: 10)
+    # @!attribute [rw] temperature
+    #   @return [Float] temperature setting for AI responses, lower values are more deterministic (default: 0.1)
+    attr_accessor :openai_api_key, :model, :max_tokens, :temperature
+
+    # Initializes a new Configuration with default values.
+    def initialize
+      @openai_api_key = nil
+      @model = "gpt-3.5-turbo"
+      @max_tokens = 50
+      @temperature = 0.1
+    end
+  end
+end

data/lib/vibe_if/evaluator.rb

@@ -0,0 +1,118 @@
+require 'openai'
+require 'json'
+
+module VibeIf
+  # Evaluator handles the AI-powered evaluation of natural language conditions.
+  # It extracts context from objects and uses OpenAI to determine condition truthiness.
+  class Evaluator
+    # Initializes the evaluator with a context object.
+    # 
+    # @param context_object [Object] the object whose state will be evaluated
+    # @raise [RuntimeError] if OpenAI API key is not configured
+    def initialize(context_object)
+      @context_object = context_object
+      @config = VibeIf.configuration
+      validate_configuration
+    end
+
+    # Evaluates a natural language condition against the context object.
+    # 
+    # @param condition_description [String] the condition to evaluate in natural language
+    # @return [Boolean] true if the condition is met, false otherwise
+    # @raise [RuntimeError] if evaluation fails due to API errors or other issues
+    # 
+    # @example Nuanced writing quality assessment
+    #   essay = StudentEssay.new(
+    #     text: "Technology has revolutionized our lives. It helps us connect with people. But also creates problems like addiction and privacy issues.",
+    #     grade_level: "high_school",
+    #     word_count: 1200,
+    #     assignment: "argumentative_essay"
+    #   )
+    #   evaluator = VibeIf::Evaluator.new(essay)
+    #   evaluator.evaluate("this essay demonstrates sophisticated critical thinking and analysis")
+    #   # => false (LLM detects simplistic reasoning despite meeting word count)
+    # 
+    # @example Intent detection from ambiguous text
+    #   message = CustomerMessage.new(
+    #     text: "I guess the product is fine for what it is",
+    #     context: "post_purchase_survey",
+    #     customer_history: "previous_complaints",
+    #     product_category: "premium"
+    #   )
+    #   evaluator = VibeIf::Evaluator.new(message)
+    #   evaluator.evaluate("this customer is expressing subtle dissatisfaction")
+    #   # => true (LLM detects lukewarm sentiment and contextual disappointment)
+    def evaluate(condition_description)
+      variables = extract_variables
+      prompt = build_prompt(condition_description, variables)
+      
+      response = openai_client.chat.completions.create(
+        model: @config.model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: @config.max_tokens,
+        temperature: @config.temperature
+      )
+
+      parse_response(response)
+    rescue => e
+      raise "VibeIf evaluation failed: #{e.message}"
+    end
+
+    private
+
+    def validate_configuration
+      return if @config.openai_api_key
+
+      raise "OpenAI API key not configured. Use VibeIf.configure to set it."
+    end
+
+    def openai_client
+      @openai_client ||= OpenAI::Client.new(api_key: @config.openai_api_key)
+    end
+
+    def extract_variables
+      variables = {}
+      
+      @context_object.instance_variables.each do |var|
+        name = var.to_s.delete('@')
+        value = @context_object.instance_variable_get(var)
+        variables[name] = serialize_value(value)
+      end
+      
+      variables
+    end
+
+    def serialize_value(value)
+      case value
+      when String, Numeric, TrueClass, FalseClass, NilClass
+        value
+      when Array, Hash
+        value.inspect
+      else
+        value.to_s
+      end
+    end
+
+    def build_prompt(condition_description, variables)
+      variables_text = variables.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
+      
+      <<~PROMPT
+        You are evaluating whether a condition is true based on the given data.
+
+        Object data:
+        #{variables_text}
+
+        Condition to evaluate: "#{condition_description}"
+
+        Consider the context and meaning carefully. For content quality, look for evidence-based information, credible sources, and reasonable claims. For sentiment, consider tone and subtext beyond surface words.
+
+        Respond with exactly "true" or "false" (no quotes, no explanation).
+      PROMPT
+    end
+
+    def parse_response(response)
+      result = response.choices.first.message.content&.strip&.downcase
+      result == "true"
+    end
+  end
+end

data/lib/vibe_if/version.rb

@@ -0,0 +1,3 @@
+module VibeIf
+  VERSION = "0.1.2"
+end

data/lib/vibe_if.rb

@@ -0,0 +1,85 @@
+require "vibe_if/version"
+require "vibe_if/configuration"
+require "vibe_if/evaluator"
+
+# VibeIf provides natural language conditional evaluation using AI.
+# It allows you to write conditions in plain English that are evaluated
+# based on the current object's state.
+module VibeIf
+  class << self
+    # Returns the current configuration instance.
+    # 
+    # @return [VibeIf::Configuration] the configuration object
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configures VibeIf by yielding the configuration object to a block.
+    # 
+    # @yield [config] the configuration object to modify
+    # @yieldparam config [VibeIf::Configuration] the configuration instance
+    # 
+    # @example
+    #   VibeIf.configure do |config|
+    #     config.openai_api_key = "your-api-key"
+    #     config.model = "gpt-4"
+    #   end
+    def configure
+      yield(configuration)
+    end
+  end
+end
+
+class Object
+  # Evaluates a natural language condition against the current object's state.
+  # Uses AI to determine if the condition is true or false based on instance variables.
+  # 
+  # @param condition_description [String] the condition to evaluate in natural language
+  # @yield optional block to execute if condition is true
+  # @return [Boolean] true if condition evaluates to true, false otherwise
+  # 
+  # @example Sentiment-based content promotion
+  #   review = Review.new(
+  #     text: "The food was okay but the service was incredibly rude and slow",
+  #     rating: 3,
+  #     restaurant_tier: "premium"
+  #   )
+  #   review.vibe_if("this review expresses genuine disappointment despite the neutral rating") do
+  #     review.escalate_to_management!
+  #   end
+  #   # => true (LLM detects negative sentiment despite 3-star rating)
+  # 
+  # @example Context-aware content quality assessment
+  #   article = BlogPost.new(
+  #     title: "10 Ways to Lose Weight Fast",
+  #     content: "Drink this magic tea and lose 20 pounds in 3 days!",
+  #     author_credentials: "fitness_blogger",
+  #     word_count: 500
+  #   )
+  #   unless article.vibe_if("this content provides valuable, evidence-based information")
+  #     article.demote_in_search!
+  #   end
+  #   # => false (LLM detects questionable health claims)
+  # 
+  # @example Intelligent customer support routing
+  #   ticket = SupportTicket.new(
+  #     subject: "My order never arrived",
+  #     message: "I'm really frustrated, this is the third time this happened",
+  #     customer_tier: "vip",
+  #     previous_issues: 2
+  #   )
+  #   ticket.vibe_if("this customer seems genuinely upset and needs immediate attention") do
+  #     ticket.assign_to_senior_agent!
+  #   end
+  #   # => true (LLM detects frustration and escalation patterns)
+  def vibe_if(condition_description, &block)
+    evaluator = VibeIf::Evaluator.new(self)
+    
+    if evaluator.evaluate(condition_description)
+      yield if block_given?
+      true
+    else
+      false
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: vibe_if
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- CuddlyBunion341
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: A Ruby gem that uses OpenAI to evaluate instance variables and local
+  variables, returning true/false to conditionally execute code blocks. Inspired by
+  vibesort (https://github.com/abyesilyurt/vibesort).
+email:
+- daniel.bengl@renuo.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/vibe_if.rb
+- lib/vibe_if/configuration.rb
+- lib/vibe_if/evaluator.rb
+- lib/vibe_if/version.rb
+homepage: https://github.com/CuddlyBunion341/vibe_if
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/CuddlyBunion341/vibe_if
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: GPT-powered conditional execution based on variable values
+test_files: []