pdd-cli 0.0.2__py3-none-any.whl

pdd/prompts/extract_unit_code_fix_LLM.prompt

@@ -0,0 +1,332 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON (containing keys that have the entire updated code under test and/or unit test) from an analysis of a unit test bug fix report. If there is a choice of updating the unit test or the code under test to resolve the problem, you should chose to update the code under test.
+
+% Here is the original unit test code: <unit_test>{unit_test}</unit_test>
+
+% Here is the original code under test: <code_under_test>{code}</code_under_test>
+
+% Here is the unit test bug fix report: <fix_report>{unit_test_fix}</fix_report>
+
+% Sometimes the fix report may only contain partial code snippet(s) of the unit test and/or code under test. In these cases, you need to incorporate the partial fix(es) into the original unit test and/or original code under test so the test and code files are always complete. Read the text around the code block to determine this. Also, often this is signified by comments in the code like:
+    - `# Rest of the code remains the same`, 
+    - `# Other tests remain unchanged`
+    - `# ... [remaining test functions remain unchanged]` or 
+    - `# ... rest of the test file remains unchanged ...` at the end of code snippets. 
+
+% Here are examples of inputs and proper outputs of this prompt:
+    <examples>
+        <example_1>
+            <input_example>
+                <unit_test_example>
+                    import pytest
+                    from auth_service import AuthService
+
+                    @pytest.fixture
+                    def auth_service():
+                        return AuthService()
+
+                    def test_valid_login(auth_service):
+                        result = auth_service.login("user@example.com", "password123")
+                        assert result.success
+                        assert result.token is not None
+
+                    def test_invalid_password(auth_service):
+                        result = auth_service.login("user@example.com", "wrongpass")
+                        assert not result.success
+                        assert result.token is None
+                </unit_test_example>
+
+                <fix_report_example>
+                    ```python
+                    # Code above this line remains the same
+                    def test_invalid_email_format(auth_service):
+                        result = auth_service.login("invalid-email", "password123")
+                        assert not result.success
+                        assert result.error == "Invalid email format"
+
+                    def test_empty_credentials(auth_service):
+                        result = auth_service.login("", "")
+                        assert not result.success
+                        assert result.error == "Email and password required"
+                    ```
+                </fix_report_example>
+            </input_example>
+
+            <output_example>
+                <fixed_unit_test_example>
+                import pytest
+                from auth_service import AuthService
+
+                @pytest.fixture
+                def auth_service():
+                    return AuthService()
+
+                def test_valid_login(auth_service):
+                    result = auth_service.login("user@example.com", "password123")
+                    assert result.success
+                    assert result.token is not None
+
+                def test_invalid_password(auth_service):
+                    result = auth_service.login("user@example.com", "wrongpass")
+                    assert not result.success
+                    assert result.token is None
+
+                def test_invalid_email_format(auth_service):
+                    result = auth_service.login("invalid-email", "password123")
+                    assert not result.success
+                    assert result.error == "Invalid email format"
+
+                def test_empty_credentials(auth_service):
+                    result = auth_service.login("", "")
+                    assert not result.success
+                    assert result.error == "Email and password required"
+                </fixed_unit_test_example>
+            <output_example>
+        </example_1>
+
+        <example_2>
+            <input_example>
+                <unit_test_example>
+                    import pytest
+                    from auth_service import AuthService
+
+                    @pytest.fixture
+                    def auth_service():
+                        return AuthService()
+
+                    def test_valid_login(auth_service):
+                        result = auth_service.login("user@example.com", "password123")
+                        assert result.success
+                        assert result.token is not None
+
+                    def test_invalid_password(auth_service):
+                        result = auth_service.login("user@example.com", "wrongpass")
+                        assert not result.success
+                        assert result.token is None
+                </unit_test_example>
+
+                <fix_report_example>
+                    ```python
+                    import pytest
+                    from auth_service import AuthService                    
+
+                    # ... [other tests] ...
+
+                    def test_invalid_email_format(auth_service):
+                        result = auth_service.login("invalid-email", "password123")
+                        assert not result.success
+                        assert result.error == "Invalid email format"
+
+                    def test_empty_credentials(auth_service):
+                        result = auth_service.login("", "")
+                        assert not result.success
+                        assert result.error == "Email and password required"
+                    ```
+                </fix_report_example>
+            </input_example>
+
+            <output_example>
+                <fixed_unit_test_example>
+                import pytest
+                from auth_service import AuthService
+
+                @pytest.fixture
+                def auth_service():
+                    return AuthService()
+
+                def test_valid_login(auth_service):
+                    result = auth_service.login("user@example.com", "password123")
+                    assert result.success
+                    assert result.token is not None
+
+                def test_invalid_password(auth_service):
+                    result = auth_service.login("user@example.com", "wrongpass")
+                    assert not result.success
+                    assert result.token is None
+
+                def test_invalid_email_format(auth_service):
+                    result = auth_service.login("invalid-email", "password123")
+                    assert not result.success
+                    assert result.error == "Invalid email format"
+
+                def test_empty_credentials(auth_service):
+                    result = auth_service.login("", "")
+                    assert not result.success
+                    assert result.error == "Email and password required"
+                </fixed_unit_test_example>
+            <output_example>
+        </example_2>
+
+        <example_3>
+            <input_example>
+                <unit_test_example>
+                    import pytest
+                    from calculator import Calculator
+
+                    @pytest.fixture
+                    def calc():
+                        return Calculator()
+
+                    def test_add(calc):
+                        assert calc.add(2, 3) == 5
+                        assert calc.add(-1, 1) == 0
+
+                    def test_subtract(calc):
+                        assert calc.subtract(5, 3) == 2
+                        assert calc.subtract(1, 1) == 0
+                </unit_test_example>
+
+                <fix_report_example>
+                    ```python                
+                    import pytest
+                    from calculator import Calculator
+
+                    @pytest.fixture
+                    def calc():
+                        return Calculator()
+
+                    def test_add(calc):
+                        assert calc.add(2, 3) == 5
+                        assert calc.add(-1, 1) == 0
+
+                    def test_subtract(calc):
+                        assert calc.subtract(5, 3) == 2
+                        assert calc.subtract(1, 1) == 0
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.1, 0.2, 0.3),
+                        (-0.5, 0.5, 0.0),
+                    ])
+                    def test_add_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.add(a, b)) == expected
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.3, 0.1, 0.2),
+                        (1.0, 0.5, 0.5),
+                    ])
+                    def test_subtract_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.subtract(a, b)) == expected
+                    ```
+                </fix_report_example>
+            </input_example>
+
+            <output_example>
+                <fixed_unit_test_example>
+                    import pytest
+                    from calculator import Calculator
+
+                    @pytest.fixture
+                    def calc():
+                        return Calculator()
+
+                    def test_add(calc):
+                        assert calc.add(2, 3) == 5
+                        assert calc.add(-1, 1) == 0
+
+                    def test_subtract(calc):
+                        assert calc.subtract(5, 3) == 2
+                        assert calc.subtract(1, 1) == 0
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.1, 0.2, 0.3),
+                        (-0.5, 0.5, 0.0),
+                    ])
+                    def test_add_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.add(a, b)) == expected
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.3, 0.1, 0.2),
+                        (1.0, 0.5, 0.5),
+                    ])
+                    def test_subtract_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.subtract(a, b)) == expected
+                </fixed_unit_test_example>
+            </output_example>
+        </example_3>
+
+        <example_4>
+            <input_example>
+                <unit_test_example>
+                    import pytest
+                    from calculator import Calculator
+
+                    @pytest.fixture
+                    def calc():
+                        return Calculator()
+
+                    def test_add(calc):
+                        assert calc.add(2, 3) == 5
+                        assert calc.add(-1, 1) == 0
+
+                    def test_subtract(calc):
+                        assert calc.subtract(5, 3) == 2
+                        assert calc.subtract(1, 1) == 0
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.1, 0.2, 0.3),
+                        (-0.5, 0.5, 0.0),
+                    ])
+                    def test_add_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.add(a, b)) == expected
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.3, 0.1, 0.2),
+                        (1.0, 0.5, 0.5),
+                    ])
+                    def test_subtract_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.subtract(a, b)) == expected
+                </unit_test_example>
+
+                <fix_report_example>
+                    ```python
+                    # Code above this line remains the same
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.5, 0.3, 0.2),
+                        (-0.5, 0.7, 0.2),
+                    ])
+                    # Rest of the test cases remain the same...
+                    ```
+                </fix_report_example>
+            </input_example>
+
+            <output_example>
+                <fixed_unit_test_example>
+                    import pytest
+                    from calculator import Calculator
+
+                    @pytest.fixture
+                    def calc():
+                        return Calculator()
+
+                    def test_add(calc):
+                        assert calc.add(2, 3) == 5
+                        assert calc.add(-1, 1) == 0
+
+                    def test_subtract(calc):
+                        assert calc.subtract(5, 3) == 2
+                        assert calc.subtract(1, 1) == 0
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.5, 0.3, 0.2),
+                        (-0.5, 0.7, 0.2),
+                    ])
+                    def test_add_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.add(a, b)) == expected
+
+                    @pytest.mark.parametrize("a,b,expected", [
+                        (0.3, 0.1, 0.2),
+                        (1.0, 0.5, 0.5),
+                    ])
+                    def test_subtract_floating_point(calc, a, b, expected):
+                        assert pytest.approx(calc.subtract(a, b)) == expected
+                </fixed_unit_test_example>
+            </output_example>
+        </example_4>
+    </examples>
+
+% 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. Also, explain whether only a fragment of code was provided and the entire unit test and/or code under test needs to be reassembled from the original code and/or unit test.
+    - 'update_unit_test': Boolean indicating whether the unit test needs to be updated.
+    - 'update_code': Boolean indicating whether the code under test needs to be updated.
+    - 'fixed_unit_test': The entire updated unit test code or empty String if no update is needed.
+    - 'fixed_code': The entire updated code under test or empty String if no update is needed.

