code_healer 0.1.0

data/lib/code_healer/error_handler.rb

@@ -0,0 +1,141 @@
+module CodeHealer
+  class ErrorHandler
+    class << self
+      def handle_error(error, context = {})
+        new(error, context).handle
+      end
+    end
+
+    attr_reader :error, :context, :logger
+
+    def initialize(error, context = {})
+      @error = error
+      @context = context
+      @logger = Logger.new(Rails.root.join('log', 'self_evolving.log'))
+      logger.debug("Initializing ErrorHandler with error: #{error.inspect}")
+    end
+
+    def handle
+      logger.debug("Starting error handling for: #{error.class}")
+      return false unless should_handle_error?
+
+      begin
+        evolution_context = build_evolution_context
+        logger.debug("Evolution context: #{evolution_context.inspect}")
+        
+        # If we can't determine the class or method, create a test class
+        target_class = error_class || create_test_class
+        target_method = error_method || 'handle_error'
+        
+        logger.debug("Target class: #{target_class}, Target method: #{target_method}")
+        
+        success = Core.evolve_method(target_class, target_method, evolution_context)
+        
+        if success
+          log_successful_repair
+          true
+        else
+          log_failed_repair
+          false
+        end
+      rescue => e
+        logger.error("Error handling failed: #{e.message}")
+        logger.error(e.backtrace.join("\n"))
+        false
+      end
+    end
+
+    private
+
+    def should_handle_error?
+      # During testing, handle all errors
+      return true if Rails.env.test? || Rails.env.development?
+      
+      # In production, only handle specific errors
+      error.is_a?(NoMethodError) || error.is_a?(ZeroDivisionError)
+    end
+
+    def error_class
+      if error.respond_to?(:backtrace_locations)
+        # Get the first backtrace location
+        location = error.backtrace_locations&.first
+        return create_test_class unless location
+
+        # Get the label (method name) from the backtrace
+        label = location.label
+        return create_test_class unless label
+
+        # Try to get the class name from the label
+        if label.include?('#')
+          class_name = label.split('#').first
+          # Only try to constantize if it looks like a valid class name
+          if class_name =~ /^[A-Z]/
+            begin
+              return class_name.constantize
+            rescue NameError
+              logger.debug("Could not constantize class name: #{class_name}")
+            end
+          end
+        end
+      end
+      
+      # If we couldn't determine the class, use the test class
+      create_test_class
+    end
+
+    def error_method
+      if error.respond_to?(:backtrace_locations)
+        location = error.backtrace_locations&.first
+        return 'handle_error' unless location
+
+        label = location.label
+        return 'handle_error' unless label
+
+        if label.include?('#')
+          method_name = label.split('#').last
+          return method_name if method_name =~ /^[a-z]/
+        end
+      end
+      
+      'handle_error'
+    end
+
+    def create_test_class
+      # Create a test class if we can't determine the original class
+      Class.new do
+        def self.name
+          'TestClass'
+        end
+      end
+    end
+
+    def build_evolution_context
+      {
+        error_type: error.class.name,
+        error_message: error.to_s,
+        backtrace: error.respond_to?(:backtrace) ? error.backtrace&.first(5) : [],
+        context: context
+      }
+    end
+
+    def log_successful_repair
+      logger.info({
+        timestamp: Time.current,
+        event: 'successful_repair',
+        error_type: error.class.name,
+        class: error_class&.name,
+        method: error_method
+      }.to_json)
+    end
+
+    def log_failed_repair
+      logger.info({
+        timestamp: Time.current,
+        event: 'failed_repair',
+        error_type: error.class.name,
+        class: error_class&.name,
+        method: error_method
+      }.to_json)
+    end
+  end
+end 

data/lib/code_healer/evolution_job.rb

