code_healer 0.1.0

data/lib/code_healer/business_rule_applier.rb

@@ -0,0 +1,54 @@
+module CodeHealer
+  # Business Rule Applier
+  # Simply provides business context to AI for natural language understanding
+  class BusinessRuleApplier
+    class << self
+      
+      def apply_business_rules_to_code(business_analysis, original_code, error, class_name, method_name)
+        puts "🔧 Providing business context to AI..."
+        
+        # Extract business context from the analysis
+        business_context = extract_business_context(business_analysis)
+        
+        if business_context.any?
+          puts "   📋 Found business context: #{business_context.join(', ')}"
+          puts "   🎯 AI will understand and apply these business rules naturally"
+          
+          # Simply return the original code - let the AI handle everything
+          # The AI will see the business context and apply it naturally
+          puts "   ✅ Business context provided to AI - no code manipulation needed"
+          original_code
+        else
+          puts "   ℹ️  No business context found"
+          original_code
+        end
+      end
+      
+      private
+      
+      def extract_business_context(business_analysis)
+        context = []
+        
+        # Extract from business rules
+        if business_analysis[:business_context][:business_rules]&.any?
+          business_analysis[:business_context][:business_rules].each do |rule|
+            context << rule[:content]
+          end
+        end
+        
+        # Extract from domain specific rules
+        if business_analysis[:business_context][:domain_specific]&.any?
+          business_analysis[:business_context][:domain_specific].each do |domain, rules|
+            if rules.is_a?(Array)
+              context.concat(rules)
+            elsif rules.is_a?(Hash)
+              context.concat(rules.values.map(&:to_s))
+            end
+          end
+        end
+        
+        context
+      end
+    end
+  end
+end

data/lib/code_healer/claude_code_evolution_handler.rb

