pdd-cli 0.0.2__py3-none-any.whl

pdd/prompts/auto_include_LLM.prompt

@@ -0,0 +1,230 @@
+<overview>
+You are a prompt expert that helps select the necessary subset of "includes" (list of code files) out of a provided list of file paths. Your goal is to infer the purpose of each file based on their names so just the proper includes are included.
+</overview>
+
+<definitions>
+    Here are the inputs and outputs of this prompt:
+    <input>
+        'input_prompt' - A string that contains the prompt that requires the includes to be selected.
+        'available_includes' - A list of strings that contains the file paths of the available includes.
+    </input>
+    <output>
+        'Step 1.' - A string of possible includes based on the input_prompt.
+        'Step 2.' - A string explaining why an include might or might not be necessary for the prompt.
+        'Step 3.' - A string of the minimum set of includes required to achieve the goal of the input_prompt.
+        'Step 4.' - A string of the string_of_includes based on Step 3.
+    </output>
+</definitions>
+
+<context>
+    Here is the input_prompt to find the includes for: <input_prompt>{input_prompt}</input_prompt>
+    Here is the available_includes: <available_includes>{available_includes}</available_includes>
+</context>
+
+Here are some examples of how to do this:
+<examples>
+    <example_1>
+        <example_input_prompt>
+            % You are an expert Python Software Engineer. Your goal is to write a Python function, "process_csv_change", that will read in a take in a csv file name and call change_example for each of the lines.
+
+            <include>context/python_preamble.prompt</include>
+
+            % Here are the inputs and outputs of the function:
+                Inputs: 
+                    'csv_file' - A string containing the path to the csv file.
+                    'strength' - A float between 0 and 1 that represents the strength of the LLM model to use.
+                    'temperature' - A float that represents the temperature parameter for the LLM model.
+                    'code_directory' - A string containing the path to the directory where the code files are stored.
+                    'language' - A string representing the programming language of the code files. 
+                    'extension' - A string representing the file extension of the code files. Includes the '.' in front of the extension.
+                    'budget' - A float representing the maximum cost allowed for the change process.
+                Outputs:
+                    'success' - A boolean indicating whether the changes were successfully made.
+                    'list_of_jsons' - A list of dictionaries containing Key:file_name,  Value:modified_prompt.
+                    'total_cost' - A float representing the total cost of all fix attempts.
+                    'model_name' - A string representing the name of the LLM model used.
+
+            % This function will do the following:
+                Step 1. Read in the csv file with columns prompt_name and change_instructions.
+                Step 2. Loop through each line in the csv file:
+                    a. Initialize variables:
+                        - Initialize a list_of_jsons to store the modified prompts.
+                        - Read the prompt from the prompt_name column (text file).
+                        - Parse the prompt_name into a input_code name:
+                            - remove the path and suffix _language.prompt from the prompt_name
+                            - add the suffix extension to the prompt_name
+                            - change the directory to code_directory
+                        - Read the input_code from the input_code_name as a string
+                        - Read the change_instructions from the change_instructions column
+                    b. Call the change function with the input_prompt, input_code, and change_prompt.
+                    c. Add the returned total_cost to the total cost accumulator.
+                    d. If the total cost exceeds the budget, break the loop.
+                    e If the change was successful, add the modified prompt to the list_of_jsons.
+                Step 3. Return the success status, list of modified prompts, total cost, and model name.
+        </example_input_prompt>
+        <example_available_includes>
+            context/DSPy_example.py
+            context/anthropic_counter_example.py
+            context/autotokenizer_example.py
+            context/bug_to_unit_test_example.py
+            context/bug_to_unit_test_failure_example.py
+            context/change_example.py
+            context/cli_example.py
+            context/cli_python_preprocessed.prompt
+            context/click_example.py
+            context/cloud_function_call.py
+            context/code_generator_example.py
+            context/comment_line_example.py
+            context/conflicts_in_prompts_example.py
+            context/conflicts_in_prompts_python.prompt
+            context/construct_paths_example.py
+            context/context_generator_example.py
+            context/continue_generation_example.py
+            context/detect_change_example.py
+            context/execute_bug_to_unit_test_failure.py
+            context/final_llm_output.py
+            context/find_section_example.py
+            context/fix_code_module_errors_example.py
+            context/fix_error_loop_example.py
+            context/fix_errors_from_unit_tests_example.py
+            context/generate_output_paths_example.py
+            context/generate_test_example.py
+            context/get_comment_example.py
+            context/get_extension_example.py
+            context/get_language_example.py
+            context/git_update_example.py
+            context/langchain_lcel_example.py
+            context/llm_selector_example.py
+            context/llm_token_counter_example.py
+            context/postprocess_0_example.py
+            context/postprocess_example.py
+            context/postprocessed_runnable_llm_output.py
+            context/preprocess_example.py
+            context/process_csv_change_example.py
+            context/prompt_caching.ipynb
+            context/split_example.py
+            context/tiktoken_example.py
+            context/trace_example.py
+            context/unfinished_prompt_example.py
+            context/unrunnable_raw_llm_output.py
+            context/update_prompt_example.py
+            context/xml_tagger_example.py
+        </example_available_includes>
+        <example_string_of_includes>
+            % Here are examples of how to use internal modules:
+            <internal_example_modules>
+                % Here is an example of the change function that will be used: <change_example><include>context/change_example.py</include></change_example>
+            </internal_example_modules>
+        </example_string_of_includes>
+    </example_1>
+
+    <example_2>
+        <example_input_prompt>
+            % You are an expert Python Software Engineer. Your goal is to write a Python function, "generate_test", that will create a unit test from a code file.
+
+            <include>./context/python_preamble.prompt</include>
+
+            % Here are the inputs and outputs of the function:
+                Inputs: 
+                    'prompt' - A string containing the prompt that generated the code file to be processed.
+                    'code' - A string containing the code to generate a unit test from.
+                    'strength' - A float between 0 and 1 that is the strength of the LLM model to use.
+                    'temperature' - A float that is the temperature of the LLM model to use.
+                    'language' - A string that is the language of the unit test to be generated.
+                Outputs: 
+                    'unit_test'- A string that is the generated unit test code.
+                    'total_cost' - A float that is the total cost to generate the unit test code.
+                    'model_name' - A string that is the name of the selected LLM model
+
+            % This program will use Langchain to do the following:
+                Step 1. use $PDD_PATH environment variable to get the path to the project. Load the '$PDD_PATH/prompts/generate_test_LLM.prompt' file.
+                Step 2. Preprocess the prompt using the preprocess function without recursion or doubling of the curly brackets.
+                Step 2. Then this will create a Langchain LCEL template from the test generator prompt.
+                Step 3. This will use llm_selector for the model.
+                Step 4. This will run the inputs through the model using Langchain LCEL. 
+                    4a. Be sure to pass the following string parameters to the prompt during invoke:
+                        - 'prompt_that_generated_code': preprocess the prompt using the preprocess function without recursion or doubling of the curly brackets.
+                        - 'code'
+                        - 'language'
+                    4b. Pretty print a message letting the user know it is running and how many tokens (using token_counter from llm_selector) are in the prompt and the cost. The cost from llm_selector is in dollars per million tokens.
+                Step 5. This will pretty print the markdown formatting that is present in the result via the rich Markdown function. It will also pretty print the number of tokens in the result and the cost.
+                Step 6. Detect if the generation is incomplete using the unfinished_prompt function (strength .7) by passing in the last 600 characters of the output of Step 4.
+                    - a. If incomplete, call the continue_generation function to complete the generation.
+                    - b. Else, if complete, postprocess the model output result using the postprocess function from the postprocess module with a strength of 0.7.
+                Step 7. Print out the total_cost including the input and output tokens and functions that incur cost (e.g. postprocessing).
+                Step 7. Return the unit_test, total_cost and model_name
+        </example_input_prompt>
+        <example_available_includes>
+            context/DSPy_example.py
+            context/anthropic_counter_example.py
+            context/autotokenizer_example.py
+            context/bug_to_unit_test_example.py
+            context/bug_to_unit_test_failure_example.py
+            context/change_example.py
+            context/cli_example.py
+            context/cli_python_preprocessed.prompt
+            context/click_example.py
+            context/cloud_function_call.py
+            context/code_generator_example.py
+            context/comment_line_example.py
+            context/conflicts_in_prompts_example.py
+            context/conflicts_in_prompts_python.prompt
+            context/construct_paths_example.py
+            context/context_generator_example.py
+            context/continue_generation_example.py
+            context/detect_change_example.py
+            context/execute_bug_to_unit_test_failure.py
+            context/final_llm_output.py
+            context/find_section_example.py
+            context/fix_code_module_errors_example.py
+            context/fix_error_loop_example.py
+            context/fix_errors_from_unit_tests_example.py
+            context/generate_output_paths_example.py
+            context/generate_test_example.py
+            context/get_comment_example.py
+            context/get_extension_example.py
+            context/get_language_example.py
+            context/git_update_example.py
+            context/langchain_lcel_example.py
+            context/llm_selector_example.py
+            context/llm_token_counter_example.py
+            context/postprocess_0_example.py
+            context/postprocess_example.py
+            context/postprocessed_runnable_llm_output.py
+            context/preprocess_example.py
+            context/process_csv_change_example.py
+            context/prompt_caching.ipynb
+            context/split_example.py
+            context/tiktoken_example.py
+            context/trace_example.py
+            context/unfinished_prompt_example.py
+            context/unrunnable_raw_llm_output.py
+            context/update_prompt_example.py
+            context/xml_tagger_example.py
+        </example_available_includes>
+        <example_string_of_includes>
+            % Here is an example of a LangChain Expression Language (LCEL) program: <lcel_example><include>context/langchain_lcel_example.py</include></lcel_example>
+
+            % Here are examples of how to use internal modules:
+            <internal_example_modules>
+                % Here is an example how to preprocess the prompt from a file: <preprocess_example><include>./context/preprocess_example.py</include></preprocess_example>
+
+                % Example of selecting a Langchain LLM and counting tokens using llm_selector: <llm_selector_example><include>./context/llm_selector_example.py</include></llm_selector_example>
+
+                % Example usage of the unfinished_prompt function: <unfinished_prompt_example><include>./context/unfinished_prompt_example.py</include></unfinished_prompt_example>
+
+                % Here is an example how to continue the generation of a model output: <continue_generation_example><include>context/continue_generation_example.py</include></continue_generation_example>
+
+                % Here is an example how to postprocess the model output result: <postprocess_example><include>context/postprocess_example.py</include></postprocess_example>
+            </internal_example_modules>
+        </example_string_of_includes>
+    </example_2>
+</examples>
+
+<instructions>
+    Follow these instructions:
+        Step 1. Select possible includes from the available_includes based on the input_prompt.
+        Step 2. Explain why an include might or might not be necessary for the prompt.
+        Step 3. Determine the minimum set of includes required to achieve the goal of the input_prompt.
+        Step 4. Generate the string_of_includes based on Step 3.
+</instructions>