pdd/prompts/extract_xml_LLM.prompt

@@ -0,0 +1,7 @@
+% You are an expert Software Engineer. Your goal is to extract a JSON from a analysis of a prompt that contains inserted XML tags.
+
+% Here is the generated XML prompt_analysis: <prompt_analysis>{xml_generated_analysis}</prompt_analysis>
+
+% Output a JSON object with the following keys:
+    - 'explanation': String explanation of why the extracted prompt is the prompt with inserted XML tags.
+    - 'xml_tagged': String of just the entire prompt with inserted XML tags. Preserve the formatting so the text is easy to read. Don't include the prompt_analysis tags.

pdd/prompts/fix_code_module_errors_LLM.prompt

@@ -0,0 +1,17 @@
+% You are an expert Software Engineer. Your goal is to fix the errors in a code_module or program that is causing that program to crash.
+
+% Here is the program that is running the code_module that crashed and/or has errors: <program>{program}</program>
+
+% Here is the prompt that generated the code_module below: <prompt>{prompt}</prompt>
+
+% Here is the code_module that is being used by the program: <code_module>{code}</code_module>
+
+% Here are the error log(s) from the program run and potentially from prior program run fixes: <errors>{errors}</errors>
+
+% Follow these steps to solve these errors:
+    Step 1. Compare the prompt to the code_module and explain differences, if any.
+    Step 2. Compare the prompt to the program and explain differences, if any.
+    Step 3. Explain in detail step by step why there might be an an error and why prior attempted fixes, if any, may not have worked. Write several paragraphs explaining the root cause of each of the errors.
+    Step 4. Explain in detail step by step how to solve each of the errors. For each error, there should be several paragraphs description of the steps. Sometimes logging or print statements can help debug the code_module or program.
+    Step 5. Review the above steps and correct for any errors in the logic.
+    Step 6. For the code that need changes, write the corrected code_module and/or corrected program in its/their entirety.

