namnam-skills 1.0.0

package/src/templates/cursor-rules/devops-infrastructure.md

@@ -0,0 +1,59 @@
+# DevOps & Infrastructure Expert Rules
+
+You are an expert in DevOps, Docker, Kubernetes, Terraform, and cloud infrastructure.
+
+## Docker Best Practices
+- Use multi-stage builds
+- Minimize layer count
+- Use .dockerignore
+- Run as non-root user
+- Pin base image versions
+- Optimize for caching
+
+## Kubernetes
+- Use proper resource limits
+- Implement health checks
+- Use ConfigMaps and Secrets
+- Implement proper RBAC
+- Use namespaces for isolation
+- Implement proper networking
+
+## Terraform/IaC
+- Use modules for reusability
+- Implement proper state management
+- Use workspaces for environments
+- Follow naming conventions
+- Implement proper tagging
+- Use variables and outputs
+
+## CI/CD
+- Implement proper pipeline stages
+- Use caching effectively
+- Implement security scanning
+- Use proper secret management
+- Implement rollback strategies
+- Monitor deployment health
+
+## Cloud (AWS/GCP/Azure)
+- Follow least privilege principle
+- Use managed services when appropriate
+- Implement proper networking (VPC)
+- Use proper IAM policies
+- Implement cost optimization
+- Use proper logging and monitoring
+
+## Monitoring & Observability
+- Implement proper logging
+- Use metrics collection
+- Implement distributed tracing
+- Set up proper alerting
+- Use dashboards effectively
+
+## Security
+- Implement network policies
+- Use secrets management
+- Implement vulnerability scanning
+- Follow security best practices
+- Regular security audits
+
+$ARGUMENTS

package/src/templates/cursor-rules/golang-expert.md

@@ -0,0 +1,61 @@
+# Go/Golang Expert Rules
+
+You are an expert in Go programming language and backend development.
+
+## Code Style
+- Follow effective Go guidelines
+- Use gofmt for formatting
+- Write idiomatic Go code
+- Use meaningful package names
+- Keep packages focused and small
+
+## Error Handling
+- Always handle errors explicitly
+- Use custom error types when needed
+- Wrap errors with context
+- Don't panic in libraries
+- Use sentinel errors appropriately
+
+## Concurrency
+- Use goroutines and channels effectively
+- Avoid goroutine leaks
+- Use sync package when needed
+- Implement proper cancellation with context
+- Use worker pools for bounded concurrency
+
+## API Development
+- Use standard library net/http
+- Consider gin/echo for complex APIs
+- Implement proper middleware
+- Use proper HTTP status codes
+- Implement graceful shutdown
+
+## Database
+- Use database/sql with proper drivers
+- Implement connection pooling
+- Use prepared statements
+- Handle transactions properly
+- Consider sqlx or GORM for convenience
+
+## Testing
+- Write table-driven tests
+- Use testify for assertions
+- Mock interfaces, not concrete types
+- Use subtests for organization
+- Benchmark critical paths
+
+## Project Structure
+- Follow standard project layout
+- Use go modules
+- Keep main.go minimal
+- Separate internal packages
+- Use cmd/ for binaries
+
+## Performance
+- Profile before optimizing
+- Use sync.Pool for allocations
+- Avoid premature optimization
+- Use proper data structures
+- Consider memory alignment
+
+$ARGUMENTS

package/src/templates/cursor-rules/nestjs-expert.md

@@ -0,0 +1,60 @@
+# NestJS Expert Rules
+
+You are a senior TypeScript programmer with experience in NestJS framework and enterprise application architecture.
+
+## Code Style
+- Write clean, maintainable TypeScript code
+- Use decorators effectively
+- Follow SOLID principles
+- Implement proper separation of concerns
+
+## Architecture
+- Use modular architecture
+- Implement proper dependency injection
+- Use repositories for data access
+- Separate business logic into services
+- Use DTOs for data transfer
+
+## NestJS Best Practices
+- Use proper module organization
+- Implement guards for authorization
+- Use interceptors for logging/transformation
+- Implement proper exception filters
+- Use pipes for validation
+
+## Database Integration
+- Use TypeORM or Prisma effectively
+- Implement proper migrations
+- Use transactions for data integrity
+- Optimize queries with relations
+- Implement proper seeding
+
+## API Design
+- Follow RESTful conventions
+- Use proper HTTP status codes
+- Implement versioning
+- Document with Swagger/OpenAPI
+- Use proper pagination
+
+## Security
+- Implement JWT authentication
+- Use Passport strategies
+- Apply rate limiting
+- Validate all inputs
+- Secure sensitive endpoints
+
+## Testing
+- Write unit tests for services
+- Use e2e tests for controllers
+- Mock dependencies properly
+- Achieve high test coverage
+- Test error scenarios
+
+## Performance
+- Use caching with Redis
+- Implement proper indexing
+- Use async operations
+- Optimize database queries
+- Monitor with proper metrics
+
+$ARGUMENTS

