claude-code-workflow 6.2.5 → 6.2.6

package/.claude/workflows/cli-templates/prompts/analysis/03-review-quality-standards.txt

@@ -0,0 +1,29 @@
+Analyze code quality and maintainability aspects.
+
+## CORE CHECKLIST ⚡
+□ Analyze against the project's established coding standards
+□ Provide file:line references for all quality issues
+□ Assess both implementation code and test coverage
+□ Apply RULES template requirements exactly as specified
+
+## REQUIRED ANALYSIS
+1. Assess code organization and structural quality
+2. Evaluate naming conventions and readability standards
+3. Review error handling and logging practices
+4. Analyze test coverage and testing strategies
+5. Document technical debt and improvement priorities
+
+## OUTPUT REQUIREMENTS
+- Code quality metrics and specific improvement areas
+- Naming convention consistency analysis
+- Error handling and logging pattern documentation
+- Test coverage assessment with gap identification
+- Prioritized list of technical debt to address
+
+## VERIFICATION CHECKLIST ✓
+□ All CONTEXT files analyzed for code quality
+□ Every finding is backed by a code reference (file:line)
+□ Both code and test quality have been evaluated
+□ Recommendations are prioritized by impact on maintainability
+
+Focus: Maintainability improvements and long-term code health.

package/.claude/workflows/cli-templates/prompts/development/02-generate-tests.txt

@@ -0,0 +1,70 @@
+Create comprehensive tests for the codebase.
+
+## Planning Required
+Before creating tests, you MUST:
+1. Analyze existing test coverage and identify gaps
+2. Study testing frameworks and conventions used
+3. Plan test strategy covering unit, integration, and e2e
+4. Design test data management approach
+
+## Core Checklist
+- [ ] Analyze coverage gaps
+- [ ] Follow testing frameworks and conventions
+- [ ] Include unit, integration, and e2e tests
+- [ ] Ensure tests are reliable and deterministic
+
+## IMPLEMENTATION PHASES
+
+### Test Strategy Phase
+1. Analyze existing test coverage and identify gaps
+2. Study codebase architecture and critical paths
+3. Identify edge cases and error scenarios
+4. Review testing frameworks and conventions used
+
+### Unit Testing Phase
+1. Write tests for individual functions and methods
+2. Test all branches and conditional logic
+3. Cover edge cases and boundary conditions
+4. Mock external dependencies appropriately
+
+### Integration Testing Phase
+1. Test interactions between components and modules
+2. Verify API endpoints and data flow
+3. Test database operations and transactions
+4. Validate external service integrations
+
+### End-to-End Testing Phase
+1. Test complete user workflows and scenarios
+2. Verify critical business logic and processes
+3. Test error handling and recovery mechanisms
+4. Validate performance under load
+
+### Quality Assurance
+1. Ensure tests are reliable and deterministic
+2. Make tests readable and maintainable
+3. Add proper test documentation and comments
+4. Follow testing best practices and conventions
+
+### Test Data Management
+1. Create realistic test data and fixtures
+2. Ensure test isolation and cleanup
+3. Use factories or builders for complex objects
+4. Handle sensitive data appropriately in tests
+
+## OUTPUT REQUIREMENTS
+- Comprehensive test suite with high coverage
+- Performance benchmarks where relevant
+- Testing strategy and conventions documentation
+- Test coverage metrics and quality improvements
+- File:line references for tested code
+
+## Verification Checklist
+Before finalizing, verify:
+- [ ] Coverage gaps filled
+- [ ] All test types included
+- [ ] Tests are reliable (no flaky tests)
+- [ ] Test data properly managed
+- [ ] Conventions followed
+
+## Focus
+High-quality, reliable test suite with comprehensive coverage.

package/.claude/workflows/cli-templates/prompts/development/02-implement-component-ui.txt

