code_healer 0.1.22 → 0.1.26

data/lib/code_healer/healing_workspace_manager.rb

@@ -1,53 +1,62 @@
 require 'fileutils'
 require 'securerandom'
+require_relative 'presentation_logger'
 
 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'}"
+        PresentationLogger.workspace_action("Preparing isolated workspace")
+        PresentationLogger.detail("Repo: #{repo_path}")
+        PresentationLogger.detail("Target branch: #{branch_name || 'default'}")
         
         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)
+        # Use persistent workspace ID based on repo (if enabled)
+        if CodeHealer::ConfigManager.persistent_workspaces_enabled?
+          repo_name = extract_repo_name(repo_path)
+          workspace_id = "persistent_#{repo_name}"
+          workspace_path = File.join(base_path, workspace_id)
+        else
+          # Fallback to unique workspace for each healing session
+          workspace_id = "healing_#{Time.now.to_i}_#{SecureRandom.hex(4)}"
+          workspace_path = File.join(base_path, workspace_id)
+        end
         
-        puts "🏥 [WORKSPACE] Workspace ID: #{workspace_id}"
-        puts "🏥 [WORKSPACE] Full workspace path: #{workspace_path}"
+        if CodeHealer::ConfigManager.persistent_workspaces_enabled?
+          PresentationLogger.detail("Using persistent workspace: #{workspace_id}")
+        else
+          PresentationLogger.detail("Creating temporary workspace: #{workspace_id}")
+        end
         
         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)
+          # Check if workspace already exists
+          if Dir.exist?(workspace_path) && Dir.exist?(File.join(workspace_path, '.git'))
+            if CodeHealer::ConfigManager.persistent_workspaces_enabled?
+              PresentationLogger.detail("Reusing existing workspace, checking out target branch")
+              checkout_to_branch(workspace_path, branch_name, repo_path)
+            else
+              PresentationLogger.detail("Recreating workspace (persistent mode disabled)")
+              cleanup_workspace(workspace_path, true)
+              create_persistent_workspace(repo_path, workspace_path, branch_name)
+            end
           else
-            puts "🏥 [WORKSPACE] Using full repo cloning..."
-            clone_full_repo(repo_path, workspace_path, branch_name)
+            PresentationLogger.detail("Creating new workspace")
+            create_persistent_workspace(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(', ')}"
+          PresentationLogger.success("Workspace ready")
+          PresentationLogger.detail("Path: #{workspace_path}")
+          PresentationLogger.detail("Branch: #{get_current_branch(workspace_path)}")
           workspace_path
         rescue => e
-          puts "❌ Failed to create healing workspace: #{e.message}"
-          cleanup_workspace(workspace_path) if Dir.exist?(workspace_path)
+          PresentationLogger.error("Failed to create workspace: #{e.message}")
+          # Don't cleanup persistent workspace on error
           raise e
         end
       end
@@ -97,51 +106,92 @@ module CodeHealer
       def test_fixes_in_workspace(workspace_path)
         config = CodeHealer::ConfigManager.code_heal_directory_config
         
-        puts "🧪 Testing fixes in workspace: #{workspace_path}"
+        PresentationLogger.step("Validating fixes")
         
         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
+            unless syntax_check
+              PresentationLogger.error("Syntax validation failed")
+              return false
+            end
             
             # Optionally skip heavy tests in demo mode
             unless CodeHealer::ConfigManager.demo_skip_tests?
               # Run tests if available
               if File.exist?('Gemfile')
                 bundle_check = system("bundle check >/dev/null 2>&1")
-                return false unless bundle_check
+                unless bundle_check
+                  PresentationLogger.error("Bundle check failed")
+                  return false
+                end
                 
                 # 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 ? '✅' : '⚠️'}"
+                  PresentationLogger.detail("Test preparation: #{test_result ? 'passed' : 'skipped'}")
                 end
               end
             end
             
-            puts "✅ Workspace validation passed"
+            PresentationLogger.success("Validation passed")
             true
           end
         rescue => e
-          puts "❌ Workspace validation failed: #{e.message}"
+          PresentationLogger.error("Validation failed: #{e.message}")
           false
         end
       end
       