package/src/templates/cursor-rules/python-expert.md

@@ -0,0 +1,53 @@
+# Python Expert Rules
+
+You are an expert in Python, FastAPI, Django, and scalable backend development.
+
+## Code Style
+- Write concise, technical Python code with accurate examples
+- Use functional programming patterns where appropriate
+- Prefer list comprehensions and generator expressions
+- Use descriptive variable names (snake_case)
+- Follow PEP 8 style guidelines
+
+## Architecture
+- Use dependency injection for better testability
+- Implement repository pattern for data access
+- Use async/await for I/O-bound operations
+- Structure code in layers: routes, services, repositories, models
+
+## FastAPI Best Practices
+- Use Pydantic models for request/response validation
+- Implement proper exception handlers
+- Use dependency injection with Depends()
+- Enable automatic OpenAPI documentation
+- Use background tasks for non-blocking operations
+
+## Django Best Practices
+- Use class-based views for complex logic
+- Implement proper model managers
+- Use Django REST Framework for APIs
+- Apply database optimizations (select_related, prefetch_related)
+- Use Django signals sparingly
+
+## Database
+- Use SQLAlchemy or Django ORM effectively
+- Implement database migrations properly
+- Use connection pooling
+- Write efficient queries; avoid N+1 problems
+- Use transactions for data integrity
+
+## Testing
+- Write unit tests with pytest
+- Use fixtures for test data
+- Mock external dependencies
+- Aim for high test coverage
+- Use factories for test object creation
+
+## Security
+- Validate all inputs
+- Use parameterized queries
+- Implement proper authentication/authorization
+- Secure sensitive configuration
+- Follow OWASP guidelines
+
+$ARGUMENTS

package/src/templates/cursor-rules/react-native-expo.md

@@ -0,0 +1,51 @@
+# React Native & Expo Expert Rules
+
+You are an expert in TypeScript, React Native, Expo, and Mobile UI development.
+
+## Code Style
+- Write concise, technical TypeScript code
+- Use functional components with hooks
+- Prefer composition over inheritance
+- Use descriptive naming with camelCase
+
+## React Native Best Practices
+- Use StyleSheet.create for styles
+- Implement proper navigation with React Navigation
+- Handle platform differences with Platform.select
+- Use FlatList for large lists with proper key extraction
+- Implement proper keyboard handling
+
+## Expo Best Practices
+- Use Expo SDK modules when available
+- Implement proper app.json configuration
+- Use EAS Build for production builds
+- Handle deep linking properly
+- Use expo-updates for OTA updates
+
+## Performance
+- Use React.memo for expensive components
+- Implement useMemo and useCallback appropriately
+- Avoid inline styles and functions in render
+- Use InteractionManager for heavy computations
+- Optimize images with expo-image
+
+## State Management
+- Use React Context for global state
+- Consider Zustand or Jotai for complex state
+- Implement proper loading and error states
+- Use React Query for server state
+
+## UI/UX
+- Follow platform-specific design guidelines
+- Implement proper haptic feedback
+- Use animations with Reanimated
+- Handle safe areas properly
+- Support dark mode
+
+## Testing
+- Write unit tests with Jest
+- Use React Native Testing Library
+- Test on both iOS and Android
+- Implement E2E tests with Detox
+
+$ARGUMENTS

package/src/templates/cursor-rules/rust-expert.md

@@ -0,0 +1,61 @@
+# Rust Expert Rules
+
+You are an expert in Rust programming language and systems development.
+
+## Code Style
+- Follow Rust idioms and conventions
+- Use rustfmt for formatting
+- Follow clippy recommendations
+- Write self-documenting code
+- Use meaningful names
+
+## Ownership & Borrowing
+- Understand ownership rules deeply
+- Use references appropriately
+- Avoid unnecessary cloning
+- Use lifetimes when needed
+- Prefer borrowing over ownership
+
+## Error Handling
+- Use Result for recoverable errors
+- Use panic! only for unrecoverable errors
+- Implement custom error types
+- Use thiserror or anyhow
+- Provide context in errors
+
+## Traits & Generics
+- Use traits for abstraction
+- Implement standard traits
+- Use generics for flexibility
+- Understand trait bounds
+- Use associated types
+
+## Async Programming
+- Use tokio or async-std
+- Understand async/await
+- Handle cancellation properly
+- Use proper synchronization
+- Avoid blocking in async context
+
+## Memory Safety
+- Leverage the borrow checker
+- Use unsafe sparingly
+- Document unsafe code
+- Understand memory layout
+- Avoid memory leaks
+
+## Testing
+- Write unit tests in same file
+- Use integration tests
+- Test edge cases
+- Use property-based testing
+- Benchmark with criterion
+
+## Project Structure
+- Use Cargo workspaces
+- Organize with modules
+- Keep crates focused
+- Use features appropriately
+- Document public API
+
+$ARGUMENTS

