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

pdd/prompts/insert_includes_LLM.prompt

@@ -6,8 +6,19 @@
         INPUT:
         <prompt_to_update>% You are an expert Python Software Engineer. Your goal is to write a python function, "postprocess", that will extract code from a string output of an LLM. All output to the console will be pretty printed using the Python rich library.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs:
@@ -53,53 +64,105 @@ if __name__ == "__main__":
         For running prompts with llm_invoke:
         <llm_invoke_example>
             from pydantic import BaseModel, Field
-from pdd.llm_invoke import llm_invoke
-from collections import defaultdict
+from pdd.llm_invoke import llm_invoke, _load_model_data, _select_model_candidates, LLM_MODEL_CSV_PATH, DEFAULT_BASE_MODEL
+from typing import List, Dict, Any
 
 # Define a Pydantic model for structured output
 class Joke(BaseModel):
     setup: str = Field(description="The setup of the joke")
     punchline: str = Field(description="The punchline of the joke")
 
-def main():
+
+def calculate_model_ranges(step: float = 0.001) -> List[Dict[str, Any]]:
     """
-    Main function to demonstrate the usage of `llm_invoke`.
+    Calculate the strength ranges for each model by sampling strength values.
+
+    Args:
+        step: The step size for sampling strength values (default 0.001)
+
+    Returns:
+        List of dicts with 'model', 'start', 'end', and 'midpoint' keys
     """
-    # Dictionary to track strength ranges for each model
-    model_ranges = defaultdict(list)
+    model_df = _load_model_data(LLM_MODEL_CSV_PATH)
+
+    ranges = []
     current_model = None
     range_start = 0.0
-    
+
+    # Sample strength values to find model boundaries
+    strength = 0.0
+    while strength <= 1.0:
+        candidates = _select_model_candidates(strength, DEFAULT_BASE_MODEL, model_df)
+        selected_model = candidates[0]['model'] if candidates else None
+
+        if current_model != selected_model:
+            if current_model is not None:
+                ranges.append({
+                    'model': current_model,
+                    'start': range_start,
+                    'end': round(strength - step, 3),
+                    'midpoint': round((range_start + strength - step) / 2, 3)
+                })
+            current_model = selected_model
+            range_start = strength
+
+        strength = round(strength + step, 3)
+
+    # Add the final range
+    if current_model is not None:
+        ranges.append({
+            'model': current_model,
+            'start': range_start,
+            'end': 1.0,
+            'midpoint': round((range_start + 1.0) / 2, 3)
+        })
+
+    return ranges
+
+
+def main():
+    """
+    Main function to demonstrate the usage of `llm_invoke`.
+
+    Automatically calculates model ranges and runs each model once
+    at its midpoint strength value.
+    """
+    # Calculate model ranges automatically
+    print("Calculating model strength ranges...")
+    model_ranges = calculate_model_ranges()
+
+    # Print the calculated ranges
+    print("\n=== Model Strength Ranges ===")
+    for range_info in model_ranges:
+        print(f"{range_info['model']}: {range_info['start']:.3f} to {range_info['end']:.3f} (midpoint: {range_info['midpoint']:.3f})")
+
     prompt = "Tell me a joke about {topic}"
     input_json = {"topic": "programmers"}
     temperature = 1
     verbose = False
-    
-    strength = 0.5
-    while strength <= 0.5:
-        print(f"\nStrength: {strength}")
-        
+
+    # Run each model once at its midpoint strength
+    print("\n=== Running Each Model Once ===")
+    for range_info in model_ranges:
+        model_name = range_info['model']
+        midpoint = range_info['midpoint']
+
+        print(f"\n--- Model: {model_name} (strength: {midpoint}) ---")
+
         # Example 1: Unstructured Output
-        print("\n--- Unstructured Output ---")
+        print("\n  Unstructured Output:")
         response = llm_invoke(
             prompt=prompt,
             input_json=input_json,
-            strength=strength,
+            strength=midpoint,
             temperature=temperature,
             verbose=verbose
         )
-        
-        # Track model changes for strength ranges
-        if current_model != response['model_name']:
-            if current_model is not None:
-                model_ranges[current_model].append((range_start, strength - 0.005))
-            current_model = response['model_name']
-            range_start = strength
-        
-        print(f"Result: {response['result']}")
-        print(f"Cost: ${response['cost']:.6f}")
-        print(f"Model Used: {response['model_name']}")
-        
+
+        print(f"  Result: {response['result']}")
+        print(f"  Cost: ${response['cost']:.6f}")
+        print(f"  Model Used: {response['model_name']}")
+
         # Example 2: Structured Output with Pydantic Model
         prompt_structured = (
             "Generate a joke about {topic}. \n"
@@ -112,41 +175,27 @@ def main():
         )
         input_json_structured = {"topic": "data scientists"}
         output_pydantic = Joke
