claude-code-templates 1.2.0 → 1.3.0

package/templates/common/.claude/commands/project-setup.md

@@ -1,316 +0,0 @@
-# Project Setup Helper
-
-Set up new projects with proper structure and best practices.
-
-## Purpose
-
-This command helps you set up new projects with proper directory structure, configuration files, and development environment.
-
-## Usage
-
-```
-/project-setup
-```
-
-## What this command does
-
-1. **Creates project structure** with standard directories
-2. **Sets up configuration files** (.gitignore, README, etc.)
-3. **Initializes version control** and development tools
-4. **Configures environment files** and dependencies
-5. **Follows language-specific** conventions and best practices
-
-## Project Structure Templates
-
-### Generic Project Structure
-```
-project-name/
-├── README.md                 # Project documentation
-├── .gitignore               # Git ignore rules
-├── .env.example             # Environment variables template
-├── LICENSE                  # Project license
-├── CHANGELOG.md             # Version history
-├── docs/                    # Documentation
-│   ├── API.md
-│   ├── CONTRIBUTING.md
-│   └── DEPLOYMENT.md
-├── src/                     # Source code
-│   ├── main/
-│   ├── utils/
-│   └── config/
-├── tests/                   # Test files
-│   ├── unit/
-│   ├── integration/
-│   └── fixtures/
-├── scripts/                 # Build and deployment scripts
-│   ├── build.sh
-│   ├── deploy.sh
-│   └── setup.sh
-└── config/                  # Configuration files
-    ├── development.yml
-    ├── production.yml
-    └── testing.yml
-```
-
-### Web Application Structure
-```
-web-app/
-├── public/                  # Static assets
-│   ├── index.html
-│   ├── favicon.ico
-│   └── assets/
-│       ├── css/
-│       ├── js/
-│       └── images/
-├── src/                     # Source code
-│   ├── components/          # Reusable components
-│   ├── pages/              # Page components
-│   ├── services/           # API services
-│   ├── utils/              # Utility functions
-│   ├── styles/             # Stylesheets
-│   └── config/             # Configuration
-├── tests/                   # Test files
-└── build/                   # Build output
-```
-
-### API Project Structure
-```
-api-project/
-├── src/
-│   ├── controllers/         # Request handlers
-│   ├── models/             # Data models
-│   ├── services/           # Business logic
-│   ├── middleware/         # Custom middleware
-│   ├── routes/             # API routes
-│   ├── utils/              # Utility functions
-│   └── config/             # Configuration
-├── tests/
-│   ├── unit/
-│   ├── integration/
-│   └── e2e/
-├── docs/
-│   ├── api-spec.yml        # OpenAPI specification
-│   └── README.md
-└── scripts/
-    ├── seed-db.js          # Database seeding
-    └── migrate.js          # Database migrations
-```
-
-## Essential Configuration Files
-
-### .gitignore Template
-```gitignore
-# Dependencies
-node_modules/
-*.log
-npm-debug.log*
-
-# Environment files
-.env
-.env.local
-.env.production
-
-# Build outputs
-dist/
-build/
-*.tgz
-
-# IDE files
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Temporary files
-*.tmp
-*.temp
-```
-
-### README.md Template
-```markdown
-# Project Name
-
-Brief description of what this project does.
-
-## Features
-
-- Feature 1
-- Feature 2
-- Feature 3
-
-## Installation
-
-\`\`\`bash
-# Clone the repository
-git clone https://github.com/username/project-name.git
-
-# Install dependencies
-npm install
-
-# Copy environment file
-cp .env.example .env
-\`\`\`
-
-## Usage
-
-\`\`\`bash
-# Start development server
-npm run dev
-
-# Run tests
-npm test
-
-# Build for production
-npm run build
-\`\`\`
-
-## API Documentation
-
-[API documentation](docs/API.md)
-
-## Contributing
-
-Please read [CONTRIBUTING.md](docs/CONTRIBUTING.md) for details.
-
-## License
-
-This project is licensed under the MIT License - see [LICENSE](LICENSE) file.
-```
-
-### .env.example Template
-```env
-# Application
-NODE_ENV=development
-PORT=3000
-HOST=localhost
-
-# Database
-DB_HOST=localhost
-DB_PORT=5432
-DB_NAME=myapp
-DB_USER=username
-DB_PASSWORD=password
-
-# API Keys
-API_KEY=your-api-key-here
-SECRET_KEY=your-secret-key-here
-
-# External Services
-REDIS_URL=redis://localhost:6379
-EMAIL_SERVICE_API_KEY=your-email-key
-```
-
-## Development Environment Setup
-
-### Package.json Scripts
-```json
-{
-  "scripts": {
-    "start": "node src/index.js",
-    "dev": "nodemon src/index.js",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "format": "prettier --write src/",
-    "build": "webpack --mode production",
-    "build:dev": "webpack --mode development",
-    "clean": "rm -rf dist/"
-  }
-}
-```
-
-### Git Initialization
-```bash
-# Initialize Git repository
-git init
-
-# Add initial files
-git add .
-
-# Create initial commit
-git commit -m "feat: initial project setup
-
-- Add project structure
-- Configure development environment
-- Add documentation templates
-- Set up testing framework"
-
-# Add remote origin
-git remote add origin https://github.com/username/project-name.git
-
-# Push to remote
-git push -u origin main
-```
-
-## Language-Specific Setup
-
-### Node.js/JavaScript
-```bash
-npm init -y
-npm install --save-dev nodemon jest eslint prettier
-```
-
-### Python
-```bash
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install -r requirements.txt
-```
-
-### Docker Setup
-```dockerfile
-# Dockerfile
-FROM node:16-alpine
-WORKDIR /app
-COPY package*.json ./
-RUN npm install
-COPY . .
-EXPOSE 3000
-CMD ["npm", "start"]
-```
-
-```yaml
-# docker-compose.yml
-version: '3.8'
-services:
-  app:
-    build: .
-    ports:
-      - "3000:3000"
-    environment:
-      - NODE_ENV=development
-    volumes:
-      - .:/app
-      - /app/node_modules
-```
-
-## Best Practices
-
-1. **Consistent Structure** - Follow established conventions
-2. **Clear Documentation** - Write comprehensive README
-3. **Environment Variables** - Keep secrets out of code
-4. **Version Control** - Initialize Git from the start
-5. **Testing Setup** - Configure testing from day one
-6. **Code Quality** - Set up linting and formatting
-7. **CI/CD Ready** - Structure for automated deployment
-8. **Security** - Include security best practices
-
-## Checklist
-
-- [ ] Create project directory structure
-- [ ] Initialize version control (Git)
-- [ ] Set up package manager (npm, pip, etc.)
-- [ ] Create README.md with project info
-- [ ] Add .gitignore file
-- [ ] Set up environment variables
-- [ ] Configure linting and formatting
-- [ ] Set up testing framework
-- [ ] Create basic documentation
-- [ ] Add license file
-- [ ] Set up CI/CD configuration (if needed)

