code_healer 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcc597b56e69d320ba09b31cf5841c188a7b9599275c0ab5d7a8f4a352fc4142
-  data.tar.gz: c20f8a3e50018e4ecc4c5d7b42c77c68522dfaf97435eb7dc99a8e83d7f10b89
+  metadata.gz: 053ae42e7bf5fe56e20fefb00f6a5474bf2e4e74622738f81b45073bfe735da3
+  data.tar.gz: e3349ed04f2cb27fec077f0003f5bde4b63b9a9a220158bbfb32b864ea1af75b
 SHA512:
-  metadata.gz: d7c683615b16fabf415d946c5b37b0bbaa13ef491b50d7a803d95688005bc406a07dfa333df4d9808631d68bb4073257577ec5d6f15bcce38379a3b720ef62c5
-  data.tar.gz: 79f822c7bea5d3b3d59a80201454bd7191b383aa4bb6ae56954cc0e32f42b35f5cbdc4da2ce2f3939ec3a4c00b1c71a4dd23dae654745fe29a6cf2c9a92668ec
+  metadata.gz: 2bac061a4947215ba717645dccf034ebf1e130eb98f58861d4f88ad8249d17cd83380853b965a1b7f539a5c6af9bbeefd795eb45b521023f447ac99cc222f8e1
+  data.tar.gz: da855be2022f1f6e1cd67dd48ea8a42985444b20895560fd34fe506734d2837fde99a374411c07f10622657b2acd5fc4ed329a5f04990aea6b30575ef0f3b5c2

data/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.5] - 2025-01-14
+
+### 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

data/lib/code_healer/healing_workspace_manager.rb

