pdd-cli 0.0.26__py3-none-any.whl → 0.0.27__py3-none-any.whl

pdd/fix_verification_errors.py

@@ -122,7 +122,7 @@ def fix_verification_errors(
         model_name = verification_response.get('model_name', model_name)
 
         if verbose:
-            rprint(f"[cyan]Verification LLM call complete.[/cyan]")
+            rprint("[cyan]Verification LLM call complete.[/cyan]")
             rprint(f"  [dim]Model Used:[/dim] {verification_response.get('model_name', 'N/A')}")
             rprint(f"  [dim]Cost:[/dim] ${verification_response.get('cost', 0.0):.6f}")
 
@@ -209,7 +209,7 @@ def fix_verification_errors(
                 "verification_issues_count": 0,
             }
     else: # Not VerificationOutput and not a successfully parsed string
-        rprint(f"[bold red]Error:[/bold red] Verification LLM call did not return the expected structured output (e.g., parsing failed).")
+        rprint("[bold red]Error:[/bold red] Verification LLM call did not return the expected structured output (e.g., parsing failed).")
         rprint(f"  [dim]Expected type:[/dim] {VerificationOutput} or str")
         rprint(f"  [dim]Received type:[/dim] {type(verification_result_obj)}")
         content_str = str(verification_result_obj)

pdd/fix_verification_errors_loop.py

@@ -86,6 +86,8 @@ def fix_verification_errors_loop(
     max_attempts: int,
     budget: float,
     verification_log_file: str = "verification.log",
+    output_code_path: Optional[str] = None,
+    output_program_path: Optional[str] = None,
     verbose: bool = False,
     program_args: Optional[list[str]] = None,
 ) -> Dict[str, Any]:
@@ -103,6 +105,8 @@ def fix_verification_errors_loop(
         max_attempts: Maximum number of fix attempts.
         budget: Maximum allowed cost in USD.
         verification_log_file: Path for detailed XML logging (default: "verification.log").
+        output_code_path: Optional path to save fixed code (default: None).
+        output_program_path: Optional path to save fixed program (default: None).
         verbose: Enable verbose logging (default: False).
         program_args: Optional list of command-line arguments for the program_file.
 
@@ -423,7 +427,7 @@ def fix_verification_errors_loop(
                 output=program_output,
                 strength=strength,
                 temperature=temperature,
-                verbose=verbose # Pass verbose flag down
+                verbose=verbose
             )
 
             # 4f: Add cost

pdd/fix_verification_main.py

@@ -88,6 +88,7 @@ def fix_verification_main(
     program_file: str,
     output_results: Optional[str],
     output_code: Optional[str],
+    output_program: Optional[str],
     loop: bool,
     verification_program: Optional[str],  # Only used if loop=True
     max_attempts: int = DEFAULT_MAX_ATTEMPTS,
@@ -105,6 +106,7 @@ def fix_verification_main(
         program_file (str): Path to the program to run for verification.
         output_results (Optional[str]): Path to save verification results log.
         output_code (Optional[str]): Path to save the verified code file.
+        output_program (Optional[str]): Path to save the verified program file.
         loop (bool): If True, perform iterative verification and fixing.
         verification_program (Optional[str]): Path to a verification program (required if loop=True).
         max_attempts (int): Max attempts for the loop.
@@ -161,12 +163,14 @@ def fix_verification_main(
     command_options: Dict[str, Optional[str]] = {
         "output_results": output_results,
         "output_code": output_code,
+        "output_program": output_program,
     }
 
     # Initial default values (in case we need the manual fallback)
     input_strings: Dict[str, str] = {}
     output_code_path: Optional[str] = output_code
     output_results_path: Optional[str] = output_results
+    output_program_path: Optional[str] = output_program
     language: str = ""
 
     try:
@@ -180,6 +184,7 @@ def fix_verification_main(
         )
         output_code_path = output_file_paths.get("output_code")
         output_results_path = output_file_paths.get("output_results")
+        output_program_path = output_file_paths.get("output_program")
 
         if verbose:
             rich_print("[dim]Resolved output paths via construct_paths.[/dim]")
@@ -211,6 +216,9 @@ def fix_verification_main(
             if output_results_path is None:
                 base, _ = os.path.splitext(program_file)
                 output_results_path = f"{base}_verify_results.log"
+            if output_program_path is None:
+                base_prog, ext_prog = os.path.splitext(program_file)
+                output_program_path = f"{base_prog}_verified{ext_prog}"
 
             # Best‑effort language guess
             if program_file.endswith(".py"):
@@ -331,7 +339,7 @@ def fix_verification_main(
             model_name = fix_results['model_name']
 
             # Build results log content for single pass
-            results_log_content = f"PDD Verify Results (Single Pass)\n"
+            results_log_content = "PDD Verify Results (Single Pass)\n"
             results_log_content += f"Timestamp: {os.path.getmtime(prompt_file)}\n" # Use prompt timestamp as reference
             results_log_content += f"Prompt File: {prompt_file}\n"
             results_log_content += f"Code File: {code_file}\n"
@@ -361,6 +369,7 @@ def fix_verification_main(
     # --- Output File Writing ---
     saved_code_path: Optional[str] = None
     saved_results_path: Optional[str] = None
+    saved_program_path: Optional[str] = None
 
     if success and output_code_path:
         try:
@@ -372,6 +381,16 @@ def fix_verification_main(
         except IOError as e:
             rich_print(f"[bold red]Error:[/bold red] Failed to write verified code file '{output_code_path}': {e}")
 
+    if success and output_program_path:
+        try:
+            with open(output_program_path, "w") as f:
+                f.write(final_program)
+            saved_program_path = output_program_path
+            if not quiet:
+                rich_print(f"Successfully verified program saved to: [green]{output_program_path}[/green]")
+        except IOError as e:
+            rich_print(f"[bold red]Error:[/bold red] Failed to write verified program file '{output_program_path}': {e}")
+
     # Write results log (only for single pass, loop writes its own)
     if not loop and output_results_path:
         try:
@@ -398,6 +417,7 @@ def fix_verification_main(
             f"Total Cost: ${total_cost:.6f}\n"
             f"Model Used: {model_name}\n"
             f"Verified Code Saved: {saved_code_path or 'N/A'}\n"
+            f"Verified Program Saved: {saved_program_path or 'N/A'}\n"
             f"Results Log Saved: {saved_results_path or 'N/A'}",
             title=title,
             border_style="green" if success else "red"

pdd/generate_output_paths.py

@@ -25,7 +25,7 @@ COMMAND_OUTPUT_KEYS: Dict[str, List[str]] = {
     'trace': ['output'],
     'bug': ['output'],
     'auto-deps': ['output'],
-    'verify': ['output_results', 'output_code'],
+    'verify': ['output_results', 'output_code', 'output_program'],
 }
 
 # Define default filename patterns for each output key
@@ -61,6 +61,7 @@ DEFAULT_FILENAMES: Dict[str, Dict[str, str]] = {
     'verify': {
         'output_results': '{basename}_verify_results.log',
         'output_code': '{basename}_verified{ext}',
+        'output_program': '{basename}_program_verified{ext}',
     },
 }
 
@@ -93,6 +94,7 @@ ENV_VAR_MAP: Dict[str, Dict[str, str]] = {
     'verify': {
         'output_results': 'PDD_VERIFY_RESULTS_OUTPUT_PATH',
         'output_code': 'PDD_VERIFY_CODE_OUTPUT_PATH',
+        'output_program': 'PDD_VERIFY_PROGRAM_OUTPUT_PATH',
     },
 }
 
@@ -435,4 +437,43 @@ if __name__ == '__main__':
     # Expected: {
     #   'output_results': '/path/to/cwd/module_to_verify_verify_results.log',
     #   'output_code': '/path/to/cwd/module_to_verify_verified.py'
-    # }
+    #   'output_program': '/path/to/cwd/module_to_verify_program_verified.py'
+    # }
+
+    # --- Test Case 12: Verify command with user-specified output_program directory ---
+    print("\n--- Test Case 12: Verify (User Dir for output_program) ---")
+    test_dir_verify_prog = "temp_verify_prog_output"
+    os.makedirs(test_dir_verify_prog, exist_ok=True)
+    paths12 = generate_output_paths(
+        command='verify',
+        output_locations={'output_program': test_dir_verify_prog + os.path.sep},
+        basename="module_to_verify",
+        language="python",
+        file_extension=".py"
+    )
+    print(f"Result: {paths12}")
+    # Expected: {
+    #   'output_results': '/path/to/cwd/module_to_verify_verify_results.log',
+    #   'output_code': '/path/to/cwd/module_to_verify_verified.py',
+    #   'output_program': f'/path/to/cwd/{test_dir_verify_prog}/module_to_verify_program_verified.py'
+    # }
+    os.rmdir(test_dir_verify_prog) # Clean up
+
+    # --- Test Case 13: Verify command with environment variable for output_program ---
+    print("\n--- Test Case 13: Verify (Env Var for output_program) ---")
+    env_verify_prog_path = "env_verify_program_custom.py"
+    os.environ['PDD_VERIFY_PROGRAM_OUTPUT_PATH'] = env_verify_prog_path
+    paths13 = generate_output_paths(
+        command='verify',
+        output_locations={},
+        basename="another_module_verify",
+        language="python",
+        file_extension=".py"
+    )
+    print(f"Result: {paths13}")
+    # Expected: {
+    #   'output_results': '/path/to/cwd/another_module_verify_verify_results.log',
+    #   'output_code': '/path/to/cwd/another_module_verify_verified.py',
+    #   'output_program': f'/path/to/cwd/{env_verify_prog_path}'
+    # }
+    del os.environ['PDD_VERIFY_PROGRAM_OUTPUT_PATH'] # Clean up