@avisek_yorkie/cursor-rules 1.0.0

package/.cursorrules

@@ -0,0 +1,153 @@
+# Cursor Rules - Generic Tech Stack
+
+This file contains comprehensive coding rules that apply to any technology stack. These rules are designed to ensure code quality, maintainability, and consistency across all projects.
+
+## How to Use These Rules
+
+1. Copy this `.cursorrules` file to your project root
+2. Copy the rule files from the `rules/` folder (code-quality.mdc, documentation.mdc, naming-conventions.mdc) to your project root
+3. Cursor will automatically apply these rules when assisting with code
+
+## Rule Categories
+
+### 1. Code Quality (rules/code-quality.mdc)
+- Clean code standards
+- Error handling
+- Security best practices
+- Performance considerations
+- Code complexity management
+- Testing requirements
+
+### 2. Documentation (rules/documentation.mdc)
+- Code documentation standards
+- README requirements
+- API documentation
+- Architecture documentation
+- Inline comments guidelines
+
+### 3. Naming Conventions (rules/naming-conventions.mdc)
+- Variable and function naming
+- Class and type naming
+- File and directory naming
+- Language-specific conventions
+- Database and API naming
+
+## Core Principles
+
+### Code Quality
+- Write self-documenting code
+- Keep functions small and focused (20-30 lines ideal)
+- Handle errors explicitly
+- Validate all inputs
+- Follow security best practices
+- Maintain low complexity
+- Write comprehensive tests
+
+### Documentation
+- Document all public APIs
+- Keep README files comprehensive and up-to-date
+- Use appropriate documentation tools
+- Include code examples
+- Maintain changelogs
+
+### Naming
+- Use descriptive names that reveal intent
+- Follow language-specific conventions
+- Be consistent throughout the codebase
+- Avoid abbreviations and generic names
+- Use appropriate prefixes for booleans
+
+## Language-Specific Guidelines
+
+### JavaScript/TypeScript
+- Use `const` over `let`, avoid `var`
+- Use `===` instead of `==`
+- Prefer async/await over promise chains
+- Use arrow functions for callbacks
+- Follow camelCase for variables/functions
+- Use PascalCase for classes/interfaces
+
+### Python
+- Follow PEP 8 style guide
+- Use snake_case for variables/functions
+- Use PascalCase for classes
+- Use type hints where applicable
+- Follow the Zen of Python
+
+### Java
+- Follow Java naming conventions
+- Use camelCase for variables/methods
+- Use PascalCase for classes
+- Handle checked exceptions appropriately
+- Prefer composition over inheritance
+
+### Go
+- Follow Go naming conventions
+- Handle all errors explicitly
+- Use interfaces for abstraction
+- Keep functions small and focused
+- Export only what's necessary
+
+## Code Review Checklist
+
+Before submitting code, ensure:
+- [ ] Code follows all naming conventions
+- [ ] All public APIs are documented
+- [ ] Error handling is appropriate
+- [ ] Input validation is present
+- [ ] No security vulnerabilities
+- [ ] No hardcoded values
+- [ ] Functions are small and focused
+- [ ] Tests are included and passing
+- [ ] No unused imports or dead code
+- [ ] README is updated if needed
+
+## Quick Reference
+
+### Function/Method Guidelines
+- Maximum length: 50 lines (ideally 20-30)
+- Single responsibility
+- Clear, descriptive names
+- Proper error handling
+- Input validation
+
+### Variable Naming
+- Descriptive nouns or noun phrases
+- Avoid abbreviations
+- Use appropriate prefixes for booleans (`is`, `has`, `can`)
+- Be specific, not generic
+
+### Documentation
+- Document all public APIs
+- Include parameter and return types
+- Provide usage examples
+- Keep documentation up-to-date
+
+### Security
+- Never hardcode secrets
+- Validate and sanitize inputs
+- Use parameterized queries
+- Keep dependencies updated
+
+## Integration with Projects
+
+To use these rules in a specific project:
+
+1. **Copy the rules**: Copy `.cursorrules` and the `.mdc` files from `rules/` to your project root
+2. **Customize if needed**: Add project-specific rules while maintaining these core principles
+3. **Team alignment**: Ensure your team is aware of and follows these rules
+4. **Code reviews**: Use the checklists during code reviews
+5. **CI/CD**: Consider adding linting rules that enforce these standards
+
+## Maintenance
+
+- Review and update rules periodically
+- Add language-specific rules as needed
+- Keep rules generic and applicable across projects
+- Remove outdated or conflicting rules
+- Document any project-specific exceptions
+
+---
+
+**Note**: These rules are designed to be generic and applicable to any technology stack. Customize them for your specific project needs while maintaining the core principles.
+