-        
-        print("\n--- Structured Output ---")
+
+        print("\n  Structured Output:")
         try:
             response_structured = llm_invoke(
                 prompt=prompt_structured,
                 input_json=input_json_structured,
-                strength=strength,
+                strength=midpoint,
                 temperature=temperature,
-                verbose=True,
+                verbose=verbose,
                 output_pydantic=output_pydantic
             )
-            print(f"Result: {response_structured['result']}")
-            print(f"Cost: ${response_structured['cost']:.6f}")
-            print(f"Model Used: {response_structured['model_name']}")
+            print(f"  Result: {response_structured['result']}")
+            print(f"  Cost: ${response_structured['cost']:.6f}")
+            print(f"  Model Used: {response_structured['model_name']}")
 
             # Access structured data
             joke: Joke = response_structured['result']
-            print(f"\nJoke Setup: {joke.setup}")
-            print(f"Joke Punchline: {joke.punchline}")
+            print(f"\n  Joke Setup: {joke.setup}")
+            print(f"  Joke Punchline: {joke.punchline}")
         except Exception as e:
-            print(f"Error encountered during structured output: {e}")
-        
-        strength += 0.005
-        # round to 3 decimal places
-        strength = round(strength, 3)
-    
-    # Add the final range for the last model
-    model_ranges[current_model].append((range_start, 1.0))
-    
-    # Print out the strength ranges for each model
-    print("\n=== Model Strength Ranges ===")
-    for model, ranges in model_ranges.items():
-        print(f"\n{model}:")
-        for start, end in ranges:
-            print(f"  Strength {start:.3f} to {end:.3f}")
+            print(f"  Error encountered during structured output: {e}")
 
 if __name__ == "__main__":
     main()
@@ -157,8 +206,19 @@ if __name__ == "__main__":
         OUTPUT:
         <updated_prompt>% You are an expert Python Software Engineer. Your goal is to write a python function, "postprocess", that will extract code from a string output of an LLM. All output to the console will be pretty printed using the Python rich library.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs:
@@ -193,53 +253,105 @@ if __name__ == "__main__":
         For running prompts with llm_invoke:
         <llm_invoke_example>
             from pydantic import BaseModel, Field
-from pdd.llm_invoke import llm_invoke
-from collections import defaultdict
+from pdd.llm_invoke import llm_invoke, _load_model_data, _select_model_candidates, LLM_MODEL_CSV_PATH, DEFAULT_BASE_MODEL
+from typing import List, Dict, Any
 
 # Define a Pydantic model for structured output
 class Joke(BaseModel):
     setup: str = Field(description="The setup of the joke")
     punchline: str = Field(description="The punchline of the joke")
 
-def main():
+
+def calculate_model_ranges(step: float = 0.001) -> List[Dict[str, Any]]:
     """
-    Main function to demonstrate the usage of `llm_invoke`.
+    Calculate the strength ranges for each model by sampling strength values.
+
+    Args:
+        step: The step size for sampling strength values (default 0.001)
+
+    Returns:
+        List of dicts with 'model', 'start', 'end', and 'midpoint' keys
     """
-    # Dictionary to track strength ranges for each model
-    model_ranges = defaultdict(list)
+    model_df = _load_model_data(LLM_MODEL_CSV_PATH)
+
+    ranges = []
     current_model = None
     range_start = 0.0
-    
+
+    # Sample strength values to find model boundaries
+    strength = 0.0
+    while strength <= 1.0:
+        candidates = _select_model_candidates(strength, DEFAULT_BASE_MODEL, model_df)
+        selected_model = candidates[0]['model'] if candidates else None
+
+        if current_model != selected_model:
+            if current_model is not None:
+                ranges.append({
+                    'model': current_model,
+                    'start': range_start,
+                    'end': round(strength - step, 3),
+                    'midpoint': round((range_start + strength - step) / 2, 3)
+                })
+            current_model = selected_model
+            range_start = strength
+
+        strength = round(strength + step, 3)
+
+    # Add the final range
+    if current_model is not None:
+        ranges.append({
+            'model': current_model,
+            'start': range_start,
+            'end': 1.0,
+            'midpoint': round((range_start + 1.0) / 2, 3)
+        })
+
+    return ranges
+
+
+def main():
+    """
+    Main function to demonstrate the usage of `llm_invoke`.
+
+    Automatically calculates model ranges and runs each model once
+    at its midpoint strength value.
+    """
+    # Calculate model ranges automatically
+    print("Calculating model strength ranges...")
+    model_ranges = calculate_model_ranges()
+
+    # Print the calculated ranges
+    print("\n=== Model Strength Ranges ===")
+    for range_info in model_ranges:
+        print(f"{range_info['model']}: {range_info['start']:.3f} to {range_info['end']:.3f} (midpoint: {range_info['midpoint']:.3f})")
+
     prompt = "Tell me a joke about {topic}"
     input_json = {"topic": "programmers"}
     temperature = 1
     verbose = False