pdd/prompts/bug_to_unit_test_LLM.prompt

@@ -0,0 +1,17 @@
+% You are an expert {language} Software Test Engineer. Your task is to generate a {language} unit test to identify issue(s) in a given code. The test should compare the current output with the desired output and to ensure the code behaves as expected. If Python, use Pytest.
+
+% Inputs:
+	•	Current output: ```{current_output}```
+	•	Desired output: ```{desired_output}```
+	•	Code under test: ```{code_under_test}``` 
+	•	Program used to run the code under test: ```{program_used_to_run_code_under_test}```
+	•	Prompt that generated the code: ```{prompt_that_generated_code}```
+% Output:
+	•	A unit test that covers the problem(s) and ensures the code meets the expected behavior.
+
+% Follow these steps to generate the unit test:
+	1.	Analyze the current output: Compare the current and desired outputs to identify discrepancies.
+	2.	Generate a unit test: Write a test that highlights the issue in the current code to test whether the function produces the correct output as specified.
+	3.	Ensure correctness: The generated test should pass only when the code produces the desired output.
+
+% Focus exclusively on generating a robust unit test to detect and identify the issue(s) in the code provided.

pdd/prompts/change_LLM.prompt

@@ -0,0 +1,34 @@
+<role>
+    You are an expert LLM Prompt Engineer. Your goal is to change the input_prompt into a modified_prompt according to the change_prompt.
+</role>
+
+<inputs_outputs_definitions>
+    Here are the inputs and outputs of this prompt:
+    <input>
+        'input_prompt' - A string that contains the prompt that will be modified by the change_prompt.
+        'input_code' - A string that contains the code that was generated from the input_prompt.
+        'change_prompt' - A string that contains the instructions of how to modify the input_prompt.
+    </input>
+    <output>
+        'modified_prompt' - A string that contains the modified prompt that was changed based on the change_prompt.
+    </output>
+</inputs_outputs_definitions>
+
+```<./prompts/xml/change_example_partial_processed.prompt>```
+
+<context>
+    Here is the input_prompt to change: <input_prompt>{input_prompt}</input_prompt>
+    Here is the input_code generated from the input_prompt: <input_code>{input_code}</input_code>
+    Here is the change_prompt to implement: <change_prompt>{change_prompt}</change_prompt>
+</context>
+
+<instructions>
+    Follow these instructions:
+    Step 1. Explain in detail step by step the ramifications of the change_prompt on the input_prompt.
+    Step 2. Explain in detail step by step what changes need to be made to the input_prompt to generate the modified_prompt based on Step 1. This step describes how to modify the input_prompt to generate the modified_prompt.
+    Step 3. Generate the modified_prompt based on Step 2. Except for the change, the rest of the existing functionality of the input_prompt should remain. Structure the prompt similar to the example prompts, especially including the descriptions of the inputs and outputs.
+</instructions>
+
+<important_notes>
+    Never ask if you should proceed with generating the modified_prompt as this prompt has no human monitoring. Always assume that the change_prompt is correct and proceed with generating the modified_prompt. Also, for step 3, output the modified prompt not just how to modify the prompt. 
+</important_notes>

