code_healer 0.1.24 → 0.1.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 704c23ee702e1f6a10a5fbbdcebe377d0523aa69d880aa40257e7351528130f3
-  data.tar.gz: e6989f6bbe820a4891c4b1268cde29d9231875c7415d4fbcc8ba9e8d5b72bc91
+  metadata.gz: 20c5c060c65cfee68cf65f2478e6335b1927f7e810fdcf6dd1c6796e29b49f65
+  data.tar.gz: 38aad1427647fe628c1a0aa2824fe09b206d6ac752ef6b1407a41ddd15560383
 SHA512:
-  metadata.gz: e383c0afbc418195f3de44b0763bca3d18014d198d4cf0d204cf65be5b4c0a763a25ae86faef7c90eba11cb694bf76f5ed24c1322ae3ebeab293fe00509c1d25
-  data.tar.gz: 694a3cad9243ece93065c849f5dba28e3316d9a678dc8b299d5b675d7125a96441a886b946f24956b0ec54052a3f6bb2e00b3cd0815b941da35094f26c7935ea
+  metadata.gz: eb2f391d38dfb0e444ff60e66d92625409f09c8389705a08c3ca3783f9aa56ae1d10dffc36109472cf2158c1e44b3df1eaba6100263f57d7d82bec713d58bbe6
+  data.tar.gz: 7864c4f255da0a1682d8c5787009998fe0e554a29fadbaf486f84d3c7664cdb12596381d8affa303110dc68a7b42d83c00f10da94c7f5f7368bc8bed88d13189

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [0.1.24] - 2025-08-31
 
+## [0.1.26] - 2025-09-03
+
+### Added
+- **Enhanced PresentationLogger**: Improved with backtrace truncation, timing display, and specialized action methods
+- **Smart Value Truncation**: Long arrays and strings are intelligently truncated for clean presentation
+- **Timing Integration**: Total healing time displayed in final outcome
+- **Action-Specific Logging**: `claude_action`, `workspace_action`, `git_action` methods for contextual logging
+
+### Changed
+- **Workspace Logs**: Dramatically reduced verbosity while maintaining key information
+- **Backtrace Display**: Shows only first 3 relevant lines with clean formatting
+- **Git Operations**: Streamlined git status and diff output for presentation clarity
+- **Outcome Display**: Enhanced with timing and better formatting
+
+### Notes
+- Perfect for conference demos with `CODE_HEALER_VERBOSE=true` for detailed debugging
+- No API changes; safe minor release
+
+## [0.1.25] - 2025-09-03
+
+### Added
+- PresentationLogger: clean, emoji-labeled, presentation-friendly logs with optional verbose mode (`CODE_HEALER_VERBOSE=true`)
+- HealingJob and ClaudeCodeEvolutionHandler now use PresentationLogger for concise output
+
+### Changed
+- Suppressed noisy prints in core healing flow in favor of high-signal steps and outcomes
+
+### Notes
+- No API changes; safe minor release. Ideal for conference demos.
+
 ### Added
 - **Aggressive File Filtering**: Implemented comprehensive filtering to prevent `tmp/`, `log/`, and other temporary files from being committed
 - **Pre-Commit Validation**: Added workspace validation before commit to ensure no temporary files slip through

data/lib/code_healer/claude_code_evolution_handler.rb

@@ -1,14 +1,15 @@
 require 'timeout'
 require 'open3'
+require_relative 'presentation_logger'
 
 module CodeHealer
   class ClaudeCodeEvolutionHandler
     class << self
       def handle_error_with_claude_code(error, class_name, method_name, file_path)
-        puts "🤖 Claude Code Terminal Evolution Triggered!"
-        puts "Error: #{error.class} - #{error.message}"
-        puts "Class: #{class_name}, Method: #{method_name}"
-        puts "File: #{file_path}"
+        PresentationLogger.section("Claude Code Terminal – Evolution")
+        PresentationLogger.kv("Error", "#{error.class}: #{error.message}")
+        PresentationLogger.kv("Target", "#{class_name}##{method_name}")
+        PresentationLogger.detail("File: #{file_path}")
         
         begin
           # Build concise, demo-optimized prompt (no repo-wide scan, no tests)