@@ -0,0 +1,99 @@
+class EvolutionJob
+  include Sidekiq::Job
+  
+  sidekiq_options retry: 3, backtrace: true, queue: 'evolution'
+  
+  def perform(error_data, class_name, method_name, file_path)
+    puts "🚀 Evolution Job Started: #{class_name}##{method_name}"
+    
+    # Reconstruct the error object
+    error = reconstruct_error(error_data)
+    
+    # Determine evolution strategy
+    evolution_method = CodeHealer::ConfigManager.evolution_method
+    
+    case evolution_method
+    when 'claude_code_terminal'
+      handle_claude_code_evolution(error, class_name, method_name, file_path)
+    when 'api'
+      handle_api_evolution(error, class_name, method_name, file_path)
+    when 'hybrid'
+      handle_hybrid_evolution(error, class_name, method_name, file_path)
+    else
+      puts "❌ Unknown evolution method: #{evolution_method}"
+    end
+    
+    puts "✅ Evolution Job Completed: #{class_name}##{method_name}"
+  rescue => e
+    puts "❌ Evolution Job Failed: #{e.message}"
+    puts "📍 Backtrace: #{e.backtrace.first(5)}"
+    raise e  # Re-raise to trigger Sidekiq retry
+  end
+
+  private
+
+  def reconstruct_error(error_data)
+    # Reconstruct the error object from serialized data
+    error_class = Object.const_get(error_data['class'])
+    error = error_class.new(error_data['message'])
+    
+    # Restore backtrace if available
+    if error_data['backtrace']
+      error.set_backtrace(error_data['backtrace'])
+    end
+    
+    error
+  end
+
+  def handle_claude_code_evolution(error, class_name, method_name, file_path)
+    puts "🤖 Using Claude Code Terminal for evolution..."
+    
+    # Use the existing Claude Code evolution handler (it's a class method)
+    success = CodeHealer::ClaudeCodeEvolutionHandler.handle_error_with_claude_code(error, class_name, method_name, file_path)
+    
+    if success
+      puts "✅ Claude Code evolution completed successfully!"
+    else
+      puts "❌ Claude Code evolution failed"
+      raise "Claude Code evolution failed for #{class_name}##{method_name}"
+    end
+  end
+
+  def handle_api_evolution(error, class_name, method_name, file_path)
+    puts "🌐 Using OpenAI API for evolution..."
+    
+    # Load business context for API evolution
+    business_context = CodeHealer::BusinessContextManager.get_context_for_error(
+      error, class_name, method_name
+    )
+    
+    puts "📋 Business context loaded for API evolution"
+    
+    # Use the existing MCP evolution handler with business context
+    success = CodeHealer::SimpleEvolution.handle_error_with_mcp_intelligence(
+      error, class_name, method_name, file_path, business_context
+    )
+    
+    if success
+      puts "✅ API evolution completed successfully!"
+    else
+      puts "❌ API evolution failed"
+      raise "API evolution failed for #{class_name}##{method_name}"
+    end
+  end
+
+  def handle_hybrid_evolution(error, class_name, method_name, file_path)
+    puts "🔄 Using Hybrid approach for evolution..."
+    
+    begin
+      # Try Claude Code first
+      success = handle_claude_code_evolution(error, class_name, method_name, file_path)
+      return if success
+    rescue => e
+      puts "⚠️  Claude Code failed, falling back to API: #{e.message}"
+    end
+    
+    # Fallback to API
+    handle_api_evolution(error, class_name, method_name, file_path)
+  end
+end

data/lib/code_healer/global_handler.rb

