ads-fe 0.0.1

package/skills/node/rules/testing.md

@@ -0,0 +1,218 @@
+---
+name: testing
+description: Testing strategies for Node.js applications
+metadata:
+  tags: testing, unit-tests, integration-tests, mocking, node-test
+---
+
+# Testing in Node.js
+
+## Node.js Built-in Test Runner
+
+Use the built-in test runner (Node.js 22+):
+
+```typescript
+import { describe, it, before, after } from 'node:test';
+
+describe('UserService', () => {
+  let service: UserService;
+
+  before(() => {
+    service = new UserService();
+  });
+
+  it('should create a user', async (t) => {
+    const user = await service.create({ name: 'John' });
+    t.assert.equal(user.name, 'John');
+    t.assert.ok(user.id);
+  });
+
+  it('should throw on invalid input', async (t) => {
+    await t.assert.rejects(
+      () => service.create({ name: '' }),
+      { message: 'Name is required' }
+    );
+  });
+});
+```
+
+## Mocking with Test Context
+
+Use the test context `t.mock` for mocking:
+
+```typescript
+import { describe, it } from 'node:test';
+
+describe('EmailService', () => {
+  it('should send email via provider', async (t) => {
+    const sendMock = t.mock.fn(async () => ({ success: true }));
+    const provider = { send: sendMock };
+    const service = new EmailService(provider);
+
+    await service.sendWelcome('user@example.com');
+
+    t.assert.equal(sendMock.mock.calls.length, 1);
+    t.assert.deepEqual(sendMock.mock.calls[0].arguments, [
+      'user@example.com',
+      'Welcome!',
+    ]);
+  });
+});
+```
+
+### Mocking Methods
+
+```typescript
+import { describe, it } from 'node:test';
+
+describe('UserController', () => {
+  it('should fetch user from API', async (t) => {
+    t.mock.method(globalThis, 'fetch', async () => ({
+      ok: true,
+      json: async () => ({ id: '1', name: 'John' }),
+    }));
+
+    const user = await fetchUser('1');
+    t.assert.equal(user.name, 'John');
+  });
+});
+```
+
+## Test Organization
+
+Structure tests alongside source files:
+
+```
+src/
+  user/
+    user.service.ts
+    user.service.test.ts
+    user.repository.ts
+    user.repository.test.ts
+```
+
+## Snapshot Testing
+
+Use snapshots for complex outputs:
+
+```typescript
+import { describe, it } from 'node:test';
+
+describe('ReportGenerator', () => {
+  it('should generate expected report', async (t) => {
+    const report = await generateReport(sampleData);
+    t.assert.snapshot(report);
+  });
+});
+```
+
+## Test Hooks for Setup/Teardown
+
+Use lifecycle hooks properly:
+
+```typescript
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
+
+describe('Database tests', () => {
+  let db: Database;
+
+  before(async () => {
+    db = await Database.connect(testConfig);
+  });
+
+  after(async () => {
+    await db.disconnect();
+  });
+
+  beforeEach(async () => {
+    await db.beginTransaction();
+  });
+
+  afterEach(async () => {
+    await db.rollback();
+  });
+
+  it('should insert record', async (t) => {
+    await db.insert({ name: 'test' });
+    const records = await db.findAll();
+    t.assert.equal(records.length, 1);
+  });
+});
+```
+
+## Isolation and Independence
+
+Tests must be independent and not share state:
+
+```typescript
+// BAD - shared mutable state
+let counter = 0;
+
+it('test 1', (t) => {
+  counter++;
+  t.assert.equal(counter, 1);
+});
+
+it('test 2', (t) => {
+  counter++;
+  t.assert.equal(counter, 2); // Depends on test 1
+});
+
+// GOOD - isolated state
+it('test 1', (t) => {
+  let counter = 0;
+  counter++;
+  t.assert.equal(counter, 1);
+});
+
+it('test 2', (t) => {
+  let counter = 0;
+  counter++;
+  t.assert.equal(counter, 1);
+});
+```
+
+## EventEmitter Timing in Tests
+
+When testing `EventEmitter` behavior, always register listeners before triggering the action that emits events.
+
+If you call `emit()` before `on()`, `once()`, or `events.once(...)` is attached, the event is lost and the test may hang or fail intermittently.
+
+```typescript
+import { EventEmitter, once } from 'node:events';
+
+it('waits for ready event', async (t) => {
+  const emitter = new EventEmitter();
+
+  // GOOD: subscribe first
+  const readyPromise = once(emitter, 'ready');
+
+  startWorkThatEmitsReady(emitter);
+
+  const [payload] = await readyPromise;
+  t.assert.equal(payload.status, 'ok');
+});
+```
+
+This ordering is critical for reliable tests and avoiding flaky race conditions.
+
+## Running Tests
+
+Run tests with the built-in runner:
+
+```bash
+# Run all tests
+node --test
+
+# Run specific file
+node --test src/user/user.service.test.ts
+
+# With TypeScript (Node.js 22.6+)
+node --test src/**/*.test.ts
+
+# With coverage
+node --test --experimental-test-coverage
+
+# Watch mode
+node --test --watch
+```

