+
+{title}
+{description}
+ +
+
+ `,
+ changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class UserCardComponent {
+ @Input() user!: User;
+ @Output() onEdit = new EventEmitter{{ user.name }}
+{{ user.email }}
+ + +Loading...
;
+ }
+
+ return (
+
+
+ );
+}
+
+const root = createRoot(document.getElementById('root')!);
+root.render(Electron App
+Platform: {window.electron.system.platform}
+Architecture: {window.electron.system.arch}
+ +Welcome to our site
+Lorem ipsum dolor sit amet
+ +Feature 1
+Description
+
+ 
+
+
+
+
+
++ Card Title +
++ Card description with responsive text that wraps nicely. +
+ +
+
+
+
+ 5 min read
+
+
+
+
+
+ {% for item in items %}
+
+```
+
+// Best Practices:
+1. Use semantic HTML
+2. Follow REST principles
+3. Implement proper validation
+4. Handle errors gracefully
+5. Show loading states
+6. Use proper targeting
+7. Optimize performance
+8. Maintain accessibility
+9. Follow progressive enhancement
+10. Document endpoints
+
+// Security Considerations:
+1. Implement CSRF protection
+2. Validate all inputs
+3. Sanitize HTML responses
+4. Use proper headers
+5. Handle errors securely
+6. Implement rate limiting
+7. Use HTTPS
+8. Follow SOP/CORS
+9. Protect against XSS
+10. Audit dependencies
diff --git a/rules/htmx-django-cursorrules-prompt-file/.cursorrules b/rules/htmx-django-cursorrules-prompt-file/.cursorrules
index eed49f6..ab0de55 100644
--- a/rules/htmx-django-cursorrules-prompt-file/.cursorrules
+++ b/rules/htmx-django-cursorrules-prompt-file/.cursorrules
@@ -1,39 +1,222 @@
-// HTMX with Django .cursorrules
-
-// HTMX and Django best practices
-const htmxDjangoBestPractices = [
- "Use Django's template system with HTMX attributes",
- "Implement Django forms for form handling",
- "Utilize Django's URL routing system",
- "Use Django's class-based views for HTMX responses",
- "Implement Django ORM for database operations",
- "Utilize Django's middleware for request/response processing",
-];
-
-// Folder structure
-const folderStructure = `
+// HTMX with Django Development Guidelines
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+Modern Django applications with HTMX integration featuring:
+- Server-side rendered templates
+- Dynamic UI updates without JavaScript
+- Django form integration
+- Real-time interactions
+- Database-driven updates
+- Infinite scrolling
+- Modal dialogs
+- Live search
+
+// Project Structure
project_name/
- app_name/
- templates/
- static/
- css/
- js/
- models.py
- views.py
- urls.py
- project_name/
- settings.py
- urls.py
-manage.py
-`;
-
-// Additional instructions
-const additionalInstructions = `
-1. Use Django's template tags with HTMX attributes
-2. Implement proper CSRF protection with Django's built-in features
-3. Utilize Django's HttpResponse for HTMX-specific responses
-4. Use Django's form validation for HTMX requests
-5. Implement proper error handling and logging
-6. Follow Django's best practices for project structure
-7. Use Django's staticfiles app for managing static assets
-`;
+ app_name/ # Django app
+ templates/ # HTML templates
+ base.html # Base template
+ components/ # Reusable components
+ form.html # Form component
+ modal.html # Modal component
+ pages/ # Page templates
+ index.html # Home page
+ about.html # About page
+ static/ # Static assets
+ css/ # Stylesheets
+ main.css # Main styles
+ js/ # JavaScript
+ htmx.min.js # HTMX library
+ models.py # Database models
+ views.py # View controllers
+ urls.py # URL routing
+ forms.py # Form definitions
+ tests/ # Test files
+ test_views.py # View tests
+ test_models.py # Model tests
+ project_name/ # Project configuration
+ settings.py # Django settings
+ urls.py # Root URL config
+ manage.py # Django CLI
+
+// Development Guidelines
+1. Django Integration:
+ - Use class-based views
+ - Implement Django forms
+ - Follow URL patterns
+ - Use template inheritance
+ - Handle CSRF properly
+ - Follow Django conventions
+
+2. HTMX Patterns:
+ - Use template tags
+ - Return partial HTML
+ - Handle form validation
+ - Implement error responses
+ - Show loading states
+ - Use proper targeting
+
+3. Database Patterns:
+ - Use Django ORM
+ - Optimize queries
+ - Handle transactions
+ - Implement caching
+ - Follow migrations
+ - Maintain consistency
+
+// Dependencies
+Core:
+- django: "^4.2.0"
+- htmx: "^1.9.0"
+- python: "^3.8"
+- psycopg2: "^2.9.0"
+
+Optional:
+- django-debug-toolbar: "^4.0.0"
+- django-htmx: "^1.0.0"
+- django-crispy-forms: "^2.0.0"
+- django-compressor: "^4.0.0"
+
+// Code Examples:
+
+1. Django View Pattern:
+```python
+from django.views.generic import ListView
+from django.http import HttpResponse
+from django.template.loader import render_to_string
+from .models import Item
+
+class ItemListView(ListView):
+ model = Item
+ template_name = 'items/list.html'
+ context_object_name = 'items'
+ paginate_by = 10
+
+ def get(self, request, *args, **kwargs):
+ # Check if this is an HTMX request
+ if request.htmx:
+ # Get queryset
+ self.object_list = self.get_queryset()
+ context = self.get_context_data()
+
+ # Render only the items partial
+ html = render_to_string(
+ 'items/partials/item_list.html',
+ context,
+ request=request
+ )
+ return HttpResponse(html)
+
+ # Regular request - render full template
+ return super().get(request, *args, **kwargs)
+```
+
+2. Django Template Pattern:
+```html
+{% extends "base.html" %}
+{% load static %}
+
+{% block content %}
+
+
+ {% endfor %}
+
+
+ {{ item.title }}
+{{ item.description }}
+ + +
+ Loading more items...
+
+
+
+ {% include "items/partials/item_list.html" %}
+
+
+
+
+
+{% endblock %}
+```
+
+3. Django Form Pattern:
+```python
+from django import forms
+from django.core.exceptions import ValidationError
+from .models import Item
+
+class ItemForm(forms.ModelForm):
+ class Meta:
+ model = Item
+ fields = ['title', 'description']
+
+ def clean_title(self):
+ title = self.cleaned_data['title']
+ if Item.objects.filter(title=title).exists():
+ raise ValidationError('An item with this title already exists.')
+ return title
+
+ def save(self, commit=True):
+ instance = super().save(commit=False)
+ if commit:
+ instance.save()
+ # Return HTML for new item
+ html = render_to_string(
+ 'items/partials/item.html',
+ {'item': instance}
+ )
+ return html
+ return instance
+
+# View using the form
+from django.views.generic.edit import CreateView
+
+class ItemCreateView(CreateView):
+ model = Item
+ form_class = ItemForm
+ template_name = 'items/create.html'
+
+ def form_valid(self, form):
+ # Save and get HTML response
+ html = form.save()
+ return HttpResponse(html)
+
+ def form_invalid(self, form):
+ return HttpResponse(
+ str(form.errors),
+ status=400
+ )
+```
+
+// Best Practices:
+1. Follow Django conventions
+2. Use class-based views
+3. Implement proper forms
+4. Handle CSRF correctly
+5. Optimize database queries
+6. Use template inheritance
+7. Handle errors gracefully
+8. Write comprehensive tests
+9. Document view responses
+10. Follow URL naming
+
+// Security Considerations:
+1. Enable CSRF protection
+2. Validate form inputs
+3. Sanitize HTML output
+4. Use proper permissions
+5. Handle file uploads safely
+6. Implement rate limiting
+7. Use HTTPS
+8. Secure admin interface
+9. Audit dependencies
+10. Log security events
diff --git a/rules/htmx-flask-cursorrules-prompt-file/.cursorrules b/rules/htmx-flask-cursorrules-prompt-file/.cursorrules
index 3e19823..dff8550 100644
--- a/rules/htmx-flask-cursorrules-prompt-file/.cursorrules
+++ b/rules/htmx-flask-cursorrules-prompt-file/.cursorrules
@@ -1,36 +1,246 @@
-// HTMX with Flask .cursorrules
-
-// HTMX and Flask best practices
-const htmxFlaskBestPractices = [
- "Use Flask's render_template for server-side rendering",
- "Implement Flask-WTF for form handling",
- "Utilize Flask's url_for for generating URLs",
- "Use Flask's jsonify for JSON responses",
- "Implement Flask-SQLAlchemy for database operations",
- "Utilize Flask's Blueprint for modular applications",
-];
-
-// Folder structure
-const folderStructure = `
+// HTMX with Flask Development Guidelines
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+Modern Flask applications with HTMX integration featuring:
+- Server-side rendered templates
+- Dynamic UI updates without JavaScript
+- Flask form integration
+- Real-time interactions
+- Database-driven updates
+- Infinite scrolling
+- Modal dialogs
+- Live search
+
+// Project Structure
app/
- templates/
- static/
- css/
- js/
- models/
- routes/
- __init__.py
-config.py
-run.py
-`;
-
-// Additional instructions
-const additionalInstructions = `
-1. Use Jinja2 templating with HTMX attributes
-2. Implement proper CSRF protection with Flask-WTF
-3. Utilize Flask's request object for handling HTMX requests
-4. Use Flask-Migrate for database migrations
-5. Implement proper error handling and logging
-6. Follow Flask's application factory pattern
-7. Use environment variables for configuration
-`;
+ templates/ # HTML templates
+ base.html # Base template
+ components/ # Reusable components
+ form.html # Form component
+ modal.html # Modal component
+ pages/ # Page templates
+ index.html # Home page
+ about.html # About page
+ static/ # Static assets
+ css/ # Stylesheets
+ main.css # Main styles
+ js/ # JavaScript
+ htmx.min.js # HTMX library
+ models/ # Database models
+ __init__.py # Package init
+ user.py # User model
+ item.py # Item model
+ routes/ # Route handlers
+ __init__.py # Package init
+ main.py # Main routes
+ api.py # API routes
+ forms/ # Form definitions
+ __init__.py # Package init
+ user.py # User forms
+ item.py # Item forms
+ __init__.py # App factory
+config.py # Configuration
+run.py # Entry point
+
+// Development Guidelines
+1. Flask Integration:
+ - Use application factory
+ - Implement Flask-WTF forms
+ - Follow Blueprint patterns
+ - Use Jinja2 templates
+ - Handle CSRF properly
+ - Follow Flask conventions
+
+2. HTMX Patterns:
+ - Use template filters
+ - Return partial HTML
+ - Handle form validation
+ - Implement error responses
+ - Show loading states
+ - Use proper targeting
+
+3. Database Patterns:
+ - Use SQLAlchemy ORM
+ - Optimize queries
+ - Handle transactions
+ - Implement caching
+ - Follow migrations
+ - Maintain consistency
+
+// Dependencies
+Core:
+- flask: "^2.3.0"
+- htmx: "^1.9.0"
+- python: "^3.8"
+- flask-sqlalchemy: "^3.0.0"
+
+Optional:
+- flask-wtf: "^1.1.0"
+- flask-migrate: "^4.0.0"
+- flask-login: "^0.6.0"
+- flask-caching: "^2.0.0"
+
+// Code Examples:
+
+1. Flask Route Pattern:
+```python
+from flask import Blueprint, render_template, request, jsonify
+from .models import Item
+from .forms import ItemForm
+
+bp = Blueprint('items', __name__)
+
+@bp.route('/items', methods=['GET'])
+def list_items():
+ page = request.args.get('page', 1, type=int)
+ items = Item.query.paginate(page=page, per_page=10)
+
+ # Check if HTMX request
+ if request.headers.get('HX-Request'):
+ return render_template(
+ 'components/item_list.html',
+ items=items
+ )
+
+ # Regular request - full page
+ return render_template(
+ 'pages/items.html',
+ items=items
+ )
+
+@bp.route('/items/create', methods=['POST'])
+def create_item():
+ form = ItemForm()
+
+ if form.validate_on_submit():
+ item = Item(
+ title=form.title.data,
+ description=form.description.data
+ )
+ db.session.add(item)
+ db.session.commit()
+
+ # Return new item HTML
+ return render_template(
+ 'components/item.html',
+ item=item
+ )
+
+ # Return form errors
+ return jsonify(form.errors), 400
+```
+
+2. Flask Template Pattern:
+```html
+{% extends "base.html" %}
+{% block content %}
+
+
+
+ Loading more items...
+
+
+
+ {% include "components/item_list.html" %}
+
+
+
+
+
+
+{% endblock %}
+```
+
+3. Flask Form Pattern:
+```python
+from flask_wtf import FlaskForm
+from wtforms import StringField, TextAreaField
+from wtforms.validators import DataRequired, Length
+
+class ItemForm(FlaskForm):
+ title = StringField(
+ 'Title',
+ validators=[
+ DataRequired(),
+ Length(min=3, max=100)
+ ]
+ )
+
+ description = TextAreaField(
+ 'Description',
+ validators=[
+ DataRequired(),
+ Length(min=10, max=500)
+ ]
+ )
+
+ def validate_title(self, field):
+ # Check for unique title
+ if Item.query.filter_by(title=field.data).first():
+ raise ValidationError('Title must be unique')
+
+# Custom response handler
+def handle_form_errors(form):
+ """Convert WTForms errors to HTMX-friendly response."""
+ errors = {}
+ for field, messages in form.errors.items():
+ errors[f"{field}-error"] = {
+ "innerHTML": " ".join(messages)
+ }
+
+ response = jsonify({
+ "errors": errors
+ })
+ response.status_code = 400
+ return response
+```
+
+// Best Practices:
+1. Follow Flask conventions
+2. Use Blueprints
+3. Implement proper forms
+4. Handle CSRF correctly
+5. Optimize database queries
+6. Use template inheritance
+7. Handle errors gracefully
+8. Write comprehensive tests
+9. Document endpoints
+10. Follow URL naming
+
+// Security Considerations:
+1. Enable CSRF protection
+2. Validate form inputs
+3. Sanitize HTML output
+4. Use proper permissions
+5. Handle file uploads safely
+6. Implement rate limiting
+7. Use HTTPS
+8. Secure configuration
+9. Audit dependencies
+10. Log security events
diff --git a/rules/htmx-go-basic-cursorrules-prompt-file/.cursorrules b/rules/htmx-go-basic-cursorrules-prompt-file/.cursorrules
index d5efd2b..14a936a 100644
--- a/rules/htmx-go-basic-cursorrules-prompt-file/.cursorrules
+++ b/rules/htmx-go-basic-cursorrules-prompt-file/.cursorrules
@@ -1,37 +1,321 @@
-// HTMX with Go (Basic Setup) .cursorrules
-
-// HTMX and Go best practices
-const htmxGoBestPractices = [
- "Use html/template for server-side rendering",
- "Implement http.HandlerFunc for handling HTMX requests",
- "Utilize gorilla/mux for routing if needed",
- "Use encoding/json for JSON responses",
- "Implement proper error handling and logging",
- "Utilize context for request cancellation and timeouts",
-];
-
-// Folder structure
-const folderStructure = `
+// HTMX with Go Development Guidelines
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+Modern Go web applications with HTMX integration featuring:
+- Server-side rendered templates
+- Dynamic UI updates without JavaScript
+- Efficient HTTP handlers
+- Real-time interactions
+- RESTful endpoints
+- Infinite scrolling
+- Modal dialogs
+- Live search
+
+// Project Structure
cmd/
- main.go
-internal/
- handlers/
- models/
- templates/
-static/
- css/
- js/
-go.mod
-go.sum
-`;
-
-// Additional instructions
-const additionalInstructions = `
-1. Use semantic HTML5 elements with HTMX attributes
-2. Implement proper CSRF protection
-3. Utilize HTMX extensions when needed
-4. Use hx-boost for full page navigation
-5. Follow Go's idiomatic error handling
-6. Implement graceful shutdown for the server
-7. Use Go modules for dependency management
-`;
+ server/ # Application entrypoint
+ main.go # Server initialization
+internal/ # Private application code
+ handlers/ # HTTP handlers
+ items.go # Item handlers
+ users.go # User handlers
+ templates.go # Template helpers
+ models/ # Data models
+ item.go # Item model
+ user.go # User model
+ middleware/ # HTTP middleware
+ auth.go # Authentication
+ logging.go # Request logging
+ csrf.go # CSRF protection
+ templates/ # HTML templates
+ base.html # Base template
+ components/ # Reusable components
+ form.html # Form component
+ modal.html # Modal component
+ pages/ # Page templates
+ index.html # Home page
+ about.html # About page
+static/ # Static assets
+ css/ # Stylesheets
+ main.css # Main styles
+ js/ # JavaScript
+ htmx.min.js # HTMX library
+go.mod # Module definition
+go.sum # Module checksums
+
+// Development Guidelines
+1. Go Integration:
+ - Use http.Handler interface
+ - Implement middleware
+ - Follow idiomatic Go
+ - Use html/template
+ - Handle errors properly
+ - Follow Go conventions
+
+2. HTMX Patterns:
+ - Return partial HTML
+ - Handle form submissions
+ - Implement validation
+ - Show loading states
+ - Use proper targeting
+ - Follow REST principles
+
+3. Performance Patterns:
+ - Use goroutines safely
+ - Implement caching
+ - Handle timeouts
+ - Optimize templates
+ - Use connection pools
+ - Monitor resources
+
+// Dependencies
+Core:
+- go: ">=1.22"
+- htmx: "^1.9.0"
+- chi: "^5.0.0"
+- sqlx: "^1.3.0"
+
+Optional:
+- gorilla/csrf: "^1.7.0"
+- zap: "^1.24.0"
+- validator: "^10.0.0"
+- pgx: "^5.0.0"
+
+// Code Examples:
+
+1. HTTP Handler Pattern:
+```go
+package handlers
+
+import (
+ "html/template"
+ "net/http"
+ "strconv"
+)
+
+type ItemHandler struct {
+ tmpl *template.Template
+ db *sqlx.DB
+}
+
+func NewItemHandler(tmpl *template.Template, db *sqlx.DB) *ItemHandler {
+ return &ItemHandler{
+ tmpl: tmpl,
+ db: db,
+ }
+}
+
+func (h *ItemHandler) List(w http.ResponseWriter, r *http.Request) {
+ // Parse pagination params
+ page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+ if page < 1 {
+ page = 1
+ }
+
+ // Fetch items
+ items, err := h.db.QueryContext(r.Context(), `
+ SELECT id, title, description
+ FROM items
+ ORDER BY created_at DESC
+ LIMIT 10 OFFSET $1
+ `, (page-1)*10)
+ if err != nil {
+ http.Error(w, "Failed to fetch items", http.StatusInternalServerError)
+ return
+ }
+ defer items.Close()
+
+ // Check if HTMX request
+ if r.Header.Get("HX-Request") == "true" {
+ h.tmpl.ExecuteTemplate(w, "components/item_list.html", items)
+ return
+ }
+
+ // Regular request - full page
+ h.tmpl.ExecuteTemplate(w, "pages/items.html", items)
+}
+
+func (h *ItemHandler) Create(w http.ResponseWriter, r *http.Request) {
+ // Parse form
+ if err := r.ParseForm(); err != nil {
+ http.Error(w, "Invalid form data", http.StatusBadRequest)
+ return
+ }
+
+ // Validate input
+ title := r.Form.Get("title")
+ description := r.Form.Get("description")
+ if title == "" || description == "" {
+ http.Error(w, "Missing required fields", http.StatusBadRequest)
+ return
+ }
+
+ // Create item
+ var id int64
+ err := h.db.QueryRowContext(r.Context(), `
+ INSERT INTO items (title, description)
+ VALUES ($1, $2)
+ RETURNING id
+ `, title, description).Scan(&id)
+ if err != nil {
+ http.Error(w, "Failed to create item", http.StatusInternalServerError)
+ return
+ }
+
+ // Fetch new item
+ item := struct {
+ ID int64
+ Title string
+ Description string
+ }{}
+ err = h.db.GetContext(r.Context(), &item, `
+ SELECT id, title, description
+ FROM items WHERE id = $1
+ `, id)
+ if err != nil {
+ http.Error(w, "Failed to fetch item", http.StatusInternalServerError)
+ return
+ }
+
+ // Return new item HTML
+ h.tmpl.ExecuteTemplate(w, "components/item.html", item)
+}
+```
+
+2. Template Pattern:
+```html
+{{/* base.html */}}
+
+
+
+
+
+ Loading more items...
+
+
+
+ {{range .Items}}
+
+{{end}}
+
+{{/* components/item_form.html */}}
+{{define "item-form"}}
+
+{{end}}
+```
+
+3. Router Pattern:
+```go
+package main
+
+import (
+ "net/http"
+
+ "github.com/go-chi/chi/v5"
+ "github.com/go-chi/chi/v5/middleware"
+)
+
+func setupRouter(h *handlers.ItemHandler) http.Handler {
+ r := chi.NewRouter()
+
+ // Middleware
+ r.Use(middleware.Logger)
+ r.Use(middleware.Recoverer)
+ r.Use(middleware.RealIP)
+ r.Use(middleware.RequestID)
+ r.Use(middleware.Timeout(60 * time.Second))
+
+ // Routes
+ r.Get("/", h.List)
+ r.Route("/items", func(r chi.Router) {
+ r.Get("/", h.List)
+ r.Post("/", h.Create)
+ r.Route("/{id}", func(r chi.Router) {
+ r.Get("/", h.Get)
+ r.Put("/", h.Update)
+ r.Delete("/", h.Delete)
+ })
+ })
+
+ // Static files
+ fileServer := http.FileServer(http.Dir("static"))
+ r.Handle("/static/*", http.StripPrefix("/static/", fileServer))
+
+ return r
+}
+```
+
+// Best Practices:
+1. Follow Go idioms
+2. Use proper interfaces
+3. Handle errors gracefully
+4. Implement middleware
+5. Optimize performance
+6. Use prepared statements
+7. Validate inputs
+8. Write unit tests
+9. Document code
+10. Follow naming conventions
+
+// Security Considerations:
+1. Enable CSRF protection
+2. Validate all inputs
+3. Sanitize HTML output
+4. Use proper headers
+5. Handle file uploads safely
+6. Implement rate limiting
+7. Use HTTPS
+8. Secure cookies
+9. Audit dependencies
+10. Log security events
diff --git a/rules/htmx-go-fiber-cursorrules-prompt-file/.cursorrules b/rules/htmx-go-fiber-cursorrules-prompt-file/.cursorrules
index ba5bb2d..a3d8662 100644
--- a/rules/htmx-go-fiber-cursorrules-prompt-file/.cursorrules
+++ b/rules/htmx-go-fiber-cursorrules-prompt-file/.cursorrules
@@ -1,37 +1,317 @@
-// HTMX with Go and Fiber .cursorrules
-
-// HTMX, Go, and Fiber best practices
-const htmxGoFiberBestPractices = [
- "Use Fiber's HTML rendering for server-side templates",
- "Implement Fiber's routing system for HTMX requests",
- "Utilize Fiber's middleware for request processing",
- "Use Fiber's JSON methods for API responses",
- "Implement proper error handling with Fiber's error handling",
- "Utilize Fiber's static file serving for assets",
-];
-
-// Folder structure
-const folderStructure = `
+// HTMX with Go Fiber Development Guidelines
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+Modern Go web applications with HTMX and Fiber integration featuring:
+- High-performance server-side rendering
+- Dynamic UI updates without JavaScript
+- Fast HTTP routing with Fiber
+- Real-time interactions
+- RESTful endpoints
+- WebSocket support
+- Modal dialogs
+- Live search
+
+// Project Structure
cmd/
- main.go
-internal/
- handlers/
- models/
- templates/
-static/
- css/
- js/
-go.mod
-go.sum
-`;
-
-// Additional instructions
-const additionalInstructions = `
-1. Use Fiber's App.Get/Post/etc for routing HTMX requests
-2. Implement CSRF protection with Fiber middleware
-3. Utilize Fiber's Context for handling HTMX-specific headers
-4. Use Fiber's template engine for server-side rendering
-5. Implement proper logging with Fiber's Logger middleware
-6. Follow Fiber's best practices for project structure
-7. Use environment variables for configuration
-`;
+ server/ # Application entrypoint
+ main.go # Server initialization
+internal/ # Private application code
+ handlers/ # HTTP handlers
+ items.go # Item handlers
+ users.go # User handlers
+ templates.go # Template helpers
+ models/ # Data models
+ item.go # Item model
+ user.go # User model
+ middleware/ # Fiber middleware
+ auth.go # Authentication
+ logging.go # Request logging
+ csrf.go # CSRF protection
+ templates/ # HTML templates
+ layouts/ # Template layouts
+ main.html # Main layout
+ views/ # View templates
+ index.html # Home page
+ about.html # About page
+ partials/ # Partial templates
+ form.html # Form partial
+ modal.html # Modal partial
+static/ # Static assets
+ css/ # Stylesheets
+ main.css # Main styles
+ js/ # JavaScript
+ htmx.min.js # HTMX library
+go.mod # Module definition
+go.sum # Module checksums
+
+// Development Guidelines
+1. Fiber Integration:
+ - Use fiber.Handler interface
+ - Implement Fiber middleware
+ - Follow idiomatic Go
+ - Use html/template or Fiber Views
+ - Handle errors properly
+ - Follow Fiber conventions
+
+2. HTMX Patterns:
+ - Return partial HTML
+ - Handle form submissions
+ - Implement validation
+ - Show loading states
+ - Use proper targeting
+ - Follow REST principles
+
+3. Performance Patterns:
+ - Use Fiber's FastHTTP
+ - Implement caching
+ - Handle timeouts
+ - Optimize templates
+ - Use connection pools
+ - Monitor resources
+
+// Dependencies
+Core:
+- go: ">=1.22"
+- fiber: "^2.52.0"
+- htmx: "^1.9.0"
+- sqlx: "^1.3.0"
+
+Optional:
+- fiber/csrf: "^2.52.0"
+- zap: "^1.24.0"
+- validator: "^10.0.0"
+- pgx: "^5.0.0"
+
+// Code Examples:
+
+1. Fiber Handler Pattern:
+```go
+package handlers
+
+import (
+ "github.com/gofiber/fiber/v2"
+ "github.com/jmoiron/sqlx"
+)
+
+type ItemHandler struct {
+ db *sqlx.DB
+}
+
+func NewItemHandler(db *sqlx.DB) *ItemHandler {
+ return &ItemHandler{
+ db: db,
+ }
+}
+
+func (h *ItemHandler) List(c *fiber.Ctx) error {
+ // Parse pagination params
+ page := c.QueryInt("page", 1)
+ if page < 1 {
+ page = 1
+ }
+
+ // Fetch items
+ var items []struct {
+ ID int64 `db:"id"`
+ Title string `db:"title"`
+ Description string `db:"description"`
+ }
+ err := h.db.SelectContext(c.Context(), &items, `
+ SELECT id, title, description
+ FROM items
+ ORDER BY created_at DESC
+ LIMIT 10 OFFSET $1
+ `, (page-1)*10)
+ if err != nil {
+ return c.Status(500).SendString("Failed to fetch items")
+ }
+
+ // Check if HTMX request
+ if c.Get("HX-Request") == "true" {
+ return c.Render("partials/item_list", fiber.Map{
+ "Items": items,
+ })
+ }
+
+ // Regular request - full page
+ return c.Render("views/items", fiber.Map{
+ "Items": items,
+ })
+}
+
+func (h *ItemHandler) Create(c *fiber.Ctx) error {
+ // Parse form
+ title := c.FormValue("title")
+ description := c.FormValue("description")
+ if title == "" || description == "" {
+ return c.Status(400).SendString("Missing required fields")
+ }
+
+ // Create item
+ var id int64
+ err := h.db.QueryRowContext(c.Context(), `
+ INSERT INTO items (title, description)
+ VALUES ($1, $2)
+ RETURNING id
+ `, title, description).Scan(&id)
+ if err != nil {
+ return c.Status(500).SendString("Failed to create item")
+ }
+
+ // Fetch new item
+ item := struct {
+ ID int64 `db:"id"`
+ Title string `db:"title"`
+ Description string `db:"description"`
+ }{}
+ err = h.db.GetContext(c.Context(), &item, `
+ SELECT id, title, description
+ FROM items WHERE id = $1
+ `, id)
+ if err != nil {
+ return c.Status(500).SendString("Failed to fetch item")
+ }
+
+ // Return new item HTML
+ return c.Render("partials/item", fiber.Map{
+ "Item": item,
+ })
+}
+```
+
+2. Template Pattern:
+```html
+{{/* layouts/main.html */}}
+
+
+
+
+
+
+ {{end}}
+
+ {{.Title}}
+{{.Description}}
+ + +
+ Loading more items...
+
+
+
+ {{range .Items}}
+
+
+{{/* partials/item_form.html */}}
+
+```
+
+3. Router Pattern:
+```go
+package main
+
+import (
+ "github.com/gofiber/fiber/v2"
+ "github.com/gofiber/fiber/v2/middleware/logger"
+ "github.com/gofiber/fiber/v2/middleware/recover"
+ "github.com/gofiber/template/html/v2"
+)
+
+func setupRouter(h *handlers.ItemHandler) *fiber.App {
+ // Initialize template engine
+ engine := html.New("./templates", ".html")
+
+ // Create Fiber app
+ app := fiber.New(fiber.Config{
+ Views: engine,
+ ViewsLayout: "layouts/main",
+ })
+
+ // Middleware
+ app.Use(logger.New())
+ app.Use(recover.New())
+
+ // Routes
+ app.Get("/", h.List)
+ app.Route("/items", func(router fiber.Router) {
+ router.Get("/", h.List)
+ router.Post("/", h.Create)
+ router.Route("/:id", func(router fiber.Router) {
+ router.Get("/", h.Get)
+ router.Put("/", h.Update)
+ router.Delete("/", h.Delete)
+ })
+ })
+
+ // Static files
+ app.Static("/static", "./static")
+
+ return app
+}
+```
+
+// Best Practices:
+1. Follow Fiber idioms
+2. Use proper interfaces
+3. Handle errors gracefully
+4. Implement middleware
+5. Optimize performance
+6. Use prepared statements
+7. Validate inputs
+8. Write unit tests
+9. Document code
+10. Follow naming conventions
+
+// Security Considerations:
+1. Enable CSRF protection
+2. Validate all inputs
+3. Sanitize HTML output
+4. Use proper headers
+5. Handle file uploads safely
+6. Implement rate limiting
+7. Use HTTPS
+8. Secure cookies
+9. Audit dependencies
+10. Log security events
diff --git a/rules/java-spring-boot-cursorrules-prompt-file/.cursorrules b/rules/java-spring-boot-cursorrules-prompt-file/.cursorrules
new file mode 100644
index 0000000..b8d46c3
--- /dev/null
+++ b/rules/java-spring-boot-cursorrules-prompt-file/.cursorrules
@@ -0,0 +1,358 @@
+// Java Spring Boot Development Guide
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+A modern Spring Boot application:
+- RESTful APIs
+- GraphQL APIs
+- WebSocket servers
+- Microservices
+- Authentication
+- Database integration
+- Message queues
+- Background jobs
+
+// Project Structure
+src/ # Source code
+ main/ # Main application
+ java/com/example/project/ # Package structure
+ Application.java # Main application class
+ config/ # Configuration
+ SecurityConfig.java # Security configuration
+ WebConfig.java # Web configuration
+ controller/ # REST controllers
+ UserController.java # User controller
+ ProductController.java # Product controller
+ model/ # Domain models
+ User.java # User model
+ Product.java # Product model
+ repository/ # Data access
+ UserRepository.java # User repository
+ ProductRepository.java # Product repository
+ service/ # Business logic
+ UserService.java # User service
+ ProductService.java # Product service
+ exception/ # Custom exceptions
+ ResourceNotFoundException.java # Resource not found exception
+ ValidationException.java # Validation exception
+ util/ # Utilities
+ Constants.java # Constants
+ DateUtils.java # Date utilities
+ resources/ # Resources
+ application.yml # Application properties
+ db/migration/ # Flyway migrations
+ static/ # Static resources
+ templates/ # Thymeleaf templates
+ test/ # Test suite
+ java/com/example/project/ # Test classes
+ controller/ # Controller tests
+ service/ # Service tests
+ repository/ # Repository tests
+
+// Development Guidelines
+1. Code Structure:
+ - Clean architecture
+ - Dependency injection
+ - Service layer
+ - Repository pattern
+ - Exception handling
+ - Logging
+
+2. API Design:
+ - RESTful principles
+ - Versioning
+ - Documentation
+ - Validation
+ - Error handling
+ - Security
+
+3. Performance:
+ - Caching
+ - Connection pooling
+ - Query optimization
+ - Async processing
+ - Monitoring
+ - Profiling
+
+// Dependencies
+Core:
+- spring-boot-starter-web: "3.1.0"
+- spring-boot-starter-data-jpa: "3.1.0"
+- spring-boot-starter-security: "3.1.0"
+- spring-boot-starter-validation: "3.1.0"
+
+Optional:
+- spring-boot-starter-actuator: "3.1.0"
+- spring-boot-starter-cache: "3.1.0"
+- spring-boot-starter-test: "3.1.0"
+- springdoc-openapi-starter-webmvc-ui: "2.1.0"
+
+// Code Examples:
+
+1. Controller Pattern:
+```java
+package com.example.project.controller;
+
+import com.example.project.model.User;
+import com.example.project.service.UserService;
+import com.example.project.dto.UserDTO;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/users")
+@RequiredArgsConstructor
+public class UserController {
+ private final UserService userService;
+
+ @GetMapping("/{id}")
+ public ResponseEntity
+
+ {{end}}
+
+ {{.Title}}
+{{.Description}}
+ + +
+ Loading more items...
+
+Loading...
;
+ }
+
+ if (error) {
+ return Error: {error.message}
;
+ }
+
+ return (
+
+ {users?.map(user => (
+
+ );
+}
+```
+
+5. Store Pattern:
+```javascript
+// userSlice.js
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+import { userService } from '../services/userService';
+
+export const fetchUsers = createAsyncThunk(
+ 'users/fetchUsers',
+ async (_, { rejectWithValue }) => {
+ try {
+ return await userService.getUsers();
+ } catch (error) {
+ return rejectWithValue(error.message);
+ }
+ }
+);
+
+const userSlice = createSlice({
+ name: 'users',
+ initialState: {
+ data: [],
+ loading: false,
+ error: null
+ },
+ reducers: {
+ clearError: state => {
+ state.error = null;
+ }
+ },
+ extraReducers: builder => {
+ builder
+ .addCase(fetchUsers.pending, state => {
+ state.loading = true;
+ state.error = null;
+ })
+ .addCase(fetchUsers.fulfilled, (state, action) => {
+ state.loading = false;
+ state.data = action.payload;
+ })
+ .addCase(fetchUsers.rejected, (state, action) => {
+ state.loading = false;
+ state.error = action.payload;
+ });
+ }
+});
+
+export const { clearError } = userSlice.actions;
+export default userSlice.reducer;
+```
+
+// Best Practices:
+1. Code Quality:
+ - Use ESLint
+ - Use Prettier
+ - Write tests
+ - Document code
+ - Review code
+ - Refactor regularly
+
+2. Performance:
+ - Optimize bundles
+ - Lazy loading
+ - Memoization
+ - Debouncing
+ - Throttling
+ - Caching
+
+3. Security:
+ - Input validation
+ - XSS prevention
+ - CSRF protection
+ - Secure storage
+ - API security
+ - Error handling
+
+4. Testing:
+ - Unit tests
+ - Integration tests
+ - E2E tests
+ - Snapshot tests
+ - Performance tests
+ - Security tests
+
+// Security Considerations:
+1. Client-side:
+ - Input validation
+ - XSS prevention
+ - CSRF tokens
+ - Secure storage
+ - API security
+ - Error handling
+
+2. Data Security:
+ - Encryption
+ - Hashing
+ - Access control
+ - Audit logging
+ - Data validation
+ - Backups
+
+3. Infrastructure:
+ - HTTPS
+ - CORS
+ - CSP
+ - Rate limiting
+ - Monitoring
+ - Logging
\ No newline at end of file
diff --git a/rules/kotlin-spring-boot-cursorrules-prompt-file/.cursorrules b/rules/kotlin-spring-boot-cursorrules-prompt-file/.cursorrules
new file mode 100644
index 0000000..7ec1854
--- /dev/null
+++ b/rules/kotlin-spring-boot-cursorrules-prompt-file/.cursorrules
@@ -0,0 +1,329 @@
+// Kotlin Spring Boot Development Guide
+// Author: {{AUTHOR_NAME}} ({{GITHUB_USERNAME}})
+
+// What you can build with this ruleset:
+A modern Kotlin Spring Boot application:
+- RESTful APIs
+- GraphQL APIs
+- WebSocket servers
+- Microservices
+- Authentication
+- Database integration
+- Message queues
+- Background jobs
+
+// Project Structure
+src/
+ main/
+ kotlin/com/example/project/ # Package structure
+ Application.kt # Main application class
+ config/ # Configuration
+ SecurityConfig.kt # Security configuration
+ WebConfig.kt # Web configuration
+ controller/ # REST controllers
+ UserController.kt # User controller
+ ProductController.kt # Product controller
+ model/ # Domain models
+ User.kt # User model
+ Product.kt # Product model
+ repository/ # Data access
+ UserRepository.kt # User repository
+ ProductRepository.kt # Product repository
+ service/ # Business logic
+ UserService.kt # User service
+ ProductService.kt # Product service
+ exception/ # Custom exceptions
+ ResourceNotFoundException.kt # Resource not found exception
+ ValidationException.kt # Validation exception
+ util/ # Utilities
+ Extensions.kt # Extension functions
+ Constants.kt # Constants
+ resources/ # Resources
+ application.yml # Application properties
+ db/migration/ # Flyway migrations
+ static/ # Static resources
+ templates/ # Thymeleaf templates
+ test/ # Test suite
+ kotlin/com/example/project/ # Test classes
+ controller/ # Controller tests
+ service/ # Service tests
+ repository/ # Repository tests
+
+// Development Guidelines
+1. Code Structure:
+ - Clean architecture
+ - Dependency injection
+ - Service layer
+ - Repository pattern
+ - Exception handling
+ - Logging
+
+2. API Design:
+ - RESTful principles
+ - Versioning
+ - Documentation
+ - Validation
+ - Error handling
+ - Security
+
+3. Performance:
+ - Caching
+ - Connection pooling
+ - Query optimization
+ - Coroutines
+ - Monitoring
+ - Profiling
+
+// Dependencies
+Core:
+- kotlin: "1.8.20"
+- spring-boot-starter-web: "3.1.0"
+- spring-boot-starter-data-jpa: "3.1.0"
+- spring-boot-starter-security: "3.1.0"
+
+Optional:
+- spring-boot-starter-actuator: "3.1.0"
+- spring-boot-starter-cache: "3.1.0"
+- spring-boot-starter-test: "3.1.0"
+- springdoc-openapi-starter-webmvc-ui: "2.1.0"
+
+// Code Examples:
+
+1. Controller Pattern:
+```kotlin
+package com.example.project.controller
+
+import com.example.project.model.User
+import com.example.project.service.UserService
+import com.example.project.dto.UserDTO
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.*
+import jakarta.validation.Valid
+
+@RestController
+@RequestMapping("/api/v1/users")
+class UserController(
+ private val userService: UserService
+) {
+ @GetMapping("/{id}")
+ suspend fun getUser(@PathVariable id: Long): ResponseEntity
+
+ ))}
+ {user.name}
+{user.email}
+
+
+
+
+ );
+}
+```
+
+3. Route Handler Pattern:
+```tsx
+// app/api/posts/route.ts
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/db';
+
+const postSchema = z.object({
+ title: z.string().min(1).max(100),
+ content: z.string().min(1),
+ published: z.boolean().default(false),
+});
+
+export async function POST(request: Request) {
+ try {
+ const session = await auth();
+
+ if (!session) {
+ return NextResponse.json(
+ { error: 'Unauthorized' },
+ { status: 401 }
+ );
+ }
+
+ const json = await request.json();
+ const body = postSchema.parse(json);
+
+ const post = await prisma.post.create({
+ data: {
+ ...body,
+ authorId: session.user.id,
+ },
+ });
+
+ return NextResponse.json(post);
+ } catch (error) {
+ if (error instanceof z.ZodError) {
+ return NextResponse.json(
+ { error: error.errors },
+ { status: 400 }
+ );
+ }
+
+ return NextResponse.json(
+ { error: 'Internal Server Error' },
+ { status: 500 }
+ );
+ }
+}
+
+export async function GET(request: Request) {
+ try {
+ const { searchParams } = new URL(request.url);
+ const published = searchParams.get('published');
+
+ const posts = await prisma.post.findMany({
+ where: {
+ published: published ? published === 'true' : undefined,
+ },
+ include: {
+ author: {
+ select: {
+ name: true,
+ image: true,
+ },
+ },
+ },
+ });
+
+ return NextResponse.json(posts);
+ } catch (error) {
+ return NextResponse.json(
+ { error: 'Internal Server Error' },
+ { status: 500 }
+ );
+ }
+}
+```
+
+4. Server Action Pattern:
+```tsx
+// app/actions/posts.ts
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/db';
+import { PostSchema } from '@/lib/validations/post';
+
+export async function createPost(formData: FormData) {
+ try {
+ const session = await auth();
+
+ if (!session) {
+ return {
+ error: 'Unauthorized',
+ };
+ }
+
+ const rawData = {
+ title: formData.get('title'),
+ content: formData.get('content'),
+ published: formData.get('published') === 'true',
+ };
+
+ const validatedData = PostSchema.parse(rawData);
+
+ const post = await prisma.post.create({
+ data: {
+ ...validatedData,
+ authorId: session.user.id,
+ },
+ });
+
+ revalidatePath('/posts');
+
+ return { data: post };
+ } catch (error) {
+ return {
+ error: 'Failed to create post',
+ };
+ }
+}
+
+export async function deletePost(postId: string) {
+ try {
+ const session = await auth();
+
+ if (!session) {
+ return {
+ error: 'Unauthorized',
+ };
+ }
+
+ const post = await prisma.post.findUnique({
+ where: { id: postId },
+ });
+
+ if (!post) {
+ return {
+ error: 'Post not found',
+ };
+ }
+
+ if (post.authorId !== session.user.id) {
+ return {
+ error: 'Unauthorized',
+ };
+ }
+
+ await prisma.post.delete({
+ where: { id: postId },
+ });
+
+ revalidatePath('/posts');
+
+ return { success: true };
+ } catch (error) {
+ return {
+ error: 'Failed to delete post',
+ };
+ }
+}
+```
+
+5. Client Component Pattern:
+```tsx
+'use client';
+
+import { useState } from 'react';
+import { useRouter } from 'next/navigation';
+import { createPost } from '@/app/actions/posts';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Textarea } from '@/components/ui/textarea';
+import { toast } from '@/components/ui/toast';
+
+export function CreatePostForm() {
+ const router = useRouter();
+ const [isPending, setIsPending] = useState(false);
+
+ async function onSubmit(event: React.FormEvent
+ {children}
+
+
+
+
+
+ App Name
+
+
+
+
+
+
+ {isDark ? '🌞' : '🌙'}
+
+
+
+
+
+
+
+```
+
+2. Composable Pattern:
+```typescript
+import { ref, computed, onMounted, onUnmounted } from 'vue'
+import type { Ref } from 'vue'
+
+interface UseDataOptions {
+ immediate?: boolean
+ transform?: (data: any) => any
+}
+
+export function useData-
+
- + {{ user.name }} + +
No users found
+ +
+
+
+
+ logger = $logger;
+ $this->client = $this->createClient($config);
+ }
+
+ private function createClient(array $config): Client {
+ $stack = HandlerStack::create();
+
+ // Add retry middleware
+ $stack->push(Middleware::retry(
+ function ($retries, $request, $response) {
+ if ($retries >= 3) {
+ return false;
+ }
+
+ if ($response && $response->getStatusCode() >= 500) {
+ return true;
+ }
+
+ return false;
+ },
+ function ($retries) {
+ return 1000 * pow(2, $retries);
+ }
+ ));
+
+ // Add logging middleware
+ $stack->push(Middleware::log(
+ $this->logger,
+ new \GuzzleHttp\MessageFormatter(
+ '{method} {uri} HTTP/{version} {code}'
+ )
+ ));
+
+ return new Client(array_merge([
+ 'handler' => $stack,
+ 'timeout' => 30,
+ 'http_errors' => true,
+ ], $config));
+ }
+
+ public function get(string $endpoint, array $options = []): array {
+ try {
+ $response = $this->client->get($endpoint, $options);
+ return json_decode($response->getBody(), true);
+ } catch (\Exception $e) {
+ $this->logger->error($e->getMessage(), [
+ 'endpoint' => $endpoint,
+ 'options' => $options,
+ ]);
+ throw $e;
+ }
+ }
+}
+```
+
+3. Plugin Integration Pattern:
+```php
+container = $this->createContainer();
+ $this->initHooks();
+ }
+
+ private function createContainer(): Container {
+ $builder = new ContainerBuilder();
+ $builder->addDefinitions([
+ LoggerInterface::class => function () {
+ return new Logger('plugin-name');
+ },
+ ApiClient::class => function (Container $c) {
+ return new ApiClient(
+ $c->get(LoggerInterface::class),
+ [
+ 'base_uri' => 'https://api.example.com',
+ ]
+ );
+ },
+ ]);
+ return $builder->build();
+ }
+
+ private function initHooks(): void {
+ add_action('init', [$this, 'init']);
+ add_action('admin_init', [$this, 'adminInit']);
+ add_action(
+ 'enqueue_block_editor_assets',
+ [$this, 'enqueueBlockAssets']
+ );
+ }
+
+ public function init(): void {
+ load_plugin_textdomain(
+ 'plugin-name',
+ false,
+ dirname(plugin_basename(__FILE__)) . '/languages'
+ );
+
+ $this->container
+ ->get(Blocks\ExampleBlock::class)
+ ->register();
+ }
+
+ public function activate(): void {
+ // Activation logic
+ flush_rewrite_rules();
+ }
+
+ public function deactivate(): void {
+ // Cleanup logic
+ flush_rewrite_rules();
+ }
+}
+```
+
+// Best Practices:
+1. Follow WordPress standards
+2. Use proper security measures
+3. Implement proper caching
+4. Handle errors gracefully
+5. Use dependency injection
+6. Write comprehensive tests
+7. Document code properly
+8. Use proper logging
+9. Handle updates properly
+10. Optimize performance
+
+// Security Considerations:
+1. Validate user input
+2. Sanitize output
+3. Use nonces properly
+4. Handle capabilities
+5. Secure API requests
+6. Implement rate limiting
+7. Use proper escaping
+8. Handle file uploads
+9. Protect sensitive data
+10. Follow WordPress security
\ No newline at end of file
diff --git a/scripts/docs/setup_and_run.md b/scripts/docs/setup_and_run.md
new file mode 100644
index 0000000..29199a5
--- /dev/null
+++ b/scripts/docs/setup_and_run.md
@@ -0,0 +1,80 @@
+# Setup and Run Script Documentation
+
+## Overview
+
+The `setup_and_run.sh` script is a bash wrapper that manages the Python virtual environment and dependencies for the `standardize_rules.py` script. It ensures all necessary dependencies are installed and the script runs in an isolated environment.
+
+## Features
+
+- 🌟 Automatic virtual environment creation and management
+- 📦 Dependency installation via requirements.txt
+- 🔄 Environment cleanup after execution
+- 🎨 Colorized output for better visibility
+
+## Prerequisites
+
+- Python 3.x installed
+- Bash shell environment
+- Write permissions in the script directory
+
+## Usage
+
+```bash
+bash scripts/setup_and_run.sh
+```
+
+## Script Flow
+
+1. **Environment Setup**
+ - Creates a virtual environment in `.venv` if it doesn't exist
+ - Creates `requirements.txt` if it doesn't exist with required packages:
+ - pathlib
+ - python-dateutil
+
+2. **Dependency Management**
+ - Activates the virtual environment
+ - Installs all required packages from requirements.txt
+
+3. **Script Execution**
+ - Runs standardize_rules.py in the virtual environment
+ - Handles any script output or errors
+
+4. **Cleanup**
+ - Deactivates the virtual environment
+ - Provides execution status
+
+## Output Colors
+
+- 🟡 Yellow: Setup and processing steps
+- 🟢 Green: Success messages and completion
+- 🔵 Blue: Cleanup operations
+
+## Directory Structure
+
+```bash
+scripts/
+├── setup_and_run.sh
+├── standardize_rules.py
+├── requirements.txt
+└── docs/
+ └── setup_and_run.md
+```
+
+## Error Handling
+
+- Exits on any error (set -e)
+- Provides clear error messages
+- Ensures virtual environment is properly deactivated
+
+## Maintenance
+
+The script is designed to be maintainable and extensible:
+
+- Add new dependencies to `requirements.txt`
+- Modify virtual environment location via `VENV_DIR`
+- Customize output colors and messages
+
+## Related Documentation
+
+- [standardize_rules.md](standardize_rules.md) - Documentation for the main Python script
+- [ci.md](ci.md) - Continuous Integration documentation
diff --git a/scripts/requirements.txt b/scripts/requirements.txt
new file mode 100644
index 0000000..449051a
--- /dev/null
+++ b/scripts/requirements.txt
@@ -0,0 +1,2 @@
+pathlib
+python-dateutil
diff --git a/scripts/setup_and_run.sh b/scripts/setup_and_run.sh
new file mode 100755
index 0000000..a219fac
--- /dev/null
+++ b/scripts/setup_and_run.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+# Script directory
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+VENV_DIR="$SCRIPT_DIR/.venv"
+REQUIREMENTS_FILE="$SCRIPT_DIR/requirements.txt"
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${YELLOW}🔧 Setting up environment for standardize_rules.py...${NC}"
+
+# Create requirements.txt if it doesn't exist
+if [ ! -f "$REQUIREMENTS_FILE" ]; then
+ echo -e "${YELLOW}📝 Creating requirements.txt...${NC}"
+ cat > "$REQUIREMENTS_FILE" << EOF
+pathlib
+python-dateutil
+EOF
+fi
+
+# Check if virtual environment exists
+if [ ! -d "$VENV_DIR" ]; then
+ echo -e "${YELLOW}🌟 Creating virtual environment...${NC}"
+ python3 -m venv "$VENV_DIR"
+fi
+
+# Activate virtual environment
+echo -e "${YELLOW}🔌 Activating virtual environment...${NC}"
+source "$VENV_DIR/bin/activate"
+
+# Install requirements
+echo -e "${YELLOW}📦 Installing dependencies...${NC}"
+pip install -r "$REQUIREMENTS_FILE"
+
+# Run the Python script
+echo -e "${GREEN}🚀 Running standardize_rules.py...${NC}"
+python "$SCRIPT_DIR/standardize_rules.py"
+
+# Cleanup and exit virtual environment
+echo -e "${BLUE}🧹 Cleaning up environment...${NC}"
+deactivate
+echo -e "${BLUE}📤 Virtual environment deactivated${NC}"
+
+echo -e "${GREEN}✅ Script execution completed!${NC}"
\ No newline at end of file
diff --git a/scripts/standardize_rules.py b/scripts/standardize_rules.py
index 8fa267f..3af785a 100755
--- a/scripts/standardize_rules.py
+++ b/scripts/standardize_rules.py
@@ -11,6 +11,25 @@ def load_template():
with open(template_path) as f:
return json.load(f)
+def convert_text_to_rules(text_content, dir_name):
+ """Convert text content to standardized rules format."""
+ try:
+ # First try to parse as JSON in case it is valid JSON
+ return json.loads(text_content)
+ except json.JSONDecodeError:
+ # If not valid JSON, create a new structure with the text as content
+ return {
+ "name": dir_name,
+ "description": "Cursor.sh AI rules for development",
+ "version": "1.0.0",
+ "content": text_content.strip(),
+ "metadata": {
+ "lastUpdated": datetime.datetime.now().isoformat(),
+ "format": "text",
+ "originalFileName": ".cursorrules"
+ }
+ }
+
def process_directory(dir_path, template):
"""Process a single directory containing .cursorrules file."""
cursorrules_path = dir_path / ".cursorrules"
@@ -22,38 +41,44 @@ def process_directory(dir_path, template):
return
try:
- # Load existing .cursorrules file
+ # Load existing .cursorrules file as text
with open(cursorrules_path) as f:
- existing_rules = json.load(f)
- except json.JSONDecodeError:
- print(f"Invalid JSON in {cursorrules_path}")
- return
+ existing_content = f.read()
+
+ # Convert the content to rules format
+ existing_rules = convert_text_to_rules(existing_content, dir_path.name)
+
+ # Create new standardized rules
+ new_rules = template.copy()
+ new_rules["name"] = dir_path.name
+ new_rules["metadata"]["lastUpdated"] = datetime.datetime.now().isoformat()
+
+ # Transfer existing data if it matches our schema
+ for key in existing_rules:
+ if key in new_rules:
+ new_rules[key] = existing_rules[key]
+ elif key == "content":
+ # Store the original text content in a specific field
+ new_rules["prompt"] = existing_rules["content"]
+
+ # Save the standardized rules
+ with open(cursorrules_path, 'w') as f:
+ json.dump(new_rules, f, indent=2)
+
+ print(f"✅ Successfully processed {dir_path}")
+
+ # Create README.md if it doesn't exist
+ if not readme_path.exists():
+ with open(readme_path, 'w') as f:
+ f.write(f"# {new_rules['name']}\n\n")
+ if "description" in new_rules:
+ f.write(f"{new_rules['description']}\n\n")
+ f.write("## Usage\n\n")
+ f.write("Copy the `.cursorrules` file to your project's root directory.\n")
+
except Exception as e:
- print(f"Error processing {cursorrules_path}: {e}")
+ print(f"⚠️ Error processing {dir_path}: {e}")
return
-
- # Create new standardized rules
- new_rules = template.copy()
- new_rules["name"] = dir_path.name
- new_rules["metadata"]["lastUpdated"] = datetime.datetime.now().isoformat()
-
- # Transfer existing data if it matches our schema
- for key in existing_rules:
- if key in new_rules:
- new_rules[key] = existing_rules[key]
-
- # Save the standardized rules
- with open(cursorrules_path, 'w') as f:
- json.dump(new_rules, f, indent=2)
-
- # Create README.md if it doesn't exist
- if not readme_path.exists():
- with open(readme_path, 'w') as f:
- f.write(f"# {new_rules['name']}\n\n")
- if "description" in new_rules:
- f.write(f"{new_rules['description']}\n\n")
- f.write("## Usage\n\n")
- f.write("Copy the `.cursorrules` file to your project's root directory.\n")
def main():
"""Main function to process all rule directories."""
@@ -63,7 +88,7 @@ def main():
# Process each directory in rules/
for dir_path in rules_dir.iterdir():
if dir_path.is_dir() and not dir_path.name.startswith('.'):
- print(f"Processing {dir_path}...")
+ print(f"🔄 Processing {dir_path}...")
process_directory(dir_path, template)
if __name__ == "__main__":