@@ -0,0 +1,55 @@
+Create a reusable component following project conventions and best practices.
+
+## CORE CHECKLIST ⚡
+□ Analyze existing component patterns BEFORE implementing
+□ Follow established naming conventions and prop patterns
+□ Include comprehensive tests (unit + visual + accessibility)
+□ Provide complete TypeScript types and documentation
+
+## IMPLEMENTATION PHASES
+
+### Design Phase
+1. Analyze existing component patterns and structures
+2. Identify reusable design principles and styling approaches
+3. Review component hierarchy and prop patterns
+4. Study existing component documentation and usage
+
+### Development Phase
+1. Create component with proper TypeScript interfaces
+2. Implement following established naming conventions
+3. Add appropriate default props and validation
+4. Include comprehensive prop documentation
+
+### Styling Phase
+1. Follow existing styling methodology (CSS modules, styled-components, etc.)
+2. Ensure responsive design principles
+3. Add proper theming support if applicable
+4. Include accessibility considerations (ARIA, keyboard navigation)
+
+### Testing Phase
+1. Write component tests covering all props and states
+2. Test accessibility compliance
+3. Add visual regression tests if applicable
+4. Test component in different contexts and layouts
+
+### Documentation Phase
+1. Create usage examples and code snippets
+2. Document all props and their purposes
+3. Include accessibility guidelines
+4. Add integration examples with other components
+
+## OUTPUT REQUIREMENTS
+- Complete component implementation with TypeScript types
+- Usage examples and integration patterns
+- Component API documentation and best practices
+- Test suite with accessibility validation
+- File:line references for pattern sources
+
+## VERIFICATION CHECKLIST ✓
+□ Implementation follows existing component patterns
+□ Complete TypeScript types and prop documentation
+□ Comprehensive tests (unit + visual + accessibility)
+□ Accessibility compliance (ARIA, keyboard navigation)
+□ Usage examples and integration documented
+
+Focus: Production-ready reusable component with comprehensive documentation and testing.

package/.claude/workflows/cli-templates/prompts/development/02-implement-feature.txt

@@ -0,0 +1,58 @@
+Implement a new feature following project conventions and best practices.
+
+## Planning Required
+Before implementing, you MUST:
+1. Study existing code patterns and conventions
+2. Review project architecture and design principles
+3. Plan implementation with error handling and tests
+4. Document integration points and dependencies
+
+## Core Checklist
+- [ ] Study existing code patterns first
+- [ ] Follow project conventions and architecture
+- [ ] Include comprehensive tests
+- [ ] Provide file:line references
+
+## IMPLEMENTATION PHASES
+
+### Analysis Phase
+1. Study existing code patterns and conventions
+2. Identify similar features and their implementation approaches
+3. Review project architecture and design principles
+4. Understand dependencies and integration points
+
+### Implementation Phase
+1. Create feature following established patterns
+2. Implement with proper error handling and validation
+3. Add comprehensive logging for debugging
+4. Follow security best practices
+
+### Integration Phase
+1. Ensure seamless integration with existing systems
+2. Update configuration files as needed
+3. Add proper TypeScript types and interfaces
+4. Update documentation and comments
+
+### Testing Phase
+1. Write unit tests covering edge cases
+2. Add integration tests for feature workflows
+3. Verify error scenarios are properly handled
+4. Test performance and security implications
+
+## OUTPUT REQUIREMENTS
+- File:line references for all changes
+- Code examples demonstrating key patterns
+- Explanation of architectural decisions made
+- Documentation of new dependencies or configurations
+- Test coverage summary
+
+## Verification Checklist
+Before finalizing, verify:
+- [ ] Follows existing patterns
+- [ ] Complete test coverage
+- [ ] Documentation updated
+- [ ] No breaking changes
+- [ ] Security and performance validated
+
+## Focus
+Production-ready implementation with comprehensive testing and documentation.

package/.claude/workflows/cli-templates/prompts/development/02-refactor-codebase.txt

