pdd-cli 0.0.90__py3-none-any.whl → 0.0.121__py3-none-any.whl

pdd/fix_code_loop.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import json
 import os
 import shutil
 import subprocess
@@ -7,6 +8,8 @@ import threading
 from pathlib import Path
 from typing import Tuple, Optional, Union, List
 
+import requests
+
 # Try to import DEFAULT_TIME, with fallback
 try:
     from . import DEFAULT_TIME
@@ -91,6 +94,83 @@ except ImportError:
     def rprint(*args, **kwargs):
         print(*args)
 
+# Cloud configuration
+try:
+    from .core.cloud import CloudConfig
+    CLOUD_AVAILABLE = True
+except ImportError:
+    CLOUD_AVAILABLE = False
+    CloudConfig = None
+
+# Cloud request timeout for crash fix
+CLOUD_REQUEST_TIMEOUT = 400  # seconds
+
+def cloud_crash_fix(
+    program: str,
+    prompt: str,
+    code: str,
+    errors: str,
+    strength: float,
+    temperature: float,
+    time: float,
+    verbose: bool,
+    program_path: str = "",
+    code_path: str = "",
+    language: str = "python",
+) -> Tuple[bool, bool, str, str, str, float, Optional[str]]:
+    """
+    Call cloud crashCode endpoint for LLM crash fix.
+
+    Returns:
+        Tuple of (update_program, update_code, fixed_program, fixed_code, analysis, cost, model_name)
+    """
+    if not CLOUD_AVAILABLE or CloudConfig is None:
+        raise RuntimeError("Cloud configuration not available")
+
+    jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
+    if not jwt_token:
+        raise RuntimeError("Cloud authentication failed - no JWT token")
+
+    payload = {
+        "programContent": program,
+        "promptContent": prompt,
+        "codeContent": code,
+        "errorContent": errors,
+        "language": language,
+        "strength": strength,
+        "temperature": temperature,
+        "time": time if time is not None else 0.25,
+        "verbose": verbose,
+        "programPath": program_path,
+        "codePath": code_path,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {jwt_token}",
+        "Content-Type": "application/json"
+    }
+    cloud_url = CloudConfig.get_endpoint_url("crashCode")
+
+    response = requests.post(
+        cloud_url,
+        json=payload,
+        headers=headers,
+        timeout=CLOUD_REQUEST_TIMEOUT
+    )
+    response.raise_for_status()
+
+    response_data = response.json()
+    fixed_code = response_data.get("fixedCode", "")
+    fixed_program = response_data.get("fixedProgram", "")
+    update_code = response_data.get("updateCode", False)
+    update_program = response_data.get("updateProgram", False)
+    analysis = response_data.get("analysis", "")
+    cost = float(response_data.get("totalCost", 0.0))
+    model_name = response_data.get("modelName", "cloud_model")
+
+    return update_program, update_code, fixed_program, fixed_code, analysis, cost, model_name
+
+
 # Use relative import for internal modules
 try:
     from .fix_code_module_errors import fix_code_module_errors
@@ -173,22 +253,30 @@ def run_process_with_output(cmd_args, timeout=300):
         except Exception:
             pass
 
-    # Close pipes to unblock reader threads
-    try:
-        proc.stdout.close()
-    except Exception:
-        pass
-    try:
-        proc.stderr.close()
-    except Exception:
-        pass
+    # Wait for threads to finish reading with timeout
+    # For normal completion, threads will exit when they read EOF from the pipe
+    # For timeout/kill cases, we may need to close pipes to unblock them
+    THREAD_JOIN_TIMEOUT = 5  # seconds - enough time to drain normal output buffers
 
-    # Wait for threads with timeout to prevent indefinite hangs
-    THREAD_JOIN_TIMEOUT = 5  # seconds
     t_out.join(timeout=THREAD_JOIN_TIMEOUT)
     t_err.join(timeout=THREAD_JOIN_TIMEOUT)
 
-    # If threads are still alive after timeout, log it (they're daemon threads so won't block exit)
+    # If threads are still alive after first timeout, close pipes to unblock them
+    # This handles cases where child processes keep pipes open
+    if t_out.is_alive() or t_err.is_alive():
+        try:
+            proc.stdout.close()
+        except Exception:
+            pass
+        try:
+            proc.stderr.close()
+        except Exception:
+            pass
+        # Give threads a bit more time after closing pipes
+        t_out.join(timeout=2)
+        t_err.join(timeout=2)
+
+    # If threads are still alive after all attempts, log it
     if t_out.is_alive() or t_err.is_alive():
         captured_stderr.append(b"\n[Thread join timeout - some output may be lost]\n")
 
