code_healer 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcc597b56e69d320ba09b31cf5841c188a7b9599275c0ab5d7a8f4a352fc4142
-  data.tar.gz: c20f8a3e50018e4ecc4c5d7b42c77c68522dfaf97435eb7dc99a8e83d7f10b89
+  metadata.gz: a1ceaaefb9e7954b186c14720e3a68876975deed3d720e812420933dd6016484
+  data.tar.gz: 5299cd3f4a2e394700692d65e74d8132e1bd77b779220cda6b40c0e9db6d2f76
 SHA512:
-  metadata.gz: d7c683615b16fabf415d946c5b37b0bbaa13ef491b50d7a803d95688005bc406a07dfa333df4d9808631d68bb4073257577ec5d6f15bcce38379a3b720ef62c5
-  data.tar.gz: 79f822c7bea5d3b3d59a80201454bd7191b383aa4bb6ae56954cc0e32f42b35f5cbdc4da2ce2f3939ec3a4c00b1c71a4dd23dae654745fe29a6cf2c9a92668ec
+  metadata.gz: a84ffb72f678182aceaf0e39e206e55e9684811c1e2edbccf6bc5368a1a6330123f9215bb5fa81dd47b63042b94a01e93accaa700a958058ad155673b518b68e
+  data.tar.gz: 1a07538709f991f556c5fe407e8212aeb21f161f107494d4a07323b6db10389b1471ddc9b61834097b8a41161c6e287ec335dd739227562a56842d67b25f7097

data/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] - 2025-01-14
+
+### Added
+- **Code heal directory permission validation** during interactive setup
+- **Repository access testing** to ensure the directory can clone and push to the target repo
+- **Write permission verification** for the code heal directory
+- **Automatic directory creation** if it doesn't exist
+- **Comprehensive error messages** with troubleshooting tips for permission issues
+
+### Fixed
+- **Duplicate HealingJob class definition** that was preventing isolated healing workspace system from working
+- **Class loading conflict** between old and new healing logic
+- **Isolated healing workspace system** now properly activated
+
+## [0.1.4] - 2025-01-14
+
+### Added
+- **Comprehensive logging** for isolated healing workspace system
+- **Detailed workspace creation logs** showing each step of the process
+- **Clone operation logging** with success/failure status
+- **Fix application logging** in isolated environment
+- **Workspace cleanup logging** for debugging
+
+### Fixed
+- **Workspace configuration reading** to handle both string and symbol keys
+- **Branch name sanitization** to prevent invalid Git branch names
+
 ## [0.1.3] - 2025-01-14
 
 ### Added

data/lib/code_healer/config_manager.rb

@@ -99,6 +99,27 @@ module CodeHealer
       def git_settings
         config['git'] || {}
       end
+      
+      # Code Heal Directory Configuration
+      def code_heal_directory_config
+        config['code_heal_directory'] || {}
+      end
+      
+      def code_heal_directory_path
+        code_heal_directory_config['path'] || '/tmp/code_healer_workspaces'
+      end
+      
+      def auto_cleanup_workspaces?
+        code_heal_directory_config['auto_cleanup'] != false
+      end
+      
+      def workspace_cleanup_after_hours
+        code_heal_directory_config['cleanup_after_hours'] || 24
+      end
+      
+      def max_workspaces
+        code_heal_directory_config['max_workspaces'] || 10
+      end
 
       def pull_request_settings
         config['pull_request'] || {}
@@ -267,6 +288,13 @@ module CodeHealer
           'safety' => {
             'backup_before_evolution' => true,
             'rollback_on_syntax_error' => true
+          },
+          'code_heal_directory' => {
+            'path' => '/tmp/code_healer_workspaces',
+            'auto_cleanup' => true,
+            'cleanup_after_hours' => 24,
+            'max_workspaces' => 10,
+            'clone_strategy' => 'branch'
           }
         }
       end

