openskill-ai 1.0.0

package/skills/backend-best-practices/rules/deploy-monitoring.md

@@ -0,0 +1,87 @@
+---
+title: Set Up Monitoring and Alerts
+impact: LOW-MEDIUM
+impactDescription: Enables proactive issue detection and resolution
+tags: deployment, monitoring, observability, alerts
+---
+
+## Set Up Monitoring and Alerts
+
+Implement monitoring and alerting to detect issues before they impact users.
+
+**Correct implementation:**
+
+```javascript
+// Application Performance Monitoring (APM)
+const newrelic = require('newrelic'); // or DataDog, AppDynamics, etc.
+
+// Custom metrics
+const promClient = require('prom-client');
+
+// Create metrics
+const httpRequestDuration = new promClient.Histogram({
+  name: 'http_request_duration_seconds',
+  help: 'Duration of HTTP requests in seconds',
+  labelNames: ['method', 'route', 'status_code']
+});
+
+const activeConnections = new promClient.Gauge({
+  name: 'active_connections',
+  help: 'Number of active connections'
+});
+
+// Middleware to track metrics
+app.use((req, res, next) => {
+  const start = Date.now();
+  
+  res.on('finish', () => {
+    const duration = (Date.now() - start) / 1000;
+    httpRequestDuration
+      .labels(req.method, req.route?.path || req.path, res.statusCode)
+      .observe(duration);
+  });
+  
+  next();
+});
+
+// Expose metrics endpoint
+app.get('/metrics', async (req, res) => {
+  res.set('Content-Type', promClient.register.contentType);
+  res.end(await promClient.register.metrics());
+});
+
+// Error tracking
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  environment: process.env.NODE_ENV,
+  tracesSampleRate: 0.1,
+});
+
+app.use(Sentry.Handlers.requestHandler());
+app.use(Sentry.Handlers.errorHandler());
+
+// Custom alerts
+const alertSlack = async (message) => {
+  if (process.env.NODE_ENV === 'production') {
+    await fetch(process.env.SLACK_WEBHOOK_URL, {
+      method: 'POST',
+      body: JSON.stringify({ text: message })
+    });
+  }
+};
+
+// Monitor critical operations
+app.post('/api/payments', async (req, res) => {
+  try {
+    const payment = await processPayment(req.body);
+    res.json(payment);
+  } catch (error) {
+    await alertSlack(`Payment failed: ${error.message}`);
+    throw error;
+  }
+});
+```
+
+Reference: [Monitoring Best Practices](https://www.datadoghq.com/blog/monitoring-101-collecting-data/)

package/skills/backend-best-practices/rules/deploy-zero-downtime.md

@@ -0,0 +1,85 @@
+---
+title: Implement Zero-Downtime Deployments
+impact: LOW-MEDIUM
+impactDescription: Eliminates service interruption during deployments
+tags: deployment, zero-downtime, continuous-deployment
+---
+
+## Implement Zero-Downtime Deployments
+
+Use rolling deployments and health checks to deploy without downtime.
+
+**Deployment strategies:**
+
+```yaml
+# Docker Compose - Rolling Update
+version: '3'
+services:
+  api:
+    image: myapp:latest
+    deploy:
+      replicas: 3
+      update_config:
+        parallelism: 1
+        delay: 10s
+        order: start-first
+      rollback_config:
+        parallelism: 1
+        delay: 5s
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+```
+
+```yaml
+# Kubernetes - Rolling Update
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: api-deployment
+spec:
+  replicas: 3
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxSurge: 1
+      maxUnavailable: 0
+  template:
+    spec:
+      containers:
+      - name: api
+        image: myapp:latest
+        readinessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 5
+          periodSeconds: 10
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 15
+          periodSeconds: 20
+```
+
+**Blue-Green Deployment:**
+
+```bash
+# Deploy new version (green)
+docker-compose -f docker-compose.green.yml up -d
+
+# Wait for health checks
+sleep 30
+
+# Switch traffic to green
+nginx -s reload
+
+# Stop old version (blue)
+docker-compose -f docker-compose.blue.yml down
+```
+
+Reference: [Zero-Downtime Deployment](https://martinfowler.com/bliki/BlueGreenDeployment.html)

package/skills/backend-best-practices/rules/error-global-handler.md

@@ -0,0 +1,94 @@
+---
+title: Implement Global Error Handling
+impact: HIGH
+impactDescription: Consistent error handling and prevents crashes
+tags: error-handling, middleware, express, robustness
+---
+
+## Implement Global Error Handling
+
+Use centralized error handling to catch errors consistently and prevent server crashes.
+
+**Incorrect (inconsistent error handling):**
+
+```javascript
+app.get('/api/users/:id', async (req, res) => {
+  try {
+    const user = await User.findById(req.params.id);
+    res.json(user);
+  } catch (error) {
+    res.status(500).json({ error: 'Something went wrong' });
+  }
+});
+
+// Another endpoint with different error format
+app.get('/api/posts/:id', async (req, res) => {
+  const post = await Post.findById(req.params.id); // Unhandled error!
+  res.json(post);
+});
+```
+
+**Correct (global error handler):**
+
+```javascript
+// Custom error class
+class AppError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+// Async wrapper to avoid try-catch in every route
+const asyncHandler = (fn) => (req, res, next) => {
+  Promise.resolve(fn(req, res, next)).catch(next);
+};
+
+// Routes
+app.get('/api/users/:id', asyncHandler(async (req, res) => {
+  const user = await User.findById(req.params.id);
+  if (!user) {
+    throw new AppError('User not found', 404);
+  }
+  res.json(user);
+}));
+
+// Global error handler (must be last)
+app.use((err, req, res, next) => {
+  err.statusCode = err.statusCode || 500;
+  err.status = err.status || 'error';
+  
+  if (process.env.NODE_ENV === 'development') {
+    res.status(err.statusCode).json({
+      status: err.status,
+      error: err,
+      message: err.message,
+      stack: err.stack
+    });
+  } else {
+    // Production - don't leak stack traces
+    if (err.isOperational) {
+      res.status(err.statusCode).json({
+        status: err.status,
+        message: err.message
+      });
+    } else {
+      console.error('ERROR:', err);
+      res.status(500).json({
+        status: 'error',
+        message: 'Something went wrong'
+      });
+    }
+  }
+});
+
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (err) => {
+  console.error('UNHANDLED REJECTION:', err);
+  process.exit(1);
+});
+```
+
+Reference: [Error Handling Best Practices](https://expressjs.com/en/guide/error-handling.html)

package/skills/backend-best-practices/rules/error-graceful-degradation.md

@@ -0,0 +1,70 @@
+---
+title: Implement Graceful Degradation
+impact: HIGH
+impactDescription: Maintains service availability during partial failures
+tags: error-handling, resilience, fault-tolerance
+---
+
+## Implement Graceful Degradation
+
+Design systems to degrade gracefully when dependencies fail, maintaining core functionality.
+
+**Incorrect (complete failure):**
+
+```javascript
+app.get('/api/dashboard', async (req, res) => {
+  // If recommendations fail, entire endpoint fails
+  const userData = await getUserData(req.user.id);
+  const recommendations = await getRecommendations(req.user.id); 
+  const analytics = await getAnalytics(req.user.id);
+  
+  res.json({ userData, recommendations, analytics });
+});
+```
+
+**Correct (graceful degradation):**
+
+```javascript
+app.get('/api/dashboard', async (req, res) => {
+  const results = await Promise.allSettled([
+    getUserData(req.user.id),
+    getRecommendations(req.user.id),
+    getAnalytics(req.user.id)
+  ]);
+  
+  const [userData, recommendations, analytics] = results;
+  
+  res.json({
+    userData: userData.status === 'fulfilled' 
+      ? userData.value 
+      : null,
+    recommendations: recommendations.status === 'fulfilled'
+      ? recommendations.value
+      : [], // Fallback to empty array
+    analytics: analytics.status === 'fulfilled'
+      ? analytics.value
+      : { message: 'Analytics temporarily unavailable' },
+    warnings: results
+      .filter(r => r.status === 'rejected')
+      .map(r => r.reason.message)
+  });
+});
+
+// With circuit breaker pattern
+const CircuitBreaker = require('opossum');
+
+const breaker = new CircuitBreaker(getRecommendations, {
+  timeout: 3000,
+  errorThresholdPercentage: 50,
+  resetTimeout: 30000
+});
+
+breaker.fallback(() => []);
+
+app.get('/api/dashboard', async (req, res) => {
+  const recommendations = await breaker.fire(req.user.id);
+  // Returns fallback if service is down
+});
+```
+
+Reference: [Fault Tolerance Patterns](https://martinfowler.com/articles/patterns-of-distributed-systems/)

package/skills/backend-best-practices/rules/error-http-status-codes.md

@@ -0,0 +1,77 @@
+---
+title: Use Appropriate HTTP Status Codes
+impact: HIGH
+impactDescription: Better API clarity and client-side error handling
+tags: error-handling, http, status-codes, api
+---
+
+## Use Appropriate HTTP Status Codes
+
+Return correct HTTP status codes to communicate the result of API requests clearly.
+
+**Incorrect (always returns 200):**
+
+```javascript
+app.get('/api/users/:id', async (req, res) => {
+  const user = await User.findById(req.params.id);
+  if (!user) {
+    return res.json({ error: 'User not found' }); // Still 200!
+  }
+  res.json(user);
+});
+
+app.post('/api/users', async (req, res) => {
+  const user = await User.create(req.body);
+  res.json(user); // Should be 201!
+});
+```
+
+**Correct (proper status codes):**
+
+```javascript
+app.get('/api/users/:id', async (req, res) => {
+  const user = await User.findById(req.params.id);
+  if (!user) {
+    return res.status(404).json({ error: 'User not found' });
+  }
+  res.status(200).json(user);
+});
+
+app.post('/api/users', async (req, res) => {
+  const user = await User.create(req.body);
+  res.status(201).json(user); // Created
+});
+
+app.put('/api/users/:id', async (req, res) => {
+  const user = await User.findByIdAndUpdate(req.params.id, req.body);
+  res.status(200).json(user); // OK
+});
+
+app.delete('/api/users/:id', async (req, res) => {
+  await User.findByIdAndDelete(req.params.id);
+  res.status(204).send(); // No Content
+});
+```
+
+**Common Status Codes:**
+
+```javascript
+// Success
+200 OK - Request succeeded
+201 Created - Resource created
+204 No Content - Success but no response body
+
+// Client Errors
+400 Bad Request - Invalid input
+401 Unauthorized - Authentication required
+403 Forbidden - Not authorized
+404 Not Found - Resource doesn't exist
+409 Conflict - Duplicate/conflict
+422 Unprocessable Entity - Validation failed
+
+// Server Errors
+500 Internal Server Error - Unexpected error
+503 Service Unavailable - Server overloaded
+```
+
+Reference: [HTTP Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)

package/skills/backend-best-practices/rules/error-logging.md

@@ -0,0 +1,71 @@
+---
+title: Log Errors with Context
+impact: HIGH
+impactDescription: Enables effective debugging and monitoring
+tags: error-handling, logging, debugging, monitoring
+---
+
+## Log Errors with Context
+
+Log errors with sufficient context for debugging, including request details and stack traces.
+
+**Incorrect (insufficient logging):**
+
+```javascript
+try {
+  await processPayment(orderId);
+} catch (error) {
+  console.log('Error'); // No context!
+  res.status(500).json({ error: 'Failed' });
+}
+```
+
+**Correct (contextual logging):**
+
+```javascript
+const winston = require('winston');
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'combined.log' })
+  ]
+});
+
+app.post('/api/payments', async (req, res) => {
+  try {
+    await processPayment(req.body.orderId);
+    res.json({ success: true });
+  } catch (error) {
+    logger.error('Payment processing failed', {
+      error: error.message,
+      stack: error.stack,
+      orderId: req.body.orderId,
+      userId: req.user?.id,
+      endpoint: req.path,
+      method: req.method,
+      timestamp: new Date().toISOString()
+    });
+    
+    res.status(500).json({ error: 'Payment failed' });
+  }
+});
+
+// Request logging middleware
+app.use((req, res, next) => {
+  logger.info('Request received', {
+    method: req.method,
+    path: req.path,
+    userId: req.user?.id,
+    ip: req.ip
+  });
+  next();
+});
+```
+
+Reference: [Logging Best Practices](https://www.datadoghq.com/blog/node-logging-best-practices/)

package/skills/backend-best-practices/rules/error-meaningful-messages.md

@@ -0,0 +1,61 @@
+---
+title: Provide Meaningful Error Messages
+impact: HIGH
+impactDescription: Improves debugging and user experience
+tags: error-handling, ux, debugging
+---
+
+## Provide Meaningful Error Messages
+
+Return clear, actionable error messages to help clients understand and fix issues.
+
+**Incorrect (vague errors):**
+
+```javascript
+if (!user) {
+  return res.status(400).json({ error: 'Error' });
+}
+
+if (age < 18) {
+  return res.status(400).json({ error: 'Invalid' });
+}
+```
+
+**Correct (descriptive errors):**
+
+```javascript
+if (!user) {
+  return res.status(404).json({ 
+    error: 'User not found',
+    code: 'USER_NOT_FOUND',
+    details: `No user exists with ID: ${userId}`
+  });
+}
+
+if (age < 18) {
+  return res.status(400).json({
+    error: 'Validation failed',
+    code: 'AGE_REQUIREMENT_NOT_MET',
+    details: 'User must be at least 18 years old',
+    field: 'age',
+    receivedValue: age,
+    expectedValue: '>=18'
+  });
+}
+
+// Validation errors
+const errors = validationResult(req);
+if (!errors.isEmpty()) {
+  return res.status(422).json({
+    error: 'Validation failed',
+    code: 'VALIDATION_ERROR',
+    details: errors.array().map(err => ({
+      field: err.param,
+      message: err.msg,
+      value: err.value
+    }))
+  });
+}
+```
+
+Reference: [API Error Handling](https://www.baeldung.com/rest-api-error-handling-best-practices)

package/skills/backend-best-practices/rules/perf-async-operations.md

@@ -0,0 +1,55 @@
+---
+title: Use Async/Await for I/O Operations
+impact: HIGH
+impactDescription: Prevents blocking and improves concurrency
+tags: performance, async, promises, nodejs
+---
+
+## Use Async/Await for I/O Operations
+
+Always use async/await for I/O operations to avoid blocking the event loop and improve performance.
+
+**Incorrect (blocking synchronous code):**
+
+```javascript
+const fs = require('fs');
+
+app.get('/api/file', (req, res) => {
+  // Blocks the entire server!
+  const data = fs.readFileSync('/large-file.json', 'utf8');
+  res.json(JSON.parse(data));
+});
+```
+
+**Correct (non-blocking async):**
+
+```javascript
+const fs = require('fs').promises;
+
+app.get('/api/file', async (req, res) => {
+  try {
+    const data = await fs.readFile('/large-file.json', 'utf8');
+    res.json(JSON.parse(data));
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+```
+
+**Parallel Async Operations:**
+
+```javascript
+// Incorrect (sequential - slower)
+const user = await User.findById(id);
+const posts = await Post.find({ authorId: id });
+const comments = await Comment.find({ userId: id });
+
+// Correct (parallel - faster)
+const [user, posts, comments] = await Promise.all([
+  User.findById(id),
+  Post.find({ authorId: id }),
+  Comment.find({ userId: id })
+]);
+```
+
+Reference: [Async/Await Best Practices](https://javascript.info/async-await)

package/skills/backend-best-practices/rules/perf-caching.md

@@ -0,0 +1,81 @@
+---
+title: Implement Caching Strategies
+impact: HIGH
+impactDescription: 70-95% reduction in response time for cached data
+tags: performance, caching, redis, optimization
+---
+
+## Implement Caching Strategies
+
+Use caching to reduce database load and improve response times for frequently accessed data.
+
+**Incorrect (no caching - hits database every time):**
+
+```javascript
+app.get('/api/products/:id', async (req, res) => {
+  // Queries database for every request
+  const product = await Product.findById(req.params.id);
+  res.json(product);
+});
+```
+
+**Correct (with Redis caching):**
+
+```javascript
+const redis = require('redis');
+const client = redis.createClient();
+
+app.get('/api/products/:id', async (req, res) => {
+  const cacheKey = `product:${req.params.id}`;
+  
+  // Try cache first
+  const cached = await client.get(cacheKey);
+  if (cached) {
+    return res.json(JSON.parse(cached));
+  }
+  
+  // If not in cache, query database
+  const product = await Product.findById(req.params.id);
+  
+  // Store in cache with 1 hour expiration
+  await client.setEx(cacheKey, 3600, JSON.stringify(product));
+  
+  res.json(product);
+});
+```
+
+**Cache Invalidation:**
+
+```javascript
+app.put('/api/products/:id', async (req, res) => {
+  const product = await Product.findByIdAndUpdate(
+    req.params.id,
+    req.body,
+    { new: true }
+  );
+  
+  // Invalidate cache
+  await client.del(`product:${req.params.id}`);
+  
+  res.json(product);
+});
+```
+
+**In-Memory Caching (node-cache):**
+
+```javascript
+const NodeCache = require('node-cache');
+const cache = new NodeCache({ stdTTL: 600 }); // 10 min default
+
+app.get('/api/stats', async (req, res) => {
+  const cached = cache.get('stats');
+  if (cached) return res.json(cached);
+  
+  const stats = await calculateStats(); // Expensive operation
+  cache.set('stats', stats);
+  
+  res.json(stats);
+});
+```
+
+Reference: [Caching Best Practices](https://aws.amazon.com/caching/best-practices/)