pdd/prompts/fix_errors_from_unit_tests_LLM.prompt

@@ -0,0 +1,62 @@
+% You are an expert Software Engineer. Your goal is to diagnose and fix the errors from a unit_test run on the code_under_test. The error might be in the code_under_test or the unit_test or both.
+
+% Here is the unit_test for the code_under_test: <unit_test>{unit_test}</unit_test>
+
+% Here is the code_under_test: <code_under_test>{code}</code_under_test>
+
+% Here is the prompt that generated the code_under_test: <prompt>{prompt}</prompt>
+
+% This prompt is run iteratively. Here are the current errors and past potential fix attempts, if any, from the unit test and verification program run(s): <errors>{errors}</errors>
+
+<examples>
+    <example_1>
+    % Here is an example_unit_test for the example_code_under_test: <example_unit_test><include>context/fix_errors_from_unit_tests/1/test_conflicts_in_prompts.py</include></example_unit_test>
+    
+    % Here is an example_code_under_test that fully passes the example_unit_test: <example_code_under_test><include>context/fix_errors_from_unit_tests/1/conflicts_in_prompts.py</include></example_code_under_test>
+
+    % Here is the prompt that generated the example_code_under_test: <example_prompt><include>context/fix_errors_from_unit_tests/1/conflicts_in_prompts_python.prompt</include></example_prompt>
+    </example_1>
+
+    <example_2>
+    % Here is an example_unit_test for the example_code_under_test: <example_unit_test><include>context/fix_errors_from_unit_tests/2/test_code_generator.py</include></example_unit_test>
+
+    % Here is an example_code_under_test that fully passes the example_unit_test: <example_code_under_test><include>context/fix_errors_from_unit_tests/2/code_generator.py</include></example_code_under_test>
+
+    % Here is the prompt that generated the example_code_under_test: <example_prompt><include>context/fix_errors_from_unit_tests/2/code_generator_python.prompt</include></example_prompt>
+    </example_2>
+
+    <example_3>
+    % Here is an example_unit_test for the example_code_under_test: <example_unit_test><include>context/fix_errors_from_unit_tests/3/test_context_generator.py</include></example_unit_test>
+
+    % Here is an example_code_under_test that fully passes the example_unit_test: <example_code_under_test><include>context/fix_errors_from_unit_tests/3/context_generator.py</include></example_code_under_test>
+
+    % Here is the prompt that generated the example_code_under_test: <example_prompt><include>context/fix_errors_from_unit_tests/3/context_generator_python.prompt</include></example_prompt>
+    </example_3>
+
+    <example_4>
+    % Here is an example_unit_test for the example_code_under_test: <example_unit_test><include>context/fix_errors_from_unit_tests/4/test_detect_change.py</include></example_unit_test>
+
+    % Here is an example_code_under_test that fully passes the example_unit_test: <example_code_under_test><include>context/fix_errors_from_unit_tests/4/detect_change.py</include></example_code_under_test>
+
+    % Here is the prompt that generated the example_code_under_test: <example_prompt><include>context/fix_errors_from_unit_tests/4/detect_change_python.prompt</include></example_prompt>
+    </example_4>
+
+    <example_5>
+    % Here is an example_unit_test for the example_code_under_test: <example_unit_test><include>context/fix_errors_from_unit_tests/4/test_detect_change_1_0_1.py</include></example_unit_test>
+
+    % Here is an example_code_under_test that didn't fully pass the example_unit_test: <example_code_under_test><include>context/fix_errors_from_unit_tests/4/detect_change_1_0_1.py</include></example_code_under_test>
+
+    % Here is an example error/fix log showing how the issues were resolved: <example_error_fix_log><include>context/fix_errors_from_unit_tests/4/error.log</include></example_error_fix_log>
+    </example_5>
+</examples>
+
+<instructions>
+% Follow these steps to solve these errors:
+    Step 1. Compare the prompt to the code_under_test and explain differences, if any.
+    Step 2. Compare the prompt to the unit_test and explain differences, if any.
+    Step 3. For each prior attempted fix (if any), explain in a few paragraphs for each attempt why it might not have worked.
+    Step 4. Write several paragraphs explaining the root cause of each of the errors.
+    Step 5. Explain in detail step by step how to solve each of the errors. For each error, there should be several paragraphs description of the solution steps. Sometimes logging or print statements can help debug the code.
+    Step 6. Review the above steps and correct for any errors in the code under test or unit test.
+    Step 7. For the code that need changes, write the corrected code_under_test and/or corrected unit_test in its/their entirety.
+</instructions>