@@ -0,0 +1,55 @@
+Refactor existing code to improve quality, performance, or maintainability.
+
+## CORE CHECKLIST ⚡
+□ Preserve existing functionality (no behavioral changes unless specified)
+□ Ensure all existing tests continue to pass
+□ Plan incremental changes (avoid big-bang refactoring)
+□ Provide file:line references for all modifications
+
+## IMPLEMENTATION PHASES
+
+### Analysis Phase
+1. Identify code smells and technical debt
+2. Analyze performance bottlenecks and inefficiencies
+3. Review code complexity and maintainability metrics
+4. Study existing test coverage and identify gaps
+
+### Planning Phase
+1. Create refactoring strategy preserving existing functionality
+2. Identify breaking changes and migration paths
+3. Plan incremental refactoring steps
+4. Consider backward compatibility requirements
+
+### Refactoring Phase
+1. Apply SOLID principles and design patterns
+2. Improve code readability and documentation
+3. Optimize performance while maintaining functionality
+4. Reduce code duplication and improve reusability
+
+### Validation Phase
+1. Ensure all existing tests continue to pass
+2. Add new tests for improved code coverage
+3. Verify performance improvements with benchmarks
+4. Test edge cases and error scenarios
+
+### Migration Phase
+1. Update dependent code to use refactored interfaces
+2. Update documentation and usage examples
+3. Provide migration guides for breaking changes
+4. Add deprecation warnings for old interfaces
+
+## OUTPUT REQUIREMENTS
+- Before/after code comparisons with file:line references
+- Performance improvements documented with benchmarks
+- Migration instructions for breaking changes
+- Updated test coverage and quality metrics
+- Technical debt reduction summary
+
+## VERIFICATION CHECKLIST ✓
+□ All existing tests pass (functionality preserved)
+□ New tests added for improved coverage
+□ Performance verified with benchmarks (if applicable)
+□ Backward compatibility maintained or migration provided
+□ Documentation updated with refactoring changes
+
+Focus: Incremental quality improvement while preserving functionality.

package/.claude/workflows/cli-templates/prompts/development/03-debug-runtime-issues.txt

@@ -0,0 +1,55 @@
+Debug and resolve issues systematically in the codebase.
+
+## CORE CHECKLIST ⚡
+□ Identify and reproduce the issue completely before fixing
+□ Perform root cause analysis (not just symptom treatment)
+□ Provide file:line references for all changes
+□ Add tests to prevent regression of this specific issue
+
+## IMPLEMENTATION PHASES
+
+### Issue Analysis Phase
+1. Identify and reproduce the reported issue
+2. Analyze error logs and stack traces
+3. Study code flow and identify potential failure points
+4. Review recent changes that might have introduced the issue
+
+### Investigation Phase
+1. Add strategic logging and debugging statements
+2. Use debugging tools and profilers as appropriate
+3. Test with different input conditions and edge cases
+4. Isolate the root cause through systematic elimination
+
+### Root Cause Analysis
+1. Document the exact cause of the issue
+2. Identify contributing factors and conditions
+3. Assess impact scope and affected functionality
+4. Determine if similar issues exist elsewhere
+
+### Resolution Phase
+1. Implement minimal, targeted fix for the root cause
+2. Ensure fix doesn't introduce new issues or regressions
+3. Add proper error handling and validation
+4. Include defensive programming measures
+
+### Prevention Phase
+1. Add tests to prevent regression of this issue
+2. Improve error messages and logging
+3. Add monitoring or alerts for early detection
+4. Document lessons learned and prevention strategies
+
+## OUTPUT REQUIREMENTS
+- Detailed root cause analysis with file:line references
+- Exact code changes made to resolve the issue
+- New tests added to prevent regression
+- Debugging process documentation and lessons learned
+- Impact assessment and affected functionality
+
+## VERIFICATION CHECKLIST ✓
+□ Root cause identified and documented (not just symptoms)
+□ Minimal fix applied without introducing new issues
+□ Tests added to prevent this specific regression
+□ Similar issues checked and addressed if found
+□ Prevention measures documented
+
+Focus: Systematic root cause resolution with regression prevention.