-    
-    strength = 0.5
-    while strength <= 0.5:
-        print(f"\nStrength: {strength}")
-        
+
+    # Run each model once at its midpoint strength
+    print("\n=== Running Each Model Once ===")
+    for range_info in model_ranges:
+        model_name = range_info['model']
+        midpoint = range_info['midpoint']
+
+        print(f"\n--- Model: {model_name} (strength: {midpoint}) ---")
+
         # Example 1: Unstructured Output
-        print("\n--- Unstructured Output ---")
+        print("\n  Unstructured Output:")
         response = llm_invoke(
             prompt=prompt,
             input_json=input_json,
-            strength=strength,
+            strength=midpoint,
             temperature=temperature,
             verbose=verbose
         )
-        
-        # Track model changes for strength ranges
-        if current_model != response['model_name']:
-            if current_model is not None:
-                model_ranges[current_model].append((range_start, strength - 0.005))
-            current_model = response['model_name']
-            range_start = strength
-        
-        print(f"Result: {response['result']}")
-        print(f"Cost: ${response['cost']:.6f}")
-        print(f"Model Used: {response['model_name']}")
-        
+
+        print(f"  Result: {response['result']}")
+        print(f"  Cost: ${response['cost']:.6f}")
+        print(f"  Model Used: {response['model_name']}")
+
         # Example 2: Structured Output with Pydantic Model
         prompt_structured = (
             "Generate a joke about {topic}. \n"
@@ -252,41 +364,27 @@ def main():
         )
         input_json_structured = {"topic": "data scientists"}
         output_pydantic = Joke
-        
-        print("\n--- Structured Output ---")
+
+        print("\n  Structured Output:")
         try:
             response_structured = llm_invoke(
                 prompt=prompt_structured,
                 input_json=input_json_structured,
-                strength=strength,
+                strength=midpoint,
                 temperature=temperature,
-                verbose=True,
+                verbose=verbose,
                 output_pydantic=output_pydantic
             )
-            print(f"Result: {response_structured['result']}")
-            print(f"Cost: ${response_structured['cost']:.6f}")
-            print(f"Model Used: {response_structured['model_name']}")
+            print(f"  Result: {response_structured['result']}")
+            print(f"  Cost: ${response_structured['cost']:.6f}")
+            print(f"  Model Used: {response_structured['model_name']}")
 
             # Access structured data
             joke: Joke = response_structured['result']
-            print(f"\nJoke Setup: {joke.setup}")
-            print(f"Joke Punchline: {joke.punchline}")
+            print(f"\n  Joke Setup: {joke.setup}")
+            print(f"  Joke Punchline: {joke.punchline}")
         except Exception as e:
-            print(f"Error encountered during structured output: {e}")
-        
-        strength += 0.005
-        # round to 3 decimal places
-        strength = round(strength, 3)
-    
-    # Add the final range for the last model
-    model_ranges[current_model].append((range_start, 1.0))
-    
-    # Print out the strength ranges for each model
-    print("\n=== Model Strength Ranges ===")
-    for model, ranges in model_ranges.items():
-        print(f"\n{model}:")
-        for start, end in ranges:
-            print(f"  Strength {start:.3f} to {end:.3f}")
+            print(f"  Error encountered during structured output: {e}")
 
 if __name__ == "__main__":
     main()
@@ -310,8 +408,19 @@ if __name__ == "__main__":
         INPUT:
         <prompt_to_update>% You are an expert Python engineer. Your goal is to write a Python function, "conflicts_in_prompts", that takes two prompts as input and finds conflicts between them and suggests how to resolve those conflicts.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs: 
@@ -693,8 +802,19 @@ if __name__ == "__main__":
         OUTPUT:
         <updated_prompt>% You are an expert Python engineer. Your goal is to write a Python function, "conflicts_in_prompts", that takes two prompts as input and finds conflicts between them and suggests how to resolve those conflicts.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs: 

pdd/prompts/trace_LLM.prompt