pdd/prompts/conflict_LLM.prompt

@@ -0,0 +1,23 @@
+% You are software architect and prompt engineering expert tasked with analyzing two prompts for potential conflicts and suggesting resolutions. Your goal is to identify any inconsistencies or contradictions between the prompts and provide constructive and detailed suggestions on how to resolve these conflicts.
+
+<inputs>
+    Here are the two prompts you need to analyze:
+    <prompt_1>
+        {PROMPT1}
+    </prompt_1>
+
+    <prompt_2>
+        {PROMPT2}
+    </prompt_2>
+</inputs>
+
+% Follow these instructions:
+    1. Carefully read and analyze both prompts. Look for any potential conflicts, contradictions, or inconsistencies between them. Consider aspects such as:
+        - Goals or objectives
+        - Specific instructions or requirements
+        - Assumptions or context
+    2. After your analysis, list any conflicts you've identified in a structured format. Remember to be thorough in your analysis and constructive in your suggestions. Your goal is to help improve the compatibility and effectiveness of these prompts. For each conflict, provide the following:
+        - Detailed explanation of why this is a conflict
+        - Suggestion on how to resolve this conflict
+        - Determine which prompt(s) would be best to changed and how
+    3. Based on step 2, create complete and detailed instructions on how to change each prompt to resolve the conflicts. Your instructions should be clear, actionable, and focused on improving the prompts while maintaining their original intent. Everything that is needed to know how to change the prompt effectively should be included here.

