chaos_to_the_rescue 0.1.0

data/examples/guidance_and_verification.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+# Example: Using ChaosGuidance and Verification Features
+#
+# This example demonstrates three key features:
+# 1. Providing guidance when defining methods (chaos_guidance)
+# 2. Adding guidance to existing methods (additional_chaos_guidance)
+# 3. Verifying method outputs with optional auto-fix (verify!)
+
+require "chaos_to_the_rescue"
+
+# Configure the gem
+ChaosToTheRescue.configure do |config|
+  config.enabled = true
+  config.auto_define_methods = true
+  config.allow_everything!
+  config.openai_api_key = ENV["OPENAI_API_KEY"] # or use ENV variable
+end
+
+# Example 1: Provide guidance when defining methods
+# ==================================================
+class Calculator
+  include ChaosToTheRescue::ChaosRescue
+  chaos_rescue_enabled!
+
+  # Add guidance BEFORE the method is generated
+  # This helps the LLM understand edge cases and requirements
+  chaos_guidance :pow, <<~GUIDANCE
+    This method should correctly handle negative bases:
+    - Negative base with even exponent should return positive: (-5)^2 = 25
+    - Negative base with odd exponent should return negative: (-5)^3 = -125
+
+    Common mistake: Using base.abs which always returns positive results.
+    Correct approach: Use base ** exponent directly.
+  GUIDANCE
+
+  # When this method is generated, the LLM will see the guidance above
+  # and create a correct implementation
+end
+
+# Example 2: Add guidance to existing methods
+# ============================================
+class ScientificCalculator
+  include ChaosToTheRescue::ChaosRescue
+  chaos_rescue_enabled!
+
+  # Already defined method with a bug
+  def sqrt(n)
+    Math.sqrt(n) # Bug: doesn't handle negative numbers
+  end
+
+  # Add guidance after the method is defined
+  # This is useful for documenting expected behavior for verification
+  additional_chaos_guidance :sqrt, <<~GUIDANCE
+    For negative inputs, this should return a complex number:
+    sqrt(-4) should return (0+2i), not NaN or raise an error.
+
+    Use Complex math when input is negative.
+  GUIDANCE
+end
+
+# You can also add global guidance in configuration
+ChaosToTheRescue.configure do |config|
+  config.method_guidance[:divide] = <<~GUIDANCE
+    Handle division by zero gracefully:
+    - Return Float::INFINITY for positive numerator
+    - Return -Float::INFINITY for negative numerator
+    - Return Float::NAN for 0/0
+  GUIDANCE
+end
+
+# Example 3: Verify method outputs
+# =================================
+
+# 3a. Simple verification without auto-fix
+puts "=== Example 3a: Simple Verification ==="
+result = Calculator.verify_chaos(:pow, -5, 2)
+
+if result.passed?
+  puts "✓ Method works correctly!"
+  puts "  Diagnosis: #{result.diagnosis}"
+else
+  puts "✗ Method has issues:"
+  puts "  Diagnosis: #{result.diagnosis}"
+  puts "  Suggestion: #{result.suggestion}"
+  puts "  Actual result: #{result.actual_result}"
+end
+
+# 3b. Verification with auto-fix enabled
+puts "\n=== Example 3b: Verification with Auto-Fix ==="
+calc = ScientificCalculator.new
+
+# This will verify the method and automatically apply a fix if needed
+result = ScientificCalculator.verify_chaos(:sqrt, -4, auto_apply: true)
+
+if result.failed?
+  puts "✗ Original implementation was incorrect"
+  puts "  Diagnosis: #{result.diagnosis}"
+  puts "🔧 Fix has been automatically applied!"
+  puts "  Fixed code:\n#{result.fixed_code}"
+
+  # Try again with the fixed implementation
+  new_result = calc.sqrt(-4)
+  puts "  New result: #{new_result}"
+end
+
+# 3c. Verification using block syntax
+puts "\n=== Example 3c: Block-based Verification ==="
+
+# More convenient syntax for one-off verifications
+result = ChaosToTheRescue.verify do
+  Calculator.new.pow(-5, 3)
+end
+
+puts result.passed? ? "✓ Passed" : "✗ Failed: #{result.diagnosis}"
+
+# 3d. Verification with auto-fix using block syntax
+puts "\n=== Example 3d: Block-based Verification with Auto-Fix ==="
+
+result = ChaosToTheRescue.verify(auto_apply: true) do
+  Calculator.new.pow(-5, 2)
+end
+
+if result.failed?
+  puts "Method was incorrect and has been fixed!"
+  puts "Actual result was: #{result.actual_result}"
+end
+
+# Example 4: Comprehensive workflow
+# ==================================
+puts "\n=== Example 4: Comprehensive Workflow ==="
+
+class MathLibrary
+  include ChaosToTheRescue::ChaosRescue
+  chaos_rescue_enabled!
+
+  # Step 1: Add guidance for a method that will be generated
+  chaos_guidance :factorial, <<~GUIDANCE
+    Calculate factorial recursively or iteratively.
+    - factorial(0) = 1
+    - factorial(1) = 1
+    - factorial(5) = 120
+    - Should handle negative inputs by raising ArgumentError
+    - Should handle large inputs efficiently (consider iterative approach)
+  GUIDANCE
+
+  chaos_guidance :fibonacci, <<~GUIDANCE
+    Calculate the nth Fibonacci number.
+    - fibonacci(0) = 0
+    - fibonacci(1) = 1
+    - fibonacci(10) = 55
+    - Use memoization or dynamic programming for efficiency
+  GUIDANCE
+end
+
+# Step 2: Call the methods (they'll be generated with guidance)
+math = MathLibrary.new
+
+begin
+  result1 = math.factorial(5)
+  puts "factorial(5) = #{result1}"
+rescue => e
+  puts "Error: #{e.message}"
+end
+
+begin
+  result2 = math.fibonacci(10)
+  puts "fibonacci(10) = #{result2}"
+rescue => e
+  puts "Error: #{e.message}"
+end
+
+# Step 3: Verify the implementations
+puts "\nVerifying implementations..."
+
+verification1 = MathLibrary.verify_chaos(:factorial, 5)
+puts "factorial verification: #{verification1.passed? ? "✓" : "✗"}"
+puts "  Diagnosis: #{verification1.diagnosis}"
+
+verification2 = MathLibrary.verify_chaos(:fibonacci, 10, auto_apply: true)
+puts "fibonacci verification: #{verification2.passed? ? "✓" : "✗ (auto-fixed)"}"
+puts "  Diagnosis: #{verification2.diagnosis}"
+
+# Example 5: Testing edge cases
+# ==============================
+puts "\n=== Example 5: Testing Edge Cases ==="
+
+class EdgeCaseCalculator
+  include ChaosToTheRescue::ChaosRescue
+  chaos_rescue_enabled!
+
+  chaos_guidance :safe_divide, <<~GUIDANCE
+    Division with edge case handling:
+    - safe_divide(10, 2) = 5.0
+    - safe_divide(10, 0) should return nil or Float::INFINITY (not raise error)
+    - safe_divide(-10, 0) should return -Float::INFINITY
+    - safe_divide(0, 0) should return nil or Float::NAN
+  GUIDANCE
+
+  def safe_divide(a, b)
+    # Intentionally buggy - doesn't handle division by zero
+    a / b
+  end
+end
+
+# Verify with specific test cases
+puts "Testing safe_divide(10, 0)..."
+result = ChaosToTheRescue.verify do
+  EdgeCaseCalculator.new.safe_divide(10, 0)
+end
+
+if result.failed?
+  puts "✗ Edge case not handled:"
+  puts "  #{result.diagnosis}"
+  puts "  Suggestion: #{result.suggestion}"
+end
+
+puts "\n" + "=" * 60
+puts "Examples complete!"
+puts "=" * 60
+puts "\nKey takeaways:"
+puts "1. Use 'chaos_guidance' to provide hints for method generation"
+puts "2. Use 'additional_chaos_guidance' (alias) for existing methods"
+puts "3. Use 'verify_chaos' or 'ChaosToTheRescue.verify' to check outputs"
+puts "4. Use 'auto_apply: true' to automatically fix incorrect implementations"
+puts "5. Guidance helps LLMs understand edge cases and requirements"

