claude-evolve 1.4.11 → 1.4.13

package/bin/claude-evolve-autostatus

@@ -1,9 +1,45 @@
-#!/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.
-"""
+#!/bin/bash
+set -e
 
+# Source configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &> /dev/null && pwd)"
+source "$SCRIPT_DIR/../lib/config.sh"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --working-dir)
+      if [[ -n ${2:-} ]]; then
+        export CLAUDE_EVOLVE_CONFIG="$2/config.yaml"
+        shift 2
+      else
+        echo "[ERROR] --working-dir requires a directory path" >&2
+        exit 1
+      fi
+      ;;
+    -h|--help)
+      echo "Usage: claude-evolve-autostatus [--working-dir DIR]"
+      echo ""
+      echo "Auto-updating status display that fits to terminal size."
+      echo "Press 'q' to quit while running."
+      exit 0
+      ;;
+    *)
+      echo "[ERROR] Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Load config using the same logic as other commands
+if [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
+  load_config "$CLAUDE_EVOLVE_CONFIG"
+else
+  load_config
+fi
+
+# Run the Python autostatus script
+exec "$PYTHON_CMD" -c '
 import os
 import sys
 import time
@@ -11,32 +47,9 @@ import termios
 import tty
 import select
 import signal
-import argparse
-import subprocess
+import csv
 from datetime import datetime
 
-# Add parent directory to path for imports
-script_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.join(script_dir, '..')
-
-# Try multiple paths to support both development and installed environments
-for path in [parent_dir, os.path.join(parent_dir, 'lib'), script_dir]:
-    if path not in sys.path:
-        sys.path.insert(0, path)
-
-try:
-    from lib.config import Config
-    from lib.evolution_csv import EvolutionCSV
-except ImportError:
-    # Fallback for installed version where lib might be in a different location
-    try:
-        from config import Config
-        from evolution_csv import EvolutionCSV
-    except ImportError:
-        print("Error: Could not import required modules. Please check installation.", file=sys.stderr)
-        sys.exit(1)
-
-
 class TerminalDisplay:
     """Handles terminal display with ANSI escape sequences for flicker-free updates."""
     
@@ -47,7 +60,7 @@ class TerminalDisplay:
     def get_terminal_size(self):
         """Get current terminal size."""
         try:
-            rows, cols = os.popen('stty size', 'r').read().split()
+            rows, cols = os.popen("stty size", "r").read().split()
             return int(rows), int(cols)
         except:
             return 24, 80  # Default fallback
@@ -58,90 +71,114 @@ class TerminalDisplay:
     
     def clear_screen(self):
         """Clear the entire screen."""
-        print('\033[2J\033[H', end='')
+        print("\033[2J\033[H", end="")
     
     def move_cursor(self, row, col):
         """Move cursor to specific position."""
-        print(f'\033[{row};{col}H', end='')
+        print(f"\033[{row};{col}H", end="")
     
     def clear_line(self):
         """Clear current line."""
-        print('\033[2K', end='')
+        print("\033[2K", end="")
     
     def hide_cursor(self):
         """Hide the cursor."""
-        print('\033[?25l', end='')
+        print("\033[?25l", end="")
     
     def show_cursor(self):
         """Show the cursor."""
-        print('\033[?25h', end='')
+        print("\033[?25h", end="")
     
     def reset(self):
         """Reset terminal to normal state."""
         self.show_cursor()
-        print('\033[0m', end='')  # Reset colors
+        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)
-        
+    def __init__(self, csv_path):
+        self.csv_path = csv_path
         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'])
+        # Read CSV data directly - using list reader to handle position-based access
+        with open(self.csv_path, "r") as f:
+            reader = csv.reader(f)
+            rows = list(reader)
         
-        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)
-            
+        if len(rows) <= 1:
             return {
-                'counts': status_counts,
-                'performance': perf_stats,
-                'recent': recent,
-                'csv_path': csv_path
+                "leader": None,
+                "generations": {},
+                "csv_path": self.csv_path,
+                "working_dir": os.path.dirname(self.csv_path)
             }
+        
+        # Process candidates by generation
+        all_candidates = []
+        stats_by_gen = {}
+        
+        for row in rows[1:]:  # Skip header
+            if len(row) >= 1 and row[0]:  # Must have an ID
+                candidate_id = row[0]
+                
+                # Extract generation (e.g., "gen03" from "gen03-001")
+                if "-" in candidate_id:
+                    gen = candidate_id.split("-")[0]
+                    
+                    # Get status and performance
+                    status = row[4] if len(row) > 4 and row[4] else "pending"
+                    performance = row[3] if len(row) > 3 and row[3] else ""
+                    
+                    # Normalize failed-retry* to failed
+                    if status.startswith("failed"):
+                        status = "failed"
+                    
+                    # Track by generation
+                    if gen not in stats_by_gen:
+                        stats_by_gen[gen] = {
+                            "pending": 0, "complete": 0, "failed": 0, "running": 0,
+                            "candidates": []
+                        }
+                    
+                    if status in stats_by_gen[gen]:
+                        stats_by_gen[gen][status] += 1
+                    else:
+                        stats_by_gen[gen]["pending"] += 1
+                    
+                    # Collect candidate info
+                    if status == "complete" and performance:
+                        try:
+                            score = float(performance)
+                            description = row[2] if len(row) > 2 else "No description"
+                            candidate_info = (candidate_id, description, score)
+                            stats_by_gen[gen]["candidates"].append(candidate_info)
+                            all_candidates.append(candidate_info)
+                        except ValueError:
+                            pass
+        
+        # Find the overall leader
+        leader = None
+        if all_candidates:
+            leader = max(all_candidates, key=lambda x: x[2])
+        
+        # Find best performer in each generation
+        for gen in stats_by_gen:
+            if stats_by_gen[gen]["candidates"]:
+                stats_by_gen[gen]["best"] = max(stats_by_gen[gen]["candidates"], key=lambda x: x[2])
+            else:
+                stats_by_gen[gen]["best"] = None
+        
+        return {
+            "leader": leader,
+            "generations": stats_by_gen,
+            "csv_path": self.csv_path,
+            "working_dir": os.path.dirname(self.csv_path)
+        }
     
     def format_duration(self, seconds):
         """Format duration in human-readable form."""
@@ -174,94 +211,79 @@ class AutoStatus:
         print(f"\033[1;36m{header.center(self.display.cols)}\033[0m")
         row += 1
         
-        # Timestamp
+        # Timestamp and working dir
         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']}")
+        working_dir = os.path.basename(data["working_dir"])
+        print(f"Last updated: {timestamp} | Working dir: {working_dir} | Press '\''q'\'' to quit")
         row += 2
         
-        # Status summary
+        # Leader
         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)
+        if data["leader"]:
+            leader_id, leader_desc, leader_score = data["leader"]
+            # Truncate description for leader
+            max_desc_len = self.display.cols - 30
+            if len(leader_desc) > max_desc_len:
+                leader_desc = leader_desc[:max_desc_len-3] + "..."
+            print(f"\033[1;32mLeader:\033[0m {leader_id} | {leader_score:.4f} | {leader_desc}")
+        else:
+            print("\033[1;32mLeader:\033[0m None (no completed candidates)")
         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
-            
+        # Generation table
+        generations = data["generations"]
+        if generations:
             # Table header
             self.display.move_cursor(row, 1)
-            header_fmt = f"{'ID':>8} | {'Status':^10} | {'Performance':>11} | {'Description'}"
-            print(header_fmt[:self.display.cols])
+            header_fmt = "{:<10} | {:^20} | {:>10} | {:>8} | {}".format(
+                "Generation", "Stats (p/c/f/r)", "Top ID", "Score", "Description"
+            )
+            print("\033[1m" + header_fmt[:self.display.cols] + "\033[0m")
             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
+            # Sort generations
+            sorted_gens = sorted(generations.keys())
+            
+            # Calculate how many generations we can show
+            available_rows = self.display.rows - row - 1  # Leave room at bottom
+            start_idx = max(0, len(sorted_gens) - available_rows)
+            
+            # Show generations (most recent at bottom)
+            for gen in sorted_gens[start_idx:]:
+                if row >= self.display.rows - 1:
                     break
                 
-                self.display.move_cursor(row, 1)
+                gen_data = generations[gen]
+                stats_str = f"{gen_data['\''pending'\'']}/{gen_data['\''complete'\'']}/{gen_data['\''failed'\'']}/{gen_data['\''running'\'']}"
                 
-                # 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
+                self.display.move_cursor(row, 1)
                 
-                # Format performance
-                if status == 'complete' and 'performance' in candidate:
-                    perf = f"{candidate['performance']:.4f}"
+                if gen_data["best"]:
+                    best_id, best_desc, best_score = gen_data["best"]
+                    # Truncate description
+                    max_desc_len = self.display.cols - 55
+                    if len(best_desc) > max_desc_len:
+                        best_desc = best_desc[:max_desc_len-3] + "..."
+                    
+                    # Highlight if this is the overall leader
+                    if data["leader"] and best_id == data["leader"][0]:
+                        line = "{:<10} | {:^20} | \033[32m{:>10}\033[0m | {:>8.4f} | {}".format(
+                            gen, stats_str, best_id, best_score, best_desc
+                        )
+                    else:
+                        line = "{:<10} | {:^20} | {:>10} | {:>8.4f} | {}".format(
+                            gen, stats_str, best_id, best_score, best_desc
+                        )
                 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 = "{:<10} | {:^20} | {:>10} | {:>8} | {}".format(
+                        gen, stats_str, "-", "-", "No completed candidates"
+                    )
                 
-                line = f"{candidate['id']:>8} | {color}{status:^10}\033[0m | {perf:>11} | {desc}"
                 print(line[:self.display.cols])
                 row += 1
         
@@ -273,7 +295,7 @@ class AutoStatus:
         """Check for keyboard input without blocking."""
         if select.select([sys.stdin], [], [], 0)[0]:
             char = sys.stdin.read(1)
-            if char.lower() == 'q':
+            if char.lower() == "q":
                 self.running = False
                 return True
         return False
@@ -284,13 +306,21 @@ class AutoStatus:
         old_settings = termios.tcgetattr(sys.stdin)
         
         try:
-            # Set terminal to raw mode for immediate input
-            tty.setraw(sys.stdin.fileno())
+            # Set terminal to cbreak mode (allows Ctrl-C) instead of raw mode
+            tty.setcbreak(sys.stdin.fileno())
             
             self.display.hide_cursor()
             
             while self.running:
-                self.render()
+                try:
+                    self.render()
+                except Exception as e:
+                    # Show error at bottom of screen
+                    self.display.move_cursor(self.display.rows - 1, 1)
+                    self.display.clear_line()
+                    print(f"\033[31mError: {str(e)}\033[0m", end="")
+                    sys.stdout.flush()
+                    time.sleep(2)  # Give time to read error
                 
                 # Check for input and wait
                 for _ in range(10):  # Check 10 times per second
@@ -299,7 +329,7 @@ class AutoStatus:
                     time.sleep(0.1)
         
         except KeyboardInterrupt:
-            pass
+            self.running = False
         
         finally:
             # Restore terminal settings
@@ -310,23 +340,8 @@ class AutoStatus:
             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()
+# Main execution
+csv_path = "'"$FULL_CSV_PATH"'"
+auto_status = AutoStatus(csv_path)
+auto_status.run()
+'

package/bin/claude-evolve-edit

@@ -33,11 +33,12 @@ SELECTORS:
 ACTIONS:
   failed           Mark candidates as failed (keeps scores)
   complete         Mark candidates as complete (keeps scores)  
-  pending          Mark candidates as pending (keeps scores)
+  pending          Mark candidates as pending (clears all data)
   failed-retry1    Mark candidates for retry attempt 1 (bug fixing)
   failed-retry2    Mark candidates for retry attempt 2 (bug fixing)
   failed-retry3    Mark candidates for retry attempt 3 (bug fixing)
   reboot           Reset completely (delete .py files, clear scores, set pending)
+  delete           Delete candidates from CSV and remove .py files (asks confirmation)
 
 EXAMPLES:
   claude-evolve edit gen03 failed        # Mark all gen03 as failed
@@ -46,6 +47,7 @@ EXAMPLES:
   claude-evolve edit complete failed     # Mark all complete as failed for re-run
   claude-evolve edit all pending         # Mark everything as pending for re-run
   claude-evolve edit gen02 reboot        # Full reset of gen02 (delete files + clear data)
+  claude-evolve edit gen02 delete        # Delete gen02 from CSV and remove .py files
 
 DESCRIPTION:
   This command helps manage evolution runs when you need to re-evaluate candidates.
@@ -77,9 +79,9 @@ fi
 
 # Validate action
 case "$ACTION" in
-  failed|complete|pending|failed-retry1|failed-retry2|failed-retry3|reboot) ;;
+  failed|complete|pending|failed-retry1|failed-retry2|failed-retry3|reboot|delete) ;;
   *)
-    echo "[ERROR] Action must be one of: failed, complete, pending, failed-retry1, failed-retry2, failed-retry3, reboot" >&2
+    echo "[ERROR] Action must be one of: failed, complete, pending, failed-retry1, failed-retry2, failed-retry3, reboot, delete" >&2
     exit 1
     ;;
 esac
@@ -152,9 +154,10 @@ try:
         
         if matches:
             if clear_scores:
-                # Reboot: clear everything after description (keep id, basedOnId, description)
+                # Clear everything after description (keep id, basedOnId, description)
                 if len(row) >= 3:
-                    rows[i] = [row[0], row[1], row[2], '', '']  # id, basedOnId, description, empty performance, empty status
+                    # Keep first 3 columns, then add empty performance and the new status
+                    rows[i] = [row[0], row[1], row[2], '', new_status]
                     updated_count += 1
             else:
                 # Just update status (preserve other fields)
@@ -277,6 +280,66 @@ except Exception as e:
   echo "[INFO] Deleted $deleted_count evolution files"
 }
 
+# Function to delete candidates from CSV
+delete_candidates_from_csv() {
+  local selector="$1"
+  
+  echo "[INFO] Deleting candidates matching '$selector' from CSV..."
+  
+  "$PYTHON_CMD" -c "
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+import re
+
+selector = '$selector'
+deleted_count = 0
+
+with EvolutionCSV('$FULL_CSV_PATH') as csv:
+    # Read CSV directly to get all candidates
+    import csv as csv_module
+    candidates_to_delete = []
+    
+    with open('$FULL_CSV_PATH', 'r') as f:
+        reader = csv_module.reader(f)
+        rows = list(reader)
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        start_idx = 1 if has_header else 0
+        
+        for row in rows[start_idx:]:
+            if not row or not row[0].strip():
+                continue
+                
+            candidate_id = row[0].strip()
+            current_status = row[4].strip() if len(row) > 4 else ''
+            
+            matches = False
+            if selector == 'all':
+                matches = True
+            elif selector.startswith('gen') and re.match(r'^gen\\d+$', selector):
+                # Generation selector (e.g., gen01, gen02)
+                gen_pattern = f'^{selector}-'
+                matches = re.match(gen_pattern, candidate_id) is not None
+            elif selector == 'pending':
+                matches = current_status == '' or current_status == 'pending'
+            elif selector == 'failed':
+                matches = current_status.startswith('failed')
+            else:
+                matches = current_status == selector
+            
+            if matches:
+                candidates_to_delete.append(candidate_id)
+    
+    # Delete candidates
+    for candidate_id in candidates_to_delete:
+        csv.delete_candidate(candidate_id)
+        deleted_count += 1
+        print(f'[INFO] Deleted from CSV: {candidate_id}')
+    
+    print(f'[INFO] Deleted {deleted_count} candidates from CSV')
+"
+}
+
 # Main execution
 echo "[INFO] Processing '$SELECTOR' with action: $ACTION"
 
@@ -288,7 +351,7 @@ case "$ACTION" in
     update_candidates_status "$SELECTOR" "complete" "false"
     ;;
   pending)
-    update_candidates_status "$SELECTOR" "" "false"  # Empty status means pending
+    update_candidates_status "$SELECTOR" "pending" "true"  # Clear all data and set to pending
     ;;
   failed-retry1)
     update_candidates_status "$SELECTOR" "failed-retry1" "false"
@@ -305,6 +368,19 @@ case "$ACTION" in
     update_candidates_status "$SELECTOR" "" "true"  # Clear scores and set pending
     echo "[INFO] Reboot complete: files deleted, scores cleared, status set to pending"
     ;;
+  delete)
+    # Ask for confirmation
+    read -p "[WARNING] This will permanently delete candidates matching '$SELECTOR' from CSV and remove their .py files. Are you sure? (yes/no): " confirmation
+    if [[ "$confirmation" != "yes" ]]; then
+      echo "[INFO] Delete operation cancelled"
+      exit 0
+    fi
+    
+    echo "[INFO] Performing delete of '$SELECTOR'..."
+    delete_evolution_files "$SELECTOR"
+    delete_candidates_from_csv "$SELECTOR"
+    echo "[INFO] Delete complete: candidates removed from CSV and files deleted"
+    ;;
 esac
 
 echo "[INFO] Edit operation complete"