pdd/prompts/continue_generation_LLM.prompt

@@ -0,0 +1,3 @@
+{FORMATTED_INPUT_PROMPT}
+{LLM_OUTPUT}
+continue, by outputting only the rest of the code and no other commentary

pdd/prompts/detect_change_LLM.prompt

@@ -0,0 +1,65 @@
+% You are an expert prompt engineer. You will be given a list of LLM prompts and a change description. Your task is to analyze which prompts need to be changed based on the change description, and provide detailed instructions on how they should be changed.
+
+% Here are the inputs:
+<input>
+    <prompt_list>
+    {PROMPT_LIST}
+    </prompt_list>
+
+    <change_description>
+    {CHANGE_DESCRIPTION}
+    </change_description>
+</input>
+ 
+
+% Here is an example of an output for a given input:
+<example>
+    <input_example>
+        <prompt_list_example>
+        <include>context/detect_change/2/prompt_list.json</include>
+        </prompt_list_example>
+
+        <change_description_example>
+        <include>context/detect_change/2/change.prompt</include>
+        </change_description_example>
+    </input_example>
+
+    <output_example>
+        <include>context/detect_change/2/detect_change_output.txt</include>
+    </output_example>
+</example>
+
+% Follow these steps to complete the task:
+<task>
+    Step 1. Carefully read and analyze the change description. Consider its implications and how it might affect different types of prompts.
+    Step 2. Review each prompt in the prompt list. For each prompt, determine if it needs to be changed based on the change description. Some prompts maybe unaffected by the change description or already have the changes applied.
+    Step 3. In your analysis, consider the following:
+        - How does the change description impact each prompt?
+        - Are there any potential issues or conflicts that might arise from implementing the change?
+        - What are different ways the change could be implemented for affected prompts?
+        - Where is the best place to implement the change to minimize issues and maximize effectiveness?
+    Step 4. Prepare your response in the following format:
+        <analysis>
+        1. Provide a detailed description of the impact of the change and potential issues.
+        2. Generate at least three different possible implementation plans. Discuss the pros and cons of each plan.
+        3. Analyze the potential issues and the different plans. Explain step by step which plan is the best and why.
+        4. For each prompt explain if it needs to be changed based on the selected plan.
+        5. List the prompts that need to be changed based on the selected plan. For each prompt that needs to be changed, include:
+            a. The prompt's name
+            b. Detail and complete instructions for a LLM of how the prompt should be changed. Everything that is needed to know how to change the prompt effectively should be included here.
+                - When instructing to include content from another file vs. actually intending to include file contents:
+                    1. Mention the filename that should be included.
+                    2. Describe where in the prompt the file's contents should be inserted.
+                    3. Do not use XML-like syntax (such as angle brackets) when referring to includes, as this may interfere with preprocessing that will happen later.
+                    For example:
+                    "Insert the contents of the file './context/python_preamble.prompt' immediately after the role and goal statement using 'include' XML tags. The format for this is 'include' in angle brackets, followed by the file path then closed with 'include' in angle brackets."
+                - If multiple files need to be included, list each one separately with clear instructions on where each should be placed.
+                - When actually intending to include file contents use the include XML tags. This is common when the include will be replacing existing content.
+                - Provide instructions on which parts of the existing prompt should be removed, modified, or retained. Focus on describing the changes conceptually rather than referencing specific text that might be altered by preprocessing.
+                - Ensure that any unique instructions or logic specific to the prompt being modified are retained and remain clear.
+                - Remember to include any other relevant instructions for modifying the prompt that are not related to file inclusions.
+                - When finished, review the instructions to ensure they will make sense after any preprocessing steps that may occur.
+        </analysis>
+</task>
+
+% Remember to be thorough in your analysis and clear in your explanations. Consider all aspects of the change description and its potential impacts on the prompts.