@@ -26,24 +27,24 @@ module CodeHealer
           success = execute_claude_code_fix(prompt, class_name, method_name)
           
           if success
-            puts "✅ Claude Code evolution completed successfully!"
+            PresentationLogger.success("Claude run completed")
             # Reload modified files
             reload_modified_files
             
             # 🚀 Trigger Git operations (commit, push, PR creation)
             # Note: Git operations are now handled by the isolated workspace manager
             # to prevent duplication and ensure proper isolation
-            puts "🔄 Git operations will be handled by isolated workspace manager..."
+            PresentationLogger.info("Git operations handled by workspace manager")
             
             return true
           else
-            puts "❌ Claude Code evolution failed"
+            PresentationLogger.error("Claude run failed")
             return false
           end
           
         rescue => e
-          puts "❌ Claude Code evolution error: #{e.message}"
-          puts e.backtrace.first(5)
+          PresentationLogger.error("Claude evolution error: #{e.message}")
+          PresentationLogger.detail("Backtrace: #{Array(e.backtrace).first(5).join("\n")}")
           return false
         end
       end
@@ -56,24 +57,20 @@ module CodeHealer
         # Build command
         command = build_claude_command(prompt, config)
         
-        puts "🚀 Executing Claude Code fix..."
-        puts "Command: #{command}"
-        puts "Timeout: #{config['timeout']} seconds"
+        PresentationLogger.claude_action("Executing Claude Code (timeout: #{config['timeout']}s)")
         
         begin
           # Execute with timeout
           Timeout.timeout(config['timeout']) do
             stdout, stderr, status = Open3.capture3(command)
             
-            puts "📤 Claude Code Output:"
             if stdout && !stdout.empty?
-              puts "✅ Response received:"
-              puts stdout
+              PresentationLogger.success("Response received from Claude")
+              PresentationLogger.detail(stdout)
 
               # Check if Claude Code is asking for permission
               if stdout.include?("permission") || stdout.include?("grant") || stdout.include?("edit")
-                puts "🔐 Claude Code needs permission to edit files"
-                puts "💡 Make sure to grant Edit permissions when prompted"
+                PresentationLogger.warn("Claude requested edit permissions. Ensure permissions are granted.")
               end
               
               # Check if fix was applied
@@ -81,28 +78,28 @@ module CodeHealer
                 puts "🎯 Fix appears to be ready - checking if files were modified..."
               end
             else
-              puts "⚠️  No output received from Claude Code"
+              PresentationLogger.warn("No output received from Claude")
             end
 
             if stderr && !stderr.empty?
-              puts "⚠️  Claude Code Warnings/Errors:"
-              puts stderr
+              PresentationLogger.warn("Claude warnings/errors present")
+              PresentationLogger.detail(stderr)
             end
             
             if status.success?
-              puts "✅ Claude Code execution completed successfully"
+              PresentationLogger.success("Claude execution succeeded")
               return true
             else
-              puts "❌ Claude Code execution failed with status: #{status.exitstatus}"
+              PresentationLogger.error("Claude execution failed (status #{status.exitstatus})")
               return false
             end
           end
           
         rescue Timeout::Error
-          puts "⏰ Claude Code execution timed out after #{config['timeout']} seconds"
+          PresentationLogger.error("Claude execution timed out after #{config['timeout']}s")
           return false
         rescue => e
-          puts "❌ Claude Code execution error: #{e.message}"
+          PresentationLogger.error("Claude execution error: #{e.message}")
           return false
         end
       end
@@ -138,7 +135,7 @@ module CodeHealer
       end
       
       def reload_modified_files
-        puts "🔄 Reloading modified files..."
+        PresentationLogger.step("Reloading modified files")
         
         # Get list of recently modified files (last 5 minutes)
         recent_files = get_recently_modified_files
