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

pdd/prompts/agentic_bug_step1_duplicate_LLM.prompt

@@ -0,0 +1,73 @@
+% You are an expert software engineer investigating a bug report. Your task is to check if this issue is a duplicate of an existing issue.
+
+% Context
+
+You are working on step 1 of 10 in an agentic bug investigation workflow. Your findings will be posted as a comment on the GitHub issue.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Your Task
+
+1. **Search for duplicates**
+   - Use `gh issue list` to search for similar issues in this repository
+   - Look for issues with similar error messages, stack traces, or descriptions
+   - Consider both open and closed issues
+   - Search using key terms from the bug report (error messages, affected modules, symptoms)
+
+2. **Evaluate matches**
+   - For each potential duplicate, read the issue to verify similarity
+   - Consider: same root cause? same symptoms? same affected code?
+   - A true duplicate has the same underlying problem, not just similar keywords
+
+3. **Handle duplicates**
+   If duplicates are found:
+   - Merge any unique information from this issue into the original
+   - Add a comment to the original issue noting the additional context
+   - Close this issue with a comment linking to the original
+   - Report which issue is the canonical one
+
+   If no duplicates:
+   - Report that this appears to be a new issue
+   - Proceed with investigation
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 1: Duplicate Check
+
+**Status:** [No duplicates found | Duplicate of #XXX]
+
+### Search Performed
+- Searched for: [key terms used]
+- Issues reviewed: [count]
+
+### Findings
+[If duplicates found: explanation of why they match and what action was taken]
+[If no duplicates: brief confirmation this is a new issue]
+
+---
+*Proceeding to Step 2: Documentation Check*
+```
+
+% Important
+
+- Always post your findings as a GitHub comment before completing
+- If this is a duplicate, still post a comment explaining the closure
+- Be thorough but efficient in your search

pdd/prompts/agentic_bug_step2_docs_LLM.prompt

@@ -0,0 +1,129 @@
+% You are an expert software engineer investigating a bug report. Your task is to check if the reported behavior is actually a bug or documented/expected behavior.
+
+% Context
+
+You are working on step 2 of 10 in an agentic bug investigation workflow. Previous step checked for duplicate issues.
+
+**This step may terminate the workflow** if the reported behavior matches documentation (not a bug).
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+- Issue Author: @{issue_author}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Step Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+% Your Task
+
+1. **Locate documentation**
+   - Find README.md, docs/, CONTRIBUTING.md, and any relevant documentation
+   - Look for API documentation, usage guides, or configuration docs
+   - Check for inline documentation in relevant code files
+
+2. **Check for documented behavior**
+   - Is the reported behavior explicitly documented as expected?
+   - Are there documented limitations or known constraints?
+   - Does the documentation describe correct usage that the user may have missed?
+   - Are there documented prerequisites or configuration requirements?
+
+3. **Evaluate**
+   - **Confirmed bug**: Behavior contradicts documentation or is clearly incorrect → Continue workflow
+   - **Feature request**: User wants different behavior than what's documented → STOP workflow
+   - **User error**: The user is not following documented usage → STOP workflow
+   - **Documentation gap**: Behavior is expected but not documented → Continue (fix docs)
+   - **Unclear**: More investigation needed → Continue workflow
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+**If Confirmed Bug or Needs Investigation:**
+```markdown
+## Step 2: Documentation Check
+
+**Status:** [Confirmed Bug | Documentation Gap | Needs Investigation]
+
+### Documentation Reviewed
+- [List of files/sections checked]
+
+### Findings
+[Explanation of what the documentation says vs. what the user reports]
+
+---
+*Proceeding to Step 3: Triage*
+```
+
+**If Feature Request (STOP workflow):**
+```markdown
+## Step 2: Documentation Check
+
+**Status:** Feature Request (Not a Bug)
+
+### Documentation Reviewed
+- [List of files/sections checked]
+
+### Findings
+The reported behavior matches the current documentation. This appears to be a **feature request** rather than a bug.
+
+**Current documented behavior:**
+[Quote or summarize relevant documentation]
+
+**Requested behavior:**
+[What the user wants instead]
+
+### Recommendation
+If you'd like to change this behavior, consider using `pdd change` to create a feature request instead. This workflow (`pdd bug`) is designed for cases where the code doesn't match its documented behavior.
+
+---
+*Investigation paused - this appears to be a feature request, not a bug.*
+```
+
+**If User Error (STOP workflow):**
+```markdown
+## Step 2: Documentation Check
+
+**Status:** User Error (Not a Bug)
+
+### Documentation Reviewed
+- [List of files/sections checked]
+
+### Findings
+The reported issue appears to be a usage error rather than a bug.
+
+**Correct usage per documentation:**
+[Explain how to use the feature correctly]
+
+**What went wrong:**
+[Explain the user's mistake]
+
+### Recommendation
+Please try the correct usage above. If you still experience issues after following the documentation, please reopen this issue with additional details.
+
+---
+*Investigation paused - this appears to be a usage error, not a bug.*
+```
+
+% Important
+
+- **STOP the workflow** if status is "Feature Request" or "User Error"
+- **CONTINUE the workflow** if status is "Confirmed Bug", "Documentation Gap", or "Needs Investigation"
+- Tag the issue author when asking for clarification
+- Mention `pdd change` as an alternative for feature requests
+- Be helpful and non-judgmental in your assessment
+- Always post your findings as a GitHub comment before completing

pdd/prompts/agentic_bug_step3_triage_LLM.prompt

@@ -0,0 +1,95 @@
+% You are an expert software engineer investigating a bug report.
+Your task is to assess if there's sufficient information to attempt reproduction.
+
+% Context
+
+You are working on step 3 of 10 in an agentic bug investigation workflow.
+Previous steps checked for duplicates and reviewed documentation.
+
+**This step may terminate the workflow** if insufficient information exists.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+- Issue Author: @{issue_author}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+% Your Task
+
+1. **Evaluate what we know**
+   - Do we understand what behavior the user expected?
+   - Do we understand what behavior actually occurred?
+   - Are there reproduction steps or enough context to infer them?
+   - Can we identify the general area of code involved?
+
+2. **Decide**
+   - **Proceed**: We have enough to attempt reproduction
+   - **Needs More Info**: Critical gaps prevent meaningful reproduction attempt
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+**If Proceed:**
+```markdown
+## Step 3: Triage
+
+**Status:** Proceed
+
+### Summary
+[What we understand about the issue and why we can attempt reproduction]
+
+---
+*Proceeding to Step 4: Reproduction*
+```
+
+**If Needs More Info (STOP workflow):**
+```markdown
+## Step 3: Triage
+
+**Status:** Needs More Info
+
+### What We Know
+[Summary of information gathered from steps 1-2]
+
+### What We Need
+To investigate this issue further, we need clarification on:
+
+1. [Specific question 1]
+2. [Specific question 2]
+...
+
+@{issue_author} - Could you provide this information?
+
+---
+*Investigation paused - awaiting additional information from issue author.*
+```
+
+% Important
+
+- **STOP the workflow** if status is "Needs More Info"
+- Tag the issue author (@username) when requesting info
+- Be specific about what information is missing
+- Only request info that's truly necessary to attempt reproduction
+- Always post your findings as a GitHub comment before completing

pdd/prompts/agentic_bug_step4_reproduce_LLM.prompt

@@ -0,0 +1,97 @@
+% You are an expert software engineer investigating a bug report. Your task is to reproduce the reported issue locally.
+
+% Context
+
+You are working on step 4 of 10 in an agentic bug investigation workflow. Previous steps confirmed this is not a duplicate, assessed documentation, and triaged for sufficient information.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+<step3_output>
+{step3_output}
+</step3_output>
+
+% Your Task
+
+1. **Extract reproduction information**
+   - Identify error messages, stack traces, or symptoms from the issue
+   - Find any reproduction steps provided by the reporter
+   - Note the environment details (OS, versions, configuration)
+
+2. **Locate the affected code**
+   - Parse stack traces to identify relevant files and line numbers
+   - Find the module/function mentioned in the issue
+   - Explore the codebase to understand the code path
+
+3. **Attempt reproduction**
+   - Set up the minimal environment needed
+   - Follow the reproduction steps (or infer them from the issue)
+   - Run the code and observe the behavior
+   - Capture the actual error/output
+
+4. **Document results**
+   - **Reproduced**: Describe exact steps and observed behavior
+   - **Partially reproduced**: Describe what worked and what differed
+   - **Could not reproduce**: Explain what was tried and potential reasons
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 4: Reproduction
+
+**Status:** [Reproduced | Partially Reproduced | Could Not Reproduce]
+
+### Environment
+- [Relevant environment details]
+
+### Steps Taken
+1. [Step 1]
+2. [Step 2]
+3. ...
+
+### Observed Behavior
+```
+[Error message, output, or behavior observed]
+```
+
+### Affected Files
+- `path/to/file.py:123` - [brief description]
+
+### Notes
+[Any additional observations or discrepancies from the reported issue]
+
+---
+*Proceeding to Step 5: Root Cause Analysis*
+```
+
+% Important
+
+- If you cannot reproduce, still proceed - the analysis may reveal the issue
+- Document your environment carefully for comparison with the reporter's
+- Capture actual error output, not paraphrased descriptions
+- Always post your findings as a GitHub comment before completing

pdd/prompts/agentic_bug_step5_root_cause_LLM.prompt

@@ -0,0 +1,123 @@
+% You are an expert software engineer investigating a bug report. Your task is to analyze the root cause of the issue.
+
+% Context
+
+You are working on step 5 of 10 in an agentic bug investigation workflow. Previous steps have triaged, attempted reproduction, and gathered context.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+<step3_output>
+{step3_output}
+</step3_output>
+
+<step4_output>
+{step4_output}
+</step4_output>
+
+% Your Task
+
+1. **Analyze the code path**
+   - Read the affected files identified in reproduction
+   - Trace the execution flow that leads to the error
+   - Understand the data flow and transformations
+
+2. **Research external sources**
+   - Search for the error message or symptoms online
+   - Check if the issue relates to a known bug in dependencies
+   - Look for similar issues in library/framework documentation
+   - Search GitHub issues, StackOverflow, or forums for related problems
+   - Note any relevant version constraints or breaking changes
+
+3. **Analyze repository history**
+   - Use `git log` and `git blame` on affected files to identify when problematic code was introduced
+   - Search for related PRs that modified this code: `gh pr list --search "keyword" --state all`
+   - Review PR discussions for context on why changes were made
+   - Check closed issues for similar (not just duplicate) problems that provide historical insight
+   - Look for recent commits that might correlate with the bug's first appearance
+
+4. **Identify the root cause**
+   - What condition triggers the bug?
+   - Is it a logic error, edge case, race condition, or incorrect assumption?
+
+5. **Run experiments**
+   - Add debug output or modify code temporarily to verify hypotheses
+   - Test edge cases and boundary conditions
+   - Confirm your understanding of why the bug occurs
+
+6. **Document the root cause**
+   - Explain the bug in clear terms
+   - Identify the specific line(s) or logic that need to change
+   - Note any related issues or implications
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 5: Root Cause Analysis
+
+**Root Cause Identified:** [Yes | Partially | No]
+
+### Summary
+[One-paragraph explanation of what causes the bug]
+
+### Technical Details
+- **Location:** `path/to/file.py:123`
+- **Problematic Code:**
+```python
+# The issue is here
+problematic_code_snippet()
+```
+- **Why it fails:** [Explanation]
+
+### External Research
+- **Search terms:** [key terms searched]
+- **Sources checked:** [GitHub, StackOverflow, docs, etc.]
+- **Relevant findings:** [any related issues, known bugs, or workarounds found]
+
+### Repository History
+- **Relevant commits:** [commits that introduced or modified the problematic code]
+- **Related PRs:** [PRs that touch the affected code path, with discussion context]
+- **Similar past issues:** [closed issues with related symptoms or fixes]
+
+### Experiments Performed
+1. [What you tested and what it revealed]
+2. ...
+
+### Fix Direction
+[High-level description of what needs to change to fix this]
+
+---
+*Proceeding to Step 6: Test Plan*
+```
+
+% Important
+
+- Be specific about the exact location and nature of the bug
+- Distinguish between symptoms and root cause
+- If root cause is unclear, document what you learned and hypotheses
+- Always post your findings as a GitHub comment before completing

pdd/prompts/agentic_bug_step6_test_plan_LLM.prompt

@@ -0,0 +1,107 @@
+% You are an expert software engineer investigating a bug report. Your task is to design a test plan that will detect this bug.
+
+% Context
+
+You are working on step 6 of 10 in an agentic bug investigation workflow. Previous steps have identified the root cause of the issue.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+<step3_output>
+{step3_output}
+</step3_output>
+
+<step4_output>
+{step4_output}
+</step4_output>
+
+<step5_output>
+{step5_output}
+</step5_output>
+
+% Your Task
+
+1. **Review existing tests**
+   - Find existing test files for the affected module
+   - Understand the testing patterns used in this project
+   - Identify gaps in current test coverage
+
+2. **Design the test strategy**
+   - What specific behavior needs to be tested?
+   - What are the inputs that trigger the bug?
+   - What is the expected vs actual output?
+   - Are there related edge cases to cover?
+
+3. **Plan test location**
+   - Which test file should contain the new test?
+   - Should it be added to an existing file or create a new one?
+   - Follow the project's testing conventions
+
+4. **Define test cases**
+   - Primary test: reproduces the exact bug
+   - Edge cases: related scenarios that should also work
+   - Regression prevention: ensure the fix doesn't break other behavior
+
+% Output
+
+After completing your analysis, use `gh issue comment` to post your findings to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 6: Test Plan
+
+### Existing Test Coverage
+- **Test file:** `tests/test_module.py`
+- **Current coverage:** [Brief description of what's tested]
+- **Gap:** [What's not covered that should be]
+
+### Proposed Tests
+
+#### Test 1: [Name describing the bug scenario]
+- **Input:** [The triggering condition]
+- **Expected:** [Correct behavior]
+- **Actual (before fix):** [Bug behavior]
+
+#### Test 2: [Related edge case]
+- **Input:** [Edge case condition]
+- **Expected:** [Correct behavior]
+
+### Test Location
+- **File:** `tests/test_module.py` (append) or `tests/test_module_bug_123.py` (new)
+- **Framework:** [pytest/unittest/etc.]
+
+### Notes
+[Any special setup, fixtures, or considerations]
+
+---
+*Proceeding to Step 7: Generate Test*
+```
+
+% Important
+
+- Tests should be specific enough to catch this exact bug
+- Tests should not be so brittle they break with valid changes
+- Consider both the bug case and related edge cases
+- Always post your findings as a GitHub comment before completing