claude-code-templates 1.21.1 → 1.21.2

package/cli-tool/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/cli-tool/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/cli-tool/templates/go/.mcp.json

@@ -1,78 +0,0 @@
-{
-  "mcpServers": {
-    "go-sdk": {
-      "name": "Go SDK",
-      "description": "Official SDK maintained with Google for Go MCP development",
-      "command": "go-sdk-server",
-      "args": [],
-      "env": {}
-    },
-    "language-server": {
-      "name": "MCP Language Server",
-      "description": "Semantic tools for Go: definitions, references, diagnostics",
-      "command": "mcp-language-server",
-      "args": [],
-      "env": {}
-    },
-    "gin": {
-      "name": "Gin MCP",
-      "description": "Expose Gin APIs automatically as MCP tools",
-      "command": "gin-mcp",
-      "args": [],
-      "env": {}
-    },
-    "mysql": {
-      "name": "Go MySQL MCP",
-      "description": "Easy-to-use MySQL MCP server built in Go",
-      "command": "go-mcp-mysql",
-      "args": [],
-      "env": {
-        "MYSQL_DSN": "user:pass@tcp(host)/db"
-      }
-    },
-    "archer": {
-      "name": "Go Archer",
-      "description": "Visual dependency analysis for Go packages",
-      "command": "go-archer",
-      "args": [],
-      "env": {}
-    },
-    "memory-bank": {
-      "name": "Memory Bank MCP",
-      "description": "Centralized memory system for AI agents",
-      "command": "server-memory",
-      "args": [],
-      "env": {}
-    },
-    "sequential-thinking": {
-      "name": "Sequential Thinking MCP",
-      "description": "Helps LLMs decompose complex tasks into logical steps",
-      "command": "code-reasoning",
-      "args": [],
-      "env": {}
-    },
-    "brave-search": {
-      "name": "Brave Search MCP",
-      "description": "Privacy-focused web search tool",
-      "command": "server-brave-search",
-      "args": [],
-      "env": {}
-    },
-    "google-maps": {
-      "name": "Google Maps MCP",
-      "description": "Integrates Google Maps for geolocation and directions",
-      "command": "server-google-maps",
-      "args": [],
-      "env": {
-        "GOOGLE_MAPS_API_KEY": "..."
-      }
-    },
-    "deep-graph": {
-      "name": "Deep Graph MCP (Code Graph)",
-      "description": "Transforms source code into semantic graphs via DeepGraph",
-      "command": "mcp-code-graph",
-      "args": [],
-      "env": {}
-    }
-  }
-}

package/cli-tool/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/cli-tool/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/cli-tool/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/cli-tool/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.

package/cli-tool/templates/javascript-typescript/.claude/commands/npm-scripts.md

@@ -1,48 +0,0 @@
-# NPM Scripts Assistant
-
-Help me with NPM scripts: $ARGUMENTS
-
-## Task
-
-I'll help you work with package.json scripts by:
-
-1. Analyzing existing npm scripts in your project
-2. Creating new scripts or modifying existing ones
-3. Explaining what specific scripts do
-4. Suggesting improvements or optimizations
-5. Troubleshooting script execution issues
-
-## Process
-
-I'll follow these steps:
-
-1. Examine your package.json file to understand current scripts
-2. Analyze dependencies and devDependencies for available tools
-3. Identify common patterns and conventions in your scripts
-4. Implement requested changes or create new scripts
-5. Provide explanations of how the scripts work
-6. Test scripts when possible to verify functionality
-
-## Common Script Types I Can Help With
-
-- Build processes (webpack, rollup, esbuild, etc.)
-- Development servers and hot reloading
-- Testing (unit, integration, e2e)
-- Linting and code formatting
-- Type checking
-- Deployment and CI/CD
-- Database migrations
-- Code generation
-- Environment setup
-- Pre/post hooks for git operations
-
-## Script Optimization Techniques
-
-- Parallelizing tasks for faster execution
-- Adding cross-platform compatibility
-- Improving error reporting and logging
-- Implementing watch modes for development
-- Creating composite scripts for common workflows
-- Adding appropriate exit codes for CI/CD pipelines
-
-I'll adapt my approach based on your project's specific needs, dependencies, and build tools.

package/cli-tool/templates/javascript-typescript/.claude/commands/refactor.md