@@ -147,14 +144,14 @@ module CodeHealer
           if file_path.include?('/app/')
             begin
               load file_path
-              puts "✅ Reloaded: #{file_path}"
+              PresentationLogger.detail("Reloaded: #{file_path}")
             rescue => e
-              puts "⚠️  Failed to reload #{file_path}: #{e.message}"
+              PresentationLogger.warn("Failed to reload #{file_path}: #{e.message}")
             end
           end
         end
         
-        puts "🔄 File reloading completed"
+        PresentationLogger.detail("File reloading completed")
       end
       
       def get_recently_modified_files
@@ -191,7 +188,7 @@ module CodeHealer
           f.puts(log_entry.to_json)
         end
         
-        puts "📝 Evolution attempt logged to #{log_file}"
+        PresentationLogger.detail("Evolution attempt logged to #{log_file}")
       end
       
 

data/lib/code_healer/healing_job.rb

@@ -1,5 +1,6 @@
 require 'sidekiq'
 require 'open3'
+require_relative 'presentation_logger'
 
 module CodeHealer
   class HealingJob
@@ -8,15 +9,15 @@ module CodeHealer
     sidekiq_options retry: 3, backtrace: true, queue: 'evolution'
 
     def perform(*args)
-      puts "🚀 [HEALING_JOB] Starting job with args: #{args.inspect}"
-      
+      start_time = Time.now
+      PresentationLogger.section("CodeHealer – Healing Job")
 
-      
       # Support both legacy and new invocation styles
       error, class_name, method_name, evolution_method, backtrace = parse_args(args)
-      
-      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}"
+      PresentationLogger.kv("Error", "#{error.class}: #{error.message}")
+      PresentationLogger.kv("Target", "#{class_name}##{method_name}")
+      PresentationLogger.kv("Strategy", evolution_method)
+      PresentationLogger.backtrace(backtrace)
 
       # Track start metric
       healing_id = MetricsCollector.generate_healing_id
@@ -30,13 +31,13 @@ module CodeHealer
       )
       MetricsCollector.track_error_occurrence(healing_id, Time.current)
 
-      puts "🚀 Evolution Job Started: #{class_name}##{method_name}"
+      PresentationLogger.success("Healing started for #{class_name}##{method_name}")
 
-      puts "🏥 [HEALING_JOB] About to create isolated healing workspace..."
+      PresentationLogger.step("Creating isolated healing workspace")
       # Create isolated healing workspace
       workspace_path = create_healing_workspace(class_name, method_name)
       MetricsCollector.track_workspace_creation(healing_id, workspace_path)
-      puts "🏥 [HEALING_JOB] Workspace created: #{workspace_path}"
+      PresentationLogger.kv("Workspace", workspace_path)
       
       ai_time_ms = nil
       git_time_ms = nil
@@ -46,7 +47,7 @@ module CodeHealer
       failure_reason = nil
 
       begin
-        puts "🔧 [HEALING_JOB] About to apply fixes in isolated environment..."
+        PresentationLogger.step("Applying fixes in isolated environment")
         # Apply fixes in isolated environment
         ai_started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         success = apply_fixes_in_workspace(workspace_path, error, class_name, method_name, evolution_method)
@@ -83,17 +84,18 @@ module CodeHealer
                 false   # pr_created
               )
               overall_success = true
-              puts "✅ Fixes applied, tested, and merged successfully! Branch: #{healing_branch}"
+              PresentationLogger.success("Fixes applied and validated")
+              PresentationLogger.kv("Branch", healing_branch)
             else
               overall_success = false
               failure_reason ||= 'healing_branch_creation_failed'
-              puts "⚠️  Fixes applied and tested, but merge failed"
+              PresentationLogger.warn("Fixes applied and tested, but merge failed")
             end
           else
             overall_success = false
             syntax_valid = false
             failure_reason ||= 'workspace_tests_failed_or_syntax_error'
