chaos_to_the_rescue 0.1.0

data/lib/chaos_to_the_rescue/configuration.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ChaosToTheRescue
+  # Thread-safe configuration for ChaosToTheRescue gem
+  class Configuration
+    include MonitorMixin
+
+    # @return [Boolean] Whether the gem is enabled globally (default: false)
+    attr_accessor :enabled
+
+    # @return [Boolean] Whether to automatically define generated methods (default: false)
+    attr_accessor :auto_define_methods
+
+    # @return [Array<Regexp>] Patterns for allowed method names
+    attr_accessor :allowed_method_name_patterns
+
+    # @return [Array<String, Symbol>] Explicit allowlist of method names
+    attr_accessor :allowlist
+
+    # @return [String] LLM model to use (default: "gpt-4o-mini")
+    attr_accessor :model
+
+    # @return [Integer] Maximum characters to send in prompts (default: 8000)
+    attr_accessor :max_prompt_chars
+
+    # @return [Symbol] Log level (:debug, :info, :warn, :error, :fatal, :unknown)
+    attr_accessor :log_level
+
+    # @return [Array<Regexp>] Patterns to redact from prompts
+    attr_accessor :redact_patterns
+
+    # @return [Boolean] Whether to log suggestions to file (default: true)
+    attr_accessor :log_suggestions
+
+    # @return [String] Path for suggestion log file
+    attr_accessor :suggestions_log_path
+
+    # @return [String] OpenAI API key (optional, can also use ENV['OPENAI_API_KEY'])
+    attr_accessor :openai_api_key
+
+    # @return [String] Anthropic API key (optional, can also use ENV['ANTHROPIC_API_KEY'])
+    attr_accessor :anthropic_api_key
+
+    # @return [Hash] Global method guidance for LLM-generated methods
+    attr_accessor :method_guidance
+
+    def initialize
+      super # Initialize MonitorMixin
+
+      # Safe defaults - disabled by default
+      @enabled = false
+      @auto_define_methods = false
+      @allowed_method_name_patterns = []
+      @allowlist = []
+      @model = "gpt-5-mini"
+      @max_prompt_chars = 8000
+      @log_level = :info
+      @log_suggestions = true
+      @suggestions_log_path = "tmp/chaos_to_the_rescue_suggestions.log"
+      @redact_patterns = default_redact_patterns
+      @openai_api_key = nil
+      @anthropic_api_key = nil
+      @method_guidance = {}
+    end
+
+    # Thread-safe configuration block
+    # @yield [Configuration] the configuration object
+    def configure
+      synchronize do
+        yield self
+      end
+    end
+
+    # Check if a method name is allowed based on patterns and allowlist
+    # @param method_name [String, Symbol] the method name to check
+    # @return [Boolean]
+    def method_allowed?(method_name)
+      method_str = method_name.to_s
+      method_sym = method_name.to_sym
+
+      # Check explicit allowlist
+      return true if allowlist.include?(method_str) || allowlist.include?(method_sym)
+
+      # Check patterns
+      allowed_method_name_patterns.any? { |pattern| pattern.match?(method_str) }
+    end
+
+    # Allow all method names by adding a catch-all pattern
+    # WARNING: Use with caution - this allows ChaosRescue to intercept any method call
+    # @return [void]
+    def allow_everything!
+      synchronize do
+        @allowed_method_name_patterns = [/.*/]
+      end
+    end
+
+    # Reset configuration to defaults
+    def reset!
+      synchronize do
+        @enabled = false
+        @auto_define_methods = false
+        @allowed_method_name_patterns = []
+        @allowlist = []
+        @model = "gpt-5-mini"
+        @max_prompt_chars = 8000
+        @log_level = :info
+        @log_suggestions = true
+        @suggestions_log_path = "tmp/chaos_to_the_rescue_suggestions.log"
+        @redact_patterns = default_redact_patterns
+        @openai_api_key = nil
+        @anthropic_api_key = nil
+        @method_guidance = {}
+      end
+    end
+
+    private
+
+    def default_redact_patterns
+      [
+        # Environment variable references
+        /ENV\[['"]([^'"]+)['"]\]/i,
+        /ENV\.fetch\(['"]+([^'"]+)['"]+.*?\)/i,
+
+        # AWS credentials
+        /AWS_ACCESS_KEY_ID[=:]\s*['"]?([A-Z0-9]{20})['"]?/i,
+        /AWS_SECRET_ACCESS_KEY[=:]\s*['"]?([A-Za-z0-9\/+=]{40})['"]?/i,
+        /AKIA[0-9A-Z]{16}/,
+
+        # OpenAI tokens
+        /sk-[a-zA-Z0-9]{20,}/,
+        /OPENAI_API_KEY[=:]\s*['"]?([^'"\s]+)['"]?/i,
+
+        # GitHub tokens
+        /ghp_[a-zA-Z0-9]{20,}/,
+        /gho_[a-zA-Z0-9]{20,}/,
+        /ghu_[a-zA-Z0-9]{20,}/,
+        /ghs_[a-zA-Z0-9]{20,}/,
+        /ghr_[a-zA-Z0-9]{20,}/,
+        /GITHUB_TOKEN[=:]\s*['"]?([^'"\s]+)['"]?/i,
+
+        # Rails credentials
+        /Rails\.application\.credentials\.[a-z_]+/i,
+
+        # Generic secrets
+        /API_KEY[=:]\s*['"]?([^'"\s]+)['"]?/i,
+        /SECRET[=:]\s*['"]?([^'"\s]+)['"]?/i,
+        /TOKEN[=:]\s*['"]?([^'"\s]+)['"]?/i,
+        /PASSWORD[=:]\s*['"]?([^'"\s]+)['"]?/i,
+
+        # Private keys
+        /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----[\s\S]*?-----END\s+(?:RSA\s+)?PRIVATE\s+KEY-----/i
+      ]
+    end
+  end
+end

data/lib/chaos_to_the_rescue/llm_client.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module ChaosToTheRescue
+  # Abstract interface for LLM interactions
+  class LLMClient
+    class LLMNotAvailableError < StandardError; end
+    class LLMRequestError < StandardError; end
+
+    def initialize
+      @redactor = Redactor.new
+      check_llm_availability!
+      configure_ruby_llm!
+    end
+
+    # Generate Ruby method code based on context
+    # @param context [Hash] context including :method_name, :class_name, :args, etc.
+    # @return [Hash] with keys: :method_name, :ruby_code, :explanation
+    def generate_method_code(context)
+      prompt = build_method_generation_prompt(context)
+      redacted_prompt = truncate_prompt(@redactor.redact(prompt))
+
+      ChaosToTheRescue.logger.debug("Generating method code for #{context[:method_name]}")
+
+      response = call_llm(redacted_prompt)
+      parse_method_generation_response(response, context[:method_name])
+    rescue => e
+      ChaosToTheRescue.logger.error("Failed to generate method code: #{e.message}")
+      raise LLMRequestError, "Failed to generate method code: #{e.message}"
+    end
+
+    # Suggest a fix for an exception
+    # @param context [Hash] context including :exception, :backtrace, :guidance, etc.
+    # @return [Hash] with keys: :title, :diagnosis, :proposed_changes, :files_to_edit
+    def suggest_fix(context)
+      prompt = build_fix_suggestion_prompt(context)
+      redacted_prompt = truncate_prompt(@redactor.redact(prompt))
+
+      ChaosToTheRescue.logger.debug("Generating fix suggestion for #{context[:exception_class]}")
+
+      response = call_llm(redacted_prompt)
+      parse_fix_suggestion_response(response)
+    rescue => e
+      ChaosToTheRescue.logger.error("Failed to generate fix suggestion: #{e.message}")
+      raise LLMRequestError, "Failed to generate fix suggestion: #{e.message}"
+    end
+
+    private
+
+    def check_llm_availability!
+      require "ruby_llm"
+    rescue LoadError
+      raise LLMNotAvailableError, <<~MSG
+        RubyLLM is not available. To use ChaosToTheRescue's LLM features, add this to your Gemfile:
+
+          gem "ruby_llm", "~> 0.1"
+
+        Then run: bundle install
+      MSG
+    end
+
+    def configure_ruby_llm!
+      # Configure ruby_llm with API keys from our configuration or ENV
+      RubyLLM.configure do |config|
+        if ChaosToTheRescue.configuration.openai_api_key
+          config.openai_api_key = ChaosToTheRescue.configuration.openai_api_key
+        end
+
+        if ChaosToTheRescue.configuration.anthropic_api_key
+          config.anthropic_api_key = ChaosToTheRescue.configuration.anthropic_api_key
+        end
+      end
+    rescue => e
+      ChaosToTheRescue.logger.debug("Could not configure ruby_llm: #{e.message}")
+      # Continue anyway - ruby_llm will try to use ENV vars
+    end
+
+    def call_llm(prompt)
+      # Use RubyLLM to interact with the configured model
+      model = ChaosToTheRescue.configuration.model
+
+      chat = RubyLLM.chat(model: model)
+      response = chat.ask(prompt)
+
+      # Return the response content as a string
+      response.content
+    rescue => e
+      raise LLMRequestError, "LLM call failed: #{e.message}"
+    end
+
+    def build_method_generation_prompt(context)
+      <<~PROMPT
+        You are a Ruby code generator. Generate a Ruby method implementation based on the following context:
+
+        Class: #{context[:class_name]}
+        Method name: #{context[:method_name]}
+        Arguments: #{context[:args].inspect}
+        Context: #{context[:additional_context] || "No additional context provided"}
+
+        #{context[:guidance] ? "IMPORTANT GUIDANCE:\n#{context[:guidance]}\n" : ""}
+
+        Requirements:
+        1. Generate only valid Ruby code
+        2. The method should be reasonable and safe
+        3. Do not include any dangerous operations (file system access, network calls, etc.)
+        4. Return a simple, working implementation
+        #{context[:guidance] ? "5. Follow the guidance provided above carefully" : ""}
+
+        Please respond in the following format:
+        METHOD_NAME: <method_name>
+        CODE:
+        <ruby code here>
+        EXPLANATION: <brief explanation of what the method does>
+      PROMPT
+    end
+
+    def build_fix_suggestion_prompt(context)
+      <<~PROMPT
+        You are a Ruby debugging assistant. Analyze the following exception and suggest a fix:
+
+        Exception class: #{context[:exception_class]}
+        Exception message: #{context[:exception_message]}
+        Backtrace:
+        #{context[:backtrace]&.first(10)&.join("\n") || "No backtrace available"}
+
+        #{"Additional guidance: #{context[:guidance]}" if context[:guidance]}
+
+        Controller: #{context[:controller_name] || "N/A"}
+        Action: #{context[:action_name] || "N/A"}
+
+        Please respond in the following format:
+        TITLE: <brief title for this fix>
+        DIAGNOSIS: <explanation of what went wrong>
+        PROPOSED_CHANGES:
+        <description of changes to make>
+        FILES_TO_EDIT:
+        <list of files that should be modified>
+      PROMPT
+    end
+
+    def parse_method_generation_response(response, method_name)
+      # Parse the LLM response into structured data
+      lines = response.split("\n")
+
+      code_start = lines.index { |l| l.strip == "CODE:" }
+      explanation_start = lines.index { |l| l.start_with?("EXPLANATION:") }
+
+      {
+        method_name: method_name,
+        ruby_code: code_start ? lines[(code_start + 1)...explanation_start].join("\n").strip : "",
+        explanation: explanation_start ? lines[explanation_start].sub("EXPLANATION:", "").strip : ""
+      }
+    end
+
+    def parse_fix_suggestion_response(response)
+      # Parse the LLM response into structured data
+      lines = response.split("\n")
+
+      title = lines.find { |l| l.start_with?("TITLE:") }&.sub("TITLE:", "")&.strip || "Suggested Fix"
+      diagnosis_idx = lines.index { |l| l.start_with?("DIAGNOSIS:") }
+      changes_idx = lines.index { |l| l.start_with?("PROPOSED_CHANGES:") }
+      files_idx = lines.index { |l| l.start_with?("FILES_TO_EDIT:") }
+
+      {
+        title: title,
+        diagnosis: diagnosis_idx ? lines[diagnosis_idx].sub("DIAGNOSIS:", "").strip : "",
+        proposed_changes: (changes_idx && files_idx) ? lines[(changes_idx + 1)...files_idx].join("\n").strip : "",
+        files_to_edit: files_idx ? lines[(files_idx + 1)..].map(&:strip).reject(&:empty?) : []
+      }
+    end
+
+    def truncate_prompt(prompt)
+      max_chars = ChaosToTheRescue.configuration.max_prompt_chars
+      return prompt if prompt.length <= max_chars
+
+      truncation_suffix = "\n[TRUNCATED]"
+      truncate_at = max_chars - truncation_suffix.length
+
+      ChaosToTheRescue.logger.warn("Prompt truncated from #{prompt.length} to #{max_chars} characters")
+      prompt[0...truncate_at] + truncation_suffix
+    end
+  end
+end

data/lib/chaos_to_the_rescue/logger.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module ChaosToTheRescue
+  # Logger wrapper that respects configuration settings
+  class Logger
+    def initialize
+      @logger = ::Logger.new($stdout)
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "[ChaosToTheRescue] #{severity} #{datetime.strftime("%Y-%m-%d %H:%M:%S")}: #{msg}\n"
+      end
+    end
+
+    # Log a debug message
+    # @param message [String] the message to log
+    def debug(message)
+      return unless enabled?
+      ensure_level
+      @logger.debug(message)
+    end
+
+    # Log an info message
+    # @param message [String] the message to log
+    def info(message)
+      return unless enabled?
+      ensure_level
+      @logger.info(message)
+    end
+
+    # Log a warning message
+    # @param message [String] the message to log
+    def warn(message)
+      return unless enabled?
+      ensure_level
+      @logger.warn(message)
+    end
+
+    # Log an error message
+    # @param message [String] the message to log
+    def error(message)
+      return unless enabled?
+      ensure_level
+      @logger.error(message)
+    end
+
+    # Log a fatal message
+    # @param message [String] the message to log
+    def fatal(message)
+      return unless enabled?
+      ensure_level
+      @logger.fatal(message)
+    end
+
+    private
+
+    def enabled?
+      ChaosToTheRescue.configuration.enabled
+    end
+
+    def ensure_level
+      @logger.level = log_level_constant
+    end
+
+    def log_level_constant
+      level = ChaosToTheRescue.configuration.log_level
+      case level
+      when :debug then ::Logger::DEBUG
+      when :info then ::Logger::INFO
+      when :warn then ::Logger::WARN
+      when :error then ::Logger::ERROR
+      when :fatal then ::Logger::FATAL
+      else ::Logger::INFO
+      end
+    end
+  end
+
+  # Module-level logger instance
+  def self.logger
+    @logger ||= Logger.new
+  end
+end

data/lib/chaos_to_the_rescue/railtie.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ChaosToTheRescue
+  # Rails integration via Railtie
+  class Railtie < Rails::Railtie
+    railtie_name :chaos_to_the_rescue
+
+    # Make RescueFrom available to ActionController
+    initializer "chaos_to_the_rescue.action_controller" do
+      ActiveSupport.on_load(:action_controller) do
+        require "chaos_to_the_rescue/rescue_from"
+      end
+    end
+
+    # Log when ChaosToTheRescue is loaded in Rails
+    config.after_initialize do
+      if ChaosToTheRescue.configuration.enabled
+        Rails.logger.info("[ChaosToTheRescue] Enabled - method generation and rescue suggestions are active")
+      else
+        Rails.logger.info("[ChaosToTheRescue] Disabled - use ChaosToTheRescue.configure to enable")
+      end
+    end
+  end
+end

data/lib/chaos_to_the_rescue/redactor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ChaosToTheRescue
+  # Redacts sensitive information from strings before sending to LLM
+  class Redactor
+    REDACTED_PLACEHOLDER = "[REDACTED]"
+
+    # @param patterns [Array<Regexp>] patterns to redact
+    def initialize(patterns = nil)
+      @patterns = patterns || ChaosToTheRescue.configuration.redact_patterns
+    end
+
+    # Redact sensitive information from text
+    # @param text [String] the text to redact
+    # @return [String] the redacted text
+    def redact(text)
+      return "" if text.nil? || text.empty?
+
+      redacted = text.dup
+
+      @patterns.each do |pattern|
+        redacted.gsub!(pattern, REDACTED_PLACEHOLDER)
+      end
+
+      redacted
+    end
+
+    # Redact sensitive information from a hash (recursive)
+    # @param hash [Hash] the hash to redact
+    # @return [Hash] a new hash with redacted values
+    def redact_hash(hash)
+      return {} unless hash.is_a?(Hash)
+
+      hash.transform_values do |value|
+        case value
+        when String
+          redact(value)
+        when Hash
+          redact_hash(value)
+        when Array
+          value.map { |item| item.is_a?(String) ? redact(item) : item }
+        else
+          value
+        end
+      end
+    end
+
+    # Redact sensitive information from an array
+    # @param array [Array] the array to redact
+    # @return [Array] a new array with redacted values
+    def redact_array(array)
+      return [] unless array.is_a?(Array)
+
+      array.map do |item|
+        case item
+        when String
+          redact(item)
+        when Hash
+          redact_hash(item)
+        when Array
+          redact_array(item)
+        else
+          item
+        end
+      end
+    end
+
+    # Redact sensitive information from any object by converting to string
+    # @param obj [Object] the object to redact
+    # @return [String] the redacted string representation
+    def redact_object(obj)
+      return "" if obj.nil?
+      redact(obj.to_s)
+    end
+  end
+end

data/lib/chaos_to_the_rescue/rescue_from.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module ChaosToTheRescue
+  # Controller concern for Rails rescue_from integration
+  module RescueFrom
+    extend ActiveSupport::Concern
+
+    # Generate a fix suggestion for an exception
+    # @param exception [Exception] the exception to analyze
+    # @param guidance [String] optional guidance for the LLM
+    # @return [Hash] suggestion with :title, :diagnosis, :proposed_changes, :files_to_edit
+    def chaos_suggest_fix(exception, guidance: nil)
+      unless ChaosToTheRescue.configuration.enabled
+        ChaosToTheRescue.logger.warn("chaos_suggest_fix called but ChaosToTheRescue is disabled")
+        return {
+          title: "ChaosToTheRescue Disabled",
+          diagnosis: "ChaosToTheRescue is not enabled. Enable it in your configuration.",
+          proposed_changes: "",
+          files_to_edit: []
+        }
+      end
+
+      context = build_exception_context(exception, guidance)
+
+      begin
+        suggestion = llm_client.suggest_fix(context)
+
+        # Log the suggestion if configured
+        log_suggestion(exception, suggestion) if ChaosToTheRescue.configuration.log_suggestions
+
+        suggestion
+      rescue LLMClient::LLMNotAvailableError => e
+        ChaosToTheRescue.logger.error("LLM not available: #{e.message}")
+        {
+          title: "LLM Not Available",
+          diagnosis: e.message,
+          proposed_changes: "",
+          files_to_edit: []
+        }
+      rescue => e
+        ChaosToTheRescue.logger.error("Failed to generate fix suggestion: #{e.message}")
+        {
+          title: "Error Generating Suggestion",
+          diagnosis: "Failed to generate suggestion: #{e.message}",
+          proposed_changes: "",
+          files_to_edit: []
+        }
+      end
+    end
+
+    private
+
+    # Build context hash for exception analysis
+    # @param exception [Exception] the exception
+    # @param guidance [String] optional guidance
+    # @return [Hash] context for LLM
+    def build_exception_context(exception, guidance)
+      {
+        exception_class: exception.class.name,
+        exception_message: sanitize_exception_message(exception.message),
+        backtrace: sanitize_backtrace(exception.backtrace),
+        guidance: guidance,
+        controller_name: controller_name,
+        action_name: action_name,
+        request_method: request.request_method,
+        request_path: request.path,
+        params: sanitize_params(params.to_unsafe_h)
+      }
+    rescue => e
+      ChaosToTheRescue.logger.warn("Failed to build full exception context: #{e.message}")
+      {
+        exception_class: exception.class.name,
+        exception_message: exception.message.to_s,
+        backtrace: exception.backtrace,
+        guidance: guidance
+      }
+    end
+
+    # Sanitize exception message to remove sensitive data
+    # @param message [String] the exception message
+    # @return [String] sanitized message
+    def sanitize_exception_message(message)
+      redactor.redact(message.to_s)
+    end
+
+    # Sanitize backtrace to remove sensitive paths
+    # @param backtrace [Array<String>] the backtrace
+    # @return [Array<String>] sanitized backtrace
+    def sanitize_backtrace(backtrace)
+      return [] unless backtrace
+
+      backtrace.first(20).map do |line|
+        # Replace absolute paths with relative paths for privacy
+        line.gsub(Rails.root.to_s, "[RAILS_ROOT]")
+      end
+    end
+
+    # Sanitize params to remove sensitive data
+    # @param params [Hash] the params hash
+    # @return [Hash] sanitized params
+    def sanitize_params(params)
+      # Remove common sensitive keys
+      sensitive_keys = %w[password password_confirmation token secret api_key access_token]
+
+      params.except(*sensitive_keys).transform_values do |value|
+        if value.is_a?(String)
+          redactor.redact(value)
+        else
+          value
+        end
+      end
+    end
+
+    # Log the suggestion to file
+    # @param exception [Exception] the exception
+    # @param suggestion [Hash] the suggestion
+    def log_suggestion(exception, suggestion)
+      log_path = ChaosToTheRescue.configuration.suggestions_log_path
+
+      # Ensure directory exists
+      FileUtils.mkdir_p(File.dirname(log_path))
+
+      File.open(log_path, "a") do |f|
+        f.puts "=" * 80
+        f.puts "Timestamp: #{Time.now.iso8601}"
+        f.puts "Exception: #{exception.class.name}: #{exception.message}"
+        f.puts "Controller: #{controller_name}##{action_name}"
+        f.puts "\nSuggestion:"
+        f.puts "Title: #{suggestion[:title]}"
+        f.puts "Diagnosis: #{suggestion[:diagnosis]}"
+        f.puts "\nProposed Changes:"
+        f.puts suggestion[:proposed_changes]
+        f.puts "\nFiles to Edit:"
+        suggestion[:files_to_edit].each { |file| f.puts "  - #{file}" }
+        f.puts "=" * 80
+        f.puts
+      end
+    rescue => e
+      ChaosToTheRescue.logger.error("Failed to log suggestion: #{e.message}")
+    end
+
+    # Get the LLM client instance
+    # @return [LLMClient]
+    def llm_client
+      @llm_client ||= LLMClient.new
+    end
+
+    # Get the redactor instance
+    # @return [Redactor]
+    def redactor
+      @redactor ||= Redactor.new
+    end
+  end
+end