@@ -211,10 +299,16 @@ def fix_code_loop(
     time: float = DEFAULT_TIME,
     prompt_file: str = "",
     agentic_fallback: bool = True,
+    use_cloud: bool = False,
 ) -> Tuple[bool, str, str, int, float, Optional[str]]:
     """
     Attempts to fix errors in a code module through multiple iterations.
 
+    Hybrid Cloud Support:
+        When use_cloud=True, the LLM fix calls are routed to the cloud crashCode endpoint
+        while local verification program execution stays local. This allows the loop to
+        pass local verification results to the cloud for analysis and fixes.
+
     Args:
         code_file: Path to the code file being tested.
         prompt: The prompt that generated the code under test.
@@ -228,6 +322,7 @@ def fix_code_loop(
         time: Time limit for the LLM calls (default: DEFAULT_TIME).
         prompt_file: Path to the prompt file.
         agentic_fallback: Enable agentic fallback if the primary fix mechanism fails.
+        use_cloud: If True, use cloud LLM for fix calls while keeping verification execution local.
 
     Returns:
         Tuple containing the following in order:
@@ -257,7 +352,37 @@ def fix_code_loop(
         lang = get_language(os.path.splitext(code_file)[1])
         verify_cmd = default_verify_cmd_for(lang, verification_program)
         if not verify_cmd:
-            raise ValueError(f"No default verification command for language: {lang}")
+            # No verify command available (e.g., Java without maven/gradle).
+            # Trigger agentic fallback directly using any existing error log.
+            rprint(f"[cyan]No verification command for {lang}. Triggering agentic fallback directly...[/cyan]")
+            error_log_path = Path(error_log_file)
+            error_log_path.parent.mkdir(parents=True, exist_ok=True)
+            # Read existing error content or create minimal log
+            if not error_log_path.exists() or error_log_path.stat().st_size == 0:
+                with open(error_log_path, "w") as f:
+                    f.write(f"No verification command available for language: {lang}\n")
+                    f.write("Agentic fix will attempt to resolve the issue.\n")
+
+            success, _msg, agent_cost, agent_model, agent_changed_files = _safe_run_agentic_crash(
+                prompt_file=prompt_file,
+                code_file=code_file,
+                program_file=verification_program,
+                crash_log_file=error_log_file,
+                cwd=Path(prompt_file).parent if prompt_file else None
+            )
+            final_program = ""
+            final_code = ""
+            try:
+                with open(verification_program, "r") as f:
+                    final_program = f.read()
+            except Exception:
+                pass
+            try:
+                with open(code_file, "r") as f:
+                    final_code = f.read()
+            except Exception:
+                pass
+            return success, final_program, final_code, 1, agent_cost, agent_model
         
         verify_result = subprocess.run(verify_cmd, capture_output=True, text=True, shell=True)
         pytest_output = (verify_result.stdout or "") + "\n" + (verify_result.stderr or "")
@@ -320,10 +445,17 @@ def fix_code_loop(
     history_log = "<history>\n"
 
     # Create initial backups before any modifications
+    # Store in .pdd/backups/ to avoid polluting code/test directories
+    from datetime import datetime
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     code_file_path = Path(code_file)
     verification_program_path = Path(verification_program)
-    original_code_backup = f"{code_file_path.stem}_original_backup{code_file_path.suffix}"
-    original_program_backup = f"{verification_program_path.stem}_original_backup{verification_program_path.suffix}"
+
+    backup_dir = Path.cwd() / '.pdd' / 'backups' / code_file_path.stem / timestamp
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    original_code_backup = str(backup_dir / f"code_original{code_file_path.suffix}")
+    original_program_backup = str(backup_dir / f"program_original{verification_program_path.suffix}")
 
     try:
         shutil.copy2(code_file, original_code_backup)
@@ -411,10 +543,9 @@ def fix_code_loop(
 
 
         # Create backup copies for this iteration BEFORE calling LLM
-        code_base, code_ext = os.path.splitext(code_file)
-        program_base, program_ext = os.path.splitext(verification_program)
-        code_backup_path = f"{code_base}_{current_iteration_number}{code_ext}"
-        program_backup_path = f"{program_base}_{current_iteration_number}{program_ext}"
+        # Store in .pdd/backups/ (backup_dir already created above)
+        code_backup_path = str(backup_dir / f"code_{current_iteration_number}{code_file_path.suffix}")
+        program_backup_path = str(backup_dir / f"program_{current_iteration_number}{verification_program_path.suffix}")
 
         try:
             shutil.copy2(code_file, code_backup_path)
@@ -439,7 +570,7 @@ def fix_code_loop(
         # Temporarily close the XML structure for the LLM call
         error_context_for_llm = history_log + attempt_log_entry + "  </attempt>\n</history>\n"
 
-        # Call fix_code_module_errors
+        # Call fix (cloud or local based on use_cloud parameter)
         rprint("Attempting to fix errors using LLM...")
         update_program, update_code, fixed_program, fixed_code = False, False, "", ""
         program_code_fix, cost, model_name_iter = "", 0.0, None
@@ -449,20 +580,63 @@ def fix_code_loop(
         # For simplicity, we assume fix_code_module_errors prints directly using `rprint`
 
         try:
-            # Note: The example signature for fix_code_module_errors returns 7 values
-            (update_program, update_code, fixed_program, fixed_code,
-             program_code_fix, cost, model_name_iter) = fix_code_module_errors(
-                program=current_program,
-                prompt=prompt,
-                code=current_code,
-                errors=error_context_for_llm, # Pass the structured history
-                strength=strength,
-                temperature=temperature,
-                time=time, # Pass time
-                verbose=verbose,
-            )
-            if model_name_iter:
-                 model_name = model_name_iter # Update model name if returned
+            if use_cloud:
+                # Use cloud LLM for fix - local verification results passed via error_context_for_llm
+                try:
+                    (update_program, update_code, fixed_program, fixed_code,
+                     program_code_fix, cost, model_name_iter) = cloud_crash_fix(
+                        program=current_program,
+                        prompt=prompt,
+                        code=current_code,
+                        errors=error_context_for_llm,
+                        strength=strength,
+                        temperature=temperature,
+                        time=time,
+                        verbose=verbose,
+                        program_path=verification_program,
+                        code_path=code_file,
+                        language="python" if is_python else get_language(os.path.splitext(code_file)[1]),
+                    )
+                    if model_name_iter:
+                        model_name = model_name_iter
+                    if verbose:
+                        rprint(f"[cyan]Cloud crash fix completed. Cost: ${cost:.4f}[/cyan]")
+                except (requests.exceptions.RequestException, RuntimeError) as cloud_err:
+                    # Cloud failed - fall back to local
+                    rprint(f"[yellow]Cloud crash fix failed: {cloud_err}. Falling back to local.[/yellow]")
+                    (update_program, update_code, fixed_program, fixed_code,
+                     program_code_fix, cost, model_name_iter) = fix_code_module_errors(
+                        program=current_program,
+                        prompt=prompt,
+                        code=current_code,
+                        errors=error_context_for_llm,
+                        strength=strength,
+                        temperature=temperature,
+                        time=time,
+                        verbose=verbose,
+                        program_path=verification_program,
+                        code_path=code_file,
+                    )
+                    if model_name_iter:
+                        model_name = model_name_iter
+            else:
+                # Local LLM fix
+                # Note: The example signature for fix_code_module_errors returns 7 values
+                (update_program, update_code, fixed_program, fixed_code,
+                 program_code_fix, cost, model_name_iter) = fix_code_module_errors(
+                    program=current_program,
+                    prompt=prompt,
+                    code=current_code,
+                    errors=error_context_for_llm, # Pass the structured history
+                    strength=strength,
+                    temperature=temperature,
+                    time=time, # Pass time
+                    verbose=verbose,
+                    program_path=verification_program,  # Pass file path for LLM context
+                    code_path=code_file,                # Pass file path for LLM context
+                )
+                if model_name_iter:
+                     model_name = model_name_iter # Update model name if returned
 
         except Exception as e:
             rprint(f"[bold red]Error calling fix_code_module_errors: {e}[/bold red]")

pdd/fix_code_module_errors.py

@@ -38,7 +38,9 @@ def fix_code_module_errors(
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0,
     time: float = DEFAULT_TIME,
-    verbose: bool = False
+    verbose: bool = False,
+    program_path: str = "",
+    code_path: str = "",
 ) -> Tuple[bool, bool, str, str, str, float, str]:
     """
     Fix errors in a code module that caused a program to crash and/or have errors.
@@ -62,7 +64,9 @@ def fix_code_module_errors(
             "program": program,
             "prompt": prompt,
             "code": code,
-            "errors": errors
+            "errors": errors,
+            "program_path": program_path,
+            "code_path": code_path,
         }
 
         if verbose: