claude-evolve 1.8.49 → 1.9.0

package/lib/evolve_worker.py

@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+"""
+Worker process for claude-evolve.
+Processes a single pending candidate: generates code via AI and runs evaluator.
+
+AIDEV-NOTE: This is the Python port of bin/claude-evolve-worker.
+Exit codes:
+  0 - Success
+  1 - General failure
+  2 - Rate limit (should retry later)
+  3 - API exhausted (stop all processing)
+  77 - AI generation failed after retries
+  78 - Missing parent algorithm
+"""
+
+import argparse
+import json
+import os
+import re
+import shutil
+import signal
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+
+# Add lib to path
+SCRIPT_DIR = Path(__file__).parent
+sys.path.insert(0, str(SCRIPT_DIR.parent))
+
+from lib.evolution_csv import EvolutionCSV
+from lib.ai_cli import call_ai, get_git_protection_warning, AIError, RateLimitError, APIExhaustedError, TimeoutError
+
+
+@dataclass
+class Config:
+    """Worker configuration."""
+    csv_path: str
+    evolution_dir: str
+    output_dir: str
+    algorithm_path: str
+    evaluator_path: str
+    brief_path: str
+    python_cmd: str = "python3"
+    memory_limit_mb: int = 0
+    timeout_seconds: int = 600
+    max_ai_retries: int = 3
+    max_candidates: int = 5
+
+
+@dataclass
+class Candidate:
+    """Candidate to process."""
+    id: str
+    based_on_id: str
+    description: str
+
+
+class Worker:
+    """Processes evolution candidates."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.csv = EvolutionCSV(config.csv_path)
+        self.current_candidate_id: Optional[str] = None
+        self._setup_signal_handlers()
+
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful shutdown."""
+        signal.signal(signal.SIGTERM, self._handle_signal)
+        signal.signal(signal.SIGINT, self._handle_signal)
+
+    def _handle_signal(self, signum, frame):
+        """Handle termination signal - reset current candidate to pending."""
+        sig_name = signal.Signals(signum).name
+        print(f"[WORKER-{os.getpid()}] Received {sig_name}", file=sys.stderr)
+
+        if self.current_candidate_id:
+            print(f"[WORKER-{os.getpid()}] Resetting {self.current_candidate_id} to pending", file=sys.stderr)
+            try:
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    info = csv.get_candidate_info(self.current_candidate_id)
+                    status = info.get('status', '').lower() if info else ''
+                    # Don't reset if already complete or permanently failed
+                    if status not in ('complete', 'failed', 'failed-ai-retry', 'failed-parent-missing'):
+                        csv.update_candidate_status(self.current_candidate_id, 'pending')
+            except Exception as e:
+                print(f"[WORKER-{os.getpid()}] Error resetting status: {e}", file=sys.stderr)
+
+        sys.exit(128 + signum)
+
+    def _resolve_parent_id(self, parent_id: str) -> Tuple[Optional[str], Optional[Path]]:
+        """
+        Resolve parent ID to actual file.
+
+        Args:
+            parent_id: Parent ID (may be comma-separated for multi-parent)
+
+        Returns:
+            Tuple of (resolved_parent_id, parent_file_path) or (None, None) if not found
+        """
+        if not parent_id or parent_id == "baseline-000":
+            return None, Path(self.config.algorithm_path)
+
+        # Split by comma or space and try each
+        candidates = re.split(r'[,;\s]+', parent_id)
+        for candidate in candidates:
+            candidate = candidate.strip()
+            if not candidate:
+                continue
+
+            parent_file = Path(self.config.output_dir) / f"evolution_{candidate}.py"
+            if parent_file.exists():
+                return candidate, parent_file
+
+        return None, None  # No valid parent found
+
+    def _is_baseline(self, candidate_id: str, parent_id: str) -> bool:
+        """Check if this is a baseline candidate."""
+        if parent_id:
+            return False
+        return candidate_id in ('baseline', 'baseline-000', '000', '0', 'gen00-000')
+
+    def _build_prompt(self, candidate: Candidate, target_basename: str) -> str:
+        """Build the AI prompt for code evolution."""
+        return f"""{get_git_protection_warning()}
+
+Modify the algorithm in {target_basename} based on this description: {candidate.description}
+
+The modification should be substantial and follow the description exactly. Make sure the algorithm still follows all interface requirements and can run properly.
+
+Important: Make meaningful changes that match the description. Don't just add comments or make trivial adjustments.
+
+IMPORTANT: If you need to read Python (.py) or CSV files, read them in chunks using offset and limit parameters to avoid context overload
+Example: Read(file_path='evolution_gen01-001.py', offset=0, limit=100) then Read(offset=100, limit=100), etc.
+This is especially important for models with smaller context windows (like GLM).
+
+CRITICAL: If you do not know how to implement what was asked for, or if the requested change is unclear or not feasible, you MUST refuse to make any changes. DO NOT modify the code if you are uncertain about the implementation. Simply respond that you cannot implement the requested change and explain why. It is better to refuse than to make incorrect or random changes."""
+
+    def _call_ai_with_retries(self, prompt: str, target_file: Path, source_file: Path) -> Tuple[bool, str]:
+        """
+        Call AI with retries.
+
+        Returns:
+            Tuple of (success, model_name)
+        """
+        for attempt in range(1, self.config.max_ai_retries + 1):
+            print(f"[WORKER-{os.getpid()}] AI attempt {attempt}/{self.config.max_ai_retries}", file=sys.stderr)
+
+            # Re-copy source if this is a retry
+            if attempt > 1:
+                print(f"[WORKER-{os.getpid()}] Re-copying source file for retry", file=sys.stderr)
+                shutil.copy(source_file, target_file)
+
+            # Get file hash before AI call
+            hash_before = self._file_hash(target_file) if target_file.exists() else None
+
+            try:
+                output, model = call_ai(prompt, command="run", working_dir=self.config.evolution_dir)
+
+                # Check if file was modified
+                hash_after = self._file_hash(target_file) if target_file.exists() else None
+
+                if hash_before != hash_after and hash_after is not None:
+                    print(f"[WORKER-{os.getpid()}] AI successfully modified file (model: {model})", file=sys.stderr)
+                    return True, model
+                else:
+                    print(f"[WORKER-{os.getpid()}] AI did not modify file", file=sys.stderr)
+
+            except RateLimitError as e:
+                print(f"[WORKER-{os.getpid()}] Rate limit: {e}", file=sys.stderr)
+                raise  # Propagate to caller
+            except APIExhaustedError as e:
+                print(f"[WORKER-{os.getpid()}] API exhausted: {e}", file=sys.stderr)
+                raise  # Propagate to caller
+            except TimeoutError as e:
+                print(f"[WORKER-{os.getpid()}] Timeout: {e}", file=sys.stderr)
+            except AIError as e:
+                print(f"[WORKER-{os.getpid()}] AI error: {e}", file=sys.stderr)
+
+            if attempt < self.config.max_ai_retries:
+                print(f"[WORKER-{os.getpid()}] Will retry with different model...", file=sys.stderr)
+                time.sleep(2)
+
+        return False, ""
+
+    def _file_hash(self, path: Path) -> Optional[str]:
+        """Get file hash."""
+        try:
+            import hashlib
+            return hashlib.sha256(path.read_bytes()).hexdigest()
+        except Exception:
+            return None
+
+    def _check_syntax(self, file_path: Path) -> bool:
+        """Check Python syntax."""
+        try:
+            result = subprocess.run(
+                [self.config.python_cmd, "-m", "py_compile", str(file_path)],
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def _run_evaluator(self, candidate_id: str, is_baseline: bool) -> Tuple[Optional[float], Dict[str, Any]]:
+        """
+        Run the evaluator.
+
+        Returns:
+            Tuple of (score, extra_data_dict) or (None, {}) on failure
+        """
+        eval_arg = "" if is_baseline else candidate_id
+
+        cmd = [self.config.python_cmd]
+
+        # Add memory wrapper if configured
+        if self.config.memory_limit_mb > 0:
+            wrapper_path = SCRIPT_DIR / "memory_limit_wrapper.py"
+            cmd.extend([str(wrapper_path), str(self.config.memory_limit_mb)])
+
+        cmd.extend([self.config.evaluator_path, eval_arg])
+
+        print(f"[WORKER-{os.getpid()}] Running evaluator: {' '.join(cmd)}", file=sys.stderr)
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=self.config.timeout_seconds,
+                cwd=self.config.evolution_dir
+            )
+
+            if result.returncode != 0:
+                print(f"[WORKER-{os.getpid()}] Evaluator failed: {result.stderr}", file=sys.stderr)
+                return None, {}
+
+            output = result.stdout + result.stderr
+            return self._parse_evaluator_output(output)
+
+        except subprocess.TimeoutExpired:
+            print(f"[WORKER-{os.getpid()}] Evaluator timed out", file=sys.stderr)
+            return None, {}
+        except Exception as e:
+            print(f"[WORKER-{os.getpid()}] Evaluator error: {e}", file=sys.stderr)
+            return None, {}
+
+    def _parse_evaluator_output(self, output: str) -> Tuple[Optional[float], Dict[str, Any]]:
+        """
+        Parse evaluator output for score.
+
+        Supports:
+        - Simple numeric value
+        - JSON with 'performance' or 'score' field
+        - SCORE: prefix (legacy)
+        """
+        score = None
+        json_data = {}
+
+        for line in output.strip().split('\n'):
+            line = line.strip()
+
+            # Try JSON first
+            if line.startswith('{'):
+                try:
+                    data = json.loads(line)
+                    json_data = data
+                    if 'performance' in data:
+                        score = float(data['performance'])
+                    elif 'score' in data:
+                        score = float(data['score'])
+                    break
+                except (json.JSONDecodeError, ValueError):
+                    pass
+
+            # Try simple numeric
+            if score is None and line and not line.startswith('{'):
+                try:
+                    score = float(line)
+                    break
+                except ValueError:
+                    pass
+
+        # Try SCORE: prefix (legacy)
+        if score is None:
+            match = re.search(r'^SCORE:\s*([+-]?\d*\.?\d+)', output, re.MULTILINE)
+            if match:
+                try:
+                    score = float(match.group(1))
+                except ValueError:
+                    pass
+
+        return score, json_data
+
+    def process_candidate(self, candidate: Candidate) -> int:
+        """
+        Process a single candidate.
+
+        Returns:
+            Exit code (0=success, 77=AI failed, 78=missing parent, etc.)
+        """
+        self.current_candidate_id = candidate.id
+        print(f"[WORKER-{os.getpid()}] Processing: {candidate.id}", file=sys.stderr)
+        print(f"[WORKER-{os.getpid()}] Description: {candidate.description}", file=sys.stderr)
+        print(f"[WORKER-{os.getpid()}] Based on: {candidate.based_on_id or 'baseline'}", file=sys.stderr)
+
+        is_baseline = self._is_baseline(candidate.id, candidate.based_on_id)
+        target_file = Path(self.config.output_dir) / f"evolution_{candidate.id}.py"
+
+        # Resolve parent
+        resolved_parent, source_file = self._resolve_parent_id(candidate.based_on_id)
+
+        if source_file is None and not is_baseline:
+            print(f"[WORKER-{os.getpid()}] ERROR: Parent not found: {candidate.based_on_id}", file=sys.stderr)
+            return 78  # Missing parent
+
+        if source_file is None:
+            source_file = Path(self.config.algorithm_path)
+
+        # Check if target already exists
+        if target_file.exists():
+            print(f"[WORKER-{os.getpid()}] File already exists, running evaluation only", file=sys.stderr)
+        elif not is_baseline:
+            # Copy source to target
+            print(f"[WORKER-{os.getpid()}] Copying {source_file} to {target_file}", file=sys.stderr)
+            shutil.copy(source_file, target_file)
+
+            # Call AI to modify
+            prompt = self._build_prompt(candidate, target_file.name)
+
+            try:
+                success, model = self._call_ai_with_retries(prompt, target_file, source_file)
+
+                if not success:
+                    print(f"[WORKER-{os.getpid()}] AI failed after all retries", file=sys.stderr)
+                    target_file.unlink(missing_ok=True)
+                    return 77  # AI generation failed
+
+                # Record model used
+                if model:
+                    with EvolutionCSV(self.config.csv_path) as csv:
+                        csv.update_candidate_field(candidate.id, 'run-LLM', model)
+
+            except RateLimitError:
+                target_file.unlink(missing_ok=True)
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'pending')
+                return 2  # Rate limit
+
+            except APIExhaustedError:
+                target_file.unlink(missing_ok=True)
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'pending')
+                return 3  # API exhausted
+
+            # Check syntax
+            if not self._check_syntax(target_file):
+                print(f"[WORKER-{os.getpid()}] Syntax error in generated file", file=sys.stderr)
+                target_file.unlink(missing_ok=True)
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'pending')
+                return 0  # Will retry
+
+        # Run evaluator
+        print(f"[WORKER-{os.getpid()}] Running evaluator...", file=sys.stderr)
+        score, json_data = self._run_evaluator(candidate.id, is_baseline)
+
+        if score is None:
+            print(f"[WORKER-{os.getpid()}] Evaluation failed - no score", file=sys.stderr)
+            with EvolutionCSV(self.config.csv_path) as csv:
+                csv.update_candidate_status(candidate.id, 'failed')
+            return 1
+
+        print(f"[WORKER-{os.getpid()}] Score: {score}", file=sys.stderr)
+
+        # Update CSV
+        with EvolutionCSV(self.config.csv_path) as csv:
+            csv.update_candidate_status(candidate.id, 'complete')
+            csv.update_candidate_performance(candidate.id, str(score))
+
+            # Update any extra fields from JSON
+            for key, value in json_data.items():
+                if key not in ('performance', 'score'):
+                    csv.update_candidate_field(candidate.id, key, str(value))
+
+        self.current_candidate_id = None
+        return 0
+
+    def run(self) -> int:
+        """
+        Main worker loop.
+
+        Returns:
+            Exit code
+        """
+        print(f"[WORKER-{os.getpid()}] Started (max {self.config.max_candidates} candidates)", file=sys.stderr)
+        processed = 0
+
+        while processed < self.config.max_candidates:
+            # Get next pending candidate
+            with EvolutionCSV(self.config.csv_path) as csv:
+                result = csv.get_next_pending_candidate()
+
+            if not result:
+                print(f"[WORKER-{os.getpid()}] No pending candidates", file=sys.stderr)
+                break
+
+            candidate_id, _ = result
+
+            # Get full candidate info
+            with EvolutionCSV(self.config.csv_path) as csv:
+                info = csv.get_candidate_info(candidate_id)
+
+            if not info:
+                print(f"[WORKER-{os.getpid()}] Candidate info not found: {candidate_id}", file=sys.stderr)
+                continue
+
+            candidate = Candidate(
+                id=info['id'],
+                based_on_id=info.get('basedOnId', ''),
+                description=info.get('description', '')
+            )
+
+            exit_code = self.process_candidate(candidate)
+            processed += 1
+
+            if exit_code == 77:  # AI failed
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'failed-ai-retry')
+            elif exit_code == 78:  # Missing parent
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'failed-parent-missing')
+            elif exit_code == 2:  # Rate limit
+                return 2
+            elif exit_code == 3:  # API exhausted
+                return 3
+
+            print(f"[WORKER-{os.getpid()}] Processed {processed}/{self.config.max_candidates}", file=sys.stderr)
+
+        print(f"[WORKER-{os.getpid()}] Exiting", file=sys.stderr)
+        return 0
+
+
+def load_config_from_yaml(config_path: Optional[str] = None) -> Config:
+    """Load configuration from YAML file."""
+    import yaml
+
+    # Find config file
+    if config_path:
+        yaml_path = Path(config_path)
+    elif os.environ.get('CLAUDE_EVOLVE_CONFIG'):
+        yaml_path = Path(os.environ['CLAUDE_EVOLVE_CONFIG'])
+    else:
+        # Look for config.yaml in evolution directory
+        yaml_path = Path('evolution/config.yaml')
+        if not yaml_path.exists():
+            yaml_path = Path('config.yaml')
+
+    if not yaml_path.exists():
+        raise FileNotFoundError(f"Config not found: {yaml_path}")
+
+    with open(yaml_path) as f:
+        data = yaml.safe_load(f) or {}
+
+    # Resolve paths relative to config file
+    base_dir = yaml_path.parent
+
+    def resolve(path: str) -> str:
+        p = Path(path)
+        if not p.is_absolute():
+            p = base_dir / p
+        return str(p.resolve())
+
+    return Config(
+        csv_path=resolve(data.get('csv_file', 'evolution.csv')),
+        evolution_dir=str(base_dir.resolve()),
+        output_dir=resolve(data.get('output_dir', '.')),
+        algorithm_path=resolve(data.get('algorithm_file', 'algorithm.py')),
+        evaluator_path=resolve(data.get('evaluator_file', 'evaluator.py')),
+        brief_path=resolve(data.get('brief_file', 'BRIEF.md')),
+        python_cmd=data.get('python_cmd', 'python3'),
+        memory_limit_mb=data.get('memory_limit_mb', 0),
+        timeout_seconds=data.get('timeout_seconds', 600),
+        max_ai_retries=data.get('max_retries', 3),
+        max_candidates=data.get('worker_max_candidates', 5)
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Claude Evolve Worker')
+    parser.add_argument('--config', help='Path to config.yaml')
+    parser.add_argument('--timeout', type=int, help='Timeout in seconds')
+    args = parser.parse_args()
+
+    try:
+        config = load_config_from_yaml(args.config)
+        if args.timeout:
+            config.timeout_seconds = args.timeout
+
+        worker = Worker(config)
+        sys.exit(worker.run())
+
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "claude-evolve",
-  "version": "1.8.49",
+  "version": "1.9.0",
   "bin": {
-    "claude-evolve": "./bin/claude-evolve",
-    "claude-evolve-main": "./bin/claude-evolve-main",
-    "claude-evolve-setup": "./bin/claude-evolve-setup",
-    "claude-evolve-ideate": "./bin/claude-evolve-ideate",
-    "claude-evolve-run": "./bin/claude-evolve-run",
-    "claude-evolve-worker": "./bin/claude-evolve-worker",
-    "claude-evolve-analyze": "./bin/claude-evolve-analyze",
-    "claude-evolve-config": "./bin/claude-evolve-config",
-    "claude-evolve-killall": "./bin/claude-evolve-killall"
+    "claude-evolve": "bin/claude-evolve",
+    "claude-evolve-main": "bin/claude-evolve-main",
+    "claude-evolve-setup": "bin/claude-evolve-setup",
+    "claude-evolve-ideate": "bin/claude-evolve-ideate",
+    "claude-evolve-run": "bin/claude-evolve-run",
+    "claude-evolve-worker": "bin/claude-evolve-worker",
+    "claude-evolve-analyze": "bin/claude-evolve-analyze",
+    "claude-evolve-config": "bin/claude-evolve-config",
+    "claude-evolve-killall": "bin/claude-evolve-killall"
   },
   "files": [
     "bin/",