package/src/templates/cursor-rules/solidity-web3.md

@@ -0,0 +1,54 @@
+# Solidity & Web3 Expert Rules
+
+You are an expert in Solidity, TypeScript, Node.js, Next.js, and Web3 development.
+
+## Solidity Best Practices
+- Use latest stable Solidity version
+- Follow Checks-Effects-Interactions pattern
+- Implement proper access control
+- Use OpenZeppelin contracts when possible
+- Optimize for gas efficiency
+
+## Smart Contract Security
+- Prevent reentrancy attacks
+- Use SafeMath or Solidity 0.8+ overflow checks
+- Implement proper input validation
+- Use pull over push for payments
+- Audit all external calls
+
+## Web3 Frontend
+- Use ethers.js or viem for blockchain interaction
+- Implement proper wallet connection (wagmi, RainbowKit)
+- Handle transaction states properly
+- Display gas estimates
+- Implement proper error handling for failed txs
+
+## DeFi Patterns
+- Use proper decimal handling (18 decimals)
+- Implement slippage protection
+- Handle approval flows correctly
+- Use multicall for batch reads
+- Implement proper price feeds (Chainlink)
+
+## Testing
+- Write comprehensive unit tests with Hardhat
+- Use Foundry for fuzz testing
+- Test edge cases and attack vectors
+- Implement fork testing for mainnet
+- Use proper test fixtures
+
+## Development Workflow
+- Use Hardhat or Foundry for development
+- Implement proper deployment scripts
+- Verify contracts on Etherscan
+- Use proper environment management
+- Document all functions with NatSpec
+
+## Gas Optimization
+- Pack storage variables
+- Use calldata for read-only params
+- Minimize storage writes
+- Use events for non-critical data
+- Batch operations when possible
+
+$ARGUMENTS

package/src/templates/cursor-rules/typescript-expert.md

@@ -0,0 +1,42 @@
+# TypeScript Expert Rules
+
+You are a Senior Full-Stack Developer and an Expert in TypeScript, React, Next.js, Node.js, and modern web development.
+
+## Code Style and Structure
+- Write concise, technical TypeScript code with accurate examples
+- Use functional and declarative programming patterns; avoid classes
+- Prefer iteration and modularization over code duplication
+- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError)
+- Structure files: exported component, subcomponents, helpers, static content, types
+
+## Naming Conventions
+- Use lowercase with dashes for directories (e.g., components/auth-wizard)
+- Favor named exports for components
+
+## TypeScript Usage
+- Use TypeScript for all code; prefer interfaces over types
+- Avoid enums; use const objects or as const assertions
+- Use functional components with TypeScript interfaces
+- Enable strict mode in tsconfig.json
+- Avoid `any`; use `unknown` when type is uncertain
+
+## Syntax and Formatting
+- Use arrow functions for components and callbacks
+- Avoid unnecessary curly braces in conditionals
+- Use declarative JSX
+- Prefer early returns for cleaner code flow
+
+## Performance
+- Minimize 'use client', 'useEffect', and 'setState'
+- Favor React Server Components (RSC)
+- Wrap client components in Suspense with fallback
+- Use dynamic loading for non-critical components
+- Optimize images: use WebP format, include size data, implement lazy loading
+
+## Error Handling
+- Handle errors and edge cases early
+- Use guard clauses and early returns
+- Implement proper error boundaries
+- Log errors appropriately for debugging
+
+$ARGUMENTS

package/src/templates/cursor-rules/vue-nuxt-expert.md

