@nockdev/awf 6.2.0

package/.agent/skills/frameworks/svelte/data/sveltekit.yaml

@@ -0,0 +1,244 @@
+# =============================================================================
+# SvelteKit Patterns (Feb 2026)
+# =============================================================================
+# Routing, Load functions, Form Actions, SSR
+
+metadata:
+  skill: svelte
+  domain: sveltekit
+  version: "2.x"
+  updated: "2026-02-05"
+  patterns_count: 6
+
+patterns:
+  - id: sve007
+    name: Page with Load Function
+    category: routing
+    version: "1.0+"
+    description: Data loading for pages with typed load functions
+    text: page load fetch data params server client
+    example: |
+      <!-- +page.svelte -->
+      <script>
+        let { data } = $props();
+      </script>
+
+      <h1>{data.user.name}</h1>
+      <ul>
+        {#each data.posts as post}
+          <li>{post.title}</li>
+        {/each}
+      </ul>
+
+      // +page.ts (runs on both client & server)
+      import type { PageLoad } from './$types';
+
+      export const load: PageLoad = async ({ params, fetch }) => {
+        const user = await fetch(`/api/users/${params.id}`)
+          .then(r => r.json());
+        const posts = await fetch(`/api/users/${params.id}/posts`)
+          .then(r => r.json());
+
+        return { user, posts };
+      };
+    severity: CRITICAL
+    docs_url: https://kit.svelte.dev/docs/load
+
+  - id: sve008
+    name: Server Load (+page.server.ts)
+    category: routing
+    version: "1.0+"
+    description: Server-only data loading with database access
+    text: server load database secret secure sensitive
+    example: |
+      // +page.server.ts (runs ONLY on server)
+      import type { PageServerLoad } from './$types';
+      import { db } from '$lib/server/db';
+      import { error } from '@sveltejs/kit';
+
+      export const load: PageServerLoad = async ({ params }) => {
+        const user = await db.user.findUnique({
+          where: { id: params.id },
+        });
+
+        if (!user) {
+          throw error(404, 'User not found');
+        }
+
+        return { user };
+      };
+
+      // ✅ Benefits:
+      // - Direct database access
+      // - Secrets never exposed
+      // - Faster initial load
+      // - Smaller bundle (db code not sent to client)
+    severity: HIGH
+    docs_url: https://kit.svelte.dev/docs/load#universal-vs-server
+
+  - id: sve009
+    name: Form Actions
+    category: forms
+    version: "1.0+"
+    description: Server-side form handling with progressive enhancement
+    text: form action submit enhance progressive validation
+    example: |
+      <!-- +page.svelte -->
+      <script>
+        import { enhance } from '$app/forms';
+      </script>
+
+      <form method="POST" action="?/create" use:enhance>
+        <input name="title" required />
+        <button>Create</button>
+      </form>
+
+      // +page.server.ts
+      import type { Actions } from './$types';
+      import { fail, redirect } from '@sveltejs/kit';
+
+      export const actions: Actions = {
+        create: async ({ request }) => {
+          const data = await request.formData();
+          const title = data.get('title');
+
+          if (!title) {
+            return fail(400, { title, missing: true });
+          }
+
+          const post = await db.post.create({ data: { title } });
+          throw redirect(303, `/posts/${post.id}`);
+        },
+
+        delete: async ({ request }) => {
+          const data = await request.formData();
+          const id = data.get('id');
+          await db.post.delete({ where: { id } });
+          return { success: true };
+        },
+      };
+    severity: HIGH
+    docs_url: https://kit.svelte.dev/docs/form-actions
+
+  - id: sve010
+    name: Layouts
+    category: routing
+    version: "1.0+"
+    description: Shared layouts with nested routing
+    text: layout nested children render shared navigation
+    example: |
+      <!-- +layout.svelte -->
+      <script>
+        let { data, children } = $props();
+      </script>
+
+      <nav>
+        <a href="/">Home</a>
+        <a href="/about">About</a>
+        {#if data.user}
+          <span>{data.user.name}</span>
+        {/if}
+      </nav>
+
+      <main>
+        {@render children()}
+      </main>
+
+      // +layout.ts
+      import type { LayoutLoad } from './$types';
+
+      export const load: LayoutLoad = async ({ fetch }) => {
+        const user = await fetch('/api/me').then(r => r.json());
+        return { user };
+      };
+
+      // ✅ Route groups for shared layouts
+      // (auth)/login/+page.svelte
+      // (auth)/register/+page.svelte
+      // (auth)/+layout.svelte  <- Shared auth layout
+    severity: HIGH
+    docs_url: https://kit.svelte.dev/docs/routing#layout
+
+  - id: sve011
+    name: Snippets (Svelte 5)
+    category: components
+    version: "5.0+"
+    description: Reusable template snippets replacing slots
+    text: snippet slot render template reusable component
+    example: |
+      <script>
+        // 🆕 Snippets replace slots
+        let { header, children } = $props();
+      </script>
+
+      {#snippet defaultHeader()}
+        <h1>Default Header</h1>
+      {/snippet}
+
+      <header>
+        {@render header?.() ?? defaultHeader()}
+      </header>
+
+      <main>
+        {@render children()}
+      </main>
+
+      <!-- Usage -->
+      <Card>
+        {#snippet header()}
+          <h2>Custom Header</h2>
+        {/snippet}
+
+        <p>Content here</p>
+      </Card>
+
+      <!-- ✅ Snippets with parameters -->
+      {#snippet item(todo)}
+        <li class:done={todo.done}>{todo.text}</li>
+      {/snippet}
+
+      <ul>
+        {#each todos as todo}
+          {@render item(todo)}
+        {/each}
+      </ul>
+    severity: MEDIUM
+    docs_url: https://svelte.dev/docs/svelte/snippet
+
+  - id: sve012
+    name: Async SSR & CSP
+    category: ssr
+    version: "2.x"
+    description: Async server-side rendering and CSP hydration
+    text: async ssr streaming csp security hydration
+    example: |
+      // ✅ SvelteKit 2.x: Async server-side rendering
+      // svelte.config.js
+      export default {
+        kit: {
+          experimental: {
+            asyncSSR: true, // ✅ Enable async SSR
+          },
+        },
+      };
+
+      // ✅ Content Security Policy support for hydration
+      export default {
+        kit: {
+          csp: {
+            mode: 'hash', // 'hash' | 'nonce' | 'auto'
+            directives: {
+              'script-src': ['self'],
+              'style-src': ['self', 'unsafe-inline'],
+            },
+          },
+        },
+      };
+
+      // Benefits of async SSR:
+      // - Streaming responses
+      // - Progressive loading
+      // - Better TTFB
+      // - Suspense-like behavior
+    severity: MEDIUM
+    docs_url: https://kit.svelte.dev/docs/configuration

package/.agent/skills/frameworks/vue/ADVANCED.md

@@ -0,0 +1,214 @@
+# Vue.js — Advanced Patterns
+
+# DOMYH Awesome Code — Tier 3 Reference
+
+## Table of Contents
+
+- [Composition API](#composition-api)
+- [Reactivity System](#reactivity-system)
+- [Performance](#performance)
+- [Testing](#testing)
+
+---
+
+## Composition API
+
+### Composables
+
+```ts
+// useAsync.ts
+export function useAsync<T>(fn: () => Promise<T>) {
+  const data = ref<T | null>(null);
+  const error = ref<Error | null>(null);
+  const loading = ref(false);
+
+  const execute = async () => {
+    loading.value = true;
+    error.value = null;
+    try {
+      data.value = await fn();
+    } catch (e) {
+      error.value = e as Error;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  return { data, error, loading, execute };
+}
+
+// useFetch.ts
+export function useFetch<T>(url: MaybeRef<string>) {
+  const urlRef = toRef(url);
+  const { data, error, loading, execute } = useAsync(() =>
+    fetch(urlRef.value).then((r) => r.json()),
+  );
+
+  watch(urlRef, execute, { immediate: true });
+
+  return { data, error, loading, refresh: execute };
+}
+```
+
+### Provide/Inject with TypeScript
+
+```ts
+// Typed injection key
+const UserKey: InjectionKey<Ref<User>> = Symbol("user");
+
+// Provider
+const user = ref<User>({ id: "1", name: "Admin" });
+provide(UserKey, user);
+
+// Consumer
+const user = inject(UserKey);
+if (!user) throw new Error("User not provided");
+
+// With default
+const user = inject(UserKey, ref({ id: "", name: "Guest" }));
+```
+
+---
+
+## Reactivity System
+
+### Deep vs Shallow
+
+```ts
+// Shallow reactive - only root level reactive
+const state = shallowReactive({
+  nested: { count: 0 },
+});
+state.nested = { count: 1 }; // Triggers update
+state.nested.count = 2; // Does NOT trigger
+
+// ShallowRef for large objects
+const largeData = shallowRef<BigObject>(null);
+largeData.value = newData; // Triggers update
+largeData.value.field = "x"; // Does NOT trigger
+
+// TriggerRef for manual updates
+triggerRef(largeData); // Force trigger
+```
+
+### Custom Ref
+
+```ts
+function useDebouncedRef<T>(value: T, delay = 200) {
+  let timeout: ReturnType<typeof setTimeout>;
+  return customRef((track, trigger) => ({
+    get() {
+      track();
+      return value;
+    },
+    set(newValue) {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        value = newValue;
+        trigger();
+      }, delay);
+    },
+  }));
+}
+
+// Usage
+const searchQuery = useDebouncedRef("", 300);
+```
+
+---
+
+## Performance
+
+### Virtual List
+
+```ts
+// useVirtualList.ts
+export function useVirtualList<T>(
+  items: Ref<T[]>,
+  options: { itemHeight: number; containerHeight: number },
+) {
+  const scrollTop = ref(0);
+
+  const visibleItems = computed(() => {
+    const start = Math.floor(scrollTop.value / options.itemHeight);
+    const visible = Math.ceil(options.containerHeight / options.itemHeight);
+    return {
+      start,
+      end: Math.min(start + visible + 1, items.value.length),
+      items: items.value.slice(start, start + visible + 1),
+    };
+  });
+
+  const totalHeight = computed(() => items.value.length * options.itemHeight);
+
+  const offsetY = computed(() => visibleItems.value.start * options.itemHeight);
+
+  const onScroll = (e: Event) => {
+    scrollTop.value = (e.target as HTMLElement).scrollTop;
+  };
+
+  return { visibleItems, totalHeight, offsetY, onScroll };
+}
+```
+
+### Component Caching
+
+```vue
+<template>
+  <KeepAlive :max="5">
+    <component :is="currentView" :key="route.path" />
+  </KeepAlive>
+</template>
+
+<script setup>
+// Control caching behavior
+onActivated(() => {
+  // Called when component is restored from cache
+  fetchLatestData();
+});
+
+onDeactivated(() => {
+  // Called when component is cached
+  cleanupSubscriptions();
+});
+</script>
+```
+
+---
+
+## Testing
+
+### Component Testing
+
+```ts
+import { mount } from "@vue/test-utils";
+import { createTestingPinia } from "@pinia/testing";
+
+describe("UserList", () => {
+  it("renders users from store", async () => {
+    const wrapper = mount(UserList, {
+      global: {
+        plugins: [
+          createTestingPinia({
+            initialState: {
+              users: { list: [{ id: "1", name: "Test" }] },
+            },
+          }),
+        ],
+      },
+    });
+
+    expect(wrapper.text()).toContain("Test");
+  });
+
+  it("emits select on click", async () => {
+    const wrapper = mount(UserList);
+    await wrapper.find(".user-item").trigger("click");
+    expect(wrapper.emitted("select")).toBeTruthy();
+  });
+});
+```
+
+---
+
+_DOMYH Awesome Code — Tier 3 Reference_

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

@@ -0,0 +1,58 @@
+name: vue
+version: "6.2.0"
+category: frontend
+tier: 3
+
+desc: "Vue 3.5/3.6 development patterns (2025-2026). defineModel, Vapor Mode alpha, deep reactivity."
+
+patterns:
+  total: 11
+  domains:
+    core: 6
+    advanced: 5
+
+hsa:
+  enabled: true
+  adapter: vue_adapter.py
+
+triggers:
+  file_patterns:
+    - "*.vue"
+    - "vue.config.js"
+    - "vite.config.ts"
+    - "nuxt.config.ts"
+  keywords:
+    # Core
+    - vue
+    - vue.js
+    - composition api
+    - script setup
+    - ref
+    - reactive
+    # 3.5+ Features
+    - defineModel
+    - suspense
+    - composable
+    # 3.6 Vapor
+    - vapor mode
+    - vapor
+    # Patterns
+    - provide inject
+    - vueuse
+    - pinia
+  intents:
+    - vue component
+    - vue composable
+    - vue state
+    - vue performance
+    - vue typescript
+
+related_skills:
+  - nuxt
+  - typescript
+  - tailwind
+  - pinia
+
+prevent_confusion_with:
+  - react: "Vue uses templates, React uses JSX"
+  - svelte: "Vue uses VDOM (except Vapor), Svelte compiles away"