package/templates/common/CLAUDE.md

@@ -1,109 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Universal Development Guidelines
-
-### Code Quality Standards
-- Write clean, readable, and maintainable code
-- Follow consistent naming conventions across the project
-- Use meaningful variable and function names
-- Keep functions focused and single-purpose
-- Add comments for complex logic and business rules
-
-### Git Workflow
-- Use descriptive commit messages following conventional commits format
-- Create feature branches for new development
-- Keep commits atomic and focused on single changes
-- Use pull requests for code review before merging
-- Maintain a clean commit history
-
-### Documentation
-- Keep README.md files up to date
-- Document public APIs and interfaces
-- Include usage examples for complex features
-- Maintain inline code documentation
-- Update documentation when making changes
-
-### Testing Approach
-- Write tests for new features and bug fixes
-- Maintain good test coverage
-- Use descriptive test names that explain the expected behavior
-- Organize tests logically by feature or module
-- Run tests before committing changes
-
-### Security Best Practices
-- Never commit sensitive information (API keys, passwords, tokens)
-- Use environment variables for configuration
-- Validate input data and sanitize outputs
-- Follow principle of least privilege
-- Keep dependencies updated
-
-## Project Structure Guidelines
-
-### File Organization
-- Group related files in logical directories
-- Use consistent file and folder naming conventions
-- Separate source code from configuration files
-- Keep build artifacts out of version control
-- Organize assets and resources appropriately
-
-### Configuration Management
-- Use configuration files for environment-specific settings
-- Centralize configuration in dedicated files
-- Use environment variables for sensitive or environment-specific data
-- Document configuration options and their purposes
-- Provide example configuration files
-
-## Development Workflow
-
-### Before Starting Work
-1. Pull latest changes from main branch
-2. Create a new feature branch
-3. Review existing code and architecture
-4. Plan the implementation approach
-
-### During Development
-1. Make incremental commits with clear messages
-2. Run tests frequently to catch issues early
-3. Follow established coding standards
-4. Update documentation as needed
-
-### Before Submitting
-1. Run full test suite
-2. Check code quality and formatting
-3. Update documentation if necessary
-4. Create clear pull request description
-
-## Common Patterns
-
-### Error Handling
-- Use appropriate error handling mechanisms for the language
-- Provide meaningful error messages
-- Log errors appropriately for debugging
-- Handle edge cases gracefully
-- Don't expose sensitive information in error messages
-
-### Performance Considerations
-- Profile code for performance bottlenecks
-- Optimize database queries and API calls
-- Use caching where appropriate
-- Consider memory usage and resource management
-- Monitor and measure performance metrics
-
-### Code Reusability
-- Extract common functionality into reusable modules
-- Use dependency injection for better testability
-- Create utility functions for repeated operations
-- Design interfaces for extensibility
-- Follow DRY (Don't Repeat Yourself) principle
-
-## Review Checklist
-
-Before marking any task as complete:
-- [ ] Code follows established conventions
-- [ ] Tests are written and passing
-- [ ] Documentation is updated
-- [ ] Security considerations are addressed
-- [ ] Performance impact is considered
-- [ ] Code is reviewed for maintainability

package/templates/common/README.md

@@ -1,96 +0,0 @@
-# Common Claude Code Templates
-
-This folder contains language-agnostic templates and configurations that can be used across different programming languages and project types.
-
-## What's Included
-
-### Core Files
-- `CLAUDE.md` - Base configuration for Claude Code with universal best practices
-- `.claude/commands/` - Custom commands for common development tasks
-
-### Common Custom Commands
-- `git-workflow.md` - Git operations and workflow automation
-- `code-review.md` - Code review and quality assurance tasks
-- `project-setup.md` - Project initialization and configuration
-- `documentation.md` - Documentation generation and maintenance
-
-## How to Use
-
-### For New Projects
-Copy the entire `common/` folder contents to your project root:
-
-```bash
-cp -r claude-code-templates/common/* your-project/
-```
-
-### For Existing Projects
-Merge the relevant files with your existing Claude Code configuration:
-
-```bash
-# Copy custom commands
-cp -r claude-code-templates/common/.claude/commands/* your-project/.claude/commands/
-
-# Review and merge CLAUDE.md content
-cat claude-code-templates/common/CLAUDE.md >> your-project/CLAUDE.md
-```
-
-## Customization
-
-### CLAUDE.md
-The base CLAUDE.md file includes:
-- Universal development best practices
-- Common project patterns and conventions
-- Git workflow guidelines
-- Code quality standards
-
-Customize it by:
-- Adding project-specific information
-- Modifying coding standards to match your team's preferences
-- Including technology-specific guidelines
-
-### Custom Commands
-The included commands are designed to be generic and widely applicable. You can:
-- Modify existing commands to match your workflow
-- Add new commands for project-specific tasks
-- Remove commands that don't apply to your project
-
-## Language-Specific Integration
-
-This common template is designed to work alongside language-specific templates:
-
-1. Start with the common template
-2. Add language-specific configurations from the appropriate folder
-3. Customize both to match your project needs
-
-## Examples
-
-### Multi-language Projects
-For projects using multiple programming languages:
-
-```bash
-# Copy common base
-cp -r claude-code-templates/common/* your-project/
-
-# Add language-specific configurations
-cp -r claude-code-templates/javascript-typescript/.claude/commands/* your-project/.claude/commands/
-cp -r claude-code-templates/python/.claude/commands/* your-project/.claude/commands/
-```
-
-### Team Standardization
-Organizations can use this as a base template and customize it for their specific needs:
-
-1. Fork this repository
-2. Modify the common templates to match your standards
-3. Distribute to development teams
-4. Keep synchronized with updates
-
-## Best Practices
-
-- **Start Simple**: Begin with the common template and add complexity as needed
-- **Document Changes**: Keep track of customizations in your project's documentation
-- **Regular Updates**: Periodically review and update your Claude Code configuration
-- **Team Alignment**: Ensure all team members understand the custom commands and workflows
-
-## Contributing
-
-If you create useful generic commands or improvements to the common template, consider contributing them back to this repository to help other developers.

package/templates/go/README.md

@@ -1,25 +0,0 @@
-# Go Claude Code Templates
-
-## Coming Soon! 🚧
-
-We're actively working on creating comprehensive Claude Code templates for Go development.
-
-### What to Expect
-- Best practices for Go project structure
-- Integration with popular Go tools and frameworks
-- Workflow optimizations for Go development
-- Testing and benchmarking configurations
-- Deployment and build automation
-
-### Meanwhile...
-You can use the [common templates](../common/README.md) as a starting point for your Go projects. The universal guidelines and git workflows will work well with Go development.
-
-### Stay Updated
-⭐ Star this repository to get notified when the Go templates are released!
-
-### Contributing
-Interested in helping build these templates? We welcome contributions! Please check the main repository's contribution guidelines and feel free to open an issue or pull request.
-
----
-
-*Expected release: Coming soon*

package/templates/javascript-typescript/.claude/commands/api-endpoint.md

@@ -1,51 +0,0 @@
-# API Endpoint Generator
-
-Generate a complete API endpoint for $ARGUMENTS following project conventions.
-
-## Task
-
-I'll analyze the project structure and create a new API endpoint with:
-
-1. Route definition
-2. Controller/handler function
-3. Input validation
-4. Service layer logic (if applicable)
-5. Data access layer (if applicable)
-6. Unit tests
-7. Documentation
-
-## Process
-
-I'll follow these steps:
-
-1. Examine the project structure to understand the architecture pattern
-2. Identify existing patterns for routes, controllers, and validation
-3. Create all necessary files following project conventions
-4. Implement the endpoint with proper error handling
-5. Add appropriate tests
-6. Document the new endpoint
-
-## Best Practices
-
-I'll ensure the implementation includes:
-
-- Strong typing with TypeScript
-- Comprehensive error handling
-- Input validation
-- Security considerations (authentication/authorization)
-- Proper logging
-- Performance considerations
-- Test coverage
-
-## Adaptability
-
-I'll adapt to various API architectures:
-
-- Express/Koa/Fastify REST APIs
-- GraphQL resolvers
-- Next.js/Nuxt.js API routes
-- Serverless functions
-- tRPC endpoints
-- NestJS controllers
-
-I'll examine your project first to determine which pattern to follow.

package/templates/javascript-typescript/.claude/commands/debug.md

@@ -1,52 +0,0 @@
-# Debug Assistant
-
-Help me debug the issue with $ARGUMENTS in this project.
-
-## Task
-
-I'll help you identify and fix the problem by:
-
-1. Understanding the issue description
-2. Analyzing relevant code
-3. Identifying potential causes
-4. Suggesting and implementing fixes
-5. Verifying the solution works
-
-## Process
-
-I'll follow these steps:
-
-1. Examine error messages, logs, or unexpected behaviors
-2. Locate relevant files and code sections
-3. Analyze the code flow and potential failure points
-4. Identify common JavaScript/TypeScript pitfalls that might apply
-5. Suggest specific fixes with explanations
-6. Help implement and test the solution
-
-## Debugging Techniques
-
-I'll apply appropriate debugging techniques such as:
-
-- Static code analysis to find syntax or type errors
-- Runtime error analysis from logs or stack traces
-- Control flow tracing to understand execution paths
-- State inspection to identify incorrect values
-- Dependency analysis to find version conflicts
-- Network request inspection for API issues
-- Browser console analysis for frontend problems
-- Database query inspection for data issues
-
-## Common Issues I Can Help With
-
-- Type errors and null/undefined issues
-- Asynchronous code problems (Promises, async/await)
-- React/Vue/Angular component lifecycle issues
-- API integration problems
-- State management bugs
-- Performance bottlenecks
-- Memory leaks
-- Build/compilation errors
-- Testing failures
-- Environment configuration issues
-
-I'll adapt my approach based on your specific project structure, frameworks, and the nature of the problem.

package/templates/javascript-typescript/.claude/commands/lint.md

@@ -1,48 +0,0 @@
-# Lint Assistant
-
-Analyze and fix linting issues in $ARGUMENTS following project conventions.
-
-## Task
-
-I'll help you identify and fix code style and quality issues by:
-
-1. Running appropriate linters for the project
-2. Analyzing linting errors and warnings
-3. Fixing issues automatically when possible
-4. Explaining complex issues that require manual intervention
-5. Ensuring code follows project style guidelines
-
-## Process
-
-I'll follow these steps:
-
-1. Identify the linting tools used in the project (ESLint, Prettier, TSLint, etc.)
-2. Run the appropriate linting commands
-3. Parse and categorize the results
-4. Apply automatic fixes for common issues
-5. Provide explanations and suggestions for more complex problems
-6. Verify fixes don't introduce new issues
-
-## Common Linting Issues I Can Fix
-
-- Code style inconsistencies (spacing, indentation, quotes, etc.)
-- Unused variables and imports
-- Missing type annotations in TypeScript
-- Accessibility (a11y) issues in UI components
-- Potential bugs flagged by static analysis
-- Performance issues in React/Vue components
-- Security vulnerabilities detected by linters
-- Deprecated API usage
-- Import ordering problems
-- Missing documentation
-
-## Linting Tools I Can Work With
-
-- ESLint (with various plugins and configs)
-- Prettier
-- TSLint (legacy)
-- stylelint (for CSS/SCSS)
-- commitlint (for commit messages)
-- Custom lint rules specific to your project
-
-I'll adapt my approach based on your project's specific linting configuration and style guide requirements.