@@ -0,0 +1,130 @@
+require 'git'
+
+module CodeHealer
+  class GlobalHandler
+    def self.setup_global_error_handling
+      # Override the default exception handler for unhandled exceptions
+      at_exit do
+        if $!
+          handle_global_error($!)
+        end
+      end
+      
+      # Set up a global error handler for specific error types
+      setup_method_error_handling
+    end
+    
+    def self.setup_method_error_handling
+      # Override method_missing to catch NoMethodError
+      Object.class_eval do
+        alias_method :original_method_missing, :method_missing
+        
+        def method_missing(method_name, *args, &block)
+          begin
+            original_method_missing(method_name, *args, &block)
+          rescue NoMethodError => e
+            CodeHealer::GlobalHandler.handle_method_error(e, self.class, method_name)
+            raise e # Re-raise the error after handling
+          end
+        end
+      end
+    end
+    
+    def self.handle_global_error(error)
+      puts "\n=== Global Error Handler Triggered ==="
+      puts "Error: #{error.class} - #{error.message}"
+      
+      # Get the backtrace to find the file and method
+      if error.backtrace && error.backtrace.first
+        file_line = error.backtrace.first
+        if file_line =~ /(.+):(\d+):in `(.+)'/
+          file_path = $1
+          line_number = $2
+          method_name = $3
+          
+          # Try to determine the class name from the file path
+          class_name = determine_class_name(file_path)
+          
+          if class_name && method_name
+            puts "File: #{file_path}"
+            puts "Class: #{class_name}"
+            puts "Method: #{method_name}"
+            
+            # Handle the error using our evolution system
+            handle_method_error(error, class_name, method_name, file_path)
+          end
+        end
+      end
+    end
+    
+    def self.handle_method_error(error, class_name, method_name, file_path = nil)
+      puts "\n=== Method Error Handler Triggered ==="
+      puts "Error: #{error.class} - #{error.message}"
+      puts "Class: #{class_name}"
+      puts "Method: #{method_name}"
+      
+      # If file_path is not provided, try to find it
+      unless file_path
+        file_path = find_file_for_class(class_name)
+      end
+      
+      if file_path && File.exist?(file_path)
+        puts "File: #{file_path}"
+        
+        # Use our evolution system to fix the method
+        success = CodeHealer::ReliableEvolution.handle_error(
+          error, 
+          class_name, 
+          method_name, 
+          file_path
+        )
+        
+        if success
+          puts "✅ Method evolution successful!"
+          # Reload the class to get the updated method
+          load file_path
+        else
+          puts "❌ Method evolution failed"
+        end
+      else
+        puts "Could not find file for class: #{class_name}"
+      end
+    end
+    
+    private
+    
+    def self.determine_class_name(file_path)
+      return nil unless File.exist?(file_path)
+      
+      content = File.read(file_path)
+      if content =~ /class\s+(\w+)/
+        return $1
+      end
+      
+      nil
+    end
+    
+    def self.find_file_for_class(class_name)
+      # Look in common Rails directories
+      search_paths = [
+        'app/models',
+        'app/controllers',
+        'app/services',
+        'lib'
+      ]
+      
+      search_paths.each do |path|
+        if Dir.exist?(path)
+          Dir.glob("#{path}/**/*.rb").each do |file|
+            content = File.read(file)
+            if content =~ /class\s+#{class_name}/
+              return file
+            end
+          end
+        end
+      end
+      
+      nil
+    end
+  end
+end 

data/lib/code_healer/healing_job.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module CodeHealer
+  class HealingJob
+    include Sidekiq::Job
+    
+    sidekiq_options retry: 3, backtrace: true, queue: 'evolution'
+    
+    def perform(error_type, error_message, class_name, method_name, evolution_method = 'api', backtrace = nil)
+      puts "🚀 Evolution Job Started: #{class_name}##{method_name}"
+      
+      # Reconstruct the error object with backtrace
+      error = reconstruct_error(error_type, error_message, backtrace)
+      
+      # Determine evolution strategy
+      case evolution_method
+      when 'claude_code_terminal'
+        handle_claude_code_evolution(error, class_name, method_name)
+      when 'api'
+        handle_api_evolution(error, class_name, method_name)
+      when 'hybrid'
+        handle_hybrid_evolution(error, class_name, method_name)
+      else
+        puts "⚠️  Unknown evolution method: #{evolution_method}"
+      end
+    end
+    
+    private
+    
+    def handle_claude_code_evolution(error, class_name, method_name)
+      puts "🤖 Using Claude Code Terminal for evolution..."
+      
+      if defined?(CodeHealer::ClaudeCodeEvolutionHandler)
+        # For Claude Code: pass the full backtrace instead of file path
+        # Claude can analyze the backtrace and find files itself
+        puts "📋 Sending full backtrace to Claude Code for intelligent analysis"
+        puts "🔍 Backtrace length: #{error.backtrace&.length || 0} lines"
+        
+        CodeHealer::ClaudeCodeEvolutionHandler.handle_error_with_claude_code(
+          error, class_name, method_name, nil
+        )
+      else
+        puts "⚠️  ClaudeCodeEvolutionHandler not available"
+      end
+    end
+    
+    def handle_api_evolution(error, class_name, method_name)
+      puts "🌐 Using OpenAI API for evolution..."
+      
+      # For API: extract file path since API doesn't have codebase access
+      file_path = extract_file_path_from_backtrace(error.backtrace)
+      puts "📁 File path for API: #{file_path || 'Not found'}"
+      
+      # Load business context
+      if defined?(CodeHealer::BusinessContextManager)
+        business_context = CodeHealer::BusinessContextManager.get_context_for_error(
+          error, class_name, method_name
+        )
+        puts "📋 Business context loaded for API evolution"
+      else
+        business_context = {}
+        puts "⚠️  BusinessContextManager not available"
+      end
+      
+      # Use SimpleHealer for API-based evolution
+      if defined?(CodeHealer::SimpleHealer)
+        CodeHealer::SimpleHealer.handle_error_with_mcp_intelligence(
+          error, class_name, method_name, file_path, business_context
+        )
+      else
+        puts "⚠️  SimpleHealer not available"
+      end
+    end
+    
+    def handle_hybrid_evolution(error, class_name, method_name)
+      puts "🔄 Using hybrid evolution strategy..."
+      
+      # Try Claude Code first, fallback to API
+      begin
+        handle_claude_code_evolution(error, class_name, method_name)
+      rescue => e
+        puts "⚠️  Claude Code evolution failed: #{e.message}"
+        puts "🔄 Falling back to API evolution..."
+        handle_api_evolution(error, class_name, method_name)
+      end
+    end
+    
+    def extract_file_path_from_backtrace(backtrace)
+      return nil unless backtrace
+      
+      core_methods = %w[* + - / % ** == != < > <= >= <=> === =~ !~ & | ^ ~ << >> [] []= `]
+      app_file_line = backtrace.find { |line| line.include?('/app/') }
+      
+      return nil unless app_file_line
+      
+      if app_file_line =~ /(.+):(\d+):in `(.+)'/
+        file_path = $1
+        method_name = $3
+        
+        # Handle Ruby operators by looking deeper in the stack
+        if core_methods.include?(method_name)
+          deeper_app_line = backtrace.find do |line| 
+            line.include?('/app/') && 
+            line =~ /in `(.+)'/ && 
+            !core_methods.include?($1) &&
+            !$1.include?('block in') &&
+            !$1.include?('each') &&
+            !$1.include?('map') &&
+            !$1.include?('reduce')
+          end
+          
+          if deeper_app_line && deeper_app_line =~ /(.+):(\d+):in `(.+)'/
+            file_path = $1
+            method_name = $3
+          end
+        end
+        
+        # Handle iterator methods and blocks
+        if method_name && (
+          method_name.include?('block in') || 
+          method_name.include?('each') || 
+          method_name.include?('map') || 
+          method_name.include?('reduce') ||
+          method_name.include?('sum')
+        )
+          containing_line = backtrace.find do |line|
+            line.include?('/app/') && 
+            line =~ /in `(.+)'/ && 
+            !$1.include?('block in') &&
+            !$1.include?('each') &&
+            !$1.include?('map') &&
+            !$1.include?('reduce') &&
+            !$1.include?('sum')
+          end
+          
+          if containing_line && containing_line =~ /(.+):(\d+):in `(.+)'/
+            file_path = $1
+            method_name = $3
+          end
+        end
+        
+        return file_path if file_path
+      end
+      
+      nil
+    end
+    
+    def reconstruct_error(error_type, error_message, backtrace = nil)
+      # Create a simple error object with the type and message
+      error_class = error_type.constantize rescue StandardError
+      error = error_class.new(error_message)
+      
+      # Set the backtrace if provided
+      if backtrace
+        error.set_backtrace(backtrace)
+        puts "📋 Backtrace restored: #{backtrace.length} lines"
+      else
+        puts "⚠️  No backtrace provided"
+      end
+      
+      error
+    rescue
+      # Fallback to generic error
+      StandardError.new(error_message)
+    end
+  end
+end

data/lib/code_healer/mcp.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module CodeHealer
+  module MCP
+    # Base class for MCP tools
+    class Tool
+      class << self
+        def description(desc = nil)
+          @description = desc if desc
+          @description
+        end
+        
+        def input_schema(schema = nil)
+          @input_schema = schema if schema
+          @input_schema
+        end
+        
+        def annotations(annotations = nil)
+          @annotations = annotations if annotations
+          @annotations
+        end
+      end
+    end
+    
+    # Response class for MCP tools
+    class Tool::Response
+      attr_reader :content
+      
+      def initialize(content)
+        @content = content
+      end
+    end
+    
+    # Base class for MCP prompts
+    class Prompt
+      class << self
+        def prompt_name(name = nil)
+          @prompt_name = name if name
+          @prompt_name
+        end
+        
+        def description(desc = nil)
+          @description = desc if desc
+          @description
+        end
+        
+        def arguments(args = nil)
+          @arguments = args if args
+          @arguments
+        end
+      end
+    end
+    
+    # Argument class for MCP prompts
+    class Prompt::Argument
+      attr_reader :name, :description, :required
+      
+      def initialize(name:, description:, required: false)
+        @name = name
+        @description = description
+        @required = required
+      end
+    end
+    
+    # Result class for MCP prompts
+    class Prompt::Result
+      attr_reader :description, :messages
+      
+      def initialize(description:, messages:)
+        @description = description
+        @messages = messages
+      end
+    end
+    
+    # Message class for MCP prompts
+    class Prompt::Message
+      attr_reader :role, :content
+      
+      def initialize(role:, content:)
+        @role = role
+        @content = content
+      end
+    end
+    
+    # Content classes for MCP prompts
+    module Content
+      class Text
+        attr_reader :text
+        
+        def initialize(text)
+          @text = text
+        end
+      end
+    end
+    
+    # Server class for MCP
+    class Server
+      attr_reader :name, :version, :tools, :server_context
+      
+      def initialize(name:, version:, tools:, server_context:)
+        @name = name
+        @version = version
+        @tools = tools
+        @server_context = server_context
+      end
+    end
+  end
+end