package/README.md

@@ -0,0 +1,291 @@
+# Cursor Rules - Generic Tech Stack
+
+This directory contains comprehensive cursor rules designed to work with any technology stack. These rules help maintain code quality, consistency, and best practices across all your projects.
+
+## 📁 Directory Structure
+
+```
+cursor-rules/
+├── rules/
+│  ├── code-quality.mdc      # Code quality standards and best practices
+│  ├── documentation.mdc    # Documentation standards and guidelines
+│  ├── naming-conventions.mdc # Naming conventions (JS/TS)
+├── .cursorrules            # Main cursor rules file (copy to project root)
+├── README.md
+└── SETUP.md
+```
+
+## 🚀 Quick Start
+
+### Step 1: Install (optional)
+
+```bash
+npm install @avisek_yorkie/cursor-rules
+```
+
+### Step 2: Copy Rules to Your Project
+
+Copy the `.cursorrules` file and all rule files from `rules/` to your project root:
+
+```bash
+# From your project root (after npm install @avisek_yorkie/cursor-rules)
+cp node_modules/@avisek_yorkie/cursor-rules/.cursorrules .
+cp node_modules/@avisek_yorkie/cursor-rules/rules/*.mdc .
+```
+
+Or from a local clone:
+```bash
+cp /path/to/cursor-rules/.cursorrules .
+cp /path/to/cursor-rules/rules/*.mdc .
+```
+
+Manual copy:
+- `.cursorrules` → Your project root
+- `rules/code-quality.mdc` → Your project root (as `code-quality.mdc`)
+- `rules/documentation.mdc` → Your project root (as `documentation.mdc`)
+- `rules/naming-conventions.mdc` → Your project root (as `naming-conventions.mdc`)
+
+### Step 3: Verify Integration
+
+Cursor will automatically detect and use the `.cursorrules` file in your project root. The rules will be applied when:
+- Writing new code
+- Refactoring existing code
+- Code completion suggestions
+- Code review assistance
+
+### Step 4: Customize (Optional)
+
+You can customize these rules for your specific project by:
+- Adding project-specific rules to `.cursorrules`
+- Modifying the `.mdc` files to include team-specific conventions
+- Adding language-specific rules for your tech stack
+
+## 📚 Rule Files Overview
+
+### 1. Code Quality (`rules/code-quality.mdc`)
+
+Covers:
+- ✅ Clean code standards
+- ✅ Error handling best practices
+- ✅ Security guidelines
+- ✅ Performance considerations
+- ✅ Code complexity management
+- ✅ Testing requirements
+- ✅ Language-specific guidelines
+
+**Key Principles:**
+- Functions should be 20-30 lines (max 50)
+- Always handle errors explicitly
+- Validate all inputs
+- Never hardcode secrets
+- Keep cyclomatic complexity low
+
+### 2. Documentation (`rules/documentation.mdc`)
+
+Covers:
+- ✅ Function/method documentation standards
+- ✅ README file requirements
+- ✅ API documentation guidelines
+- ✅ Architecture documentation
+- ✅ Inline comments best practices
+- ✅ Documentation tools and generators
+
+**Key Principles:**
+- Document all public APIs
+- Write self-documenting code
+- Include code examples
+- Keep documentation up-to-date
+- Use appropriate documentation tools
+
+### 3. Naming Conventions (`rules/naming-conventions.mdc`)
+
+Covers:
+- ✅ Variable and function naming
+- ✅ Class and type naming
+- ✅ File and directory naming
+- ✅ TypeScript/JavaScript conventions
+- ✅ Database naming
+- ✅ API endpoint naming
+- ✅ Configuration naming
+
+**Key Principles:**
+- Use descriptive names that reveal intent
+- Follow language-specific conventions
+- Be consistent throughout codebase
+- Avoid abbreviations and generic names
+- Use appropriate prefixes for booleans
+
+## 🎯 Usage Examples
+
+### Example 1: Starting a New Project
+
+```bash
+# Create new project
+mkdir my-new-project
+cd my-new-project
+
+# Copy cursor rules
+cp node_modules/@avisek_yorkie/cursor-rules/.cursorrules .
+cp node_modules/@avisek_yorkie/cursor-rules/rules/*.mdc .
+
+# Initialize your project (npm, pip, etc.)
+npm init -y  # or your package manager
+
+# Start coding - Cursor will apply the rules automatically!
+```
+
+### Example 2: Adding Rules to Existing Project
+
+```bash
+# Navigate to your project
+cd /path/to/your/project
+
+# Copy rules (backup existing .cursorrules if present)
+cp node_modules/@avisek_yorkie/cursor-rules/.cursorrules .
+cp node_modules/@avisek_yorkie/cursor-rules/rules/*.mdc .
+
+# Review and merge with existing rules if needed
+```
+
+### Example 3: Publishing NPM Package
+
+When publishing an npm package, these rules ensure:
+- ✅ Proper documentation in README
+- ✅ Consistent naming conventions
+- ✅ High code quality
+- ✅ Proper error handling
+- ✅ Security best practices
+
+```bash
+# Your package will follow all rules automatically
+npm publish
+```
+
+## 🔧 Customization Guide
+
+### Adding Project-Specific Rules
+
+Edit `.cursorrules` to add project-specific rules:
+
+```markdown
+# Project-Specific Rules
+
+## React/React Native Specific
+- Always use functional components
+- Add testID to interactive components
+- Use hooks for state management
+
+## Your Custom Rules
+- Follow our internal API conventions
+- Use our design system components
+```
+
+### Language-Specific Customization
+
+Edit the appropriate `.mdc` file to add language-specific rules:
+
+```markdown
+# In rules/code-quality.mdc
+
+### Your Language
+- Follow your language style guide
+- Use your preferred linter configuration
+- Follow your team's conventions
+```
+
+## 📋 Code Review Checklist
+
+Use this checklist during code reviews:
+
+### Code Quality
+- [ ] Functions are small and focused (20-30 lines)
+- [ ] All errors are handled appropriately
+- [ ] Input validation is present
+- [ ] No security vulnerabilities
+- [ ] No hardcoded secrets or values
+- [ ] Code complexity is manageable
+
+### Documentation
+- [ ] All public APIs are documented
+- [ ] README is complete and up-to-date
+- [ ] Code examples are included where needed
+- [ ] Comments explain "why" not "what"
+
+### Naming
+- [ ] Names are descriptive and reveal intent
+- [ ] Follows language-specific conventions
+- [ ] Consistent throughout codebase
+- [ ] Boolean names use appropriate prefixes
+- [ ] No abbreviations or generic names
+
+## 🌐 Supported Stack
+
+These rules target **JavaScript/TypeScript** (Node.js, React, React Native, Vue, Angular, etc.). Core principles are universal; conventions are JS/TS-specific.
+
+## 🔄 Maintenance
+
+### Updating Rules
+
+1. Edit the `.mdc` files as needed
+2. Update `.cursorrules` if structure changes
+3. Test rules in a sample project
+4. Document any breaking changes
+
+### Version Control
+
+Consider versioning your rules:
+- Tag releases: `v1.0.0`, `v1.1.0`, etc.
+- Document changes in CHANGELOG
+- Keep rules in sync across projects
+
+## 📖 Best Practices
+
+1. **Start Early**: Add rules at project inception
+2. **Team Alignment**: Ensure all team members use the same rules
+3. **Regular Review**: Review and update rules quarterly
+4. **Consistency**: Use the same rules across all projects
+5. **Documentation**: Document any project-specific exceptions
+
+## 🐛 Troubleshooting
+
+### Rules Not Being Applied
+
+1. Check that `.cursorrules` is in project root
+2. Verify `.mdc` files are in project root (copied from `rules/`)
+3. Restart Cursor if needed
+4. Check for syntax errors in rule files
+
+### Conflicts with Existing Rules
+
+1. Review existing `.cursorrules` in your project
+2. Merge rules carefully
+3. Test in a sample file
+4. Document any conflicts resolved
+
+## 📝 License
+
+These rules are provided as-is for use in your projects. Customize as needed for your team and organization.
+
+## 🤝 Contributing
+
+To improve these generic rules:
+
+1. Test changes in multiple projects
+2. Ensure rules remain generic (not project-specific)
+3. Document language-specific additions
+4. Keep examples clear and practical
+
+## 📞 Support
+
+For questions or issues:
+- Review the rule files for detailed guidelines
+- Check language-specific sections
+- Customize rules for your needs
+- Consult your team's coding standards
+
+---
+
+**Happy Coding! 🚀**
+
+These rules will help you maintain high-quality, consistent code across all your projects, regardless of the technology stack.
+

