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

pdd/fix_main.py

@@ -1,8 +1,11 @@
 import sys
 from typing import Tuple, Optional
+import json
 import click
 from rich import print as rprint
 from rich.markup import MarkupError, escape
+from rich.console import Console
+from rich.panel import Panel
 
 import requests
 import asyncio
@@ -16,10 +19,24 @@ from .fix_errors_from_unit_tests import fix_errors_from_unit_tests
 from .fix_error_loop import fix_error_loop, run_pytest_on_file
 from .get_jwt_token import get_jwt_token
 from .get_language import get_language
+from .core.cloud import CloudConfig
 
 # Import DEFAULT_STRENGTH from the package
 from . import DEFAULT_STRENGTH
 
+# Cloud request timeout
+CLOUD_REQUEST_TIMEOUT = 400  # seconds
+
+console = Console()
+
+
+def _env_flag_enabled(name: str) -> bool:
+    """Return True when an env var is set to a truthy value."""
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
 def fix_main(
     ctx: click.Context,
     prompt_file: str,
@@ -111,8 +128,185 @@ def fix_main(
         verbose = ctx.obj.get('verbose', False)
         time = ctx.obj.get('time') # Get time from context
 
+        # Determine cloud vs local execution preference
+        is_local_execution_preferred = ctx.obj.get('local', False)
+        cloud_only = _env_flag_enabled("PDD_CLOUD_ONLY") or _env_flag_enabled("PDD_NO_LOCAL_FALLBACK")
+        current_execution_is_local = is_local_execution_preferred and not cloud_only
+
+        # Cloud execution is only supported for single-pass mode (not loop mode)
+        # because loop mode requires running tests and verification programs locally
+        cloud_execution_attempted = False
+        cloud_execution_succeeded = False
+
+        if not loop and not current_execution_is_local:
+            if verbose:
+                console.print(Panel("Attempting cloud fix execution...", title="[blue]Mode[/blue]", expand=False))
+
+            jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
+
+            if not jwt_token:
+                if cloud_only:
+                    console.print("[red]Cloud authentication failed.[/red]")
+                    raise click.UsageError("Cloud authentication failed")
+                console.print("[yellow]Cloud authentication failed. Falling back to local execution.[/yellow]")
+                current_execution_is_local = True
+
+            if jwt_token and not current_execution_is_local:
+                cloud_execution_attempted = True
+                # Build cloud payload
+                payload = {
+                    "unitTest": input_strings["unit_test_file"],
+                    "code": input_strings["code_file"],
+                    "prompt": input_strings["prompt_file"],
+                    "errors": input_strings.get("error_file", ""),
+                    "language": get_language(os.path.splitext(code_file)[1]),
+                    "strength": strength,
+                    "temperature": temperature,
+                    "time": time if time is not None else 0.25,
+                    "verbose": verbose,
+                }
+
+                headers = {
+                    "Authorization": f"Bearer {jwt_token}",
+                    "Content-Type": "application/json"
+                }
+                cloud_url = CloudConfig.get_endpoint_url("fixCode")
+
+                try:
+                    response = requests.post(
+                        cloud_url,
+                        json=payload,
+                        headers=headers,
+                        timeout=CLOUD_REQUEST_TIMEOUT
+                    )
+                    response.raise_for_status()
+
+                    response_data = response.json()
+                    fixed_unit_test = response_data.get("fixedUnitTest", "")
+                    fixed_code = response_data.get("fixedCode", "")
+                    analysis_results = response_data.get("analysis", "")
+                    total_cost = float(response_data.get("totalCost", 0.0))
+                    model_name = response_data.get("modelName", "cloud_model")
+                    success = response_data.get("success", False)
+                    update_unit_test = response_data.get("updateUnitTest", False)
+                    update_code = response_data.get("updateCode", False)
+
+                    if not (fixed_unit_test or fixed_code):
+                        if cloud_only:
+                            console.print("[red]Cloud execution returned no fixed code.[/red]")
+                            raise click.UsageError("Cloud execution returned no fixed code")
+                        console.print("[yellow]Cloud execution returned no fixed code. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+                    else:
+                        cloud_execution_succeeded = True
+                        attempts = 1
+
+                        # Validate the fix by running tests (same as local)
+                        if update_unit_test or update_code:
+                            import tempfile
+                            import shutil as shutil_module
+
+                            test_dir = tempfile.mkdtemp(prefix="pdd_fix_validate_")
+                            temp_test_file = os.path.join(test_dir, "test_temp.py")
+                            temp_code_file = os.path.join(test_dir, "code_temp.py")
+
+                            try:
+                                test_content = fixed_unit_test if fixed_unit_test else input_strings["unit_test_file"]
+                                code_content = fixed_code if fixed_code else input_strings["code_file"]
+
+                                with open(temp_test_file, 'w') as f:
+                                    f.write(test_content)
+                                with open(temp_code_file, 'w') as f:
+                                    f.write(code_content)
+
+                                fails, errors_count, warnings, test_output = run_pytest_on_file(temp_test_file)
+                                success = (fails == 0 and errors_count == 0)
+
+                                if verbose:
+                                    rprint(f"[cyan]Fix validation: {fails} failures, {errors_count} errors, {warnings} warnings[/cyan]")
+                                    if not success:
+                                        rprint("[yellow]Fix suggested by cloud did not pass tests[/yellow]")
+                            finally:
+                                try:
+                                    shutil_module.rmtree(test_dir)
+                                except Exception:
+                                    pass
+                        else:
+                            success = False
+
+                        if verbose:
+                            console.print(Panel(
+                                f"Cloud fix completed. Model: {model_name}, Cost: ${total_cost:.6f}",
+                                title="[green]Cloud Success[/green]",
+                                expand=False
+                            ))
+
+                except requests.exceptions.Timeout:
+                    if cloud_only:
+                        console.print(f"[red]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s).[/red]")
+                        raise click.UsageError("Cloud execution timed out")
+                    console.print(f"[yellow]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s). Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+                except requests.exceptions.HTTPError as e:
+                    status_code = e.response.status_code if e.response else 0
+                    err_content = e.response.text[:200] if e.response else "No response content"
+
+                    # Non-recoverable errors: do NOT fall back to local
+                    if status_code == 402:  # Insufficient credits
+                        try:
+                            error_data = e.response.json()
+                            current_balance = error_data.get("currentBalance", "unknown")
+                            estimated_cost = error_data.get("estimatedCost", "unknown")
+                            console.print(f"[red]Insufficient credits. Current balance: {current_balance}, estimated cost: {estimated_cost}[/red]")
+                        except Exception:
+                            console.print(f"[red]Insufficient credits: {err_content}[/red]")
+                        raise click.UsageError("Insufficient credits for cloud fix")
+                    elif status_code == 401:  # Authentication error
+                        console.print(f"[red]Authentication failed: {err_content}[/red]")
+                        raise click.UsageError("Cloud authentication failed")
+                    elif status_code == 403:  # Authorization error (not approved)
+                        console.print(f"[red]Access denied: {err_content}[/red]")
+                        raise click.UsageError("Access denied - user not approved")
+                    elif status_code == 400:  # Validation error
+                        console.print(f"[red]Invalid request: {err_content}[/red]")
+                        raise click.UsageError(f"Invalid request: {err_content}")
+                    else:
+                        # Recoverable errors (5xx, unexpected errors): fall back to local
+                        if cloud_only:
+                            console.print(f"[red]Cloud HTTP error ({status_code}): {err_content}[/red]")
+                            raise click.UsageError(f"Cloud HTTP error ({status_code}): {err_content}")
+                        console.print(f"[yellow]Cloud HTTP error ({status_code}): {err_content}. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+
+                except requests.exceptions.RequestException as e:
+                    if cloud_only:
+                        console.print(f"[red]Cloud network error: {e}[/red]")
+                        raise click.UsageError(f"Cloud network error: {e}")
+                    console.print(f"[yellow]Cloud network error: {e}. Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+                except json.JSONDecodeError:
+                    if cloud_only:
+                        console.print("[red]Cloud returned invalid JSON.[/red]")
+                        raise click.UsageError("Cloud returned invalid JSON")
+                    console.print("[yellow]Cloud returned invalid JSON. Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+        # Local execution path (for loop mode or when cloud failed/skipped)
         if loop:
-            # Use fix_error_loop for iterative fixing
+            # Determine if loop should use cloud for LLM calls (hybrid mode)
+            # Local test execution stays local, but LLM fix calls can go to cloud
+            use_cloud_for_loop = not is_local_execution_preferred and not cloud_only
+
+            # If cloud_only is set but we're in loop mode, we still use hybrid approach
+            if cloud_only and not is_local_execution_preferred:
+                use_cloud_for_loop = True
+
+            if verbose:
+                mode_desc = "hybrid (local tests + cloud LLM)" if use_cloud_for_loop else "local"
+                console.print(Panel(f"Performing {mode_desc} fix loop...", title="[blue]Mode[/blue]", expand=False))
+
             success, fixed_unit_test, fixed_code, attempts, total_cost, model_name = fix_error_loop(
                 unit_test_file=unit_test_file,
                 code_file=code_file,
@@ -126,10 +320,13 @@ def fix_main(
                 budget=budget,
                 error_log_file=output_file_paths.get("output_results"),
                 verbose=verbose,
-                agentic_fallback=agentic_fallback
+                agentic_fallback=agentic_fallback,
+                use_cloud=use_cloud_for_loop
             )
-        else:
-            # Use fix_errors_from_unit_tests for single-pass fixing
+        elif not cloud_execution_succeeded:
+            # Use fix_errors_from_unit_tests for single-pass fixing (local fallback)
+            if verbose:
+                console.print(Panel("Performing local fix...", title="[blue]Mode[/blue]", expand=False))
             update_unit_test, update_code, fixed_unit_test, fixed_code, analysis_results, total_cost, model_name = fix_errors_from_unit_tests(
                 unit_test=input_strings["unit_test_file"],
                 code=input_strings["code_file"],
@@ -342,6 +539,9 @@ def fix_main(
     except click.Abort:
         # User cancelled - re-raise to stop the sync loop
         raise
+    except click.UsageError:
+        # Re-raise UsageError for proper CLI handling (e.g., cloud auth failures, insufficient credits)
+        raise
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             # Safely handle and print MarkupError

pdd/fix_verification_errors_loop.py

@@ -1,3 +1,4 @@
+import json
 import os
 import shutil
 import subprocess
@@ -8,6 +9,8 @@ from typing import Dict, Tuple, Any, Optional
 from xml.sax.saxutils import escape
 import time
 
+import requests
+
 from rich.console import Console
 
 # Use relative import assuming fix_verification_errors is in the same package
@@ -31,6 +34,78 @@ from .get_language import get_language
 from .agentic_langtest import default_verify_cmd_for
 from .agentic_verify import run_agentic_verify
 
+# Cloud configuration
+try:
+    from .core.cloud import CloudConfig
+    CLOUD_AVAILABLE = True
+except ImportError:
+    CLOUD_AVAILABLE = False
+    CloudConfig = None
+
+# Cloud request timeout for verify fix
+CLOUD_REQUEST_TIMEOUT = 400  # seconds
+
+
+def cloud_verify_fix(
+    program: str,
+    prompt: str,
+    code: str,
+    output: str,
+    strength: float,
+    temperature: float,
+    time_param: float,
+    verbose: bool,
+    language: str = "python",
+) -> Dict[str, Any]:
+    """
+    Call cloud verifyCode endpoint for LLM verification fix.
+
+    Returns:
+        Dict with keys: fixed_code, fixed_program, explanation, verification_issues_count, total_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,
+        "outputContent": output,
+        "language": language,
+        "strength": strength,
+        "temperature": temperature,
+        "time": time_param if time_param is not None else 0.25,
+        "verbose": verbose,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {jwt_token}",
+        "Content-Type": "application/json"
+    }
+    cloud_url = CloudConfig.get_endpoint_url("verifyCode")
+
+    response = requests.post(
+        cloud_url,
+        json=payload,
+        headers=headers,
+        timeout=CLOUD_REQUEST_TIMEOUT
+    )
+    response.raise_for_status()
+
+    response_data = response.json()
+    return {
+        "fixed_code": response_data.get("fixedCode", code),
+        "fixed_program": response_data.get("fixedProgram", program),
+        "explanation": response_data.get("explanation", ""),
+        "verification_issues_count": response_data.get("issuesCount", 0),
+        "total_cost": float(response_data.get("totalCost", 0.0)),
+        "model_name": response_data.get("modelName", "cloud_model"),
+    }
+
 def _normalize_agentic_result(result):
     """
     Normalize run_agentic_verify result into: (success: bool, msg: str, cost: float, model: str, changed_files: List[str])
@@ -156,11 +231,17 @@ def fix_verification_errors_loop(
     program_args: Optional[list[str]] = None,
     llm_time: float = DEFAULT_TIME, # Add time parameter
     agentic_fallback: bool = True,
+    use_cloud: bool = False,
 ) -> Dict[str, Any]:
     """
     Attempts to fix errors in a code file based on program execution output
     against the prompt's intent, iterating multiple times with secondary verification.
 
+    Hybrid Cloud Support:
+        When use_cloud=True, the LLM fix calls are routed to the cloud verifyCode endpoint
+        while local program execution stays local. This allows the loop to pass local
+        verification results to the cloud for analysis and fixes.
+
     Args:
         program_file: Path to the Python program exercising the code.
         code_file: Path to the code file being tested/verified.
@@ -178,6 +259,7 @@ def fix_verification_errors_loop(
         program_args: Optional list of command-line arguments for the program_file.
         llm_time: Time parameter for fix_verification_errors calls (default: DEFAULT_TIME).
         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:
         A dictionary containing:
@@ -196,8 +278,55 @@ def fix_verification_errors_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.
+            console.print(f"[cyan]No verification command for {lang}. Triggering agentic fallback directly...[/cyan]")
+            verification_log_path = Path(verification_log_file)
+            verification_log_path.parent.mkdir(parents=True, exist_ok=True)
+            # Create minimal error log if it doesn't exist
+            if not verification_log_path.exists() or verification_log_path.stat().st_size == 0:
+                with open(verification_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")
+
+            agent_cwd = Path(prompt_file).parent if prompt_file else None
+            console.print(f"[cyan]Attempting agentic verify fallback (prompt_file={prompt_file!r})...[/cyan]")
+            success, agent_msg, agent_cost, agent_model, agent_changed_files = _safe_run_agentic_verify(
+                prompt_file=prompt_file,
+                code_file=code_file,
+                program_file=verification_program,
+                verification_log_file=verification_log_file,
+                verbose=verbose,
+                cwd=agent_cwd,
+            )
+            if not success:
+                console.print(f"[bold red]Agentic verify fallback failed: {agent_msg}[/bold red]")
+            if agent_changed_files:
+                console.print(f"[cyan]Agent modified {len(agent_changed_files)} file(s):[/cyan]")
+                for f in agent_changed_files:
+                    console.print(f"  • {f}")
+            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": success,
+                "final_program": final_program,
+                "final_code": final_code,
+                "total_attempts": 1,
+                "total_cost": agent_cost,
+                "model_name": agent_model,
+                "statistics": {},
+            }
+
         verify_result = subprocess.run(verify_cmd, capture_output=True, text=True, shell=True)
         pytest_output = (verify_result.stdout or "") + "\n" + (verify_result.stderr or "")
         console.print("[cyan]Non-Python target detected. Triggering agentic fallback...[/cyan]")
@@ -310,6 +439,11 @@ def fix_verification_errors_loop(
     program_contents = "" # Keep track of current contents
     code_contents = ""    # Keep track of current contents
 
+    # Create backup directory in .pdd/backups/ to avoid polluting code/test directories
+    backup_timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_dir = Path.cwd() / '.pdd' / 'backups' / code_path.stem / backup_timestamp
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
     # --- Step 3: Determine Initial State ---
     if verbose:
         console.print("[bold cyan]Step 3: Determining Initial State...[/bold cyan]")
@@ -324,6 +458,21 @@ def fix_verification_errors_loop(
         stats['status_message'] = f'Error reading initial files: {e}' # Add status message
         return {"success": False, "final_program": "", "final_code": "", "total_attempts": 0, "total_cost": 0.0, "model_name": None, "statistics": stats}
 
+    # 3a-pre: Validate code file is not empty (prevents infinite loops with empty content)
+    if not initial_code_content or len(initial_code_content.strip()) == 0:
+        error_msg = f"Code file is empty or contains only whitespace: {code_path}"
+        console.print(f"[bold red]Error: {error_msg}[/bold red]")
+        stats['status_message'] = f'Error: Code file is empty - cannot verify'
+        return {
+            "success": False,
+            "final_program": initial_program_content,
+            "final_code": "",
+            "total_attempts": 0,
+            "total_cost": 0.0,
+            "model_name": None,
+            "statistics": stats
+        }
+
     # 3a: Run initial program with args
     initial_return_code, initial_output = _run_program(program_path, args=program_args)
     if verbose:
@@ -370,16 +519,46 @@ def fix_verification_errors_loop(
             if verbose:
                 console.print("Running initial assessment with fix_verification_errors...")
             # Use actual strength/temp for realistic initial assessment
-            initial_fix_result = fix_verification_errors(
-                program=initial_program_content,
-                prompt=prompt,
-                code=initial_code_content,
-                output=initial_output,
-                strength=strength,
-                temperature=temperature,
-                verbose=verbose,
-                time=llm_time # Pass time
-            )
+            # Use cloud or local based on use_cloud parameter
+            if use_cloud:
+                try:
+                    initial_fix_result = cloud_verify_fix(
+                        program=initial_program_content,
+                        prompt=prompt,
+                        code=initial_code_content,
+                        output=initial_output,
+                        strength=strength,
+                        temperature=temperature,
+                        time_param=llm_time,
+                        verbose=verbose,
+                        language="python" if is_python else get_language(os.path.splitext(code_file)[1]),
+                    )
+                    if verbose:
+                        console.print(f"[cyan]Cloud verify fix completed.[/cyan]")
+                except (requests.exceptions.RequestException, RuntimeError) as cloud_err:
+                    # Cloud failed - fall back to local
+                    console.print(f"[yellow]Cloud verify fix failed: {cloud_err}. Falling back to local.[/yellow]")
+                    initial_fix_result = fix_verification_errors(
+                        program=initial_program_content,
+                        prompt=prompt,
+                        code=initial_code_content,
+                        output=initial_output,
+                        strength=strength,
+                        temperature=temperature,
+                        verbose=verbose,
+                        time=llm_time
+                    )
+            else:
+                initial_fix_result = fix_verification_errors(
+                    program=initial_program_content,
+                    prompt=prompt,
+                    code=initial_code_content,
+                    output=initial_output,
+                    strength=strength,
+                    temperature=temperature,
+                    verbose=verbose,
+                    time=llm_time # Pass time
+                )
             # 3e: Add cost
             initial_cost = initial_fix_result.get('total_cost', 0.0)
             total_cost += initial_cost
@@ -539,9 +718,9 @@ def fix_verification_errors_loop(
         #     code_contents = code_path.read_text(encoding="utf-8")
         # except IOError as e: ...
 
-        # 4d: Create backups
-        program_backup_path = program_path.with_stem(f"{program_path.stem}_iteration_{current_attempt}").with_suffix(program_path.suffix)
-        code_backup_path = code_path.with_stem(f"{code_path.stem}_iteration_{current_attempt}").with_suffix(code_path.suffix)
+        # 4d: Create backups in .pdd/backups/ (backup_dir already created above)
+        program_backup_path = backup_dir / f"program_{current_attempt}{program_path.suffix}"
+        code_backup_path = backup_dir / f"code_{current_attempt}{code_path.suffix}"
         try:
             # Copy from the *current* state before this iteration's fix
             program_path.write_text(program_contents, encoding="utf-8") # Ensure file matches memory state
@@ -561,7 +740,7 @@ def fix_verification_errors_loop(
             stats['status_message'] = f'Error creating backups on attempt {current_attempt}'
             break # Don't proceed without backups
 
-        # 4e: Call fix_verification_errors
+        # 4e: Call fix_verification_errors (cloud or local based on use_cloud parameter)
         iteration_log_xml += f'  <InputsToFixer>\n'
         iteration_log_xml += f'    <Program>{escape(program_contents)}</Program>\n'
         iteration_log_xml += f'    <Code>{escape(code_contents)}</Code>\n'
@@ -573,16 +752,46 @@ def fix_verification_errors_loop(
         try:
             if verbose:
                 console.print("Calling fix_verification_errors...")
-            fix_result = fix_verification_errors(
-                program=program_contents,
-                prompt=prompt,
-                code=code_contents,
-                output=program_output,
-                strength=strength,
-                temperature=temperature,
-                verbose=verbose,
-                time=llm_time # Pass time
-            )
+            # Use cloud or local based on use_cloud parameter
+            if use_cloud:
+                try:
+                    fix_result = cloud_verify_fix(
+                        program=program_contents,
+                        prompt=prompt,
+                        code=code_contents,
+                        output=program_output,
+                        strength=strength,
+                        temperature=temperature,
+                        time_param=llm_time,
+                        verbose=verbose,
+                        language="python" if is_python else get_language(os.path.splitext(code_file)[1]),
+                    )
+                    if verbose:
+                        console.print(f"[cyan]Cloud verify fix completed.[/cyan]")
+                except (requests.exceptions.RequestException, RuntimeError) as cloud_err:
+                    # Cloud failed - fall back to local
+                    console.print(f"[yellow]Cloud verify fix failed: {cloud_err}. Falling back to local.[/yellow]")
+                    fix_result = fix_verification_errors(
+                        program=program_contents,
+                        prompt=prompt,
+                        code=code_contents,
+                        output=program_output,
+                        strength=strength,
+                        temperature=temperature,
+                        verbose=verbose,
+                        time=llm_time
+                    )
+            else:
+                fix_result = fix_verification_errors(
+                    program=program_contents,
+                    prompt=prompt,
+                    code=code_contents,
+                    output=program_output,
+                    strength=strength,
+                    temperature=temperature,
+                    verbose=verbose,
+                    time=llm_time # Pass time
+                )
 
             # 4f: Add cost
             attempt_cost = fix_result.get('total_cost', 0.0)