@nockdev/awf 6.2.0

package/.agent/skills/frameworks/nextjs/data/server.yaml

@@ -0,0 +1,248 @@
+# =============================================================================
+# Next.js Server Patterns (Feb 2026)
+# =============================================================================
+# Server Actions, proxy.ts, React 19.2 features
+
+metadata:
+  skill: nextjs
+  domain: server
+  version: "16"
+  updated: "2026-02-05"
+  patterns_count: 5
+
+patterns:
+  - id: next012
+    name: Server Actions
+    category: data-mutation
+    version: "14+"
+    description: Form submissions and mutations without API routes
+    text: use server action form mutation revalidate redirect
+    example: |
+      // app/actions.ts
+      "use server";
+
+      import { revalidatePath } from "next/cache";
+      import { redirect } from "next/navigation";
+      import { z } from "zod";
+
+      const UserSchema = z.object({
+        name: z.string().min(2),
+        email: z.string().email(),
+      });
+
+      export async function createUser(formData: FormData) {
+        // ✅ Validate input
+        const validated = UserSchema.parse({
+          name: formData.get("name"),
+          email: formData.get("email"),
+        });
+
+        // ✅ Database operation
+        const user = await db.user.create({
+          data: validated,
+        });
+
+        // ✅ Revalidate cache
+        revalidatePath("/users");
+
+        // ✅ Redirect
+        redirect(`/users/${user.id}`);
+      }
+
+      // Usage in form
+      export default function CreateUserForm() {
+        return (
+          <form action={createUser}>
+            <input name="name" placeholder="Name" />
+            <input name="email" type="email" placeholder="Email" />
+            <button type="submit">Create</button>
+          </form>
+        );
+      }
+    severity: CRITICAL
+    docs_url: https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations
+
+  - id: next013
+    name: proxy.ts (Next.js 16)
+    category: networking
+    version: "16+"
+    description: |
+      Network boundary control replacing middleware.ts.
+      Clearer separation of concerns.
+    text: proxy middleware network boundary auth redirect
+    example: |
+      // ✅ Next.js 16: proxy.ts for network boundary control
+      // Provides clearer separation than middleware.ts
+
+      // proxy.ts
+      import { NextResponse } from "next/server";
+      import type { NextRequest } from "next/server";
+
+      export function proxy(request: NextRequest) {
+        const { pathname } = request.nextUrl;
+
+        // Auth check with clearer network boundary
+        const token = request.cookies.get("token");
+        if (pathname.startsWith("/dashboard") && !token) {
+          return NextResponse.redirect(new URL("/login", request.url));
+        }
+
+        // API rate limiting
+        if (pathname.startsWith("/api")) {
+          // Rate limit logic here
+        }
+
+        return NextResponse.next();
+      }
+
+      export const config = {
+        matcher: ["/((?!api|_next/static|_next/image|favicon.ico).*)"],
+      };
+
+      // ⚠️ Migration from middleware.ts:
+      // - Rename function from `middleware` to `proxy`
+      // - Update import paths if needed
+    severity: HIGH
+    docs_url: https://nextjs.org/docs/app/building-your-application/routing/middleware
+
+  - id: next014
+    name: React 19.2 Integration
+    category: react
+    version: "16+"
+    description: |
+      Next.js 16 bundles React 19.2 with new hooks and features.
+      View Transitions, useEffectEvent, Activity component.
+    text: react 19 useOptimistic useEffectEvent view transition activity
+    example: |
+      // ✅ Next.js 16 bundles React 19.2
+      import { useOptimistic, useEffectEvent } from "react";
+
+      // View Transitions API
+      export function NavigationLink({ href, children }) {
+        return (
+          <Link href={href} viewTransition>
+            {children}
+          </Link>
+        );
+      }
+
+      // useEffectEvent for stable event handlers
+      function ChatRoom({ roomId }) {
+        const onMessage = useEffectEvent((msg) => {
+          showNotification(msg);
+        });
+
+        useEffect(() => {
+          const connection = createConnection(roomId);
+          connection.on("message", onMessage);
+          return () => connection.disconnect();
+        }, [roomId]); // onMessage not in deps!
+      }
+
+      // Activity component for offscreen rendering
+      import { Activity } from "react";
+
+      <Activity mode="hidden">
+        <HeavyComponent />
+      </Activity>;
+
+      // useOptimistic for instant UI feedback
+      export function LikeButton({ likes }: { likes: number }) {
+        const [optimisticLikes, addOptimisticLike] = useOptimistic(
+          likes,
+          (state) => state + 1,
+        );
+
+        async function handleLike() {
+          addOptimisticLike(null); // Instant UI update
+          await likePost();        // Server action
+        }
+
+        return <button onClick={handleLike}>❤️ {optimisticLikes}</button>;
+      }
+    severity: HIGH
+    docs_url: https://react.dev/blog/2024/04/25/react-19
+
+  - id: next015
+    name: React Compiler (Stable)
+    category: optimization
+    version: "16+"
+    description: |
+      Automatic memoization at build time.
+      No more manual useMemo/useCallback needed.
+    text: react compiler memoization useMemo useCallback automatic
+    example: |
+      // ✅ Next.js 16: Built-in React Compiler support
+      // Automatic memoization at build time
+
+      // next.config.ts
+      export default {
+        experimental: {
+          reactCompiler: true, // ✅ Stable in Next.js 16
+        },
+      };
+
+      // No more manual useMemo/useCallback needed!
+      function ExpensiveComponent({ data }) {
+        // ✅ Compiler auto-memoizes this computation
+        const processed = data.map((item) => expensiveOperation(item));
+        
+        // ✅ Callbacks also auto-memoized
+        const handleClick = (id) => {
+          doSomething(id);
+        };
+
+        return <List items={processed} onClick={handleClick} />;
+      }
+
+      // Before React Compiler:
+      // const processed = useMemo(() => data.map(...), [data]);
+      // const handleClick = useCallback((id) => ..., []);
+
+      // After: Just write normal code!
+    severity: HIGH
+    docs_url: https://react.dev/learn/react-compiler
+
+  - id: next016
+    name: Middleware (Legacy)
+    category: networking
+    version: "12+"
+    description: Edge runtime middleware for auth, redirects, headers
+    text: middleware edge runtime auth headers cookies
+    example: |
+      // middleware.ts (still supported, proxy.ts preferred in v16)
+      import { NextResponse } from "next/server";
+      import type { NextRequest } from "next/server";
+
+      export function middleware(request: NextRequest) {
+        const { pathname } = request.nextUrl;
+
+        // ✅ Auth check
+        const token = request.cookies.get("token");
+        if (pathname.startsWith("/dashboard") && !token) {
+          return NextResponse.redirect(new URL("/login", request.url));
+        }
+
+        // ✅ Add headers
+        const response = NextResponse.next();
+        response.headers.set("x-pathname", pathname);
+
+        // ✅ Geolocation-based routing
+        const country = request.geo?.country;
+        if (country === "CN" && !pathname.startsWith("/cn")) {
+          return NextResponse.redirect(new URL("/cn" + pathname, request.url));
+        }
+
+        return response;
+      }
+
+      export const config = {
+        matcher: ["/((?!api|_next/static|_next/image|favicon.ico).*)"],
+      };
+
+      // ⚠️ Middleware runs on Edge Runtime
+      // - No Node.js APIs (fs, path, etc.)
+      // - Limited to Web APIs
+      // - Max 1MB code size
+    severity: MEDIUM
+    docs_url: https://nextjs.org/docs/app/building-your-application/routing/middleware

