@frontmcp/skills 1.0.0-beta.9 → 1.0.0

package/catalog/frontmcp-setup/examples/setup-redis/docker-redis-local-dev.md

@@ -0,0 +1,88 @@
+---
+name: docker-redis-local-dev
+reference: setup-redis
+level: basic
+description: 'Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.'
+tags: [setup, docker-compose, redis, docker, session, local]
+features:
+  - 'Docker Compose with Redis 7 Alpine, AOF persistence, and health checks'
+  - "`redis` config in `@FrontMcp` with `provider: 'redis'` and environment variable fallbacks"
+  - '`--appendonly yes` preserves data across container restarts'
+  - "`keyPrefix: 'mcp:'` namespaces all session keys"
+---
+
+# Docker Redis for Local Development
+
+Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.
+
+## Code
+
+```yaml
+# docker-compose.yml
+services:
+  redis:
+    image: redis:7-alpine
+    ports:
+      - '6379:6379'
+    volumes:
+      - redis_data:/data
+    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
+    healthcheck:
+      test: ['CMD', 'redis-cli', 'ping']
+      interval: 10s
+      timeout: 3s
+      retries: 3
+
+volumes:
+  redis_data:
+```
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'my-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  redis: {
+    provider: 'redis',
+    host: process.env['REDIS_HOST'] ?? 'localhost',
+    port: parseInt(process.env['REDIS_PORT'] ?? '6379', 10),
+    keyPrefix: 'mcp:',
+  },
+})
+export default class Server {}
+```
+
+```env
+# .env
+REDIS_HOST=localhost
+REDIS_PORT=6379
+```
+
+```bash
+# Start Redis and verify
+docker compose up -d redis
+docker compose exec redis redis-cli ping
+# Expected: PONG
+
+# Start the FrontMCP server
+frontmcp dev
+
+# Verify session keys after an MCP request
+redis-cli -h localhost -p 6379 keys "mcp:*"
+```
+
+## What This Demonstrates
+
+- Docker Compose with Redis 7 Alpine, AOF persistence, and health checks
+- `redis` config in `@FrontMcp` with `provider: 'redis'` and environment variable fallbacks
+- `--appendonly yes` preserves data across container restarts
+- `keyPrefix: 'mcp:'` namespaces all session keys
+
+## Related
+
+- See `setup-redis` for Vercel KV, TLS connections, and pub/sub configuration

package/catalog/frontmcp-setup/examples/setup-redis/hybrid-vercel-kv-with-pubsub.md

@@ -0,0 +1,78 @@
+---
+name: hybrid-vercel-kv-with-pubsub
+reference: setup-redis
+level: advanced
+description: 'Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions.'
+tags: [setup, vercel-kv, redis, vercel, session, hybrid]
+features:
+  - 'Vercel KV handles sessions (`redis` config) while a real Redis handles pub/sub (`pubsub` config)'
+  - 'Vercel KV does not support pub/sub operations, so a separate Redis instance is required'
+  - 'Resources with `subscribe: true` rely on the `pubsub` config for real-time notifications'
+  - "The `pubsub` field accepts `provider: 'redis'` only (no Vercel KV support)"
+---
+
+# Hybrid Vercel KV with Redis Pub/Sub
+
+Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions.
+
+## Code
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'my-hybrid-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  transport: { protocol: 'modern' },
+  redis: {
+    provider: 'vercel-kv',
+    keyPrefix: 'mcp:',
+  },
+  pubsub: {
+    provider: 'redis',
+    host: process.env['REDIS_PUBSUB_HOST'] ?? 'localhost',
+    port: parseInt(process.env['REDIS_PUBSUB_PORT'] ?? '6379', 10),
+    password: process.env['REDIS_PUBSUB_PASSWORD'],
+  },
+})
+export default class Server {}
+```
+
+```typescript
+// src/resources/live-metrics.resource.ts
+import { Resource, ResourceContext } from '@frontmcp/sdk';
+
+@Resource({
+  uri: 'metrics://live',
+  name: 'Live Metrics',
+  mimeType: 'application/json',
+  subscribe: true,
+})
+export default class LiveMetricsResource extends ResourceContext {
+  async read() {
+    return { contents: [{ uri: 'metrics://live', text: '{"cpu":45,"memory":72}' }] };
+  }
+}
+```
+
+```env
+# .env
+REDIS_PUBSUB_HOST=redis.internal
+REDIS_PUBSUB_PORT=6379
+REDIS_PUBSUB_PASSWORD=secret
+```
+
+## What This Demonstrates
+
+- Vercel KV handles sessions (`redis` config) while a real Redis handles pub/sub (`pubsub` config)
+- Vercel KV does not support pub/sub operations, so a separate Redis instance is required
+- Resources with `subscribe: true` rely on the `pubsub` config for real-time notifications
+- The `pubsub` field accepts `provider: 'redis'` only (no Vercel KV support)
+
+## Related
+
+- See `setup-redis` for single-provider Redis setups and session store factory usage