+      def validate_workspace_for_commit(workspace_path)
+        puts "🔍 [WORKSPACE] Validating workspace for commit..."
+        
+        Dir.chdir(workspace_path) do
+          # Check for any temporary files that might have been added
+          staged_files = `git diff --cached --name-only`.strip.split("\n")
+          working_files = `git status --porcelain | grep '^ M\\|^M \\|^A ' | awk '{print $2}'`.strip.split("\n")
+          
+          all_files = (staged_files + working_files).uniq.reject(&:empty?)
+          
+          puts "🔍 [WORKSPACE] Files to be committed: #{all_files.join(', ')}"
+          
+          # Check for any temporary files
+          temp_files = all_files.select { |file| should_skip_file?(file) }
+          
+          if temp_files.any?
+            puts "⚠️ [WORKSPACE] WARNING: Temporary files detected in commit:"
+            temp_files.each { |file| puts "   - #{file}" }
+            
+            # Remove them from staging
+            temp_files.each do |file|
+              puts "🗑️ [WORKSPACE] Removing temporary file from staging: #{file}"
+              system("git reset HEAD '#{file}' 2>/dev/null || true")
+            end
+            
+            puts "🔍 [WORKSPACE] Temporary files removed from staging"
+            return false
+          end
+          
+          puts "✅ [WORKSPACE] Workspace validation passed - no temporary files detected"
+          return true
+        end
+      rescue => e
+        puts "❌ [WORKSPACE] Workspace validation failed: #{e.message}"
+        return false
+      end
+      
       def create_healing_branch(repo_path, workspace_path, branch_name)
-        puts "🔄 Creating healing branch and PR from isolated workspace"
+        PresentationLogger.git_action("Creating healing branch and PR")
         
         begin
           # All Git operations happen in the isolated workspace
           Dir.chdir(workspace_path) do
-            puts "🌿 [WORKSPACE] Working in isolated workspace: #{workspace_path}"
-            
-            # Debug Git configuration
-            puts "🌿 [WORKSPACE] Git remote origin: #{`git config --get remote.origin.url`.strip}"
-            puts "🌿 [WORKSPACE] Current branch: #{`git branch --show-current`.strip}"
+            PresentationLogger.detail("Working in isolated workspace")
+            PresentationLogger.detail("Remote: #{`git config --get remote.origin.url`.strip}")
+            PresentationLogger.detail("Current branch: #{`git branch --show-current`.strip}")
             
             # Ensure we're on the target branch
             system("git checkout #{branch_name}")
@@ -151,75 +201,80 @@ module CodeHealer
             healing_branch = "code-healer-fix-#{Time.now.to_i}"
             system("git checkout -b #{healing_branch}")
             
-            # Check Git status
-            puts "📊 [WORKSPACE] Git status in workspace:"
-            system("git status --porcelain")
-            
             # Add all changes (the fixes are already applied in the workspace)
-            system("git add .")
+            add_only_relevant_files(workspace_path)
+            
+            # Validate workspace before commit to ensure no temporary files
+            unless validate_workspace_for_commit(workspace_path)
+              PresentationLogger.detail("Retrying file addition after validation")
+              add_only_relevant_files(workspace_path)
+            end
             
             # Check if there are changes to commit
             if system("git diff --cached --quiet") == false
-              puts "📝 [WORKSPACE] Changes detected, committing to healing branch..."
+              PresentationLogger.detail("Committing changes to healing branch")
               commit_message = "Fix applied by CodeHealer: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
               system("git commit -m '#{commit_message}'")
               
               # Push healing branch from workspace
-              puts "🚀 [WORKSPACE] Pushing healing branch from workspace..."
+              PresentationLogger.detail("Pushing healing branch")
               system("git push origin #{healing_branch}")
               
-              puts "✅ [WORKSPACE] Healing branch created and pushed: #{healing_branch}"
-              puts "🔒 Main repository (#{repo_path}) remains completely untouched"
-              puts "📝 All changes committed in isolated workspace"
+              PresentationLogger.success("Branch created and pushed: #{healing_branch}")
+              PresentationLogger.detail("Main repository remains untouched")
               
-                          # Create pull request if auto-create is enabled and no PR was already created
-            if should_create_pull_request? && !CodeHealer::ConfigManager.demo_skip_pr?
-              puts "🔍 [WORKSPACE] Checking if PR was already created by evolution handler..."
-              # Skip PR creation if we're in a healing workflow (PR likely already created)
-              puts "🔍 [WORKSPACE] PR creation skipped - likely already created by evolution handler"
-              puts "🔍 [WORKSPACE] Review the changes and create a pull request when ready"
-            else
-              puts "🔍 [WORKSPACE] Review the changes and create a pull request when ready"
-            end
+              # Create pull request if auto-create is enabled
+              if should_create_pull_request?
+                PresentationLogger.detail("Creating pull request")
+                pr_url = create_pull_request(healing_branch, branch_name)
+                if pr_url
+                  PresentationLogger.success("Pull request created: #{pr_url}")
+                else
+                  PresentationLogger.warn("Failed to create pull request")
+                end
+              else
+                PresentationLogger.info("Review changes and create PR when ready")
+              end
               
               healing_branch
             else