package/SETUP.md

@@ -0,0 +1,122 @@
+# Quick Setup Guide
+
+## 🎯 Step-by-Step Setup for Your NPM Package (or Any Project)
+
+### Step 0: Get the Rules (choose one)
+
+**From npm:**
+```bash
+npm install @avisek_yorkie/cursor-rules
+```
+
+**Or clone the repo** and use the path to your local `cursor-rules` folder in the steps below.
+
+### Step 1: Navigate to Your Project
+```bash
+cd /path/to/your/project
+```
+
+### Step 2: Copy Cursor Rules
+
+**From the package (after `npm install @avisek_yorkie/cursor-rules`):**
+```bash
+cp node_modules/@avisek_yorkie/cursor-rules/.cursorrules .
+cp node_modules/@avisek_yorkie/cursor-rules/rules/*.mdc .
+```
+
+**From a local clone:**
+```bash
+# Copy main file and all rule files to your project root
+cp /path/to/cursor-rules/.cursorrules .
+cp /path/to/cursor-rules/rules/*.mdc .
+```
+
+### Step 3: Verify Files Are in Place
+```bash
+ls -la .cursorrules *.mdc
+```
+
+You should see:
+- `.cursorrules`
+- `code-quality.mdc`
+- `documentation.mdc`
+- `naming-conventions.mdc`
+
+### Step 4: Restart Cursor (Optional)
+Close and reopen Cursor to ensure rules are loaded.
+
+### Step 5: Test the Rules
+Create a test file and ask Cursor to help you write code. The rules will be automatically applied!
+
+## 📦 For NPM Package Publishing
+
+### Before Publishing Checklist
+
+1. **Code Quality**
+   - [ ] All functions are under 50 lines
+   - [ ] Error handling is implemented
+   - [ ] Input validation is present
+   - [ ] No hardcoded secrets
+
+2. **Documentation**
+   - [ ] README.md is complete
+   - [ ] All public APIs are documented
+   - [ ] Code examples are included
+   - [ ] Installation instructions are clear
+
+3. **Naming**
+   - [ ] All names follow conventions
+   - [ ] Consistent naming throughout
+   - [ ] No abbreviations or generic names
+
+### Publishing Command
+```bash
+npm publish
+```
+
+## 📤 Publishing This Package to npm
+
+To publish **this** cursor-rules package to npm:
+
+1. **Create an npm account** (if you don’t have one): [https://www.npmjs.com/signup](https://www.npmjs.com/signup)
+
+2. **Log in from the terminal:**
+   ```bash
+   npm login
+   ```
+   npm will print a **login URL**. Open it in your browser, sign in (or create an account), then return to the terminal—you’ll be logged in. Use a one-time password in the browser if you have 2FA enabled.
+
+4. **From this project root, publish:**
+   ```bash
+   cd /path/to/cursor-rules
+   npm publish
+   ```
+   The package is scoped as `@avisek_yorkie/cursor-rules` and `publishConfig.access` is set to `"public"`, so it will be published as a public package.
+
+5. **After publish**, anyone can install with:
+   ```bash
+   npm install @avisek_yorkie/cursor-rules
+   ```
+
+## 🔄 Updating Rules
+
+If you update the rules (or upgrade the package), sync them to your project:
+
+```bash
+# From your project root (when using npm package)
+cp node_modules/@avisek_yorkie/cursor-rules/.cursorrules .
+cp node_modules/@avisek_yorkie/cursor-rules/rules/*.mdc .
+```
+
+## ✅ Verification
+
+To verify rules are working:
+1. Ask Cursor to write a function
+2. Check that it follows naming conventions
+3. Verify error handling is included
+4. Confirm documentation is added
+
+---
+
+**That's it!** Your project now has comprehensive cursor rules that will help maintain code quality across any tech stack.
+

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@avisek_yorkie/cursor-rules",
+  "version": "1.0.0",
+  "description": "Cursor AI rules for code quality, documentation, and naming conventions (JS/TS)",
+  "keywords": [
+    "cursor",
+    "cursor-rules",
+    "code-quality",
+    "documentation",
+    "naming-conventions",
+    "javascript",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avisek41/cursor-rules-js-ts.git"
+  },
+  "files": [
+    "rules",
+    "README.md",
+    "SETUP.md",
+    ".cursorrules"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}