claude-evolve 1.4.12 → 1.4.13

package/bin/claude-evolve-autostatus

@@ -105,54 +105,79 @@ class AutoStatus:
         
     def get_status_data(self):
         """Get current status data from CSV."""
-        # Read CSV data directly
+        # Read CSV data directly - using list reader to handle position-based access
         with open(self.csv_path, "r") as f:
-            reader = csv.DictReader(f)
+            reader = csv.reader(f)
             rows = list(reader)
         
-        # Count by status
-        status_counts = {
-            "pending": 0,
-            "running": 0,
-            "complete": 0,
-            "failed": 0,
-            "total": len(rows)
-        }
+        if len(rows) <= 1:
+            return {
+                "leader": None,
+                "generations": {},
+                "csv_path": self.csv_path,
+                "working_dir": os.path.dirname(self.csv_path)
+            }
         
-        # Collect performance values and recent candidates
-        perf_values = []
-        for row in rows:
-            status = row.get("status", "unknown")
-            if status in status_counts:
-                status_counts[status] += 1
-            
-            # Collect performance for completed
-            if status == "complete" and "performance" in row and row["performance"]:
-                try:
-                    perf_values.append(float(row["performance"]))
-                except ValueError:
-                    pass
+        # Process candidates by generation
+        all_candidates = []
+        stats_by_gen = {}
         
-        # Calculate performance stats
-        if perf_values:
-            perf_stats = {
-                "min": min(perf_values),
-                "max": max(perf_values),
-                "mean": sum(perf_values) / len(perf_values),
-                "count": len(perf_values)
-            }
-        else:
-            perf_stats = None
+        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])
         
-        # Get recent candidates (last N that fit on screen)
-        max_candidates = max(1, self.display.rows - 15)  # Reserve space for header/stats
-        recent = rows[-max_candidates:] if rows else []
+        # 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 {
-            "counts": status_counts,
-            "performance": perf_stats,
-            "recent": recent,
-            "csv_path": self.csv_path
+            "leader": leader,
+            "generations": stats_by_gen,
+            "csv_path": self.csv_path,
+            "working_dir": os.path.dirname(self.csv_path)
         }
     
     def format_duration(self, seconds):
@@ -186,97 +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")
+        working_dir = os.path.basename(data["working_dir"])
+        print(f"Last updated: {timestamp} | Working dir: {working_dir} | 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")
-        
+        # Leader
         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 data["recent"]:
-            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"]:
-                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 and candidate["performance"]:
-                    try:
-                        perf = f"{float(candidate['\''performance'\'']):.4f}"
-                    except ValueError:
-                        perf = "-"
+                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
         

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"