@@ -0,0 +1,296 @@
+require 'fileutils'
+require 'securerandom'
+
+module CodeHealer
+  # Manages isolated healing workspaces for safe code evolution
+  class HealingWorkspaceManager
+    class << self
+      def create_healing_workspace(repo_path, branch_name = nil)
+        puts "🏥 [WORKSPACE] Starting workspace creation..."
+        puts "🏥 [WORKSPACE] Repo path: #{repo_path}"
+        puts "🏥 [WORKSPACE] Branch name: #{branch_name || 'current'}"
+        
+        config = CodeHealer::ConfigManager.code_heal_directory_config
+        puts "🏥 [WORKSPACE] Raw config: #{config.inspect}"
+        
+        base_path = config['path'] || config[:path] || '/tmp/code_healer_workspaces'
+        puts "🏥 [WORKSPACE] Base heal dir: #{base_path}"
+        
+        # Create unique workspace directory
+        workspace_id = "healing_#{Time.now.to_i}_#{SecureRandom.hex(4)}"
+        workspace_path = File.join(base_path, workspace_id)
+        
+        puts "🏥 [WORKSPACE] Workspace ID: #{workspace_id}"
+        puts "🏥 [WORKSPACE] Full workspace path: #{workspace_path}"
+        
+        begin
+          puts "🏥 [WORKSPACE] Creating base directory..."
+          # Ensure code heal directory exists
+          FileUtils.mkdir_p(base_path)
+          puts "🏥 [WORKSPACE] Base directory created/verified: #{base_path}"
+          
+          # Clone current branch to workspace
+          strategy = clone_strategy
+          puts "🏥 [WORKSPACE] Clone strategy: #{strategy}"
+          
+          if strategy == "branch"
+            puts "🏥 [WORKSPACE] Using branch-only cloning..."
+            clone_current_branch(repo_path, workspace_path, branch_name)
+          else
+            puts "🏥 [WORKSPACE] Using full repo cloning..."
+            clone_full_repo(repo_path, workspace_path, branch_name)
+          end
+          
+          puts "🏥 [WORKSPACE] Workspace creation completed successfully!"
+          puts "🏥 [WORKSPACE] Final workspace path: #{workspace_path}"
+          puts "🏥 [WORKSPACE] Workspace contents: #{Dir.entries(workspace_path).join(', ')}"
+          workspace_path
+        rescue => e
+          puts "❌ Failed to create healing workspace: #{e.message}"
+          cleanup_workspace(workspace_path) if Dir.exist?(workspace_path)
+          raise e
+        end
+      end
+      
+      def apply_fixes_in_workspace(workspace_path, fixes, class_name, method_name)
+        puts "🔧 [WORKSPACE] Starting fix application..."
+        puts "🔧 [WORKSPACE] Workspace: #{workspace_path}"
+        puts "🔧 [WORKSPACE] Class: #{class_name}, Method: #{method_name}"
+        puts "🔧 [WORKSPACE] Fixes to apply: #{fixes.inspect}"
+        
+        begin
+          puts "🔧 [WORKSPACE] Processing #{fixes.length} fixes..."
+          # Apply each fix to the workspace
+          fixes.each_with_index do |fix, index|
+            puts "🔧 [WORKSPACE] Processing fix #{index + 1}: #{fix.inspect}"
+            file_path = File.join(workspace_path, fix[:file_path])
+            puts "🔧 [WORKSPACE] Target file: #{file_path}"
+            puts "🔧 [WORKSPACE] File exists: #{File.exist?(file_path)}"
+            
+            next unless File.exist?(file_path)
+            
+            puts "🔧 [WORKSPACE] Creating backup..."
+            # Backup original file
+            backup_file(file_path)
+            
+            puts "🔧 [WORKSPACE] Applying fix to file..."
+            # Apply the fix
+            apply_fix_to_file(file_path, fix[:new_code], class_name, method_name)
+          end
+          
+          puts "✅ Fixes applied successfully in workspace"
+          true
+        rescue => e
+          puts "❌ Failed to apply fixes in workspace: #{e.message}"
+          false
+        end
+      end
+      
+      def test_fixes_in_workspace(workspace_path)
+        config = CodeHealer::ConfigManager.code_heal_directory_config
+        
+        puts "🧪 Testing fixes in workspace: #{workspace_path}"
+        
+        begin
+          # Change to workspace directory
+          Dir.chdir(workspace_path) do
+            # Run basic syntax check
+            syntax_check = system("ruby -c #{find_ruby_files.join(' ')} 2>/dev/null")
+            return false unless syntax_check
+            
+            # Run tests if available
+            if File.exist?('Gemfile')
+              bundle_check = system("bundle check >/dev/null 2>&1")
+              return false unless bundle_check
+              
+              # Run tests if RSpec is available
+              if File.exist?('spec') || File.exist?('test')
+                test_result = system("bundle exec rspec --dry-run >/dev/null 2>&1") ||
+                             system("bundle exec rake test:prepare >/dev/null 2>&1")
+                puts "🧪 Test preparation: #{test_result ? '✅' : '⚠️'}"
+              end
+            end
+            
+            puts "✅ Workspace validation passed"
+            true
+          end
+        rescue => e
+          puts "❌ Workspace validation failed: #{e.message}"
+          false
+        end
+      end
+      
+      def merge_fixes_back(repo_path, workspace_path, branch_name)
+        puts "🔄 Merging fixes back to main repository"
+        
+        begin
+          # Create healing branch in main repo
+          Dir.chdir(repo_path) do
+            # Ensure we're on the target branch
+            system("git checkout #{branch_name}")
+            system("git pull origin #{branch_name}")
+            
+            # Create healing branch
+            healing_branch = "code-healer-fix-#{Time.now.to_i}"
+            system("git checkout -b #{healing_branch}")
+            
+            # Copy fixed files from workspace
+            copy_fixed_files(workspace_path, repo_path)
+            
+            # Commit changes
+            system("git add .")
+            commit_message = "Fix applied by CodeHealer: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+            system("git commit -m '#{commit_message}'")
+            
+            # Push branch
+            system("git push origin #{healing_branch}")
+            
+            puts "✅ Healing branch created: #{healing_branch}"
+            healing_branch
+          end
+        rescue => e
+          puts "❌ Failed to merge fixes back: #{e.message}"
+          nil
+        end
+      end
+      
+      def cleanup_workspace(workspace_path)
+        puts "🧹 [WORKSPACE] Starting workspace cleanup..."
+        puts "🧹 [WORKSPACE] Target: #{workspace_path}"
+        puts "🧹 [WORKSPACE] Exists: #{Dir.exist?(workspace_path)}"
+        
+        return unless Dir.exist?(workspace_path)
+        
+        puts "🧹 [WORKSPACE] Removing workspace directory..."
+        FileUtils.rm_rf(workspace_path)
+        puts "🧹 [WORKSPACE] Workspace cleanup completed"
+        puts "🧹 [WORKSPACE] Directory still exists: #{Dir.exist?(workspace_path)}"
+      end
+      
+      def cleanup_expired_workspaces
+        config = CodeHealer::ConfigManager.code_heal_directory_config
+        auto_cleanup = config['auto_cleanup']
+        auto_cleanup = config[:auto_cleanup] if auto_cleanup.nil?
+        return unless auto_cleanup
+        
+        puts "🧹 Cleaning up expired healing workspaces"
+        
+        base_path = config['path'] || config[:path] || '/tmp/code_healer_workspaces'
+        Dir.glob(File.join(base_path, "healing_*")).each do |workspace_path|
+          next unless Dir.exist?(workspace_path)
+          
+          # Check if workspace is expired
+          hours = config['cleanup_after_hours'] || config[:cleanup_after_hours]
+          hours = hours.to_i if hours
+          if workspace_expired?(workspace_path, hours)
+            cleanup_workspace(workspace_path)
+          end
+        end
+      end
+      
+      private
+      
+      def clone_strategy
+        cfg = CodeHealer::ConfigManager.code_heal_directory_config
+        cfg['clone_strategy'] || cfg[:clone_strategy] || "branch"
+      end
+      
+      def clone_current_branch(repo_path, workspace_path, branch_name)
+        puts "🌿 [WORKSPACE] Starting branch cloning..."
+        Dir.chdir(repo_path) do
+          current_branch = branch_name || `git branch --show-current`.strip
+          puts "🌿 [WORKSPACE] Current branch: #{current_branch}"
+          puts "🌿 [WORKSPACE] Executing: git clone --single-branch --branch #{current_branch} #{repo_path} #{workspace_path}"
+          
+          # Clone only the current branch
+          result = system("git clone --single-branch --branch #{current_branch} #{repo_path} #{workspace_path}")
+          puts "🌿 [WORKSPACE] Clone result: #{result ? 'SUCCESS' : 'FAILED'}"
+          
+          if result
+            puts "🌿 [WORKSPACE] Removing .git to avoid conflicts..."
+            # Remove .git to avoid conflicts
+            FileUtils.rm_rf(File.join(workspace_path, '.git'))
+            puts "🌿 [WORKSPACE] .git removed successfully"
+          else
+            puts "🌿 [WORKSPACE] Clone failed, checking workspace..."
+            puts "🌿 [WORKSPACE] Workspace exists: #{Dir.exist?(workspace_path)}"
+            puts "🌿 [WORKSPACE] Workspace contents: #{Dir.exist?(workspace_path) ? Dir.entries(workspace_path).join(', ') : 'N/A'}"
+          end
+        end
+      end
+      
+      def clone_full_repo(repo_path, workspace_path, branch_name)
+        puts "🌿 [WORKSPACE] Starting full repo cloning..."
+        Dir.chdir(repo_path) do
+          current_branch = branch_name || `git branch --show-current`.strip
+          puts "🌿 [WORKSPACE] Target branch: #{current_branch}"
+          puts "🌿 [WORKSPACE] Executing: git clone #{repo_path} #{workspace_path}"
+          
+          # Clone full repo
+          result = system("git clone #{repo_path} #{workspace_path}")
+          puts "🌿 [WORKSPACE] Clone result: #{result ? 'SUCCESS' : 'FAILED'}"
+          
+          if result
+            puts "🌿 [WORKSPACE] Switching to branch: #{current_branch}"
+            # Switch to specific branch
+            Dir.chdir(workspace_path) do
+              checkout_result = system("git checkout #{current_branch}")
+              puts "🌿 [WORKSPACE] Checkout result: #{checkout_result ? 'SUCCESS' : 'FAILED'}"
+            end
+          else
+            puts "🌿 [WORKSPACE] Full repo clone failed"
+          end
+        end
+      end
+      
+      def backup_file(file_path)
+        backup_path = "#{file_path}.code_healer_backup"
+        FileUtils.cp(file_path, backup_path)
+      end
+      
+      def apply_fix_to_file(file_path, new_code, class_name, method_name)
+        content = File.read(file_path)
+        
+        # Find and replace the method
+        method_pattern = /def\s+#{Regexp.escape(method_name)}\s*\([^)]*\)(.*?)end/m
+        if content.match(method_pattern)
+          content.gsub!(method_pattern, new_code)
+          File.write(file_path, content)
+          puts "✅ Applied fix to #{File.basename(file_path)}##{method_name}"
+        else
+          puts "⚠️  Could not find method #{method_name} in #{File.basename(file_path)}"
+        end
+      end
+      
+      def find_ruby_files
+        Dir.glob("**/*.rb")
+      end
+      
+      def copy_fixed_files(workspace_path, repo_path)
+        # Copy all Ruby files from workspace to repo
+        Dir.glob(File.join(workspace_path, "**/*.rb")).each do |workspace_file|
+          relative_path = workspace_file.sub(workspace_path + "/", "")
+          repo_file = File.join(repo_path, relative_path)
+          
+          if File.exist?(repo_file)
+            FileUtils.cp(workspace_file, repo_file)
+            puts "📁 Copied fixed file: #{relative_path}"
+          end
+        end
+      end
+      
+      def workspace_expired?(workspace_path, hours)
+        return false unless hours && hours > 0
+        
+        # Extract timestamp from workspace name
+        if workspace_path =~ /healing_(\d+)/
+          timestamp = $1.to_i
+          age_hours = (Time.now.to_i - timestamp) / 3600
+          age_hours > hours
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/code_healer/setup.rb