package/.claude/workflows/cli-templates/prompts/documentation/api.txt

@@ -0,0 +1,15 @@
+Generate comprehensive API documentation for code or HTTP services.
+
+## CORE CHECKLIST ⚡
+□ Include only sections relevant to the project type (Code API vs. HTTP API)
+□ Provide complete and runnable examples for HTTP APIs
+□ Use signatures-only for Code API documentation (no implementation)
+□ Document all public-facing APIs, not internal ones
+
+## UNIFIED API DOCUMENTATION TEMPLATE
+
+This template supports both **Code API** (for libraries/modules) and **HTTP API** (for web services). Include only the sections relevant to your project type.
+
+--- 
+
+...(content truncated)...

package/.claude/workflows/cli-templates/prompts/documentation/folder-navigation.txt

@@ -0,0 +1,27 @@
+Generate a navigation README for directories that contain only subdirectories.
+
+## CORE CHECKLIST ⚡
+□ Keep the content brief and act as an index
+□ Use one-line descriptions for each module
+□ Ensure all mentioned modules link to their respective READMEs
+□ Use scannable formats like tables and lists
+
+## REQUIRED CONTENT
+1. **Overview**: Brief description of the directory's purpose.
+2. **Directory Structure**: A tree view of subdirectories with one-line descriptions.
+3. **Module Quick Reference**: A table with links, purposes, and key features.
+4. **How to Navigate**: Guidance on which module to explore for specific needs.
+5. **Module Relationships (Optional)**: A simple diagram showing dependencies.
+
+## OUTPUT REQUIREMENTS
+- A scannable index for navigating subdirectories.
+- Links to each submodule's detailed documentation.
+- A clear, high-level overview of the directory's contents.
+
+## VERIFICATION CHECKLIST ✓
+□ The generated README is brief and serves as a scannable index
+□ All submodules are linked correctly
+□ Descriptions are concise and clear
+□ The structure follows the required content outline
+
+Focus: Creating a clear and concise navigation hub for parent directories.

package/.claude/workflows/cli-templates/prompts/documentation/module-readme.txt

@@ -0,0 +1,49 @@
+Generate module documentation focused on understanding and usage.
+
+## Planning Required
+Before providing documentation, you MUST:
+1. Understand what the module does and why it exists
+2. Review existing documentation to avoid duplication
+3. Prepare practical usage examples
+4. Identify module boundaries and dependencies
+
+## Core Checklist
+- [ ] Explain WHAT, WHY, and HOW
+- [ ] Reference API.md instead of duplicating signatures
+- [ ] Include practical usage examples
+- [ ] Define module boundaries and dependencies
+
+## DOCUMENTATION STRUCTURE
+
+### 1. Purpose
+- **What**: Clearly state what this module is responsible for.
+- **Why**: Explain the problem it solves.
+- **Boundaries**: Define what is in and out of scope.
+
+### 2. Core Concepts
+- Explain key concepts, patterns, or abstractions.
+
+### 3. Usage Scenarios
+- Provide 2-4 common use cases with code examples.
+
+### 4. Dependencies
+- List internal and external dependencies with explanations.
+
+### 5. Configuration
+- Document environment variables and configuration options.
+
+### 6. Testing
+- Explain how to run tests for the module.
+
+### 7. Common Issues
+- List common problems and their solutions.
+
+## Verification Checklist
+Before finalizing output, verify:
+- [ ] Module purpose, scope, and boundaries are clear
+- [ ] Core concepts are explained
+- [ ] Usage examples are practical and realistic
+- [ ] Dependencies and configuration are documented
+
+## Focus
+Explain module purpose and usage, not just API details.

package/.claude/workflows/cli-templates/prompts/documentation/project-architecture.txt

