claude-evolve 1.4.10 → 1.4.12

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,18 +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__))
-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."""
     
@@ -33,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
@@ -44,90 +71,89 @@ 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
+        with open(self.csv_path, "r") as f:
+            reader = csv.DictReader(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)
+        # Count by status
+        status_counts = {
+            "pending": 0,
+            "running": 0,
+            "complete": 0,
+            "failed": 0,
+            "total": len(rows)
+        }
+        
+        # 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
             
-            return {
-                'counts': status_counts,
-                'performance': perf_stats,
-                'recent': recent,
-                'csv_path': csv_path
+            # Collect performance for completed
+            if status == "complete" and "performance" in row and row["performance"]:
+                try:
+                    perf_values.append(float(row["performance"]))
+                except ValueError:
+                    pass
+        
+        # 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
+        
+        # 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 []
+        
+        return {
+            "counts": status_counts,
+            "performance": perf_stats,
+            "recent": recent,
+            "csv_path": self.csv_path
+        }
     
     def format_duration(self, seconds):
         """Format duration in human-readable form."""
@@ -163,12 +189,12 @@ class AutoStatus:
         # 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")
+        print(f"Updated: {timestamp} | Press '\''q'\'' to quit")
         row += 2
         
         # File info
         self.display.move_cursor(row, 1)
-        print(f"CSV: {data['csv_path']}")
+        print(f"CSV: {data['\''csv_path'\'']}")
         row += 2
         
         # Status summary
@@ -176,38 +202,38 @@ class AutoStatus:
         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")
+        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']:
+        if data["performance"]:
             self.display.move_cursor(row, 1)
             print("\033[1mPerformance Stats:\033[0m")
             row += 1
             
-            perf = data['performance']
+            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']}")
+            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:
+        if data["recent"]:
             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'}"
+            header_fmt = f"{"ID":>8} | {"Status":^10} | {"Performance":>11} | {"Description"}"
             print(header_fmt[:self.display.cols])
             row += 1
             
@@ -216,38 +242,41 @@ class AutoStatus:
             row += 1
             
             # Table rows
-            for _, candidate in data['recent'].iterrows():
+            for candidate in data["recent"]:
                 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
+                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
+                    color = "\033[0m"   # Default
                 
                 # Format performance
-                if status == 'complete' and 'performance' in candidate:
-                    perf = f"{candidate['performance']:.4f}"
+                if status == "complete" and "performance" in candidate and candidate["performance"]:
+                    try:
+                        perf = f"{float(candidate['\''performance'\'']):.4f}"
+                    except ValueError:
+                        perf = "-"
                 else:
                     perf = "-"
                 
                 # Truncate description to fit
-                desc = candidate.get('description', '')
+                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}"
+                line = f"{candidate['\''id'\'']:>8} | {color}{status:^10}\033[0m | {perf:>11} | {desc}"
                 print(line[:self.display.cols])
                 row += 1
         
@@ -259,7 +288,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
@@ -270,13 +299,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
@@ -285,7 +322,7 @@ class AutoStatus:
                     time.sleep(0.1)
         
         except KeyboardInterrupt:
-            pass
+            self.running = False
         
         finally:
             # Restore terminal settings
@@ -296,23 +333,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/lib/config.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Configuration loader for claude-evolve Python scripts."""
+
+import os
+import yaml
+from pathlib import Path
+
+
+class Config:
+    """Configuration manager that matches the bash config.sh functionality."""
+    
+    # Default values matching config.sh
+    DEFAULTS = {
+        'evolution_dir': 'evolution',
+        'algorithm_file': 'algorithm.py',
+        'evaluator_file': 'evaluator.py',
+        'brief_file': 'BRIEF.md',
+        'csv_file': 'evolution.csv',
+        'output_dir': '',
+        'parent_selection': 'best',
+        'python_cmd': 'python3',
+        'ideation': {
+            'total_ideas': 15,
+            'novel_exploration': 3,
+            'hill_climbing': 5,
+            'structural_mutation': 3,
+            'crossover_hybrid': 4,
+            'num_elites': 3,
+            'num_revolution': 2
+        },
+        'parallel': {
+            'enabled': False,
+            'max_workers': 4,
+            'lock_timeout': 10
+        },
+        'auto_ideate': True,
+        'max_retries': 3
+    }
+    
+    def __init__(self):
+        self.data = self.DEFAULTS.copy()
+        self.config_path = None
+        self.working_dir = None
+    
+    def load(self, config_path=None, working_dir=None):
+        """Load configuration from YAML file."""
+        # Determine config file path
+        if config_path:
+            # Explicit config path provided
+            self.config_path = Path(config_path)
+        elif working_dir:
+            # Look for config.yaml in working directory
+            self.working_dir = Path(working_dir)
+            self.config_path = self.working_dir / 'config.yaml'
+        else:
+            # Default to evolution/config.yaml
+            self.config_path = Path('evolution/config.yaml')
+        
+        # Load config if it exists
+        if self.config_path.exists():
+            with open(self.config_path, 'r') as f:
+                yaml_data = yaml.safe_load(f) or {}
+                
+                # Merge with defaults
+                self.data.update(yaml_data)
+                
+                # Handle nested structures
+                if 'ideation' in yaml_data:
+                    self.data['ideation'] = {**self.DEFAULTS['ideation'], **yaml_data['ideation']}
+                if 'parallel' in yaml_data:
+                    self.data['parallel'] = {**self.DEFAULTS['parallel'], **yaml_data['parallel']}
+    
+    def resolve_path(self, relative_path):
+        """Resolve a path relative to the config directory."""
+        if not relative_path:
+            return None
+            
+        # If config_path is set, use its parent directory
+        if self.config_path:
+            base_dir = self.config_path.parent
+        elif self.working_dir:
+            base_dir = self.working_dir
+        else:
+            base_dir = Path.cwd()
+        
+        # Handle output_dir special case
+        if relative_path == self.data.get('output_dir', '') and not relative_path:
+            # Empty output_dir means use evolution_dir
+            relative_path = self.data.get('evolution_dir', 'evolution')
+        
+        resolved = base_dir / relative_path
+        return str(resolved.resolve())

package/package.json

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