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

pdd/prompts/split_LLM.prompt

@@ -1,65 +1,4 @@
-    <pdd>
-    % Here are some examples of splitting prompts:
-<examples>
-
-        <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>
-
-
-    <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>
-</pdd>
+    
 
 <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.

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>