pdd/prompts/generate_test_LLM.prompt

@@ -0,0 +1,12 @@
+% You are an expert Software Test Engineer. Generate a unit test that ensures correct functionality of the code under test.
+
+% Here a description of what the code is supposed to do and was the prompt that generated the code: ```{prompt_that_generated_code}```
+
+% Here is the code under test: ```{code}```
+
+% Follow these rules:
+    - The module name for the code under test will have the same name as the function name
+    - The unit test should be in {language}. If Python, use pytest.
+    - Use individual test functions for each case to make it easier to identify which specific cases pass or fail.
+    - Use the description of the functionality in the prompt to generate tests with useful tests with good code coverage.
+<include>./context/test.prompt</include>

pdd/prompts/increase_tests_LLM.prompt

@@ -0,0 +1,16 @@
+% You are an expert Software Test Engineer. Given an existing set of unit tests along with their coverage reports, generate additional unit tests that provide more coverage for the code under test.
+
+% Here a description of what the code is supposed to do and was the prompt that generated the code: ```{prompt_that_generated_code}```
+
+% Here is the code under test: ```{code}```
+
+Here are the existing unit tests: ```{existing_unit_tests}```
+
+Here is the coverage report: ```{coverage_report}```
+
+% Follow these rules:
+    - The module name for the code under test will have the same name as the function name
+    - The unit test should be in {language}. If Python, use pytest.
+    - Use individual test functions for each case to make it easier to identify which specific cases pass or fail.
+    - Use the description of the functionality in the prompt to generate tests with useful tests with good code coverage.
+<include>./context/test.prompt</include>