-            puts "⚠️  Fixes applied but failed tests, not merging back"
+            PresentationLogger.warn("Fixes applied but validation failed; skipping merge")
           end
         else
           overall_success = false
@@ -105,7 +107,7 @@ module CodeHealer
             ai_provider_for(evolution_method),
             failure_reason
           )
-          puts "❌ Failed to apply fixes in workspace"
+          PresentationLogger.error("Failed to apply fixes in workspace")
         end
       ensure
         # Persist timing metrics if captured
@@ -122,10 +124,12 @@ module CodeHealer
         cleanup_workspace(workspace_path)
       end
 
-      puts "✅ Evolution Job Completed: #{class_name}##{method_name}"
+      total_time = ((Time.now - start_time) * 1000).round
+      timing = "#{total_time}ms total"
+      PresentationLogger.outcome(success: overall_success, branch: healing_branch, pr_url: nil, reason: failure_reason, timing: timing)
     rescue => e
-      puts "❌ Evolution Job Failed: #{e.message}"
-      puts "📍 Backtrace: #{e.backtrace.first(5)}"
+      PresentationLogger.error("Evolution Job Failed: #{e.message}")
+      PresentationLogger.detail("Backtrace: #{Array(e.backtrace).first(5).join("\n")}")
       raise e  # Re-raise to trigger Sidekiq retry
     end
 
@@ -222,7 +226,7 @@ module CodeHealer
     end
 
     def create_healing_workspace(class_name, method_name)
-      puts "🏥 Creating isolated healing workspace for #{class_name}##{method_name}"
+      PresentationLogger.detail("Preparing workspace for #{class_name}##{method_name}")
 
       # Create persistent workspace and checkout to target branch
       workspace_path = CodeHealer::HealingWorkspaceManager.create_healing_workspace(
@@ -230,12 +234,12 @@ module CodeHealer
         CodeHealer::ConfigManager.pr_target_branch  # Use configured target branch
       )
 
-      puts "✅ Healing workspace ready: #{workspace_path}"
+      PresentationLogger.detail("Workspace ready: #{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"
+      PresentationLogger.detail("Applying fixes in workspace #{workspace_path}")
 
       case evolution_method
       when 'claude_code_terminal'
@@ -251,13 +255,13 @@ module CodeHealer
         end
         handle_api_evolution_in_workspace(workspace_path, error, class_name, method_name)
       else
-        puts "❌ Unknown evolution method: #{evolution_method}"
+        PresentationLogger.error("Unknown evolution method: #{evolution_method}")
         false
       end
     end
 
     def handle_claude_code_evolution_in_workspace(workspace_path, error, class_name, method_name)
-      puts "🤖 Using Claude Code Terminal for evolution in workspace..."
+      PresentationLogger.step("Claude Code Terminal evolution")
 
       # Change to workspace directory for Claude Code operations
       Dir.chdir(workspace_path) do
@@ -266,17 +270,17 @@ module CodeHealer
         )
 
         if success
-          puts "✅ Claude Code evolution completed successfully in workspace!"
+          PresentationLogger.success("Claude evolution succeeded")
           true
         else
-          puts "❌ Claude Code evolution failed in workspace"
+          PresentationLogger.error("Claude evolution failed")
           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..."
+      PresentationLogger.step("OpenAI API evolution")
 
       # Load business context for API evolution
       business_context = CodeHealer::BusinessContextManager.get_context_for_error(
@@ -286,7 +290,7 @@ module CodeHealer
       # Optionally record business context used
       # MetricsCollector.track_business_context(healing_id, business_context) # healing_id not accessible here
 
-      puts "📋 Business context loaded for API evolution"
+      PresentationLogger.detail("Business context loaded for API evolution")
 
       # Change to workspace directory for API operations
       Dir.chdir(workspace_path) do
@@ -295,10 +299,10 @@ module CodeHealer
         )
 
         if success
-          puts "✅ API evolution completed successfully in workspace!"
+          PresentationLogger.success("API evolution succeeded")
           true
         else