@@ -0,0 +1,224 @@
+require 'timeout'
+require 'open3'
+
+module CodeHealer
+  class ClaudeCodeEvolutionHandler
+    class << self
+      def handle_error_with_claude_code(error, class_name, method_name, file_path)
+        puts "🤖 Claude Code Terminal Evolution Triggered!"
+        puts "Error: #{error.class} - #{error.message}"
+        puts "Class: #{class_name}, Method: #{method_name}"
+        puts "File: #{file_path}"
+        
+        begin
+          # Build comprehensive prompt
+          prompt = BusinessContextManager.build_claude_code_prompt(
+            error, class_name, method_name, file_path
+          )
+          
+          # Execute Claude Code command
+          success = execute_claude_code_fix(prompt, class_name, method_name)
+          
+          if success
+            puts "✅ Claude Code evolution completed successfully!"
+            # Reload modified files
+            reload_modified_files
+            
+            # 🚀 Trigger Git operations (commit, push, PR creation)
+            puts "🔄 Starting Git operations..."
+            trigger_git_operations(error, class_name, method_name, file_path)
+            
+            return true
+          else
+            puts "❌ Claude Code evolution failed"
+            return false
+          end
+          
+        rescue => e
+          puts "❌ Claude Code evolution error: #{e.message}"
+          puts e.backtrace.first(5)
+          return false
+        end
+      end
+      
+      private
+      
+      def execute_claude_code_fix(prompt, class_name, method_name)
+        config = ConfigManager.claude_code_settings
+        
+        # Build command
+        command = build_claude_command(prompt, config)
+        
+        puts "🚀 Executing Claude Code fix..."
+        puts "Command: #{command}"
+        puts "Timeout: #{config['timeout']} seconds"
+        
+        begin
+          # Execute with timeout
+          Timeout.timeout(config['timeout']) do
+            stdout, stderr, status = Open3.capture3(command)
+            
+            puts "📤 Claude Code Output:"
+            if stdout && !stdout.empty?
+              puts "✅ Response received:"
+              puts stdout
+
+              # Check if Claude Code is asking for permission
+              if stdout.include?("permission") || stdout.include?("grant") || stdout.include?("edit")
+                puts "🔐 Claude Code needs permission to edit files"
+                puts "💡 Make sure to grant Edit permissions when prompted"
+              end
+              
+              # Check if fix was applied
+              if stdout.include?("fix") && (stdout.include?("applied") || stdout.include?("ready"))
+                puts "🎯 Fix appears to be ready - checking if files were modified..."
+              end
+            else
+              puts "⚠️  No output received from Claude Code"
+            end
+
+            if stderr && !stderr.empty?
+              puts "⚠️  Claude Code Warnings/Errors:"
+              puts stderr
+            end
+            
+            if status.success?
+              puts "✅ Claude Code execution completed successfully"
+              return true
+            else
+              puts "❌ Claude Code execution failed with status: #{status.exitstatus}"
+              return false
+            end
+          end
+          
+        rescue Timeout::Error
+          puts "⏰ Claude Code execution timed out after #{config['timeout']} seconds"
+          return false
+        rescue => e
+          puts "❌ Claude Code execution error: #{e.message}"
+          return false
+        end
+      end
+      
+      def build_claude_command(prompt, config)
+        # Escape prompt for shell
+        escaped_prompt = prompt.gsub("'", "'\"'\"'")
+        
+        # Build command template
+        command_template = config['command_template'] || "claude --code '{prompt}'"
+        
+        # Replace placeholder
+        command = command_template.gsub('{prompt}', escaped_prompt)
+        
+        # Add additional options if configured
+        if config['include_tests']
+          command += " --append-system-prompt 'Include tests when fixing the code'"
+        end
+        
+        if config['max_file_changes']
+          command += " --append-system-prompt 'Limit changes to #{config['max_file_changes']} files maximum'"
+        end
+        
+        # Add file editing permissions
+        command += " --permission-mode acceptEdits --allowedTools Edit"
+        
+        # Add current directory access
+        command += " --add-dir ."
+        
+        command
+      end
+      
+      def reload_modified_files
+        puts "🔄 Reloading modified files..."
+        
+        # Get list of recently modified files (last 5 minutes)
+        recent_files = get_recently_modified_files
+        
+        recent_files.each do |file_path|
+          if file_path.include?('/app/')
+            begin
+              load file_path
+              puts "✅ Reloaded: #{file_path}"
+            rescue => e
+              puts "⚠️  Failed to reload #{file_path}: #{e.message}"
+            end
+          end
+        end
+        
+        puts "🔄 File reloading completed"
+      end
+      
+      def get_recently_modified_files
+        # Get files modified in the last 5 minutes
+        cutoff_time = Time.now - 300 # 5 minutes ago
+        
+        files = []
+        Dir.glob('**/*.rb').each do |file|
+          if File.mtime(file) > cutoff_time
+            files << file
+          end
+        end
+        
+        files.sort_by { |f| File.mtime(f) }.reverse
+      end
+      
+      def log_evolution_attempt(error, class_name, method_name, success)
+        log_entry = {
+          timestamp: Time.now.iso8601,
+          method: 'claude_code_terminal',
+          error_type: error.class.name,
+          error_message: error.message,
+          class_name: class_name,
+          method_name: method_name,
+          success: success,
+          execution_time: Time.now
+        }
+        
+        # Log to file
+        log_file = 'log/claude_code_evolution.log'
+        FileUtils.mkdir_p(File.dirname(log_file))
+        
+        File.open(log_file, 'a') do |f|
+          f.puts(log_entry.to_json)
+        end
+        
+        puts "📝 Evolution attempt logged to #{log_file}"
+      end
+      
+      def trigger_git_operations(error, class_name, method_name, file_path)
+        puts "🚀 Triggering Git operations for Claude Code evolution..."
+        
+        begin
+          # Use the existing SimpleEvolution Git operations
+          require_relative 'simple_evolution'
+          
+          # Create a mock business context for Git operations
+          business_context = {
+            error_type: error.class.name,
+            error_message: error.message,
+            class_name: class_name,
+            method_name: method_name
+          }
+          
+          # Trigger the Git operations through SimpleEvolution
+          git_success = CodeHealer::SimpleEvolution.handle_git_operations_for_claude(
+            error, class_name, method_name, file_path
+          )
+          
+          if git_success
+            puts "✅ Git operations completed successfully!"
+            puts "   - Branch created and committed"
+            puts "   - Changes pushed to remote"
+            puts "   - Pull request created"
+          else
+            puts "❌ Git operations failed"
+          end
+          
+        rescue => e
+          puts "❌ Error during Git operations: #{e.message}"
+          puts "💡 You may need to manually commit and create PR"
+        end
+      end
+    end
+  end
+end

data/lib/code_healer/claude_error_monitor.rb

