claude-code-workflow 6.2.3 → 6.2.5

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

@@ -1,29 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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.