claude-evolve 1.3.26 → 1.3.28

package/README.md

@@ -203,6 +203,46 @@ your-project/
 └── (your main project files)
 ```
 
+## Evaluator Output Format
+
+Your evaluator must output a performance score to stdout. Three formats are supported:
+
+### 1. Plain Number (Simplest)
+Just output a single floating-point number:
+```
+1.077506371224117
+```
+
+### 2. JSON with "score" field
+```json
+{"score": 0.95}
+```
+
+### 3. JSON with "performance" field
+```json
+{"performance": 1.234}
+```
+
+### 4. JSON with additional metrics (Advanced)
+You can include additional metrics that will be automatically added as new columns to the CSV:
+```json
+{
+  "score": 0.95,
+  "sharpe_ratio": 1.23,
+  "max_drawdown": -0.15,
+  "total_return": 0.42,
+  "win_rate": 0.65
+}
+```
+
+**Important notes:**
+- Higher scores indicate better performance
+- A score of 0 indicates complete failure
+- Non-zero exit codes indicate evaluation errors
+- Any additional output (warnings, logs) should go to stderr, not stdout
+- Additional JSON fields will be automatically added as new CSV columns
+- New columns are added after the standard columns (id, basedOnId, description, performance, status)
+
 ## Environment Variables for Evaluators
 
 When your evaluator.py runs, it has access to the `EXPERIMENT_ID` environment variable containing the current experiment's ID (e.g., `gen07-001`). This allows evaluators to:
@@ -221,7 +261,10 @@ experiment_id = os.environ.get('EXPERIMENT_ID', 'unknown')
 
 # Use it for logging or file naming
 output_file = f"results_{experiment_id}.json"
-print(f"Evaluating experiment: {experiment_id}")
+print(f"Evaluating experiment: {experiment_id}", file=sys.stderr)  # Use stderr for logs!
+
+# Output just the score
+print(score)  # Simple number to stdout
 ```
 
 ## Configuration

package/bin/claude-evolve-ideate