@@ -0,0 +1,48 @@
+module CodeHealer
+  class ClaudeErrorMonitor
+    def self.monitor_and_fix(error, context = {})
+      # Send error to Claude API for analysis and fix
+      claude_response = send_to_claude({
+        error: {
+          type: error.class.name,
+          message: error.message,
+          backtrace: error.backtrace&.first(5)
+        },
+        context: context,
+        request_type: 'error_analysis_and_fix'
+      })
+      
+      # Apply fix if Claude provides one
+      if claude_response[:fix_available]
+        apply_automated_fix(claude_response[:fix])
+      end
+      
+      claude_response
+    end
+    
+    private
+    
+    def self.send_to_claude(payload)
+      # Integration with Claude API
+      # This would use your preferred method to communicate with Claude
+      # Options:
+      # 1. Direct API calls to Claude
+      # 2. MCP server integration
+      # 3. WebSocket connection
+      # 4. File-based communication
+      
+      {
+        analysis: "Error analyzed",
+        fix_available: false,
+        suggested_fix: nil,
+        user_message: "Something is wrong with your order data"
+      }
+    end
+    
+    def self.apply_automated_fix(fix)
+      # Only apply safe, non-breaking fixes automatically
+      # Log all changes for review
+      Rails.logger.info "Claude applied automated fix: #{fix}"
+    end
+  end
+end

data/lib/code_healer/config_manager.rb