-              puts "⚠️ [WORKSPACE] No changes detected in workspace"
-              puts "🔍 This might indicate that:"
-              puts "   - The fixes were not applied to the workspace"
-              puts "   - There was an issue with the healing process"
+              PresentationLogger.warn("No changes detected in workspace")
+              PresentationLogger.detail("This might indicate fixes were not applied or there was an issue")
               
               # Delete the empty branch
               system("git checkout #{branch_name}")
               system("git branch -D #{healing_branch}")
-              puts "🗑️ [WORKSPACE] Deleted empty healing branch: #{healing_branch}"
+              PresentationLogger.detail("Deleted empty healing branch: #{healing_branch}")
               nil
             end
           end
         rescue => e
-          puts "❌ Failed to create healing branch from workspace: #{e.message}"
+          PresentationLogger.error("Failed to create healing branch: #{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)}"
-        
+      def cleanup_workspace(workspace_path, force = false)
         return unless Dir.exist?(workspace_path)
         
+        # Check if this is a persistent workspace
+        is_persistent = workspace_path.include?('persistent_')
+        
+        if is_persistent && !force
+          PresentationLogger.detail("Skipping cleanup of persistent workspace")
+          return
+        end
+        
+        PresentationLogger.detail("Cleaning up workspace")
+        
         # Remove .git directory first to avoid conflicts
         git_dir = File.join(workspace_path, '.git')
         if Dir.exist?(git_dir)
-          puts "🧹 [WORKSPACE] Removing .git directory to prevent conflicts..."
           FileUtils.rm_rf(git_dir)
         end
         
-        puts "🧹 [WORKSPACE] Removing workspace directory..."
         FileUtils.rm_rf(workspace_path)
-        puts "🧹 [WORKSPACE] Workspace cleanup completed"
-        puts "🧹 [WORKSPACE] Directory still exists: #{Dir.exist?(workspace_path)}"
+        PresentationLogger.detail("Workspace cleanup completed")
       end
       
       def cleanup_expired_workspaces
@@ -258,17 +313,25 @@ module CodeHealer
         begin
           require 'octokit'
           
-          config = CodeHealer::ConfigManager.config
-          github_token = ENV['GITHUB_TOKEN']
-          repo_name = config['github_repo'] || config[:github_repo]
+          # Try to get GitHub token from environment
+          github_token = ENV['GITHUB_TOKEN'] || ENV['GITHUB_ACCESS_TOKEN']
           
-          unless github_token && repo_name
-            puts "❌ Missing GitHub token or repository configuration"
+          unless github_token
+            puts "❌ Missing GitHub token. Set GITHUB_TOKEN environment variable"
+            puts "💡 You can create a token at: https://github.com/settings/tokens"
             return nil
           end
           
-          # Parse repo name (owner/repo)
-          owner, repo = repo_name.split('/')
+          # Auto-detect repository from git remote
+          repo_name = detect_github_repository
+          
+          unless repo_name
+            puts "❌ Could not detect GitHub repository from git remote"
+            puts "💡 Make sure your repository has a GitHub remote origin"
+            return nil
+          end
+          
+          puts "🔗 Creating PR for repository: #{repo_name}"
           
           client = Octokit::Client.new(access_token: github_token)
           
@@ -283,13 +346,283 @@ module CodeHealer
             "Generated at: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
           )
           
+          puts "✅ Pull request created successfully: #{pr.html_url}"
           pr.html_url
         rescue => e
           puts "❌ Failed to create pull request: #{e.message}"
+          puts "💡 Check your GitHub token and repository access"
           nil
         end
       end
+
+      def detect_github_repository
+        # Try to detect from current git remote
+        Dir.chdir(Dir.pwd) do
+          remote_url = `git config --get remote.origin.url`.strip
+          
+          if remote_url.include?('github.com')
+            # Extract owner/repo from GitHub URL
+            if remote_url.include?('git@github.com:')
+              # SSH format: git@github.com:owner/repo.git
+              repo_part = remote_url.gsub('git@github.com:', '').gsub('.git', '')
+            elsif remote_url.include?('https://github.com/')
+              # HTTPS format: https://github.com/owner/repo.git
+              repo_part = remote_url.gsub('https://github.com/', '').gsub('.git', '')
+            else
+              return nil
+            end
+            puts "🔍 Detected GitHub repository: #{repo_part}"
+            return repo_part
+          end
+        end
+        
+        nil
+      rescue
+        nil
+      end
       
