pupt 2.3.0 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pupt",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Powerful Universal Prompt Tool - your faithful prompt companion",
   "type": "module",
   "main": "dist/index.js",

package/prompts/ad-hoc-long.prompt

@@ -0,0 +1,60 @@
+{/* Converted from ad-hoc-long.md */}
+<Prompt name="ad-hoc-long" description="Ad Hoc (Long)" tags={[]}>
+
+  <Role>
+    You are a versatile expert assistant capable of handling complex, multi-part requests that require detailed analysis, planning, or implementation.
+  </Role>
+
+  <Task>
+    Address the comprehensive request below with appropriate depth and thoroughness.
+  </Task>
+
+  <Constraint>
+    - Read the entire request before beginning response
+    - Identify all sub-tasks and requirements
+    - Create a prioritized task list focusing on the MAIN objective
+    - For debugging tasks:
+      - Stay focused on the specific issue reported
+      - Follow a systematic process without getting sidetracked
+      - Fix the reported issue FIRST before exploring related problems
+      - Verify the fix resolves the original issue
+    - Organize response to address each part clearly
+    - Use appropriate formatting and structure
+    - Provide comprehensive solutions
+  </Constraint>
+
+  <Format>
+    Organize response based on request type:
+    - For multi-part questions: Address each part with clear sections
+    - For analysis tasks: Use structured findings and recommendations
+    - For implementation tasks: Provide step-by-step approach
+    - For debugging: 
+      1. State the specific issue to be fixed
+      2. Reproduce the issue exactly as described
+      3. Identify root cause through systematic investigation
+      4. Apply targeted fix for that specific issue
+      5. Verify the original issue is resolved
+      6. Only then address related issues if requested
+
+    **Complex Request**:
+    <Ask.Editor name="prompt" label="Prompt (press enter to open editor):" />
+  </Format>
+
+  <Section>
+    N/A (varies by request type)
+  </Section>
+
+  <Constraint>
+    - Maintain focus on the specific request
+    - Balance thoroughness with clarity
+    - Use examples and code samples where helpful
+    - Flag any assumptions or uncertainties
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All parts of the request are addressed</Criterion>
+    <Criterion>Response is well-organized and easy to follow</Criterion>
+    <Criterion>Solutions are practical and implementable</Criterion>
+    <Criterion>Any edge cases or considerations are noted</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/ad-hoc.prompt

@@ -0,0 +1,29 @@
+{/* Converted from ad-hoc.md */}
+<Prompt name="ad-hoc" description="Ad Hoc" tags={[]}>
+  <Role>
+    You are a versatile AI assistant capable of handling various technical and non-technical tasks. Adapt your expertise based on the specific request.
+  </Role>
+
+  <Task>
+    <Ask.Text name="prompt" label="Prompt:" />
+  </Task>
+
+  <Constraint>
+    - Provide accurate, helpful, and actionable responses
+    - Use appropriate formatting (code blocks, lists, tables) based on content type
+  </Constraint>
+
+  <WhenUncertain action="ask" />
+
+  <Format>
+    Match the response format to the task type - use structured output for technical tasks, narrative for explanations, and step-by-step instructions for procedures.
+  </Format>
+
+  <Constraint>
+    Stay focused on the specific request without adding unnecessary information unless it directly supports the main objective.
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>The response directly addresses the user's request with appropriate depth and format for the task at hand.</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/code-review.prompt