data/lib/chaos_to_the_rescue/chaos_rescue.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module ChaosToTheRescue
+  # Core module that provides method_missing-based LLM method generation
+  module ChaosRescue
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_variable_set(:@@chaos_rescue_enabled, false)
+      base.class_variable_set(:@@chaos_method_guidance, {})
+    end
+
+    # Class methods for enabling/disabling ChaosRescue per class
+    module ClassMethods
+      # Enable ChaosRescue for this class specifically
+      def chaos_rescue_enabled!
+        class_variable_set(:@@chaos_rescue_enabled, true)
+      end
+
+      # Disable ChaosRescue for this class specifically
+      def chaos_rescue_disabled!
+        class_variable_set(:@@chaos_rescue_enabled, false)
+      end
+
+      # Check if ChaosRescue is enabled for this class
+      # @return [Boolean]
+      def chaos_rescue_enabled?
+        class_variable_get(:@@chaos_rescue_enabled)
+      end
+
+      # Add guidance for a method to help the LLM generate correct implementations
+      # @param method_name [Symbol] the method name
+      # @param guidance [String] guidance text for the LLM
+      # @return [void]
+      def chaos_guidance(method_name, guidance)
+        guidance_hash = class_variable_get(:@@chaos_method_guidance)
+        guidance_hash[method_name.to_sym] = guidance
+        class_variable_set(:@@chaos_method_guidance, guidance_hash)
+        ChaosToTheRescue.logger.debug("Added guidance for #{name}##{method_name}")
+      end
+
+      # Alias for adding guidance to existing methods
+      alias_method :additional_chaos_guidance, :chaos_guidance
+
+      # Get guidance for a method
+      # @param method_name [Symbol] the method name
+      # @return [String, nil] the guidance text or nil
+      def chaos_method_guidance
+        class_variable_get(:@@chaos_method_guidance)
+      end
+
+      # Verify a method call
+      # @param method_name [Symbol] the method name
+      # @param args [Array] arguments to pass
+      # @param auto_apply [Boolean] whether to automatically apply fixes
+      # @return [Verifier::VerificationResult]
+      def verify_chaos(method_name, *args, auto_apply: false, **kwargs)
+        verifier = Verifier.new
+        instance = new
+        verifier.verify(
+          object: instance,
+          method_name: method_name,
+          args: args,
+          kwargs: kwargs,
+          auto_apply: auto_apply
+        )
+      end
+
+      # Handle missing class methods by generating them via LLM
+      def method_missing(method_name, *args, **kwargs, &block)
+        # Check if enabled (globally or per-class)
+        unless class_enabled?
+          ChaosToTheRescue.logger.debug("ChaosRescue disabled for #{name}.#{method_name}")
+          return super
+        end
+
+        # Check if method name is allowed
+        unless ChaosToTheRescue.configuration.method_allowed?(method_name)
+          ChaosToTheRescue.logger.debug("Method #{method_name} not in allowlist or patterns")
+          return super
+        end
+
+        ChaosToTheRescue.logger.info("Attempting to generate class method: #{name}.#{method_name}")
+
+        begin
+          # Generate the method code via LLM
+          result = generate_class_method(method_name, args, kwargs)
+
+          # If auto_define_methods is enabled, define the method on the class
+          if ChaosToTheRescue.configuration.auto_define_methods && result[:ruby_code]
+            define_generated_class_method(method_name, result[:ruby_code])
+
+            # Call the newly defined method
+            ChaosToTheRescue.logger.info("🚀 Executing generated class method: #{name}.#{method_name}")
+            if kwargs.empty?
+              send(method_name, *args, &block)
+            else
+              send(method_name, *args, **kwargs, &block)
+            end
+          else
+            # Return the generated code without executing it
+            ChaosToTheRescue.logger.info("Generated class method code (not auto-defined): #{result[:ruby_code]}")
+            result
+          end
+        rescue LLMClient::LLMNotAvailableError => e
+          ChaosToTheRescue.logger.error("LLM not available: #{e.message}")
+          raise
+        rescue => e
+          ChaosToTheRescue.logger.error("Failed to generate class method #{method_name}: #{e.message}")
+          super
+        end
+      end
+
+      # Properly handle respond_to? for missing class methods
+      def respond_to_missing?(method_name, include_private = false)
+        if class_enabled? && ChaosToTheRescue.configuration.method_allowed?(method_name)
+          true
+        else
+          super
+        end
+      end
+
+      private
+
+      # Check if ChaosRescue is enabled for this class
+      # @return [Boolean]
+      def class_enabled?
+        # Check global configuration first
+        return false unless ChaosToTheRescue.configuration.enabled
+
+        # Then check class-level setting
+        chaos_rescue_enabled?
+      end
+
+      # Generate class method code via LLM client
+      # @param method_name [Symbol] the method name
+      # @param args [Array] the arguments passed
+      # @param kwargs [Hash] the keyword arguments passed
+      # @return [Hash] the generated method info
+      def generate_class_method(method_name, args, kwargs)
+        # Get guidance if available
+        guidance = get_method_guidance(method_name)
+
+        context = {
+          method_name: method_name,
+          class_name: name,
+          class_method: true,
+          args: args,
+          kwargs: kwargs,
+          guidance: guidance,
+          additional_context: build_class_context_string(method_name, args, kwargs)
+        }
+
+        llm_client.generate_method_code(context)
+      end
+
+      # Define the generated class method
+      # @param method_name [Symbol] the method name
+      # @param code [String] the Ruby code to define
+      def define_generated_class_method(method_name, code)
+        ChaosToTheRescue.logger.info("🤖 Defining generated class method: #{name}.#{method_name}")
+        ChaosToTheRescue.logger.debug("Generated code:\n#{code}")
+
+        begin
+          # WARNING: This executes LLM-generated code!
+          # The code should contain a class definition that reopens the class and adds the class method
+          # We eval it in the context of the main object to allow class definitions
+          eval(code, TOPLEVEL_BINDING)
+
+          ChaosToTheRescue.logger.info("✅ Successfully defined #{name}.#{method_name}")
+        rescue => e
+          ChaosToTheRescue.logger.error("❌ Failed to define class method #{method_name}: #{e.message}")
+          ChaosToTheRescue.logger.error("Backtrace: #{e.backtrace.first(5).join("\n")}")
+          raise SyntaxError, "Failed to define generated class method #{method_name}: #{e.message}"
+        end
+      end
+
+      # Build a context string for class methods
+      # @param method_name [Symbol] the method name
+      # @param args [Array] the arguments
+      # @param kwargs [Hash] the keyword arguments
+      # @return [String] a descriptive context string
+      def build_class_context_string(method_name, args, kwargs)
+        parts = ["Class Method: #{method_name}"]
+        parts << "Args: #{args.inspect}" unless args.empty?
+        parts << "Kwargs: #{kwargs.inspect}" unless kwargs.empty?
+        parts.join(", ")
+      end
+
+      # Get guidance for a method
+      # @param method_name [Symbol] the method name
+      # @return [String, nil] guidance text or nil
+      def get_method_guidance(method_name)
+        # Check class-level guidance first
+        class_guidance = class_variable_get(:@@chaos_method_guidance)[method_name.to_sym]
+        return class_guidance if class_guidance
+
+        # Check global configuration guidance
+        ChaosToTheRescue.configuration.method_guidance[method_name.to_sym]
+      end
+
+      # Get the LLM client instance
+      # @return [LLMClient]
+      def llm_client
+        @llm_client ||= LLMClient.new
+      end
+    end
+
+    private
+
+    # Handle missing methods by generating them via LLM
+    def method_missing(method_name, *args, **kwargs, &block)
+      # Check if enabled (globally or per-class)
+      unless enabled_for_class?
+        ChaosToTheRescue.logger.debug("ChaosRescue disabled for #{self.class.name}##{method_name}")
+        return super
+      end
+
+      # Check if method name is allowed
+      unless ChaosToTheRescue.configuration.method_allowed?(method_name)
+        ChaosToTheRescue.logger.debug("Method #{method_name} not in allowlist or patterns")
+        return super
+      end
+
+      ChaosToTheRescue.logger.info("Attempting to generate method: #{self.class.name}##{method_name}")
+
+      begin
+        # Generate the method code via LLM
+        result = generate_method(method_name, args, kwargs)
+
+        # If auto_define_methods is enabled, define the method on the class
+        if ChaosToTheRescue.configuration.auto_define_methods && result[:ruby_code]
+          define_generated_method(method_name, result[:ruby_code])
+
+          # Call the newly defined method
+          ChaosToTheRescue.logger.info("🚀 Executing generated method: #{self.class.name}##{method_name}")
+          if kwargs.empty?
+            send(method_name, *args, &block)
+          else
+            send(method_name, *args, **kwargs, &block)
+          end
+        else
+          # Return the generated code without executing it
+          ChaosToTheRescue.logger.info("Generated method code (not auto-defined): #{result[:ruby_code]}")
+          result
+        end
+      rescue LLMClient::LLMNotAvailableError => e
+        ChaosToTheRescue.logger.error("LLM not available: #{e.message}")
+        raise
+      rescue => e
+        ChaosToTheRescue.logger.error("Failed to generate method #{method_name}: #{e.message}")
+        super
+      end
+    end
+
+    # Properly handle respond_to? for missing methods
+    def respond_to_missing?(method_name, include_private = false)
+      if enabled_for_class? && ChaosToTheRescue.configuration.method_allowed?(method_name)
+        true
+      else
+        super
+      end
+    end
+
+    # Generate method code via LLM client
+    # @param method_name [Symbol] the method name
+    # @param args [Array] the arguments passed
+    # @param kwargs [Hash] the keyword arguments passed
+    # @return [Hash] the generated method info
+    def generate_method(method_name, args, kwargs)
+      # Get guidance if available
+      guidance = self.class.respond_to?(:chaos_method_guidance) ?
+                  self.class.chaos_method_guidance[method_name.to_sym] : nil
+      guidance ||= ChaosToTheRescue.configuration.method_guidance[method_name.to_sym]
+
+      context = {
+        method_name: method_name,
+        class_name: self.class.name,
+        args: args,
+        kwargs: kwargs,
+        guidance: guidance,
+        additional_context: build_context_string(method_name, args, kwargs)
+      }
+
+      llm_client.generate_method_code(context)
+    end
+
+    # Define the generated method on the singleton class
+    # @param method_name [Symbol] the method name
+    # @param code [String] the Ruby code to define
+    def define_generated_method(method_name, code)
+      ChaosToTheRescue.logger.info("🤖 Defining generated method: #{self.class.name}##{method_name}")
+      ChaosToTheRescue.logger.debug("Generated code:\n#{code}")
+
+      begin
+        # WARNING: This executes LLM-generated code!
+        # The code should contain a class definition that reopens the class and adds the method
+        # We eval it in the context of the main object to allow class definitions
+        eval(code, TOPLEVEL_BINDING)
+
+        ChaosToTheRescue.logger.info("✅ Successfully defined #{self.class.name}##{method_name}")
+      rescue => e
+        ChaosToTheRescue.logger.error("❌ Failed to define method #{method_name}: #{e.message}")
+        ChaosToTheRescue.logger.error("Backtrace: #{e.backtrace.first(5).join("\n")}")
+        raise SyntaxError, "Failed to define generated method #{method_name}: #{e.message}"
+      end
+    end
+
+    # Build a context string from method name and arguments
+    # @param method_name [Symbol] the method name
+    # @param args [Array] the arguments
+    # @param kwargs [Hash] the keyword arguments
+    # @return [String] a descriptive context string
+    def build_context_string(method_name, args, kwargs)
+      parts = ["Method: #{method_name}"]
+      parts << "Args: #{args.inspect}" unless args.empty?
+      parts << "Kwargs: #{kwargs.inspect}" unless kwargs.empty?
+      parts.join(", ")
+    end
+
+    # Check if ChaosRescue is enabled for this class
+    # @return [Boolean]
+    def enabled_for_class?
+      # Check global configuration first
+      return false unless ChaosToTheRescue.configuration.enabled
+
+      # Then check class-level setting
+      self.class.chaos_rescue_enabled?
+    end
+
+    # Get the LLM client instance
+    # @return [LLMClient]
+    def llm_client
+      @llm_client ||= LLMClient.new
+    end
+  end
+end