package/.agent/skills/frameworks/nuxt/META.yaml

@@ -0,0 +1,57 @@
+name: nuxt
+version: "6.2.0"
+category: frontend
+tier: 3
+
+desc: "Nuxt 4 development patterns (Mid 2025+). App directory, smart data fetching, Nitro server."
+
+patterns:
+  total: 11
+  domains:
+    core: 6
+    server: 5
+
+hsa:
+  enabled: true
+  adapter: nuxt_adapter.py
+
+triggers:
+  file_patterns:
+    - "nuxt.config.ts"
+    - "nuxt.config.js"
+    - "app.vue"
+    - "pages/*.vue"
+    - "server/api/*.ts"
+  keywords:
+    # Core
+    - nuxt
+    - nuxt.js
+    - useAsyncData
+    - useFetch
+    - definePageMeta
+    - NuxtLink
+    # Server
+    - nitro
+    - defineEventHandler
+    - useRuntimeConfig
+    - server/api
+    # Features
+    - auto-import
+    - file-based routing
+    - layouts
+    - middleware
+  intents:
+    - nuxt app
+    - nuxt page
+    - nuxt api
+    - nuxt server
+    - vue fullstack
+
+related_skills:
+  - vue
+  - typescript
+  - nitro
+
+prevent_confusion_with:
+  - nextjs: "Nuxt uses Vue, Next.js uses React"
+  - vue: "Nuxt is a Vue meta-framework with SSR/SSG"

