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

pdd/continue_generation.py

@@ -11,9 +11,11 @@ from . import EXTRACTION_STRENGTH
 console = Console()
 
 class TrimResultsStartOutput(BaseModel):
+    explanation: str = Field(description="The explanation of how you determined what to cut out")
     code_block: str = Field(description="The trimmed code block from the start")
 
 class TrimResultsOutput(BaseModel):
+    explanation: str = Field(description="The explanation of the code block")
     trimmed_continued_generation: str = Field(description="The trimmed continuation of the generation")
 
 def continue_generation(
@@ -70,7 +72,7 @@ def continue_generation(
         trim_start_response = llm_invoke(
             prompt=processed_prompts['trim_start'],
             input_json={"LLM_OUTPUT": llm_output},
-            strength=0.8,
+            strength=0.75,
             temperature=0,
             output_pydantic=TrimResultsStartOutput,
             verbose=verbose

pdd/data/llm_model.csv

@@ -1,17 +1,18 @@
-provider,model,input,output,coding_arena_elo,base_url,api_key,counter,encoder,max_tokens,max_completion_tokens,structured_output
-OpenAI,"gpt-4.1-nano",0.1,0.40,1246,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"grok-3-beta",3,15,1255,"https://api.x.ai/v1",XAI_API_KEY,tiktoken,o200k_base,131072,,False
-Anthropic,"claude-3-5-haiku-20241022",1,5,1259,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,8192,,False
-OpenAI,"deepseek-coder",0.14,0.28,1279,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Google,"gemini-2.5-flash-preview-04-17",.15,3.5,1291,,GOOGLE_API_KEY,,,65535,,False
-GoogleVertexAI,"gemini-2.5-pro-exp-03-25",1.25,10,1299,,VERTEX_AI_API_KEY,,,65535,,False
-Anthropic,claude-3-7-sonnet-20250219,3,15,1312,,ANTHROPIC_API_KEY,anthropic,claude-3-sonnet-20240229,64000,,False
-Google,gemini-2.5-pro-exp-03-25,1.25,10,1313,,GOOGLE_API_KEY,,,65535,,False
-OpenAI,"deepseek-r1-distill-llama-70b-specdec",5,5,1314,https://api.groq.com/openai/v1,GROQ_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,16384,,False
-Ollama,"deepseek-r1:70b-llama-distill-q8_0",0.0,0.0,1315,,PWD,,,,,False
-Ollama,deepseek-r1:32b-qwen-distill-fp16,0.0,0.0,1316,,PWD,,,,,False
-OpenAI,"o4-mini",1.1,4.4,1319,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"o3",10,40,1331,,OPENAI_API_KEY,tiktoken,o200k_base,,100000,True
-OpenAI,"gpt-4.1",2,8,1332,,OPENAI_API_KEY,tiktoken,o200k_base,,32768,True
-OpenAI,"deepseek-reasoner",0.55,2.19,1336,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
-Fireworks,accounts/fireworks/models/deepseek-r1,3,8,1338,,FIREWORKS_API_KEY,,,8192,,False
+provider,model,input,output,coding_arena_elo,base_url,api_key,max_reasoning_tokens,structured_output,reasoning_type
+OpenAI,gpt-4.1-nano,0.1,0.4,1249,,OPENAI_API_KEY,0,True,none
+xai,xai/grok-3-beta,3.0,15.0,1332,https://api.x.ai/v1,XAI_API_KEY,0,False,none
+Anthropic,claude-3-5-haiku-20241022,.8,4,1261,,ANTHROPIC_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-chat,.27,1.1,1353,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Google,vertex_ai/gemini-2.5-flash-preview-04-17,0.15,0.6,1330,,VERTEX_CREDENTIALS,0,True,effort
+Google,gemini-2.5-pro-exp-03-25,1.25,10.0,1360,,GOOGLE_API_KEY,0,True,none
+Anthropic,claude-3-7-sonnet-20250219,3.0,15.0,1340,,ANTHROPIC_API_KEY,64000,True,budget
+Google,vertex_ai/gemini-2.5-pro-preview-05-06,1.25,10.0,1361,,VERTEX_CREDENTIALS,0,True,none
+OpenAI,o4-mini,1.1,4.4,1333,,OPENAI_API_KEY,0,True,effort
+OpenAI,o3,10.0,40.0,1389,,OPENAI_API_KEY,0,True,effort
+OpenAI,gpt-4.1,2.0,8.0,1335,,OPENAI_API_KEY,0,True,none
+OpenAI,deepseek/deepseek-reasoner,0.55,2.19,1337,https://api.deepseek.com/beta,DEEPSEEK_API_KEY,0,False,none
+Fireworks,fireworks_ai/accounts/fireworks/models/deepseek-r1,3.0,8.0,1338,,FIREWORKS_API_KEY,0,False,none
+OpenAI,chatgpt-4o-latest,5,15,1369,,OPENAI_API_KEY,0,False,none
+Anthropic,bedrock/us.anthropic.claude-3-7-sonnet-20250219-v1:0,3.0,15.0,1339,,,64000,True,budget
+OpenAI,azure/o4-mini,1.1,4.4,1334,,OPENAI_API_KEY,0,True,effort
+OpenAI,openai/mlx-community/Qwen3-30B-A3B-4bit,0,0,1293,http://localhost:8080,,0,False,none

pdd/fix_main.py

@@ -289,6 +289,7 @@ def fix_main(
                  rprint(f"[bold red]Markup Error in fix_main:[/bold red]")
                  rprint(escape(str(e)))
             else:
-                 # Print other errors normally (might still fail if they contain markup)
-                 rprint(f"[bold red]Error:[/bold red] {str(e)}")
+                 # Print other errors normally, escaping the error string
+                 from rich.markup import escape # Ensure escape is imported
+                 rprint(f"[bold red]Error:[/bold red] {escape(str(e))}")
         sys.exit(1)

pdd/fix_verification_errors.py

@@ -1,10 +1,22 @@
 import re
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 from rich import print as rprint
 from rich.markdown import Markdown
+from pydantic import BaseModel, Field
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
 
+# Define Pydantic model for structured LLM output for VERIFICATION
+class VerificationOutput(BaseModel):
+    issues_count: int = Field(description="The number of issues found during verification.")
+    details: Optional[str] = Field(description="Detailed explanation of any discrepancies or issues found. Can be null or empty if issues_count is 0.", default=None)
+
+# Define Pydantic model for structured LLM output for FIXES
+class FixerOutput(BaseModel):
+    explanation: str = Field(description="Detailed explanation of the analysis and fixes applied.")
+    fixed_code: str = Field(description="The complete, runnable, and fixed code module.")
+    fixed_program: str = Field(description="The complete, runnable, and fixed program that uses the code module.")
+
 def fix_verification_errors(
     program: str,
     prompt: str,
@@ -41,18 +53,17 @@ def fix_verification_errors(
     verification_issues_count = 0
     verification_details = None
     fix_explanation = None
-    fixed_program = program
-    fixed_code = code
+    fixed_program = program # Initialize with original program
+    fixed_code = code       # Initialize with original code
     final_explanation = None
 
     # Check only essential inputs, allow empty output
     if not all([program, prompt, code]):
-        # Keep the error print for program, prompt, code missing
         rprint("[bold red]Error:[/bold red] Missing one or more required inputs (program, prompt, code).")
         return {
             "explanation": None,
-            "fixed_program": program, # Return original if possible
-            "fixed_code": code,       # Return original if possible
+            "fixed_program": program,
+            "fixed_code": code,
             "total_cost": 0.0,
             "model_name": None,
             "verification_issues_count": 0,
@@ -104,14 +115,14 @@ def fix_verification_errors(
             input_json=verification_input_json,
             strength=strength,
             temperature=temperature,
-            verbose=False, # Keep internal llm_invoke verbose off unless needed
+            verbose=False,
+            output_pydantic=VerificationOutput
         )
         total_cost += verification_response.get('cost', 0.0)
         model_name = verification_response.get('model_name', model_name)
-        verification_result = verification_response.get('result', '')
 
         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}")
 
@@ -123,73 +134,97 @@ def fix_verification_errors(
             "fixed_code": code,
             "total_cost": total_cost,
             "model_name": model_name,
-            "verification_issues_count": verification_issues_count,
+            "verification_issues_count": 0, # Reset on LLM call error
         }
 
-    if verbose:
-        rprint("\n[blue]Verification Result:[/blue]")
-        # Markdown object handles its own rendering, no extra needed here
-        rprint(Markdown(verification_result))
-
     issues_found = False
-    try:
-        # Attempt to match and extract digits directly
-        count_match = re.search(r"<issues_count>(\d+)</issues_count>", verification_result)
-        if count_match:
-            verification_issues_count = int(count_match.group(1)) # Safe due to \d+
-        else:
-            # Specific match failed, check if tag exists with invalid content or is missing
-            generic_count_match = re.search(r"<issues_count>(.*?)</issues_count>", verification_result, re.DOTALL)
-            if generic_count_match:
-                # Tag found, but content is not \d+ -> Parsing Error
-                rprint("[bold red]Error:[/bold red] Could not parse integer value from <issues_count> tag.")
-                # Return the specific error structure for parsing errors after verification call
-                return {
-                    "explanation": None,
-                    "fixed_program": program,
-                    "fixed_code": code,
-                    "total_cost": total_cost, # Cost incurred so far
-                    "model_name": model_name, # Model used so far
-                    "verification_issues_count": 0, # Reset count on parsing error
-                }
+    verification_result_obj = verification_response.get('result')
+
+    if isinstance(verification_result_obj, VerificationOutput):
+        verification_issues_count = verification_result_obj.issues_count
+        verification_details = verification_result_obj.details
+        if verbose:
+            rprint("[green]Successfully parsed structured output from verification LLM.[/green]")
+            rprint("\n[blue]Verification Result (parsed):[/blue]")
+            rprint(f"  Issues Count: {verification_issues_count}")
+            if verification_details:
+                rprint(Markdown(f"**Details:**\n{verification_details}"))
             else:
-                # Tag truly not found -> Warning
-                rprint("[yellow]Warning:[/yellow] Could not find <issues_count> tag in verification result. Assuming 0 issues.")
-                verification_issues_count = 0
+                rprint("  Details: None provided or no issues found.")
 
-        # Proceed to check for details tag if count > 0
         if verification_issues_count > 0:
-            details_match = re.search(r"<details>(.*?)</details>", verification_result, re.DOTALL)
-            if details_match:
-                verification_details = details_match.group(1).strip()
-                if verification_details:
-                    issues_found = True
-                    if verbose:
-                        rprint(f"\n[yellow]Found {verification_issues_count} potential issues. Proceeding to fix step.[/yellow]")
-                else:
-                    # Count > 0, but details empty -> Warning
-                    rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but <details> tag is empty. Treating as no issues found.")
-                    verification_issues_count = 0 # Reset count
+            if verification_details and verification_details.strip():
+                issues_found = True
+                if verbose:
+                    rprint(f"\n[yellow]Found {verification_issues_count} potential issues. Proceeding to fix step.[/yellow]")
             else:
-                # Count > 0, but no details tag -> Warning
-                rprint("[yellow]Warning:[/yellow] <issues_count> is > 0, but could not find <details> tag. Treating as no issues found.")
-                verification_issues_count = 0 # Reset count
+                rprint(f"[yellow]Warning:[/yellow] <issues_count> is {verification_issues_count}, but <details> field is empty or missing. Treating as no actionable issues found.")
+                verification_issues_count = 0
         else:
-            # verification_issues_count is 0 (either parsed as 0 or defaulted after warning)
             if verbose:
-                rprint("\n[green]No issues found during verification.[/green]")
+                rprint("\n[green]No issues found during verification based on structured output.[/green]")
+    elif isinstance(verification_result_obj, str):
+        try:
+            issues_match = re.search(r'<issues_count>(\d+)</issues_count>', verification_result_obj)
+            if issues_match:
+                parsed_issues_count = int(issues_match.group(1))
+                details_match = re.search(r'<details>(.*?)</details>', verification_result_obj, re.DOTALL)
+                parsed_verification_details = details_match.group(1).strip() if (details_match and details_match.group(1)) else None
 
-    # Removed ValueError catch as it's handled by the logic above
-    except Exception as e:
-        # Generic catch for other potential parsing issues
-        rprint(f"[bold red]Error parsing verification result:[/bold red] {e}")
+
+                if parsed_issues_count > 0:
+                    if parsed_verification_details: # Check if details exist and are not empty
+                        issues_found = True
+                        verification_issues_count = parsed_issues_count
+                        verification_details = parsed_verification_details
+                        if verbose:
+                            rprint(f"\n[yellow]Found {verification_issues_count} potential issues in string response. Proceeding to fix step.[/yellow]")
+                    else:
+                        rprint(f"[yellow]Warning:[/yellow] <issues_count> is {parsed_issues_count} in string response, but <details> field is empty or missing. Treating as no actionable issues found.")
+                        verification_issues_count = 0
+                        issues_found = False
+                else: # parsed_issues_count == 0
+                    verification_issues_count = 0
+                    issues_found = False
+                    if verbose:
+                         rprint("\n[green]No issues found in string verification based on <issues_count> being 0.[/green]")
+            else: # issues_match is None (tag not found or content not digits)
+                rprint("[bold red]Error:[/bold red] Could not find or parse integer value from <issues_count> tag in string response.")
+                return {
+                    "explanation": None,
+                    "fixed_program": program,
+                    "fixed_code": code,
+                    "total_cost": total_cost,
+                    "model_name": model_name,
+                    "verification_issues_count": 0,
+                }
+        except ValueError: # Should not be hit if regex is \d+, but as a safeguard
+            rprint("[bold red]Error:[/bold red] Invalid non-integer value in <issues_count> tag in string response.")
+            return {
+                "explanation": None,
+                "fixed_program": program,
+                "fixed_code": code,
+                "total_cost": total_cost,
+                "model_name": model_name,
+                "verification_issues_count": 0,
+            }
+    else: # Not VerificationOutput and not a successfully parsed string
+        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)
+        rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
+        raw_text = verification_response.get('result_text')
+        if raw_text:
+            raw_text_str = str(raw_text)
+            rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
         return {
             "explanation": None,
             "fixed_program": program,
             "fixed_code": code,
             "total_cost": total_cost,
             "model_name": model_name,
-            "verification_issues_count": 0, # Reset count on parsing error
+            "verification_issues_count": 0,
         }
 
     if issues_found and verification_details:
@@ -210,71 +245,81 @@ def fix_verification_errors(
                 input_json=fix_input_json,
                 strength=strength,
                 temperature=temperature,
-                verbose=False, # Keep internal llm_invoke verbose off unless needed
+                verbose=False,
+                output_pydantic=FixerOutput
             )
             total_cost += fix_response.get('cost', 0.0)
-            model_name = fix_response.get('model_name', model_name) # Update model name to the last one used
-            fix_result = fix_response.get('result', '')
+            model_name = fix_response.get('model_name', model_name)
 
             if verbose:
                 rprint(f"[cyan]Fix LLM call complete.[/cyan]")
                 rprint(f"  [dim]Model Used:[/dim] {fix_response.get('model_name', 'N/A')}")
                 rprint(f"  [dim]Cost:[/dim] ${fix_response.get('cost', 0.0):.6f}")
-                rprint("\n[blue]Fix Result:[/blue]")
-                # Markdown object handles its own rendering, no extra needed here
-                rprint(Markdown(fix_result))
 
-            fixed_program_match = re.search(r"<fixed_program>(.*?)</fixed_program>", fix_result, re.DOTALL)
-            fixed_code_match = re.search(r"<fixed_code>(.*?)</fixed_code>", fix_result, re.DOTALL)
-            explanation_match = re.search(r"<explanation>(.*?)</explanation>", fix_result, re.DOTALL)
+            fix_result_obj = fix_response.get('result')
+            parsed_fix_successfully = False
 
-            if fixed_program_match:
-                fixed_program = fixed_program_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fixed program.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <fixed_program> tag in fix result. Using original program.")
+            if isinstance(fix_result_obj, FixerOutput):
+                fixed_program = fix_result_obj.fixed_program
+                fixed_code = fix_result_obj.fixed_code
+                fix_explanation = fix_result_obj.explanation
+                parsed_fix_successfully = True
+                if verbose:
+                    rprint("[green]Successfully parsed structured output for fix.[/green]")
+                    rprint(Markdown(f"**Explanation from LLM:**\n{fix_explanation}"))
+            elif isinstance(fix_result_obj, str):
+                program_match = re.search(r'<fixed_program>(.*?)</fixed_program>', fix_result_obj, re.DOTALL)
+                code_match = re.search(r'<fixed_code>(.*?)</fixed_code>', fix_result_obj, re.DOTALL)
+                explanation_match = re.search(r'<explanation>(.*?)</explanation>', fix_result_obj, re.DOTALL)
 
-            if fixed_code_match:
-                fixed_code = fixed_code_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fixed code module.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <fixed_code> tag in fix result. Using original code module.")
+                if program_match or code_match or explanation_match: # If any tag is found, attempt to parse
+                    fixed_program_candidate = program_match.group(1).strip() if (program_match and program_match.group(1)) else None
+                    fixed_code_candidate = code_match.group(1).strip() if (code_match and code_match.group(1)) else None
+                    fix_explanation_candidate = explanation_match.group(1).strip() if (explanation_match and explanation_match.group(1)) else None
 
-            if explanation_match:
-                fix_explanation = explanation_match.group(1).strip()
-                if verbose: rprint("[green]Extracted fix explanation.[/green]")
-            else:
-                if verbose: rprint("[yellow]Warning:[/yellow] Could not find <explanation> tag in fix result.")
-                fix_explanation = "[Fix explanation not provided by LLM]"
+                    fixed_program = fixed_program_candidate if fixed_program_candidate else program
+                    fixed_code = fixed_code_candidate if fixed_code_candidate else code
+                    fix_explanation = fix_explanation_candidate if fix_explanation_candidate else "[Fix explanation not provided by LLM]"
+                    parsed_fix_successfully = True
+
+                    if verbose:
+                        if not program_match or not fixed_program_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_program> tag in fix result string. Using original program.")
+                        if not code_match or not fixed_code_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <fixed_code> tag in fix result string. Using original code module.")
+                        if not explanation_match or not fix_explanation_candidate:
+                            rprint("[yellow]Warning:[/yellow] Could not find or parse <explanation> tag in fix result string. Using default explanation.")
+                # else: string, but no relevant tags. Will fall to parsed_fix_successfully = False below
+
+            if not parsed_fix_successfully:
+                rprint(f"[bold red]Error:[/bold red] Fix generation LLM call did not return the expected structured output (e.g., parsing failed).")
+                rprint(f"  [dim]Expected type:[/dim] {FixerOutput} or str (with XML tags)")
+                rprint(f"  [dim]Received type:[/dim] {type(fix_result_obj)}")
+                content_str = str(fix_result_obj)
+                rprint(f"  [dim]Received content:[/dim] {content_str[:500]}{'...' if len(content_str) > 500 else ''}")
+                raw_text = fix_response.get('result_text')
+                if raw_text:
+                    raw_text_str = str(raw_text)
+                    rprint(f"  [dim]Raw LLM text (if available from llm_invoke):[/dim] {raw_text_str[:500]}{'...' if len(raw_text_str) > 500 else ''}")
+                fix_explanation = "[Error: Failed to parse structured output from LLM for fix explanation]"
+                # fixed_program and fixed_code remain original (already initialized)
 
         except Exception as e:
-            rprint(f"[bold red]Error during fix LLM call or extraction:[/bold red] {e}")
-            # Combine verification details with the error message if fix failed
-            final_explanation = f"<error>Error during fix generation: {str(e)}</error>\n"
-            if verification_details:
-                fix_explanation = f"[Error during fix generation: {e}]"
-            # Note: verification_issues_count should retain its value from the verification step
+            rprint(f"[bold red]Error during fix LLM call or processing structured output:[/bold red] {e}")
+            fix_explanation = f"[Error during fix generation: {e}]"
+            # fixed_program and fixed_code remain original
+
+    if issues_found:
+        final_explanation = (
+            f"<verification_details>{verification_details}</verification_details>\n"
+            f"<fix_explanation>{fix_explanation}</fix_explanation>"
+        )
+    else:
+        final_explanation = None # Or "" if an empty list/None is preferred per prompt for "no issues"
 
     if verbose:
         rprint(f"\n[bold blue]Total Cost for fix_verification_errors run:[/bold blue] ${total_cost:.6f}")
 
-    # Construct final explanation only if issues were initially found and processed
-    if verification_details:
-        if fix_explanation:
-             final_explanation = (
-                 f"<verification_details>{verification_details}</verification_details>\n"
-                 f"<fix_explanation>{fix_explanation}</fix_explanation>"
-             )
-        else:
-             # This case might occur if fix step wasn't run due to parsing issues after verification,
-             # or if fix_explanation extraction failed silently (though we added a default).
-             # Let's ensure we always provide some context if details were found.
-             final_explanation = (
-                 f"<verification_details>{verification_details}</verification_details>\n"
-                 f"<fix_explanation>[Fix explanation not available or fix step skipped]</fix_explanation>"
-             )
-    # If no issues were found initially (verification_details is None), final_explanation remains None
-
     return {
         "explanation": final_explanation,
         "fixed_program": fixed_program,
@@ -282,4 +327,4 @@ def fix_verification_errors(
         "total_cost": total_cost,
         "model_name": model_name,
         "verification_issues_count": verification_issues_count,
-    }
+    }

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