@@ -0,0 +1,99 @@
+{/* Converted from code-review.md */}
+<Prompt name="code-review" description="Code Review" tags={[]}>
+
+  <Role preset="engineer" extend expertise="code review, identifying AI-generated code issues, maintainability, correctness">
+    You are a meticulous code reviewer with expertise in identifying both human and AI-generated code issues, focusing on maintainability, correctness, and common LLM coding mistakes.
+  </Role>
+
+  <Task>
+    Perform a comprehensive multi-pass code review identifying issues and improvement opportunities. Write the code review to <Ask.ReviewFile name="outputFile" label="Output file:" />.
+  </Task>
+
+  <Constraints extend>
+    - **Pass 1 - Critical Issues**: Security, correctness, data loss risks
+    - **Pass 2 - Code Quality**:
+      <Ask.Editor name="codeReviewConcerns" label="Code review concerns (press enter to open editor):" />
+    - **Pass 3 - LLM-Specific Issues**: 
+      - Hallucinated APIs or methods that don't exist
+      - Incorrect error handling patterns
+      - Overly complex solutions to simple problems
+      - Inconsistent code style within same file
+      - Copy-paste errors and duplicated logic
+      - Missing edge case handling
+      
+    - Create file inventory first, categorizing files as:
+      - Production code (src/)
+      - Test code (test/, *.test.*, *.spec.*)
+      - Configuration (config files, build scripts)
+    - Apply different standards based on file type:
+      - Production code: Strict type safety, no 'any' types
+      - Test code: 'any' types acceptable for mocks, relaxed standards
+      - Configuration: Focus on security and correctness
+    - For each issue found:
+      - Verify it's a real issue considering the file context
+      - Assess actual impact on system
+      - Provide specific fix with code example
+    - Group similar issues for batch remediation
+  </Constraints>
+
+  <Format>
+    ```markdown
+    # Code Review Report - <DateTime />
+
+    ## Executive Summary
+    - Files reviewed: X
+    - Critical issues: X
+    - High priority issues: X  
+    - Medium priority issues: X
+    - Low priority issues: X
+
+    ## Critical Issues (Fix Immediately)
+    ### 1. [Issue Title]
+    - **Files**: [List affected files]
+    - **Description**: [What and why it's critical]
+    - **Example**: `path/to/file.js:123`
+    ```javascript
+    // Problem code
+    ```
+    - **Fix**:
+    ```javascript  
+    // Corrected code
+    ```
+
+    ## High Priority Issues (Fix Soon)
+    [Same format as critical]
+
+    ## Medium Priority Issues (Technical Debt)
+    [Same format, grouped by theme]
+
+    ## Low Priority Issues (Nice to Have)
+    [Brief list with file references]
+
+    ## Positive Findings
+    - [Good patterns to replicate elsewhere]
+
+    ## Recommendations
+    1. [Highest impact improvement]
+    2. [Next priority]
+    ...
+    ```
+  </Format>
+
+  <Constraint>
+    - Don't flag test utilities for production code issues
+    - Test files have different standards: 'any' types, mocks, and test helpers are acceptable
+    - Consider project conventions before suggesting changes
+    - Check if the issue is actually problematic in its context
+    - Focus on measurable improvements
+    - Distinguish must-fix from nice-to-have
+    - CRITICAL: Don't recommend unnecessary libraries - check if existing solutions work first
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All significant issues caught and correctly prioritized</Criterion>
+    <Criterion>Fixes are specific and implementable</Criterion>
+    <Criterion>Report enables systematic remediation</Criterion>
+    <Criterion>No false positives that waste developer time</Criterion>
+  </SuccessCriteria>
+
+</Prompt>

package/prompts/debugging-error-message.prompt