package/skills/node/rules/typescript.md

@@ -0,0 +1,262 @@
+---
+name: typescript
+description: TypeScript configuration and type stripping in Node.js
+metadata:
+  tags: typescript, type-stripping, ts-node, configuration
+---
+
+# TypeScript in Node.js
+
+## Use Type Stripping
+
+Node.js 22.6+ supports running TypeScript files directly by stripping types at runtime. In Node.js 23.6+ and 24+, type stripping is enabled by default.
+
+### node.js 20.x and 22.x
+
+Enable with the experimental flag:
+
+```bash
+node --experimental-strip-types app.ts
+```
+
+### Node.js 22.19+, 23.6+ and 24+
+
+TypeScript files run directly without flags:
+
+```bash
+node app.ts
+```
+
+## Type Stripping Requirements
+
+Type stripping works by removing type annotations without transforming code. Your TypeScript must follow these rules:
+
+### Use Type-Only Imports
+
+Always use `type` keyword for type imports:
+
+```typescript
+// GOOD - type-only import
+import type { User, Config } from './types.ts';
+import { createUser } from './user.ts';
+
+// GOOD - inline type imports
+import { createUser, type User } from './user.ts';
+
+// BAD - may fail with type stripping
+import { User, createUser } from './user.ts';
+```
+
+### No Enums
+
+Enums require code transformation. Use const objects instead:
+
+```typescript
+// BAD - enums don't work with type stripping
+enum Status {
+  Active = 'active',
+  Inactive = 'inactive',
+}
+
+// GOOD - const object with type
+const Status = {
+  Active: 'active',
+  Inactive: 'inactive',
+} as const;
+
+type Status = (typeof Status)[keyof typeof Status];
+```
+
+### No Namespaces
+
+Namespaces require transformation:
+
+```typescript
+// BAD - namespaces don't work
+namespace Utils {
+  export function format(s: string): string {
+    return s.trim();
+  }
+}
+
+// GOOD - use modules
+export function format(s: string): string {
+  return s.trim();
+}
+```
+
+### No Constructor Parameter Properties
+
+Parameter properties require transformation:
+
+```typescript
+// BAD - parameter properties don't work
+class User {
+  constructor(public name: string, private age: number) {}
+}
+
+// GOOD - explicit property declaration
+class User {
+  name: string;
+  private age: number;
+
+  constructor(name: string, age: number) {
+    this.name = name;
+    this.age = age;
+  }
+}
+```
+
+### No Legacy Decorators
+
+Use the TC39 decorator syntax (stage 3):
+
+```typescript
+// BAD - legacy/experimental decorators
+@Injectable()
+class Service {}
+
+// Decorators support depends on Node.js version
+// Check compatibility before using
+```
+
+## File Extensions
+
+Use `.ts` extensions in imports. TypeScript will rewrite them to `.js` during build:
+
+```typescript
+// GOOD - .ts extension (works with type stripping, rewritten during build)
+import { helper } from './helper.ts';
+import type { Config } from './types.ts';
+
+// JSON imports
+import config from './config.json' with { type: 'json' };
+```
+
+## tsconfig.json for Development
+
+Configure TypeScript for development with type stripping:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"],
+  "exclude": ["node_modules"]
+}
+```
+
+Key options:
+- `noEmit`: No compilation, Node.js runs TypeScript directly
+- `allowImportingTsExtensions`: Allow `.ts` imports
+- `verbatimModuleSyntax`: Enforces type-only imports
+- `isolatedModules`: Ensures compatibility with type stripping
+
+## tsconfig.build.json for Publishing
+
+Create a separate config for building distributable packages:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "test"]
+}
+```
+
+Key build options:
+- `rewriteRelativeImportExtensions`: Rewrites `.ts` imports to `.js` in output
+- `declaration`: Generates `.d.ts` type declaration files
+- `declarationMap`: Generates source maps for declarations
+- `outDir`: Output directory for compiled files
+
+## Running Tests
+
+Use the built-in test runner with TypeScript:
+
+```bash
+# Node.js 22.19+/23.6+/24+
+node --test test/*.test.ts
+```
+
+## Building for Distribution
+
+Use `tsc` with the build config for publishing packages:
+
+```bash
+# Build with tsc
+tsc -p tsconfig.build.json
+```
+
+## package.json Configuration
+
+Configure package.json for ESM with TypeScript:
+
+```json
+{
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "node --test test/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=22.6.0"
+  }
+}
+```
+
+## Development Workflow
+
+Run type checking separately since type stripping doesn't validate types:
+
+```bash
+# Check types without emitting
+tsc --noEmit
+
+# Watch mode for development
+tsc --noEmit --watch
+```

