code_healer 0.1.0

data/lib/code_healer/business_context_loader.rb

@@ -0,0 +1,273 @@
+module CodeHealer
+  # Dynamic Business Context Loader for Large Applications
+  # Intelligently loads and provides business context for any class/method
+  class BusinessContextLoader
+    class << self
+      def load_context_for_class(class_name)
+        context = load_base_context
+        domain_context = find_domain_for_class(class_name)
+        
+        if domain_context
+          context.merge!(domain_context)
+          context[:class_specific] = load_class_specific_context(class_name, domain_context)
+        end
+        
+        context
+      end
+      
+      def load_context_for_method(class_name, method_name)
+        class_context = load_context_for_class(class_name)
+        method_context = load_method_specific_context(class_name, method_name, class_context)
+        
+        class_context.merge!(method_context)
+      end
+      
+      def find_domain_for_class(class_name)
+        domains = load_domains_from_config
+        
+        # Direct class match
+        domains.each do |domain_name, domain_config|
+          if domain_config['classes']&.key?(class_name)
+            return {
+              domain: domain_name,
+              domain_config: domain_config,
+              class_config: domain_config['classes'][class_name]
+            }
+          end
+        end
+        
+        # Pattern matching for similar classes
+        domains.each do |domain_name, domain_config|
+          if matches_domain_pattern?(class_name, domain_name)
+            return {
+              domain: domain_name,
+              domain_config: domain_config,
+              class_config: infer_class_config(class_name, domain_config)
+            }
+          end
+        end
+        
+        # Default domain based on class name patterns
+        default_domain = infer_default_domain(class_name)
+        if default_domain && domains[default_domain]
+          return {
+            domain: default_domain,
+            domain_config: domains[default_domain],
+            class_config: infer_class_config(class_name, domains[default_domain])
+          }
+        end
+        
+        nil
+      end
+      
+      def load_method_specific_context(class_name, method_name, class_context)
+        return {} unless class_context[:class_config]
+        
+        method_config = class_context[:class_config]['methods']&.dig(method_name)
+        
+        if method_config
+          {
+            method_specific: method_config,
+            error_handling: method_config['error_handling'],
+            logging: method_config['logging'],
+            return_values: method_config['return_values']
+          }
+        else
+          # Infer method context based on method name patterns
+          infer_method_context(method_name, class_context)
+        end
+      end
+      
+      private
+      
+      def load_base_context
+        business_context_file = Rails.root.join('config', 'business_context.yml')
+        
+        if File.exist?(business_context_file)
+          YAML.load_file(business_context_file)
+        else
+          default_context
+        end
+      end
+      
+      def load_domains_from_config
+        context = load_base_context
+        context['domains'] || {}
+      end
+      
+      def load_class_specific_context(class_name, domain_context)
+        domain_context[:class_config] || infer_class_config(class_name, domain_context[:domain_config])
+      end
+      
+      def matches_domain_pattern?(class_name, domain_name)
+        patterns = {
+          'user_management' => /User|Session|Auth|Profile/,
+          'inventory_management' => /Product|Inventory|Stock|Catalog/,
+          'order_management' => /Order|Cart|Checkout|Fulfillment/,
+          'payment_processing' => /Payment|Transaction|Gateway|Refund/,
+          'analytics_reporting' => /Analytics|Report|Metrics|Dashboard/
+        }
+        
+        pattern = patterns[domain_name]
+        pattern&.match?(class_name)
+      end
+      
+      def infer_default_domain(class_name)
+        case class_name
+        when /User|Session|Auth/
+          'user_management'
+        when /Product|Inventory|Stock/
+          'inventory_management'
+        when /Order|Cart|Checkout/
+          'order_management'
+        when /Payment|Transaction/
+          'payment_processing'
+        when /Analytics|Report|Metrics/
+          'analytics_reporting'
+        else
+          'general'
+        end
+      end
+      
+      def infer_class_config(class_name, domain_config)
+        {
+          'description' => "Auto-inferred configuration for #{class_name}",
+          'business_criticality' => domain_config['criticality'] || 'medium',
+          'data_privacy' => domain_config['data_sensitivity'] || 'standard',
+          'methods' => infer_methods_for_class(class_name, domain_config)
+        }
+      end
+      
+      def infer_methods_for_class(class_name, domain_config)
+        # Common method patterns by domain
+        patterns = {
+          'user_management' => {
+            'authenticate' => {
+              'description' => 'User authentication',
+              'error_handling' => 'secure_fallback',
+              'logging' => 'security_audit'
+            },
+            'update_profile' => {
+              'description' => 'Update user profile',
+              'error_handling' => 'validation_errors',
+              'logging' => 'audit_trail'
+            }
+          },
+          'inventory_management' => {
+            'update_stock' => {
+              'description' => 'Update inventory stock',
+              'error_handling' => 'stock_validation',
+              'logging' => 'inventory_audit'
+            },
+            'calculate_availability' => {
+              'description' => 'Calculate product availability',
+              'error_handling' => 'graceful_fallback',
+              'logging' => 'inventory_metrics'
+            }
+          },
+          'order_management' => {
+            'process_payment' => {
+              'description' => 'Process order payment',
+              'error_handling' => 'payment_failure',
+              'logging' => 'payment_audit'
+            },
+            'update_status' => {
+              'description' => 'Update order status',
+              'error_handling' => 'status_validation',
+              'logging' => 'order_audit'
+            }
+          }
+        }
+        
+        domain_name = domain_config['description']&.downcase&.gsub(/\s+/, '_')
+        patterns[domain_name] || {}
+      end
+      
+      def infer_method_context(method_name, class_context)
+        # Infer based on method name patterns
+        case method_name.to_s
+        when /authenticate|login/
+          {
+            method_specific: {
+              'description' => 'Authentication method',
+              'error_handling' => 'secure_fallback',
+              'logging' => 'security_audit',
+              'return_values' => {
+                'success' => 'user_object',
+                'failure' => 'nil_with_logging'
+              }
+            }
+          }
+        when /update|save/
+          {
+            method_specific: {
+              'description' => 'Update method',
+              'error_handling' => 'validation_errors',
+              'logging' => 'audit_trail',
+              'return_values' => {
+                'success' => 'boolean',
+                'validation_failed' => 'errors_hash'
+              }
+            }
+          }
+        when /calculate|compute/
+          {
+            method_specific: {
+              'description' => 'Calculation method',
+              'error_handling' => 'calculation_error',
+              'logging' => 'metrics',
+              'return_values' => {
+                'success' => 'numeric_result',
+                'error' => 'nil_or_default'
+              }
+            }
+          }
+        when /process|execute/
+          {
+            method_specific: {
+              'description' => 'Processing method',
+              'error_handling' => 'process_failure',
+              'logging' => 'process_audit',
+              'return_values' => {
+                'success' => 'result_object',
+                'failure' => 'error_object'
+              }
+            }
+          }
+        else
+          {
+            method_specific: {
+              'description' => "Auto-inferred method: #{method_name}",
+              'error_handling' => 'graceful_handling',
+              'logging' => 'info',
+              'return_values' => {
+                'success' => 'method_result',
+                'error' => 'nil_or_default'
+              }
+            }
+          }
+        end
+      end
+      
+      def default_context
+        {
+          'project' => {
+            'type' => 'Rails Application',
+            'business_domain' => 'General Application',
+            'description' => 'Default business context'
+          },
+          'coding_standards' => {
+            'error_handling' => 'comprehensive',
+            'logging' => 'structured',
+            'validation' => 'strict',
+            'performance' => 'optimized',
+            'security' => 'high'
+          },
+          'business_rules' => {
+            # Structured error_resolution removed in favor of markdown requirements
+          }
+        }
+      end
+    end
+  end
+end 

