Update core/evolution_engine.py

core/evolution_engine.py

@@ -1,119 +1,80 @@
-# algoforge_prime/core/evaluation_engine.py
-import random
+# algoforge_prime/core/evolution_engine.py
+print("DEBUG: Importing core.evolution_engine")
 
-from prompts.prompt_templates import format_critique_user_prompt
-# Import our (simulated) safe executor
-from core.llm_clients import call_huggingface_api, call_gemini_api, LLMResponse # Absolute
-from prompts.system_prompts import get_system_prompt # 
-from safe_executor import execute_python_code_with_tests, ExecutionResult # Assuming it's in the same 'core' package
+# --- Corrected Imports ---
+# Absolute imports for modules outside the 'core' package
+from prompts.system_prompts import get_system_prompt
 
-class EvaluationResultOutput: # Renamed to avoid conflict with safe_executor.ExecutionResult
-    def __init__(self, combined_score=0, llm_critique_text="", execution_details: ExecutionResult = None, raw_llm_response=None):
-        self.combined_score = combined_score
-        self.llm_critique_text = llm_critique_text # LLM's qualitative assessment
-        self.execution_details = execution_details # Object from safe_executor
-        self.raw_llm_response = raw_llm_response
+# Absolute imports for other modules within the 'core' package (or relative for siblings)
+from core.llm_clients import call_huggingface_api, call_gemini_api, LLMResponse
 
-    def get_display_critique(self):
-        full_critique = self.llm_critique_text if self.llm_critique_text else "LLM critique was not performed or failed."
-        if self.execution_details:
-            full_critique += f"\n\n**Automated Execution & Test Results (Simulated):**\n"
-            if self.execution_details.total_tests > 0:
-                full_critique += f"  Tests Attempted: {self.execution_details.total_tests}\n"
-                full_critique += f"  Tests Passed:    {self.execution_details.passed_tests}\n"
-            if self.execution_details.error:
-                full_critique += f"  Execution Error: {self.execution_details.error}\n"
-            elif self.execution_details.output:
-                 full_critique += f"  Execution Output (stdout):\n```\n{self.execution_details.output[:500]}\n```\n" # Limit output display
-            full_critique += f"  Execution Time: {self.execution_details.execution_time:.4f}s\n"
-        return full_critique
+# Relative import for a sibling module within the 'core' package
+# from .safe_executor import ExecutionResult # Not directly used in this module, but evaluation_output_obj might contain it
+# from .evaluation_engine import EvaluationResultOutput # For type hinting the parameter
 
+print("DEBUG: core.evolution_engine - Imports successful")
 
-def _parse_llm_score(llm_text_output: str) -> int:
-    # ... (keep your existing _parse_score_from_llm_text, renamed for clarity) ...
-    score = 0 
-    if not llm_text_output or not isinstance(llm_text_output, str): return score
-    try:
-        import re
-        match = re.search(r"Score:\s*(\d+)(?:\s*/\s*10)?", llm_text_output, re.IGNORECASE)
-        if match:
-            parsed_score_val = int(match.group(1))
-            score = max(1, min(parsed_score_val, 10)) 
-        else: score = random.randint(3, 6) # Fallback if no score marker
-    except Exception: score = random.randint(3, 5) # Fallback on any parsing error
-    return score
-
-
-def evaluate_solution_candidate(
-    solution_text: str,
+def evolve_solution(
+    original_solution_text: str,
+    evaluation_output_obj, # This object comes from evaluation_engine and contains EvaluationResultOutput
+                           # It will have a .get_display_critique() method and .combined_score attribute
     problem_description: str,
     problem_type: str,
-    user_provided_tests_code: str,
-    llm_client_config: dict
-) -> EvaluationResultOutput:
+    llm_client_config: dict # {"type": ..., "model_id": ..., "temp": ..., "max_tokens": ...}
+) -> str: # Returns evolved solution text or an error string
+    """
+    Attempts to evolve a solution based on its comprehensive evaluation details.
+    """
+    print(f"DEBUG: evolution_engine.py - Evolving solution. Problem type: {problem_type}")
+    system_p_evolve = get_system_prompt("evolution_general") # problem_type can be used for specialization here too
     
-    llm_critique_text = "LLM critique generation failed or was skipped."
-    llm_score = 0
-    raw_llm_critique_resp = None
-    execution_result_obj = None # type: ExecutionResult
-
-    # 1. LLM-based Critique (only if solution_text is not an error itself)
-    if solution_text and not solution_text.startswith("ERROR"):
-        system_p_critique = get_system_prompt("critique_general")
-        user_p_critique = format_critique_user_prompt(problem_description, solution_text)
-        
-        llm_response_obj = None
-        if llm_client_config["type"] == "hf":
-            llm_response_obj = call_huggingface_api(user_p_critique, llm_client_config["model_id"], llm_client_config["temp"], llm_client_config["max_tokens"], system_p_critique)
-        elif llm_client_config["type"] == "google_gemini":
-            llm_response_obj = call_gemini_api(user_p_critique, llm_client_config["model_id"], llm_client_config["temp"], llm_client_config["max_tokens"], system_p_critique)
-        
-        if llm_response_obj:
-            raw_llm_critique_resp = llm_response_obj.raw_response
-            if llm_response_obj.success:
-                llm_critique_text = llm_response_obj.text
-                llm_score = _parse_llm_score(llm_critique_text)
-            else:
-                llm_critique_text = f"Error during LLM critique (Model: {llm_response_obj.model_id_used}): {llm_response_obj.error}"
-                llm_score = 0 # Penalize
-    elif solution_text and solution_text.startswith("ERROR"):
-        llm_critique_text = f"Solution was an error from Genesis: {solution_text}"
-        llm_score = 0
+    # Extract necessary info from the evaluation_output_obj
+    # This assumes evaluation_output_obj is an instance of EvaluationResultOutput from evaluation_engine.py
+    # or at least has these attributes/methods.
+    try:
+        critique_and_test_feedback = evaluation_output_obj.get_display_critique() 
+        original_score = evaluation_output_obj.combined_score
+    except AttributeError as e:
+        print(f"ERROR: evolution_engine.py - evaluation_output_obj is missing expected attributes/methods: {e}")
+        # Fallback if the object structure is not as expected
+        critique_and_test_feedback = "Critique data was not in the expected format."
+        original_score = 0 # Assign a neutral score if real one can't be found
 