@@ -153,6 +153,17 @@ puts "🌿 Git Branch Configuration:"
 branch_prefix = ask_for_input("Enter branch prefix for healing branches (default: evolve):", default: "evolve")
 pr_target_branch = ask_for_input("Enter target branch for pull requests (default: main):", default: "main")
 
+# Code Heal Directory Configuration
+puts
+puts "🏥 Code Heal Directory Configuration:"
+puts "This directory will store isolated copies of your code for safe healing."
+puts "CodeHealer will clone your current branch here before making fixes."
+puts
+
+code_heal_directory = ask_for_input("Enter code heal directory path (default: /tmp/code_healer_workspaces):", default: "/tmp/code_healer_workspaces")
+auto_cleanup = ask_for_yes_no("Automatically clean up healing workspaces after use?", default: true)
+cleanup_after_hours = ask_for_input("Clean up workspaces after how many hours? (default: 24):", default: "24")
+
 # Business Context
 puts
 puts "💼 Business Context Setup:"
@@ -297,6 +308,14 @@ config_content = <<~YAML
     max_concurrent_healing: 3
     healing_timeout: 300
     retry_attempts: 3
+  
+  # Code Heal Directory Configuration
+  code_heal_directory:
+    path: "#{code_heal_directory}"
+    auto_cleanup: #{auto_cleanup}
+    cleanup_after_hours: #{cleanup_after_hours}
+    max_workspaces: 10
+    clone_strategy: "branch"  # Options: branch, full_repo
 YAML
 
 create_file_with_content('config/code_healer.yml', config_content, dry_run: options[:dry_run])