@@ -1,55 +0,0 @@
-# Code Refactoring Assistant
-
-Refactor $ARGUMENTS following modern JavaScript/TypeScript best practices.
-
-## Task
-
-I'll help you refactor code by:
-
-1. Analyzing the current implementation
-2. Identifying improvement opportunities
-3. Applying modern patterns and practices
-4. Maintaining existing functionality
-5. Ensuring type safety and test coverage
-6. Documenting the changes made
-
-## Process
-
-I'll follow these steps:
-
-1. Examine the code to understand its purpose and structure
-2. Identify code smells, anti-patterns, or outdated approaches
-3. Plan the refactoring strategy with clear goals
-4. Implement changes incrementally while maintaining behavior
-5. Verify refactored code with tests
-6. Document improvements and benefits
-
-## Refactoring Techniques
-
-I can apply various refactoring techniques:
-
-- Converting to modern JavaScript/TypeScript features
-- Improving type definitions and type safety
-- Extracting reusable functions and components
-- Applying design patterns appropriately
-- Converting callbacks to Promises or async/await
-- Simplifying complex conditionals and loops
-- Removing duplicate code
-- Improving naming and readability
-- Optimizing performance
-- Enhancing error handling
-
-## Modern Practices I Can Apply
-
-- ES modules and import/export syntax
-- Optional chaining and nullish coalescing
-- Array and object destructuring
-- Spread and rest operators
-- Template literals
-- Arrow functions
-- Class fields and private methods
-- TypeScript utility types
-- Functional programming patterns
-- React hooks (for React components)
-
-I'll ensure the refactored code maintains compatibility with your project's requirements while improving quality and maintainability.

package/cli-tool/templates/javascript-typescript/.claude/commands/test.md

@@ -1,61 +0,0 @@
-# Test Assistant
-
-Help with tests for $ARGUMENTS following project conventions and testing best practices.
-
-## Task
-
-I'll help you with testing by:
-
-1. Creating comprehensive test suites for your code
-2. Implementing different types of tests (unit, integration, e2e)
-3. Mocking dependencies and external services
-4. Improving test coverage for existing code
-5. Troubleshooting failing tests
-6. Setting up testing infrastructure
-
-## Process
-
-I'll follow these steps:
-
-1. Examine your project to understand testing frameworks and patterns
-2. Analyze the code to be tested to understand its functionality
-3. Identify appropriate testing strategies and edge cases
-4. Implement tests with proper structure and assertions
-5. Ensure tests are maintainable and follow best practices
-6. Run tests to verify they pass and provide adequate coverage
-
-## Testing Frameworks I Can Work With
-
-- Jest, Vitest, Mocha, Jasmine for JavaScript/TypeScript
-- React Testing Library, Enzyme for React components
-- Cypress, Playwright, Puppeteer for E2E testing
-- Supertest, Pactum for API testing
-- Storybook for component testing
-- Testing-library family for various frameworks
-
-## Testing Techniques
-
-I can implement various testing approaches:
-
-- TDD (Test-Driven Development)
-- BDD (Behavior-Driven Development)
-- Snapshot testing
-- Property-based testing
-- Parameterized tests
-- Contract testing
-- Visual regression testing
-- Performance testing
-
-## Mocking Strategies
-
-I can help with different mocking approaches:
-
-- Function mocks and spies
-- Module mocks
-- HTTP request mocking
-- Browser API mocking
-- Timer mocking
-- Database mocking
-- Service worker mocking
-
-I'll adapt to your project's specific testing frameworks, patterns, and conventions to ensure consistency with your existing codebase.

package/cli-tool/templates/javascript-typescript/.claude/commands/typescript-migrate.md

@@ -1,51 +0,0 @@
-# TypeScript Migration Assistant
-
-Migrate $ARGUMENTS from JavaScript to TypeScript with proper typing and modern practices.
-
-## Task
-
-I'll help you migrate JavaScript code to TypeScript by:
-
-1. Converting JavaScript files to TypeScript (.js/.jsx to .ts/.tsx)
-2. Adding appropriate type definitions and interfaces
-3. Configuring TypeScript settings for your project
-4. Resolving type errors and compatibility issues
-5. Implementing modern TypeScript patterns and features
-6. Ensuring backward compatibility with existing code
-
-## Process
-
-I'll follow these steps:
-
-1. Examine your project structure and dependencies
-2. Analyze the JavaScript code to understand its functionality
-3. Create or update tsconfig.json with appropriate settings
-4. Convert files to TypeScript with proper type annotations
-5. Add necessary type definitions for libraries
-6. Fix type errors and implement type safety
-7. Refactor code to leverage TypeScript features
-
-## TypeScript Features I Can Implement
-
-- Interfaces and type aliases for complex data structures
-- Generics for reusable, type-safe components and functions
-- Union and intersection types for flexible typing
-- Enums for related constants
-- Utility types (Partial, Pick, Omit, etc.)
-- Type guards and type narrowing
-- Mapped and conditional types
-- Function overloading
-- Readonly properties and immutability
-- Module augmentation for extending third-party types
-
-## Migration Strategies
-
-I can apply different migration approaches based on your needs:
-
-- Gradual migration with allowJs and incremental adoption
-- File-by-file conversion while maintaining functionality
-- Comprehensive migration with full type safety
-- Hybrid approach with .d.ts files for complex modules
-- Integration with existing type definitions (@types packages)
-
-I'll adapt to your project's specific requirements and ensure a smooth transition to TypeScript while maintaining existing functionality.