@@ -1,30 +1,33 @@
-% Imagine you're a an expert Python Software Engineer. Your goal is to find the part of the .prompt file. It will take in three arguments, the text of the .prompt file, the text of the code file, and the line that the debugger is on in the code file. Your task is to find the equivalent line in the .prompt file that matches with the line in the code file.
-
-% Here are the inputs and outputs of the prompt:
-    Input:
-        `code_file` (str) - A string that contains the text of the code file.
-        `code_str` (str) - A substring of code_file that represents the line that the debugger is on in the code_file.
-        `prompt_file` (str) - A string that contains the text of the .prompt file.
-    Output:
-        `prompt_line` (str) - An string that represents the equivalent line in the .prompt file that matches with the code_str line in the code file.
-
-% Here is the code_file to reference: 
-
+% You are a highly accurate Python Software Engineer. Your job is to locate the exact line (or smallest excerpt) in the prompt file that produced the current line in the generated code.
+
+% Inputs
+    code_file (str)    : full contents of the generated code file
+    code_str (str)     : the single line from the code file currently under inspection
+    prompt_file (str)  : full contents of the originating prompt file
+
+% Rules
+1. Identify the minimal substring in prompt_file whose wording most directly corresponds to code_str. Copy it VERBATIM.
+2. Do not paraphrase, summarize, or reformat; the substring must appear exactly in prompt_file.
+3. If multiple lines apply, choose the most specific line or snippet (prefer the shortest exact match).
+4. Provide a short explanation of why the substring matches code_str.
+
+% Output format (MUST follow exactly; no additional text)
+<analysis>
+Explain your reasoning here in plain text (no JSON). Reference the file sections you compared.
+</analysis>
+<verbatim_prompt_line>
+<<PASTE THE EXACT SUBSTRING FROM prompt_file HERE>>
+</verbatim_prompt_line>
+
+% Reference materials
 <code_file>
-    {CODE_FILE}
+{CODE_FILE}
 </code_file>
 
-% Here is the code_str to reference:
-
 <code_str>
-    {CODE_STR}
+{CODE_STR}
 </code_str>
 
-% Here is the prompt_file to reference:
-
 <prompt_file>
-    {PROMPT_FILE}
+{PROMPT_FILE}
 </prompt_file>
-
-% To generate the prompt_line, find a substring of prompt_file that matches code_str, which is a substring of code_file.
-

pdd/prompts/unfinished_prompt_LLM.prompt

@@ -1,18 +1,102 @@
 % You are tasked with determining whether a given prompt has finished outputting everything or if it still needs to continue. This is crucial for ensuring that all necessary information has been provided before proceeding with further actions. You will often be provided the last few hundred characters of the prompt_text to analyze and determine if it appears to be complete or if it seems to be cut off or unfinished. You are just looking at the prompt_text and not the entire prompt file. The beginning part of the prompt_text is not always provided, so you will need to make a judgment based on the text you are given.
 
+% IMPORTANT:
+%  - The prompt_text may contain code in various languages without Markdown fences.
+%  - Do NOT require triple backticks for completeness; judge the code/text itself.
+%  - Prefer concrete syntactic signals of completeness over stylistic ones.
+
 % Here is the prompt text to analyze:
 <prompt_text>
     {PROMPT_TEXT}
 </prompt_text>
 
+% Optional language hint (may be empty or missing). If not provided, infer the language from the text:
+<language>
+    {LANGUAGE}
+</language>
+
 % Carefully examine the provided prompt text and determine if it appears to be complete or if it seems to be cut off or unfinished. Consider the following factors:
     1. Sentence structure: Are all sentences grammatically complete?
     2. Content flow: Does the text end abruptly or does it have a natural conclusion?
     3. Context: Based on the content, does it seem like all necessary information has been provided?
     4. Formatting: Are there any unclosed parentheses, quotation marks, or other formatting issues that suggest incompleteness?
 
+% Multi-language code completeness heuristics (apply when text looks like code):
+    - If the text forms a syntactically complete module/snippet for the language, treat it as finished (even without Markdown fences).
+    - Generic signals across languages:
+        * Balanced delimiters: (), [], {{}}, quotes, and block comments are closed.
+        * No mid-token/mid-statement tail: it does not end on `return a +`, `a =`, `def foo(`, `function f(`, trailing `.`, `->`, `::`, trailing `,`, or a line-continuation like `\\`.
+        * Block closure: constructs that open a block are closed (e.g., Python indentation after `:`, or matching `{{}}` in C/Java/JS/TS/Go).
+    - Language specifics (use LANGUAGE if given; otherwise infer from the text):
+        * Python: colon-introduced blocks closed; indentation consistent; triple-quoted strings balanced.
+        * JS/TS: braces and parentheses balanced; no dangling `export`/`import` without a following specifier; `/* ... */` comments closed.
+        * Java/C/C++/C#: braces and parentheses balanced; string/char literals closed; block comments closed.
+        * Go: braces balanced; no dangling keyword indicating an unfinished clause.
+        * HTML/XML: tags properly nested/closed; attributes properly quoted; no unfinished `<tag` or dangling `</`.
+    - If this is only the tail of a longer file, mark finished when the tail itself is syntactically complete and does not indicate a dangling continuation.
+
 % Provide your reasoning for why you believe the prompt is complete or incomplete.
 
 % Output a JSON object with two keys:
     1. "reasoning": A string containing your structured reasoning