@@ -78,7 +78,6 @@ call_claude_with_limit_check() {
 
 # Parse arguments
 use_strategies=true
-no_ai=false
 
 while [[ $# -gt 0 ]]; do
   case $1 in
@@ -87,11 +86,10 @@ while [[ $# -gt 0 ]]; do
 claude-evolve ideate - Generate new algorithm ideas using evolutionary strategies
 
 USAGE:
-  claude-evolve ideate [--legacy N] [--no-ai]
+  claude-evolve ideate [--legacy N]
 
 OPTIONS:
   --legacy N  Use legacy mode with N ideas (ignores strategy config)
-  --no-ai     Use manual entry mode instead of AI generation
   --help      Show this help message
 
 DESCRIPTION:
@@ -116,10 +114,6 @@ EOF
       exit 1
     fi
     ;;
-  --no-ai)
-    no_ai=true
-    shift
-    ;;
   *)
     echo "[ERROR] Unknown option: $1" >&2
     exit 1
@@ -195,21 +189,6 @@ get_next_id() {
   printf "gen%s-%03d" "$generation" $((max_id + 1))
 }
 
-# Add idea to CSV manually (fallback for manual mode)
-add_idea_manual() {
-  local description="$1"
-  local based_on_id="$2"
-  local generation="$3"
-  local id
-  id=$(get_next_id "$generation")
-
-  # Escape quotes in description
-  local escaped_desc="${description//\"/\"\"}"
-
-  # Append to CSV
-  echo "${id},${based_on_id},\"${escaped_desc}\",," >>"$FULL_CSV_PATH"
-  echo "[INFO] Added idea: $description"
-}
 
 # Get top performers for parent selection
 get_top_performers() {
@@ -246,47 +225,12 @@ with open('$FULL_CSV_PATH', 'r') as f:
 "
 }
 
-# Manual entry mode
-ideate_manual() {
-  local ideas_added=0
-
-  for ((i = 1; i <= TOTAL_IDEAS; i++)); do
-    if [[ $TOTAL_IDEAS -eq 1 ]]; then
-      read -r -p "Enter algorithm idea (or empty to skip): " description
-    else
-      read -r -p "Enter algorithm idea $i/$TOTAL_IDEAS (or empty to skip): " description
-    fi
-
-    if [[ -z $description ]]; then
-      echo "[INFO] Empty description, skipping idea"
-      continue
-    fi
-
-    add_idea_manual "$description" "" "$CURRENT_GENERATION"
-    ((ideas_added++))
-
-    if [[ $i -lt $TOTAL_IDEAS ]]; then
-      read -r -p "Add another idea? (y/N) " continue_adding
-      if [[ $continue_adding != "y" && $continue_adding != "Y" ]]; then
-        break
-      fi
-    fi
-  done
-
-  echo "[INFO] Added $ideas_added idea(s) to $EVOLUTION_CSV"
-}
 
 # Generate ideas using AI with multi-strategy approach
 ideate_ai_strategies() {
-  # Check for AI CLI (codex or claude)
-  if ! command -v codex >/dev/null 2>&1 && ! command -v claude >/dev/null 2>&1; then
-    echo "[WARN] No AI CLI found (codex or claude). Falling back to manual entry."
-    return 1
-  fi
-
   if [[ ! -f "$FULL_BRIEF_PATH" ]]; then
-    echo "[WARN] $BRIEF_FILE not found. Falling back to manual entry."
-    return 1
+    echo "[ERROR] $BRIEF_FILE not found. Run 'claude-evolve setup' first." >&2
+    exit 1
   fi
 
   # Get top performers
@@ -531,6 +475,16 @@ Requirements for new CSV rows:
 - Each description should be one clear sentence combining elements from different algorithms
 - Be specific about what elements to merge
 - All new rows should have empty performance and status fields
+
+CRITICAL CSV FORMAT RULES:
+- DO NOT modify the CSV header row
+- DO NOT change the column order
+- DO NOT add extra columns or fields
+- DO NOT modify existing rows - only append new ones
+- DO NOT add extra blank lines or formatting
+- Maintain exact CSV format: id,basedOnId,description,performance,status
+- Leave performance and status fields completely empty (just commas)
+- Use proper CSV quoting only when descriptions contain commas
 - CRITICAL: You must read the relevant algorithm files to:
   * Identify the specific improvements that made each algorithm successful
   * Understand which components are compatible for merging
@@ -553,15 +507,9 @@ Add exactly $count hybrid combination rows to the CSV file now."
 
 # Legacy AI generation mode (for backward compatibility)
 ideate_ai_legacy() {
-  # Check for AI CLI (codex or claude)
-  if ! command -v codex >/dev/null 2>&1 && ! command -v claude >/dev/null 2>&1; then
-    echo "[WARN] No AI CLI found (codex or claude). Falling back to manual entry."
-    return 1
-  fi
-
   if [[ ! -f "$FULL_BRIEF_PATH" ]]; then
-    echo "[WARN] $BRIEF_FILE not found. Falling back to manual entry."
-    return 1
+    echo "[ERROR] $BRIEF_FILE not found. Run 'claude-evolve setup' first." >&2
+    exit 1
   fi
 
   # Get top performers (pure shell)
@@ -606,6 +554,16 @@ Requirements for new CSV rows:
 - Each description should be one clear sentence describing an algorithmic approach
 - All new rows should have empty performance and status fields
 
+CRITICAL CSV FORMAT RULES:
+- DO NOT modify the CSV header row
+- DO NOT change the column order
+- DO NOT add extra columns or fields
+- DO NOT modify existing rows - only append new ones
+- DO NOT add extra blank lines or formatting
+- Maintain exact CSV format: id,basedOnId,description,performance,status
+- Leave performance and status fields completely empty (just commas)
+- Use proper CSV quoting only when descriptions contain commas
+
 Add exactly $TOTAL_IDEAS algorithm variation rows to the CSV file now."
 
   echo "[INFO] Generating $TOTAL_IDEAS ideas (legacy mode)..."
@@ -621,19 +579,12 @@ CURRENT_GENERATION=$(get_next_generation)
 echo "[INFO] Starting ideation for generation $CURRENT_GENERATION"
 
 # Main execution
-if [[ $no_ai == true ]]; then
-  echo "[INFO] Manual entry mode"
-  ideate_manual
-elif [[ $use_strategies == true ]]; then
+if [[ $use_strategies == true ]]; then
   echo "[INFO] Multi-strategy AI generation mode"
-  if ! ideate_ai_strategies; then
-    echo "[INFO] Falling back to manual entry"
-    ideate_manual
-  fi
+  ideate_ai_strategies
+  echo "[INFO] Ideation complete! Check $EVOLUTION_CSV for new ideas."
 else
   echo "[INFO] Legacy AI generation mode"
-  if ! ideate_ai_legacy; then
-    echo "[INFO] Falling back to manual entry" 
-    ideate_manual
-  fi
+  ideate_ai_legacy
+  echo "[INFO] Ideation complete! Check $EVOLUTION_CSV for new ideas."
 fi

package/bin/claude-evolve-worker

@@ -239,7 +239,49 @@ fi
 
 # Process results
 if [[ $eval_exit_code -eq 0 ]]; then
-  # Extract score
+  # First, check if output is just a plain number
+  if [[ $eval_output =~ ^[[:space:]]*-?[0-9]+\.?[0-9]*[[:space:]]*$ ]]; then
+    score=$(echo "$eval_output" | tr -d ' ')
+    if (( $(echo "$score == 0" | bc -l) )); then
+      update_csv_row_with_lock "$candidate_id" "status" "failed"
+      update_csv_row_with_lock "$candidate_id" "performance" "$score"
+      echo "[WORKER-$$] ✗ Evaluation failed with score 0"
+      exit 1
+    else
+      update_csv_row_with_lock "$candidate_id" "performance" "$score"
+      update_csv_row_with_lock "$candidate_id" "status" "complete"
+      echo "[WORKER-$$] ✓ Evaluation complete, score: $score"
+      exit 0
+    fi
+  fi
+  
+  # Try to parse as JSON and extract all fields
+  if echo "$eval_output" | jq . >/dev/null 2>&1; then
+    # Valid JSON - use CSV helper to update with all fields
+    if ! acquire_csv_lock; then
+      echo "[ERROR] Failed to acquire CSV lock" >&2
+      exit 1
+    fi
+    
+    score=$("$PYTHON_CMD" "$SCRIPT_DIR/../lib/csv_helper.py" update_with_json "$FULL_CSV_PATH" "$candidate_id" "$eval_output")
+    release_csv_lock
+    
+    if [[ -n $score ]] && [[ $score != "0" ]]; then
+      echo "[WORKER-$$] ✓ Evaluation complete, score: $score"
+      # Extract and display additional fields if present
+      if additional_fields=$(echo "$eval_output" | jq -r 'to_entries | map(select(.key != "score" and .key != "performance")) | map("\(.key): \(.value)") | join(", ")' 2>/dev/null); then
+        if [[ -n $additional_fields ]]; then
+          echo "[WORKER-$$]   Additional metrics: $additional_fields"
+        fi
+      fi
+      exit 0
+    else
+      echo "[WORKER-$$] ✗ Evaluation failed with score 0"
+      exit 1
+    fi
+  fi
+  
+  # Fallback: Try simple grep for score/performance fields
   if score=$(echo "$eval_output" | grep -o '"score"[[:space:]]*:[[:space:]]*[0-9.]*' | cut -d: -f2 | tr -d ' '); then
     if [[ -n $score ]]; then
       if (( $(echo "$score == 0" | bc -l) )); then
@@ -274,6 +316,7 @@ if [[ $eval_exit_code -eq 0 ]]; then
   fi
   
   echo "[ERROR] No score found in evaluator output" >&2
+  echo "[ERROR] Expected: plain number (e.g., 1.23) or JSON with 'score' or 'performance' field" >&2
   update_csv_row_with_lock "$candidate_id" "status" "failed"
   exit 1
 else

package/lib/csv_helper.py

@@ -1,120 +1,159 @@
 #!/usr/bin/env python3
 """
-CSV helper for claude-evolve to properly handle CSV parsing with quoted fields.
+CSV helper for dynamic column management in claude-evolve.
+Handles adding new columns and updating rows with arbitrary fields.
 """
+
 import csv
-import sys
 import json
+import sys
+import os
+from typing import Dict, List, Any
 
-def find_pending_row(csv_path):
-    """Find the first pending row in the CSV."""
-    with open(csv_path, 'r') as f:
-        reader = csv.reader(f)
-        next(reader)  # Skip header
-        for row_num, row in enumerate(reader, start=2):
-            # If row has fewer than 5 fields, it's pending
-            if len(row) < 5:
-                return row_num
-            
-            # Ensure row has at least 5 fields for status check
-            while len(row) < 5:
-                row.append('')
-            
-            status = row[4].strip()
-            # Check if status is pending or empty
-            if status == 'pending' or status == '':
-                return row_num
-    return None
-
-def get_row_data(csv_path, row_num):
-    """Get data from a specific row."""
-    with open(csv_path, 'r') as f:
-        reader = csv.reader(f)
-        for i, row in enumerate(reader, start=1):
-            if i == row_num:
-                # Ensure row has at least 5 fields
-                while len(row) < 5:
-                    row.append('')
-                return {
-                    'id': row[0],
-                    'basedOnId': row[1],
-                    'description': row[2],
-                    'performance': row[3],
-                    'status': row[4]
-                }
-    return None
 
-def update_row(csv_path, row_num, performance, status):
-    """Update a specific row in the CSV."""
-    rows = []
-    with open(csv_path, 'r') as f:
+def read_csv(filepath: str) -> tuple[list[str], list[list[str]]]:
+    """Read CSV and return headers and rows."""
+    with open(filepath, 'r') as f:
         reader = csv.reader(f)
+        headers = next(reader, [])
         rows = list(reader)
+    return headers, rows
+
+
+def write_csv(filepath: str, headers: list[str], rows: list[list[str]]):
+    """Write CSV with headers and rows."""
+    with open(filepath, 'w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(headers)
+        writer.writerows(rows)
+
+
+def ensure_columns(headers: list[str], rows: list[list[str]], new_fields: dict) -> tuple[list[str], list[list[str]]]:
+    """Add new columns if they don't exist and ensure all rows have correct length."""
+    # Find which fields need to be added as new columns
+    existing_columns = set(headers)
+    new_columns = []
+    
+    for field in new_fields:
+        if field not in existing_columns and field not in ['id', 'basedOnId', 'description', 'performance', 'status']:
+            new_columns.append(field)
     
-    # Update the specific row
-    if row_num <= len(rows):
-        row = rows[row_num - 1]
-        # Ensure row has at least 5 fields
-        while len(row) < 5:
+    # Add new columns to headers (after status column)
+    if new_columns:
+        headers = headers + new_columns
+    
+    # Ensure all rows have the correct number of columns
+    for row in rows:
+        while len(row) < len(headers):
             row.append('')
-        row[3] = performance  # performance field
-        row[4] = status       # status field
     
-    # Write back
-    with open(csv_path, 'w', newline='') as f:
-        writer = csv.writer(f)
-        writer.writerows(rows)
+    return headers, rows
 
-if __name__ == '__main__':
+
+def update_row_with_fields(headers: list[str], rows: list[list[str]], target_id: str, fields: dict):
+    """Update a specific row with multiple fields."""
+    # Find column indices
+    col_indices = {header: i for i, header in enumerate(headers)}
+    
+    # Find and update the target row
+    for row in rows:
+        if row[0] == target_id:
+            for field, value in fields.items():
+                if field in col_indices:
+                    row[col_indices[field]] = str(value)
+            break
+
+
+def main():
+    """Main entry point for CSV operations."""
     if len(sys.argv) < 3:
-        print("Usage: csv_helper.py <command> <csv_path> [args...]", file=sys.stderr)
+        print("Usage: csv_helper.py <operation> <args...>", file=sys.stderr)
         sys.exit(1)
     
-    command = sys.argv[1]
-    csv_path = sys.argv[2]
+    operation = sys.argv[1]
     
-    try:
-        if command == 'find_pending':
-            row_num = find_pending_row(csv_path)
-            if row_num:
-                print(row_num)
-                sys.exit(0)
-            else:
-                sys.exit(1)
-        
-        elif command == 'get_row':
-            if len(sys.argv) < 4:
-                print("Usage: csv_helper.py get_row <csv_path> <row_num>", file=sys.stderr)
-                sys.exit(1)
-            row_num = int(sys.argv[3])
-            data = get_row_data(csv_path, row_num)
-            if data:
-                # Output as shell variable assignments
-                for key, value in data.items():
-                    # Escape special characters for shell
-                    value = value.replace('\\', '\\\\')
-                    value = value.replace('"', '\\"')
-                    value = value.replace('$', '\\$')
-                    value = value.replace('`', '\\`')
-                    print(f'{key}="{value}"')
-                sys.exit(0)
-            else:
-                sys.exit(1)
+    if operation == "update_with_json":
+        # Args: csv_file, target_id, json_output
+        if len(sys.argv) != 5:
+            print("Usage: csv_helper.py update_with_json <csv_file> <target_id> <json_output>", file=sys.stderr)
+            sys.exit(1)
         
-        elif command == 'update_row':
-            if len(sys.argv) < 6:
-                print("Usage: csv_helper.py update_row <csv_path> <row_num> <performance> <status>", file=sys.stderr)
-                sys.exit(1)
-            row_num = int(sys.argv[3])
-            performance = sys.argv[4]
-            status = sys.argv[5]
-            update_row(csv_path, row_num, performance, status)
-            sys.exit(0)
+        csv_file = sys.argv[2]
+        target_id = sys.argv[3]
+        json_output = sys.argv[4]
         
-        else:
-            print(f"Unknown command: {command}", file=sys.stderr)
+        try:
+            # Parse JSON output
+            data = json.loads(json_output)
+            
+            # Extract performance/score
+            performance = data.get('performance') or data.get('score', 0)
+            
+            # Build fields to update
+            fields = {'performance': performance, 'status': 'complete' if performance > 0 else 'failed'}
+            
+            # Add all other fields from the JSON
+            for key, value in data.items():
+                if key not in ['performance', 'score', 'status']:
+                    fields[key] = value
+            
+            # Read CSV
+            headers, rows = read_csv(csv_file)
+            
+            # Ensure columns exist for all fields
+            headers, rows = ensure_columns(headers, rows, fields)
+            
+            # Update the row
+            update_row_with_fields(headers, rows, target_id, fields)
+            
+            # Write back
+            write_csv(csv_file + '.tmp', headers, rows)
+            os.rename(csv_file + '.tmp', csv_file)
+            
+            # Return the performance score
+            print(performance)
+            
+        except json.JSONDecodeError:
+            print("0")  # Invalid JSON means failed
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            print("0")
             sys.exit(1)
+    
+    elif operation == "update_field":
+        # Args: csv_file, target_id, field, value
+        if len(sys.argv) != 6:
+            print("Usage: csv_helper.py update_field <csv_file> <target_id> <field> <value>", file=sys.stderr)
+            sys.exit(1)
+        
+        csv_file = sys.argv[2]
+        target_id = sys.argv[3]
+        field = sys.argv[4]
+        value = sys.argv[5]
+        
+        try:
+            # Read CSV
+            headers, rows = read_csv(csv_file)
+            
+            # Ensure column exists
+            headers, rows = ensure_columns(headers, rows, {field: value})
+            
+            # Update the row
+            update_row_with_fields(headers, rows, target_id, {field: value})
+            
+            # Write back
+            write_csv(csv_file + '.tmp', headers, rows)
+            os.rename(csv_file + '.tmp', csv_file)
             
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    else:
+        print(f"Unknown operation: {operation}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

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

package/templates/evaluator.py

@@ -40,11 +40,10 @@ def evaluate_performance(algorithm_module):
     end_time = time.time()
     execution_time = end_time - start_time
     
-    return {
-        "execution_time": execution_time,
-        "score": 1.0 / execution_time if execution_time > 0 else 0,
-        "status": "success"
-    }
+    # Calculate a performance score (higher is better)
+    score = 1.0 / execution_time if execution_time > 0 else 0
+    
+    return score  # Simple: just return the number
 
 
 def main():
@@ -60,15 +59,18 @@ def main():
     
     try:
         algorithm_module = load_algorithm(algorithm_file)
-        metrics = evaluate_performance(algorithm_module)
-        print(json.dumps(metrics))
+        score = evaluate_performance(algorithm_module)
+        
+        # Option 1: Just print the number (simplest)
+        print(score)
+        
+        # Option 2: Print as JSON (if you need more structure)
+        # print(json.dumps({"score": score}))
+        
         sys.exit(0)
     except Exception as e:
-        error_result = {
-            "error": str(e),
-            "status": "failed"
-        }
-        print(json.dumps(error_result))
+        # Log errors to stderr, not stdout
+        print(f"Error: {e}", file=sys.stderr)
         sys.exit(1)