-          puts "❌ API evolution failed in workspace"
+          PresentationLogger.error("API evolution failed")
           false
         end
       end
@@ -307,7 +311,7 @@ module CodeHealer
     def cleanup_workspace(workspace_path)
       return unless workspace_path && Dir.exist?(workspace_path)
 
-      puts "🧹 Cleaning up healing workspace: #{workspace_path}"
+      PresentationLogger.step("Cleaning up workspace")
       CodeHealer::HealingWorkspaceManager.cleanup_workspace(workspace_path)
     end
 

data/lib/code_healer/healing_workspace_manager.rb

@@ -1,20 +1,18 @@
 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] Target branch: #{branch_name || 'default'}"
+        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}"
         
         # Use persistent workspace ID based on repo (if enabled)
         if CodeHealer::ConfigManager.persistent_workspaces_enabled?
@@ -28,39 +26,36 @@ module CodeHealer
         end
         
         if CodeHealer::ConfigManager.persistent_workspaces_enabled?
-          puts "🏥 [WORKSPACE] Persistent workspace ID: #{workspace_id}"
+          PresentationLogger.detail("Using persistent workspace: #{workspace_id}")
         else
-          puts "🏥 [WORKSPACE] Temporary workspace ID: #{workspace_id}"
+          PresentationLogger.detail("Creating temporary workspace: #{workspace_id}")
         end
-        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}"
           
           # Check if workspace already exists
           if Dir.exist?(workspace_path) && Dir.exist?(File.join(workspace_path, '.git'))
             if CodeHealer::ConfigManager.persistent_workspaces_enabled?
-              puts "🏥 [WORKSPACE] Persistent workspace exists, checking out to target branch..."
+              PresentationLogger.detail("Reusing existing workspace, checking out target branch")
               checkout_to_branch(workspace_path, branch_name, repo_path)
             else
-              puts "🏥 [WORKSPACE] Workspace exists but persistent mode disabled, creating new one..."
+              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] Creating new workspace..."
+            PresentationLogger.detail("Creating new workspace")
             create_persistent_workspace(repo_path, workspace_path, branch_name)
           end
           
-          puts "🏥 [WORKSPACE] Workspace ready successfully!"
-          puts "🏥 [WORKSPACE] Final workspace path: #{workspace_path}"
-          puts "🏥 [WORKSPACE] Current branch: #{get_current_branch(workspace_path)}"
+          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/prepare healing workspace: #{e.message}"
+          PresentationLogger.error("Failed to create workspace: #{e.message}")
           # Don't cleanup persistent workspace on error
           raise e
         end
@@ -111,36 +106,42 @@ 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
@@ -183,16 +184,14 @@ module CodeHealer
       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}")
@@ -202,94 +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)
             add_only_relevant_files(workspace_path)
             
             # Validate workspace before commit to ensure no temporary files
             unless validate_workspace_for_commit(workspace_path)
-              puts "⚠️ [WORKSPACE] Workspace validation failed, retrying file addition..."
+              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
-                          if should_create_pull_request?
-                            puts "🔍 [WORKSPACE] Auto-creating pull request..."
-                            pr_url = create_pull_request(healing_branch, branch_name)
-                            if pr_url
-                              puts "✅ [WORKSPACE] Pull request created: #{pr_url}"
-                            else
-                              puts "⚠️ [WORKSPACE] Failed to create pull request"
-                            end
-                          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, force = false)
-        puts "🧹 [WORKSPACE] Starting workspace cleanup..."
-        puts "🧹 [WORKSPACE] Target: #{workspace_path}"
-        puts "🧹 [WORKSPACE] Force cleanup: #{force}"
-        puts "🧹 [WORKSPACE] Exists: #{Dir.exist?(workspace_path)}"
-        
         return unless Dir.exist?(workspace_path)
         
         # Check if this is a persistent workspace
         is_persistent = workspace_path.include?('persistent_')
         
         if is_persistent && !force