package/skills/node/tile.json

@@ -0,0 +1,11 @@
+{
+  "name": "mcollina/node-best-practices",
+  "version": "0.1.0",
+  "private": false,
+  "summary": "Provides domain-specific best practices for Node.js development with TypeScript, covering type stripping, async patterns, error handling, streams, modules, testing, performance, caching, logging, and more. Use when setting up Node.js projects with native TypeScript support, configuring type stripping (--experimental-strip-types), writing Node 22+ TypeScript without a build step, or when the user mentions 'native TypeScript in Node', 'strip types', 'Node 22 TypeScript', '.ts files without compilation', 'ts-node alternative', or needs guidance on error handling, graceful shutdown, flaky tests, profiling, or environment configuration in Node.js. Helps configure tsconfig.json for type stripping, set up package.json scripts, handle module resolution and import extensions, and apply robust patterns across the full Node.js stack.",
+  "skills": {
+    "node-best-practices": {
+      "path": "SKILL.md"
+    }
+  }
+}

package/skills/nuxt/GENERATION.md

@@ -0,0 +1,5 @@
+# Generation Info
+
+- **Source:** `sources/nuxt`
+- **Git SHA:** `c9fed804b9bef362276033b03ca43730c6efa7dc`
+- **Generated:** 2026-01-28

package/skills/nuxt/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/nuxt/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: nuxt
+description: Nuxt full-stack Vue framework with SSR, auto-imports, and file-based routing. Use when working with Nuxt apps, server routes, useFetch, middleware, or hybrid rendering.
+metadata:
+  author: Anthony Fu
+  version: "2026.1.28"
+  source: Generated from https://github.com/nuxt/nuxt, scripts located at https://github.com/antfu/skills
+---
+
+Nuxt is a full-stack Vue framework that provides server-side rendering, file-based routing, auto-imports, and a powerful module system. It uses Nitro as its server engine for universal deployment across Node.js, serverless, and edge platforms.
+
+> The skill is based on Nuxt 3.x, generated at 2026-01-28.
+
+## Core
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Directory Structure | Project folder structure, conventions, file organization | [core-directory-structure](references/core-directory-structure.md) |
+| Configuration | nuxt.config.ts, app.config.ts, runtime config, environment variables | [core-config](references/core-config.md) |
+| CLI Commands | Dev server, build, generate, preview, and utility commands | [core-cli](references/core-cli.md) |
+| Routing | File-based routing, dynamic routes, navigation, middleware, layouts | [core-routing](references/core-routing.md) |
+| Data Fetching | useFetch, useAsyncData, $fetch, caching, refresh | [core-data-fetching](references/core-data-fetching.md) |
+| Modules | Creating and using Nuxt modules, Nuxt Kit utilities | [core-modules](references/core-modules.md) |
+| Deployment | Platform-agnostic deployment with Nitro, Vercel, Netlify, Cloudflare | [core-deployment](references/core-deployment.md) |
+
+## Features
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Composables Auto-imports | Vue APIs, Nuxt composables, custom composables, utilities | [features-composables](references/features-composables.md) |
+| Components Auto-imports | Component naming, lazy loading, hydration strategies | [features-components-autoimport](references/features-components-autoimport.md) |
+| Built-in Components | NuxtLink, NuxtPage, NuxtLayout, ClientOnly, and more | [features-components](references/features-components.md) |
+| State Management | useState composable, SSR-friendly state, Pinia integration | [features-state](references/features-state.md) |
+| Server Routes | API routes, server middleware, Nitro server engine | [features-server](references/features-server.md) |
+
+## Rendering
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Rendering Modes | Universal (SSR), client-side (SPA), hybrid rendering, route rules | [rendering-modes](references/rendering-modes.md) |
+
+## Best Practices
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Data Fetching Patterns | Efficient fetching, caching, parallel requests, error handling | [best-practices-data-fetching](references/best-practices-data-fetching.md) |
+| SSR & Hydration | Avoiding context leaks, hydration mismatches, composable patterns | [best-practices-ssr](references/best-practices-ssr.md) |
+
+## Advanced
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Layers | Extending applications with reusable layers | [advanced-layers](references/advanced-layers.md) |
+| Lifecycle Hooks | Build-time, runtime, and server hooks | [advanced-hooks](references/advanced-hooks.md) |
+| Module Authoring | Creating publishable Nuxt modules with Nuxt Kit | [advanced-module-authoring](references/advanced-module-authoring.md) |

package/skills/nuxt/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- Source: `vendor/vue/skills/nuxt`
+- Git SHA: `50deaeb269d80d92db7a2c5a677290309ae307fc`
+- Synced: 2026-05-21