pdd-cli 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

pdd/fix_verification_main.py

@@ -2,12 +2,14 @@ import sys
 import os
 import subprocess
 import click
+import logging
 from typing import Optional, Tuple, List, Dict, Any
 
 # Use Rich for pretty printing to the console
 from rich import print as rich_print
 from rich.panel import Panel
 from rich.syntax import Syntax
+from rich.text import Text
 
 # Internal imports using relative paths
 from .construct_paths import construct_paths
@@ -17,9 +19,15 @@ from .fix_verification_errors_loop import fix_verification_errors_loop
 from . import DEFAULT_STRENGTH
 
 # Default values from the README
+DEFAULT_TEMPERATURE = 0.0
 DEFAULT_MAX_ATTEMPTS = 3
 DEFAULT_BUDGET = 5.0
-DEFAULT_TEMPERATURE = 0.0
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Define a constant for the verification program name
+VERIFICATION_PROGRAM_NAME = "verification_program.py" # Example, adjust if needed
 
 def run_program(program_path: str, args: List[str] = []) -> Tuple[bool, str, str]:
     """
@@ -78,8 +86,8 @@ def run_program(program_path: str, args: List[str] = []) -> Tuple[bool, str, str
         rich_print(f"[bold red]Error:[/bold red] Program execution timed out: '{program_path}'")
         return False, "", f"Program execution timed out: {program_path}"
     except Exception as e:
-        rich_print(f"[bold red]Error:[/bold red] Failed to run program '{program_path}': {e}")
-        return False, "", f"Failed to run program: {e}"
+        logger.error(f"An unexpected error occurred while running {program_path}: {e}")
+        return False, "", f"An unexpected error occurred: {e}"
 
 def fix_verification_main(
     ctx: click.Context,
@@ -122,10 +130,9 @@ def fix_verification_main(
             - model_name (str): Name of the LLM used.
     """
     # Extract global options from context
-    # params = ctx.params # We need obj for global flags
-    strength: float = ctx.obj.get('strength', DEFAULT_STRENGTH) # Get globals from obj
+    strength: float = ctx.obj.get('strength', DEFAULT_STRENGTH)
     temperature: float = ctx.obj.get('temperature', DEFAULT_TEMPERATURE)
-    force: bool = ctx.obj.get('force', False) # <<< FIX: Get force from ctx.obj
+    force: bool = ctx.obj.get('force', False)
     quiet: bool = ctx.obj.get('quiet', False)
     verbose: bool = ctx.obj.get('verbose', False)
 
