@persistadev/mcp-server 3.3.5 → 3.3.8

package/dist/knowledge-base.js

@@ -0,0 +1,1430 @@
+"use strict";
+/**
+ * PERSISTA KNOWLEDGE BASE v2.0
+ * ═══════════════════════════════════════════════════════════════
+ * A comprehensive collection of development knowledge including:
+ * - AI Prompts for every task
+ * - Design systems & tokens
+ * - Architecture patterns
+ * - Checklists for launch, security, a11y, code review
+ * - Code patterns & hooks
+ * - Boilerplates & templates
+ * - Workflows & processes
+ * - Best practices for every framework
+ * ═══════════════════════════════════════════════════════════════
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWLEDGE_BASE = void 0;
+exports.KNOWLEDGE_BASE = [
+    // ═══════════════════════════════════════════════════════════════
+    // 🎯 AI PROMPTS - Elite development prompts
+    // ═══════════════════════════════════════════════════════════════
+    // React Prompts
+    { domain: 'prompts', topic: 'react', update_type: 'prompt', title: 'Generate React Component', content: `Create a React component called [ComponentName] that:
+- Uses TypeScript with proper type definitions
+- Follows single responsibility principle  
+- Includes JSDoc comments for props
+- Uses CSS modules for styling
+- Handles loading, error, and empty states
+- Is accessible (ARIA labels, keyboard nav)
+- Includes basic unit test file
+
+Props needed: [describe]
+Functionality: [describe]` },
+    { domain: 'prompts', topic: 'react', update_type: 'prompt', title: 'Refactor React Component', content: `Refactor this React component to:
+1. Extract reusable logic into custom hooks
+2. Memoize expensive computations with useMemo
+3. Optimize re-renders with React.memo
+4. Split into smaller components if over 150 lines
+5. Add proper TypeScript types (no 'any')
+6. Improve accessibility
+7. Add error boundaries if needed
+
+Explain each change and why.` },
+    { domain: 'prompts', topic: 'react', update_type: 'prompt', title: 'Debug React Performance', content: `This React app is slow. Help debug:
+1. Identify unnecessary re-renders using React DevTools
+2. Find expensive computations to memoize
+3. Detect prop drilling that needs Context
+4. Spot missing keys in lists
+5. Find components to lazy load
+6. Check for memory leaks in useEffect
+
+For each issue: problem, why it's slow, fix with code.` },
+    { domain: 'prompts', topic: 'react', update_type: 'prompt', title: 'Create Custom Hook', content: `Create a custom React hook called [useName] that:
+- Follows the Rules of Hooks
+- Has proper TypeScript types
+- Handles cleanup in useEffect
+- Is reusable across components
+- Includes error handling
+- Has JSDoc documentation
+
+Purpose: [describe]
+Inputs: [describe]
+Returns: [describe]` },
+    { domain: 'prompts', topic: 'react', update_type: 'prompt', title: 'Convert Class to Function', content: `Convert this class component to a functional component:
+1. Replace state with useState
+2. Convert lifecycle methods to useEffect
+3. Move instance methods to useCallback
+4. Use useMemo for derived state
+5. Keep same external API
+6. Add TypeScript types
+7. Test behavior is identical` },
+    // TypeScript Prompts
+    { domain: 'prompts', topic: 'typescript', update_type: 'prompt', title: 'Type This JavaScript', content: `Convert this JavaScript to TypeScript:
+1. Add types for all variables, params, returns
+2. Create interfaces for complex objects
+3. Use generics where appropriate
+4. Add type guards for runtime checking
+5. Use strict null checks
+6. No 'any' - use 'unknown' if needed
+7. Export types consumers might need` },
+    { domain: 'prompts', topic: 'typescript', update_type: 'prompt', title: 'Create Type-Safe API', content: `Create a type-safe API client:
+1. Full TypeScript types for requests/responses
+2. Type-safe path params and query strings
+3. Proper error types and handling
+4. Generic fetch wrapper with JSON parsing
+5. Request/response interceptors
+6. Retry logic with exponential backoff
+7. Cancel token support` },
+    { domain: 'prompts', topic: 'typescript', update_type: 'prompt', title: 'Fix TypeScript Errors', content: `Fix these TypeScript errors:
+1. Explain what each error means
+2. Show the incorrect code
+3. Show the corrected code
+4. Explain why the fix works
+5. Suggest stricter types if applicable
+6. Check for potential runtime issues the types might miss` },
+    { domain: 'prompts', topic: 'typescript', update_type: 'prompt', title: 'Create Type Utilities', content: `Create TypeScript utility types for:
+1. DeepPartial<T> - all nested props optional
+2. DeepRequired<T> - all nested props required
+3. PickByType<T, U> - pick props of certain type
+4. Mutable<T> - remove readonly
+5. NonNullableProps<T> - remove null/undefined
+6. Include usage examples for each` },
+    // Next.js Prompts
+    { domain: 'prompts', topic: 'nextjs', update_type: 'prompt', title: 'Create Next.js Page', content: `Create a Next.js App Router page for [route]:
+1. Server Component by default
+2. Proper metadata export for SEO
+3. Loading state with loading.tsx
+4. Error handling with error.tsx
+5. generateStaticParams if dynamic
+6. Parallel data fetching
+7. Proper TypeScript types
+8. Accessible and responsive` },
+    { domain: 'prompts', topic: 'nextjs', update_type: 'prompt', title: 'Create Server Action', content: `Create a Next.js Server Action:
+1. 'use server' directive at top
+2. Zod validation for all inputs
+3. Proper error handling with try/catch
+4. Revalidate affected paths
+5. Return typed response
+6. Rate limiting consideration
+7. Auth check with getServerSession` },
+    { domain: 'prompts', topic: 'nextjs', update_type: 'prompt', title: 'Optimize Next.js App', content: `Optimize this Next.js app:
+1. Audit with next build --analyze
+2. Identify client vs server components
+3. Add dynamic imports for heavy components
+4. Optimize images with next/image
+5. Implement ISR where appropriate
+6. Add proper caching headers
+7. Check Core Web Vitals` },
+    // Database Prompts
+    { domain: 'prompts', topic: 'database', update_type: 'prompt', title: 'Design Database Schema', content: `Design a database schema for [feature]:
+1. Normalized (3NF unless justified)
+2. Proper foreign keys with ON DELETE
+3. Indexes for common queries
+4. Timestamps (created_at, updated_at)
+5. Soft delete if needed (deleted_at)
+6. UUID primary keys
+7. RLS policies for Supabase
+
+Output as SQL CREATE statements with comments.` },
+    { domain: 'prompts', topic: 'database', update_type: 'prompt', title: 'Optimize SQL Query', content: `Optimize this SQL query:
+1. Analyze with EXPLAIN ANALYZE
+2. Check for missing indexes
+3. Identify N+1 patterns
+4. Consider denormalization trade-offs
+5. Suggest pagination if large result
+6. Check for proper JOIN types
+7. Show before/after performance` },
+    { domain: 'prompts', topic: 'database', update_type: 'prompt', title: 'Write Supabase RLS', content: `Write Row Level Security policies for [table]:
+1. Enable RLS first
+2. SELECT policy for read access
+3. INSERT policy with auth checks
+4. UPDATE policy scoped to owner
+5. DELETE policy if needed
+6. Consider service role bypass
+7. Test each policy` },
+    // Code Review Prompts
+    { domain: 'prompts', topic: 'review', update_type: 'prompt', title: 'Full Code Review', content: `Review this code thoroughly:
+
+## Security
+- SQL injection, XSS, CSRF
+- Data exposure, auth issues
+- Secrets in code
+
+## Performance
+- N+1 queries, missing indexes
+- Memory leaks, bundle size
+- Unnecessary re-renders
+
+## Maintainability
+- Naming conventions
+- Single responsibility
+- DRY violations
+- Code complexity (cyclomatic)
+
+## TypeScript
+- No 'any' usage
+- Proper null handling
+- Correct generic usage
+
+Provide specific line-by-line feedback with fixes.` },
+    { domain: 'prompts', topic: 'review', update_type: 'prompt', title: 'Security Audit', content: `Security audit this code:
+1. Authentication vulnerabilities
+2. Authorization bypass risks
+3. Input validation gaps
+4. Output encoding issues
+5. Sensitive data exposure
+6. Dependency vulnerabilities
+7. Error message information leaks
+
+For each issue: severity, impact, fix.` },
+    // Debugging Prompts
+    { domain: 'prompts', topic: 'debugging', update_type: 'prompt', title: 'Debug This Error', content: `Debug this error:
+
+Error: [paste error]
+Context: [what you were doing]
+Environment: [dev/prod, versions]
+
+1. Explain what this error means
+2. List most common causes (ranked by likelihood)
+3. Debugging steps to find root cause
+4. Give fix with code example
+5. How to prevent this in future` },
+    { domain: 'prompts', topic: 'debugging', update_type: 'prompt', title: 'Debug Memory Leak', content: `This app has a memory leak. Help find it:
+1. How to profile memory in Chrome DevTools
+2. Common React memory leak patterns
+3. Event listener cleanup
+4. Subscription cleanup
+5. Timer cleanup
+6. DOM reference cleanup
+7. Show fix for each pattern` },
+    { domain: 'prompts', topic: 'debugging', update_type: 'prompt', title: 'Debug Slow Page', content: `This page is slow. Diagnose:
+1. Run Lighthouse audit
+2. Check Network tab for slow requests
+3. Look for layout thrashing
+4. Find large JavaScript bundles
+5. Identify render-blocking resources
+6. Check for hydration issues
+7. Prioritize fixes by impact` },
+    // Testing Prompts
+    { domain: 'prompts', topic: 'testing', update_type: 'prompt', title: 'Write Unit Tests', content: `Write unit tests for this code:
+1. Test happy path
+2. Test edge cases
+3. Test error handling
+4. Mock external dependencies
+5. Use describe/it structure
+6. Aim for high coverage
+7. Use meaningful test names
+
+Framework: Jest + React Testing Library` },
+    { domain: 'prompts', topic: 'testing', update_type: 'prompt', title: 'Write E2E Tests', content: `Write E2E tests for this feature:
+1. User flows to test
+2. Setup/teardown database state
+3. Mock external APIs
+4. Test happy path
+5. Test error states
+6. Test edge cases
+7. Keep tests independent
+
+Framework: Playwright` },
+    // Architecture Prompts
+    { domain: 'prompts', topic: 'architecture', update_type: 'prompt', title: 'Design System Architecture', content: `Design the architecture for [system]:
+1. Requirements analysis
+2. Component breakdown
+3. Data flow diagram
+4. API design
+5. Database schema
+6. Deployment strategy
+7. Scalability considerations
+8. Security measures
+9. Monitoring plan` },
+    { domain: 'prompts', topic: 'architecture', update_type: 'prompt', title: 'Microservices Design', content: `Design microservices for [domain]:
+1. Service boundaries (DDD approach)
+2. Communication patterns (sync/async)
+3. Data ownership
+4. API contracts
+5. Event-driven patterns
+6. Service discovery
+7. Fault tolerance
+8. Deployment topology` },
+    // ═══════════════════════════════════════════════════════════════
+    // 🎨 DESIGN SYSTEMS
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'design', topic: 'colors', update_type: 'design_system', title: 'Modern SaaS Light Palette', content: `:root {
+  /* Primary */
+  --primary-50: #faf5ff;
+  --primary-100: #f3e8ff;
+  --primary-200: #e9d5ff;
+  --primary-500: #a855f7;
+  --primary-600: #9333ea;
+  --primary-700: #7e22ce;
+  
+  /* Neutrals */
+  --gray-50: #f8fafc;
+  --gray-100: #f1f5f9;
+  --gray-200: #e2e8f0;
+  --gray-300: #cbd5e1;
+  --gray-400: #94a3b8;
+  --gray-500: #64748b;
+  --gray-600: #475569;
+  --gray-700: #334155;
+  --gray-800: #1e293b;
+  --gray-900: #0f172a;
+  
+  /* Semantic */
+  --success: #10b981;
+  --warning: #f59e0b;
+  --error: #ef4444;
+  --info: #3b82f6;
+}` },
+    { domain: 'design', topic: 'colors', update_type: 'design_system', title: 'Dark Mode Palette', content: `[data-theme="dark"] {
+  --bg-primary: #09090b;
+  --bg-secondary: #18181b;
+  --bg-tertiary: #27272a;
+  --bg-elevated: #3f3f46;
+  
+  --text-primary: #fafafa;
+  --text-secondary: #a1a1aa;
+  --text-muted: #71717a;
+  
+  --border-subtle: #27272a;
+  --border-default: #3f3f46;
+  --border-strong: #52525b;
+  
+  --accent: #a855f7;
+  --accent-hover: #9333ea;
+  
+  /* Adjust semantic colors for dark */
+  --success: #34d399;
+  --warning: #fbbf24;
+  --error: #f87171;
+  --info: #60a5fa;
+}` },
+    { domain: 'design', topic: 'typography', update_type: 'design_system', title: 'Typography Scale', content: `:root {
+  /* Font Families */
+  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  --font-mono: 'JetBrains Mono', 'Fira Code', monospace;
+  --font-display: 'Cal Sans', 'Inter', sans-serif;
+  
+  /* Size Scale (rem) */
+  --text-xs: 0.75rem;    /* 12px */
+  --text-sm: 0.875rem;   /* 14px */
+  --text-base: 1rem;     /* 16px */
+  --text-lg: 1.125rem;   /* 18px */
+  --text-xl: 1.25rem;    /* 20px */
+  --text-2xl: 1.5rem;    /* 24px */
+  --text-3xl: 1.875rem;  /* 30px */
+  --text-4xl: 2.25rem;   /* 36px */
+  --text-5xl: 3rem;      /* 48px */
+  
+  /* Line Heights */
+  --leading-none: 1;
+  --leading-tight: 1.25;
+  --leading-snug: 1.375;
+  --leading-normal: 1.5;
+  --leading-relaxed: 1.625;
+  
+  /* Font Weights */
+  --font-normal: 400;
+  --font-medium: 500;
+  --font-semibold: 600;
+  --font-bold: 700;
+}` },
+    { domain: 'design', topic: 'spacing', update_type: 'design_system', title: 'Spacing & Layout', content: `:root {
+  /* Spacing Scale */
+  --space-0: 0;
+  --space-1: 0.25rem;   /* 4px */
+  --space-2: 0.5rem;    /* 8px */
+  --space-3: 0.75rem;   /* 12px */
+  --space-4: 1rem;      /* 16px */
+  --space-5: 1.25rem;   /* 20px */
+  --space-6: 1.5rem;    /* 24px */
+  --space-8: 2rem;      /* 32px */
+  --space-10: 2.5rem;   /* 40px */
+  --space-12: 3rem;     /* 48px */
+  --space-16: 4rem;     /* 64px */
+  --space-20: 5rem;     /* 80px */
+  
+  /* Border Radius */
+  --radius-sm: 4px;
+  --radius-md: 8px;
+  --radius-lg: 12px;
+  --radius-xl: 16px;
+  --radius-2xl: 24px;
+  --radius-full: 9999px;
+  
+  /* Shadows */
+  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+  --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+  --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
+  --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.1);
+  --shadow-2xl: 0 25px 50px -12px rgb(0 0 0 / 0.25);
+}` },
+    { domain: 'design', topic: 'animations', update_type: 'design_system', title: 'Animation Tokens', content: `:root {
+  /* Durations */
+  --duration-fast: 150ms;
+  --duration-normal: 200ms;
+  --duration-slow: 300ms;
+  --duration-slower: 500ms;
+  
+  /* Easings */
+  --ease-in: cubic-bezier(0.4, 0, 1, 1);
+  --ease-out: cubic-bezier(0, 0, 0.2, 1);
+  --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
+  --ease-bounce: cubic-bezier(0.68, -0.55, 0.265, 1.55);
+  
+  /* Common Transitions */
+  --transition-colors: color var(--duration-fast) var(--ease-in-out),
+                       background-color var(--duration-fast) var(--ease-in-out),
+                       border-color var(--duration-fast) var(--ease-in-out);
+  --transition-transform: transform var(--duration-normal) var(--ease-out);
+  --transition-opacity: opacity var(--duration-normal) var(--ease-in-out);
+  --transition-all: all var(--duration-normal) var(--ease-in-out);
+}
+
+/* Keyframes */
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes slideUp {
+  from { opacity: 0; transform: translateY(10px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+@keyframes pulse {
+  50% { opacity: 0.5; }
+}` },
+    { domain: 'design', topic: 'components', update_type: 'design_system', title: 'Button Variants', content: `.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--space-2);
+  padding: var(--space-2) var(--space-4);
+  font-size: var(--text-sm);
+  font-weight: var(--font-medium);
+  border-radius: var(--radius-md);
+  transition: var(--transition-colors);
+  cursor: pointer;
+}
+
+.btn-primary {
+  background: var(--primary-600);
+  color: white;
+  border: none;
+}
+.btn-primary:hover { background: var(--primary-700); }
+
+.btn-secondary {
+  background: transparent;
+  color: var(--gray-700);
+  border: 1px solid var(--gray-300);
+}
+.btn-secondary:hover { background: var(--gray-50); }
+
+.btn-ghost {
+  background: transparent;
+  color: var(--gray-600);
+  border: none;
+}
+.btn-ghost:hover { background: var(--gray-100); }
+
+.btn-danger {
+  background: var(--error);
+  color: white;
+  border: none;
+}
+.btn-danger:hover { background: #dc2626; }` },
+    // ═══════════════════════════════════════════════════════════════
+    // 📁 ARCHITECTURE
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'architecture', topic: 'react', update_type: 'architecture', title: 'React Project Structure', content: `src/
+├── components/
+│   ├── ui/              # Reusable UI (Button, Input, Modal)
+│   ├── features/        # Feature-specific components
+│   ├── layouts/         # Layout components
+│   └── providers/       # Context providers
+├── hooks/               # Custom hooks
+├── lib/
+│   ├── api.ts           # API client
+│   ├── utils.ts         # Utility functions
+│   └── constants.ts     # App constants
+├── stores/              # State management (Zustand/Jotai)
+├── types/               # TypeScript types
+├── styles/              # Global CSS, themes
+└── app/ or pages/       # Routes` },
+    { domain: 'architecture', topic: 'nextjs', update_type: 'architecture', title: 'Next.js App Router Structure', content: `app/
+├── (marketing)/         # Marketing pages (landing, pricing)
+│   ├── page.tsx
+│   └── layout.tsx
+├── (auth)/              # Auth pages (login, register)
+│   ├── login/
+│   ├── register/
+│   └── layout.tsx
+├── (dashboard)/         # Protected dashboard
+│   ├── dashboard/
+│   ├── settings/
+│   └── layout.tsx       # With auth check
+├── api/                 # API routes
+│   └── [...route]/
+├── globals.css
+├── layout.tsx           # Root layout
+└── not-found.tsx
+
+Key Conventions:
+(folder) = Route group (no URL impact)
+[folder] = Dynamic route
+@folder = Parallel route
+loading.tsx = Suspense boundary
+error.tsx = Error boundary
+template.tsx = Re-render on nav` },
+    { domain: 'architecture', topic: 'api', update_type: 'architecture', title: 'REST API Design', content: `# Endpoints
+GET    /api/users              # List (paginated)
+POST   /api/users              # Create
+GET    /api/users/:id          # Get one
+PUT    /api/users/:id          # Replace
+PATCH  /api/users/:id          # Partial update
+DELETE /api/users/:id          # Delete
+
+# Query Parameters
+?page=1&limit=20              # Pagination
+?sort=-created_at             # Sort (- = desc)
+?filter[status]=active        # Filter
+?include=posts,comments       # Relations
+?fields=id,name,email         # Sparse fields
+
+# Response Format
+{
+  "data": [...],
+  "meta": {
+    "total": 100,
+    "page": 1,
+    "limit": 20,
+    "pages": 5
+  }
+}
+
+# Error Format
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Invalid input",
+    "details": [...]
+  }
+}` },
+    { domain: 'architecture', topic: 'monorepo', update_type: 'architecture', title: 'Monorepo Structure (Turborepo)', content: `monorepo/
+├── apps/
+│   ├── web/              # Next.js frontend
+│   ├── api/              # Backend service
+│   ├── admin/            # Admin dashboard
+│   └── docs/             # Documentation
+├── packages/
+│   ├── ui/               # Shared UI components
+│   ├── config/           # Shared configs (ESLint, TS)
+│   ├── database/         # Prisma/Drizzle schema
+│   └── utils/            # Shared utilities
+├── turbo.json            # Turborepo config
+├── package.json          # Root package.json
+└── pnpm-workspace.yaml   # Workspace config
+
+Benefits:
+- Shared code between apps
+- Atomic changes across packages
+- Consistent tooling
+- Faster builds with caching` },
+    { domain: 'architecture', topic: 'clean', update_type: 'architecture', title: 'Clean Architecture Layers', content: `# Layer Structure
+
+## 1. Domain (innermost)
+- Entities: Core business objects
+- Value Objects: Immutable objects
+- Domain Events: Business events
+- No external dependencies
+
+## 2. Application
+- Use Cases: Application-specific logic
+- Interfaces: Ports for adapters
+- DTOs: Data transfer objects
+- Depends only on Domain
+
+## 3. Infrastructure (outermost)
+- Repositories: Data access implementation
+- External Services: APIs, email, etc.
+- Framework Code: Express, Next.js
+- Implements Application interfaces
+
+## 4. Presentation
+- Controllers: HTTP handlers
+- Views: UI components
+- Presenters: Format data for views
+
+# Dependency Rule
+Dependencies point inward only.
+Inner layers don't know about outer layers.` },
+    // ═══════════════════════════════════════════════════════════════
+    // ✅ CHECKLISTS
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'checklist', topic: 'launch', update_type: 'checklist', title: 'Production Launch Checklist', content: `## Performance
+- [ ] Lighthouse score > 90
+- [ ] Images optimized (WebP, lazy loading)
+- [ ] Bundle size analyzed and optimized
+- [ ] Core Web Vitals passing
+- [ ] CDN configured
+
+## SEO
+- [ ] Meta tags on all pages
+- [ ] Open Graph tags for social
+- [ ] Sitemap.xml generated
+- [ ] robots.txt configured
+- [ ] Canonical URLs set
+- [ ] Schema.org markup
+
+## Security
+- [ ] HTTPS enforced
+- [ ] Security headers (CSP, HSTS)
+- [ ] Rate limiting enabled
+- [ ] Input validation everywhere
+- [ ] SQL injection prevented
+- [ ] XSS prevented
+
+## Monitoring
+- [ ] Error tracking (Sentry)
+- [ ] Analytics (Plausible/GA)
+- [ ] Uptime monitoring
+- [ ] Performance monitoring
+- [ ] Log aggregation
+
+## Backups & Recovery
+- [ ] Database backups automated
+- [ ] Backup restore tested
+- [ ] Disaster recovery plan
+
+## Legal
+- [ ] Privacy Policy
+- [ ] Terms of Service
+- [ ] Cookie consent (GDPR)
+- [ ] Accessibility statement` },
+    { domain: 'checklist', topic: 'security', update_type: 'checklist', title: 'Security Audit Checklist', content: `## Authentication
+- [ ] Passwords hashed (bcrypt/argon2)
+- [ ] MFA available
+- [ ] Session timeout configured
+- [ ] Account lockout after failed attempts
+- [ ] Password strength requirements
+- [ ] Secure password reset flow
+
+## Authorization
+- [ ] Role-based access control
+- [ ] Resource-level permissions
+- [ ] JWT/session validation
+- [ ] API key rotation
+
+## Data Protection
+- [ ] Encryption at rest
+- [ ] TLS 1.3 in transit
+- [ ] PII handling compliant
+- [ ] Data retention policy
+- [ ] Audit logs enabled
+
+## Input/Output
+- [ ] All input validated
+- [ ] SQL injection prevented
+- [ ] XSS prevented (output encoding)
+- [ ] CSRF tokens implemented
+- [ ] File upload restrictions
+
+## Infrastructure
+- [ ] Secrets in env vars/vault
+- [ ] Dependencies updated
+- [ ] Vulnerability scanning (npm audit)
+- [ ] Firewall configured
+- [ ] DDoS protection` },
+    { domain: 'checklist', topic: 'a11y', update_type: 'checklist', title: 'Accessibility (WCAG 2.1)', content: `## Perceivable
+- [ ] All images have alt text
+- [ ] Videos have captions
+- [ ] Audio has transcripts
+- [ ] Color contrast ≥ 4.5:1 (AA)
+- [ ] Text resizable to 200%
+- [ ] Content reflows at 320px
+
+## Operable
+- [ ] All functions keyboard accessible
+- [ ] Focus indicators visible
+- [ ] Skip to main content link
+- [ ] Touch targets ≥ 44px
+- [ ] No keyboard traps
+- [ ] Page titles descriptive
+- [ ] Focus order logical
+
+## Understandable
+- [ ] Language attribute set
+- [ ] Form labels associated
+- [ ] Error messages descriptive
+- [ ] Required fields indicated
+- [ ] Consistent navigation
+
+## Robust
+- [ ] Valid HTML
+- [ ] ARIA used correctly
+- [ ] Screen reader tested (NVDA/VoiceOver)
+- [ ] Automated testing (axe)
+- [ ] Manual testing completed` },
+    { domain: 'checklist', topic: 'code-review', update_type: 'checklist', title: 'Code Review Checklist', content: `## Functionality
+- [ ] Code does what PR description says
+- [ ] Edge cases handled
+- [ ] Error handling appropriate
+- [ ] No broken functionality elsewhere
+
+## Code Quality
+- [ ] DRY - no duplication
+- [ ] Single responsibility
+- [ ] Meaningful names
+- [ ] No magic numbers
+- [ ] Comments explain "why", not "what"
+- [ ] No console.log / debugger
+
+## TypeScript
+- [ ] No any types
+- [ ] Proper null/undefined handling
+- [ ] Types exported for consumers
+- [ ] Generics used appropriately
+
+## Testing
+- [ ] Unit tests for new code
+- [ ] Tests actually test behavior
+- [ ] Edge cases tested
+- [ ] No skipped tests
+
+## Security
+- [ ] No secrets in code
+- [ ] User input validated
+- [ ] SQL injection prevented
+- [ ] XSS prevented
+- [ ] Auth checks present
+
+## Performance
+- [ ] No N+1 queries
+- [ ] Large lists paginated
+- [ ] Expensive operations memoized
+- [ ] Bundle impact considered` },
+    { domain: 'checklist', topic: 'pr', update_type: 'checklist', title: 'PR Submission Checklist', content: `## Before Opening PR
+- [ ] Code compiles without errors
+- [ ] All tests passing
+- [ ] Linter passes
+- [ ] Self-reviewed changes
+- [ ] Removed debug code/console.logs
+- [ ] Branch up to date with main
+
+## PR Description
+- [ ] Clear title (type: description)
+- [ ] Description explains WHAT changed
+- [ ] Description explains WHY
+- [ ] Screenshots/video for UI changes
+- [ ] Breaking changes noted
+- [ ] Migration steps if needed
+
+## Testing
+- [ ] Tested locally
+- [ ] Added/updated tests
+- [ ] Tested edge cases
+- [ ] Tested on mobile (if UI)
+
+## Documentation
+- [ ] README updated if needed
+- [ ] API docs updated if needed
+- [ ] CHANGELOG updated
+- [ ] Comments added for complex logic
+
+## Size
+- [ ] PR is focused (one concern)
+- [ ] < 400 lines (ideal)
+- [ ] Large PRs split if possible` },
+    { domain: 'checklist', topic: 'api', update_type: 'checklist', title: 'API Endpoint Checklist', content: `## Design
+- [ ] RESTful naming conventions
+- [ ] Proper HTTP methods
+- [ ] Consistent response format
+- [ ] Pagination for lists
+- [ ] Versioning strategy
+
+## Validation
+- [ ] Request body validated
+- [ ] Query params validated
+- [ ] Path params validated
+- [ ] File uploads restricted
+
+## Security
+- [ ] Authentication required
+- [ ] Authorization checked
+- [ ] Rate limiting enabled
+- [ ] Input sanitized
+- [ ] Sensitive data filtered from logs
+
+## Error Handling
+- [ ] Proper HTTP status codes
+- [ ] Consistent error format
+- [ ] No stack traces in production
+- [ ] Errors logged server-side
+
+## Documentation
+- [ ] OpenAPI/Swagger spec
+- [ ] Request/response examples
+- [ ] Error codes documented
+- [ ] Rate limits documented
+
+## Testing
+- [ ] Unit tests for logic
+- [ ] Integration tests for API
+- [ ] Load testing done
+- [ ] Security testing done` },
+    // ═══════════════════════════════════════════════════════════════
+    // 🔧 CODE PATTERNS
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'patterns', topic: 'react', update_type: 'code_pattern', title: 'useAsync Hook', content: `import { useState, useCallback } from 'react';
+
+interface AsyncState<T> {
+  data: T | null;
+  error: Error | null;
+  isLoading: boolean;
+}
+
+export function useAsync<T>() {
+  const [state, setState] = useState<AsyncState<T>>({
+    data: null,
+    error: null,
+    isLoading: false,
+  });
+
+  const execute = useCallback(async (promise: Promise<T>) => {
+    setState({ data: null, error: null, isLoading: true });
+    try {
+      const data = await promise;
+      setState({ data, error: null, isLoading: false });
+      return data;
+    } catch (error) {
+      setState({ data: null, error: error as Error, isLoading: false });
+      throw error;
+    }
+  }, []);
+
+  const reset = useCallback(() => {
+    setState({ data: null, error: null, isLoading: false });
+  }, []);
+
+  return { ...state, execute, reset };
+}` },
+    { domain: 'patterns', topic: 'react', update_type: 'code_pattern', title: 'useDebounce Hook', content: `import { useState, useEffect } from 'react';
+
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+
+  return debouncedValue;
+}
+
+// Usage
+const [searchTerm, setSearchTerm] = useState('');
+const debouncedSearch = useDebounce(searchTerm, 300);
+
+useEffect(() => {
+  if (debouncedSearch) {
+    // Make API call
+  }
+}, [debouncedSearch]);` },
+    { domain: 'patterns', topic: 'react', update_type: 'code_pattern', title: 'useLocalStorage Hook', content: `import { useState, useEffect } from 'react';
+
+export function useLocalStorage<T>(
+  key: string,
+  initialValue: T
+): [T, (value: T | ((prev: T) => T)) => void] {
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    if (typeof window === 'undefined') return initialValue;
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch {
+      return initialValue;
+    }
+  });
+
+  const setValue = (value: T | ((prev: T) => T)) => {
+    try {
+      const valueToStore = value instanceof Function 
+        ? value(storedValue) 
+        : value;
+      setStoredValue(valueToStore);
+      if (typeof window !== 'undefined') {
+        window.localStorage.setItem(key, JSON.stringify(valueToStore));
+      }
+    } catch (error) {
+      console.error('useLocalStorage error:', error);
+    }
+  };
+
+  return [storedValue, setValue];
+}` },
+    { domain: 'patterns', topic: 'typescript', update_type: 'code_pattern', title: 'Type-Safe Fetch', content: `type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+interface RequestConfig {
+  headers?: Record<string, string>;
+  params?: Record<string, string>;
+}
+
+async function request<T>(
+  method: HttpMethod,
+  url: string,
+  data?: unknown,
+  config?: RequestConfig
+): Promise<T> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...config?.headers,
+  };
+
+  const queryString = config?.params
+    ? '?' + new URLSearchParams(config.params).toString()
+    : '';
+
+  const response = await fetch(url + queryString, {
+    method,
+    headers,
+    body: data ? JSON.stringify(data) : undefined,
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new ApiError(response.status, error.message || response.statusText);
+  }
+
+  return response.json();
+}
+
+export const api = {
+  get: <T>(url: string, config?: RequestConfig) => 
+    request<T>('GET', url, undefined, config),
+  post: <T>(url: string, data: unknown, config?: RequestConfig) => 
+    request<T>('POST', url, data, config),
+  put: <T>(url: string, data: unknown, config?: RequestConfig) => 
+    request<T>('PUT', url, data, config),
+  delete: <T>(url: string, config?: RequestConfig) => 
+    request<T>('DELETE', url, undefined, config),
+};` },
+    { domain: 'patterns', topic: 'typescript', update_type: 'code_pattern', title: 'Result Type (No Throws)', content: `type Result<T, E = Error> = 
+  | { ok: true; value: T }
+  | { ok: false; error: E };
+
+function Ok<T>(value: T): Result<T, never> {
+  return { ok: true, value };
+}
+
+function Err<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+// Usage
+async function fetchUser(id: string): Promise<Result<User, string>> {
+  try {
+    const response = await fetch(\`/api/users/\${id}\`);
+    if (!response.ok) {
+      return Err('User not found');
+    }
+    const user = await response.json();
+    return Ok(user);
+  } catch {
+    return Err('Network error');
+  }
+}
+
+// Consuming
+const result = await fetchUser('123');
+if (result.ok) {
+  console.log(result.value); // User
+} else {
+  console.error(result.error); // string
+}` },
+    { domain: 'patterns', topic: 'react', update_type: 'code_pattern', title: 'Compound Component Pattern', content: `import { createContext, useContext, useState, ReactNode } from 'react';
+
+// Context
+interface TabsContextValue {
+  activeTab: string;
+  setActiveTab: (tab: string) => void;
+}
+
+const TabsContext = createContext<TabsContextValue | null>(null);
+
+function useTabsContext() {
+  const context = useContext(TabsContext);
+  if (!context) throw new Error('Must be used within Tabs');
+  return context;
+}
+
+// Root
+interface TabsProps {
+  defaultTab: string;
+  children: ReactNode;
+}
+
+function Tabs({ defaultTab, children }: TabsProps) {
+  const [activeTab, setActiveTab] = useState(defaultTab);
+  return (
+    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
+      <div className="tabs">{children}</div>
+    </TabsContext.Provider>
+  );
+}
+
+// Tab Trigger
+function TabTrigger({ value, children }: { value: string; children: ReactNode }) {
+  const { activeTab, setActiveTab } = useTabsContext();
+  return (
+    <button
+      className={\`tab \${activeTab === value ? 'active' : ''}\`}
+      onClick={() => setActiveTab(value)}
+    >
+      {children}
+    </button>
+  );
+}
+
+// Tab Content
+function TabContent({ value, children }: { value: string; children: ReactNode }) {
+  const { activeTab } = useTabsContext();
+  if (activeTab !== value) return null;
+  return <div className="tab-content">{children}</div>;
+}
+
+// Attach components
+Tabs.Trigger = TabTrigger;
+Tabs.Content = TabContent;
+
+export { Tabs };` },
+    // ═══════════════════════════════════════════════════════════════
+    // 🚀 BOILERPLATES
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'boilerplate', topic: 'react', update_type: 'boilerplate', title: 'React Component Template', content: `import { memo, forwardRef, ComponentPropsWithRef } from 'react';
+import styles from './ComponentName.module.css';
+
+export interface ComponentNameProps extends ComponentPropsWithRef<'div'> {
+  /** Description of the variant prop */
+  variant?: 'default' | 'primary' | 'secondary';
+  /** Whether the component is loading */
+  isLoading?: boolean;
+}
+
+/**
+ * ComponentName - Brief description
+ * 
+ * @example
+ * <ComponentName variant="primary">Content</ComponentName>
+ */
+export const ComponentName = memo(forwardRef<HTMLDivElement, ComponentNameProps>(
+  function ComponentName(
+    { variant = 'default', isLoading = false, className, children, ...props },
+    ref
+  ) {
+    if (isLoading) {
+      return <div className={styles.skeleton} />;
+    }
+
+    return (
+      <div
+        ref={ref}
+        className={\`\${styles.root} \${styles[variant]} \${className || ''}\`}
+        {...props}
+      >
+        {children}
+      </div>
+    );
+  }
+));` },
+    { domain: 'boilerplate', topic: 'nextjs', update_type: 'boilerplate', title: 'Next.js API Route Template', content: `import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth';
+
+const RequestSchema = z.object({
+  name: z.string().min(1).max(100),
+  email: z.string().email(),
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    // Auth check
+    const session = await getServerSession(authOptions);
+    if (!session) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      );
+    }
+
+    // Validate body
+    const body = await request.json();
+    const data = RequestSchema.parse(body);
+
+    // Business logic
+    const result = await createSomething(data);
+
+    return NextResponse.json(result, { status: 201 });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Validation error', details: error.errors },
+        { status: 400 }
+      );
+    }
+    
+    console.error('API Error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}` },
+    { domain: 'boilerplate', topic: 'nextjs', update_type: 'boilerplate', title: 'Next.js Server Action Template', content: `'use server';
+
+import { z } from 'zod';
+import { revalidatePath } from 'next/cache';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth';
+
+const FormSchema = z.object({
+  title: z.string().min(1, 'Title is required').max(100),
+  content: z.string().min(10, 'Content too short'),
+});
+
+export type FormState = {
+  errors?: {
+    title?: string[];
+    content?: string[];
+  };
+  message?: string;
+  success?: boolean;
+};
+
+export async function createPost(
+  prevState: FormState,
+  formData: FormData
+): Promise<FormState> {
+  // Auth
+  const session = await getServerSession(authOptions);
+  if (!session?.user?.id) {
+    return { message: 'Unauthorized', success: false };
+  }
+
+  // Validate
+  const validatedFields = FormSchema.safeParse({
+    title: formData.get('title'),
+    content: formData.get('content'),
+  });
+
+  if (!validatedFields.success) {
+    return {
+      errors: validatedFields.error.flatten().fieldErrors,
+      message: 'Invalid fields',
+      success: false,
+    };
+  }
+
+  try {
+    // Create
+    await db.post.create({
+      data: {
+        ...validatedFields.data,
+        userId: session.user.id,
+      },
+    });
+
+    revalidatePath('/posts');
+    return { message: 'Post created!', success: true };
+  } catch {
+    return { message: 'Database error', success: false };
+  }
+}` },
+    { domain: 'boilerplate', topic: 'testing', update_type: 'boilerplate', title: 'Jest Test Template', content: `import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ComponentName } from './ComponentName';
+
+describe('ComponentName', () => {
+  const defaultProps = {
+    onSubmit: jest.fn(),
+    initialValue: 'test',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders correctly', () => {
+    render(<ComponentName {...defaultProps} />);
+    expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('handles click events', async () => {
+    const user = userEvent.setup();
+    render(<ComponentName {...defaultProps} />);
+    
+    await user.click(screen.getByRole('button'));
+    
+    expect(defaultProps.onSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows error state', () => {
+    render(<ComponentName {...defaultProps} error="Something went wrong" />);
+    expect(screen.getByText(/something went wrong/i)).toBeInTheDocument();
+  });
+
+  it('handles async operations', async () => {
+    render(<ComponentName {...defaultProps} />);
+    
+    fireEvent.click(screen.getByRole('button'));
+    
+    await waitFor(() => {
+      expect(screen.getByText(/success/i)).toBeInTheDocument();
+    });
+  });
+});` },
+    // ═══════════════════════════════════════════════════════════════
+    // 🔄 WORKFLOWS
+    // ═══════════════════════════════════════════════════════════════
+    { domain: 'workflow', topic: 'feature', update_type: 'workflow', title: 'Feature Development Flow', content: `1. PLAN
+   - Write user story with acceptance criteria
+   - Break into subtasks
+   - Estimate complexity
+   - Identify dependencies
+
+2. DESIGN
+   - API contract (if backend)
+   - Component hierarchy (if frontend)
+   - Database changes (if needed)
+   - Get design review
+
+3. IMPLEMENT
+   - Create feature branch
+   - Write tests first (TDD)
+   - Implement in small commits
+   - Keep PR focused
+
+4. TEST
+   - Run unit tests
+   - Run integration tests
+   - Manual testing
+   - Cross-browser testing (if UI)
+
+5. REVIEW
+   - Self-review first
+   - Open PR with description
+   - Address feedback promptly
+   - Get approval
+
+6. DEPLOY
+   - Merge to main
+   - Verify in staging
+   - Deploy to production
+   - Monitor for errors
+
+7. DOCUMENT
+   - Update README if needed
+   - Update API docs
+   - Add to changelog` },
+    { domain: 'workflow', topic: 'debugging', update_type: 'workflow', title: 'Systematic Debugging', content: `1. REPRODUCE
+   - What are the exact steps?
+   - What environment? (browser, OS, versions)
+   - Is it consistent or intermittent?
+   - Can you reproduce locally?
+
+2. ISOLATE
+   - When did it start working/breaking?
+   - Frontend or backend issue?
+   - Which specific component/function?
+   - Narrow down with binary search
+
+3. GATHER EVIDENCE
+   - Console errors
+   - Network requests/responses
+   - Server logs
+   - Error tracking (Sentry)
+   - Database state
+
+4. HYPOTHESIZE
+   - List top 3 likely causes
+   - Rank by probability
+   - Start with simplest explanation
+
+5. TEST HYPOTHESES
+   - Add logging/breakpoints
+   - Change ONE thing at a time
+   - Verify assumptions
+   - Don't skip steps
+
+6. FIX
+   - Implement minimal fix
+   - Verify fix works
+   - Check for side effects
+   - Add regression test
+
+7. PREVENT
+   - Why wasn't this caught earlier?
+   - Add monitoring/alerting?
+   - Improve error handling?
+   - Document for team` },
+    { domain: 'workflow', topic: 'code-review', update_type: 'workflow', title: 'Effective Code Review', content: `## As Author
+
+BEFORE SUBMITTING:
+1. Self-review your changes first
+2. Run all tests locally
+3. Check linting passes
+4. Write clear PR description
+5. Add screenshots for UI changes
+6. Keep PR < 400 lines if possible
+
+DURING REVIEW:
+1. Respond to all comments
+2. Don't take feedback personally
+3. Explain your reasoning
+4. Make requested changes promptly
+5. Re-request review when ready
+
+## As Reviewer
+
+FIRST PASS (5 min):
+1. Understand the goal from PR description
+2. Check PR size is reasonable
+3. Look at file structure changes
+4. Identify areas of concern
+
+DETAILED REVIEW:
+1. Check logic and edge cases
+2. Look for security issues
+3. Check error handling
+4. Verify tests cover changes
+5. Check code style consistency
+
+GIVING FEEDBACK:
+1. Be specific, not vague
+2. Explain the "why"
+3. Suggest alternatives
+4. Distinguish must-fix vs nice-to-have
+5. Praise good patterns
+6. Use conventional comments (nit:, blocking:)` },
+    { domain: 'workflow', topic: 'incident', update_type: 'workflow', title: 'Incident Response', content: `1. DETECT
+   - Monitoring alert
+   - User report
+   - Automated test failure
+
+2. TRIAGE (5 min)
+   - Assess severity (P1-P4)
+   - Estimate impact (users affected)
+   - Assign incident commander
+   - Start incident channel
+
+3. MITIGATE (ASAP)
+   - Can we rollback?
+   - Can we feature flag off?
+   - Can we scale up?
+   - Communicate status to stakeholders
+
+4. INVESTIGATE
+   - Gather logs and metrics
+   - Identify timeline of events
+   - Find root cause
+   - Document findings
+
+5. FIX
+   - Implement permanent fix
+   - Test thoroughly
+   - Deploy with monitoring
+   - Verify resolution
+
+6. COMMUNICATE
+   - Update status page
+   - Notify affected users
+   - Internal update
+
+7. POST-MORTEM
+   - Blameless analysis
+   - Document timeline
+   - Identify improvements
+   - Create action items
+   - Share learnings` },
+    // ═══════════════════════════════════════════════════════════════
+    // 💡 BEST PRACTICES
+    // ═══════════════════════════════════════════════════════════════
+    // React
+    { domain: 'react', topic: 'performance', update_type: 'best_practice', title: 'Use React.memo() wisely', content: 'Wrap components with stable props but expensive render logic. Avoid for components with frequently changing props as the comparison overhead isn\'t worth it.', package_name: 'react', min_version: '16.6.0' },
+    { domain: 'react', topic: 'hooks', update_type: 'best_practice', title: 'useCallback for handlers', content: 'Wrap callbacks passed to memoized child components with useCallback. Without it, a new function reference is created each render, breaking memo.', package_name: 'react', min_version: '16.8.0' },
+    { domain: 'react', topic: 'lists', update_type: 'best_practice', title: 'Stable keys, never indices', content: 'Keys should be unique IDs from your data, not array indices. Index keys cause bugs with reordering and state preservation.', package_name: 'react', min_version: '16.0.0' },
+    { domain: 'react', topic: 'state', update_type: 'best_practice', title: 'Colocate state', content: 'Keep state as close to where it\'s used as possible. Only lift state when truly needed. Avoid premature global state.', package_name: 'react', min_version: '16.0.0' },
+    { domain: 'react', topic: 'effects', update_type: 'best_practice', title: 'Always cleanup useEffect', content: 'Return a cleanup function from useEffect for subscriptions, timers, and event listeners. Prevents memory leaks and stale closures.', package_name: 'react', min_version: '16.8.0' },
+    { domain: 'react', topic: 'state', update_type: 'best_practice', title: 'Avoid derived state', content: 'Don\'t useState for values derivable from props or other state. Use useMemo or calculate during render instead.', package_name: 'react', min_version: '16.8.0' },
+    { domain: 'react', topic: 'errors', update_type: 'best_practice', title: 'Use Error Boundaries', content: 'Wrap route-level and critical components in error boundaries. Prevents the entire app from crashing on render errors.', package_name: 'react', min_version: '16.0.0' },
+    { domain: 'react', topic: 'refs', update_type: 'best_practice', title: 'useRef for non-render values', content: 'Use useRef for values that don\'t need re-render (timers, previous values, DOM refs). Unlike state, changing ref.current won\'t trigger render.', package_name: 'react', min_version: '16.8.0' },
+    // TypeScript
+    { domain: 'typescript', topic: 'types', update_type: 'best_practice', title: 'type vs interface', content: 'Use type for unions, intersections, and primitives. Use interface for object shapes that might be extended or implemented.', package_name: 'typescript', min_version: '4.0.0' },
+    { domain: 'typescript', topic: 'safety', update_type: 'best_practice', title: 'unknown over any', content: 'Use unknown instead of any when type is truly unknown. unknown is type-safe - you must narrow it before use.', package_name: 'typescript', min_version: '3.0.0' },
+    { domain: 'typescript', topic: 'config', update_type: 'best_practice', title: 'Enable strict mode', content: 'Set strict: true in tsconfig.json. This enables strictNullChecks, noImplicitAny, and other safety checks.', package_name: 'typescript', min_version: '2.3.0' },
+    { domain: 'typescript', topic: 'types', update_type: 'best_practice', title: 'Prefer const assertions', content: 'Use as const for literal types: const routes = { home: "/home" } as const. Prevents widening to string.', package_name: 'typescript', min_version: '3.4.0' },
+    { domain: 'typescript', topic: 'types', update_type: 'best_practice', title: 'Use satisfies keyword', content: 'satisfies validates type without widening: const config = { a: 1 } satisfies Config keeps literal types while ensuring shape.', package_name: 'typescript', min_version: '4.9.0' },
+    { domain: 'typescript', topic: 'enums', update_type: 'best_practice', title: 'Avoid enums, use const objects', content: 'const STATUS = { IDLE: "idle" } as const is more predictable than enum at runtime and doesn\'t generate extra code.', package_name: 'typescript', min_version: '3.4.0' },
+    // Next.js
+    { domain: 'nextjs', topic: 'components', update_type: 'best_practice', title: 'Server Components by default', content: 'In App Router, components are Server Components by default. Only add "use client" when you need hooks, browser APIs, or event handlers.', package_name: 'next', min_version: '13.0.0' },
+    { domain: 'nextjs', topic: 'data', update_type: 'best_practice', title: 'Fetch in Server Components', content: 'Do data fetching in Server Components, not useEffect. Use async components and fetch() with automatic deduplication.', package_name: 'next', min_version: '13.0.0' },
+    { domain: 'nextjs', topic: 'data', update_type: 'best_practice', title: 'Parallel data fetching', content: 'Use Promise.all() for independent fetches. Avoid sequential awaits that create waterfalls.', package_name: 'next', min_version: '13.0.0' },
+    { domain: 'nextjs', topic: 'images', update_type: 'best_practice', title: 'Always use next/image', content: 'Image component provides automatic optimization, lazy loading, responsive sizes, and WebP conversion.', package_name: 'next', min_version: '10.0.0' },
+    { domain: 'nextjs', topic: 'routing', update_type: 'best_practice', title: 'Use route groups', content: 'Use (folder) syntax for route groups. Organize routes without affecting URL structure.', package_name: 'next', min_version: '13.0.0' },
+    { domain: 'nextjs', topic: 'caching', update_type: 'best_practice', title: 'Understand caching', content: 'Next.js caches aggressively. Use revalidatePath/revalidateTag for on-demand revalidation. Set { cache: "no-store" } for dynamic data.', package_name: 'next', min_version: '13.0.0' },
+    // Node.js
+    { domain: 'nodejs', topic: 'async', update_type: 'best_practice', title: 'async/await over callbacks', content: 'Use async/await for cleaner code and better error handling with try/catch. Avoid callback hell.', package_name: 'node', min_version: '8.0.0' },
+    { domain: 'nodejs', topic: 'config', update_type: 'best_practice', title: 'Validate env vars at startup', content: 'Use zod or joi to validate environment variables when the app starts. Fail fast if required vars are missing.', package_name: 'node', min_version: '12.0.0' },
+    { domain: 'nodejs', topic: 'errors', update_type: 'best_practice', title: 'Handle uncaught exceptions', content: 'process.on("uncaughtException") should log the error and exit gracefully. Never swallow errors silently.', package_name: 'node', min_version: '1.0.0' },
+    { domain: 'nodejs', topic: 'production', update_type: 'best_practice', title: 'Graceful shutdown', content: 'Handle SIGTERM/SIGINT to close database connections and finish in-flight requests before exiting.', package_name: 'node', min_version: '1.0.0' },
+    { domain: 'nodejs', topic: 'streams', update_type: 'best_practice', title: 'Stream large data', content: 'Use streams for large files instead of reading entire files into memory. Prevents memory exhaustion.', package_name: 'node', min_version: '1.0.0' },
+    // CSS
+    { domain: 'css', topic: 'variables', update_type: 'best_practice', title: 'Use CSS custom properties', content: 'CSS variables (--color-primary) enable theming, reduce repetition, and can be changed at runtime via JavaScript.', package_name: null, min_version: null },
+    { domain: 'css', topic: 'units', update_type: 'best_practice', title: 'rem for font sizes, px for borders', content: 'rem scales with user preferences for accessibility. px is fine for borders and small fixed elements.', package_name: null, min_version: null },
+    { domain: 'css', topic: 'layout', update_type: 'best_practice', title: 'Mobile-first media queries', content: 'Write base styles for mobile, use min-width queries to enhance for larger screens. Better performance and simpler code.', package_name: null, min_version: null },
+    { domain: 'css', topic: 'specificity', update_type: 'best_practice', title: 'Avoid !important', content: '!important breaks the cascade. Fix specificity issues with better selectors or CSS layers instead.', package_name: null, min_version: null },
+    { domain: 'css', topic: 'performance', update_type: 'best_practice', title: 'Use contain property', content: 'contain: content isolates layout/paint. Great for cards, modals, and independently updating components.', package_name: null, min_version: null },
+    // Git
+    { domain: 'git', topic: 'commits', update_type: 'best_practice', title: 'Atomic commits', content: 'Each commit should be one logical change. Makes reviews, reverts, and bisecting much easier.', package_name: null, min_version: null },
+    { domain: 'git', topic: 'commits', update_type: 'best_practice', title: 'Conventional commits', content: 'Use feat:, fix:, docs:, chore:, refactor: prefixes. Enables automatic changelog generation and semantic versioning.', package_name: null, min_version: null },
+    { domain: 'git', topic: 'branches', update_type: 'best_practice', title: 'Short-lived feature branches', content: 'Feature branches should live hours or days, not weeks. Long-lived branches lead to merge hell.', package_name: null, min_version: null },
+    { domain: 'git', topic: 'workflow', update_type: 'best_practice', title: 'Rebase feature branches', content: 'Rebase onto main before merging for linear history. Squash WIP commits to keep history clean.', package_name: null, min_version: null },
+    { domain: 'git', topic: 'safety', update_type: 'best_practice', title: 'Never force push shared branches', content: 'Force pushing rewrites history and breaks collaborators. Only force push personal feature branches.', package_name: null, min_version: null },
+    // Supabase
+    { domain: 'supabase', topic: 'security', update_type: 'best_practice', title: 'Always enable RLS', content: 'Row Level Security is disabled by default. Enable it on ALL tables. Without RLS, your data is publicly accessible.', package_name: '@supabase/supabase-js', min_version: '2.0.0' },
+    { domain: 'supabase', topic: 'queries', update_type: 'best_practice', title: 'Select specific columns', content: 'Use .select("id, name") instead of .select("*"). Reduces payload size and improves security.', package_name: '@supabase/supabase-js', min_version: '2.0.0' },
+    { domain: 'supabase', topic: 'auth', update_type: 'best_practice', title: 'Use auth.uid() in RLS', content: 'Reference auth.uid() in RLS policies to scope data to the current user. Never trust client-side user IDs.', package_name: '@supabase/supabase-js', min_version: '2.0.0' },
+    // Testing
+    { domain: 'testing', topic: 'unit', update_type: 'best_practice', title: 'Test behavior, not implementation', content: 'Test what the code does, not how it does it. Tests should survive refactoring if behavior stays the same.', package_name: null, min_version: null },
+    { domain: 'testing', topic: 'mocking', update_type: 'best_practice', title: 'Mock at boundaries', content: 'Mock external services (APIs, databases) not internal modules. Mocking internals makes tests brittle.', package_name: null, min_version: null },
+    { domain: 'testing', topic: 'naming', update_type: 'best_practice', title: 'Descriptive test names', content: 'Test names should describe expected behavior: "should show error when email is invalid" not "test email"', package_name: null, min_version: null },
+    { domain: 'testing', topic: 'isolation', update_type: 'best_practice', title: 'Tests should be independent', content: 'Each test should set up its own state and clean up after. Tests should pass in any order.', package_name: null, min_version: null },
+    // Security
+    { domain: 'security', topic: 'auth', update_type: 'best_practice', title: 'Use established auth libraries', content: 'Don\'t roll your own auth. Use NextAuth.js, Clerk, or Supabase Auth. Auth is hard to get right.', package_name: null, min_version: null },
+    { domain: 'security', topic: 'secrets', update_type: 'best_practice', title: 'Never commit secrets', content: 'API keys, passwords, and tokens go in .env files (gitignored). Use secret managers in production.', package_name: null, min_version: null },
+    { domain: 'security', topic: 'input', update_type: 'best_practice', title: 'Validate all input', content: 'Validate on server-side even if validated client-side. Client validation is for UX, server validation is for security.', package_name: null, min_version: null },
+    { domain: 'security', topic: 'dependencies', update_type: 'best_practice', title: 'Keep dependencies updated', content: 'Run npm audit regularly. Use Dependabot or Renovate for automated updates. Review breaking changes.', package_name: null, min_version: null },
+];
+//# sourceMappingURL=knowledge-base.js.map