-          puts "🧹 [WORKSPACE] This is a persistent workspace - skipping cleanup"
-          puts "🧹 [WORKSPACE] Use force=true to override"
+          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

data/lib/code_healer/presentation_logger.rb

@@ -0,0 +1,114 @@
+module CodeHealer
+  # Presentation-focused logger for conference demos and clean operator output
+  class PresentationLogger
+    class << self
+      def verbose?
+        env_flag = ENV.fetch('CODE_HEALER_VERBOSE', 'false')
+        env_flag.to_s.downcase == 'true'
+      end
+
+      def section(title)
+        divider
+        puts "\n🎤  #{title}\n"
+      end
+
+      def step(message)
+        puts "➡️  #{message}"
+      end
+
+      def info(message)
+        puts "ℹ️  #{message}"
+      end
+
+      def success(message)
+        puts "✅ #{message}"
+      end
+
+      def warn(message)
+        puts "⚠️  #{message}"
+      end
+
+      def error(message)
+        puts "❌ #{message}"
+      end
+
+      def detail(message)
+        return unless verbose?
+        puts "   · #{message}"
+      end
+
+      def kv(label, value)
+        # Truncate long values for presentation
+        display_value = case value
+        when Array
+          if value.length > 3
+            "#{value.first(2).join(', ')}... (#{value.length} total)"
+          else
+            value.join(', ')
+          end
+        when String
+          value.length > 100 ? "#{value[0..97]}..." : value
+        else
+          value.to_s
+        end
+        puts "   • #{label}: #{display_value}"
+      end
+
+      def backtrace(backtrace_array)
+        return unless backtrace_array&.any?
+        
+        # Show only the first 3 relevant lines for presentation
+        relevant_lines = backtrace_array.first(3).map do |line|
+          # Extract just the file and line number for cleaner display
+          if line.match?(/^(.+\.rb):(\d+):in/)
+            file = File.basename($1)
+            line_num = $2
+            method = line.match(/in `(.+)'/)&.[](1) || 'unknown'
+            "#{file}:#{line_num} in #{method}"
+          else
+            line
+          end
+        end
+        
+        puts "   • Backtrace: #{relevant_lines.join(' → ')}"
+        detail("Full backtrace available with CODE_HEALER_VERBOSE=true") if backtrace_array.length > 3
+      end
+
+      def time(label, ms)
+        puts "⏱️  #{label}: #{ms} ms"
+      end
+
+      def divider
+        puts "\n────────────────────────────────────────────────────────\n"
+      end
+
+      def outcome(success:, branch: nil, pr_url: nil, reason: nil, timing: nil)
+        if success
+          success_msg = "🎉 Healing complete"
+          success_msg << " (#{timing})" if timing
+          success(success_msg)
+          puts "   • Branch: #{branch}" if branch
+          puts "   • PR: #{pr_url}" if pr_url
+        else
+          error_msg = "💥 Healing failed"
+          error_msg << " (#{reason})" if reason
+          error(error_msg)
+        end
+      end
+
+      def claude_action(action)
+        puts "🤖 #{action}"
+      end
+
+      def workspace_action(action)
+        puts "🏗️  #{action}"
+      end
+
+      def git_action(action)
+        puts "📝 #{action}"
+      end
+    end
+  end
+end
+
+

data/lib/code_healer/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_healer
 version: !ruby/object:Gem::Version
-  version: 0.1.24
+  version: 0.1.26
 platform: ruby
 authors:
 - Deepan Kumar
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-31 00:00:00.000000000 Z
+date: 2025-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -401,6 +401,7 @@ files:
 - lib/code_healer/mcp_server.rb
 - lib/code_healer/mcp_tools.rb
 - lib/code_healer/models/healing_metric.rb
+- lib/code_healer/presentation_logger.rb
 - lib/code_healer/pull_request_creator.rb
 - lib/code_healer/routes.rb
 - lib/code_healer/services/metrics_collector.rb