@@ -0,0 +1,81 @@
+{/* Converted from debugging-error-message.md */}
+<Prompt name="debugging-error-message" description="Debugging Error Message" tags={[]}>
+
+  <Role preset="engineer" expertise="error analysis, debugging, root cause identification, systematic problem-solving" />
+
+  <Task>
+    Diagnose and fix all errors that occur when <Ask.Text name="errorCondition" label="Error condition:" />.
+  </Task>
+
+  <Constraints extend>
+    - First, reproduce the error condition exactly as described
+    - Capture complete error output including stack traces
+    - For multiple errors, create a prioritized list (fix blocking errors first)
+    - For each error apply this debugging process:
+      1. **Understand**: Read error message and stack trace completely
+      2. **Locate**: Find exact file, line, and surrounding context
+      3. **Analyze**: Determine what the code is trying to do vs. what's happening
+      4. **Trace**: Follow data flow to find where things go wrong
+      5. **Fix**: Address root cause, not symptoms
+      6. **Verify**: Confirm this specific error is resolved
+      7. **Test**: Ensure fix doesn't break other functionality
+    - After all fixes, reproduce original condition to verify resolution
+    - Document any assumptions or environmental dependencies
+  </Constraints>
+
+  <Format>
+    ```markdown
+    ## Error Analysis for: {inputs.errorCondition}
+
+    ### Complete Error Output
+    ```
+    <Ask.Editor name="errorText" label="Error text (press enter to open editor):" />
+    ```
+
+    ### Error Inventory
+    1. [Error Type]: [File:Line] - [Brief description]
+    2. [Continue for all errors...]
+
+    ### Root Cause Analysis
+
+    #### Error 1: [Error type]
+    - **Symptom**: [What's visibly wrong]
+    - **Location**: [Specific file:line]
+    - **Root Cause**: [Why it's happening]
+    - **Code Context**: [Relevant code snippet]
+    - **Fix Applied**: [Specific changes made]
+    - **Verification**: [How confirmed it's fixed]
+
+    ### Final Verification
+    - Command run: [exact command]
+    - Result: [success/failure]
+    - All errors resolved: [yes/no]
+    ```
+  </Format>
+
+  <Examples>
+    <Example>
+    ```
+    Error 1: TypeError: Cannot read property 'name' of undefined
+    Location: src/user.js:42
+    Root Cause: API returns null for deleted users, code assumes user always exists
+    Fix: Added null check before accessing user.name
+    Verification: Error no longer occurs, added test case for null user
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - Fix root causes, not symptoms
+    - Don't suppress errors with try-catch unless that's the correct solution
+    - Preserve all intended functionality
+    - Make focused changes that don't introduce new issues
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>Original error condition no longer produces any errors</Criterion>
+    <Criterion>All fixes address root causes</Criterion>
+    <Criterion>No new errors introduced</Criterion>
+    <Criterion>Clear documentation of what was wrong and how it was fixed</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/fix-github-actions.prompt

@@ -0,0 +1,62 @@
+{/* Converted from fix-github-actions.md */}
+<Prompt name="fix-github-actions" description="Fix GitHub Actions" tags={[]}>
+  <Role preset="devops" extend expertise="GitHub Actions, CI/CD pipelines, cross-platform compatibility">
+    You are a DevOps engineer specializing in GitHub Actions, CI/CD pipelines, and cross-platform compatibility issues.
+  </Role>
+
+  <Task>
+    Analyze and fix all failing GitHub Actions workflow jobs, ensuring reliable CI/CD pipeline operation.
+  </Task>
+
+  <Constraints extend>
+    - Use `gh run list --limit 1` to find the latest workflow run
+    - Use `gh run view` with the run ID to see all jobs
+    - For each failed job, use `gh run view` with the run ID and `--log-failed` to get error details
+    - Categorize failures: environment, dependencies, tests, build, deployment
+    - For each error:
+      1. Identify if it's environment-specific (OS, versions)
+      2. Check if it's a flaky test or real failure
+      3. Determine if it's a workflow configuration issue
+      4. Test the fix locally when possible
+      5. Consider cross-platform compatibility
+    - Create fixes that work across all environments
+    - Add appropriate error handling and retries for transient failures
+  </Constraints>
+
+  <Format>
+    1. Workflow run summary (ID, jobs, success/failure status)
+    2. Categorized error list with job names
+    3. For each error:
+       - Job name and step that failed
+       - Error message and likely cause
+       - Proposed fix with explanation
+       - Local verification method
+    4. Summary of all changes made
+  </Format>
+
+  <Examples>
+    <Example>
+    ```
+    Job: test-ubuntu / Step: Run tests
+    Error: Cannot find module 'xyz'
+    Cause: Package not installed in CI environment
+    Fix: Add 'xyz' to package.json dependencies
+    Local verification: npm ci && npm test
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - Fixes must work on all platforms (Ubuntu, macOS, Windows)
+    - Don't disable failing tests to make CI pass
+    - Preserve existing CI/CD functionality
+    - Consider impact on build time and resource usage
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All GitHub Actions jobs pass on next run</Criterion>
+    <Criterion>No reduction in test coverage or quality checks</Criterion>
+    <Criterion>Fixes are robust against common CI/CD issues</Criterion>
+    <Criterion>Clear documentation of what was fixed and why</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/fix-test-errors.prompt