data/lib/code_healer/evolution_job.rb

@@ -9,18 +9,39 @@ class EvolutionJob
     # Reconstruct the error object
     error = reconstruct_error(error_data)
     
-    # Determine evolution strategy
-    evolution_method = CodeHealer::ConfigManager.evolution_method
+    # Create isolated healing workspace
+    workspace_path = create_healing_workspace(class_name, method_name)
     
-    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}"
+    begin
+      # Apply fixes in isolated environment
+      success = apply_fixes_in_workspace(workspace_path, error, class_name, method_name)
+      
+      if success
+        # Test fixes in isolated environment
+        test_success = CodeHealer::HealingWorkspaceManager.test_fixes_in_workspace(workspace_path)
+        
+        if test_success
+          # Merge back to main repo
+          healing_branch = CodeHealer::HealingWorkspaceManager.merge_fixes_back(
+            Rails.root.to_s, 
+            workspace_path, 
+            CodeHealer::ConfigManager.git_settings['pr_target_branch'] || 'main'
+          )
+          
+          if healing_branch
+            puts "✅ Fixes applied, tested, and merged successfully! Branch: #{healing_branch}"
+          else
+            puts "⚠️  Fixes applied and tested, but merge failed"
+          end
+        else
+          puts "⚠️  Fixes applied but failed tests, not merging back"
+        end
+      else
+        puts "❌ Failed to apply fixes in workspace"
+      end
+    ensure
+      # Clean up workspace
+      cleanup_workspace(workspace_path)
     end
     
     puts "✅ Evolution Job Completed: #{class_name}##{method_name}"
@@ -32,35 +53,59 @@ class EvolutionJob
 
   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'])
+  def create_healing_workspace(class_name, method_name)
+    puts "🏥 Creating isolated healing workspace for #{class_name}##{method_name}"
     
-    # Restore backtrace if available
-    if error_data['backtrace']
-      error.set_backtrace(error_data['backtrace'])
-    end
+    # Create unique workspace
+    workspace_path = CodeHealer::HealingWorkspaceManager.create_healing_workspace(
+      Rails.root.to_s,
+      nil  # Use current branch
+    )
     
-    error
+    puts "✅ Healing workspace created: #{workspace_path}"
+    workspace_path
   end
-
-  def handle_claude_code_evolution(error, class_name, method_name, file_path)
-    puts "🤖 Using Claude Code Terminal for evolution..."
+  
+  def apply_fixes_in_workspace(workspace_path, error, class_name, method_name)
+    puts "🔧 Applying fixes in isolated workspace"
     
-    # 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)
+    # Determine evolution strategy
+    evolution_method = CodeHealer::ConfigManager.evolution_method
     
-    if success
-      puts "✅ Claude Code evolution completed successfully!"
+    case evolution_method
+    when 'claude_code_terminal'
+      handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+    when 'api'
+      handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
+    when 'hybrid'
+      handle_hybrid_evolution_in_workspace(workspace_path, error, class_name, method_name)
     else
-      puts "❌ Claude Code evolution failed"
-      raise "Claude Code evolution failed for #{class_name}##{method_name}"
+      puts "❌ Unknown evolution method: #{evolution_method}"
+      false
     end
   end
-
-  def handle_api_evolution(error, class_name, method_name, file_path)
-    puts "🌐 Using OpenAI API for evolution..."
+  
+  def handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+    puts "🤖 Using Claude Code Terminal for evolution in workspace..."
+    
+    # Change to workspace directory for Claude Code operations
+    Dir.chdir(workspace_path) do
+      success = CodeHealer::ClaudeCodeEvolutionHandler.handle_error_with_claude_code(
+        error, class_name, method_name, nil  # file_path not needed in workspace
+      )
+      
+      if success
+        puts "✅ Claude Code evolution completed successfully in workspace!"
+        true
+      else
+        puts "❌ Claude Code evolution failed in workspace"
+        false
+      end
+    end
+  end
+  
+  def handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
+    puts "🌐 Using OpenAI API for evolution in workspace..."
     
     # Load business context for API evolution
     business_context = CodeHealer::BusinessContextManager.get_context_for_error(
@@ -69,31 +114,56 @@ class EvolutionJob
     
     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}"