@@ -0,0 +1,275 @@
+require 'yaml'
+require 'erb'
+
+module CodeHealer
+  class ConfigManager
+    class << self
+      def config
+        @config ||= load_config
+      end
+
+      def reload_config
+        @config = load_config
+      end
+
+      def enabled?
+        config['enabled'] == true
+      end
+
+      def require_approval?
+        config['require_approval'] == true
+      end
+
+      def auto_create_pr?
+        # Use only the nested pull_request configuration for consistency
+        config.dig('pull_request', 'auto_create') == true ||
+        config.dig('pull_request', 'enabled') == true
+      end
+
+      def auto_generate_tests?
+        config['auto_generate_tests'] == true
+      end
+
+      def allowed_error_types
+        config['allowed_error_types'] || []
+      end
+
+      def allowed_classes
+        config['allowed_classes'] || []
+      end
+
+      def excluded_classes
+        config['excluded_classes'] || []
+      end
+
+      def can_evolve_class?(class_name)
+        return false unless enabled?
+        return false if excluded_classes.include?(class_name)
+        return true if allowed_classes.empty?
+        allowed_classes.include?(class_name)
+      end
+
+      def can_handle_error?(error)
+        return false unless enabled?
+        allowed_error_types.include?(error.class.name)
+      end
+
+      # Evolution Strategy Configuration
+      def evolution_strategy
+        config['evolution_strategy'] || {}
+      end
+
+      def evolution_method
+        evolution_strategy['method'] || 'api'
+      end
+
+      def claude_code_enabled?
+        evolution_method == 'claude_code_terminal' && 
+        config.dig('claude_code', 'enabled') == true
+      end
+
+      def api_enabled?
+        evolution_method == 'api' || 
+        (evolution_method == 'hybrid' && config.dig('api', 'enabled') != false)
+      end
+
+      def fallback_to_api?
+        evolution_strategy['fallback_to_api'] == true
+      end
+
+      # Claude Code Configuration
+      def claude_code_settings
+        config['claude_code'] || {}
+      end
+
+      # Business Context Configuration
+      def business_context_enabled?
+        config.dig('business_context', 'enabled') == true
+      end
+
+      def business_context_settings
+        config['business_context'] || {}
+      end
+
+      # API Configuration
+      def api_settings
+        config['api'] || {}
+      end
+
+      def git_settings
+        config['git'] || {}
+      end
+
+      def pull_request_settings
+        config['pull_request'] || {}
+      end
+
+      def notification_settings
+        config['notifications'] || {}
+      end
+
+      def safety_settings
+        config['safety'] || {}
+      end
+
+      def evolution_patterns
+        config['evolution_patterns'] || {}
+      end
+
+      def get_evolution_pattern(error_type)
+        evolution_patterns[error_type.to_s]
+      end
+
+      def max_evolutions_per_day
+        config['max_evolutions_per_day'] || 10
+      end
+
+      # Enhanced Git Configuration Methods
+      def branch_prefix
+        git_settings['branch_prefix'] || 'evolve'
+      end
+
+      def pr_target_branch
+        git_settings['pr_target_branch'] || 'main'
+      end
+
+      def commit_message_template
+        git_settings['commit_message_template'] || 'Fix {class_name}##{method_name}: {error_type}'
+      end
+
+      def auto_commit?
+        git_settings['auto_commit'] != false
+      end
+
+      def auto_push?
+        git_settings['auto_push'] != false
+      end
+
+      # Enhanced Safety Configuration Methods
+      def backup_before_evolution?
+        safety_settings['backup_before_evolution'] != false
+      end
+
+      def rollback_on_syntax_error?
+        safety_settings['rollback_on_syntax_error'] != false
+      end
+
+      # Enhanced Pull Request Configuration Methods
+      def pull_request_enabled?
+        pull_request_settings['enabled'] != false
+      end
+
+      def auto_create_pr?
+        pull_request_settings['auto_create'] == true
+      end
+
+      def pr_labels
+        pull_request_settings['labels'] || ['auto-fix', 'self-evolving', 'bug-fix']
+      end
+
+      # Enhanced Claude Code Configuration Methods
+      def claude_code_timeout
+        claude_code_settings['timeout'] || 300
+      end
+
+      def claude_code_max_file_changes
+        claude_code_settings['max_file_changes'] || 10
+      end
+
+      def claude_code_include_tests?
+        claude_code_settings['include_tests'] != false
+      end
+
+      def claude_code_command_template
+        claude_code_settings['command_template'] || "claude --print '{prompt}' --output-format text"
+      end
+
+      private
+
+      def load_config
+        # Try to find config file in current directory or parent directories
+        config_path = find_config_file
+        
+        if config_path && File.exist?(config_path)
+          YAML.load(ERB.new(File.read(config_path)).result)
+        else
+          default_config
+        end
+      rescue => e
+        puts "Failed to load code-healer config: #{e.message}" if defined?(Rails)
+        default_config
+      end
+      
+      def find_config_file
+        # Look for config file in current directory and parent directories
+        current_dir = Dir.pwd
+        max_depth = 5
+        
+        max_depth.times do |depth|
+          config_path = File.join(current_dir, 'config', 'code_healer.yml')
+          return config_path if File.exist?(config_path)
+          
+          # Go up one directory
+          current_dir = File.dirname(current_dir)
+          break if current_dir == '/'
+        end
+        
+        nil
+      end
+
+      def default_config
+        {
+          'enabled' => true,
+          'require_approval' => false,
+          'max_evolutions_per_day' => 10,
+          'auto_generate_tests' => true,
+          'allowed_error_types' => ['ZeroDivisionError', 'NoMethodError', 'ArgumentError', 'TypeError'],
+          'allowed_classes' => ['User', 'Order', 'PaymentProcessor'],
+          'excluded_classes' => ['ApplicationController', 'ApplicationRecord', 'ApplicationJob', 'ApplicationMailer'],
+          'evolution_strategy' => {
+            'method' => 'api',
+            'fallback_to_api' => true
+          },
+          'claude_code' => {
+            'enabled' => false,
+            'timeout' => 300,
+            'max_file_changes' => 10,
+            'include_tests' => true,
+            'command_template' => "claude --print '{prompt}' --output-format text --permission-mode acceptEdits --allowedTools Edit",
+            'business_context_sources' => [
+              'config/business_rules.yml',
+              'docs/business_logic.md',
+              'spec/business_context_specs.rb'
+            ]
+          },
+          'business_context' => {
+            'enabled' => true,
+            'sources' => ['docs/business_rules.md']
+          },
+          'api' => {
+            'provider' => 'openai',
+            'model' => 'gpt-4',
+            'max_tokens' => 2000,
+            'temperature' => 0.1
+          },
+          'git' => {
+            'auto_commit' => true,
+            'auto_push' => true,
+            'branch_prefix' => 'evolve',
+            'commit_message_template' => 'Fix {class_name}##{method_name}: {error_type}',
+            'pr_target_branch' => 'main'
+          },
+          'pull_request' => {
+            'enabled' => true,
+            'auto_create' => true,
+            'labels' => ['auto-fix', 'self-evolving', 'bug-fix']
+          },
+          'safety' => {
+            'backup_before_evolution' => true,
+            'rollback_on_syntax_error' => true
+          }
+        }
+      end
+    end
+  end
+end