package/catalog/frontmcp-setup/examples/setup-redis/vercel-kv-serverless.md

@@ -0,0 +1,78 @@
+---
+name: vercel-kv-serverless
+reference: setup-redis
+level: intermediate
+description: 'Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.'
+tags: [setup, vercel-kv, redis, vercel, session, transport]
+features:
+  - "`provider: 'vercel-kv'` for managed Redis-compatible storage on Vercel"
+  - "`transport: { protocol: 'modern' }` required for Streamable HTTP on serverless"
+  - 'Vercel auto-injects `KV_REST_API_URL` and `KV_REST_API_TOKEN` in production'
+  - 'Explicit `url` and `token` fields for local testing outside Vercel'
+---
+
+# Vercel KV for Serverless Deployment
+
+Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.
+
+## Code
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'my-vercel-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  transport: { protocol: 'modern' },
+  redis: {
+    provider: 'vercel-kv',
+    keyPrefix: 'mcp:',
+    defaultTtlMs: 3600000,
+  },
+})
+export default class Server {}
+```
+
+For testing Vercel KV locally with explicit credentials:
+
+```typescript
+// src/main.ts (local testing variant)
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'my-vercel-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  transport: { protocol: 'modern' },
+  redis: {
+    provider: 'vercel-kv',
+    url: process.env['KV_REST_API_URL'],
+    token: process.env['KV_REST_API_TOKEN'],
+    keyPrefix: 'mcp:',
+  },
+})
+export default class Server {}
+```
+
+```env
+# .env.local (for local testing; Vercel auto-injects these in production)
+KV_REST_API_URL=https://your-kv.kv.vercel-storage.com
+KV_REST_API_TOKEN=your-token
+```
+
+## What This Demonstrates
+
+- `provider: 'vercel-kv'` for managed Redis-compatible storage on Vercel
+- `transport: { protocol: 'modern' }` required for Streamable HTTP on serverless
+- Vercel auto-injects `KV_REST_API_URL` and `KV_REST_API_TOKEN` in production
+- Explicit `url` and `token` fields for local testing outside Vercel
+
+## Related
+
+- See `setup-redis` for Docker provisioning and hybrid pub/sub with Vercel KV

package/catalog/frontmcp-setup/examples/setup-sqlite/basic-sqlite-setup.md

@@ -0,0 +1,75 @@
+---
+name: basic-sqlite-setup
+reference: setup-sqlite
+level: basic
+description: 'Configure a FrontMCP server with SQLite for local session storage with WAL mode enabled.'
+tags: [setup, sqlite, session, database, local]
+features:
+  - '`@frontmcp/storage-sqlite` and `better-sqlite3` as required dependencies'
+  - '`sqlite` config in `@FrontMcp` with `path` and `walMode`'
+  - 'WAL mode creates three files (`.sqlite`, `.sqlite-wal`, `.sqlite-shm`)'
+  - 'Tilde-prefixed paths for stable storage across working directories'
+---
+
+# Basic SQLite Setup
+
+Configure a FrontMCP server with SQLite for local session storage with WAL mode enabled.
+
+## Code
+
+```bash
+# Install the native dependency
+yarn add @frontmcp/storage-sqlite better-sqlite3
+yarn add -D @types/better-sqlite3
+
+# Verify the native module loads
+node -e "require('better-sqlite3')"
+```
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'my-cli-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  sqlite: {
+    path: '~/.frontmcp/data/sessions.sqlite',
+    walMode: true,
+  },
+})
+export default class Server {}
+```
+
+```env
+# .env
+SQLITE_DB_PATH=~/.frontmcp/data/sessions.sqlite
+```
+
+```bash
+# Start the server
+frontmcp dev
+
+# Verify the database file was created
+ls -la ~/.frontmcp/data/sessions.sqlite
+ls -la ~/.frontmcp/data/sessions.sqlite-wal
+ls -la ~/.frontmcp/data/sessions.sqlite-shm
+
+# Inspect the database after at least one session
+sqlite3 ~/.frontmcp/data/sessions.sqlite ".tables"
+sqlite3 ~/.frontmcp/data/sessions.sqlite "SELECT key FROM kv_store LIMIT 5;"
+```
+
+## What This Demonstrates
+
+- `@frontmcp/storage-sqlite` and `better-sqlite3` as required dependencies
+- `sqlite` config in `@FrontMcp` with `path` and `walMode`
+- WAL mode creates three files (`.sqlite`, `.sqlite-wal`, `.sqlite-shm`)
+- Tilde-prefixed paths for stable storage across working directories
+
+## Related
+
+- See `setup-sqlite` for encryption, custom TTL cleanup, and migration to Redis