+    # Change to workspace directory for API operations
+    Dir.chdir(workspace_path) do
+      success = CodeHealer::SimpleEvolution.handle_error_with_mcp_intelligence(
+        error, class_name, method_name, nil, business_context  # file_path not needed in workspace
+      )
+      
+      if success
+        puts "✅ API evolution completed successfully in workspace!"
+        true
+      else
+        puts "❌ API evolution failed in workspace"
+        false
+      end
     end
   end
-
-  def handle_hybrid_evolution(error, class_name, method_name, file_path)
-    puts "🔄 Using Hybrid approach for evolution..."
+  
+  def handle_hybrid_evolution_in_workspace(workspace_path, error, class_name, method_name)
+    puts "🔄 Using Hybrid approach for evolution in workspace..."
     
     begin
       # Try Claude Code first
-      success = handle_claude_code_evolution(error, class_name, method_name, file_path)
-      return if success
+      success = handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+      return success 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)
+    handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
+  end
+  
+  def cleanup_workspace(workspace_path)
+    return unless workspace_path && Dir.exist?(workspace_path)
+    
+    puts "🧹 Cleaning up healing workspace: #{workspace_path}"
+    CodeHealer::HealingWorkspaceManager.cleanup_workspace(workspace_path)
+  end
+
+  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
+
+
 end

data/lib/code_healer/healing_job.rb

@@ -1,167 +1,187 @@
-# frozen_string_literal: true
+require 'sidekiq'
 
 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}"
+
+    def perform(*args)
+      puts "🚀 [HEALING_JOB] Starting job with args: #{args.inspect}"
       
-      # Reconstruct the error object with backtrace
-      error = reconstruct_error(error_type, error_message, backtrace)
+      # Support both legacy and new invocation styles
+      error, class_name, method_name, evolution_method, backtrace = parse_args(args)
       
-      # 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}"
+      puts "🚀 [HEALING_JOB] Parsed args - Error: #{error.class}, Class: #{class_name}, Method: #{method_name}, Evolution: #{evolution_method}"
+      puts "🚀 [HEALING_JOB] Backtrace length: #{backtrace&.length || 0}"
+
+      puts "🚀 Evolution Job Started: #{class_name}##{method_name}"
+
+            puts "🏥 [HEALING_JOB] About to create isolated healing workspace..."
+      # Create isolated healing workspace
+      workspace_path = create_healing_workspace(class_name, method_name)
+      puts "🏥 [HEALING_JOB] Workspace created: #{workspace_path}"
+      
+      begin
+        puts "🔧 [HEALING_JOB] About to apply fixes in isolated environment..."
+        # Apply fixes in isolated environment
+        success = apply_fixes_in_workspace(workspace_path, error, class_name, method_name, evolution_method)
+
+        if success
+          # Test fixes in isolated environment
+          test_success = CodeHealer::HealingWorkspaceManager.test_fixes_in_workspace(workspace_path)
+
+          if test_success
+            # Merge back to main repo
+            healing_branch = CodeHealer::HealingWorkspaceManager.merge_fixes_back(
+              Rails.root.to_s,
+              workspace_path,
+              CodeHealer::ConfigManager.git_settings['pr_target_branch'] || 'main'
+            )
+
+            if healing_branch
+              puts "✅ Fixes applied, tested, and merged successfully! Branch: #{healing_branch}"
+            else
+              puts "⚠️  Fixes applied and tested, but merge failed"
+            end
+          else
+            puts "⚠️  Fixes applied but failed tests, not merging back"
+          end
+        else
+          puts "❌ Failed to apply fixes in workspace"
+        end
+      ensure
+        # Clean up workspace
+        cleanup_workspace(workspace_path)
       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 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
