@mrtrinhvn/ag-kit 1.0.5 → 1.0.7

package/.agent/skills/nextjs-react-expert/8-advanced-advanced-patterns.md

@@ -0,0 +1,150 @@
+# 8. Advanced Patterns
+
+> **Impact:** VARIABLE
+> **Focus:** Advanced patterns for specific cases that require careful implementation.
+
+---
+
+## Overview
+
+This section contains **3 rules** focused on advanced patterns.
+
+---
+
+## Rule 8.1: Initialize App Once, Not Per Mount
+
+**Impact:** LOW-MEDIUM  
+**Tags:** initialization, useEffect, app-startup, side-effects  
+
+## Initialize App Once, Not Per Mount
+
+Do not put app-wide initialization that must run once per app load inside `useEffect([])` of a component. Components can remount and effects will re-run. Use a module-level guard or top-level init in the entry module instead.
+
+**Incorrect (runs twice in dev, re-runs on remount):**
+
+```tsx
+function Comp() {
+  useEffect(() => {
+    loadFromStorage()
+    checkAuthToken()
+  }, [])
+
+  // ...
+}
+```
+
+**Correct (once per app load):**
+
+```tsx
+let didInit = false
+
+function Comp() {
+  useEffect(() => {
+    if (didInit) return
+    didInit = true
+    loadFromStorage()
+    checkAuthToken()
+  }, [])
+
+  // ...
+}
+```
+
+Reference: [Initializing the application](https://react.dev/learn/you-might-not-need-an-effect#initializing-the-application)
+
+---
+
+## Rule 8.2: Store Event Handlers in Refs
+
+**Impact:** LOW  
+**Tags:** advanced, hooks, refs, event-handlers, optimization  
+
+## Store Event Handlers in Refs
+
+Store callbacks in refs when used in effects that shouldn't re-subscribe on callback changes.
+
+**Incorrect (re-subscribes on every render):**
+
+```tsx
+function useWindowEvent(event: string, handler: (e) => void) {
+  useEffect(() => {
+    window.addEventListener(event, handler)
+    return () => window.removeEventListener(event, handler)
+  }, [event, handler])
+}
+```
+
+**Correct (stable subscription):**
+
+```tsx
+function useWindowEvent(event: string, handler: (e) => void) {
+  const handlerRef = useRef(handler)
+  useEffect(() => {
+    handlerRef.current = handler
+  }, [handler])
+
+  useEffect(() => {
+    const listener = (e) => handlerRef.current(e)
+    window.addEventListener(event, listener)
+    return () => window.removeEventListener(event, listener)
+  }, [event])
+}
+```
+
+**Alternative: use `useEffectEvent` if you're on latest React:**
+
+```tsx
+import { useEffectEvent } from 'react'
+
+function useWindowEvent(event: string, handler: (e) => void) {
+  const onEvent = useEffectEvent(handler)
+
+  useEffect(() => {
+    window.addEventListener(event, onEvent)
+    return () => window.removeEventListener(event, onEvent)
+  }, [event])
+}
+```
+
+`useEffectEvent` provides a cleaner API for the same pattern: it creates a stable function reference that always calls the latest version of the handler.
+
+---
+
+## Rule 8.3: useEffectEvent for Stable Callback Refs
+
+**Impact:** LOW  
+**Tags:** advanced, hooks, useEffectEvent, refs, optimization  
+
+## useEffectEvent for Stable Callback Refs
+
+Access latest values in callbacks without adding them to dependency arrays. Prevents effect re-runs while avoiding stale closures.
+
+**Incorrect (effect re-runs on every callback change):**
+
+```tsx
+function SearchInput({ onSearch }: { onSearch: (q: string) => void }) {
+  const [query, setQuery] = useState('')
+
+  useEffect(() => {
+    const timeout = setTimeout(() => onSearch(query), 300)
+    return () => clearTimeout(timeout)
+  }, [query, onSearch])
+}
+```
+
+**Correct (using React's useEffectEvent):**
+
+```tsx
+import { useEffectEvent } from 'react';
+
+function SearchInput({ onSearch }: { onSearch: (q: string) => void }) {
+  const [query, setQuery] = useState('')
+  const onSearchEvent = useEffectEvent(onSearch)
+
+  useEffect(() => {
+    const timeout = setTimeout(() => onSearchEvent(query), 300)
+    return () => clearTimeout(timeout)
+  }, [query])
+}
+```
+

package/.agent/skills/nextjs-react-expert/9-cache-components.md

@@ -0,0 +1,103 @@
+# Cache Components: `use cache` & `cacheLife`
+
+> [!IMPORTANT]
+> This is a Next.js 16+ specific skill. Do NOT apply these patterns to Next.js 15 or earlier without explicitly checking compatibility.
+
+## Core Philosophy
+Next.js 16 marks the transition from "Segment-level caching" to "Component-level caching". We no longer rely on `export const revalidate = 3600`. Instead, we use granular directives and profiles.
+
+## 1. The `use cache` Directive
+The `use cache` directive can be applied to **Server Components** or **Functions**.
+
+### Rule: Granular Application
+Wrap only the data-fetching logic or the specific component that needs caching.
+
+```tsx
+// Good: Granular function caching
+async function getProduct(id: string) {
+  'use cache'
+  return await db.product.findUnique({ where: { id } })
+}
+
+// Good: Component-level caching
+export default async function ProductCard({ id }: { id: string }) {
+  'use cache'
+  const product = await getProduct(id)
+  return <div>{product.name}</div>
+}
+```
+
+## 2. Using `cacheLife`
+`cacheLife` defines the "Freshness" and "Staleness" of a cached item using pre-defined or custom profiles.
+
+### Usage Pattern
+```tsx
+import { cacheLife } from 'next/cache'
+
+async function getStockInfo() {
+  'use cache'
+  cacheLife('minutes') // Using a pre-defined profile
+  return await fetchStocks()
+}
+```
+
+### Profile Reference
+- `default`: Base profile (1 year stale time).
+- `seconds`: High-frequency updates.
+- `minutes`: Standard dynamic content.
+- `hours`: Stable content (e.g., blog posts).
+- `days`: Semi-static content.
+- `weeks`: Static-like content.
+- `max`: Permanent cache until invalidated.
+
+## 3. On-Demand Invalidation with `cacheTag`
+`cacheTag` allows you to label cached data for selective purging.
+
+### Implementation
+```tsx
+import { cacheTag } from 'next/cache'
+
+async function getProfile(user: string) {
+  'use cache'
+  cacheTag(`profile-${user}`)
+  return await db.user.findUnique(...)
+}
+```
+
+### Revalidation
+In a Server Action:
+```tsx
+import { revalidateTag, updateTag } from 'next/cache'
+
+export async function updateProfile(user: string, data: any) {
+  await db.user.update(...)
+  
+  // Choice A: Background revalidation (Stale-While-Revalidate)
+  revalidateTag(`profile-${user}`)
+  
+  // Choice B: Immediate "Read-Your-Writes" update
+  updateTag(`profile-${user}`)
+}
+```
+
+## 4. Partial Pre-Rendering (PPR)
+Next.js 16 stabilizes PPR via the `cacheComponents` flag in `next.config.ts`. 
+
+### Pattern: Suspense Boundaries
+Always wrap dynamic "Cache Components" in `<Suspense>` to enable PPR.
+
+```tsx
+import { Suspense } from 'react'
+import { Skeleton } from '@/components/ui/skeleton'
+
+export default function Page() {
+  return (
+    <main>
+      <h1>Static Header</h1>
+      <Suspense fallback={<Skeleton />}>
+        <DynamicCacheComponent />
+      </Suspense>
+    </main>
+  )
+}
+```

package/.agent/skills/nextjs-react-expert/SKILL.md

@@ -0,0 +1,267 @@
+---
+name: nextjs-react-expert
+description: React and Next.js performance optimization from Vercel Engineering. Use when building React components, optimizing performance, eliminating waterfalls, reducing bundle size, reviewing code for performance issues, or implementing server/client-side optimizations.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Next.js & React Performance Expert
+
+> **From Vercel Engineering** - 57 optimization rules prioritized by impact
+> **Philosophy:** Eliminate waterfalls first, optimize bundles second, then micro-optimize.
+
+---
+
+## 🎯 Selective Reading Rule (MANDATORY)
+
+**Read ONLY sections relevant to your task!** Check the content map below and load what you need.
+
+> 🔴 **For performance reviews: Start with CRITICAL sections (1-2), then move to HIGH/MEDIUM.**
+
+---
+
+## 📑 Content Map
+
+| File | Impact | Rules | When to Read |
+|------|--------|-------|--------------|
+| `1-async-eliminating-waterfalls.md` | 🔴 **CRITICAL** | 5 rules | Slow page loads, sequential API calls, data fetching waterfalls |
+| `2-bundle-bundle-size-optimization.md` | 🔴 **CRITICAL** | 5 rules | Large bundle size, slow Time to Interactive, First Load issues |
+| `3-server-server-side-performance.md` | 🟠 **HIGH** | 7 rules | Slow SSR, API route optimization, server-side waterfalls |
+| `4-client-client-side-data-fetching.md` | 🟡 **MEDIUM-HIGH** | 4 rules | Client data management, SWR patterns, deduplication |
+| `5-rerender-re-render-optimization.md` | 🟡 **MEDIUM** | 12 rules | Excessive re-renders, React performance, memoization |
+| `6-rendering-rendering-performance.md` | 🟡 **MEDIUM** | 9 rules | Rendering bottlenecks, virtualization, image optimization |
+| `7-js-javascript-performance.md` | ⚪ **LOW-MEDIUM** | 12 rules | Micro-optimizations, caching, loop performance |
+| `8-advanced-advanced-patterns.md` | 🔵 **VARIABLE** | 3 rules | Advanced React patterns, useLatest, init-once |
+
+**Total: 57 rules across 8 categories**
+
+---
+
+## 🚀 Quick Decision Tree
+
+**What's your performance issue?**
+
+```
+🐌 Slow page loads / Long Time to Interactive
+  → Read Section 1: Eliminating Waterfalls
+  → Read Section 2: Bundle Size Optimization
+
+📦 Large bundle size (> 200KB)
+  → Read Section 2: Bundle Size Optimization
+  → Check: Dynamic imports, barrel imports, tree-shaking
+
+🖥️ Slow Server-Side Rendering
+  → Read Section 3: Server-Side Performance
+  → Check: Parallel data fetching, streaming
+
+🔄 Too many re-renders / UI lag
+  → Read Section 5: Re-render Optimization
+  → Check: React.memo, useMemo, useCallback
+
+🎨 Rendering performance issues
+  → Read Section 6: Rendering Performance
+  → Check: Virtualization, layout thrashing
+
+🌐 Client-side data fetching problems
+  → Read Section 4: Client-Side Data Fetching
+  → Check: SWR deduplication, localStorage
+
+✨ Need advanced patterns
+  → Read Section 8: Advanced Patterns
+```
+
+---
+
+## 📊 Impact Priority Guide
+
+**Use this order when doing comprehensive optimization:**
+
+```
+1️⃣ CRITICAL (Biggest Gains - Do First):
+   ├─ Section 1: Eliminating Waterfalls
+   │  └─ Each waterfall adds full network latency (100-500ms+)
+   └─ Section 2: Bundle Size Optimization
+      └─ Affects Time to Interactive and Largest Contentful Paint
+
+2️⃣ HIGH (Significant Impact - Do Second):
+   └─ Section 3: Server-Side Performance
+      └─ Eliminates server-side waterfalls, faster response times
+
+3️⃣ MEDIUM (Moderate Gains - Do Third):
+   ├─ Section 4: Client-Side Data Fetching
+   ├─ Section 5: Re-render Optimization
+   └─ Section 6: Rendering Performance
+
+4️⃣ LOW (Polish - Do Last):
+   ├─ Section 7: JavaScript Performance
+   └─ Section 8: Advanced Patterns
+```
+
+---
+
+## 🔗 Related Skills
+
+| Need | Skill |
+|------|-------|
+| API design patterns | `@[skills/api-patterns]` |
+| Database optimization | `@[skills/database-design]` |
+| Testing strategies | `@[skills/testing-patterns]` |
+| UI/UX design principles | `@[skills/frontend-design]` |
+| TypeScript patterns | `@[skills/typescript-expert]` |
+| Deployment & DevOps | `@[skills/deployment-procedures]` |
+
+---
+
+## ✅ Performance Review Checklist
+
+Before shipping to production:
+
+**Critical (Must Fix):**
+- [ ] No sequential data fetching (waterfalls eliminated)
+- [ ] Bundle size < 200KB for main bundle
+- [ ] No barrel imports in app code
+- [ ] Dynamic imports used for large components
+- [ ] Parallel data fetching where possible
+
+**High Priority:**
+- [ ] Server components used where appropriate
+- [ ] API routes optimized (no N+1 queries)
+- [ ] Suspense boundaries for data fetching
+- [ ] Static generation used where possible
+
+**Medium Priority:**
+- [ ] Expensive computations memoized
+- [ ] List rendering virtualized (if > 100 items)
+- [ ] Images optimized with next/image
+- [ ] No unnecessary re-renders
+
+**Low Priority (Polish):**
+- [ ] Hot path loops optimized
+- [ ] RegExp patterns hoisted
+- [ ] Property access cached in loops
+
+---
+
+## ❌ Anti-Patterns (Common Mistakes)
+
+**DON'T:**
+- ❌ Use sequential `await` for independent operations
+- ❌ Import entire libraries when you need one function
+- ❌ Use barrel exports (`index.ts` re-exports) in app code
+- ❌ Skip dynamic imports for large components/libraries
+- ❌ Fetch data in useEffect without deduplication
+- ❌ Forget to memoize expensive computations
+- ❌ Use client components when server components work
+
+**DO:**
+- ✅ Fetch data in parallel with `Promise.all()`
+- ✅ Use dynamic imports: `const Comp = dynamic(() => import('./Heavy'))`
+- ✅ Import directly: `import { specific } from 'library/specific'`
+- ✅ Use Suspense boundaries for better UX
+- ✅ Leverage React Server Components
+- ✅ Measure performance before optimizing
+- ✅ Use Next.js built-in optimizations (next/image, next/font)
+
+---
+
+## 🎯 How to Use This Skill
+
+### For New Features:
+1. Check **Section 1 & 2** while building (prevent waterfalls, keep bundle small)
+2. Use server components by default (Section 3)
+3. Apply memoization for expensive operations (Section 5)
+
+### For Performance Reviews:
+1. Start with **Section 1** (waterfalls = biggest impact)
+2. Then **Section 2** (bundle size)
+3. Then **Section 3** (server-side)
+4. Finally other sections as needed
+
+### For Debugging Slow Performance:
+1. Identify the symptom (slow load, lag, etc.)
+2. Use Quick Decision Tree above
+3. Read relevant section
+4. Apply fixes in priority order
+
+---
+
+## 📚 Learning Path
+
+**Beginner (Focus on Critical):**
+→ Section 1: Eliminating Waterfalls
+→ Section 2: Bundle Size Optimization
+
+**Intermediate (Add High Priority):**
+→ Section 3: Server-Side Performance
+→ Section 5: Re-render Optimization
+
+**Advanced (Full Optimization):**
+→ All sections + Section 8: Advanced Patterns
+
+---
+
+## 🔍 Validation Script
+
+| Script | Purpose | Command |
+|--------|---------|---------|
+| `scripts/react_performance_checker.py` | Automated performance audit | `python scripts/react_performance_checker.py <project_path>` |
+
+---
+
+## 📖 Section Details
+
+### Section 1: Eliminating Waterfalls (CRITICAL)
+**Impact:** Each waterfall adds 100-500ms+ latency
+**Key Concepts:** Parallel fetching, Promise.all(), Suspense boundaries, preloading
+
+### Section 2: Bundle Size Optimization (CRITICAL)
+**Impact:** Directly affects Time to Interactive, Largest Contentful Paint
+**Key Concepts:** Dynamic imports, tree-shaking, barrel import avoidance
+
+### Section 3: Server-Side Performance (HIGH)
+**Impact:** Faster server responses, better SEO
+**Key Concepts:** Parallel server fetching, streaming, API route optimization
+
+### Section 4: Client-Side Data Fetching (MEDIUM-HIGH)
+**Impact:** Reduces redundant requests, better UX
+**Key Concepts:** SWR deduplication, localStorage caching, event listeners
+
+### Section 5: Re-render Optimization (MEDIUM)
+**Impact:** Smoother UI, less wasted computation
+**Key Concepts:** React.memo, useMemo, useCallback, component structure
+
+### Section 6: Rendering Performance (MEDIUM)
+**Impact:** Better rendering efficiency
+**Key Concepts:** Virtualization, image optimization, layout thrashing
+
+### Section 7: JavaScript Performance (LOW-MEDIUM)
+**Impact:** Incremental improvements in hot paths
+**Key Concepts:** Loop optimization, caching, RegExp hoisting
+
+### Section 8: Advanced Patterns (VARIABLE)
+**Impact:** Specific use cases
+**Key Concepts:** useLatest hook, init-once patterns, event handler refs
+
+---
+
+## 🎓 Best Practices Summary
+
+**Golden Rules:**
+1. **Measure first** - Use React DevTools Profiler, Chrome DevTools
+2. **Biggest impact first** - Waterfalls → Bundle → Server → Micro
+3. **Don't over-optimize** - Focus on real bottlenecks
+4. **Use platform features** - Next.js has optimizations built-in
+5. **Think about users** - Real-world conditions matter
+
+**Performance Mindset:**
+- Every `await` in sequence = potential waterfall
+- Every `import` = potential bundle bloat
+- Every re-render = wasted computation (if unnecessary)
+- Server components = less JavaScript to ship
+- Measure, don't guess
+
+---
+
+**Source:** Vercel Engineering
+**Date:** January 2026
+**Version:** 1.0.0
+**Total Rules:** 57 across 8 categories