package/catalog/frontmcp-setup/examples/setup-sqlite/encrypted-sqlite-storage.md

@@ -0,0 +1,55 @@
+---
+name: encrypted-sqlite-storage
+reference: setup-sqlite
+level: intermediate
+description: 'Enable AES-256-GCM at-rest encryption for sensitive session data stored in SQLite.'
+tags: [setup, sqlite, session, database, encrypted, storage]
+features:
+  - '`encryption.secret` enables AES-256-GCM encryption with HKDF-SHA256 key derivation'
+  - 'The secret must be at least 32 characters and sourced from environment variables'
+  - 'The same secret must be used across server restarts to decrypt existing data'
+  - 'Never hardcode the encryption secret in source code'
+---
+
+# Encrypted SQLite Storage
+
+Enable AES-256-GCM at-rest encryption for sensitive session data stored in SQLite.
+
+## Code
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'secure-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  sqlite: {
+    path: '~/.frontmcp/data/sessions.sqlite',
+    walMode: true,
+    encryption: {
+      secret: process.env['SQLITE_ENCRYPTION_SECRET']!,
+    },
+  },
+})
+export default class Server {}
+```
+
+```env
+# .env (secret must be at least 32 characters)
+SQLITE_ENCRYPTION_SECRET=my-super-secret-key-at-least-32-characters-long
+```
+
+## What This Demonstrates
+
+- `encryption.secret` enables AES-256-GCM encryption with HKDF-SHA256 key derivation
+- The secret must be at least 32 characters and sourced from environment variables
+- The same secret must be used across server restarts to decrypt existing data
+- Never hardcode the encryption secret in source code
+
+## Related
+
+- See `setup-sqlite` for WAL mode details, TTL cleanup, and migration to Redis

package/catalog/frontmcp-setup/examples/setup-sqlite/unix-socket-daemon.md

@@ -0,0 +1,70 @@
+---
+name: unix-socket-daemon
+reference: setup-sqlite
+level: advanced
+description: 'Configure a FrontMCP daemon that listens on a unix socket and uses SQLite for persistent storage.'
+tags: [setup, unix-socket, sqlite, session, transport, database]
+features:
+  - '`http.unixSocket` for unix socket transport instead of TCP port'
+  - "`transport: { protocol: 'modern' }` for Streamable HTTP with strict sessions"
+  - '`ttlCleanupIntervalMs: 15000` for more aggressive cleanup on high-throughput daemons'
+  - 'Absolute path for the database file in system-level storage (`/var/lib/`)'
+---
+
+# Unix Socket Daemon with SQLite
+
+Configure a FrontMCP daemon that listens on a unix socket and uses SQLite for persistent storage.
+
+## Code
+
+```typescript
+// src/main.ts
+import 'reflect-metadata';
+import { FrontMcp } from '@frontmcp/sdk';
+
+@FrontMcp({
+  info: { name: 'frontmcp-daemon', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  sqlite: {
+    path: '/var/lib/frontmcp/daemon.sqlite',
+    walMode: true,
+    ttlCleanupIntervalMs: 15000,
+  },
+  transport: {
+    protocol: 'modern',
+  },
+  http: {
+    unixSocket: '/tmp/frontmcp.sock',
+  },
+})
+export default class Server {}
+```
+
+```env
+# .env
+SQLITE_DB_PATH=/var/lib/frontmcp/daemon.sqlite
+```
+
+```bash
+# Start the daemon
+frontmcp dev
+
+# Test via unix socket
+curl --unix-socket /tmp/frontmcp.sock \
+  -X POST http://localhost/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}'
+```
+
+## What This Demonstrates
+
+- `http.unixSocket` for unix socket transport instead of TCP port
+- `transport: { protocol: 'modern' }` for Streamable HTTP with strict sessions
+- `ttlCleanupIntervalMs: 15000` for more aggressive cleanup on high-throughput daemons
+- Absolute path for the database file in system-level storage (`/var/lib/`)
+
+## Related
+
+- See `setup-sqlite` for basic setup, encryption, and WAL mode configuration

package/catalog/frontmcp-setup/references/frontmcp-skills-usage.md

@@ -1,3 +1,8 @@
+---
+name: frontmcp-skills-usage
+description: Search, install, and manage FrontMCP skill catalog for AI agents (Claude Code, Codex)
+---
+
 # FrontMCP Skills — Search, Install, and Usage
 
 FrontMCP ships with a catalog of development skills that teach AI agents (Claude Code, Codex) how to build FrontMCP servers. You can deliver these skills **statically** (copy to disk) or **dynamically** (search on demand via CLI).
@@ -49,7 +54,7 @@ frontmcp skills list
 frontmcp skills list --category development
 
 # Show full skill content
-frontmcp skills show frontmcp-development
+frontmcp skills read frontmcp-development
 
 # Install a skill for Claude Code
 frontmcp skills install frontmcp-development --provider claude
@@ -81,13 +86,23 @@ frontmcp skills list --tag redis              # Skills tagged with redis
 frontmcp skills list --bundle recommended     # Recommended bundle
 ```
 
-### `frontmcp skills show <name>`
+### `frontmcp skills read <name> [reference]`
 
-Print the full SKILL.md content to stdout — useful for piping to AI context:
+Read a skill's main SKILL.md, a specific reference, or list available references:
 
 ```bash
-frontmcp skills show frontmcp-development    # Print development skill
-frontmcp skills show frontmcp-config         # Print config skill
+# Read main skill content
+frontmcp skills read frontmcp-development
+
+# List all references for a skill
+frontmcp skills read frontmcp-development --refs
+
+# Read a specific reference by name
+frontmcp skills read frontmcp-development create-tool
+
+# Read any file using colon syntax (works with non-.md files too)
+frontmcp skills read frontmcp-development:references/create-tool.md
+frontmcp skills read frontmcp-development:scripts/setup.sh
 ```
 
 ### `frontmcp skills install <name>`
@@ -154,10 +169,10 @@ Use the CLI to search and show skills on demand — no installation needed:
 frontmcp skills search "how to create a tool with zod"
 
 # Pipe skill content directly into context
-frontmcp skills show frontmcp-development
+frontmcp skills read frontmcp-development
 ```
 
-This works because `frontmcp skills show` outputs the full SKILL.md content to stdout.
+This works because `frontmcp skills read` outputs the full SKILL.md content to stdout.
 
 ## Comparison: Static vs Dynamic
 
@@ -184,7 +199,7 @@ frontmcp skills install frontmcp-config --provider claude
 # Everything else — search on demand
 frontmcp skills search "deploy to vercel"
 frontmcp skills search "rate limiting"
-frontmcp skills show frontmcp-deployment
+frontmcp skills read frontmcp-deployment
 ```
 
 ## Provider Directories
@@ -245,7 +260,7 @@ frontmcp skills list --category guides       # End-to-end examples and best prac
 ### Runtime
 
 - [ ] Installed skills appear in the correct provider directory after `frontmcp skills install`
-- [ ] `frontmcp skills show <name>` outputs the full SKILL.md content to stdout
+- [ ] `frontmcp skills read <name>` outputs the full SKILL.md content to stdout
 - [ ] `frontmcp skills search <query>` returns relevant results ranked by relevance
 - [ ] AI agent (Claude Code or Codex) loads installed skills in its system prompt context
 
@@ -259,6 +274,15 @@ frontmcp skills list --category guides       # End-to-end examples and best prac
 | Skill content is outdated after a CLI upgrade         | Static installs are point-in-time snapshots of the catalog          | Re-run `frontmcp skills install <name> --provider claude` to fetch the latest version                     |
 | Too many tokens consumed by agent context             | All skills installed statically, inflating the system prompt        | Uninstall rarely-used skills and switch to dynamic search (`frontmcp skills search`) for occasional needs |
 
+## Examples
+
+| Example                                                                                         | Level        | Description                                                                                   |
+| ----------------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------- |
+| [`bundle-presets-scaffolding`](../examples/frontmcp-skills-usage/bundle-presets-scaffolding.md) | Intermediate | Use `--skills` flag during project creation to install a skill bundle preset.                 |
+| [`install-and-search-skills`](../examples/frontmcp-skills-usage/install-and-search-skills.md)   | Basic        | Install skills statically for Claude Code and use dynamic CLI search for on-demand discovery. |
+
+> See all examples in [`examples/frontmcp-skills-usage/`](../examples/frontmcp-skills-usage/)
+
 ## Reference
 
 - **Docs:** <https://docs.agentfront.dev/frontmcp/servers/skills>

package/catalog/frontmcp-setup/references/multi-app-composition.md

@@ -1,3 +1,8 @@
+---
+name: multi-app-composition
+description: Compose multiple @App classes, ESM packages, and remote MCP servers into a single FrontMCP gateway
+---
+
 # Multi-App Composition
 
 Compose multiple `@App` classes into a single `@FrontMcp` server. Each app contributes its own tools, resources, prompts, skills, and plugins. Apps can be local classes, npm packages loaded at runtime, or remote MCP servers proxied through your gateway.
@@ -394,6 +399,16 @@ export default class Server {}
 | `standalone: true` app tools not visible | Standalone apps are fully isolated by design                | Use `standalone: 'includeInParent'` to expose tools in the parent server while keeping scope isolation   |
 | Per-app auth not working                 | App does not declare its own `auth` field                   | Add `auth` configuration directly on the `@App` decorator; omitted `auth` inherits server-level defaults |
 
+## Examples
+
+| Example                                                                                             | Level        | Description                                                                                     |
+| --------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------- |
+| [`local-apps-with-shared-tools`](../examples/multi-app-composition/local-apps-with-shared-tools.md) | Basic        | Compose multiple local `@App` classes into a server with shared tools available to all apps.    |
+| [`per-app-auth-and-isolation`](../examples/multi-app-composition/per-app-auth-and-isolation.md)     | Advanced     | Configure mixed authentication modes and scope isolation for different apps in a single server. |
+| [`remote-and-esm-apps`](../examples/multi-app-composition/remote-and-esm-apps.md)                   | Intermediate | Compose local, ESM (npm package), and remote (external MCP server) apps into a single gateway.  |
+
+> See all examples in [`examples/multi-app-composition/`](../examples/multi-app-composition/)
+
 ## Reference
 
 - [Multi-App Composition Documentation](https://docs.agentfront.dev/frontmcp/features/multi-app-composition)

package/catalog/frontmcp-setup/references/nx-workflow.md

@@ -1,3 +1,8 @@
+---
+name: nx-workflow
+description: Scaffold, build, test, and deploy FrontMCP projects using the @frontmcp/nx plugin in a monorepo
+---
+
 # Nx Monorepo Workflow for FrontMCP
 
 Use the `@frontmcp/nx` plugin to scaffold, build, test, and deploy FrontMCP projects in an Nx monorepo. The plugin provides generators for every FrontMCP primitive (tools, resources, prompts, skills, agents, plugins, adapters, providers, flows, jobs, workflows) and deployment shells for multiple targets.
@@ -408,6 +413,16 @@ Complete list of all `@frontmcp/nx` generators from `generators.json`:
 | Build fails with circular dependency error     | Library A imports from Library B and vice versa             | Use `nx graph` to visualize the cycle; extract shared code into a new library                        |
 | Cache not working (full rebuild every time)    | Missing or misconfigured `cacheableOperations` in `nx.json` | Ensure `build`, `test`, and `lint` are listed in `targetDefaults` with `cache: true`                 |
 
+## Examples
+
+| Example                                                                         | Level        | Description                                                                                                   |
+| ------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------- |
+| [`build-test-affected`](../examples/nx-workflow/build-test-affected.md)         | Intermediate | Use Nx commands for efficient building, testing, and CI with affected-only execution.                         |
+| [`multi-server-deployment`](../examples/nx-workflow/multi-server-deployment.md) | Advanced     | Generate multiple servers in an Nx workspace, each composing different apps for different deployment targets. |
+| [`scaffold-and-generate`](../examples/nx-workflow/scaffold-and-generate.md)     | Basic        | Initialize an Nx workspace and use generators to scaffold an app with tools, resources, and a server.         |
+
+> See all examples in [`examples/nx-workflow/`](../examples/nx-workflow/)
+
 ## Reference
 
 - **Docs:** [Nx Plugin Overview](https://docs.agentfront.dev/frontmcp/nx-plugin/overview)

package/catalog/frontmcp-setup/references/project-structure-nx.md

@@ -1,3 +1,8 @@
+---
+name: project-structure-nx
+description: Canonical directory layout, generators, and dependency rules for FrontMCP Nx monorepos
+---
+
 # Nx Monorepo Project Structure
 
 ## When to Use This Skill
@@ -240,6 +245,16 @@ Use `nx graph` to visualize the dependency graph and ensure no circular imports
 | Nx cache returns stale results           | Source files changed but Nx hash did not detect it      | Run `nx reset` to clear the cache, then rebuild                            |
 | Server cannot find app export            | App barrel `index.ts` does not export the `@App` class  | Add the app class to the barrel export in `apps/<name>/src/index.ts`       |
 
+## Examples
+
+| Example                                                                                    | Level        | Description                                                                                                                    |
+| ------------------------------------------------------------------------------------------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------ |
+| [`nx-generator-scaffolding`](../examples/project-structure-nx/nx-generator-scaffolding.md) | Basic        | Use `@frontmcp/nx` generators to scaffold tools, resources, and providers within an app, with automatic barrel export updates. |
+| [`nx-workspace-with-apps`](../examples/project-structure-nx/nx-workspace-with-apps.md)     | Basic        | Scaffold an Nx monorepo with two apps and a server that composes them into a single gateway.                                   |
+| [`shared-library-usage`](../examples/project-structure-nx/shared-library-usage.md)         | Intermediate | Create a shared library in an Nx monorepo and use it from multiple apps to avoid cross-app imports.                            |
+
+> See all examples in [`examples/project-structure-nx/`](../examples/project-structure-nx/)
+
 ## Reference
 
 - [Nx Plugin Documentation](https://docs.agentfront.dev/frontmcp/nx-plugin/overview)

package/catalog/frontmcp-setup/references/project-structure-standalone.md

@@ -1,3 +1,8 @@
+---
+name: project-structure-standalone
+description: File layout, naming conventions, and dev workflow for standalone FrontMCP projects
+---
+
 # Standalone Project Structure
 
 ## When to Use This Skill
@@ -206,6 +211,16 @@ Skills inside `src/skills/` are `@Skill` classes that are part of your applicati
 | Build target error             | Invalid `--target` flag value                                 | Use `node`, `vercel`, `lambda`, or `cloudflare` as the target value      |
 | Catalog skills not loaded      | Skills placed in `src/skills/` instead of top-level `skills/` | Move catalog `SKILL.md` directories to the top-level `skills/` directory |
 
+## Examples
+
+| Example                                                                                                  | Level        | Description                                                                                                                 |
+| -------------------------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------- |
+| [`dev-workflow-commands`](../examples/project-structure-standalone/dev-workflow-commands.md)             | Basic        | Run the standard development workflow for a standalone FrontMCP project: dev server, build, and tests.                      |
+| [`feature-folder-organization`](../examples/project-structure-standalone/feature-folder-organization.md) | Intermediate | Organize a growing standalone project into domain-specific feature folders instead of flat type-based directories.          |
+| [`minimal-standalone-layout`](../examples/project-structure-standalone/minimal-standalone-layout.md)     | Basic        | Set up the canonical file structure for a standalone FrontMCP project with one app, one tool, and the required entry point. |
+
+> See all examples in [`examples/project-structure-standalone/`](../examples/project-structure-standalone/)
+
 ## Reference
 
 - [Quickstart Documentation](https://docs.agentfront.dev/frontmcp/getting-started/quickstart)