package/.agent/skills/frameworks/nuxt/SKILL.md

@@ -0,0 +1,283 @@
+---
+name: nuxt
+detect: ["nuxt.config.ts", "nuxt.config.js", ".nuxtrc", "app.vue"]
+version: "6.1.2"
+category: frontend
+tier: 1
+---
+
+# Nuxt Patterns — DOMYH Awesome Code
+
+> **Version**: Nuxt 4 (2025-2026)
+> **Philosophy**: Full-stack Vue, hybrid rendering, DX-first
+
+---
+
+## 🎯 When to Use This Skill
+
+Use for: Full-stack Vue apps, SSR, SSG, hybrid rendering.
+**NOT for**: Static sites only (→ vue), non-Vue (→ nextjs).
+
+---
+
+## 📦 Recommended Stack (2025-2026)
+
+### Core
+
+| Tool       | Use Case          |
+| ---------- | ----------------- |
+| **Nuxt 4** | Full-stack Vue 🏆 |
+| **Nitro**  | Server engine     |
+| **Vite**   | Dev bundler       |
+
+### State & Data
+
+| Library                 | Use Case            |
+| ----------------------- | ------------------- |
+| **Pinia**               | State management 🏆 |
+| **VueUse**              | Composables         |
+| **@tanstack/vue-query** | Server state        |
+
+### IDE Support
+
+| IDE                 | Features                   |
+| ------------------- | -------------------------- |
+| **VS Code + Volar** | Full TypeScript support 🏆 |
+| **Nuxtr extension** | Nuxt-specific tooling      |
+| **WebStorm**        | Built-in Nuxt support      |
+
+---
+
+## 🆕 Nuxt 4 Features (2025)
+
+### New Directory Structure
+
+```
+my-app/
+├── app/                    # 🆕 Main app code
+│   ├── components/
+│   ├── composables/
+│   ├── layouts/
+│   ├── pages/
+│   ├── plugins/
+│   └── app.vue
+├── server/                 # Server code
+│   ├── api/
+│   ├── middleware/
+│   └── routes/
+├── shared/                 # 🆕 Shared across client/server
+├── public/
+├── nuxt.config.ts
+└── package.json
+```
+
+### Enhanced Data Fetching
+
+```typescript
+// ✅ Nuxt 4: Improved useFetch with auto-sharing
+const {
+  data: users,
+  pending,
+  error,
+  refresh,
+} = await useFetch("/api/users", {
+  key: "users", // Auto-deduplication
+  default: () => [], // Default value
+  getCachedData: (key) => {
+    // Custom cache
+    return nuxtApp.payload.data[key];
+  },
+});
+
+// ✅ Reactive keys - auto-refetch when params change
+const userId = ref(1);
+const { data: user } = await useFetch(() => `/api/users/${userId.value}`);
+
+// ✅ useAsyncData for computed fetch logic
+const { data } = await useAsyncData("user-profile", async () => {
+  const user = await $fetch("/api/me");
+  const posts = await $fetch(`/api/users/${user.id}/posts`);
+  return { user, posts };
+});
+```
+
+### Server Routes
+
+```typescript
+// server/api/users/[id].get.ts
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+
+  // Validate
+  if (!id || isNaN(Number(id))) {
+    throw createError({
+      statusCode: 400,
+      message: "Invalid user ID",
+    });
+  }
+
+  const user = await db.user.findUnique({
+    where: { id: Number(id) },
+  });
+
+  if (!user) {
+    throw createError({
+      statusCode: 404,
+      message: "User not found",
+    });
+  }
+
+  return user;
+});
+
+// ✅ Cached event handler for expensive operations
+export default cachedEventHandler(
+  async (event) => {
+    return await expensiveComputation();
+  },
+  {
+    maxAge: 60 * 60, // 1 hour
+    swr: true, // Stale-while-revalidate
+  },
+);
+```
+
+---
+
+## 🔧 Core Patterns
+
+### Page Component
+
+```vue
+<!-- pages/users/[id].vue -->
+<script setup lang="ts">
+definePageMeta({
+  middleware: "auth",
+  layout: "dashboard",
+});
+
+const route = useRoute();
+const {
+  data: user,
+  pending,
+  error,
+} = await useFetch(`/api/users/${route.params.id}`);
+
+// SEO
+useSeoMeta({
+  title: () => user.value?.name ?? "User",
+  description: () => `Profile for ${user.value?.name}`,
+});
+</script>
+
+<template>
+  <div v-if="pending">Loading...</div>
+  <div v-else-if="error">{{ error.message }}</div>
+  <UserProfile v-else :user="user!" />
+</template>
+```
+
+### Middleware
+
+```typescript
+// middleware/auth.ts
+export default defineNuxtRouteMiddleware((to, from) => {
+  const user = useSupabaseUser(); // or your auth composable
+
+  // ⚠️ Always use to/from, NOT useRoute()
+  if (!user.value && to.path !== "/login") {
+    return navigateTo("/login", {
+      redirectCode: 302,
+    });
+  }
+});
+
+// middleware/admin.ts
+export default defineNuxtRouteMiddleware(async (to) => {
+  const { data } = await useFetch("/api/me");
+
+  if (data.value?.role !== "admin") {
+    throw createError({
+      statusCode: 403,
+      message: "Admin access required",
+    });
+  }
+});
+```
+
+### Server Components (Islands)
+
+```vue
+<!-- components/HeavySyntaxHighlighter.server.vue -->
+<script setup lang="ts">
+// 🆕 Server-only component - no client JS
+import { highlight } from "shikiji";
+
+const props = defineProps<{
+  code: string;
+  lang: string;
+}>();
+
+const html = await highlight(props.code, {
+  lang: props.lang,
+  theme: "github-dark",
+});
+</script>
+
+<template>
+  <div v-html="html" />
+</template>
+```
+
+---
+
+## 🚀 Hybrid Rendering
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  routeRules: {
+    // Static generation
+    "/": { prerender: true },
+    "/blog/**": { swr: 3600 }, // ISR: 1 hour
+
+    // Client-side only
+    "/dashboard/**": { ssr: false },
+
+    // Server-side
+    "/api/**": { cors: true },
+
+    // Cache headers
+    "/assets/**": { headers: { "cache-control": "max-age=31536000" } },
+  },
+});
+```
+
+---
+
+## ✅ Best Practices Checklist
+
+### Data Fetching
+
+- [ ] Use `useFetch` over `$fetch` in components
+- [ ] Provide `key` for deduplication
+- [ ] Set `default` values
+- [ ] Handle `pending` and `error` states
+
+### Performance
+
+- [ ] Use server components for static content
+- [ ] Configure proper routeRules
+- [ ] Cache expensive API handlers
+- [ ] Lazy load heavy components
+
+### Security
+
+- [ ] Validate all route params
+- [ ] Use `createError` for proper errors
+- [ ] Implement proper middleware
+- [ ] Never trust client data
+
+---
+
+_DOMYH Awesome Code • Nuxt 4_