@@ -0,0 +1,41 @@
+Generate comprehensive architecture documentation for the entire project.
+
+## CORE CHECKLIST ⚡
+□ Synthesize information from all modules; do not duplicate content
+□ Maintain a system-level perspective, focusing on module interactions
+□ Use visual aids (like ASCII diagrams) to clarify structure
+□ Explain the WHY behind architectural decisions
+
+## DOCUMENTATION STRUCTURE
+
+### 1. System Overview
+- Architectural Style, Core Principles, and Technology Stack.
+
+### 2. System Structure
+- Visual representation of the system's layers or components.
+
+### 3. Module Map
+- A table listing all modules, their layers, responsibilities, and dependencies.
+
+### 4. Module Interactions
+- Describe key data flows and show a dependency graph.
+
+### 5. Design Patterns
+- Document key architectural patterns used across the project.
+
+### 6. Aggregated API Overview
+- A high-level summary of all public APIs, grouped by category.
+
+### 7. Data Flow
+- Describe the typical request lifecycle or event flow.
+
+### 8. Security and Scalability
+- Overview of security measures and scalability considerations.
+
+## VERIFICATION CHECKLIST ✓
+□ The documentation provides a cohesive, system-level view
+□ Module interactions and dependencies are clearly illustrated
+□ The rationale behind major design patterns and decisions is explained
+□ The document synthesizes, rather than duplicates, module-level details
+
+Focus: Providing a holistic, system-level understanding of the project architecture.

package/.claude/workflows/cli-templates/prompts/documentation/project-examples.txt

@@ -0,0 +1,35 @@
+Generate practical, end-to-end examples demonstrating core project usage.
+
+## CORE CHECKLIST ⚡
+□ Provide complete, runnable code for every example
+□ Focus on realistic, real-world scenarios, not trivial cases
+□ Explain the flow and how different modules interact
+□ Include expected output to verify correctness
+
+## EXAMPLES STRUCTURE
+
+### 1. Introduction
+- Overview of the examples and any prerequisites.
+
+### 2. Quick Start Example
+- The simplest possible working example to verify setup.
+
+### 3. Core Use Cases
+- 3-5 complete examples for common scenarios with code, output, and explanations.
+
+### 4. Advanced & Integration Examples
+- Showcase more complex scenarios or integrations with external systems.
+
+### 5. Testing Examples
+- Show how to test code that uses the project.
+
+### 6. Best Practices & Troubleshooting
+- Demonstrate recommended patterns and provide solutions to common issues.
+
+## VERIFICATION CHECKLIST ✓
+□ All examples are complete, runnable, and tested
+□ Scenarios are realistic and demonstrate key project features
+□ Explanations clarify module interactions and data flow
+□ Best practices and error handling are demonstrated
+
+Focus: Helping users accomplish common tasks through complete, practical examples.

package/.claude/workflows/cli-templates/prompts/documentation/project-readme.txt

@@ -0,0 +1,35 @@
+Generate a comprehensive project-level README documentation.
+
+## CORE CHECKLIST ⚡
+□ Clearly state the project's purpose and target audience
+□ Provide clear, runnable instructions for getting started
+□ Outline the development workflow and coding standards
+□ Offer a high-level overview of the project structure and architecture
+
+## README STRUCTURE
+
+### 1. Overview
+- Purpose, Target Audience, and Key Features.
+
+### 2. System Architecture
+- Architectural Style, Core Components, Tech Stack, and Design Principles.
+
+### 3. Getting Started
+- Prerequisites, Installation, Configuration, and Running the Project.
+
+### 4. Development Workflow
+- Branching Strategy, Coding Standards, Testing, and Build/Deployment.
+
+### 5. Project Structure
+- A high-level tree view of the main directories.
+
+### 6. Navigation
+- Links to more detailed documentation (modules, API, architecture).
+
+## VERIFICATION CHECKLIST ✓
+□ The project's purpose and value proposition are clear
+□ A new developer can successfully set up and run the project
+□ The development process and standards are well-defined
+□ The README provides clear navigation to other key documents
+
+Focus: Providing a central entry point for new users and developers to understand and run the project.