claude-evolve 1.4.7 → 1.4.9

package/bin/claude-evolve-autostatus

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""
+Auto-updating status display for claude-evolve that fits to terminal size.
+Updates in real-time without flicker using ANSI escape sequences.
+"""
+
+import os
+import sys
+import time
+import termios
+import tty
+import select
+import signal
+import argparse
+import subprocess
+from datetime import datetime
+
+# Add parent directory to path for imports
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(script_dir, '..'))
+
+from lib.config import Config
+from lib.evolution_csv import EvolutionCSV
+
+
+class TerminalDisplay:
+    """Handles terminal display with ANSI escape sequences for flicker-free updates."""
+    
+    def __init__(self):
+        self.rows, self.cols = self.get_terminal_size()
+        signal.signal(signal.SIGWINCH, self.handle_resize)
+        
+    def get_terminal_size(self):
+        """Get current terminal size."""
+        try:
+            rows, cols = os.popen('stty size', 'r').read().split()
+            return int(rows), int(cols)
+        except:
+            return 24, 80  # Default fallback
+    
+    def handle_resize(self, signum, frame):
+        """Handle terminal resize signal."""
+        self.rows, self.cols = self.get_terminal_size()
+    
+    def clear_screen(self):
+        """Clear the entire screen."""
+        print('\033[2J\033[H', end='')
+    
+    def move_cursor(self, row, col):
+        """Move cursor to specific position."""
+        print(f'\033[{row};{col}H', end='')
+    
+    def clear_line(self):
+        """Clear current line."""
+        print('\033[2K', end='')
+    
+    def hide_cursor(self):
+        """Hide the cursor."""
+        print('\033[?25l', end='')
+    
+    def show_cursor(self):
+        """Show the cursor."""
+        print('\033[?25h', end='')
+    
+    def reset(self):
+        """Reset terminal to normal state."""
+        self.show_cursor()
+        print('\033[0m', end='')  # Reset colors
+
+
+class AutoStatus:
+    """Auto-updating status display."""
+    
+    def __init__(self, working_dir=None):
+        self.config = Config()
+        
+        # Load config using same mechanism as other commands
+        # First check CLAUDE_EVOLVE_CONFIG env var
+        config_env = os.environ.get('CLAUDE_EVOLVE_CONFIG')
+        if config_env:
+            self.config.load(config_env)
+        else:
+            # Load from working directory or current directory
+            self.config.load(working_dir=working_dir)
+        
+        self.display = TerminalDisplay()
+        self.running = True
+        
+    def get_status_data(self):
+        """Get current status data from CSV."""
+        csv_path = self.config.resolve_path(self.config.data['csv_file'])
+        
+        with EvolutionCSV(csv_path) as csv:
+            df = csv.df
+            
+            # Count by status
+            status_counts = {
+                'pending': len(df[df['status'] == 'pending']),
+                'running': len(df[df['status'] == 'running']),
+                'complete': len(df[df['status'] == 'complete']),
+                'failed': len(df[df['status'] == 'failed']),
+                'total': len(df)
+            }
+            
+            # Get performance stats for completed
+            completed_df = df[df['status'] == 'complete']
+            if not completed_df.empty and 'performance' in completed_df.columns:
+                perf_values = completed_df['performance'].dropna()
+                if not perf_values.empty:
+                    perf_stats = {
+                        'min': perf_values.min(),
+                        'max': perf_values.max(),
+                        'mean': perf_values.mean(),
+                        'count': len(perf_values)
+                    }
+                else:
+                    perf_stats = None
+            else:
+                perf_stats = None
+            
+            # Get recent candidates (last N that fit on screen)
+            max_candidates = max(1, self.display.rows - 15)  # Reserve space for header/stats
+            recent = df.tail(max_candidates)
+            
+            return {
+                'counts': status_counts,
+                'performance': perf_stats,
+                'recent': recent,
+                'csv_path': csv_path
+            }
+    
+    def format_duration(self, seconds):
+        """Format duration in human-readable form."""
+        if seconds < 60:
+            return f"{seconds}s"
+        elif seconds < 3600:
+            return f"{seconds//60}m {seconds%60}s"
+        else:
+            hours = seconds // 3600
+            mins = (seconds % 3600) // 60
+            return f"{hours}h {mins}m"
+    
+    def render(self):
+        """Render the current status to the terminal."""
+        try:
+            data = self.get_status_data()
+        except Exception as e:
+            self.display.clear_screen()
+            self.display.move_cursor(1, 1)
+            print(f"Error reading status: {e}")
+            return
+        
+        # Clear screen and start rendering
+        self.display.clear_screen()
+        row = 1
+        
+        # Header
+        self.display.move_cursor(row, 1)
+        header = "Claude Evolution Auto-Status"
+        print(f"\033[1;36m{header.center(self.display.cols)}\033[0m")
+        row += 1
+        
+        # Timestamp
+        self.display.move_cursor(row, 1)
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f"Updated: {timestamp} | Press 'q' to quit")
+        row += 2
+        
+        # File info
+        self.display.move_cursor(row, 1)
+        print(f"CSV: {data['csv_path']}")
+        row += 2
+        
+        # Status summary
+        self.display.move_cursor(row, 1)
+        print("\033[1mStatus Summary:\033[0m")
+        row += 1
+        
+        counts = data['counts']
+        status_line = (f"  Total: {counts['total']} | "
+                      f"\033[33mPending: {counts['pending']}\033[0m | "
+                      f"\033[36mRunning: {counts['running']}\033[0m | "
+                      f"\033[32mComplete: {counts['complete']}\033[0m | "
+                      f"\033[31mFailed: {counts['failed']}\033[0m")
+        
+        self.display.move_cursor(row, 1)
+        print(status_line)
+        row += 2
+        
+        # Performance stats
+        if data['performance']:
+            self.display.move_cursor(row, 1)
+            print("\033[1mPerformance Stats:\033[0m")
+            row += 1
+            
+            perf = data['performance']
+            self.display.move_cursor(row, 1)
+            print(f"  Min: {perf['min']:.4f} | Max: {perf['max']:.4f} | "
+                  f"Mean: {perf['mean']:.4f} | Count: {perf['count']}")
+            row += 2
+        
+        # Recent candidates
+        if not data['recent'].empty:
+            self.display.move_cursor(row, 1)
+            print("\033[1mRecent Candidates:\033[0m")
+            row += 1
+            
+            # Table header
+            self.display.move_cursor(row, 1)
+            header_fmt = f"{'ID':>8} | {'Status':^10} | {'Performance':>11} | {'Description'}"
+            print(header_fmt[:self.display.cols])
+            row += 1
+            
+            self.display.move_cursor(row, 1)
+            print("-" * min(self.display.cols, len(header_fmt)))
+            row += 1
+            
+            # Table rows
+            for _, candidate in data['recent'].iterrows():
+                if row >= self.display.rows - 1:  # Leave room for bottom
+                    break
+                
+                self.display.move_cursor(row, 1)
+                
+                # Color based on status
+                status = candidate.get('status', 'unknown')
+                if status == 'complete':
+                    color = '\033[32m'  # Green
+                elif status == 'running':
+                    color = '\033[36m'  # Cyan
+                elif status == 'failed':
+                    color = '\033[31m'  # Red
+                elif status == 'pending':
+                    color = '\033[33m'  # Yellow
+                else:
+                    color = '\033[0m'   # Default
+                
+                # Format performance
+                if status == 'complete' and 'performance' in candidate:
+                    perf = f"{candidate['performance']:.4f}"
+                else:
+                    perf = "-"
+                
+                # Truncate description to fit
+                desc = candidate.get('description', '')
+                max_desc_len = self.display.cols - 35  # Account for other columns
+                if len(desc) > max_desc_len:
+                    desc = desc[:max_desc_len-3] + "..."
+                
+                line = f"{candidate['id']:>8} | {color}{status:^10}\033[0m | {perf:>11} | {desc}"
+                print(line[:self.display.cols])
+                row += 1
+        
+        # Ensure cursor is at bottom
+        self.display.move_cursor(self.display.rows, 1)
+        sys.stdout.flush()
+    
+    def check_input(self):
+        """Check for keyboard input without blocking."""
+        if select.select([sys.stdin], [], [], 0)[0]:
+            char = sys.stdin.read(1)
+            if char.lower() == 'q':
+                self.running = False
+                return True
+        return False
+    
+    def run(self):
+        """Main loop for auto-updating display."""
+        # Save terminal settings
+        old_settings = termios.tcgetattr(sys.stdin)
+        
+        try:
+            # Set terminal to raw mode for immediate input
+            tty.setraw(sys.stdin.fileno())
+            
+            self.display.hide_cursor()
+            
+            while self.running:
+                self.render()
+                
+                # Check for input and wait
+                for _ in range(10):  # Check 10 times per second
+                    if self.check_input():
+                        break
+                    time.sleep(0.1)
+        
+        except KeyboardInterrupt:
+            pass
+        
+        finally:
+            # Restore terminal settings
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+            self.display.reset()
+            self.display.clear_screen()
+            self.display.move_cursor(1, 1)
+            print("Exiting auto-status...")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Auto-updating status display for claude-evolve that fits to terminal size.",
+        epilog="Press 'q' to quit while running."
+    )
+    parser.add_argument(
+        '--working-dir',
+        help='Working directory containing claude-evolve.yaml config file'
+    )
+    
+    args = parser.parse_args()
+    
+    # Run auto-status
+    auto_status = AutoStatus(working_dir=args.working_dir)
+    auto_status.run()
+
+
+if __name__ == '__main__':
+    main()

package/bin/claude-evolve-worker

@@ -111,18 +111,22 @@ Important: Make meaningful changes that match the description. Don't just add co
   
   # Run evaluation
   echo "[WORKER-$$] Evaluating algorithm..."
-  local eval_output
+  local eval_output_file="/tmp/claude-evolve-eval-$$-$candidate_id.out"
   local eval_start=$(date +%s)
   
   # Prepare evaluation command
   local eval_cmd=("$PYTHON_CMD" "$FULL_EVALUATOR_PATH" "$candidate_id")
   [[ -n "$timeout_seconds" ]] && eval_cmd=(timeout "$timeout_seconds" "${eval_cmd[@]}")
   
-  # Run evaluation and capture output
-  if eval_output=$("${eval_cmd[@]}" 2>&1); then
+  # Run evaluation with tee to both display and capture output
+  # Use stdbuf to disable buffering for real-time output
+  if stdbuf -o0 -e0 "${eval_cmd[@]}" 2>&1 | tee "$eval_output_file" >&2; then
     local eval_end=$(date +%s)
     local eval_duration=$((eval_end - eval_start))
     
+    # Read captured output for parsing
+    eval_output=$(<"$eval_output_file")
+    
     # Extract performance score - support multiple formats
     # Try to parse the output and extract score
     local score_and_json=$("$PYTHON_CMD" -c "
@@ -224,10 +228,18 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     else
       echo "[WORKER-$$] ERROR: No score found in evaluation output" >&2
       echo "[WORKER-$$] Output: $eval_output" >&2
+      rm -f "$eval_output_file"
       return 1
     fi
+    
+    # Clean up temp file
+    rm -f "$eval_output_file"
   else
     local exit_code=$?
+    # Read any output that was captured before failure
+    eval_output=$(<"$eval_output_file")
+    rm -f "$eval_output_file"
+    
     echo "[WORKER-$$] ERROR: Evaluation failed with exit code $exit_code" >&2
     echo "[WORKER-$$] Output: $eval_output" >&2
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-evolve",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "bin": {
     "claude-evolve": "./bin/claude-evolve",
     "claude-evolve-main": "./bin/claude-evolve-main",