code_healer 0.1.0

data/lib/code_healer/context_aware_prompt_builder.rb

@@ -0,0 +1,153 @@
+module CodeHealer
+  # Context-Aware Prompt Builder for Large Applications
+  # Builds intelligent prompts using rich business context
+  class ContextAwarePromptBuilder
+    class << self
+      def build_error_fix_prompt(error, class_name, method_name, context)
+        business_context = context[:business_context]
+        domain_context = context[:domain_context]
+        method_context = context[:method_specific_context]
+        
+        <<~PROMPT
+          You are an expert Ruby developer and code evolution specialist for a #{business_context['project']['business_domain']} application.
+          
+          ## ERROR DETAILS
+          Type: #{error.class.name}
+          Message: #{error.message}
+          Class: #{class_name}
+          Method: #{method_name}
+          
+          ## BUSINESS CONTEXT
+          #{build_business_context_section(business_context, domain_context)}
+          
+          ## METHOD-SPECIFIC CONTEXT
+          #{build_method_context_section(method_context, method_name)}
+          
+          ## DOMAIN REQUIREMENTS
+          #{build_domain_requirements_section(domain_context, business_context)}
+          
+          ## CODING STANDARDS
+          #{build_coding_standards_section(business_context)}
+          
+          ## ERROR-SPECIFIC REQUIREMENTS
+          #{build_error_specific_requirements(error, business_context)}
+          
+          ## CODE REQUIREMENTS
+          - Generate ONLY the complete method implementation (def #{method_name}...end)
+          - Include comprehensive error handling specific to #{error.class.name}
+          - Add business-appropriate logging using Rails.logger
+          - Include input validation and parameter checking
+          - Follow Ruby best practices and conventions
+          - Ensure the fix is production-ready and secure
+          - Add performance considerations where relevant
+          - Include proper return values and error responses
+          - Use the exact method name: #{method_name}
+          - Consider domain-specific business rules and compliance requirements
+          
+          Generate a complete, intelligent fix for the #{method_name} method that specifically addresses the #{error.class.name}:
+        PROMPT
+      end
+      
+      private
+      
+      def build_business_context_section(business_context, domain_context)
+        return "No business context available." unless business_context
+        
+        <<~CONTEXT
+          **Project**: #{business_context['project']['description']}
+          **Domain**: #{domain_context || 'General'}
+          **Criticality**: #{business_context['class_specific']&.dig('business_criticality') || 'medium'}
+          **Data Privacy**: #{business_context['class_specific']&.dig('data_privacy') || 'standard'}
+          **SLA Requirements**: #{business_context['domain_config']&.dig('sla_requirements') || '99.9%'}
+          **Compliance**: #{business_context['domain_config']&.dig('compliance')&.join(', ') || 'Standard'}
+        CONTEXT
+      end
+      
+      def build_method_context_section(method_context, method_name)
+        return "No method-specific context available." unless method_context
+        
+        <<~METHOD
+          **Method Description**: #{method_context['description'] || "Auto-inferred method: #{method_name}"}
+          **Error Handling Strategy**: #{method_context['error_handling'] || 'graceful_handling'}
+          **Logging Level**: #{method_context['logging'] || 'info'}
+          **Return Values**: #{format_return_values(method_context['return_values'])}
+        METHOD
+      end
+      
+      def build_domain_requirements_section(domain_context, business_context)
+        return "No domain-specific requirements." unless domain_context
+        
+        domain_config = business_context['domain_config']
+        return "No domain configuration available." unless domain_config
+        
+        <<~DOMAIN
+          **Domain**: #{domain_context}
+          **Description**: #{domain_config['description']}
+          **Criticality**: #{domain_config['criticality']}
+          **Data Consistency**: #{domain_config['data_consistency'] || 'standard'}
+          **Security Level**: #{domain_config['security'] || 'standard'}
+          **Performance Requirements**: #{format_performance_requirements(domain_context, business_context)}
+        DOMAIN
+      end
+      
+      def build_coding_standards_section(business_context)
+        return "No coding standards defined." unless business_context['coding_standards']
+        
+        standards = business_context['coding_standards']
+        
+        <<~STANDARDS
+          **Error Handling**: #{standards['error_handling']}
+          **Logging**: #{standards['logging']}
+          **Validation**: #{standards['validation']}
+          **Performance**: #{standards['performance']}
+          **Security**: #{standards['security']}
+          **Documentation**: #{standards['documentation']}
+          **Testing**: #{standards['testing']}
+        STANDARDS
+      end
+      
+      def build_error_specific_requirements(error, business_context)
+        # Previously extracted structured error rules removed. Use textual markdown/business context only.
+        error_rules = nil
+        
+        if error_rules
+          <<~ERROR
+            **Strategy**: #{error_rules['strategy']}
+            **Return Value**: #{error_rules['return_value']}
+            **Logging**: #{error_rules['logging']}
+            **User Experience**: #{error_rules['user_experience']}
+            **Business Impact**: #{error_rules['business_impact']}
+            **Default Return**: #{error_rules['default_return']}
+          ERROR
+        else
+          <<~ERROR
+            **Strategy**: defensive_programming
+            **Return Value**: nil_or_default
+            **Logging**: error_level
+            **User Experience**: graceful_degradation
+            **Business Impact**: variable
+          ERROR
+        end
+      end
+      
+      def format_return_values(return_values)
+        return "Standard return values" unless return_values
+        
+        return_values.map { |key, value| "#{key}: #{value}" }.join(", ")
+      end
+      
+      def format_performance_requirements(domain_context, business_context)
+        performance_config = business_context['performance_requirements']&.dig(domain_context)
+        
+        if performance_config
+          "Response Time: #{performance_config['response_time']}, " \
+          "Memory: #{performance_config['memory_usage']}, " \
+          "CPU: #{performance_config['cpu_usage']}, " \
+          "DB Queries: #{performance_config['database_queries']}"
+        else
+          "Standard performance requirements"
+        end
+      end
+    end
+  end
+end 

data/lib/code_healer/core.rb

@@ -0,0 +1,513 @@
+require 'logger'
+require 'git'
+require 'octokit'
+
+module CodeHealer
+  class Core
+    class << self
+      def initialize(config)
+        puts "🏥 Initializing CodeHealer with configuration..."
+        # Store configuration globally
+        @config = config
+        puts "✅ CodeHealer initialized successfully!"
+      end
+      
+      def setup_error_handling
+        puts "🔧 Setting up error handling..."
+        
+        # Set up Rails error handling for web requests
+        if defined?(Rails) && Rails.application
+          # Subscribe to Rails error reporter
+          Rails.error.subscribe(WebRequestErrorSubscriber.new)
+          puts "✅ Web request error handling set up"
+        end
+        
+        # Set up console error handling
+        if defined?(IRB) || defined?(Pry)
+          # Patch classes to catch console errors
+          patch_classes_for_evolution
+          puts "✅ Console error handling set up"
+        end
+        
+        puts "✅ Error handling setup complete!"
+      end
+      
+      def evolve_method(klass, method_name, context)
+        puts "Starting evolution process for #{klass.name}##{method_name}"
+        
+        # Get the file path
+        file_path = Rails.root.join('app', 'models', "#{klass.name.underscore}.rb")
+        puts "File path: #{file_path}"
+        
+        # Read the current content
+        current_content = File.read(file_path)
+        puts "Current content length: #{current_content.length}"
+        
+        # Get the original method
+        original_method = klass.instance_method(method_name)
+        
+        # Try to get the method source
+        begin
+          original_source = original_method.source
+        rescue
+          # If we can't get the source, try to find it in the file
+          if current_content =~ /def\s+#{method_name}.*?end/m
+            original_source = $&
+          else
+            # If we still can't find it, use the error context to generate a new method
+            original_source = generate_method_from_error(klass, method_name, context)
+          end
+        end
+        
+        puts "Original method source: #{original_source}"
+        
+        # Generate new method implementation
+        new_method = generate_method(klass, method_name, context, original_source)
+        puts "Generated new method: #{new_method}"
+        
+        # Replace the method in the file content
+        new_content = current_content.gsub(original_source, new_method)
+        puts "New content length: #{new_content.length}"
+        
+        # Create a new branch
+        branch_name = "evolve/#{klass.name.underscore}-#{method_name}-#{Time.now.to_i}"
+        puts "Creating new branch: #{branch_name}"
+        
+        # Initialize git if not already initialized
+        unless File.exist?(Rails.root.join('.git'))
+          puts "Initializing git repository..."
+          git = Git.init(Rails.root.to_s)
+          git.add('.')
+          git.commit('Initial commit')
+        end
+        
+        # Create and checkout new branch
+        git = Git.open(Rails.root.to_s)
+        git.branch(branch_name).checkout
+        
+        # Write the new content
+        File.write(file_path, new_content)
+        puts "Updated file: #{file_path}"
+        
+        # Commit changes
+        git.add(file_path)
+        commit_message = "Evolve #{klass.name}##{method_name} to handle #{context[:error].class}"
+        git.commit(commit_message)
+        
+        # Push branch
+        git.push('origin', branch_name)
+        puts "Pushed branch: #{branch_name}"
+        
+        # Create PR
+        client = Octokit::Client.new(access_token: ENV['GITHUB_TOKEN'])
+        repo = ENV['GITHUB_REPOSITORY'] || 'your-username/your-repo'
+        
+        pr_title = "Evolve #{klass.name}##{method_name}"
+        pr_body = <<~MARKDOWN
+          This PR contains an evolved version of `#{klass.name}##{method_name}` to handle the following error:
+          
+          ```
+          #{context[:error].class}: #{context[:error].message}
+          ```
+          
+          Changes:
+          - Added error handling for #{context[:error].class}
+          - Improved method robustness
+          - Added logging for debugging
+        MARKDOWN
+        
+        pr = client.create_pull_request(
+          repo,
+          'main',
+          branch_name,
+          pr_title,
+          pr_body
+        )
+        puts "Created PR: #{pr.html_url}"
+        
+        # Return the new method implementation
+        new_method
+      end
+      
+      private
+      
+      def generate_method_from_error(klass, method_name, context)
+        # Get the error message and backtrace
+        error = context[:error]
+        backtrace = error.backtrace.first
+        
+        # Extract the line number from the backtrace
+        if backtrace =~ /:(\d+):/
+          line_number = $1.to_i
+        end
+        
+        # Generate a basic method structure
+        <<~RUBY
+          def #{method_name}(#{original_method.parameters.map { |type, name| name }.join(', ')})
+            #{error.message}
+          end
+        RUBY
+      end
+      
+      def generate_method(klass, method_name, context, original_source)
+        # Get the original method
+        original_method = klass.instance_method(method_name)
+        
+        # Extract the method body (everything between the first and last line)
+        method_lines = original_source.split("\n")
+        method_body = method_lines[1..-2].join("\n")
+        
+        # Generate new method with error handling
+        new_method = <<~RUBY
+          def #{method_name}(#{original_method.parameters.map { |type, name| name }.join(', ')})
+            begin
+              #{method_body}
+            rescue NoMethodError => e
+              if e.message.include?('undefined method') && e.message.include?('nil')
+                # Handle nil object errors
+                puts "Handling nil object error: \#{e.message}"
+                return 0.05 # Default discount for nil cases
+              end
+              raise e
+            rescue => e
+              puts "Unexpected error in #{method_name}: \#{e.message}"
+              raise e
+            end
+          end
+        RUBY
+        
+        new_method
+      end
+      
+      def patch_classes_for_evolution
+        # Get allowed classes from config
+        allowed_classes = CodeHealer::ConfigManager.allowed_classes
+        
+        allowed_classes.each do |class_name|
+          begin
+            klass = class_name.constantize
+            patch_class_for_evolution(klass)
+          rescue NameError => e
+            puts "⚠️  Could not load class #{class_name}: #{e.message}"
+          end
+        end
+      end
+      
+      def patch_class_for_evolution(klass)
+        # This will be called when errors occur in the class
+        # For now, just log that we're ready to handle errors
+        puts "🔍 Ready to handle errors in #{klass.name}"
+      end
+      
+      # Web request error subscriber
+      class WebRequestErrorSubscriber
+        def report(error, handled:, severity:, context:, source: nil)
+          return unless should_handle_error?(error, context)
+          
+          puts "🚨 Web request error caught: #{error.class} - #{error.message}"
+          
+          # Extract class and method from error backtrace
+          class_name, method_name = extract_from_backtrace(error.backtrace)
+          
+          if class_name && method_name
+            puts "🔧 Triggering healing for #{class_name}##{method_name}"
+            
+            # Queue healing job
+            queue_evolution_job(error, class_name, method_name)
+          else
+            puts "⚠️  Could not extract class/method from backtrace"
+          end
+        end
+        
+        private
+        
+        def should_handle_error?(error, context)
+          # Always try to handle errors - we'll extract class from backtrace
+          true
+        end
+        
+        def extract_from_backtrace(backtrace)
+          return [nil, nil] unless backtrace
+          
+          puts "🔍 DEBUG: Starting backtrace analysis..."
+          puts "🔍 DEBUG: First 5 backtrace lines:"
+          backtrace.first(5).each_with_index { |line, i| puts "  #{i}: #{line}" }
+          
+          # Use the exact working implementation from SelfRuby
+          core_methods = %w[* + - / % ** == != < > <= >= <=> === =~ !~ & | ^ ~ << >> [] []= `]
+          app_file_line = backtrace.find { |line| line.include?('/app/') }
+          return [nil, nil] unless app_file_line
+          
+          puts "🔍 DEBUG: Found app file line: #{app_file_line}"
+          
+          if app_file_line =~ /(.+):(\d+):in `(.+)'/
+            file_path = $1
+            method_name = $3
+            
+            puts "🔍 DEBUG: Extracted file_path=#{file_path}, method_name=#{method_name}"
+            
+            # If it's a core method, look deeper in the backtrace
+            if core_methods.include?(method_name)
+              puts "🔍 DEBUG: #{method_name} is a core method, looking deeper..."
+              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
+                puts "🔍 DEBUG: Found deeper app line: #{deeper_app_line}"
+                if deeper_app_line =~ /(.+):(\d+):in `(.+)'/
+                  file_path = $1
+                  method_name = $3
+                  puts "🔍 DEBUG: Updated to file_path=#{file_path}, method_name=#{method_name}"
+                end
+              else
+                puts "🔍 DEBUG: No deeper app line found"
+              end
+            end
+            
+            # If it's still a block or iterator, look for the containing method
+            if method_name && (
+              method_name.include?('block in') || 
+              method_name.include?('each') || 
+              method_name.include?('map') || 
+              method_name.include?('reduce') ||
+              method_name.include?('sum')
+            )
+              puts "🔍 DEBUG: #{method_name} is a block/iterator, looking for containing method..."
+              # Look for the FIRST valid method in the backtrace, not just any method
+              containing_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') &&
+                !$1.include?('sum') &&
+                !$1.include?('*')  # Also skip the core method we started with
+              end
+              
+              if containing_line
+                puts "🔍 DEBUG: Found containing line: #{containing_line}"
+                if containing_line =~ /(.+):(\d+):in `(.+)'/
+                  file_path = $1
+                  method_name = $3
+                  puts "🔍 DEBUG: Updated to file_path=#{file_path}, method_name=#{method_name}"
+                end
+              else
+                puts "🔍 DEBUG: No containing line found"
+              end
+            end
+            
+            # Extract class name from file path
+            if file_path && method_name
+              if file_path.include?('app/models/')
+                file_name = file_path.split('/').last.gsub('.rb', '')
+                class_name = file_name.classify
+              elsif file_path.include?('app/controllers/')
+                file_name = file_path.split('/').last.gsub('.rb', '')
+                if file_name.include?('/')
+                  parts = file_name.split('/')
+                  class_name = parts.map(&:classify).join('::')
+                else
+                  class_name = file_name.classify
+                end
+              end
+              
+              puts "🔍 DEBUG: Final result - class_name=#{class_name}, method_name=#{method_name}"
+              puts "🔍 Extracted: #{class_name}##{method_name} from #{file_path}"
+              return [class_name, method_name]
+            end
+          end
+          
+          puts "🔍 DEBUG: No valid method found in backtrace"
+          [nil, nil]
+        end
+        
+        def queue_evolution_job(error, class_name, method_name)
+          # Queue the healing job in Sidekiq
+          if defined?(CodeHealer::HealingJob)
+            # Get evolution method from configuration
+            evolution_method = CodeHealer::ConfigManager.evolution_method
+            puts "🔄 Using evolution method: #{evolution_method}"
+            
+            CodeHealer::HealingJob.perform_async(
+              error.class.name,
+              error.message,
+              class_name.to_s,
+              method_name.to_s,
+              evolution_method,  # Use configured evolution method
+              error.backtrace    # Pass the full backtrace for better analysis
+            )
+            puts "✅ Healing job queued for #{class_name}##{method_name}"
+          else
+            puts "⚠️  HealingJob not available"
+          end
+        end
+      end
+    end
+
+    attr_reader :klass, :method_name, :context, :logger
+
+    def initialize(klass, method_name, context = {})
+      @klass = klass
+      @method_name = method_name
+      @context = context
+      @logger = Logger.new(Rails.root.join('log', 'self_evolving.log'))
+    end
+
+    def evolve
+      begin
+        puts "Starting evolution for #{klass.name}##{method_name}"
+        puts "Error: #{context[:error].class} - #{context[:error].message}"
+        
+        # Get the original method
+        original_method = klass.instance_method(method_name)
+        puts "Original method parameters: #{original_method.parameters.inspect}"
+        
+        # Generate the fixed method
+        new_method = generate_method(original_method)
+        puts "Generated new method:"
+        puts new_method
+        
+        # Apply the changes directly
+        if apply_changes(new_method)
+          puts "Changes applied successfully"
+          true
+        else
+          puts "Failed to apply changes"
+          false
+        end
+      rescue => e
+        logger.error("Evolution failed: #{e.message}")
+        puts "Evolution failed: #{e.message}"
+        puts e.backtrace
+        false
+      end
+    end
+
+    private
+
+    def generate_method(original_method)
+      # Get the actual parameters from the original method
+      parameters = original_method.parameters
+      param_list = parameters.map { |type, name| name || "arg#{type}" }.join(', ')
+
+      # Use the source from context or try to get it
+      source = context[:source]
+      unless source
+        begin
+          source = original_method.source
+          puts "Original source: #{source}"
+        rescue
+          # If we can't get the source, read it from the file
+          file_path = Rails.root.join('app', 'models', "#{klass.name.underscore}.rb")
+          content = File.read(file_path)
+          if content =~ /def\s+#{method_name}.*?end/m
+            source = $&
+            puts "Found source in file: #{source}"
+          else
+            source = nil
+            puts "Could not find source in file"
+          end
+        end
+      end
+
+      case context[:error]
+      when NoMethodError
+        # For nil errors, add nil checks
+        <<~RUBY
+          def #{method_name}(#{param_list})
+            # Original method with nil checks
+            if user.purchase_history.nil? || user.purchase_history.empty?
+              0.05
+            else
+              last_purchase = user.purchase_history.last
+              last_purchase && last_purchase[:amount] > 1000 ? 0.1 : 0.05
+            end
+          end
+        RUBY
+      else
+        # For other errors, add basic error handling
+        if source
+          # Extract the method body from the source
+          if source =~ /def\s+#{method_name}.*?\n(.*?)end/m
+            method_body = $1
+            <<~RUBY
+              def #{method_name}(#{param_list})
+                begin
+                  #{method_body}
+                rescue => e
+                  logger.error("Error in #{method_name}: \#{e.message}")
+                  raise e
+                end
+              end
+            RUBY
+          else
+            # If we couldn't extract the body, use the whole source
+            <<~RUBY
+              def #{method_name}(#{param_list})
+                begin
+                  #{source}
+                rescue => e
+                  logger.error("Error in #{method_name}: \#{e.message}")
+                  raise e
+                end
+              end
+            RUBY
+          end
+        else
+          # If we couldn't get the source, use a generic error handler
+          <<~RUBY
+            def #{method_name}(#{param_list})
+              begin
+                # Original method implementation
+                super
+              rescue => e
+                logger.error("Error in #{method_name}: \#{e.message}")
+                raise e
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    def apply_changes(new_method)
+      # Write the new method to the file
+      file_path = Rails.root.join('app', 'models', "#{klass.name.underscore}.rb")
+      puts "Updating file: #{file_path}"
+      
+      content = File.read(file_path)
+      puts "Current file content:"
+      puts content
+      
+      # Find the original method definition
+      method_pattern = /def\s+#{method_name}.*?end/m
+      if content =~ method_pattern
+        new_content = content.gsub(method_pattern, new_method)
+        puts "New file content:"
+        puts new_content
+        
+        # Write the changes
+        File.write(file_path, new_content)
+        puts "File updated successfully"
+        
+        # Reload the class to apply changes
+        klass.class_eval(new_method)
+        puts "Class reloaded with new method"
+        
+        true
+      else
+        puts "Could not find method #{method_name} in #{file_path}"
+        false
+      end
+    end
+  end
+end