+    user_p_evolve = (
+        f"Original Problem Context: \"{problem_description}\"\n\n"
+        f"The solution to be evolved achieved a combined score of {original_score}/10.\n"
+        f"Here is the original solution text:\n```python\n{original_solution_text}\n```\n\n"
+        f"Here is the comprehensive evaluation it received (including LLM critique and automated test feedback if run):\n'''\n{critique_and_test_feedback}\n'''\n\n"
+        f"Your Task: Based on ALL the information above (solution, LLM critique, and crucially any test execution results/errors mentioned in the evaluation), "
+        f"evolve the provided solution to make it demonstrably superior. "
+        f"Prioritize fixing any reported execution errors or failed tests. "
+        f"Then, address other critique points like efficiency, clarity, or completeness. "
+        f"Output the *complete evolved solution*. "
+        f"Follow this with a brief explanation of the key changes and improvements you implemented, especially how you addressed test failures or execution issues."
+    )
 
-    # 2. Code Execution (if Python problem, code exists, and tests are provided)
-    if "python" in problem_type.lower() and solution_text and not solution_text.startswith("ERROR") and user_provided_tests_code.strip():
-        print(f"INFO: evaluation_engine.py - Preparing to execute Python code candidate against user tests.")
-        # Use the (simulated) safe executor
-        execution_result_obj = execute_python_code_with_tests(
-            solution_text, user_provided_tests_code, timeout_seconds=10 # Example timeout
+    llm_response_obj = None # type: LLMResponse
+    if llm_client_config["type"] == "hf":
+        llm_response_obj = call_huggingface_api(
+            user_p_evolve, llm_client_config["model_id"],
+            temperature=llm_client_config["temp"], max_new_tokens=llm_client_config["max_tokens"],
+            system_prompt_text=system_p_evolve
         )
-        print(f"INFO: evaluation_engine.py - Execution result: {execution_result_obj}")
-    elif "python" in problem_type.lower() and not user_provided_tests_code.strip():
-         execution_result_obj = ExecutionResult(success=True, output="No user tests provided to run against the Python code.", total_tests=0)
-
+    elif llm_client_config["type"] == "google_gemini":
+        llm_response_obj = call_gemini_api(
+            user_p_evolve, llm_client_config["model_id"],
+            temperature=llm_client_config["temp"], max_new_tokens=llm_client_config["max_tokens"],
+            system_prompt_text=system_p_evolve
+        )
+    else:
+        error_msg = f"ERROR (Evolution): Unknown LLM client type '{llm_client_config['type']}'"
+        print(f"ERROR: evolution_engine.py - {error_msg}")
+        return error_msg
 
-    # 3. Combine Scores into a Final Score (More sophisticated heuristic)
-    combined_score = llm_score
-    if execution_result_obj and execution_result_obj.total_tests > 0:
-        if not execution_result_obj.success or execution_result_obj.error: # Major execution failure
-            combined_score = max(1, llm_score - 5) # Penalize heavily
-        else:
-            pass_ratio = execution_result_obj.passed_tests / execution_result_obj.total_tests
-            if pass_ratio == 1.0: # All tests passed
-                combined_score = min(10, llm_score + 2) # Significant bonus
-            elif pass_ratio >= 0.75: # Most tests passed
-                combined_score = min(10, llm_score + 1) # Small bonus
-            elif pass_ratio < 0.25: # Very few tests passed
-                combined_score = max(1, llm_score - 4)
-            else: # Some tests passed
-                combined_score = int(llm_score * (0.5 + 0.5 * pass_ratio)) # Weighted average
-    
-    combined_score = max(1, min(10, combined_score)) # Clamp 1-10
+    if llm_response_obj.success:
+        return llm_response_obj.text
+    else:
+        # Error is already logged by call_..._api functions if it's from there
+        return f"ERROR (Evolution with {llm_response_obj.model_id_used}): {llm_response_obj.error}"
 
-    return EvaluationResultOutput(
-        combined_score=combined_score,
-        llm_critique_text=llm_critique_text,
-        execution_details=execution_result_obj,
-        raw_llm_response=raw_llm_critique_resp
-    )
+print("DEBUG: core.evolution_engine - Module fully defined.")