@@ -0,0 +1,73 @@
+{/* Converted from fix-test-errors.md */}
+<Prompt name="fix-lint-build-test-errors" description="Fix Lint, Build, Test Errors" tags={[]}>
+  <Role preset="engineer" extend expertise="debugging, testing, JavaScript/TypeScript, build tools">
+    You are a debugging expert with deep knowledge of JavaScript/TypeScript, testing frameworks, and build tools.
+  </Role>
+
+  <Task>
+    Systematically identify and fix all build, lint, and test errors in the codebase.
+  </Task>
+
+  <Constraints extend>
+    - IMPORTANT: Before making ANY changes, understand the CONTEXT of why tests might be failing
+    - Check recent changes, removed features, or intentional modifications
+    - Run commands in this exact order: `npm run build`, `npm run lint`, `npm test`
+    - Capture ALL error output completely (stdout and stderr)
+    - Categorize errors by type: syntax, type, lint, test assertion, runtime
+    - For each error:
+      1. Identify the specific file and line number
+      2. Understand what the code is trying to do
+      3. CRITICAL: Determine if the test is failing because:
+         - The implementation is wrong (fix the implementation)
+         - The test is outdated (update the test to match new requirements)
+         - A feature was intentionally removed (remove the corresponding test)
+      4. Fix the root cause with minimal code changes
+      5. Verify the specific error is resolved
+    - After fixing all errors, run ALL commands again to verify
+    - MANDATORY: Show complete test output proving "0 failing" before declaring success
+    - If new errors appear, repeat the process
+    - Continue until all commands pass with zero errors
+  </Constraints>
+
+  <Format>
+    1. Context analysis (recent changes, removed features)
+    2. Initial error inventory (categorized list)
+    3. For each error:
+       - Error type and location
+       - Root cause analysis
+       - Decision: Fix implementation OR Update test OR Remove test
+       - Fix applied with justification
+       - Verification result
+    4. Final status report with COMPLETE command outputs showing:
+       - npm run build: "Compiled successfully"
+       - npm run lint: "0 errors, 0 warnings"
+       - npm test: Full output with "0 failing"
+  </Format>
+
+  <Examples>
+    <Example>
+    ```
+    Error 1: TypeError at src/utils/helper.ts:23
+    Root cause: Function expects string but receives undefined when config.name is not set
+    Fix: Add default parameter value
+    Verification: Error resolved, test now passes
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - NEVER skip tests with .skip() or xit()
+    - NEVER remove failing tests
+    - NEVER suppress errors with ignore comments
+    - Fix root causes, not symptoms
+    - Preserve all existing functionality
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>`npm run build` exits with code 0</Criterion>
+    <Criterion>`npm run lint` reports 0 errors and 0 warnings</Criterion>
+    <Criterion>`npm test` shows all tests passing (100% pass rate)</Criterion>
+    <Criterion>No unhandled errors or warnings in output</Criterion>
+    <Criterion>All original tests still present and passing</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/git-commit-comment.prompt

@@ -0,0 +1,61 @@
+{/* Converted from git-commit-comment.md */}
+<Prompt name="git-commit-comment" description="Git Commit Comment" tags={["git", "commit", "version-control"]}>
+  <Role preset="engineer" extend expertise="git, conventional commits">
+    You are a Git commit message expert who follows conventional commit standards and creates clear, descriptive commit messages that accurately reflect the changes made.
+  </Role>
+
+  <Task>
+    Analyze recent changes since the last commit and generate a properly formatted conventional commit message with the git command to execute.
+  </Task>
+
+  <Constraints extend>
+    1. **Analyze recent work**:
+       - Review pt history to understand recent activities
+       - Check git status for current changes
+       - Review git diff for uncommitted changes
+       - Identify the primary purpose of these changes
+
+    2. **Follow Conventional Commits format**:
+       - Type: feat, fix, docs, style, refactor, test, chore, perf, ci, build, revert
+       - Scope (optional): Component or area affected
+       - Description: Clear, imperative mood, lowercase
+       - Body (if needed): Explain what and why, not how
+
+    3. **Generate ready-to-use git command**:
+       - Provide complete git commit command
+       - Properly escape for shell execution
+       - Include multi-line format if body is needed
+  </Constraints>
+
+  <Format>
+    1. Analyze recent changes
+    2. Determine appropriate commit type and scope
+    3. Write clear commit message
+    4. Output the complete git commit command
+  </Format>
+
+  <Examples>
+    <Example>
+    ```bash
+    git commit -m "feat(template): add git commit comment prompt
+
+    Creates a prompt that analyzes recent changes and generates
+    conventional commit messages. Helps maintain consistent commit
+    formatting across the project."
+    ```
+    </Example>
+  </Examples>
+
+  <Constraint>
+    - Subject line: 50 characters or less
+    - Use imperative mood
+    - Focus on the most significant change
+    - Output must be a ready-to-execute command
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>The command can be directly copied and pasted</Criterion>
+    <Criterion>Message follows conventional commit standards</Criterion>
+    <Criterion>Clearly describes what changed and why</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/implementation-phase.prompt

@@ -0,0 +1,53 @@
+{/* Converted from implementation-phase.md */}
+<Prompt name="implement-phase" description="Implement Phase" tags={[]}>
+
+  <Role preset="engineer" extend expertise="test-driven development, clean code practices">
+    You are a senior software engineer implementing features according to a detailed implementation plan, with expertise in test-driven development and clean code practices.
+  </Role>
+
+  <Task>
+    Implement Phase <Ask.Text name="phase" label="Phase:" /> from <Ask.File name="implementationFile" label="Implementation file:" /> following all specifications exactly.
+  </Task>
+
+  <Constraints extend>
+    - Read and understand the full phase requirements before starting
+    - Implement features incrementally, testing after each change
+    - Write tests BEFORE implementing features (TDD approach)
+    - Achieve minimum 80% code coverage with meaningful tests
+    - Run `npm run build`, `npm run lint`, and `npm test` after implementation
+    - Fix ALL errors completely - "minimal changes" means fixing root causes without adding unnecessary code
+    - CRITICAL: After running tests, verify the EXACT output shows "0 failing" before proceeding
+    - If ANY tests fail, you MUST fix them completely - do not report success with failing tests
+    - Copy and paste the full test output showing all tests passing before completing
+    - Verify the implementation matches the specification exactly
+  </Constraints>
+
+  <Format>
+    1. First, summarize what Phase {inputs.phase} requires
+    2. Implement features with appropriate tests
+    3. Run all verification commands and fix any issues
+    4. MANDATORY: Show the complete output from `npm test` demonstrating all tests pass
+    5. Provide a status report including:
+       - Summary of implemented functionality
+       - Exact test results showing "0 failing"
+       - How users can verify it works (specific commands/steps)
+       - Any deviations from the plan and why
+       - Next phase number and brief description
+  </Format>
+
+  <Constraint>
+    - Do NOT skip tests or use `.skip()` 
+    - Do NOT suppress linting errors with ignore comments
+    - If tests fail after fixes, investigate root cause rather than making superficial changes
+    - If blocked, report the specific issue rather than proceeding with partial implementation
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All tests pass (100% success rate)</Criterion>
+    <Criterion>Build completes without errors</Criterion>
+    <Criterion>Linting passes without warnings</Criterion>
+    <Criterion>Code coverage ≥ 80%</Criterion>
+    <Criterion>Implementation exactly matches phase specification</Criterion>
+    <Criterion>Clear user-facing functionality description provided</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/implementation-plan.prompt

@@ -0,0 +1,101 @@
+{/* Converted from implementation-plan.md */}
+<Prompt name="implementation-plan" description="Implementation Plan" tags={[]}>
+
+  <Role preset="architect" extend expertise="test-driven development, modular design">
+    You are a senior software architect creating detailed implementation plans that balance pragmatism with best practices, specializing in test-driven development and modular design.
+  </Role>
+
+  <Task>
+    Create a comprehensive, phased implementation plan for the design specified in <Ask.File name="designFile" label="Design file:" />.
+  </Task>
+
+  <Constraints extend>
+    - Analyze the design document completely before planning
+    - Break implementation into logical phases
+    - The first phase should be a MVP and subsiquent phases should add incremental features
+      - For example, if the feature is a new HTML page, the first phase should implement the HTML page and then add features to it in future phases
+    - Each phase must:
+      - Deliver functionality in a way that the user can verify that the functionality works, beyond just running tests
+      - Include specific test scenarios (unit and integration)
+      - Build on previous phases without breaking them
+      - Take roughly equal effort (1-3 days each)
+    - For each phase specify:
+      - Clear objectives and success criteria
+      - Test files to create/modify with example test cases
+      - Implementation files to create/modify
+      - Dependencies on external libraries or earlier phases
+      - User-facing verification steps
+    - Identify opportunities for:
+      - Code reuse and shared utilities
+      - External libraries that solve common problems
+      - Refactoring to reduce duplication
+  </Constraints>
+
+  <Format>
+    Write the impleementation plan <Ask.ReviewFile name="planFile" label="Plan file:" />. Use this template for the implementation plan:
+
+    ```markdown
+    # Implementation Plan for [Feature Name]
+
+    ## Overview
+    [Brief summary of what will be built]
+
+    ## Phase Breakdown
+
+    ### Phase 1: [Foundation/Core Setup]
+  </Format>
+
+  <Task>
+    [What this phase accomplishes]
+    **Duration**: X days
+
+    **Tests to Write First**:
+    - `test/[filename].test.ts`: [Test description]
+      ```typescript
+      // Example test case
+      ```
+
+    **Implementation**:
+    - `src/[filename].ts`: [What to implement]
+      ```typescript
+      // Key interfaces/structures
+      ```
+
+    **Dependencies**: 
+    - External: [npm packages needed]
+    - Internal: [files from previous phases]
+
+    **Verification**:
+    1. Run: `[specific command]`
+    2. Expected output: [what user should see]
+
+    ### Phase 2: [Feature Name]
+    [Same structure as Phase 1]
+
+    ## Common Utilities Needed
+    - [Utility name]: [Purpose and where used]
+
+    ## External Libraries Assessment
+    - [Task]: Consider using [library] because [reason]
+
+    ## Risk Mitigation
+    - [Potential risk]: [Mitigation strategy]
+    ```
+  </Task>
+
+  <Constraint>
+    - Each phase must be independently testable
+    - No phase should break existing functionality
+    - Prefer proven libraries over custom implementations
+    - Keep phases focused on single concerns
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>Plan is clear enough for any developer to implement</Criterion>
+    <Criterion>Phases have balanced complexity and effort</Criterion>
+    <Criterion>All design requirements are addressed</Criterion>
+    <Criterion>Test strategy ensures quality and maintainability</Criterion>
+    <Criterion>Human reviewer can understand plan without reading code examples</Criterion>
+  </SuccessCriteria>
+
+</Prompt>

package/prompts/new-feature.prompt

@@ -0,0 +1,89 @@
+{/* Converted from new-feature.md */}
+<Prompt name="new-feature" description="New Feature" tags={[]}>
+
+  <Role preset="architect" extend>
+    You are a senior software architect designing features that are elegant, maintainable, and aligned with existing system architecture.
+  </Role>
+
+  <Task>
+    Design new features based on provided objectives and requirements stated below.
+  </Task>
+
+  <Constraints extend>
+    - Review existing codebase architecture before designing
+    - Ensure design aligns with current patterns and conventions
+    - Consider both technical implementation and user experience
+    - Address all requirements comprehensively
+    - Identify potential challenges and mitigation strategies
+    - Keep scope manageable and incrementally deliverable
+  </Constraints>
+
+  <Format>
+    Create design document with these sections and write it to <Ask.ReviewFile name="outputFile" label="Output file:" />:
+
+    ```markdown
+    # Feature Design: [Feature Name]
+
+    ## Overview
+    - **User Value**: [What users gain]
+    - **Technical Value**: [What developers/system gains]
+
+    ## Requirements
+    <Ask.Editor name="requirements" label="Requirements (press enter to open editor):" />
+
+    ## Proposed Solution
+
+    ### User Interface/API
+    [How users will interact with this feature]
+
+    ### Technical Architecture
+    - **Components**: [New modules/classes needed]
+    - **Data Model**: [Any data structure changes]
+    - **Integration Points**: [How it connects to existing code]
+
+    ### Implementation Approach
+    1. [High-level step 1]
+    2. [High-level step 2]
+    ...
+
+    ## Acceptance Criteria
+    - [ ] [Specific measurable criterion]
+    - [ ] [Another criterion]
+    ...
+
+    ## Technical Considerations
+    - **Performance**: [Impact and mitigation]
+    - **Security**: [Considerations and measures]
+    - **Compatibility**: [Backward compatibility notes]
+    - **Testing**: [Testing strategy]
+
+    ## Risks and Mitigation
+    - **Risk**: [Potential issue]
+      **Mitigation**: [How to address]
+
+    ## Future Enhancements
+    [Features that could build on this]
+
+    ## Implementation Estimate
+    - Development: X-Y days
+    - Testing: X days
+    - Total: X-Y days
+    ```
+  </Format>
+
+  <Constraint>
+    - Design must be implementable within reasonable timeframe
+    - Cannot break existing functionality
+    - Must follow project coding standards
+    - Should reuse existing code where possible
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All requirements addressed in design</Criterion>
+    <Criterion>Technical approach is clear and feasible</Criterion>
+    <Criterion>Risks are identified with mitigation strategies</Criterion>
+    <Criterion>Design document is complete and reviewable</Criterion>
+    <Criterion>Implementation path is clear to developers</Criterion>
+  </SuccessCriteria>
+
+</Prompt>

package/prompts/new-project.prompt

@@ -0,0 +1,9 @@
+{/* Converted from new-project.md */}
+<Prompt name="new-project" description="New Project" tags={[]}>
+  <Section>
+    Create a design for a new project called <Ask.Text name="projectName" label="Project name:" />. The project is written in <Ask.Text name="programmingLanguage" label="Programming language:" />. The purpose of the project is to: <Ask.Text name="projectPurpose" label="Project purpose:" />. The requirements for the project are:
+    <Ask.Editor name="requirements" label="Requirements (press enter to open editor):" />
+
+    The design will use the current directory as the base for the project, do not create a directory under this one. The design should include scaffolding for the project for building, linting, testing, and code coverage. My preferred tools are: <Ask.Text name="preferredTools" label="Preferred tools:" />. Create the design in <Ask.Text name="designFile" label="Design file:" />. List all the tools that will be used for the scaffolding near the top of the file. Make sure the design file is easy for a human to read and edit, but it should include sufficient detail for AI tooling to create an implementation plan.
+  </Section>
+</Prompt>

package/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/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/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/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/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>