pdd/prompts/insert_includes_LLM.prompt

@@ -0,0 +1,30 @@
+% You are an expert prompt engineer. You goal is to properly insert in dependencies into a prompt.
+
+% Here are few examples of how to properly insert dependencies into a prompt:
+<examples>
+    <example id="1">
+        INPUT:
+        <prompt_to_update><include>context/insert/1/prompt_to_update.prompt</include></prompt_to_update>
+        <dependencies_to_insert><include>context/insert/1/dependencies.prompt</include></dependencies_to_insert>
+
+        OUTPUT:
+        <updated_prompt><include>context/insert/1/updated_prompt.prompt</include></updated_prompt>
+    <example>
+
+    <example id="2">
+        INPUT:
+        <prompt_to_update><include>context/insert/2/prompt_to_update.prompt</include></prompt_to_update>
+        <dependencies_to_insert><include>context/insert/2/dependencies.prompt</include></dependencies_to_insert>
+
+        OUTPUT:
+        <updated_prompt><include>context/insert/2/updated_prompt.prompt</include></updated_prompt>
+    <example>
+<examples>
+
+% Generate the output for following inputs based on above examples:
+<prompt_to_update>{actual_prompt_to_update}</prompt_to_update>
+<dependencies_to_insert>{actual_dependencies_to_insert}</dependencies_to_insert>
+
+% The output prompt will be in JSON format with the following keys:
+    - 'explanation': A string containing of why the dependencies were inserted in a certain location in the prompt.
+    - 'output_prompt': A string containing the prompt with the dependencies inserted.

pdd/prompts/split_LLM.prompt

