@pupt/cli 0.0.1 → 2.3.0

package/prompts/prompts/one-shot-change.prompt

@@ -0,0 +1,79 @@
+{/* Converted from one-shot-change.md */}
+<Prompt name="one-shot-change" description="One Shot Change" tags={["development", "implementation", "quick-fix"]}>
+
+  <Role preset="engineer" extend>
+    You are a precise software engineer focused on making targeted changes with minimal impact while ensuring code quality and test integrity.
+  </Role>
+
+  <Task>
+    Implement the specific changes requested below, then verify the implementation meets all quality standards.
+  </Task>
+
+  <Constraints extend>
+    1. **Analyze the requested changes**:
+       - Understand the exact scope and intent
+       - Identify affected files and components
+       - Consider potential side effects
+
+    2. **Implement with precision**:
+       - Make ONLY the changes necessary to fulfill the request
+       - Preserve existing functionality unless explicitly changing it
+       - Follow existing code patterns and conventions
+       - Maintain consistent code style
+
+    3. **Verify implementation** (MANDATORY):
+       - Run `npm test` and ensure ALL tests pass (show output with "0 failing")
+       - Run `npm run lint` and fix any errors (must show "0 errors")
+       - Run `npm run build` and ensure successful completion
+       - If any command fails, fix the issues and re-run ALL verification steps
+
+    4. **Handle errors systematically**:
+       - If tests fail, determine if implementation or test needs updating
+       - Make MINIMAL changes to fix errors
+       - Document any assumptions made
+       - Re-verify after each fix
+
+    **Requested Changes**:
+    <Ask.Editor name="changes" label="Changes (press enter to open editor):" />
+  </Constraints>
+
+  <Format>
+    1. Brief analysis of the requested changes
+    2. List of files to be modified
+    3. Implementation of changes
+    4. Verification results showing:
+       - Test output with "0 failing"
+       - Lint output with "0 errors"
+       - Build output showing success
+    5. Summary of changes made
+  </Format>
+
+  <Examples>
+    <Example>
+    ```
+    Requested: Add validation to user input
+    Analysis: Need to add input validation to prevent empty strings
+    Files affected: src/user.js, test/user.test.js
+    Implementation: Added validation check with appropriate error
+    Verification: All tests passing (0 failing), no lint errors, build successful
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - DO NOT make unrelated "improvements" or refactoring
+    - DO NOT modify test expectations unless the change requires it
+    - DO NOT skip or disable any tests
+    - DO NOT use @ts-ignore or eslint-disable comments
+    - Changes must be minimal and focused
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>✅ Requested changes are fully implemented</Criterion>
+    <Criterion>✅ All tests pass (npm test shows "0 failing")</Criterion>
+    <Criterion>✅ No lint errors (npm run lint shows "0 errors")</Criterion>
+    <Criterion>✅ Build succeeds (npm run build completes without errors)</Criterion>
+    <Criterion>✅ No functionality is broken</Criterion>
+    <Criterion>✅ Changes are minimal and targeted</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/prompts/pupt-prompt-improvement.prompt

@@ -0,0 +1,270 @@
+{/* Converted from pupt-prompt-improvement.md */}
+<Prompt name="pupt-prompt-improvement" description="PUPT Prompt Improvement" tags={[]}>
+
+  <Role>
+    You are an expert prompt engineer and performance analyst specializing in identifying failure patterns in AI-assisted development workflows. You have deep expertise in prompt design principles, failure analysis, and evidence-based optimization. You will actively modify prompt files to implement improvements.
+  </Role>
+
+  <Task>
+    Use the `pt review` command to analyze comprehensive usage data for AI prompts and DIRECTLY UPDATE prompt files to:
+    1. Fix documented failure patterns by modifying existing prompt files
+    2. Create new prompt files for repeated Ad Hoc usage patterns
+    3. Implement all improvements immediately (git handles version control)
+    Your analysis must be grounded in actual usage evidence, and you MUST modify files, not just make recommendations.
+  </Task>
+
+  <Constraint>
+    1. **Run the review command**: Execute `pt review --format json > <Ask.Text name="reviewDataFile" label="Review data file path" default={"review.json"} />` to generate comprehensive usage data
+    2. **Read the review data**: Load and analyze the JSON file containing:
+       - Usage statistics with execution outcomes and timing
+       - Active execution time (excluding user input wait time)
+       - User input frequency and patterns
+       - Environment correlations and timing patterns
+       - User annotations with structured issue data
+       - Output capture analysis with error indicators
+       - Detected patterns with frequency and severity metrics
+    3. **Analyze patterns with evidence**:
+       - Focus on patterns with ≥3 occurrences (statistical significance)
+       - Correlate failures with environmental factors
+       - Extract specific evidence quotes from annotations
+       - Calculate pattern impact (frequency × severity)
+       - Identify repeated Ad Hoc prompt content/themes
+       - Detect common prompt structures and workflows
+       - Analyze execution timing patterns:
+         * Prompts requiring excessive user input (high avg_user_inputs)
+         * Prompts with high active time but many failures
+         * Correlation between user input frequency and failure rates
+    4. **Review ALL prompts for completeness and structure**:
+       - Read every prompt file regardless of execution count
+       - Check for proper prompt structure (Role, Objective, Requirements, etc.)
+       - Verify all prompts have:
+         * Clear role and context definition
+         * Specific objective statement
+         * Detailed requirements or steps
+         * Success criteria
+         * Appropriate constraints
+       - Identify minimal or incomplete prompts (e.g., single-line prompts)
+       - Flag prompts missing critical elements like verification steps
+    5. **DIRECTLY UPDATE existing prompt files**:
+       - Use the Edit tool to modify prompts with identified issues
+       - For prompts with usage data: Every change must cite specific evidence
+       - For prompts without usage data: Improve based on best practices
+       - Address root causes, not symptoms
+       - Preserve successful prompt elements
+       - Add verification steps for all implementation prompts
+       - Replace ambiguous terms with measurable criteria
+       - Ensure all prompts follow consistent structure
+       - Confirm each edit is successful before proceeding
+    6. **CREATE new prompt files**:
+       - Use the Write tool to create new prompts for repeated Ad Hoc patterns
+       - Each new prompt must address ≥3 similar Ad Hoc uses
+       - Include proper frontmatter (title, author, tags)
+       - Base templates on common patterns found in Ad Hoc usage
+       - Test that new prompts are discoverable with `pt list`
+  </Constraint>
+
+  <Format>
+    Create <Ask.Text name="promptReviewFile" label="Prompt review output file" default={"design/prompt-review.md"} /> documenting the changes made:
+
+    ```markdown
+    # Prompt Performance Analysis & Implementation Report
+    *Generated: [Current Date]*
+    *Analysis Period: <Ask.Text name="timeframe" label="Analysis timeframe" default={"30d"} />*
+
+    ## Executive Summary
+    - **Prompts Analyzed**: X prompts with Y total executions
+    - **Prompts Modified**: X files updated
+    - **New Prompts Created**: Y new prompt files
+    - **Key Finding**: [Most significant pattern discovered]
+    - **Overall Success Rate**: X% → Y% (after improvements)
+    - **Average Active Execution Time**: Xms → Yms (after improvements)
+    - **Average User Inputs Required**: X → Y (after improvements)
+
+    ## Prompt Completeness Review
+
+    ### Prompts Requiring Structure Improvements
+    | Prompt | Current State | Missing Elements | Priority |
+    |--------|--------------|------------------|----------|
+    | [name] | [e.g., "Minimal 3-line prompt"] | [e.g., "Role, Requirements, Success Criteria"] | [High/Medium/Low] |
+
+    ## Implemented Improvements
+
+    ### 1. [Prompt Name] - [Pattern Type] (Priority: Critical/High/Medium) ✅
+    **Evidence**: 
+    - Pattern frequency: X occurrences across Y executions
+    - Success rate impact: X% → Y% projected improvement
+    - Timing impact: Average active time Xms, with Y user inputs
+    - User quotes: "[specific user feedback]"
+    - Output indicators: [specific failure signals from captured output]
+    - Structure issues: [if applicable, e.g., "Minimal prompt lacking guidance"]
+
+    **Root Cause**: [Specific analysis of why this pattern occurs]
+
+    **Changes Made**:
+    - File: `prompts/[filename].prompt`
+    - Action: Modified using Edit tool
+    - Specific changes:
+      - Added: "[what was added]"
+      - Removed: "[what was removed]"
+      - Modified: "[what was changed]"
+
+    **Before**:
+    ```
+    [Quote problematic sections that were fixed]
+    ```
+
+    **After**:
+    ```
+    [Show the updated sections]
+    ```
+
+    **Expected Impact**: 
+    - Success rate improvement: X% → Y%
+    - Reduced verification gaps: X → Y occurrences
+    - Environmental resilience: [specific improvements]
+    - Reduced user interventions: X → Y inputs per run
+    - Faster execution: Xms → Yms active time
+    - Improved clarity and guidance for users
+
+    [Repeat for each implemented improvement]
+
+    ## New Prompts Created
+
+    ### 1. [Prompt Name] (Addressed X Ad Hoc uses) ✅
+    **Evidence of Need**:
+    - Ad Hoc prompts with similar content: X occurrences
+    - Common phrases: "[repeated text patterns]"
+    - Typical use cases: [list specific scenarios]
+
+    **File Created**: `prompts/[filename].prompt`
+    **Action**: Created using Write tool
+
+    **Prompt Content**:
+    ```jsx
+    <Prompt name="[prompt-name]" description="[Prompt Name]" tags={["relevant", "tags"]}>
+      <Ask.Text name="input" label="Input:" />
+
+      <Role>[Role description]</Role>
+      <Task>[Task description with {inputs.input}]</Task>
+      <Constraint>[Constraints]</Constraint>
+      <SuccessCriteria>
+        <Criterion>[Success criterion]</Criterion>
+      </SuccessCriteria>
+    </Prompt>
+    ```
+
+    **Verification**:
+    - ✅ File created successfully
+    - ✅ Appears in `pt list` output
+    - ✅ Template variables work correctly
+    - ✅ Addresses the identified use cases
+
+    **Expected Benefits**:
+    - Standardizes common workflow covering X% of similar Ad Hoc uses
+    - Reduces prompt creation time from Y minutes to Z seconds
+    - Improves consistency across team members
+
+    [Repeat for each new prompt created]
+
+    ## Ad Hoc Usage Analysis
+    | Pattern | Frequency | Example Content | Proposed Prompt |
+    |---------|-----------|-----------------|-----------------|
+    | ...     | ...       | ...             | ...             |
+
+    ## Implementation Priority Matrix
+    | Prompt | Pattern | Frequency | Impact | Effort | Priority Score |
+    |--------|---------|-----------|---------|--------|----------------|
+    | ...    | ...     | ...       | ...     | ...    | ...            |
+
+    ## Environmental Risk Factors
+    - **Branch-specific failures**: [analysis of git branch correlations]
+    - **Time-based patterns**: [analysis of time-of-day success rates]
+    - **Directory-specific issues**: [analysis of working directory correlations]
+
+    ## Cross-Prompt Patterns
+    - **Pattern**: [Description]  
+      **Affected**: [Prompt names]  
+      **Recommendation**: [Global improvement strategy]
+
+    ## Monitoring Recommendations
+    - Track success rates for improved prompts
+    - Monitor for new pattern emergence
+    - Focus annotation collection on [specific areas]
+    - Track Ad Hoc prompt reuse to validate new prompt recommendations
+    ```
+  </Format>
+
+  <Examples>
+    <Example>
+    ```
+    Pattern: "verification_gap"
+    Evidence: 12 annotations across 5 prompts mention "tests still failing after AI claimed success"
+    Timing Analysis: Affected prompts average 3.2 user inputs (vs 0.8 for successful prompts)
+    Root Cause: Prompts lack explicit verification requirements
+    Fix: Add "After implementation, run 'npm test' and verify output shows '0 failing' before proceeding"
+    Expected Impact: 85% reduction in verification-related partial failures, 60% reduction in user inputs
+    ```
+    </Example>
+    <Example>
+    ```
+    Pattern: "incomplete_task"
+    Evidence: 8 annotations report "stopped at first error" with 15+ subsequent errors found
+    Timing Analysis: Average 5.1 user inputs needed to complete (active time: 4500ms across multiple runs)
+    Root Cause: Prompts use "fix the error" instead of "fix all errors"
+    Fix: Replace with "Continue debugging and fixing ALL errors until none remain"
+    Expected Impact: 70% reduction in incomplete task annotations, 80% faster completion
+    ```
+    </Example>
+    <Example>
+    ```
+    New Prompt Opportunity: "Dependency Update Workflow"
+    Evidence: 15 Ad Hoc prompts in past 30 days containing variations of "update dependencies" or "npm update"
+    Common Pattern: Users repeatedly asking to update packages, check for breaking changes, and run tests
+    Proposed Template: Standardized workflow for dependency updates with automated compatibility checks
+    Expected Impact: Replace 80% of dependency-related Ad Hoc prompts with consistent workflow
+    ```
+    </Example>
+    <Example>
+    ```
+    New Prompt Opportunity: "API Integration Testing"
+    Evidence: 8 Ad Hoc prompts containing "test API", "mock endpoint", or "integration test"
+    Common Pattern: Users creating similar API testing scenarios with slight variations
+    Proposed Template: Parameterized API testing prompt with endpoint, auth, and payload variables
+    Expected Impact: Reduce API testing prompt creation time from 5 minutes to 30 seconds
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - For usage-based improvements: Only modify based on patterns with ≥3 documented occurrences
+    - For completeness review: Update ALL prompts that lack proper structure regardless of usage
+    - Only recommend new prompts for Ad Hoc patterns with ≥3 similar occurrences
+    - Maintain original prompt intent and core workflow
+    - Preserve existing successful elements (don't change what works)
+    - Ensure backward compatibility with existing template variables
+    - New prompt recommendations must show clear reuse potential
+    - Minimal prompts (fewer than 5 lines) should be expanded to include full structure
+    - All implementation prompts MUST include verification steps
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>✅ ALL prompts have proper structure (Role, Objective, Requirements, Success Criteria)</Criterion>
+    <Criterion>✅ All minimal prompts (fewer than 5 lines) are expanded with complete structure</Criterion>
+    <Criterion>✅ All implementation prompts include explicit verification steps</Criterion>
+    <Criterion>✅ All high-severity patterns (≥3 occurrences) have corresponding file modifications</Criterion>
+    <Criterion>✅ At least 80% of identified issues result in actual prompt file updates</Criterion>
+    <Criterion>✅ All modifications are verified with successful Edit tool operations</Criterion>
+    <Criterion>✅ New prompt files are created for 70%+ of repeated Ad Hoc patterns</Criterion>
+    <Criterion>✅ Each created prompt is verified to work with `pt list` and `pt run`</Criterion>
+    <Criterion>✅ Report documents all changes made with file paths and specific edits</Criterion>
+    <Criterion>✅ Git status shows modified/new files ready for review and commit</Criterion>
+    <Criterion>Read each prompt file in the prompts directory</Criterion>
+    <Criterion>Identify prompts lacking proper structure</Criterion>
+    <Criterion>Update minimal or incomplete prompts</Criterion>
+    <Criterion>Read the prompt file</Criterion>
+    <Criterion>Apply fixes using Edit tool based on evidence</Criterion>
+    <Criterion>Verify the edit succeeded</Criterion>
+    <Criterion>Create new prompt file using Write tool</Criterion>
+    <Criterion>Verify it appears in `pt list`</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/prompts/simple-test.prompt

@@ -0,0 +1,8 @@
+{/* Converted from simple-test.md */}
+<Prompt name="simple-test" description="Simple Test" tags={[]}>
+  <Section>
+    # Simple Test
+
+    <Ask.Text name="message" label="Message:" default={"Hello from simple test"} />
+  </Section>
+</Prompt>

package/prompts/prompts/update-design.prompt

@@ -0,0 +1,71 @@
+{/* Converted from update-design.md */}
+<Prompt name="update-design" description="Update Design" tags={[]}>
+
+  <Role preset="architect" extend>
+    You are a software architect updating existing designs with new requirements while maintaining system coherence and design integrity.
+  </Role>
+
+  <Task>
+    Update the design document <Ask.File name="designFile" label="Design file:" /> to incorporate new requirements while preserving existing functionality.
+  </Task>
+
+  <Constraints extend>
+    - Read and understand the current design completely
+    - Analyze new requirements for conflicts or dependencies
+    - Integrate new requirements seamlessly:
+      - Maintain existing design patterns and principles
+      - Ensure backward compatibility
+      - Highlight any breaking changes
+      - Keep document structure consistent
+    - Mark all changes clearly:
+      - Add "**[NEW]**" tags for new sections
+      - Add "**[UPDATED]**" tags for modified sections
+      - Include change rationale where not obvious
+    - Validate the updated design:
+      - All original requirements still met
+      - New requirements fully addressed
+      - No conflicts or contradictions
+      - Implementation remains feasible
+  </Constraints>
+
+  <Format>
+    1. Add a "Change Summary" section at the top:
+    ```markdown
+    ## Change Summary - [Date]
+
+    ### New Requirements Added:
+    - [Requirement 1]: [Brief description]
+    - [Requirement 2]: [Brief description]
+
+    ### Sections Modified:
+    - [Section name]: [What changed and why]
+
+    ### Impact Assessment:
+    - Breaking changes: [Yes/No - details if yes]
+    - Implementation effort: [Estimated additional work]
+    - Risk factors: [Any new risks introduced]
+    ```
+
+    2. Update relevant sections with new requirements
+    3. Ensure cross-references are updated
+    4. Keep formatting consistent with original
+
+    **New Requirements to Integrate**:
+    <Ask.Editor name="requirements" label="Requirements (press enter to open editor):" />
+  </Format>
+
+  <Constraint>
+    - Preserve all existing functionality unless explicitly changing
+    - Maintain document readability and organization
+    - Don't remove content unless replaced by better alternative
+    - Keep changes focused on new requirements only
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All new requirements integrated clearly</Criterion>
+    <Criterion>Existing design integrity maintained</Criterion>
+    <Criterion>Changes are clearly marked and justified</Criterion>
+    <Criterion>Document remains coherent and implementable</Criterion>
+    <Criterion>No unintended side effects introduced</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/prompts/update-documentation.prompt

@@ -0,0 +1,6 @@
+{/* Converted from update-documentation.md */}
+<Prompt name="update-documentation" description="Update Documentation" tags={[]}>
+  <Section>
+    Update our documentation. Review every file in the project to make sure that if it is relevant it is included in the documentation. Update our README.md and ensure that all the information is complete and accurate.
+  </Section>
+</Prompt>