@@ -220,14 +227,9 @@ def fix_verification_main(
                 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"):
-                language = "python"
-            elif program_file.endswith(".js"):
-                language = "javascript"
-            elif program_file.endswith(".sh"):
-                language = "bash"
-
+            if program_file.endswith(".py"): language = "python"
+            elif program_file.endswith(".js"): language = "javascript"
+            elif program_file.endswith(".sh"): language = "bash"
         else:
             # Some other error – re‑raise / abort
             rich_print(f"[bold red]Error:[/bold red] Failed during path construction: {e}")
@@ -238,12 +240,12 @@ def fix_verification_main(
 
     # --- Core Logic ---
     success: bool = False
-    final_program: str = input_strings.get("program_file", "") # Initialize with input content
-    final_code: str = input_strings.get("code_file", "")     # Initialize with input content
+    final_program: str = input_strings.get("program_file", "")
+    final_code: str = input_strings.get("code_file", "")
     attempts: int = 0
     total_cost: float = 0.0
     model_name: str = "N/A"
-    results_log_content: str = "" # To store content for the results file
+    results_log_content: str = ""
 
     try:
         if loop:
@@ -258,19 +260,19 @@ def fix_verification_main(
             loop_results = fix_verification_errors_loop(
                 program_file=program_file,
                 code_file=code_file,
-                prompt=input_strings["prompt_file"], # Prompt content is needed
-                verification_program=verification_program, # Path is needed
+                prompt=input_strings["prompt_file"],
+                verification_program=verification_program,
                 strength=strength,
                 temperature=temperature,
                 max_attempts=max_attempts,
                 budget=budget,
-                verification_log_file=output_results_path, # Pass path for internal logging
+                verification_log_file=output_results_path,
                 verbose=verbose,
                 program_args=program_args
             )
             success = loop_results['success']
-            final_program = loop_results['final_program'] # Loop function returns final content
-            final_code = loop_results['final_code']       # Loop function returns final content
+            final_program = loop_results['final_program']
+            final_code = loop_results['final_code']
             attempts = loop_results['total_attempts']
             total_cost = loop_results['total_cost']
             model_name = loop_results['model_name']
@@ -300,12 +302,11 @@ def fix_verification_main(
             # 2. Call fix_verification_errors with content and program output
             if not quiet:
                 rich_print("Calling LLM to verify program output against prompt...")
-
             fix_results = fix_verification_errors(
                 program=input_strings["program_file"],
                 prompt=input_strings["prompt_file"],
                 code=input_strings["code_file"],
-                output=program_output, # Pass the captured output
+                output=program_output,
                 strength=strength,
                 temperature=temperature,
                 verbose=verbose
@@ -319,19 +320,15 @@ def fix_verification_main(
 
             if not issues_found:
                 success = True
-                if not quiet:
-                    rich_print("[green]Verification Passed:[/green] LLM found no discrepancies.")
+                if not quiet: rich_print("[green]Verification Passed:[/green] LLM found no discrepancies.")
             elif code_updated or program_updated:
                  # If issues were found AND fixes were made, assume success for this single pass.
                  # A more robust check might re-run the program with fixed code, but that's the loop's job.
                  success = True
-                 if not quiet:
-                     rich_print("[yellow]Verification Issues Found:[/yellow] LLM proposed fixes.")
+                 if not quiet: rich_print("[yellow]Verification Issues Found:[/yellow] LLM proposed fixes.")
             else:
-                 success = False # Issues found, but no fixes proposed
-                 if not quiet:
-                     rich_print("[red]Verification Failed:[/red] LLM found discrepancies but proposed no fixes.")
-
+                 success = False
+                 if not quiet: rich_print("[red]Verification Failed:[/red] LLM found discrepancies but proposed no fixes.")
 
             final_program = fix_results['fixed_program']
             final_code = fix_results['fixed_code']
@@ -340,7 +337,7 @@ def fix_verification_main(
 
             # Build results log content for single pass
             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"Timestamp: {os.path.getmtime(prompt_file)}\n"
             results_log_content += f"Prompt File: {prompt_file}\n"
             results_log_content += f"Code File: {code_file}\n"
             results_log_content += f"Program File: {program_file}\n"
@@ -371,27 +368,46 @@ def fix_verification_main(
     saved_results_path: Optional[str] = None
     saved_program_path: Optional[str] = None
 
-    if success and output_code_path:
+    if verbose:
+        rich_print(f"[cyan bold DEBUG] In fix_verification_main, BEFORE save attempt for CODE:")
+        rich_print(f"  success: {success}")
+        rich_print(f"  output_code_path: {output_code_path!r}")
+        rich_print(f"  final_code is None: {final_code is None}")
+        if final_code is not None:
+            rich_print(f"  len(final_code): {len(final_code)}")
+
+    if success and output_code_path and final_code is not None:
         try:
+            if verbose:
+                rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write code to: {output_code_path!r}")
             with open(output_code_path, "w") as f:
                 f.write(final_code)
             saved_code_path = output_code_path
             if not quiet:
                 rich_print(f"Successfully verified code saved to: [green]{output_code_path}[/green]")
-        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:
+        except Exception as e:
+            rich_print(f"[bold red]Error:[/bold red] Failed to write code file '{output_code_path}': {type(e).__name__} - {e}")
+
+    if verbose:
+        rich_print(f"[cyan bold DEBUG] In fix_verification_main, BEFORE save attempt for PROGRAM:")
+        rich_print(f"  success: {success}")
+        rich_print(f"  output_program_path: {output_program_path!r}")
+        rich_print(f"  final_program is None: {final_program is None}")
+        if final_program is not None:
+            rich_print(f"  len(final_program): {len(final_program)}")
+
+    if success and output_program_path and final_program is not None:
         try:
+            if verbose:
+                rich_print(f"[cyan bold DEBUG] In fix_verification_main, ATTEMPTING to write program to: {output_program_path!r}")
             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}")
+        except Exception as e:
+            rich_print(f"[bold red]Error:[/bold red] Failed to write program file '{output_program_path}': {type(e).__name__} - {e}")
 
-    # Write results log (only for single pass, loop writes its own)
     if not loop and output_results_path:
         try:
             with open(output_results_path, "w") as f:
@@ -405,28 +421,40 @@ def fix_verification_main(
         # For loop, just confirm the path where the loop function *should* have saved the log
         saved_results_path = output_results_path
         if not quiet:
-            rich_print(f"Verification results log (from loop) should be at: [green]{output_results_path}[/green]")
+            # We assume fix_verification_errors_loop handles its own logging confirmation.
+            # This message confirms the path was passed.
+            rich_print(f"Verification results log (from loop) expected at: [green]{output_results_path}[/green]")
+
 
     # --- Final User Feedback ---
+    if verbose:
+        rich_print(f"[cyan bold DEBUG] Before summary - saved_code_path: {saved_code_path!r}, output_code_path: {output_code_path!r}[/cyan bold DEBUG]")
+        rich_print(f"[cyan bold DEBUG] Before summary - saved_program_path: {saved_program_path!r}, output_program_path: {output_program_path!r}[/cyan bold DEBUG]")
+
     if not quiet:
         rich_print("\n" + "="*40)
         title = "[bold green]Verification Complete[/bold green]" if success else "[bold red]Verification Failed[/bold red]"
-        summary_panel = Panel(
+        summary_panel_content = (
             f"Status: {'[green]Success[/green]' if success else '[red]Failure[/red]'}\n"
             f"Attempts: {attempts}\n"
             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'}",
+            f"Verified Code Saved: {saved_code_path or 'N/A (Not saved on failure or no path)'}\n"
+            f"Verified Program Saved: {saved_program_path or 'N/A (Not saved on failure or no path)'}\n"
+            f"Results Log Saved: {saved_results_path or 'N/A'}"
+        )
+        summary_panel = Panel(
+            summary_panel_content,
             title=title,
             border_style="green" if success else "red"
         )
         rich_print(summary_panel)
 
-        if verbose and not success and not loop:
-             rich_print("[bold yellow]Final Code (after failed single pass):[/bold yellow]")
+        if verbose and not success and not loop: # Only show final code if verbose, failed, and single pass
+             rich_print("[bold yellow]Final Code (after failed single pass, not saved):[/bold yellow]")
              rich_print(Syntax(final_code, language or "python", theme="default", line_numbers=True))
+             rich_print("[bold yellow]Final Program (after failed single pass, not saved):[/bold yellow]")
+             rich_print(Syntax(final_program, language or "python", theme="default", line_numbers=True))
 
 
     return success, final_program, final_code, attempts, total_cost, model_name

pdd/incremental_code_generator.py

@@ -0,0 +1,198 @@
+from typing import Optional, Tuple
+from pydantic import BaseModel, Field
+from rich.console import Console
+from rich.markdown import Markdown
+
+from .llm_invoke import llm_invoke
+from .load_prompt_template import load_prompt_template
+from .preprocess import preprocess
+from . import DEFAULT_STRENGTH # Removed unused EXTRACTION_STRENGTH
+
+console = Console()
+
+# Pydantic models for structured output
+class DiffAnalysis(BaseModel):
+    is_big_change: bool = Field(description="Whether the change is considered significant enough to require full regeneration")
+    change_description: str = Field(description="A description of the changes between the original and new prompts")
+    analysis: str = Field(description="Detailed analysis of the differences and recommendation")
+
+class CodePatchResult(BaseModel):
+    patched_code: str = Field(description="The updated code with incremental patches applied")
+    analysis: str = Field(description="Analysis of the patching process")
+    planned_modifications: str = Field(description="Description of the modifications planned and applied")
+
+def incremental_code_generator(
+    original_prompt: str,
+    new_prompt: str,
+    existing_code: str,
+    language: str,
+    strength: float = DEFAULT_STRENGTH,
+    temperature: float = 0.0,
+    time: float = 0.25,
+    force_incremental: bool = False,
+    verbose: bool = False,
+    preprocess_prompt: bool = True
+) -> Tuple[Optional[str], bool, float, str]:
+    """
+    Analyzes changes to a prompt and either incrementally patches existing code or suggests full regeneration.
+    
+    Args:
+        original_prompt (str): The original prompt used to generate the existing code.
+        new_prompt (str): The updated prompt that needs to be processed.
+        existing_code (str): The existing code generated from the original prompt.
+        language (str): The programming language of the output code (e.g., 'python', 'bash').
+        strength (float): Strength parameter for the LLM model (0 to 1). Defaults to DEFAULT_STRENGTH.
+        temperature (float): Temperature parameter for randomness in LLM output (0 to 1). Defaults to 0.0.
+        time (float): Thinking time or reasoning effort for the LLM model (0 to 1). Defaults to 0.25.
+        force_incremental (bool): Forces incremental patching even if full regeneration is suggested. Defaults to False.
+        verbose (bool): If True, prints detailed information about the process. Defaults to False.
+        preprocess_prompt (bool): If True, preprocesses the prompt before invocation. Defaults to True.
+    
+    Returns:
+        Tuple[Optional[str], bool, float, str]: A tuple containing:
+            - updated_code (Optional[str]): The updated code if incremental patching is applied, None if full regeneration is needed.
+            - is_incremental (bool): True if incremental patching was applied, False if full regeneration is needed.
+            - total_cost (float): The total cost of all LLM invocations.
+            - model_name (str): The name of the LLM model used for the main operation.
+    """
+    # Validate inputs (moved outside the main try-except block)
+    if not original_prompt or not new_prompt or not existing_code or not language:
+        raise ValueError("All required inputs (original_prompt, new_prompt, existing_code, language) must be provided.")
+
+    if not 0 <= strength <= 1 or not 0 <= temperature <= 1 or not 0 <= time <= 1:
+        raise ValueError("Strength, temperature, and time must be between 0 and 1.")
+
+    try:
+        total_cost = 0.0
+        model_name = ""
+
+        # Step 1: Load and preprocess the diff_analyzer_LLM prompt template
+        diff_analyzer_template = load_prompt_template("diff_analyzer_LLM")
+        if preprocess_prompt:
+            diff_analyzer_template = preprocess(
+                diff_analyzer_template,
+                recursive=False,
+                double_curly_brackets=True,
+                exclude_keys=["ORIGINAL_PROMPT", "NEW_PROMPT", "EXISTING_CODE"]
+            )
+
+        if verbose:
+            console.print("[bold cyan]Step 1: Loaded diff_analyzer_LLM template[/bold cyan]")
+
+        # Step 2: Run diff_analyzer_LLM through llm_invoke
+        input_json = {
+            "ORIGINAL_PROMPT": original_prompt,
+            "NEW_PROMPT": new_prompt,
+            "EXISTING_CODE": existing_code
+        }
+        diff_response = llm_invoke(
+            prompt=diff_analyzer_template,
+            input_json=input_json,
+            strength=strength,
+            temperature=temperature,
+            time=time,
+            verbose=verbose,
+            output_pydantic=DiffAnalysis
+        )
+        diff_result: DiffAnalysis = diff_response['result']
+        total_cost += diff_response['cost']
+        model_name = diff_response['model_name'] # Initial model name
+
+        if verbose:
+            console.print("[bold green]Diff Analyzer Results:[/bold green]")
+            console.print(f"Is Big Change: {diff_result.is_big_change}")
+            console.print(Markdown(f"**Analysis:**\n{diff_result.analysis}"))
+            console.print(f"Cost so far: ${total_cost:.6f}")
+
+        # Step 3: Determine whether to use incremental patching or full regeneration
+        should_regenerate = not force_incremental and diff_result.is_big_change
+
+        if verbose and force_incremental and diff_result.is_big_change:
+            console.print("[bold yellow]Forcing incremental patching despite major change detection[/bold yellow]")
+
+        # Step 4: Handle regeneration or incremental patching
+        if should_regenerate:
+            if verbose:
+                console.print("[bold red]Major change detected. Recommending full regeneration.[/bold red]")
+            return None, False, total_cost, model_name
+        else:
+            # Load and preprocess the code_patcher_LLM prompt template
+            patcher_template = load_prompt_template("code_patcher_LLM")
+            if preprocess_prompt:
+                patcher_template = preprocess(
+                    patcher_template,
+                    recursive=False,
+                    double_curly_brackets=True,
+                    exclude_keys=["ORIGINAL_PROMPT", "NEW_PROMPT", "EXISTING_CODE", "CHANGE_DESCRIPTION"]
+                )
+
+            if verbose:
+                console.print("[bold cyan]Step 4: Loaded code_patcher_LLM template for incremental patching[/bold cyan]")
+
+            # Run code_patcher_LLM through llm_invoke
+            patch_input_json = {
+                "ORIGINAL_PROMPT": original_prompt,
+                "NEW_PROMPT": new_prompt,
+                "EXISTING_CODE": existing_code,
+                "CHANGE_DESCRIPTION": diff_result.change_description
+            }
+            patch_response = llm_invoke(
+                prompt=patcher_template,
+                input_json=patch_input_json,
+                strength=strength,
+                temperature=temperature,
+                time=time,
+                verbose=verbose,
+                output_pydantic=CodePatchResult
+            )
+            patch_result: CodePatchResult = patch_response['result']
+            total_cost += patch_response['cost']
+            model_name = patch_response['model_name'] # Update model_name to patcher's model
+
+            if verbose:
+                console.print("[bold green]Code Patcher Results:[/bold green]")
+                console.print(Markdown(f"**Analysis:**\n{patch_result.analysis}"))
+                console.print(Markdown(f"**Planned Modifications:**\n{patch_result.planned_modifications}"))
+                console.print(f"Total Cost: ${total_cost:.6f}")
+
+            return patch_result.patched_code, True, total_cost, model_name
+
+    except Exception as e:
+        # This will now catch errors from LLM calls or other unexpected runtime issues,
+        # not the initial input validation ValueErrors.
+        console.print(f"[bold red]Error in incremental_code_generator: {str(e)}[/bold red]")
+        raise RuntimeError(f"Failed to process incremental code generation: {str(e)}")
+
+if __name__ == "__main__":
+    # Example usage for testing purposes
+    try:
+        original_prompt = "Write a Python function to calculate the factorial of a number."
+        new_prompt = "Write a Python function to calculate the factorial of a number with input validation."
+        existing_code = """
+def factorial(n):
+    if n == 0 or n == 1:
+        return 1
+    return n * factorial(n - 1)
+"""
+        language = "python"
+        updated_code, is_incremental, total_cost, model_name = incremental_code_generator(
+            original_prompt=original_prompt,
+            new_prompt=new_prompt,
+            existing_code=existing_code,
+            language=language,
+            strength=DEFAULT_STRENGTH,
+            temperature=0.0,
+            time=0.25,
+            force_incremental=False,
+            verbose=True
+        )
+        console.print("[bold magenta]Final Results:[/bold magenta]")
+        if is_incremental:
+            console.print("[bold green]Incremental Patch Applied[/bold green]")
+            console.print(Markdown(f"**Updated Code:**\n```python\n{updated_code}\n```"))
+        else:
+            console.print("[bold red]Full Regeneration Recommended[/bold red]")
+        console.print(f"Total Cost: ${total_cost:.6f}")
+        console.print(f"Model Used: {model_name}")
+    except Exception as e:
+        console.print(f"[bold red]Test Error: {str(e)}[/bold red]")

pdd/prompts/code_patcher_LLM.prompt

@@ -0,0 +1,63 @@
+% You are an expert code patcher, tasked with incrementally updating existing code based on changes between two prompts.
+
+% Given:
+    - The original prompt used to generate code
+    - A new, updated prompt
+    - The existing code generated from the original prompt
+    - A description of the changes needed to update the code
+% Your task is to:
+    1. Apply the necessary changes to the existing code while maintaining its overall structure
+    2. Make only the modifications required to address the changes between the prompts
+    3. Ensure the updated code is complete, correct, and meets all requirements in the new prompt
+    4. Preserve the style, variable naming conventions, and organization of the original code
+
+% Output a JSON object with:
+    - analysis: string - a detailed analysis of the changes needed
+    - planned_modifications: string - a detailed description of the modifications needed and why this change should not break the existing code
+    - patched_code: string - the complete updated code after applying all necessary changes
+
+ORIGINAL_PROMPT:
+<original_prompt>
+{ORIGINAL_PROMPT}
+</original_prompt>
+
+NEW_PROMPT:
+<new_prompt>
+{NEW_PROMPT}
+</new_prompt>
+
+EXISTING_CODE:
+<existing_code>
+{EXISTING_CODE}
+</existing_code>
+
+CHANGE_DESCRIPTION:
+<change_description>
+{CHANGE_DESCRIPTION}
+</change_description>
+
+Based on the change description and differences between the prompts, carefully update the existing code.
+
+Remember to:
+1. Only modify what's necessary to implement the changes
+2. Maintain consistency with the existing code style and structure
+3. Ensure all functionality from the original code still works correctly
+4. Implement all new requirements from the updated prompt
+5. Test the logic of your changes to ensure correctness
+6. Include appropriate error handling for any new code
+
+First, analyze the existing code to understand its structure and functionality:
+[Your code structure analysis]
+
+Next, determine specific modifications needed based on the change description:
+[Your planned modifications]
+
+Now, implement those changes to create the updated code:
+
+<output_json_example>
+{{
+  "analysis": "A detailed analysis of the changes needed,
+  "planned_modifications": "A detailed description of the modifications needed and why this change should not break the existing code",
+  "patched_code": "YOUR COMPLETE UPDATED CODE HERE"
+}}
+</output_json_example>

pdd/prompts/diff_analyzer_LLM.prompt

@@ -0,0 +1,69 @@
+% You are an expert code analyzer, tasked with determining if changes between two prompts are significant enough to warrant complete code regeneration.
+
+% Given:
+    - The original prompt used to generate code
+    - A new, updated prompt
+    - The existing code generated from the original prompt
+% Your task is to:
+    1. Analyze the differences between the original and new prompts
+    2. Evaluate how significantly these differences would impact the code implementation
+    3. Decide if the changes require completely regenerating the code or if incremental patching would be sufficient
+    4. Provide a clear description of the changes needed, which will be used for patching if applicable
+
+% Output a JSON object with:
+    - is_big_change: boolean - true if changes are significant enough to require complete regeneration, false if incremental patching is sufficient
+    - change_description: string - detailed description of changes needed, especially helpful for incremental patching
+
+% Guidelines for determining significant changes:
+    - Major architectural changes (significantly different data structures, algorithms, or patterns)
+    - Addition of entirely new functionalities that alter the core purpose
+    - Changes to return types or critical input parameters
+    - Major changes to the programming paradigm or approach
+    - Substantial adjustments to business logic
+
+% Examples of changes that can be handled incrementally:
+    - Bug fixes or minor logic corrections
+    - Adding or modifying non-critical validation
+    - Adding simple helper functions
+    - Renaming variables or functions
+    - Adding documentation or comments
+    - Minor enhancements to existing functionality
+    - Small adjustments to error handling
+
+% Be conservative in determining if a change is "big" - if there's significant uncertainty, prefer complete regeneration.
+
+ORIGINAL_PROMPT:
+<original_prompt>
+{ORIGINAL_PROMPT}
+</original_prompt>
+
+NEW_PROMPT:
+<new_prompt>
+{NEW_PROMPT}
+</new_prompt>
+
+EXISTING_CODE:
+<existing_code>
+{EXISTING_CODE}
+</existing_code>
+
+Analyze the differences between the original and new prompts. Consider how these differences would impact the implementation of the code.
+
+First, identify and list the specific changes between the prompts:
+
+1. [List each significant change]
+
+Next, evaluate if these changes fundamentally alter the approach needed in the code implementation:
+
+2. [Your detailed analysis]
+
+Based on your analysis, determine whether these changes require completely regenerating the code or if they can be addressed with targeted modifications to the existing code.
+
+Output your conclusion as a JSON object with the following format:
+<output_json_example>
+{{
+  "analysis": "A detailed analysis of the changes needed 1 and 2 above",
+  "change_description": "A detailed description of the changes needed..."
+  "is_big_change": true/false,
+}}
+</output_json_example>

pdd/prompts/find_verification_errors_LLM.prompt

@@ -6,13 +6,13 @@
 
 % Here is the code_module that is being used by the program: <code_module>{code}</code_module>
 
-% Here are the output logs from the program run: <o>{output}</o>
+% Here are the output logs from the program run: <output_logs>{output}</output_logs>
 
 % IMPORTANT CONSIDERATIONS:
-% 1. The prompt may only describe part of the functionality needed by the program.
-% 2. Always consider compatibility between the program and code_module as the highest priority.
-% 3. Functions used by the program must exist in the code_module, even if not mentioned in the prompt.
-% 4. The prompt might only request new functionality to be added to existing code.
+    1. The prompt may only describe part of the functionality needed by the program.
+    2. Always consider compatibility between the program and code_module as the highest priority.
+    3. Functions used by the program must exist in the code_module, even if not mentioned in the prompt.
+    4. The prompt might only request new functionality to be added to existing code.
 
 % Follow these steps to identify any issues:
     Step 1. First, identify all functions and features in the code_module that are used by the program, as these must be preserved.
@@ -28,11 +28,11 @@
 
 % After your analysis, determine the number of distinct issues found. If no issues are found, the count should be 0.
 
-% Return your response as a single, valid JSON object.
-% The JSON object must conform to the following structure:
-% {{
-%   "issues_count": <integer_count_of_issues_found>,
-%   "details": "A detailed explanation of all steps taken during your analysis, including any discrepancies, bugs, or potential issues identified. If no issues are found, this can be a brief confirmation."
-% }}
-% Ensure the "details" field contains your complete textual analysis from Steps 1-7.
-% Ensure the "issues_count" is an integer representing the total number of distinct problems you've identified in your details.
+% Return your response as a single, valid JSON object. The JSON object must conform to the following structure:
+<example_output>
+    {{
+    "details": "A detailed explanation of all steps taken during your analysis, including any discrepancies, bugs, or potential issues identified. If no issues are found, this can be a brief confirmation.",
+    "issues_count": <integer_count_of_issues_found>
+    }}
+</example_output>
+% Ensure the "details" field contains your complete textual analysis from Steps 1-7 and ensure the "issues_count" is an integer representing the total number of distinct problems you've identified in your details.