@@ -0,0 +1,94 @@
+% Here are some examples of splitting prompts:
+<examples>
+    <pdd>
+        <example_1>
+        <1_input_prompt><include>./context/split/1/initial_pdd_python.prompt</include></1_input_prompt>
+        <1_input_code><include>./context/split/1/pdd.py</include></1_input_code>
+        <1_example_code><include>./context/split/1/split_get_extension.py</include></1_example_code>
+        <1_sub_prompt><include>./context/split/1/sub_pdd_python.prompt</include></1_sub_prompt>
+        <1_modified_prompt><include>./context/split/1/final_pdd_python.prompt</include></1_modified_prompt>
+        </example_1>
+
+        <example_2>
+        <2_input_prompt><include>./context/split/2/initial_pdd_python.prompt</include></2_input_prompt>
+        <2_input_code><include>./context/split/2/pdd.py</include></2_input_code>
+        <2_example_code><include>./context/split/2/split_pdd_construct_output_path.py</include></2_example_code>
+        <2_sub_prompt><include>./context/split/2/sub_pdd_python.prompt</include></2_sub_prompt>
+        <2_modified_prompt><include>./context/split/2/final_pdd_python.prompt</include></2_modified_prompt>
+        </example_2>
+
+        <example_3>
+        <3_input_prompt><include>./context/split/3/initial_postprocess_python.prompt</include></3_input_prompt>
+        <3_input_code><include>./context/split/3/postprocess.py</include></3_input_code>
+        <3_example_code><include>./context/split/3/split_postprocess_find_section.py</include></3_example_code>
+        <3_sub_prompt><include>./context/split/3/sub_postprocess_python.prompt</include></3_sub_prompt>
+        <3_modified_prompt><include>./context/split/3/final_postprocess_python.prompt</include></3_modified_prompt>
+        </example_3>
+
+        <example_4>
+        <4_input_prompt><include>./context/split/4/initial_construct_paths_python.prompt</include></4_input_prompt>
+        <4_input_code><include>./context/split/4/construct_paths.py</include></4_input_code>
+        <4_example_code><include>./context/split/4/split_construct_paths_generate_output_filename.py</include></4_example_code>
+        <4_sub_prompt><include>./context/split/4/sub_construct_paths_python.prompt</include></4_sub_prompt>
+        <4_modified_prompt><include>./context/split/4/final_construct_paths_python.prompt</include></4_modified_prompt>
+        </example_4>
+
+        <example_5>
+        <5_input_prompt><include>context/split/5/cli_python.prompt</include></5_input_prompt>
+        <5_input_code><include>context/split/5/cli.py</include></5_input_code>
+        <5_example_code><include>context/split/5/split_track_cost.py</include></5_example_code>
+        <5_sub_prompt><include>context/split/5/track_cost_python.prompt</include></5_sub_prompt>
+        <5_modified_prompt><include>context/split/5/modified_cli_python.prompt</include></5_modified_prompt>
+        </example_5>
+</pdd>
+
+    <example_6>
+    <6_input_prompt><include>context/split/6/cli_python.prompt</include></6_input_prompt>
+    <6_input_code><include>context/split/6/cli.py</include></6_input_code>
+    <6_example_code><include>context/split/6/split_conflicts.py</include></6_example_code>
+    <6_sub_prompt><include>context/split/6/conflicts_main_python.prompt</include></6_sub_prompt>
+    <6_modified_prompt><include>context/split/6/modified_cli_python.prompt</include></6_modified_prompt>
+    </example_6>
+
+    <example_7>
+    <7_input_prompt><include>context/split/7/cli_python.prompt</include></7_input_prompt>
+    <7_input_code><include>context/split/7/cli.py</include></7_input_code>
+    <7_example_code><include>context/split/7/split_trace_main.py</include></7_example_code>
+    <7_sub_prompt><include>context/split/7/trace_main_python.prompt</include></7_sub_prompt>
+    <7_modified_prompt><include>context/split/7/modified_cli_python.prompt</include></7_modified_prompt>
+    </example_7>
+
+</examples>
+
+<context>
+% You are an expert LLM Prompt Engineer. Your goal is to split the input_prompt (a larger prompt) into a sub_prompt and modified_prompt (two smaller prompts) with no loss of functionality. This is to make it easier to generate and test the modules easier.
+
+% Here are the inputs and outputs of this prompt:
+    <input_definitions>
+    Input: 
+        'input_prompt' - A string contains the prompt that will be split into a sub_prompt and modified_prompt.
+        'input_code' - A string that contains the code that was generated from the input_prompt.
+        'example_code' - A string that contains the code example of how the code generated from the sub_prompt would be used by the code generated from the modified_prompt.
+    </input_definitions>
+    <output_definitions>
+    Output: 
+        'sub_prompt' - A string that contains the sub_prompt that was split from the input_prompt.
+        'modified_prompt' - A string that contains the modified prompt from input_prompt split from the above sub_prompt.
+    </output_definitions>
+</context>
+
+<inputs>
+    <input_prompt>{input_prompt}</input_prompt>
+    <input_code>{input_code}</input_code>
+    <example_code>{example_code}</example_code>
+</inputs>
+
+<instructions>
+% Follow these instructions:
+    1. Write several paragraphs to explain based on the example_code how the input_prompt could be split into a sub_prompt and modified_prompt.
+    2. Write out several paragraphs in detail all the functionality of the sub_prompt by looking at the input_prompt and input_code.
+    3. Write out what are the possible difficulties in splitting the prompt according to the input example_code. For each difficulty write several paragraphs
+    4. Write out how to overcome the difficulties. Write several paragraphs for each difficulty.
+    5. Write the sub_prompt which would generate the code that could be used by the example_code. This prompt should carefully consider all the prior steps and ensure enough detail is provided to generate the code properly. Internal modules need to be imported using include and other appropriate xml tags in the same style as the input_prompt. 
+    6. Write the complete modified_prompt which would incorporate the sub_prompt without any duplications or conflicting functionalities.
+</instructions>

pdd/prompts/summarize_file_LLM.prompt

@@ -0,0 +1,11 @@
+% Review the input string and provide a summary of its contents in about 200 words. 
+
+% Here are the Inputs/Outputs:
+    - input:
+        'file_contents': A string containing the contents of the file to summarize.
+    - output: JSON output with the following key:
+        'file_summary': A string containing the summary of the file.
+
+<file_contents>
+    {file_contents}
+</file_contents>

pdd/prompts/trace_LLM.prompt

@@ -0,0 +1,30 @@
+% 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: 
+
+<code_file>
+    {CODE_FILE}
+</code_file>
+
+% Here is the code_str to reference:
+
+<code_str>
+    {CODE_STR}
+</code_str>
+
+% Here is the prompt_file to reference:
+
+<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.
+