-    2. "is_finished": A boolean value (true if the prompt is complete, false if it's incomplete)
+    2. "is_finished": A boolean value (true if the prompt is complete, false if it's incomplete)
+
+% Examples (concise):
+<examples>
+  <example1>
+    <input>
+      <prompt_text>
+        def add(a, b):\n    return a + b\n
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "Python code parses; blocks and quotes are closed; ends on a complete return statement.", "is_finished": true}}
+    </output>
+  </example1>
+  <example2>
+    <input>
+      <prompt_text>
+        def add(a, b):\n    return a +
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "Ends mid-expression (`return a +`), indicates unfinished statement.", "is_finished": false}}
+    </output>
+  </example2>
+  <example3>
+    <input>
+      <prompt_text>
+        function add(a, b) {{\n  return a + b;\n}}\n
+      </prompt_text>
+      <language>
+        JavaScript
+      </language>
+    </input>
+    <output>
+      {{"reasoning": "JS braces and parentheses balanced; ends at a statement boundary; no dangling tokens.", "is_finished": true}}
+    </output>
+  </example3>
+  <example4>
+    <input>
+      <prompt_text>
+        <div class=\"box\">Hello
+      </prompt_text>
+      <language>
+        HTML
+      </language>
+    </input>
+    <output>
+      {{"reasoning": "HTML tag not closed (missing </div>); attribute quotes OK but element is unclosed.", "is_finished": false}}
+    </output>
+  </example4>
+  <example5>
+    <input>
+      <prompt_text>
+        class C:\n            def f(self):\n                x = 1\n
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "All blocks properly indented and closed in the visible tail; no dangling colon blocks or open delimiters; tail is syntactically complete.", "is_finished": true}}
+    </output>
+  </example5>
+</examples>

pdd/prompts/update_prompt_LLM.prompt

@@ -16,4 +16,25 @@
     1. Using the provided input_code and input_prompt, identify what the code does and how it was generated.
     2. Compare the input_code and modified_code to determine the changes made by the user.
     3. Identify what the modified_code does differently from the input_code.
-    4. Generate a modified_prompt that will guide the generation of the modified_code based on the identified changes.
+    4. Generate a modified_prompt that will guide the generation of the modified_code based on the identified changes.
+    5. Ensure that the modified_prompt adheres to the principles of Prompt-Driven Development (PDD) and includes all necessary sections: Role and Scope, Requirements, Dependencies & Context, Instructions, and Deliverables.
+    6. Try to preserve the structure and format of the existing prompt as much as possible while incorporating the necessary changes to reflect the modifications in the code.
+
+% When generating the modified prompt, you must follow the core principles of Prompt-Driven Development (PDD).
+% Here are the essential guidelines for structuring a PDD prompt:
+<pdd_prompting_guide>
+% The prompt you generate must follow this structure:
+1) First paragraph: describe the role and responsibility of the module/component within the system (consider the LAYER if provided).
+2) A "Requirements" section with numbered points covering functionality, contracts, error handling, validation, logging, performance, and security.
+3) A "Dependencies" section using XML include tags for each dependency (see format below).
+4) An "Instructions" section with precise implementation guidance (clarify inputs/outputs, function/class responsibilities, edge cases, and testing notes).
+5) A clear "Deliverable" section describing the expected code artifacts and entry points.
+
+% Dependencies format and conventions:
+- Represent each dependency using an XML tag with the dependency name, and put the file path inside an &lt;include&gt; tag. For example:
+  &lt;orders_service&gt;
+    &lt;include&gt;context/orders_service_example.py&lt;/include&gt;
+  &lt;/orders_service&gt;
+- Prefer real example files available in the provided context (use &lt;include-many&gt; when listing multiple). If examples are not provided, assume dependency examples live under context/ using the pattern context/[dependency_name]_example. You should always try to include example files when possible.
+- Include all necessary dependencies for the module/component (based on the provided context and references).
+</pdd_prompting_guide>