data/lib/code_healer/business_context_manager.rb

@@ -0,0 +1,297 @@
+require 'yaml'
+require 'json'
+
+module CodeHealer
+  class BusinessContextManager
+    class << self
+      def get_context_for_error(error, class_name, method_name)
+        return {} unless ConfigManager.business_context_enabled?
+        
+        # Load business context from markdown files (same as Claude Code)
+        markdown_context = load_business_context_from_markdown_simple
+        
+        context = {
+          class_context: get_class_business_context(class_name),
+          method_context: get_method_business_context(class_name, method_name),
+          error_context: get_error_context(error),
+          related_context: get_related_context(class_name, method_name),
+          domain_patterns: get_domain_patterns(class_name),
+          markdown_requirements: markdown_context  # Add markdown content
+        }
+        
+        context.compact
+      end
+      
+      def get_class_business_context(class_name)
+        business_context = ConfigManager.business_context_settings
+        
+        # Extract class-specific context
+        class_context = business_context[class_name] || {}
+        
+        # Add domain information
+        domain_info = {
+          domain: class_context['domain'] || 'General Business Logic',
+          key_rules: class_context['key_rules'] || [],
+          validation_patterns: class_context['validation_patterns'] || []
+        }
+        
+        domain_info
+      end
+      
+      def get_method_business_context(class_name, method_name)
+        # Method-specific business rules
+        method_rules = {
+          'calculate_discount' => {
+            rules: ['Discount cannot exceed 50% of subtotal', 'VIP customers get maximum 15%'],
+            constraints: ['Positive amounts only', 'Valid customer tier required']
+          },
+          'process_order' => {
+            rules: ['Orders must have valid items', 'Customer validation required'],
+            constraints: ['Positive quantities', 'Valid payment method']
+          },
+          'validate_payment' => {
+            rules: ['Card number must be valid', 'Expiry date must be future'],
+            constraints: ['Valid CVV format', 'Supported payment method']
+          }
+        }
+        
+        method_rules[method_name] || {}
+      end
+      
+      def get_error_context(error)
+        {
+          type: error.class.name,
+          message: error.message,
+          common_causes: get_common_error_causes(error.class),
+          suggested_fixes: get_suggested_fixes(error.class)
+        }
+      end
+      
+      def get_common_error_causes(error_class)
+        causes = {
+          'ArgumentError' => [
+            'Invalid parameter types',
+            'Missing required parameters',
+            'Parameter validation failed'
+          ],
+          'NoMethodError' => [
+            'Method not defined',
+            'Incorrect method name',
+            'Missing method implementation'
+          ],
+          'TypeError' => [
+            'Incompatible data types',
+            'Nil value where object expected',
+            'Type conversion failed'
+          ],
+          'NameError' => [
+            'Undefined variable or constant',
+            'Scope issue with variable',
+            'Missing import or require'
+          ]
+        }
+        
+        causes[error_class.name] || ['Unknown error cause']
+      end
+      
+      def get_suggested_fixes(error_class)
+        fixes = {
+          'ArgumentError' => [
+            'Add parameter validation',
+            'Check parameter types',
+            'Provide default values'
+          ],
+          'NoMethodError' => [
+            'Implement missing method',
+            'Check method spelling',
+            'Verify method exists in parent class'
+          ],
+          'TypeError' => [
+            'Add type checking',
+            'Handle nil values',
+            'Convert types appropriately'
+          ],
+          'NameError' => [
+            'Define missing variable',
+            'Check variable scope',
+            'Add missing imports'
+          ]
+        }
+        
+        fixes[error_class.name] || ['Review error and implement appropriate fix']
+      end
+      
+      def get_related_context(class_name, method_name)
+        # Find related classes and methods
+        related = {
+          'OrderProcessor' => ['User', 'Payment', 'Inventory'],
+          'User' => ['Order', 'Profile', 'Authentication'],
+          'OrderProcessorV2' => ['OrderProcessor', 'AdvancedValidation', 'BusinessRules']
+        }
+        
+        {
+          related_classes: related[class_name] || [],
+          related_methods: get_related_methods(method_name),
+          dependencies: get_class_dependencies(class_name)
+        }
+      end
+      
+      def get_related_methods(method_name)
+        # Method relationships
+        relationships = {
+          'calculate_discount' => ['validate_customer', 'calculate_loyalty_points', 'apply_coupon'],
+          'process_order' => ['validate_inventory', 'process_payment', 'send_confirmation'],
+          'validate_payment' => ['validate_card', 'check_balance', 'process_transaction']
+        }
+        
+        relationships[method_name] || []
+      end
+      
+      def get_class_dependencies(class_name)
+        # Class dependencies
+        dependencies = {
+          'OrderProcessor' => ['User', 'Payment', 'Inventory'],
+          'User' => ['Order', 'Profile'],
+          'OrderProcessorV2' => ['OrderProcessor', 'AdvancedValidation']
+        }
+        
+        dependencies[class_name] || []
+      end
+      
+      def get_domain_patterns(class_name)
+        # Domain-specific patterns
+        patterns = {
+          'OrderProcessor' => {
+            validation_pattern: 'Input validation → Business rule check → Processing → Result',
+            error_handling: 'Graceful degradation with meaningful error messages',
+            logging: 'Comprehensive logging for debugging and monitoring'
+          },
+          'User' => {
+            validation_pattern: 'Data validation → Security check → Database operation → Response',
+            error_handling: 'User-friendly error messages with guidance',
+            logging: 'Security-focused logging without sensitive data'
+          }
+        }
+        
+        patterns[class_name] || {}
+      end
+      
+    def build_claude_code_prompt(error, class_name, method_name, file_path)
+        # Load business context from markdown files
+        business_context = load_business_context_from_markdown_simple
+        
+        prompt = <<~PROMPT
+          I have a Ruby on Rails application with an error that needs fixing.
+          
+          ## Error Details:
+          - **Type:** #{error.class.name}
+          - **Message:** #{error.message}
+          - **Class:** #{class_name}
+          - **Method:** #{method_name}
+          - **File:** #{file_path}
+          
+          ## Complete Backtrace (for root cause analysis):
+          ```
+          #{error.backtrace&.join("\n") || "No backtrace available"}
+          ```
+          
+          ## Business Context (from requirements):
+          #{business_context}
+          
+          ## Instructions:
+          Please:
+          1. Analyze the error and understand the root cause
+          2. **IMPORTANT: Check if the fix requires changes to multiple files or if the root cause is in a different file**
+          3. Fix the issue considering the business rules above
+          4. Ensure the fix doesn't break other functionality
+          5. Follow Rails conventions and patterns
+          6. Make sure to write testcases for the fix
+          
+          ## IMPORTANT: Full Codebase Access & Multi-File Fixes
+          You have permission to edit ANY files in the codebase. Please:
+          - **Don't limit yourself to just the file where the error occurred**
+          - **Check related files, dependencies, and the broader codebase**
+          - **If the fix requires multiple file changes, make ALL necessary changes**
+          - **Look for root causes that might be in different files**
+          - **Edit any file that needs to be modified to resolve the issue completely**
+          - Ensure the fix follows business rules and validation patterns
+          
+          ## Multi-File Fix Strategy:
+          - **Analyze the complete backtrace above** to understand the full error chain
+          - **Start from the bottom of the backtrace** (where the error originated)
+          - **Work your way up** to see how the error propagated through different files
+          - **Identify ALL files in the call stack** that need modification
+          - **Look for the root cause** - it might be in a different file than where the error was caught
+          - **Make comprehensive changes** across the codebase if needed
+          - **Don't just patch the symptom** - fix the underlying issue
+          - **Check each file in the backtrace** for potential fixes
+          
+          Use your full codebase access to provide the best solution.
+        PROMPT
+        
+        prompt.strip
+      end
+      
+      def build_api_prompt(error, class_name, method_name, file_path)
+        context = get_context_for_error(error, class_name, method_name)
+        
+        prompt = <<~PROMPT
+          Fix this Ruby on Rails error:
+          
+          Error: #{context[:error_context][:type]} - #{context[:error_context][:message]}
+          Class: #{class_name}
+          Method: #{method_name}
+          File: #{file_path}
+          
+          Business Context:
+          - Domain: #{context[:class_context][:domain]}
+          - Key Rules: #{context[:class_context][:key_rules].join("; ")}
+          - Validation: #{context[:class_context][:validation_patterns].join("; ")}
+          
+          Method Rules: #{context[:method_context][:rules]&.join("; ") || "None"}
+          
+          Common Causes: #{context[:error_context][:common_causes].join("; ")}
+          Suggested Fixes: #{context[:error_context][:suggested_fixes].join("; ")}
+          
+          ## Business Requirements (from markdown):
+          #{context[:markdown_requirements]}
+          
+          Provide a production-ready fix that handles the error gracefully while maintaining business logic integrity.
+        PROMPT
+        
+        prompt.strip
+      end
+      
+      private
+      
+      def load_business_context_from_markdown_simple
+        # Look for business requirements in the docs directory (created by setup script)
+        docs_path = 'docs'
+        business_rules_path = 'docs/business_rules.md'
+        
+        # First try the specific business_rules.md file
+        if File.exist?(business_rules_path)
+          content = File.read(business_rules_path)
+          puts "📋 Loaded business context from: #{business_rules_path}"
+          return content.strip
+        end
+        
+        # Fallback: look for any markdown files in docs directory
+        if Dir.exist?(docs_path)
+          markdown_files = Dir.glob("#{docs_path}/**/*.md")
+          
+          if markdown_files.any?
+            # Load the first markdown file
+            content = File.read(markdown_files.first)
+            puts "📋 Loaded business context from: #{markdown_files.first}"
+            return content.strip
+          end
+        end
+        
+        # Fallback to basic business context
+        puts "⚠️  No business context markdown files found, using fallback"
+        return "Follow standard business logic and error handling practices."
+      end
+    end
+  end
+end