-        )
+
+    def parse_args(args)
+      # Formats supported:
+      # 1) [error_class, error_message, class_name, method_name, evolution_method, backtrace]
+      # 2) [error_data_hash, class_name, method_name, file_path]
+      if args.length >= 6 && args[0].is_a?(String)
+        error_class, error_message, class_name, method_name, evolution_method, backtrace = args
+        error = reconstruct_error({ 'class' => error_class, 'message' => error_message, 'backtrace' => backtrace })
+        [error, class_name, method_name, evolution_method, backtrace]
+      elsif args.length == 4 && args[0].is_a?(Hash)
+        error_data, class_name, method_name, _file_path = args
+        error = reconstruct_error(error_data)
+        evolution_method = CodeHealer::ConfigManager.evolution_method
+        [error, class_name, method_name, evolution_method, error.backtrace]
       else
-        puts "⚠️  ClaudeCodeEvolutionHandler not available"
+        raise ArgumentError, "Unsupported HealingJob arguments: #{args.inspect}"
       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
-        )
+
+    def create_healing_workspace(class_name, method_name)
+      puts "🏥 Creating isolated healing workspace for #{class_name}##{method_name}"
+
+      # Create unique workspace
+      workspace_path = CodeHealer::HealingWorkspaceManager.create_healing_workspace(
+        Rails.root.to_s,
+        nil  # Use current branch
+      )
+
+      puts "✅ Healing workspace created: #{workspace_path}"
+      workspace_path
+    end
+
+    def apply_fixes_in_workspace(workspace_path, error, class_name, method_name, evolution_method)
+      puts "🔧 Applying fixes in isolated workspace"
+
+      case evolution_method
+      when 'claude_code_terminal'
+        handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+      when 'api'
+        handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
+      when 'hybrid'
+        begin
+          success = handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+          return true if success
+        rescue => e
+          puts "⚠️  Claude Code failed, falling back to API: #{e.message}"
+        end
+        handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
       else
-        puts "⚠️  SimpleHealer not available"
+        puts "❌ Unknown evolution method: #{evolution_method}"
+        false
       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)
+
+    def handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
+      puts "🤖 Using Claude Code Terminal for evolution in workspace..."
+
+      # Change to workspace directory for Claude Code operations
+      Dir.chdir(workspace_path) do
+        success = CodeHealer::ClaudeCodeEvolutionHandler.handle_error_with_claude_code(
+          error, class_name, method_name, nil  # file_path not needed in workspace
+        )
+
+        if success
+          puts "✅ Claude Code evolution completed successfully in workspace!"
+          true
+        else
+          puts "❌ Claude Code evolution failed in workspace"
+          false
+        end
       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')
+
+    def handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
+      puts "🌐 Using OpenAI API for evolution in workspace..."
+
+      # 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"
+
+      # Change to workspace directory for API operations
+      Dir.chdir(workspace_path) do
+        success = CodeHealer::SimpleEvolution.handle_error_with_mcp_intelligence(
+          error, class_name, method_name, nil, business_context  # file_path not needed in workspace
         )
-          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
+
+        if success
+          puts "✅ API evolution completed successfully in workspace!"
+          true
+        else
+          puts "❌ API evolution failed in workspace"
+          false
         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"
+
+    def cleanup_workspace(workspace_path)
+      return unless workspace_path && Dir.exist?(workspace_path)
+
+      puts "🧹 Cleaning up healing workspace: #{workspace_path}"
+      CodeHealer::HealingWorkspaceManager.cleanup_workspace(workspace_path)
+    end
+
+    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
-    rescue
-      # Fallback to generic error
-      StandardError.new(error_message)
     end
   end
 end
+
+# This duplicate class has been removed to fix the isolated healing workspace system