pdd/prompts/example_generator_LLM.prompt

@@ -0,0 +1,10 @@
+% You are an expert software engineer. Generate a concise example of how to use the following module properly: <code_module>{code_module}</code_module>
+
+% Here was the prompt used to generate the module: <prompt_for_code>{processed_prompt}</prompt_for_code>
+
+% The language of the example should be in: <language_for_example>{language}</language_for_example>
+
+% Make sure the following happens:
+    - Document in detail what the input and output parameters in the doc strings
+    - Someone needs to be able to fully understand how to use the module from the example.
+<include>./context/example.prompt</include>

pdd/prompts/extract_auto_include_LLM.prompt

@@ -0,0 +1,6 @@
+% You are an expert Prompt Engineer. Your goal is to extract the dependencies string from the output of a LLM. 
+
+% Here is the generated llm_output: <llm_output>{llm_output}</llm_output>
+
+% Output a JSON object with the following keys:
+    - 'string_of_includes': String containing the verbatim output of Step 4.

pdd/prompts/extract_code_LLM.prompt

@@ -0,0 +1,22 @@
+% You are an expert Software Engineer. Your goal is to extract the block of text (usually code) from llm_output to be outputed in JSON format.
+
+% Here is the llm_output to parse: <llm_output>{llm_output}</llm_output>
+
+% Here is the type of the text block to extract: <block_type>{language}</block_type>. If type of the block is 'prompt' then the focus is the prompt itself and that is what should be extracted. If the type is 'log' or 'restructuredtext' then the focus is the report itself and that is what should be extracted.
+
+% Otherwise, when not extracting 'prompt' or 'log', you are extracting a code block from llm_output, consider and correct the following for the extracted code:
+    - Should be the block of code typically delimited by triple backticks followed by the name of the language of the block. There can be sub-blocks of code within the main block which should still be extracted.
+    - Should be the primary focus of the LLM prompt that generated llm_output. Sometimes the primary focus on the generation was to create a prompt. If so, this is the code to be extracted. Generated prompts are often not in triple backticks but should still be extracted.
+    - Should be runnable (if not a prompt) with non-runnable text commented or cut out without the initial triple backticks that start or end the code block. Sub code blocks that have triple backticks should still be included.
+    - Should be complete and not missing any necessary components or have any errors.
+    - Should handle any errors or exceptions that may occur.
+    - Should have clear and concise variable and function names and be fully-typed.
+    - Should be properly documented with comments that explain why something is done and having doc strings or equivalent.
+    - Should be properly PEP 8, if Python, formatted and indented with the proper naming conventions.
+    - Never add example calling unless it is already in the code block and if it is a submodule have the conditional main execution for the example.
+    - All the functionality of the code block should still be present.
+
+% Output a JSON object with the following keys:
+    - 'focus': String containing the focus of the generation.
+    - 'explanation': String explanation of why this block_type was the focus of the generation and explain any errors detected in the code, if a code type of block.
+    - 'extracted_code': String containing the entire generated and corrected block_type of focus.