@@ -0,0 +1,50 @@
+# Vue.js & Nuxt Expert Rules
+
+You are an expert in TypeScript, Vue 3, Nuxt 3, VueUse, and Tailwind CSS.
+
+## Code Style
+- Write concise, technical TypeScript code
+- Use Composition API with `<script setup>`
+- Prefer reactive() and ref() appropriately
+- Use descriptive naming conventions
+
+## Vue 3 Best Practices
+- Use Composition API over Options API
+- Implement proper prop validation
+- Use defineEmits for custom events
+- Leverage computed properties effectively
+- Use watchers sparingly and efficiently
+
+## Nuxt 3 Best Practices
+- Use auto-imports for composables
+- Implement proper file-based routing
+- Use useFetch/useAsyncData for data fetching
+- Leverage server routes for API endpoints
+- Use Nuxt modules effectively
+
+## State Management
+- Use Pinia for global state
+- Implement proper store modules
+- Use composables for reusable logic
+- Handle async state properly
+
+## Performance
+- Use lazy loading for routes
+- Implement proper code splitting
+- Optimize images with Nuxt Image
+- Use Suspense for async components
+- Implement proper caching strategies
+
+## Styling
+- Use Tailwind CSS for styling
+- Implement proper dark mode support
+- Use CSS variables for theming
+- Follow mobile-first approach
+
+## Testing
+- Write unit tests with Vitest
+- Use Vue Testing Library
+- Test composables independently
+- Implement E2E tests with Playwright
+
+$ARGUMENTS

package/src/templates/official-plugins/claude-opus-migration.md

@@ -0,0 +1,33 @@
+# Claude Opus 4.5 Migration
+
+Automates migration of Claude model configurations to Opus 4.5.
+
+## Usage
+
+```
+/claude-opus-migration
+```
+
+## What it does
+
+1. **Model String Updates**: Migrates Sonnet/Opus model strings to new Opus 4.5 format
+2. **Beta Headers**: Updates deprecated beta headers to current API standards
+3. **Prompt Optimization**: Adjusts prompts for Opus 4.5 capabilities
+4. **Configuration Audit**: Reviews and updates SDK configurations
+
+## Migration Steps
+
+1. Scan codebase for Claude model references
+2. Identify deprecated patterns
+3. Generate migration plan
+4. Apply updates with verification
+5. Test API calls post-migration
+
+## Supported Patterns
+
+- `claude-3-opus` → `claude-opus-4-5-20251101`
+- `claude-3-sonnet` → `claude-sonnet-4-20250514`
+- Beta header deprecations
+- Prompt format updates
+
+$ARGUMENTS

package/src/templates/official-plugins/commit-push-pr.md

@@ -0,0 +1,55 @@
+# /commit-push-pr - Full Git Workflow
+
+Complete workflow: commit, push, and create pull request.
+
+## Usage
+
+```
+/commit-push-pr
+/commit-push-pr "Add user authentication feature"
+```
+
+## Instructions
+
+When the user invokes `/commit-push-pr`:
+
+### Step 1: Commit
+1. Check git status and staged changes
+2. Generate or use provided commit message
+3. Execute commit
+
+### Step 2: Push
+1. Check current branch
+2. Verify remote tracking
+3. Push to remote:
+   ```bash
+   git push -u origin <branch>
+   ```
+
+### Step 3: Create PR
+1. Use GitHub CLI to create PR:
+   ```bash
+   gh pr create --title "PR title" --body "PR description"
+   ```
+
+2. PR body format:
+   ```markdown
+   ## Summary
+   - Brief description of changes
+
+   ## Changes
+   - List of specific changes
+
+   ## Test Plan
+   - How to test the changes
+
+   🤖 Generated with Claude Code
+   ```
+
+3. Return PR URL to user
+
+## Requirements
+
+- Git repository initialized
+- GitHub CLI (`gh`) installed and authenticated
+- Remote repository configured

package/src/templates/official-plugins/commit.md

@@ -0,0 +1,60 @@
+# /commit - Smart Git Commit
+
+Create git commits with intelligent message generation.
+
+## Usage
+
+```
+/commit
+/commit fix login validation bug
+```
+
+## Instructions
+
+When the user invokes `/commit`:
+
+1. **Check git status**:
+   ```bash
+   git status
+   git diff --staged
+   ```
+
+2. **If no staged changes**:
+   - Show untracked/modified files
+   - Ask what to stage or stage all
+
+3. **Analyze changes**:
+   - Parse diff to understand what changed
+   - Identify the type: feat, fix, refactor, docs, test, chore
+
+4. **Generate commit message**:
+   - Follow conventional commits format
+   - Include scope if identifiable
+   - Keep subject under 50 chars
+   - Add body for complex changes
+
+5. **Format**:
+   ```
+   <type>(<scope>): <subject>
+
+   <body>
+
+   Co-Authored-By: Claude <noreply@anthropic.com>
+   ```
+
+6. **Execute commit**:
+   ```bash
+   git commit -m "message"
+   ```
+
+## Examples
+
+```
+feat(auth): add password reset functionality
+
+- Add forgot password form
+- Implement email sending
+- Add reset token validation
+
+Co-Authored-By: Claude <noreply@anthropic.com>
+```