@frontmcp/skills 1.0.0-beta.9 → 1.0.0

package/catalog/frontmcp-setup/references/readme-guide.md

@@ -0,0 +1,235 @@
+---
+name: readme-guide
+description: Generate deployment-target-aware README.md files for FrontMCP MCP servers
+---
+
+# FrontMCP README Generator
+
+Generate deployment-target-aware README.md files for FrontMCP MCP servers. The README adapts its content based on how the project is intended to be consumed — as an npm package, CLI tool, browser SDK, or serverless deployment.
+
+## When to Use This Skill
+
+### Must Use
+
+- Creating a new FrontMCP project that will be published or shared
+- Preparing an open-source release of an MCP server
+- Updating README after adding tools, prompts, resources, or changing deployment targets
+
+### Recommended
+
+- After significant changes to tools, resources, or server configuration
+- When switching deployment targets (e.g., from Node to Vercel)
+- Before publishing a new version to npm
+
+### Skip When
+
+- Internal project with no external users
+- The README is already comprehensive and manually maintained
+
+> **Decision:** Use this skill whenever the project's README needs to reflect its current tools, capabilities, and deployment instructions. Always ask the user which deployment target they're publishing for.
+
+## Step 1: Determine the Deployment Target
+
+Ask the user how the project will be consumed. This determines the README structure:
+
+| Target                          | README Focus                                                   |
+| ------------------------------- | -------------------------------------------------------------- |
+| **npm package** (direct client) | Installation via npm, SDK usage, `create()` API examples       |
+| **CLI binary**                  | Global install, CLI commands, configuration, usage examples    |
+| **Browser SDK**                 | CDN/bundler import, browser-compatible API, framework examples |
+| **Node server** (Docker)        | Docker setup, environment variables, health checks, deployment |
+| **Vercel**                      | One-click deploy, `vercel.json` config, environment setup      |
+| **Lambda**                      | SAM template, deployment commands, API Gateway config          |
+| **Cloudflare Workers**          | `wrangler.toml` config, deploy commands, edge runtime notes    |
+
+## Step 2: Gather Project Information
+
+Read these files to understand the project:
+
+1. **`src/main.ts`** — Server name, version, registered apps
+2. **`src/**/\*.app.ts`\*\* — App names and their tools/resources/prompts
+3. **`src/tools/*.tool.ts`** — Tool names, descriptions, input/output schemas
+4. **`src/resources/*.resource.ts`** — Resource URIs and descriptions
+5. **`package.json`** — Name, version, scripts, dependencies
+6. **`.env.example`** — Required environment variables
+7. **`ci/`** — Dockerfile, docker-compose.yml if present
+
+## Step 3: Generate README Sections
+
+### Common Sections (all targets)
+
+```markdown
+# {Project Name}
+
+{One-line description from @FrontMcp info}
+
+## Features
+
+- {Tool 1 name} — {description}
+- {Tool 2 name} — {description}
+- {Resource 1} — {description}
+
+## Quick Start
+
+{Target-specific install + run instructions}
+
+## Tools
+
+| Tool     | Description   | Input                    |
+| -------- | ------------- | ------------------------ |
+| `{name}` | {description} | `{input schema summary}` |
+
+## Resources
+
+| URI                 | Description   |
+| ------------------- | ------------- |
+| `{uri or template}` | {description} |
+
+## Environment Variables
+
+| Variable | Required | Description   |
+| -------- | -------- | ------------- |
+| `{VAR}`  | {yes/no} | {description} |
+
+## Development
+
+{How to run locally, test, inspect}
+
+## License
+
+{License from package.json}
+```
+
+### Target-Specific Sections
+
+**npm package (direct client):**
+
+```markdown
+## Installation
+
+npm install {package-name}
+
+## Usage
+
+import { create } from '{package-name}';
+
+const server = await create({
+// configuration
+});
+const client = await server.connect();
+const tools = await client.listTools();
+```
+
+**CLI binary:**
+
+```markdown
+## Installation
+
+npm install -g {package-name}
+
+## Usage
+
+{package-name} --help
+{package-name} [command] [options]
+
+## Commands
+
+| Command | Description   |
+| ------- | ------------- |
+| `{cmd}` | {description} |
+```
+
+**Docker / Node server:**
+
+```markdown
+## Docker
+
+docker compose up
+
+## Manual Deployment
+
+docker build -f ci/Dockerfile -t {name}:latest .
+docker run -p 3000:3000 {name}:latest
+```
+
+**Vercel:**
+
+```markdown
+## Deploy to Vercel
+
+npm i -g vercel
+frontmcp build --target vercel
+vercel deploy --prebuilt
+
+## Configuration
+
+See `vercel.json` for route configuration and environment variables.
+Set secrets via: `vercel env add REDIS_URL`
+```
+
+**AWS Lambda:**
+
+```markdown
+## Deploy to AWS Lambda
+
+frontmcp build --target lambda
+cd dist && sam build && sam deploy --guided
+
+## Configuration
+
+- SAM template: `template.yaml` defines the Lambda function, API Gateway, and DynamoDB table
+- Environment variables: Set via `sam deploy` parameters or AWS Console
+- API Gateway: Streamable HTTP endpoint at `https://{api-id}.execute-api.{region}.amazonaws.com/mcp`
+```
+
+**Cloudflare Workers:**
+
+```markdown
+## Deploy to Cloudflare Workers
+
+frontmcp build --target cloudflare
+npx wrangler deploy
+
+## Configuration
+
+- Workers config: `wrangler.toml` defines the worker name, routes, and KV bindings
+- Secrets: `npx wrangler secret put REDIS_URL`
+- KV namespace: Create via `npx wrangler kv:namespace create SESSION_STORE`
+```
+
+## Step 4: Update Existing README
+
+When updating (not creating), preserve:
+
+- Custom sections the user added manually
+- Badges, logos, and branding
+- Contributing guidelines, code of conduct links
+
+Only update:
+
+- Tool/resource tables (regenerate from source)
+- Quick start instructions (if deployment target changed)
+- Environment variables (if .env.example changed)
+
+## Verification Checklist
+
+- [ ] README includes all tools with descriptions from source code
+- [ ] README includes all resources and their URIs
+- [ ] Installation instructions match the deployment target
+- [ ] Environment variables match `.env.example`
+- [ ] Development section includes `frontmcp dev`, `frontmcp test`, `frontmcp inspect`
+- [ ] License matches `package.json`
+
+## Examples
+
+| Example                                                                            | Level        | Description                                                                                            |
+| ---------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------ |
+| [`node-server-readme`](../examples/readme-guide/node-server-readme.md)             | Basic        | Generate a README for a FrontMCP server deployed as a Docker/Node.js service with tools and resources. |
+| [`vercel-deployment-readme`](../examples/readme-guide/vercel-deployment-readme.md) | Intermediate | Generate a README for a FrontMCP server deployed to Vercel with Vercel KV storage.                     |
+
+> See all examples in [`examples/readme-guide/`](../examples/readme-guide/)
+
+## Reference
+
+- Related skills: `frontmcp-deployment` (for target-specific deployment details)
+- Related skills: `frontmcp-setup` (for project structure)

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

@@ -1,3 +1,8 @@
+---
+name: setup-project
+description: Scaffold a new FrontMCP project with CLI or manual setup, decorators, apps, and deployment config
+---
+
 # Scaffold and Configure a New FrontMCP Project
 
 ## When to Use This Skill
@@ -159,7 +164,7 @@ import { FrontMcp } from '@frontmcp/sdk';
   // tools?: ToolType[]         - shared tools available to all apps
   // resources?: ResourceType[] - shared resources available to all apps
   // skills?: SkillType[]       - shared skills available to all apps
-  // skillsConfig?: { enabled: boolean, mcpTools?: boolean, cache?: {...}, auth?: 'api-key' | 'bearer' }
+  // skillsConfig?: { enabled: boolean, mcpResources?: boolean, cache?: {...}, auth?: 'api-key' | 'bearer' }
   // elicitation?: { enabled: boolean }
   // pubsub?: { provider: 'redis', host: string, ... }
   // pagination?: { ... }
@@ -487,6 +492,16 @@ Run with: `nx serve <projectName>`.
 | Build fails with "Cannot find module '@frontmcp/sdk'" | Dependencies were not installed after scaffolding                                      | Run `yarn install` (or `npm install` / `pnpm install`) in the project root                             |
 | Vercel deploy returns 500 on `/mcp` endpoint          | Transport not set to `modern` or storage not configured for Vercel KV                  | Set `transport: { protocol: 'modern' }` and `redis: { provider: 'vercel-kv' }` in `@FrontMcp` metadata |
 
+## Examples
+
+| Example                                                                             | Level        | Description                                                                                                                                           |
+| ----------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`basic-node-server`](../examples/setup-project/basic-node-server.md)               | Basic        | Scaffold a minimal FrontMCP server with one app and one tool, running on Node.js with HTTP transport.                                                 |
+| [`cli-scaffold-with-flags`](../examples/setup-project/cli-scaffold-with-flags.md)   | Basic        | Use the `frontmcp create` CLI to scaffold a complete project non-interactively with explicit flags for deployment target, Redis, and package manager. |
+| [`vercel-serverless-server`](../examples/setup-project/vercel-serverless-server.md) | Intermediate | Configure a FrontMCP server for Vercel deployment with Vercel KV storage and modern transport protocol.                                               |
+
+> See all examples in [`examples/setup-project/`](../examples/setup-project/)
+
 ## Reference
 
 - [Getting Started Quickstart](https://docs.agentfront.dev/frontmcp/getting-started/quickstart)

package/catalog/frontmcp-setup/references/setup-redis.md

@@ -1,3 +1,8 @@
+---
+name: setup-redis
+description: Provision and configure Redis or Vercel KV for session storage and distributed state
+---
+
 # Configure Redis for Session Storage and Distributed State
 
 ## When to Use This Skill
@@ -352,6 +357,16 @@ You should see session keys like `mcp:session:<session-id>`.
 | Vercel KV `401 Unauthorized`          | Missing or invalid KV tokens in the environment     | Verify `KV_REST_API_URL` and `KV_REST_API_TOKEN` in the Vercel dashboard and redeploy                         |
 | Sessions lost after container restart | Redis running without append-only persistence       | Add `--appendonly yes` to the Redis command in docker-compose or use a managed Redis with persistence enabled |
 
+## Examples
+
+| Example                                                                                   | Level        | Description                                                                                         |
+| ----------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------- |
+| [`docker-redis-local-dev`](../examples/setup-redis/docker-redis-local-dev.md)             | Basic        | Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.        |
+| [`hybrid-vercel-kv-with-pubsub`](../examples/setup-redis/hybrid-vercel-kv-with-pubsub.md) | Advanced     | Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions. |
+| [`vercel-kv-serverless`](../examples/setup-redis/vercel-kv-serverless.md)                 | Intermediate | Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.          |
+
+> See all examples in [`examples/setup-redis/`](../examples/setup-redis/)
+
 ## Reference
 
 - [Redis Setup Docs](https://docs.agentfront.dev/frontmcp/deployment/redis-setup)

package/catalog/frontmcp-setup/references/setup-sqlite.md

@@ -1,3 +1,8 @@
+---
+name: setup-sqlite
+description: Configure SQLite with WAL mode and optional encryption for local single-instance deployments
+---
+
 # Configure SQLite for Local and Single-Instance Deployments
 
 ## When to Use This Skill
@@ -341,6 +346,16 @@ The change in `src/main.ts`:
 | WAL errors on network mount             | WAL mode requires a local filesystem with shared-memory support | Move the database to a local disk or set `walMode: false`                                                                 |
 | Encrypted data unreadable after restart | Encryption secret changed or missing                            | The secret must be identical across restarts; if the original secret is lost, delete the database and let it be recreated |
 
+## Examples
+
+| Example                                                                            | Level        | Description                                                                                       |
+| ---------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------- |
+| [`basic-sqlite-setup`](../examples/setup-sqlite/basic-sqlite-setup.md)             | Basic        | Configure a FrontMCP server with SQLite for local session storage with WAL mode enabled.          |
+| [`encrypted-sqlite-storage`](../examples/setup-sqlite/encrypted-sqlite-storage.md) | Intermediate | Enable AES-256-GCM at-rest encryption for sensitive session data stored in SQLite.                |
+| [`unix-socket-daemon`](../examples/setup-sqlite/unix-socket-daemon.md)             | Advanced     | Configure a FrontMCP daemon that listens on a unix socket and uses SQLite for persistent storage. |
+
+> See all examples in [`examples/setup-sqlite/`](../examples/setup-sqlite/)
+
 ## Reference
 
 - **Docs:** [SQLite Setup Guide](https://docs.agentfront.dev/frontmcp/deployment/sqlite-setup)

package/catalog/frontmcp-testing/SKILL.md

@@ -1,7 +1,10 @@
 ---
 name: frontmcp-testing
-description: "Domain router for testing MCP servers \u2014 unit tests, E2E tests, coverage, and quality assurance. Use when starting any testing task for a FrontMCP application."
+description: 'Use when you want to write tests, run tests, add e2e tests, improve test coverage, test a tool, test a resource, or learn how to test any FrontMCP component. The skill for ALL testing needs.'
 tags: [router, testing, jest, e2e, coverage, quality, guide]
+category: testing
+targets: [all]
+bundle: [recommended, full]
 priority: 10
 visibility: both
 license: Apache-2.0
@@ -37,37 +40,48 @@ Entry point for testing FrontMCP applications. This skill helps you navigate tes
 
 ## Scenario Routing Table
 
-| Scenario                                | Skill / Section                    | Description                                               |
-| --------------------------------------- | ---------------------------------- | --------------------------------------------------------- |
-| Set up Jest, coverage, and test harness | `setup-testing`                    | Full Jest config, test utilities, and coverage thresholds |
-| Write unit tests for a tool             | `setup-testing` (Unit Testing)     | Mock DI, validate input/output, test error paths          |
-| Write unit tests for a resource         | `setup-testing` (Unit Testing)     | Test URI resolution, template params, read results        |
-| Write unit tests for a prompt           | `setup-testing` (Unit Testing)     | Test argument handling, message generation                |
-| Write E2E protocol-level tests          | `setup-testing` (E2E Testing)      | Real MCP client/server, full protocol flow                |
-| Test authenticated endpoints            | `setup-testing` + `configure-auth` | E2E with OAuth tokens, session validation                 |
-| Test deployment builds                  | `setup-testing` + `deploy-to-*`    | Smoke tests against built output                          |
+| Scenario                                | Skill / Section                 | Description                                                  |
+| --------------------------------------- | ------------------------------- | ------------------------------------------------------------ |
+| Set up Jest, coverage, and test harness | `setup-testing`                 | Full Jest config, test utilities, and coverage thresholds    |
+| Write unit tests for a tool             | `setup-testing` (Unit Testing)  | Mock DI, validate input/output, test error paths             |
+| Write unit tests for a resource         | `setup-testing` (Unit Testing)  | Test URI resolution, template params, read results           |
+| Write unit tests for a prompt           | `setup-testing` (Unit Testing)  | Test argument handling, message generation                   |
+| Write E2E protocol-level tests          | `setup-testing` (E2E Testing)   | Real MCP client/server, full protocol flow                   |
+| Test authenticated endpoints            | `test-auth`                     | E2E with OAuth tokens, session validation, role-based access |
+| Test deployment builds                  | `setup-testing` + `deploy-to-*` | Smoke tests against built output                             |
+| Test browser builds                     | `test-browser-build`            | Testing browser builds                                       |
+| Test CLI binary builds                  | `test-cli-binary`               | Testing CLI binary builds                                    |
+| Test with the direct API client         | `test-direct-client`            | Testing with the direct API client                           |
+| Write E2E test handler patterns         | `test-e2e-handler`              | E2E test handler patterns                                    |
+| Unit test individual tools              | `test-tool-unit`                | Unit testing individual tools                                |
 
 ## Testing Strategy by Component Type
 
-| Component | Unit Test Focus                                          | E2E Test Focus                     | Key Assertions                                 |
-| --------- | -------------------------------------------------------- | ---------------------------------- | ---------------------------------------------- |
-| Tool      | Input validation, execute logic, error paths, DI mocking | `tools/call` via MCP client        | Output matches schema, errors return MCP codes |
-| Resource  | URI resolution, read content, template param handling    | `resources/read` via MCP client    | Content type correct, URI patterns resolve     |
-| Prompt    | Argument validation, message generation, multi-turn      | `prompts/get` via MCP client       | Messages match expected structure              |
-| Agent     | LLM config, tool selection, handoff logic                | Agent loop via MCP client          | Tools called in order, result synthesized      |
-| Provider  | Lifecycle hooks, factory output, singleton behavior      | Indirectly via tool/resource tests | Instance reuse, cleanup on scope disposal      |
-| Job       | Progress tracking, retry logic, attempt counting         | Job execution via test harness     | Progress events emitted, retries respected     |
+| Component | Unit Test Focus                                          | E2E Test Focus                     | Key Assertions                                                          |
+| --------- | -------------------------------------------------------- | ---------------------------------- | ----------------------------------------------------------------------- |
+| Tool      | Input validation, execute logic, error paths, DI mocking | `tools/call` via MCP client        | Output matches schema, errors return MCP codes                          |
+| Resource  | URI resolution, read content, template param handling    | `resources/read` via MCP client    | Content type correct, URI patterns resolve                              |
+| Prompt    | Argument validation, message generation, multi-turn      | `prompts/get` via MCP client       | Messages match expected structure                                       |
+| Agent     | LLM config, tool selection, handoff logic                | Agent loop via MCP client          | Tools called in order, result synthesized                               |
+| Provider  | Lifecycle hooks, factory output, singleton behavior      | Indirectly via tool/resource tests | Instance reuse, cleanup on scope disposal                               |
+| Job       | Progress tracking, retry logic, attempt counting         | Job execution via test harness     | Progress events emitted, retries respected                              |
+| Workflow  | Step dependencies, conditions, input mapping functions   | Workflow run via test harness      | Steps execute in order, conditions evaluated, continueOnError respected |
+| Skill     | Instruction loading (inline/file/url), tool validation   | Skill discovery via MCP/HTTP       | Instructions resolve, tool refs validated per `toolValidation` mode     |
+| Plugin    | Context extensions, provider registration, hook firing   | Indirectly via tool tests          | Extensions available on `this`, hooks fire at correct stages            |
 
 ## Cross-Cutting Testing Patterns
 
-| Pattern            | Rule                                                                                  |
-| ------------------ | ------------------------------------------------------------------------------------- |
-| File naming        | Always `.spec.ts` (not `.test.ts`); E2E uses `.e2e.spec.ts`                           |
-| Coverage threshold | 95%+ across statements, branches, functions, lines                                    |
-| Test descriptions  | Plain English, no prefixes like "PT-001"; describe behavior not implementation        |
-| Mocking            | Mock providers via DI token replacement, never mock the framework                     |
-| Error testing      | Assert `instanceof` specific error class AND MCP error code                           |
-| Async              | Always `await` async operations; use `expect(...).rejects.toThrow()` for async errors |
+| Pattern            | Rule                                                                                                                                                                                                                                                                                                 |
+| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| File naming        | Always `.spec.ts` (not `.test.ts`); E2E uses `.e2e.spec.ts`                                                                                                                                                                                                                                          |
+| File organization  | Split E2E tests by app/feature: `e2e/calc.e2e.spec.ts`, `e2e/ecommerce.e2e.spec.ts`. Never put all tests in a single `server.e2e.spec.ts`                                                                                                                                                            |
+| Test runner        | Use `frontmcp test` (not `jest --config ...`). It auto-generates the correct Jest/SWC config                                                                                                                                                                                                         |
+| Coverage threshold | 95%+ across statements, branches, functions, lines                                                                                                                                                                                                                                                   |
+| Test descriptions  | Plain English, no prefixes like "PT-001"; describe behavior not implementation                                                                                                                                                                                                                       |
+| Mocking            | Mock providers via DI token replacement, never mock the framework                                                                                                                                                                                                                                    |
+| httpMock scope     | `httpMock` intercepts HTTP in the **test process** only, NOT in the MCP server subprocess. Do not use httpMock to intercept server-to-API calls — those happen in the child process. Use httpMock for verifying client-to-server request shapes or mocking external APIs called from the test itself |
+| Error testing      | Assert `instanceof` specific error class AND MCP error code                                                                                                                                                                                                                                          |
+| Async              | Always `await` async operations; use `expect(...).rejects.toThrow()` for async errors                                                                                                                                                                                                                |
 
 ## Common Patterns
 
@@ -110,7 +124,7 @@ Entry point for testing FrontMCP applications. This skill helps you navigate tes
 | Problem                            | Cause                                                   | Solution                                                                               |
 | ---------------------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------------------- |
 | Jest not finding test files        | Wrong file extension (`.test.ts` instead of `.spec.ts`) | Rename to `.spec.ts`; check `testMatch` in jest.config                                 |
-| Coverage below 95%                 | Untested error paths or conditional branches            | Run `jest --coverage` and inspect uncovered lines in the report                        |
+| Coverage below 95%                 | Untested error paths or conditional branches            | Run `frontmcp test --coverage` and inspect uncovered lines in the report               |
 | E2E test timeout                   | Server startup too slow or port conflict                | Increase Jest timeout; use random port allocation                                      |
 | DI resolution fails in tests       | Provider not registered in test scope                   | Register mock providers before creating the test context                               |
 | Istanbul shows 0% on async methods | TypeScript source-map mismatch with Istanbul            | Known issue with some TS compilation settings; verify coverage with actual test output |

package/catalog/frontmcp-testing/examples/setup-testing/fixture-based-e2e-test.md

@@ -0,0 +1,70 @@
+---
+name: fixture-based-e2e-test
+reference: setup-testing
+level: advanced
+description: 'Write E2E tests using the fixture API from `@frontmcp/testing` that manages server lifecycle automatically and uses MCP-specific custom matchers.'
+tags: [testing, jest, e2e, setup, fixture, based]
+features:
+  - 'Using `test.use()` to configure server path and port for automatic lifecycle management'
+  - 'Importing `test` and `expect` from `@frontmcp/testing` (not from Jest) to access MCP-specific matchers'
+  - 'Custom matchers: `toContainTool()`, `toBeSuccessful()`, `toHaveTextContent()` for MCP assertions'
+  - 'Testing all three MCP primitives (tools, resources, prompts) in a single E2E suite'
+---
+
+# Fixture-Based E2E Test with Custom Matchers
+
+Write E2E tests using the fixture API from `@frontmcp/testing` that manages server lifecycle automatically and uses MCP-specific custom matchers.
+
+## Code
+
+```typescript
+// my-server.e2e.spec.ts
+import { test, expect } from '@frontmcp/testing';
+
+test.use({
+  server: './src/main.ts',
+  port: 3003,
+});
+
+test('server exposes expected tools', async ({ mcp }) => {
+  const tools = await mcp.tools.list();
+  expect(tools).toContainTool('create_record');
+  expect(tools).toContainTool('delete_record');
+});
+
+test('create_record tool returns success', async ({ mcp }) => {
+  const result = await mcp.tools.call('create_record', {
+    name: 'Test Record',
+    type: 'example',
+  });
+
+  expect(result).toBeSuccessful();
+  expect(result).toHaveTextContent('created');
+});
+
+test('reading a resource returns valid content', async ({ mcp }) => {
+  const result = await mcp.resources.read('config://server-info');
+
+  expect(result.contents).toHaveLength(1);
+  expect(result.contents[0]).toHaveProperty('mimeType', 'application/json');
+});
+
+test('prompts return well-formed messages', async ({ mcp }) => {
+  const result = await mcp.prompts.get('summarize', { topic: 'testing' });
+
+  expect(result.messages).toBeDefined();
+  expect(result.messages.length).toBeGreaterThan(0);
+});
+```
+
+## What This Demonstrates
+
+- Using `test.use()` to configure server path and port for automatic lifecycle management
+- Importing `test` and `expect` from `@frontmcp/testing` (not from Jest) to access MCP-specific matchers
+- Custom matchers: `toContainTool()`, `toBeSuccessful()`, `toHaveTextContent()` for MCP assertions
+- Testing all three MCP primitives (tools, resources, prompts) in a single E2E suite
+
+## Related
+
+- See `setup-testing` for the full testing setup reference
+- See `test-e2e-handler` for manual `McpTestClient` E2E patterns

package/catalog/frontmcp-testing/examples/setup-testing/jest-config-with-coverage.md

@@ -0,0 +1,59 @@
+---
+name: jest-config-with-coverage
+reference: setup-testing
+level: basic
+description: 'Set up a Jest configuration file that enforces 95%+ coverage across all metrics for a FrontMCP library.'
+tags: [testing, jest, setup, config, coverage]
+features:
+  - 'How to configure Jest with `ts-jest` for TypeScript test files'
+  - 'Setting 95%+ coverage thresholds required by FrontMCP standards'
+  - 'Proper `tsconfig.spec.json` that extends the base config and includes `.spec.ts` files'
+---
+
+# Jest Configuration with Coverage Thresholds
+
+Set up a Jest configuration file that enforces 95%+ coverage across all metrics for a FrontMCP library.
+
+## Code
+
+```typescript
+// jest.config.ts
+export default {
+  displayName: 'my-lib',
+  preset: '../../jest.preset.js',
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  coverageThreshold: {
+    global: {
+      statements: 95,
+      branches: 95,
+      functions: 95,
+      lines: 95,
+    },
+  },
+};
+```
+
+```json
+// tsconfig.spec.json
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.spec.tsx"]
+}
+```
+
+## What This Demonstrates
+
+- How to configure Jest with `ts-jest` for TypeScript test files
+- Setting 95%+ coverage thresholds required by FrontMCP standards
+- Proper `tsconfig.spec.json` that extends the base config and includes `.spec.ts` files
+
+## Related
+
+- See `setup-testing` for the full testing setup reference