data/lib/code_healer/business_logic_generator.rb

@@ -0,0 +1,94 @@
+module CodeHealer
+  class BusinessLogicGenerator
+    class << self
+      def generate_from_description(description, target_class, method_name)
+        new(description, target_class, method_name).generate
+      end
+    end
+
+    attr_reader :description, :target_class, :method_name, :logger
+
+    def initialize(description, target_class, method_name)
+      @description = description
+      @target_class = target_class
+      @method_name = method_name
+      @logger = Logger.new(Rails.root.join('log', 'self_evolving.log'))
+    end
+
+    def generate
+      return false unless valid_description?
+
+      begin
+        method_definition = generate_method_definition
+        return false unless valid_method?(method_definition)
+
+        success = Core.evolve_method(target_class, method_name, {
+          description: description,
+          generated_at: Time.current
+        })
+
+        if success
+          log_successful_generation
+          true
+        else
+          log_failed_generation
+          false
+        end
+      rescue => e
+        logger.error("Business logic generation failed: #{e.message}")
+        false
+      end
+    end
+
+    private
+
+    def valid_description?
+      # Implement your validation logic here
+      # For example: minimum length, required keywords, etc.
+      description.present? && description.length >= 10
+    end
+
+    def generate_method_definition
+      # This is where you'd integrate with your AI system
+      # For now, we'll return a simple placeholder
+      <<~RUBY
+        def #{method_name}
+          # Generated from description: #{description}
+          # TODO: Implement actual business logic
+          true
+        end
+      RUBY
+    end
+
+    def valid_method?(method)
+      # Basic syntax validation
+      begin
+        RubyVM::InstructionSequence.compile(method)
+        true
+      rescue SyntaxError => e
+        logger.error("Invalid method syntax: #{e.message}")
+        false
+      end
+    end
+
+    def log_successful_generation
+      logger.info({
+        timestamp: Time.current,
+        event: 'successful_generation',
+        class: target_class.name,
+        method: method_name,
+        description: description
+      }.to_json)
+    end
+
+    def log_failed_generation
+      logger.info({
+        timestamp: Time.current,
+        event: 'failed_generation',
+        class: target_class.name,
+        method: method_name,
+        description: description
+      }.to_json)
+    end
+  end
+end