@@ -366,14 +385,19 @@ else
   puts "4. Start your Rails server: rails s"
   puts
   puts "🔒 Security Notes:"
-  puts "   - .env file contains your actual API keys and is ignored by git"
-  puts "   - .env.example is safe to commit and shows the required format"
-  puts "   - Never commit .env files with real secrets to version control"
-  puts
-  puts "⚙️  Configuration:"
-  puts "   - code_healer.yml contains comprehensive settings with sensible defaults"
-  puts "   - Customize the configuration file as needed for your project"
-  puts "   - All features are pre-configured and ready to use"
+puts "   - .env file contains your actual API keys and is ignored by git"
+puts "   - .env.example is safe to commit and shows the required format"
+puts "   - Never commit .env files with real secrets to version control"
+puts
+puts "🏥 Code Heal Directory:"
+puts "   - Your code will be cloned to: #{code_heal_directory}"
+puts "   - This ensures safe, isolated healing without affecting your running server"
+puts "   - Workspaces are automatically cleaned up after #{cleanup_after_hours} hours"
+puts
+puts "⚙️  Configuration:"
+puts "   - code_healer.yml contains comprehensive settings with sensible defaults"
+puts "   - Customize the configuration file as needed for your project"
+puts "   - All features are pre-configured and ready to use"
   puts
   puts "🌍 Environment Variables:"
   puts "   - Add 'gem \"dotenv-rails\"' to your Gemfile for automatic .env loading"

data/lib/code_healer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodeHealer
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/code_healer.rb

@@ -21,6 +21,7 @@ autoload :BusinessContextManager, "code_healer/business_context_manager"
 autoload :ClaudeCodeEvolutionHandler, "code_healer/claude_code_evolution_handler"
 autoload :SimpleHealer, "code_healer/simple_healer"
 autoload :HealingJob, "code_healer/healing_job"
+autoload :HealingWorkspaceManager, "code_healer/healing_workspace_manager"
 autoload :PullRequestCreator, "code_healer/pull_request_creator"
 autoload :McpServer, "code_healer/mcp_server"
 autoload :McpTools, "code_healer/mcp_tools"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_healer
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Deepan Kumar
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-14 00:00:00.000000000 Z
+date: 2025-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -368,6 +368,7 @@ files:
 - lib/code_healer/evolution_job.rb
 - lib/code_healer/global_handler.rb
 - lib/code_healer/healing_job.rb
+- lib/code_healer/healing_workspace_manager.rb
 - lib/code_healer/mcp.rb
 - lib/code_healer/mcp_prompts.rb
 - lib/code_healer/mcp_server.rb