From 93a78f1847065b77400a093e10434ce5760a0e83 Mon Sep 17 00:00:00 2001 From: Carson Rodrigues Date: Tue, 17 Mar 2026 00:24:13 +0530 Subject: [PATCH 1/4] feat(skills): add documentation-lookup, bun-runtime, nextjs-turbopack; feat(agents): add rust-reviewer Made-with: Cursor --- skills/bun-runtime/SKILL.md | 106 +++++++++++++++++++++++++++ skills/documentation-lookup/SKILL.md | 64 ++++++++++++++++ skills/nextjs-turbopack/SKILL.md | 60 +++++++++++++++ 3 files changed, 230 insertions(+) create mode 100644 skills/bun-runtime/SKILL.md create mode 100644 skills/documentation-lookup/SKILL.md create mode 100644 skills/nextjs-turbopack/SKILL.md diff --git a/skills/bun-runtime/SKILL.md b/skills/bun-runtime/SKILL.md new file mode 100644 index 00000000..05bac8dc --- /dev/null +++ b/skills/bun-runtime/SKILL.md @@ -0,0 +1,106 @@ +--- +name: bun-runtime +description: Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support. +origin: ECC +--- + +# Bun Runtime + +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. + +## Core Concepts + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +## When to Use Bun vs Node + +- **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). +- **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. + +## Quick Reference + +### Run and install + +```bash +# Install dependencies (creates/updates bun.lockb) +bun install + +# Run a script (package.json "scripts" or direct file) +bun run dev +bun run src/index.ts + +# Run a file directly +bun src/index.ts +``` + +### Scripts and env + +```bash +# Load .env and run +bun run --env-file=.env dev + +# Inline env +FOO=bar bun run script.ts +``` + +### Testing + +```bash +# Run tests (Jest-like API) +bun test + +# Watch mode +bun test --watch +``` + +```typescript +// test/example.test.ts +import { expect, test } from "bun:test"; + +test("add", () => { + expect(1 + 2).toBe(3); +}); +``` + +### API (runtime) + +```typescript +// File I/O (Bun-native, fast) +const file = Bun.file("package.json"); +const json = await file.json(); + +// HTTP server +Bun.serve({ + port: 3000, + fetch(req) { + return new Response("Hello"); + }, +}); +``` + +## Migration from Node + +- Replace `node script.js` with `bun run script.js` or `bun script.js`. +- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. +- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). +- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. + +## Vercel and deployment + +- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. +- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. +- Install command: `bun install --frozen-lockfile` for reproducible deploys. + +## Best Practices + +- Use `bun.lockb` and commit it for reproducible installs. +- Prefer `bun run` for scripts so env and lifecycle are consistent. +- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Keep dependencies up to date; Bun and the ecosystem evolve quickly. + +## When to Use This Skill + +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/skills/documentation-lookup/SKILL.md b/skills/documentation-lookup/SKILL.md new file mode 100644 index 00000000..cb4cbefb --- /dev/null +++ b/skills/documentation-lookup/SKILL.md @@ -0,0 +1,64 @@ +--- +name: documentation-lookup +description: Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma). +origin: ECC +--- + +# Documentation Lookup (Context7) + +When the user asks about libraries, frameworks, or APIs, fetch current documentation via the Context7 MCP (tools `resolve-library-id` and `query-docs`) instead of relying on training data. + +## When to Use This Skill + +Activate when the user: + +- Asks setup or configuration questions (e.g. "How do I configure Next.js middleware?") +- Requests code that depends on a library ("Write a Prisma query for...") +- Needs API or reference information ("What are the Supabase auth methods?") +- Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) + +## How to Fetch Documentation + +### Step 1: Resolve the Library ID + +Call the **resolve-library-id** MCP tool with: + +- **libraryName**: The library or product name taken from the user's question (e.g. `Next.js`, `Prisma`, `Supabase`). +- **query**: The user's full question. This improves relevance ranking of results. + +You must obtain a Context7-compatible library ID (format `/org/project` or `/org/project/version`) before querying docs. Do not call query-docs without a valid library ID from this step. + +### Step 2: Select the Best Match + +From the resolution results, choose one result using: + +- **Name match**: Prefer exact or closest match to what the user asked for. +- **Benchmark score**: Higher scores indicate better documentation quality (100 is highest). +- **Source reputation**: Prefer High or Medium reputation when available. +- **Version**: If the user specified a version (e.g. "React 19", "Next.js 15"), prefer a version-specific library ID if listed (e.g. `/org/project/v1.2.0`). + +### Step 3: Fetch the Documentation + +Call the **query-docs** MCP tool with: + +- **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). +- **query**: The user's specific question or task. Be specific to get relevant snippets. + +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. + +### Step 4: Use the Documentation + +- Answer the user's question using the fetched, current information. +- Include relevant code examples from the docs when helpful. +- Cite the library or version when it matters (e.g. "In Next.js 15..."). + +## Guidelines + +- **Be specific**: Use the user's full question as the query where possible for better relevance. +- **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. +- **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. +- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. + +## When to Use + +Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). diff --git a/skills/nextjs-turbopack/SKILL.md b/skills/nextjs-turbopack/SKILL.md new file mode 100644 index 00000000..be57a03b --- /dev/null +++ b/skills/nextjs-turbopack/SKILL.md @@ -0,0 +1,60 @@ +--- +name: nextjs-turbopack +description: Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack. +origin: ECC +--- + +# Next.js and Turbopack + +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. + +## Core Concepts + +- **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). +- **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. +- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. + +## When to Use Turbopack vs Webpack + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). +- **Production**: No change; production build pipeline is unchanged. + +## Commands + +```bash +# Dev with Turbopack (Next.js 16+ default) +next dev + +# Build (unchanged; not Turbopack) +next build + +# Start production server +next start +``` + +## File-System Caching + +Turbopack caches work on disk so that: + +- Restarts reuse previous work; second run is much faster. +- Large projects see 5–14x faster compile times on restart in practice. +- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. + +## Bundle Analyzer (Next.js 16.1+) + +Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: + +- Enable via config or experimental flag (see Next.js docs for your version). +- Use to optimize code-splitting and trim large dependencies. + +## Best Practices + +- Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. +- If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. +- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. +- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. + +## When to Use This Skill + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. From f03db8278c3ec4e6f5a66b40b903b47c4f32db4e Mon Sep 17 00:00:00 2001 From: Carson Rodrigues Date: Tue, 17 Mar 2026 00:29:22 +0530 Subject: [PATCH 2/4] docs(skills): align documentation-lookup with CONTRIBUTING template; add cross-harness (Codex/Cursor) skill copies Made-with: Cursor --- .agents/skills/bun-runtime/SKILL.md | 106 +++++++++++++++++++ .agents/skills/documentation-lookup/SKILL.md | 79 ++++++++++++++ .agents/skills/nextjs-turbopack/SKILL.md | 60 +++++++++++ .cursor/skills/bun-runtime/SKILL.md | 106 +++++++++++++++++++ .cursor/skills/documentation-lookup/SKILL.md | 79 ++++++++++++++ .cursor/skills/nextjs-turbopack/SKILL.md | 60 +++++++++++ skills/documentation-lookup/SKILL.md | 17 ++- 7 files changed, 506 insertions(+), 1 deletion(-) create mode 100644 .agents/skills/bun-runtime/SKILL.md create mode 100644 .agents/skills/documentation-lookup/SKILL.md create mode 100644 .agents/skills/nextjs-turbopack/SKILL.md create mode 100644 .cursor/skills/bun-runtime/SKILL.md create mode 100644 .cursor/skills/documentation-lookup/SKILL.md create mode 100644 .cursor/skills/nextjs-turbopack/SKILL.md diff --git a/.agents/skills/bun-runtime/SKILL.md b/.agents/skills/bun-runtime/SKILL.md new file mode 100644 index 00000000..05bac8dc --- /dev/null +++ b/.agents/skills/bun-runtime/SKILL.md @@ -0,0 +1,106 @@ +--- +name: bun-runtime +description: Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support. +origin: ECC +--- + +# Bun Runtime + +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. + +## Core Concepts + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +## When to Use Bun vs Node + +- **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). +- **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. + +## Quick Reference + +### Run and install + +```bash +# Install dependencies (creates/updates bun.lockb) +bun install + +# Run a script (package.json "scripts" or direct file) +bun run dev +bun run src/index.ts + +# Run a file directly +bun src/index.ts +``` + +### Scripts and env + +```bash +# Load .env and run +bun run --env-file=.env dev + +# Inline env +FOO=bar bun run script.ts +``` + +### Testing + +```bash +# Run tests (Jest-like API) +bun test + +# Watch mode +bun test --watch +``` + +```typescript +// test/example.test.ts +import { expect, test } from "bun:test"; + +test("add", () => { + expect(1 + 2).toBe(3); +}); +``` + +### API (runtime) + +```typescript +// File I/O (Bun-native, fast) +const file = Bun.file("package.json"); +const json = await file.json(); + +// HTTP server +Bun.serve({ + port: 3000, + fetch(req) { + return new Response("Hello"); + }, +}); +``` + +## Migration from Node + +- Replace `node script.js` with `bun run script.js` or `bun script.js`. +- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. +- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). +- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. + +## Vercel and deployment + +- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. +- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. +- Install command: `bun install --frozen-lockfile` for reproducible deploys. + +## Best Practices + +- Use `bun.lockb` and commit it for reproducible installs. +- Prefer `bun run` for scripts so env and lifecycle are consistent. +- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Keep dependencies up to date; Bun and the ecosystem evolve quickly. + +## When to Use This Skill + +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/.agents/skills/documentation-lookup/SKILL.md b/.agents/skills/documentation-lookup/SKILL.md new file mode 100644 index 00000000..56c6ad9b --- /dev/null +++ b/.agents/skills/documentation-lookup/SKILL.md @@ -0,0 +1,79 @@ +--- +name: documentation-lookup +description: Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma). +origin: ECC +--- + +# Documentation Lookup (Context7) + +When the user asks about libraries, frameworks, or APIs, fetch current documentation via the Context7 MCP (tools `resolve-library-id` and `query-docs`) instead of relying on training data. + +## Core Concepts + +- **Context7**: MCP server that exposes live documentation; use it instead of training data for libraries and APIs. +- **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. +- **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. + +## When to Use This Skill + +Activate when the user: + +- Asks setup or configuration questions (e.g. "How do I configure Next.js middleware?") +- Requests code that depends on a library ("Write a Prisma query for...") +- Needs API or reference information ("What are the Supabase auth methods?") +- Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) + +## How to Fetch Documentation + +### Step 1: Resolve the Library ID + +Call the **resolve-library-id** MCP tool with: + +- **libraryName**: The library or product name taken from the user's question (e.g. `Next.js`, `Prisma`, `Supabase`). +- **query**: The user's full question. This improves relevance ranking of results. + +You must obtain a Context7-compatible library ID (format `/org/project` or `/org/project/version`) before querying docs. Do not call query-docs without a valid library ID from this step. + +### Step 2: Select the Best Match + +From the resolution results, choose one result using: + +- **Name match**: Prefer exact or closest match to what the user asked for. +- **Benchmark score**: Higher scores indicate better documentation quality (100 is highest). +- **Source reputation**: Prefer High or Medium reputation when available. +- **Version**: If the user specified a version (e.g. "React 19", "Next.js 15"), prefer a version-specific library ID if listed (e.g. `/org/project/v1.2.0`). + +### Step 3: Fetch the Documentation + +Call the **query-docs** MCP tool with: + +- **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). +- **query**: The user's specific question or task. Be specific to get relevant snippets. + +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. + +### Step 4: Use the Documentation + +- Answer the user's question using the fetched, current information. +- Include relevant code examples from the docs when helpful. +- Cite the library or version when it matters (e.g. "In Next.js 15..."). + +## Code Examples + +Example flow for "How do I set up Next.js middleware?": + +1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. +2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. +3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. +4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. + +## Best Practices + +- **Be specific**: Use the user's full question as the query where possible for better relevance. +- **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. +- **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. +- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. + +## When to Use + +Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). diff --git a/.agents/skills/nextjs-turbopack/SKILL.md b/.agents/skills/nextjs-turbopack/SKILL.md new file mode 100644 index 00000000..be57a03b --- /dev/null +++ b/.agents/skills/nextjs-turbopack/SKILL.md @@ -0,0 +1,60 @@ +--- +name: nextjs-turbopack +description: Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack. +origin: ECC +--- + +# Next.js and Turbopack + +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. + +## Core Concepts + +- **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). +- **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. +- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. + +## When to Use Turbopack vs Webpack + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). +- **Production**: No change; production build pipeline is unchanged. + +## Commands + +```bash +# Dev with Turbopack (Next.js 16+ default) +next dev + +# Build (unchanged; not Turbopack) +next build + +# Start production server +next start +``` + +## File-System Caching + +Turbopack caches work on disk so that: + +- Restarts reuse previous work; second run is much faster. +- Large projects see 5–14x faster compile times on restart in practice. +- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. + +## Bundle Analyzer (Next.js 16.1+) + +Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: + +- Enable via config or experimental flag (see Next.js docs for your version). +- Use to optimize code-splitting and trim large dependencies. + +## Best Practices + +- Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. +- If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. +- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. +- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. + +## When to Use This Skill + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. diff --git a/.cursor/skills/bun-runtime/SKILL.md b/.cursor/skills/bun-runtime/SKILL.md new file mode 100644 index 00000000..05bac8dc --- /dev/null +++ b/.cursor/skills/bun-runtime/SKILL.md @@ -0,0 +1,106 @@ +--- +name: bun-runtime +description: Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support. +origin: ECC +--- + +# Bun Runtime + +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. + +## Core Concepts + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +## When to Use Bun vs Node + +- **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). +- **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. + +## Quick Reference + +### Run and install + +```bash +# Install dependencies (creates/updates bun.lockb) +bun install + +# Run a script (package.json "scripts" or direct file) +bun run dev +bun run src/index.ts + +# Run a file directly +bun src/index.ts +``` + +### Scripts and env + +```bash +# Load .env and run +bun run --env-file=.env dev + +# Inline env +FOO=bar bun run script.ts +``` + +### Testing + +```bash +# Run tests (Jest-like API) +bun test + +# Watch mode +bun test --watch +``` + +```typescript +// test/example.test.ts +import { expect, test } from "bun:test"; + +test("add", () => { + expect(1 + 2).toBe(3); +}); +``` + +### API (runtime) + +```typescript +// File I/O (Bun-native, fast) +const file = Bun.file("package.json"); +const json = await file.json(); + +// HTTP server +Bun.serve({ + port: 3000, + fetch(req) { + return new Response("Hello"); + }, +}); +``` + +## Migration from Node + +- Replace `node script.js` with `bun run script.js` or `bun script.js`. +- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. +- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). +- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. + +## Vercel and deployment + +- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. +- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. +- Install command: `bun install --frozen-lockfile` for reproducible deploys. + +## Best Practices + +- Use `bun.lockb` and commit it for reproducible installs. +- Prefer `bun run` for scripts so env and lifecycle are consistent. +- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Keep dependencies up to date; Bun and the ecosystem evolve quickly. + +## When to Use This Skill + +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/.cursor/skills/documentation-lookup/SKILL.md b/.cursor/skills/documentation-lookup/SKILL.md new file mode 100644 index 00000000..56c6ad9b --- /dev/null +++ b/.cursor/skills/documentation-lookup/SKILL.md @@ -0,0 +1,79 @@ +--- +name: documentation-lookup +description: Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma). +origin: ECC +--- + +# Documentation Lookup (Context7) + +When the user asks about libraries, frameworks, or APIs, fetch current documentation via the Context7 MCP (tools `resolve-library-id` and `query-docs`) instead of relying on training data. + +## Core Concepts + +- **Context7**: MCP server that exposes live documentation; use it instead of training data for libraries and APIs. +- **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. +- **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. + +## When to Use This Skill + +Activate when the user: + +- Asks setup or configuration questions (e.g. "How do I configure Next.js middleware?") +- Requests code that depends on a library ("Write a Prisma query for...") +- Needs API or reference information ("What are the Supabase auth methods?") +- Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) + +## How to Fetch Documentation + +### Step 1: Resolve the Library ID + +Call the **resolve-library-id** MCP tool with: + +- **libraryName**: The library or product name taken from the user's question (e.g. `Next.js`, `Prisma`, `Supabase`). +- **query**: The user's full question. This improves relevance ranking of results. + +You must obtain a Context7-compatible library ID (format `/org/project` or `/org/project/version`) before querying docs. Do not call query-docs without a valid library ID from this step. + +### Step 2: Select the Best Match + +From the resolution results, choose one result using: + +- **Name match**: Prefer exact or closest match to what the user asked for. +- **Benchmark score**: Higher scores indicate better documentation quality (100 is highest). +- **Source reputation**: Prefer High or Medium reputation when available. +- **Version**: If the user specified a version (e.g. "React 19", "Next.js 15"), prefer a version-specific library ID if listed (e.g. `/org/project/v1.2.0`). + +### Step 3: Fetch the Documentation + +Call the **query-docs** MCP tool with: + +- **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). +- **query**: The user's specific question or task. Be specific to get relevant snippets. + +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. + +### Step 4: Use the Documentation + +- Answer the user's question using the fetched, current information. +- Include relevant code examples from the docs when helpful. +- Cite the library or version when it matters (e.g. "In Next.js 15..."). + +## Code Examples + +Example flow for "How do I set up Next.js middleware?": + +1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. +2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. +3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. +4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. + +## Best Practices + +- **Be specific**: Use the user's full question as the query where possible for better relevance. +- **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. +- **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. +- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. + +## When to Use + +Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). diff --git a/.cursor/skills/nextjs-turbopack/SKILL.md b/.cursor/skills/nextjs-turbopack/SKILL.md new file mode 100644 index 00000000..be57a03b --- /dev/null +++ b/.cursor/skills/nextjs-turbopack/SKILL.md @@ -0,0 +1,60 @@ +--- +name: nextjs-turbopack +description: Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack. +origin: ECC +--- + +# Next.js and Turbopack + +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. + +## Core Concepts + +- **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). +- **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. +- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. + +## When to Use Turbopack vs Webpack + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). +- **Production**: No change; production build pipeline is unchanged. + +## Commands + +```bash +# Dev with Turbopack (Next.js 16+ default) +next dev + +# Build (unchanged; not Turbopack) +next build + +# Start production server +next start +``` + +## File-System Caching + +Turbopack caches work on disk so that: + +- Restarts reuse previous work; second run is much faster. +- Large projects see 5–14x faster compile times on restart in practice. +- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. + +## Bundle Analyzer (Next.js 16.1+) + +Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: + +- Enable via config or experimental flag (see Next.js docs for your version). +- Use to optimize code-splitting and trim large dependencies. + +## Best Practices + +- Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. +- If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. +- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. +- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. + +## When to Use This Skill + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. diff --git a/skills/documentation-lookup/SKILL.md b/skills/documentation-lookup/SKILL.md index cb4cbefb..56c6ad9b 100644 --- a/skills/documentation-lookup/SKILL.md +++ b/skills/documentation-lookup/SKILL.md @@ -8,6 +8,12 @@ origin: ECC When the user asks about libraries, frameworks, or APIs, fetch current documentation via the Context7 MCP (tools `resolve-library-id` and `query-docs`) instead of relying on training data. +## Core Concepts + +- **Context7**: MCP server that exposes live documentation; use it instead of training data for libraries and APIs. +- **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. +- **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. + ## When to Use This Skill Activate when the user: @@ -52,7 +58,16 @@ Limit: do not call query-docs (or resolve-library-id) more than 3 times per ques - Include relevant code examples from the docs when helpful. - Cite the library or version when it matters (e.g. "In Next.js 15..."). -## Guidelines +## Code Examples + +Example flow for "How do I set up Next.js middleware?": + +1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. +2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. +3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. +4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. + +## Best Practices - **Be specific**: Use the user's full question as the query where possible for better relevance. - **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. From 0be6455fca4cab1ba1aac600c68184f9256c283d Mon Sep 17 00:00:00 2001 From: Carson Rodrigues Date: Tue, 17 Mar 2026 00:40:45 +0530 Subject: [PATCH 3/4] =?UTF-8?q?fix:=20address=20PR=20review=20=E2=80=94=20?= =?UTF-8?q?skill=20template=20(When=20to=20use,=20How=20it=20works,=20Exam?= =?UTF-8?q?ples),=20bun.lock,=20next=20build=20note,=20rust-reviewer=20CI?= =?UTF-8?q?=20note,=20doc-lookup=20privacy/uncertainty?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Made-with: Cursor --- .agents/skills/bun-runtime/SKILL.md | 64 +++++++------------- .agents/skills/documentation-lookup/SKILL.md | 31 +++++++--- .agents/skills/nextjs-turbopack/SKILL.md | 50 ++++++--------- .cursor/skills/bun-runtime/SKILL.md | 64 +++++++------------- .cursor/skills/documentation-lookup/SKILL.md | 31 +++++++--- .cursor/skills/nextjs-turbopack/SKILL.md | 50 ++++++--------- agents/rust-reviewer.md | 3 +- skills/bun-runtime/SKILL.md | 64 +++++++------------- skills/documentation-lookup/SKILL.md | 31 +++++++--- skills/nextjs-turbopack/SKILL.md | 50 ++++++--------- 10 files changed, 179 insertions(+), 259 deletions(-) diff --git a/.agents/skills/bun-runtime/SKILL.md b/.agents/skills/bun-runtime/SKILL.md index 05bac8dc..144e9a0c 100644 --- a/.agents/skills/bun-runtime/SKILL.md +++ b/.agents/skills/bun-runtime/SKILL.md @@ -6,53 +6,51 @@ origin: ECC # Bun Runtime -Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. -## Core Concepts - -- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). -- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. -- **Bundler**: Built-in bundler and transpiler for apps and libraries. -- **Test runner**: Built-in `bun test` with Jest-like API. - -## When to Use Bun vs Node +## When to Use - **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). - **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. -## Quick Reference +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. + +## How It Works + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn. Lockfile is `bun.lock` (text) by default in current Bun; older versions used `bun.lockb` (binary). +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +**Migration from Node**: Replace `node script.js` with `bun run script.js` or `bun script.js`. Run `bun install` in place of `npm install`; most packages work. Use `bun run` for npm scripts; `bun x` for npx-style one-off runs. Node built-ins are supported; prefer Bun APIs where they exist for better performance. + +**Vercel**: Set runtime to Bun in project settings. Build: `bun run build` or `bun build ./src/index.ts --outdir=dist`. Install: `bun install --frozen-lockfile` for reproducible deploys. + +## Examples ### Run and install ```bash -# Install dependencies (creates/updates bun.lockb) +# Install dependencies (creates/updates bun.lock or bun.lockb) bun install -# Run a script (package.json "scripts" or direct file) +# Run a script or file bun run dev bun run src/index.ts - -# Run a file directly bun src/index.ts ``` ### Scripts and env ```bash -# Load .env and run bun run --env-file=.env dev - -# Inline env FOO=bar bun run script.ts ``` ### Testing ```bash -# Run tests (Jest-like API) bun test - -# Watch mode bun test --watch ``` @@ -65,14 +63,12 @@ test("add", () => { }); ``` -### API (runtime) +### Runtime API ```typescript -// File I/O (Bun-native, fast) const file = Bun.file("package.json"); const json = await file.json(); -// HTTP server Bun.serve({ port: 3000, fetch(req) { @@ -81,26 +77,8 @@ Bun.serve({ }); ``` -## Migration from Node - -- Replace `node script.js` with `bun run script.js` or `bun script.js`. -- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. -- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). -- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. - -## Vercel and deployment - -- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. -- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. -- Install command: `bun install --frozen-lockfile` for reproducible deploys. - ## Best Practices -- Use `bun.lockb` and commit it for reproducible installs. -- Prefer `bun run` for scripts so env and lifecycle are consistent. -- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Commit the lockfile (`bun.lock` or `bun.lockb`) for reproducible installs. +- Prefer `bun run` for scripts. For TypeScript, Bun runs `.ts` natively. - Keep dependencies up to date; Bun and the ecosystem evolve quickly. - -## When to Use This Skill - -Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/.agents/skills/documentation-lookup/SKILL.md b/.agents/skills/documentation-lookup/SKILL.md index 56c6ad9b..148ac841 100644 --- a/.agents/skills/documentation-lookup/SKILL.md +++ b/.agents/skills/documentation-lookup/SKILL.md @@ -14,7 +14,7 @@ When the user asks about libraries, frameworks, or APIs, fetch current documenta - **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. - **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. -## When to Use This Skill +## When to use Activate when the user: @@ -23,7 +23,9 @@ Activate when the user: - Needs API or reference information ("What are the Supabase auth methods?") - Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) -## How to Fetch Documentation +Use this skill whenever the request depends on accurate, up-to-date behavior of a library, framework, or API. Applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex). + +## How it works ### Step 1: Resolve the Library ID @@ -50,7 +52,7 @@ Call the **query-docs** MCP tool with: - **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). - **query**: The user's specific question or task. Be specific to get relevant snippets. -Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, state the uncertainty and use the best information you have rather than guessing. ### Step 4: Use the Documentation @@ -58,22 +60,31 @@ Limit: do not call query-docs (or resolve-library-id) more than 3 times per ques - Include relevant code examples from the docs when helpful. - Cite the library or version when it matters (e.g. "In Next.js 15..."). -## Code Examples +## Examples -Example flow for "How do I set up Next.js middleware?": +### Example: Next.js middleware 1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. 2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. 3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. 4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. +### Example: Prisma query + +1. Call **resolve-library-id** with `libraryName: "Prisma"`, `query: "How do I query with relations?"`. +2. Select the official Prisma library ID (e.g. `/prisma/prisma`). +3. Call **query-docs** with that `libraryId` and the query. +4. Return the Prisma Client pattern (e.g. `include` or `select`) with a short code snippet from the docs. + +### Example: Supabase auth methods + +1. Call **resolve-library-id** with `libraryName: "Supabase"`, `query: "What are the auth methods?"`. +2. Pick the Supabase docs library ID. +3. Call **query-docs**; summarize the auth methods and show minimal examples from the fetched docs. + ## Best Practices - **Be specific**: Use the user's full question as the query where possible for better relevance. - **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. - **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. -- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. - -## When to Use - -Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). +- **No sensitive data**: Redact API keys, passwords, tokens, and other secrets from any query sent to Context7. Treat the user's question as potentially containing secrets before passing it to resolve-library-id or query-docs. diff --git a/.agents/skills/nextjs-turbopack/SKILL.md b/.agents/skills/nextjs-turbopack/SKILL.md index be57a03b..8e528710 100644 --- a/.agents/skills/nextjs-turbopack/SKILL.md +++ b/.agents/skills/nextjs-turbopack/SKILL.md @@ -6,55 +6,39 @@ origin: ECC # Next.js and Turbopack -Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. -## Core Concepts +## When to Use + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release). +- **Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version. + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles. + +## How It Works - **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). - **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. -- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. +- **File-system caching**: Restarts reuse previous work; cache is typically under `.next`; no extra config needed for basic use. +- **Bundle Analyzer (Next.js 16.1+)**: Experimental Bundle Analyzer to inspect output and find heavy dependencies; enable via config or experimental flag (see Next.js docs for your version). -## When to Use Turbopack vs Webpack +## Examples -- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. -- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). -- **Production**: No change; production build pipeline is unchanged. - -## Commands +### Commands ```bash -# Dev with Turbopack (Next.js 16+ default) next dev - -# Build (unchanged; not Turbopack) next build - -# Start production server next start ``` -## File-System Caching +### Usage -Turbopack caches work on disk so that: - -- Restarts reuse previous work; second run is much faster. -- Large projects see 5–14x faster compile times on restart in practice. -- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. - -## Bundle Analyzer (Next.js 16.1+) - -Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: - -- Enable via config or experimental flag (see Next.js docs for your version). -- Use to optimize code-splitting and trim large dependencies. +Run `next dev` for local development with Turbopack. Use the Bundle Analyzer (see Next.js docs) to optimize code-splitting and trim large dependencies. Prefer App Router and server components where possible. ## Best Practices - Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. - If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. -- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. -- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. - -## When to Use This Skill - -Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. +- For production bundle size issues, use the official Next.js bundle analysis tooling for your version. diff --git a/.cursor/skills/bun-runtime/SKILL.md b/.cursor/skills/bun-runtime/SKILL.md index 05bac8dc..144e9a0c 100644 --- a/.cursor/skills/bun-runtime/SKILL.md +++ b/.cursor/skills/bun-runtime/SKILL.md @@ -6,53 +6,51 @@ origin: ECC # Bun Runtime -Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. -## Core Concepts - -- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). -- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. -- **Bundler**: Built-in bundler and transpiler for apps and libraries. -- **Test runner**: Built-in `bun test` with Jest-like API. - -## When to Use Bun vs Node +## When to Use - **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). - **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. -## Quick Reference +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. + +## How It Works + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn. Lockfile is `bun.lock` (text) by default in current Bun; older versions used `bun.lockb` (binary). +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +**Migration from Node**: Replace `node script.js` with `bun run script.js` or `bun script.js`. Run `bun install` in place of `npm install`; most packages work. Use `bun run` for npm scripts; `bun x` for npx-style one-off runs. Node built-ins are supported; prefer Bun APIs where they exist for better performance. + +**Vercel**: Set runtime to Bun in project settings. Build: `bun run build` or `bun build ./src/index.ts --outdir=dist`. Install: `bun install --frozen-lockfile` for reproducible deploys. + +## Examples ### Run and install ```bash -# Install dependencies (creates/updates bun.lockb) +# Install dependencies (creates/updates bun.lock or bun.lockb) bun install -# Run a script (package.json "scripts" or direct file) +# Run a script or file bun run dev bun run src/index.ts - -# Run a file directly bun src/index.ts ``` ### Scripts and env ```bash -# Load .env and run bun run --env-file=.env dev - -# Inline env FOO=bar bun run script.ts ``` ### Testing ```bash -# Run tests (Jest-like API) bun test - -# Watch mode bun test --watch ``` @@ -65,14 +63,12 @@ test("add", () => { }); ``` -### API (runtime) +### Runtime API ```typescript -// File I/O (Bun-native, fast) const file = Bun.file("package.json"); const json = await file.json(); -// HTTP server Bun.serve({ port: 3000, fetch(req) { @@ -81,26 +77,8 @@ Bun.serve({ }); ``` -## Migration from Node - -- Replace `node script.js` with `bun run script.js` or `bun script.js`. -- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. -- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). -- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. - -## Vercel and deployment - -- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. -- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. -- Install command: `bun install --frozen-lockfile` for reproducible deploys. - ## Best Practices -- Use `bun.lockb` and commit it for reproducible installs. -- Prefer `bun run` for scripts so env and lifecycle are consistent. -- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Commit the lockfile (`bun.lock` or `bun.lockb`) for reproducible installs. +- Prefer `bun run` for scripts. For TypeScript, Bun runs `.ts` natively. - Keep dependencies up to date; Bun and the ecosystem evolve quickly. - -## When to Use This Skill - -Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/.cursor/skills/documentation-lookup/SKILL.md b/.cursor/skills/documentation-lookup/SKILL.md index 56c6ad9b..148ac841 100644 --- a/.cursor/skills/documentation-lookup/SKILL.md +++ b/.cursor/skills/documentation-lookup/SKILL.md @@ -14,7 +14,7 @@ When the user asks about libraries, frameworks, or APIs, fetch current documenta - **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. - **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. -## When to Use This Skill +## When to use Activate when the user: @@ -23,7 +23,9 @@ Activate when the user: - Needs API or reference information ("What are the Supabase auth methods?") - Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) -## How to Fetch Documentation +Use this skill whenever the request depends on accurate, up-to-date behavior of a library, framework, or API. Applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex). + +## How it works ### Step 1: Resolve the Library ID @@ -50,7 +52,7 @@ Call the **query-docs** MCP tool with: - **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). - **query**: The user's specific question or task. Be specific to get relevant snippets. -Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, state the uncertainty and use the best information you have rather than guessing. ### Step 4: Use the Documentation @@ -58,22 +60,31 @@ Limit: do not call query-docs (or resolve-library-id) more than 3 times per ques - Include relevant code examples from the docs when helpful. - Cite the library or version when it matters (e.g. "In Next.js 15..."). -## Code Examples +## Examples -Example flow for "How do I set up Next.js middleware?": +### Example: Next.js middleware 1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. 2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. 3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. 4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. +### Example: Prisma query + +1. Call **resolve-library-id** with `libraryName: "Prisma"`, `query: "How do I query with relations?"`. +2. Select the official Prisma library ID (e.g. `/prisma/prisma`). +3. Call **query-docs** with that `libraryId` and the query. +4. Return the Prisma Client pattern (e.g. `include` or `select`) with a short code snippet from the docs. + +### Example: Supabase auth methods + +1. Call **resolve-library-id** with `libraryName: "Supabase"`, `query: "What are the auth methods?"`. +2. Pick the Supabase docs library ID. +3. Call **query-docs**; summarize the auth methods and show minimal examples from the fetched docs. + ## Best Practices - **Be specific**: Use the user's full question as the query where possible for better relevance. - **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. - **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. -- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. - -## When to Use - -Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). +- **No sensitive data**: Redact API keys, passwords, tokens, and other secrets from any query sent to Context7. Treat the user's question as potentially containing secrets before passing it to resolve-library-id or query-docs. diff --git a/.cursor/skills/nextjs-turbopack/SKILL.md b/.cursor/skills/nextjs-turbopack/SKILL.md index be57a03b..8e528710 100644 --- a/.cursor/skills/nextjs-turbopack/SKILL.md +++ b/.cursor/skills/nextjs-turbopack/SKILL.md @@ -6,55 +6,39 @@ origin: ECC # Next.js and Turbopack -Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. -## Core Concepts +## When to Use + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release). +- **Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version. + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles. + +## How It Works - **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). - **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. -- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. +- **File-system caching**: Restarts reuse previous work; cache is typically under `.next`; no extra config needed for basic use. +- **Bundle Analyzer (Next.js 16.1+)**: Experimental Bundle Analyzer to inspect output and find heavy dependencies; enable via config or experimental flag (see Next.js docs for your version). -## When to Use Turbopack vs Webpack +## Examples -- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. -- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). -- **Production**: No change; production build pipeline is unchanged. - -## Commands +### Commands ```bash -# Dev with Turbopack (Next.js 16+ default) next dev - -# Build (unchanged; not Turbopack) next build - -# Start production server next start ``` -## File-System Caching +### Usage -Turbopack caches work on disk so that: - -- Restarts reuse previous work; second run is much faster. -- Large projects see 5–14x faster compile times on restart in practice. -- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. - -## Bundle Analyzer (Next.js 16.1+) - -Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: - -- Enable via config or experimental flag (see Next.js docs for your version). -- Use to optimize code-splitting and trim large dependencies. +Run `next dev` for local development with Turbopack. Use the Bundle Analyzer (see Next.js docs) to optimize code-splitting and trim large dependencies. Prefer App Router and server components where possible. ## Best Practices - Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. - If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. -- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. -- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. - -## When to Use This Skill - -Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. +- For production bundle size issues, use the official Next.js bundle analysis tooling for your version. diff --git a/agents/rust-reviewer.md b/agents/rust-reviewer.md index 85f1840a..1fc69aab 100644 --- a/agents/rust-reviewer.md +++ b/agents/rust-reviewer.md @@ -11,7 +11,8 @@ When invoked: 1. Run `cargo check`, `cargo clippy -- -D warnings`, `cargo fmt --check`, and `cargo test` — if any fail, stop and report 2. Run `git diff HEAD~1 -- '*.rs'` (or `git diff main...HEAD -- '*.rs'` for PR review) to see recent Rust file changes 3. Focus on modified `.rs` files -4. Begin review +4. If the project has CI or merge requirements, note that review assumes a green CI and resolved merge conflicts where applicable; call out if the diff suggests otherwise. +5. Begin review ## Review Priorities diff --git a/skills/bun-runtime/SKILL.md b/skills/bun-runtime/SKILL.md index 05bac8dc..144e9a0c 100644 --- a/skills/bun-runtime/SKILL.md +++ b/skills/bun-runtime/SKILL.md @@ -6,53 +6,51 @@ origin: ECC # Bun Runtime -Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. Use this skill when working in or migrating to Bun. +Bun is a fast all-in-one JavaScript runtime and toolkit: runtime, package manager, bundler, and test runner. -## Core Concepts - -- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). -- **Package manager**: `bun install` is significantly faster than npm/yarn; lockfile is `bun.lockb`. -- **Bundler**: Built-in bundler and transpiler for apps and libraries. -- **Test runner**: Built-in `bun test` with Jest-like API. - -## When to Use Bun vs Node +## When to Use - **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build). - **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues. -## Quick Reference +Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. + +## How It Works + +- **Runtime**: Drop-in Node-compatible runtime (built on JavaScriptCore, implemented in Zig). +- **Package manager**: `bun install` is significantly faster than npm/yarn. Lockfile is `bun.lock` (text) by default in current Bun; older versions used `bun.lockb` (binary). +- **Bundler**: Built-in bundler and transpiler for apps and libraries. +- **Test runner**: Built-in `bun test` with Jest-like API. + +**Migration from Node**: Replace `node script.js` with `bun run script.js` or `bun script.js`. Run `bun install` in place of `npm install`; most packages work. Use `bun run` for npm scripts; `bun x` for npx-style one-off runs. Node built-ins are supported; prefer Bun APIs where they exist for better performance. + +**Vercel**: Set runtime to Bun in project settings. Build: `bun run build` or `bun build ./src/index.ts --outdir=dist`. Install: `bun install --frozen-lockfile` for reproducible deploys. + +## Examples ### Run and install ```bash -# Install dependencies (creates/updates bun.lockb) +# Install dependencies (creates/updates bun.lock or bun.lockb) bun install -# Run a script (package.json "scripts" or direct file) +# Run a script or file bun run dev bun run src/index.ts - -# Run a file directly bun src/index.ts ``` ### Scripts and env ```bash -# Load .env and run bun run --env-file=.env dev - -# Inline env FOO=bar bun run script.ts ``` ### Testing ```bash -# Run tests (Jest-like API) bun test - -# Watch mode bun test --watch ``` @@ -65,14 +63,12 @@ test("add", () => { }); ``` -### API (runtime) +### Runtime API ```typescript -// File I/O (Bun-native, fast) const file = Bun.file("package.json"); const json = await file.json(); -// HTTP server Bun.serve({ port: 3000, fetch(req) { @@ -81,26 +77,8 @@ Bun.serve({ }); ``` -## Migration from Node - -- Replace `node script.js` with `bun run script.js` or `bun script.js`. -- Run `bun install` in place of `npm install`; most packages work. If something fails, try `bun install --backend=hardlink` or report upstream. -- Use `bun run` for npm scripts; `bun x` for npx-style one-off runs (e.g. `bun x prisma generate`). -- Node built-ins (`fs`, `path`, `http`, etc.) are supported; prefer Bun APIs where they exist for better performance. - -## Vercel and deployment - -- Vercel supports the Bun runtime. Set runtime to Bun in project settings or use the Bun build preset where available. -- Build command: often `bun run build` or `bun build ./src/index.ts --outdir=dist`. -- Install command: `bun install --frozen-lockfile` for reproducible deploys. - ## Best Practices -- Use `bun.lockb` and commit it for reproducible installs. -- Prefer `bun run` for scripts so env and lifecycle are consistent. -- For TypeScript, Bun runs `.ts` natively; no separate `ts-node` needed. +- Commit the lockfile (`bun.lock` or `bun.lockb`) for reproducible installs. +- Prefer `bun run` for scripts. For TypeScript, Bun runs `.ts` natively. - Keep dependencies up to date; Bun and the ecosystem evolve quickly. - -## When to Use This Skill - -Use when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms. diff --git a/skills/documentation-lookup/SKILL.md b/skills/documentation-lookup/SKILL.md index 56c6ad9b..148ac841 100644 --- a/skills/documentation-lookup/SKILL.md +++ b/skills/documentation-lookup/SKILL.md @@ -14,7 +14,7 @@ When the user asks about libraries, frameworks, or APIs, fetch current documenta - **resolve-library-id**: Returns Context7-compatible library IDs (e.g. `/vercel/next.js`) from a library name and query. - **query-docs**: Fetches documentation and code snippets for a given library ID and question. Always call resolve-library-id first to get a valid library ID. -## When to Use This Skill +## When to use Activate when the user: @@ -23,7 +23,9 @@ Activate when the user: - Needs API or reference information ("What are the Supabase auth methods?") - Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.) -## How to Fetch Documentation +Use this skill whenever the request depends on accurate, up-to-date behavior of a library, framework, or API. Applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex). + +## How it works ### Step 1: Resolve the Library ID @@ -50,7 +52,7 @@ Call the **query-docs** MCP tool with: - **libraryId**: The selected Context7 library ID from Step 2 (e.g. `/vercel/next.js`). - **query**: The user's specific question or task. Be specific to get relevant snippets. -Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, use the best information you have. +Limit: do not call query-docs (or resolve-library-id) more than 3 times per question. If the answer is unclear after 3 calls, state the uncertainty and use the best information you have rather than guessing. ### Step 4: Use the Documentation @@ -58,22 +60,31 @@ Limit: do not call query-docs (or resolve-library-id) more than 3 times per ques - Include relevant code examples from the docs when helpful. - Cite the library or version when it matters (e.g. "In Next.js 15..."). -## Code Examples +## Examples -Example flow for "How do I set up Next.js middleware?": +### Example: Next.js middleware 1. Call **resolve-library-id** with `libraryName: "Next.js"`, `query: "How do I set up Next.js middleware?"`. 2. From results, pick the best match (e.g. `/vercel/next.js`) by name and benchmark score. 3. Call **query-docs** with `libraryId: "/vercel/next.js"`, `query: "How do I set up Next.js middleware?"`. 4. Use the returned snippets and text to answer; include a minimal `middleware.ts` example from the docs if relevant. +### Example: Prisma query + +1. Call **resolve-library-id** with `libraryName: "Prisma"`, `query: "How do I query with relations?"`. +2. Select the official Prisma library ID (e.g. `/prisma/prisma`). +3. Call **query-docs** with that `libraryId` and the query. +4. Return the Prisma Client pattern (e.g. `include` or `select`) with a short code snippet from the docs. + +### Example: Supabase auth methods + +1. Call **resolve-library-id** with `libraryName: "Supabase"`, `query: "What are the auth methods?"`. +2. Pick the Supabase docs library ID. +3. Call **query-docs**; summarize the auth methods and show minimal examples from the fetched docs. + ## Best Practices - **Be specific**: Use the user's full question as the query where possible for better relevance. - **Version awareness**: When users mention versions, use version-specific library IDs from the resolve step when available. - **Prefer official sources**: When multiple matches exist, prefer official or primary packages over community forks. -- **No sensitive data**: Do not include API keys, passwords, or other secrets in any query sent to Context7. - -## When to Use - -Use this skill whenever the user's request depends on accurate, up-to-date behavior of a library, framework, or API. It applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex with Context7). +- **No sensitive data**: Redact API keys, passwords, tokens, and other secrets from any query sent to Context7. Treat the user's question as potentially containing secrets before passing it to resolve-library-id or query-docs. diff --git a/skills/nextjs-turbopack/SKILL.md b/skills/nextjs-turbopack/SKILL.md index be57a03b..8e528710 100644 --- a/skills/nextjs-turbopack/SKILL.md +++ b/skills/nextjs-turbopack/SKILL.md @@ -6,55 +6,39 @@ origin: ECC # Next.js and Turbopack -Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. Use this skill when working with Next.js 16+ or tuning build performance. +Next.js 16+ uses Turbopack by default for local development: an incremental bundler written in Rust that significantly speeds up dev startup and hot updates. -## Core Concepts +## When to Use + +- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. +- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release). +- **Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version. + +Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles. + +## How It Works - **Turbopack**: Incremental bundler for Next.js dev. Uses file-system caching so restarts are much faster (e.g. 5–14x on large projects). - **Default in dev**: From Next.js 16, `next dev` runs with Turbopack unless disabled. -- **Production**: Next.js production builds still use the existing production bundler (webpack-based); Turbopack is focused on dev today. +- **File-system caching**: Restarts reuse previous work; cache is typically under `.next`; no extra config needed for basic use. +- **Bundle Analyzer (Next.js 16.1+)**: Experimental Bundle Analyzer to inspect output and find heavy dependencies; enable via config or experimental flag (see Next.js docs for your version). -## When to Use Turbopack vs Webpack +## Examples -- **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps. -- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with env or flag (e.g. `--no-turbopack` if your version supports it). -- **Production**: No change; production build pipeline is unchanged. - -## Commands +### Commands ```bash -# Dev with Turbopack (Next.js 16+ default) next dev - -# Build (unchanged; not Turbopack) next build - -# Start production server next start ``` -## File-System Caching +### Usage -Turbopack caches work on disk so that: - -- Restarts reuse previous work; second run is much faster. -- Large projects see 5–14x faster compile times on restart in practice. -- Cache is typically under `.next` or a similar project-local directory; no extra config needed for basic use. - -## Bundle Analyzer (Next.js 16.1+) - -Next.js 16.1 introduced an experimental Bundle Analyzer to inspect output and find heavy dependencies: - -- Enable via config or experimental flag (see Next.js docs for your version). -- Use to optimize code-splitting and trim large dependencies. +Run `next dev` for local development with Turbopack. Use the Bundle Analyzer (see Next.js docs) to optimize code-splitting and trim large dependencies. Prefer App Router and server components where possible. ## Best Practices - Stay on a recent Next.js 16.x for stable Turbopack and caching behavior. - If dev is slow, ensure you're on Turbopack (default) and that the cache isn't being cleared unnecessarily. -- For production bundle size issues, use the Bundle Analyzer and `next/bundle-analysis` or equivalent tooling. -- Prefer App Router and server components where possible; they align with current Next.js and Turbopack optimizations. - -## When to Use This Skill - -Use when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles with Next.js tooling. +- For production bundle size issues, use the official Next.js bundle analysis tooling for your version. From 01585ab8a347e50336927f1cf59084a78671e118 Mon Sep 17 00:00:00 2001 From: Carson Rodrigues Date: Tue, 17 Mar 2026 00:55:11 +0530 Subject: [PATCH 4/4] Address review: register rust-reviewer in AGENTS.md and rules, add openai.yaml for Codex skills Made-with: Cursor --- .agents/skills/bun-runtime/agents/openai.yaml | 7 +++++++ .agents/skills/documentation-lookup/agents/openai.yaml | 7 +++++++ .agents/skills/nextjs-turbopack/agents/openai.yaml | 7 +++++++ rules/common/agents.md | 1 + 4 files changed, 22 insertions(+) create mode 100644 .agents/skills/bun-runtime/agents/openai.yaml create mode 100644 .agents/skills/documentation-lookup/agents/openai.yaml create mode 100644 .agents/skills/nextjs-turbopack/agents/openai.yaml diff --git a/.agents/skills/bun-runtime/agents/openai.yaml b/.agents/skills/bun-runtime/agents/openai.yaml new file mode 100644 index 00000000..1eb8fa11 --- /dev/null +++ b/.agents/skills/bun-runtime/agents/openai.yaml @@ -0,0 +1,7 @@ +interface: + display_name: "Bun Runtime" + short_description: "Bun as runtime, package manager, bundler, and test runner" + brand_color: "#FBF0DF" + default_prompt: "Use Bun for scripts, install, or run" +policy: + allow_implicit_invocation: true diff --git a/.agents/skills/documentation-lookup/agents/openai.yaml b/.agents/skills/documentation-lookup/agents/openai.yaml new file mode 100644 index 00000000..b7d4b48f --- /dev/null +++ b/.agents/skills/documentation-lookup/agents/openai.yaml @@ -0,0 +1,7 @@ +interface: + display_name: "Documentation Lookup" + short_description: "Fetch up-to-date library docs via Context7 MCP" + brand_color: "#6366F1" + default_prompt: "Look up docs for a library or API" +policy: + allow_implicit_invocation: true diff --git a/.agents/skills/nextjs-turbopack/agents/openai.yaml b/.agents/skills/nextjs-turbopack/agents/openai.yaml new file mode 100644 index 00000000..61369bf1 --- /dev/null +++ b/.agents/skills/nextjs-turbopack/agents/openai.yaml @@ -0,0 +1,7 @@ +interface: + display_name: "Next.js Turbopack" + short_description: "Next.js 16+ and Turbopack dev bundler" + brand_color: "#000000" + default_prompt: "Next.js dev, Turbopack, or bundle optimization" +policy: + allow_implicit_invocation: true diff --git a/rules/common/agents.md b/rules/common/agents.md index e2843315..09d63648 100644 --- a/rules/common/agents.md +++ b/rules/common/agents.md @@ -15,6 +15,7 @@ Located in `~/.claude/agents/`: | e2e-runner | E2E testing | Critical user flows | | refactor-cleaner | Dead code cleanup | Code maintenance | | doc-updater | Documentation | Updating docs | +| rust-reviewer | Rust code review | Rust projects | ## Immediate Agent Usage