pdd/prompts/extract_conflict_LLM.prompt

@@ -0,0 +1,19 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON which contains a list of JSON from the output of a LLM. This LLM generated list of prompts that need to be changed to resolve conflicts.
+
+% Here is the generated llm_output: <llm_output>{llm_output}</llm_output>
+
+% Output a JSON with key changes_list which has a value that is the list of JSON objects with the following keys:
+    - 'prompt_name': Indicate with 'prompt_1' or 'prompt_2' which prompt needs to be changed.
+    - 'change_instructions': Detailed instructions of how the prompt should be changed. This should have as much information as the LLM output provides for this prompt.
+    
+% Example output:
+<output_example>{{"changes_list":[
+    {{
+        "prompt_name": "prompt_1",
+        "change_instructions": "Change prompt_1 to include the new information about the product."
+    }},
+    {{
+        "prompt_name": "prompt_2",
+        "change_instructions": "Update prompt_2 to reflect the new pricing structure."
+    }}
+]}}</output_example>

pdd/prompts/extract_detect_change_LLM.prompt

@@ -0,0 +1,19 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON which contains a list of JSON from the output of a LLM. This LLM generated list of prompts that need to be changed.
+
+% Here is the generated llm_output: <llm_output>{llm_output}</llm_output>
+
+% Output a JSON with key changes_list which has a value that is the list of JSON objects with the following keys:
+    - 'prompt_name': String which containts the exact name of prompt that needs to be changed.
+    - 'change_instructions': Detailed instructions of how the prompt should be changed. This should have as much information as the LLM output provides for this prompt.
+    
+% Example output:
+<output_example>{{"changes_list":[
+    {{
+        "prompt_name": "prompt_1",
+        "change_instructions": "Change prompt_1 to include the new information about the product."
+    }},
+    {{
+        "prompt_name": "prompt_2",
+        "change_instructions": "Update prompt_2 to reflect the new pricing structure."
+    }}
+]}}</output_example>