+      def extract_repo_name(repo_path)
+        # Extract repo name from path or git remote
+        if File.exist?(File.join(repo_path, '.git'))
+          Dir.chdir(repo_path) do
+            remote_url = `git config --get remote.origin.url`.strip
+            if remote_url.include?('/')
+              remote_url.split('/').last.gsub('.git', '')
+            else
+              File.basename(repo_path)
+            end
+          end
+        else
+          File.basename(repo_path)
+        end
+      end
+
+      def create_persistent_workspace(repo_path, workspace_path, branch_name)
+        puts "🏥 [WORKSPACE] Creating new persistent workspace..."
+        
+        # Get the GitHub remote URL
+        Dir.chdir(repo_path) do
+          remote_url = `git config --get remote.origin.url`.strip
+          if remote_url.empty?
+            puts "❌ [WORKSPACE] No remote origin found in #{repo_path}"
+            return false
+          end
+          
+          puts "🏥 [WORKSPACE] Cloning from: #{remote_url}"
+          puts "🏥 [WORKSPACE] To workspace: #{workspace_path}"
+          
+          # Clone the full repository for persistent use
+          result = system("git clone #{remote_url} #{workspace_path}")
+          if result
+            puts "🏥 [WORKSPACE] Repository cloned successfully"
+            # Now checkout to the target branch
+            checkout_to_branch(workspace_path, branch_name, repo_path)
+          else
+            puts "❌ [WORKSPACE] Failed to clone repository"
+            return false
+          end
+        end
+      end
+
+      def checkout_to_branch(workspace_path, branch_name, repo_path)
+        puts "🏥 [WORKSPACE] Checking out to target branch..."
+        
+        # Determine target branch
+        target_branch = branch_name || CodeHealer::ConfigManager.pr_target_branch || get_default_branch(repo_path)
+        puts "🏥 [WORKSPACE] Target branch: #{target_branch}"
+        
+        Dir.chdir(workspace_path) do
+          # Fetch latest changes
+          puts "🏥 [WORKSPACE] Fetching latest changes..."
+          system("git fetch origin")
+          
+          # Check if branch exists locally
+          local_branch_exists = system("git show-ref --verify --quiet refs/heads/#{target_branch}")
+          
+          if local_branch_exists
+            puts "🏥 [WORKSPACE] Checking out existing local branch: #{target_branch}"
+            system("git checkout #{target_branch}")
+          else
+            puts "🏥 [WORKSPACE] Checking out remote branch: #{target_branch}"
+            system("git checkout -b #{target_branch} origin/#{target_branch}")
+          end
+          
+          # Pull latest changes
+          puts "🏥 [WORKSPACE] Pulling latest changes..."
+          system("git pull origin #{target_branch}")
+          
+          # Ensure workspace is clean
+          puts "🏥 [WORKSPACE] Ensuring workspace is clean..."
+          system("git reset --hard HEAD")
+          system("git clean -fd")
+          
+          # Remove any tracked temporary files that shouldn't be committed - AGGRESSIVE cleanup
+          puts "🏥 [WORKSPACE] Removing tracked temporary files..."
+          
+          # Remove root level temporary directories
+          system("git rm -r --cached tmp/ 2>/dev/null || true")
+          system("git rm -r --cached log/ 2>/dev/null || true")
+          system("git rm -r --cached .bundle/ 2>/dev/null || true")
+          system("git rm -r --cached storage/ 2>/dev/null || true")
+          system("git rm -r --cached coverage/ 2>/dev/null || true")
+          system("git rm -r --cached .yardoc/ 2>/dev/null || true")
+          system("git rm -r --cached .rspec_status 2>/dev/null || true")
+          
+          # Remove any nested tmp/ or log/ directories that might be tracked
+          system("find . -name 'tmp' -type d -exec git rm -r --cached {} + 2>/dev/null || true")
+          system("find . -name 'log' -type d -exec git rm -r --cached {} + 2>/dev/null || true")
+          
+          # Remove any .tmp, .log, .cache files
+          system("find . -name '*.tmp' -exec git rm --cached {} + 2>/dev/null || true")
+          system("find . -name '*.log' -exec git rm --cached {} + 2>/dev/null || true")
+          system("find . -name '*.cache' -exec git rm --cached {} + 2>/dev/null || true")
+          
+          puts "🏥 [WORKSPACE] Successfully checked out to: #{target_branch}"
+        end
+      end
+
+      def get_default_branch(repo_path)
+        Dir.chdir(repo_path) do
+          # Try to get default branch from remote
+          default_branch = `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`.strip
+          if default_branch.include?('origin/')
+            default_branch.gsub('refs/remotes/origin/', '')
+          else
+            # Fallback to common defaults
+            ['main', 'master'].find { |branch| system("git ls-remote --heads origin #{branch} >/dev/null 2>&1") }
+          end
+        end
+      end
+
+      def get_current_branch(workspace_path)
+        Dir.chdir(workspace_path) do
+          `git branch --show-current`.strip
+        end
+      rescue
+        'unknown'
+      end
+
+      def add_only_relevant_files(workspace_path)
+        puts "📁 [WORKSPACE] Adding only relevant files, respecting .gitignore..."
+        
+        Dir.chdir(workspace_path) do
+          # First, ensure .gitignore is respected
+          if File.exist?('.gitignore')
+            puts "📁 [WORKSPACE] Using repository's .gitignore file"
+          else
+            puts "📁 [WORKSPACE] No .gitignore found, using default patterns"
+          end
+          
+          # Get list of modified files
+          modified_files = `git status --porcelain | grep '^ M\\|^M \\|^A ' | awk '{print $2}'`.strip.split("\n")
+          
+          if modified_files.empty?
+            puts "📁 [WORKSPACE] No modified files to add"
+            return
+          end
+          
+          puts "📁 [WORKSPACE] Modified files: #{modified_files.join(', ')}"
+          
+          # Add each modified file individually
+          modified_files.each do |file|
+            next if file.empty?
+            
+            # Skip temporary and generated files
+            if should_skip_file?(file)
+              puts "📁 [WORKSPACE] Skipping temporary file: #{file}"
+              next
+            end
+            
+            puts "📁 [WORKSPACE] Adding file: #{file}"
+            system("git add '#{file}'")
+          end
+          
+          puts "📁 [WORKSPACE] File addition completed"
+        end
+      end
+
+      def should_skip_file?(file_path)
+        # Skip temporary and generated files - AGGRESSIVE filtering
+        skip_patterns = [
+          # Root level directories - NEVER commit these
+          /^tmp\//,
+          /^log\//,
+          /^\.git\//,
+          /^node_modules\//,
+          /^vendor\//,
+          /^public\/packs/,
+          /^public\/assets/,
+          /^\.bundle\//,
+          /^bootsnap/,
+          /^cache/,
+          /^storage\//,
+          /^coverage\//,
+          /^\.yardoc\//,
+          /^\.rspec_status/,
+          
+          # Any tmp/ directory at any level
+          /tmp\//,
+          
+          # Any log/ directory at any level  
+          /log\//,
+          
+          # Specific tmp subdirectories
+          /tmp\/cache\//,
+          /tmp\/bootsnap\//,
+          /tmp\/pids\//,
+          /tmp\/sockets\//,
+          /tmp\/sessions\//,
+          /tmp\/backup\//,
+          /tmp\/test\//,
+          
+          # File extensions
+          /\.tmp$/,
+          /\.log$/,
+          /\.cache$/,
+          /\.swp$/,
+          /\.swo$/,
+          /\.bak$/,
+          /\.backup$/,
+          /~$/,
+          
+          # Rails specific
+          /\.bundle\//,
+          /Gemfile\.lock\.backup/,
+          /config\/database\.yml\.backup/,
+          /config\/secrets\.yml\.backup/
+        ]
+        
+        # Additional check: if path contains 'tmp' or 'log' anywhere, skip it
+        if file_path.include?('tmp') || file_path.include?('log')
+          puts "📁 [WORKSPACE] Skipping file containing 'tmp' or 'log': #{file_path}"
+          return true
+        end
+        
+        skip_patterns.any? { |pattern| file_path.match?(pattern) }
+      end
+
+      def reset_workspace_to_clean_state(workspace_path, branch_name = nil)
+        puts "🔄 [WORKSPACE] Resetting workspace to clean state..."
+        
+        Dir.chdir(workspace_path) do
+          # Stash any uncommitted changes
+          puts "🔄 [WORKSPACE] Stashing any uncommitted changes..."
+          system("git stash")
+          
+          # Reset to clean state
+          puts "🔄 [WORKSPACE] Resetting to clean state..."
+          system("git reset --hard HEAD")
+          system("git clean -fd")
+          
+          # Checkout to target branch if specified
+          if branch_name
+            checkout_to_branch(workspace_path, branch_name, nil)
+          end
+          
+          puts "🔄 [WORKSPACE] Workspace reset to clean state"
+        end
+      end
+
       def clone_strategy
         cfg = CodeHealer::ConfigManager.code_heal_directory_config
         cfg['clone_strategy'] || cfg[:clone_strategy] || "branch"