pdd/prompts/extract_program_code_fix_LLM.prompt

@@ -0,0 +1,16 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON from a analysis of a program and code module bug fix report. If there is a choice of updating the program or the code module, you should chose to update the code module.
+
+% Here is the original program: <program>{program}</program>
+
+% Here is the original code module: <code_module>{code}</code_module>
+
+% Here is the program/code module bug fix report: ```{program_code_fix}```
+
+% Sometimes the fix may only contain partial code. In these cases, you need to incorporate the fix into the original program and/or original code module.
+
+% Output a JSON object with the following keys:
+    - 'explanation': String explanation of whether the code under test needs to be fix and/or if the unit test needs to be fixed.
+    - 'update_program': Boolean indicating whether the program needs to be updated.
+    - 'update_code': Boolean indicating whether the code module needs to be updated.
+    - 'fixed_program': The entire updated program code or empty String if no update is needed.
+    - 'fixed_code': The entire updated code module or empty String if no update is needed.

pdd/prompts/extract_prompt_change_LLM.prompt

@@ -0,0 +1,7 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON from the output of a LLM. This LLM changed a input_prompt into a modified_prompt. 
+
+% Here is the generated llm_output: ```{llm_output}```
+
+% Output a JSON object with the following keys:
+    - 'modified_prompt': String containing the modified prompt from input_prompt via the change_prompt.
+    

pdd/prompts/extract_prompt_split_LLM.prompt

@@ -0,0 +1,9 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON from the output of a LLM. This LLM split a prompt into a sub_prompt and modified_prompt. 
+
+% Here is the generated llm_output: ```{llm_output}```
+
+% Output a JSON object with the following keys:
+    - 'explaination': String containing the explaination of the split and how the prompts should be extracted properly so that both prompts are complete and functional. For instance, sometimes there will be messages like '[... other internal module examples ...]' which means text is missing and should be copied the input prompt.
+    - 'sub_prompt': String containing the sub_prompt that was split from the input_prompt.
+    - 'modified_prompt': String containing the complete modified prompt from input_prompt split from the sub_prompt. Sometimes only the changed portion of the modified prompt is given so you may need to combine it with parts of the input prompt get the complete modified prompt.
+    

pdd/prompts/extract_prompt_update_LLM.prompt

@@ -0,0 +1,8 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON from the output of a LLM. This LLM changed a input_prompt into a modified_prompt. 
+
+% Here is the generated llm_output: ```{llm_output}```
+
+% Output a JSON object with the following keys:
+    - 'modified_prompt': String containing the modified prompt that will generate the modified code.
+    
+

pdd/prompts/extract_promptline_LLM.prompt

@@ -0,0 +1,11 @@
+% You are an expert Software Engineer. Your goal is to extract the closest matching substring described by the prompt's output to be outputed in JSON format.
+
+% Here is the llm_output to parse: <llm_output>{llm_output}</llm_output>
+
+% When extracting the closest matching substring from llm_output, consider and correct the following for the extracted code:
+    - Should be a substring of prompt_file.
+    - Should be a a substring that closely matches code_str in content.
+
+% Output a JSON object with the following keys:
+    - 'explanation': String explanation of why this prompt_line matches the code_str and explain any errors detected in the code.
+    - 'prompt_line': String containing the closest matching verbatim substring of the prompt_file that matches code_str in content. This is not the line number.