@slbdn/mcp-tester 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -5,6 +5,109 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-07-01
+
+### Added
+- **TypeScript type generator** (`src/generate-types.ts`) — generate typed `.d.ts` from MCP tool schemas:
+  - `generateTypes()` API: connect to server, inspect schemas, emit TypeScript declarations
+  - CLI: `npx mcp-tester generate-types node ./server.js -o server.d.ts`
+  - Handles: primitives, enums, arrays, nested objects, oneOf/anyOf/allOf, $ref, const
+  - Generated types: `{Tool}Args`, `ToolName`, `ToolArgsMap`, `ToolCall`, `ResourceUri`, `PromptCall`
+  - 59 tests (12 e2e + 4 options + 43 unit)
+- **Server health checks** — detect zombie processes and monitor server health:
+  - `isHealthy()` — sends a lightweight `tools/list` ping, returns `HealthStatus` with latency, PID, message
+  - `getServerPid()` — get the server process PID
+  - `getLastHealthStatus()` — cached result without re-checking
+  - `startHealthMonitor(options)` — periodic health monitoring with `onUnhealthy`/`onRecovery`/`onCheck` callbacks
+  - `stopHealthMonitor()` — stop periodic monitoring (also auto-stopped by `client.stop()`)
+  - Zombie process detection via `process.kill(pid, 0)`
+  - 17 tests (including SIGKILL zombie detection test)
+- **Enhanced mock server** (`src/__tests__/fixtures/mock-server.ts`) — 68 tests:
+  - Configurable delays (`defaultDelay`) and random failures (`failureRate`)
+  - Input schema validation (`validateSchemas` option)
+  - Stateful tools: `counter` (increment/get/reset), `items` (add/list/remove/clear)
+  - Transform tool: `upper`/`lower`/`reverse`/`length` operations
+  - Custom handlers: `registerToolHandler`, `registerResourceHandler`, `registerPromptHandler`
+  - Call history: `getCallHistory`, `getCallCount` for test assertions
+  - Streaming support: `setupStream`, `nextStreamChunk`
+  - Dynamic registration/removal of tools, resources, prompts
+
+### Changed
+- **CLI version** is now read dynamically from `package.json` (was hardcoded `1.0.0`)
+- Applied safe dependency patches: `@typescript-eslint/*` 8.60.0, `@types/node` 20.19.41, `prettier` 3.8.3, `ts-jest` 29.4.11
+- `npm audit fix` — 0 vulnerabilities (was 11)
+
+### Test Suite
+- **635 tests** (17 suites), up from 491 (14 suites)
+- New: mock server (68), generate-types (59), health checks (17)
+
+## [1.2.0] - 2026-04-30
+
+### Added
+- **Visual test reports** — HTML test report auto-generated on every `npm test` run:
+  - Uses `jest-html-reporters` with collapsible test trees, timing, failure details
+  - Report saved to `reports/test-report.html`
+  - CI uploads report as artifact (14-day retention)
+  - Open locally: `open reports/test-report.html`
+- **Property-based tests** (`src/__tests__/property-based.test.ts`) — 73 tests using fast-check:
+  - 44 validation tests: reject/accept all input types, error code invariants
+  - 17 masking tests: idempotency, completeness, secret detection, length bounds
+  - 12 generate-tests tests: no-throw, serializability, schema priority, nested arrays
+  - Fixed flaky `fc.double()` producing NaN/Infinity → use `fc.integer()` for numeric fields
+- **Enhanced mock server** (`src/__tests__/fixtures/mock-server.ts`) — 68 tests:
+  - Configurable delays (`defaultDelay`) and random failures (`failureRate`)
+  - Input schema validation (`validateSchemas` option)
+  - Stateful tools: `counter` (increment/get/reset), `items` (add/list/remove/clear)
+  - Transform tool: `upper`/`lower`/`reverse`/`length` operations
+  - Custom handlers: `registerToolHandler`, `registerResourceHandler`, `registerPromptHandler`
+  - Call history: `getCallHistory`, `getCallCount` for test assertions
+  - Streaming support: `setupStream`, `nextStreamChunk`
+  - Dynamic registration/removal of tools, resources, prompts
+- **TypeScript type generator** (`src/generate-types.ts`) — generate typed `.d.ts` from MCP tool schemas:
+  - `generateTypes()` API: connect to server, inspect schemas, emit TypeScript declarations
+  - CLI: `npx mcp-tester generate-types node ./server.js -o server.d.ts`
+  - Handles: primitives, enums, arrays, nested objects, oneOf/anyOf/allOf, $ref, const
+  - Generated types: `{Tool}Args`, `ToolName`, `ToolArgsMap`, `ToolCall`, `ResourceUri`, `PromptCall`
+  - 59 tests (12 e2e + 4 options + 43 unit)
+- **Server health checks** — detect zombie processes and monitor server health:
+  - `isHealthy()` — sends a lightweight `tools/list` ping, returns `HealthStatus` with latency, PID, message
+  - `getServerPid()` — get the server process PID
+  - `getLastHealthStatus()` — cached result without re-checking
+  - `startHealthMonitor(options)` — periodic health monitoring with `onUnhealthy`/`onRecovery`/`onCheck` callbacks
+  - `stopHealthMonitor()` — stop periodic monitoring (also auto-stopped by `client.stop()`)
+  - Zombie process detection via `process.kill(pid, 0)`
+  - 17 tests (including SIGKILL zombie detection test)
+- **Test code generator** (`src/generate-tests.ts`) — generate a complete test file from MCP server inspection:
+  - CLI: `mcp-tester generate node ./server.js -o server.test.ts` (alias: `gen`)
+  - API: `generateTests({ command, args, framework, ... })`
+  - Generates lifecycle tests, tool call tests with sample args from JSON Schema, resource read tests, prompt tests
+  - Options: `--framework jest|vitest`, `--output <file>`, `--description <name>`, `--no-tools`, `--no-resources`, `--no-prompts`, `--no-matchers`
+  - Sample arguments derived from JSON Schema: types, enums, defaults, examples
+  - 21 tests in `generate-tests.test.ts`
+- **Input validation** (`src/utils/validation.ts`) — all MCPClient methods validate inputs before execution:
+  - `start()`: validates command (required string), args (string array), env (string values), startupDelay (non-negative number)
+  - `callTool()`: validates name (required string), arguments (object), timeout (positive number), retries (non-negative number)
+  - `readResource()`: validates URI (required non-empty string)
+  - `getPrompt()`: validates name (required string), args (string values)
+  - `requestSampling()`: validates messages (non-empty array)
+  - Constructor: validates timeout (positive), retries/retryDelay/startupDelay (non-negative), name/version (string)
+  - Validation runs before connection checks — invalid args throw `MCPClientError`, not `MCPNotStartedError`
+  - 91 tests in `validation.test.ts`
+- **Code coverage comments on PRs** — GitHub Actions workflow now posts a coverage table as a sticky comment on every pull request (statements/branches/functions/lines with thresholds)
+- **Dedicated `coverage` CI job** — runs on single Node.js version (faster than matrix), generates `coverage-summary.json`, uploads to Codecov v4
+- **`coverageReporters`** in `jest.config.js` — added `json-summary` reporter for CI coverage data extraction
+- **VS Code snippets** (`.vscode/mcp-tester.code-snippets`) — 15 snippets for MCP test patterns (type `mcp` prefix)
+
+### Changed
+- **Per-file coverage thresholds** updated for new files (`masking.ts`, `logger.ts`) and actual coverage numbers
+- Global thresholds: 67% statements, 61% branches, 60% functions, 67% lines (was 76/57/64/76)
+- **README** coverage badge and table updated with real numbers (68/61/60/68)
+- **docs/cicd.md** — rewritten with full workflow including coverage job, PR comments, and Codecov
+- **docs/testing.md** — updated coverage thresholds (was "80%", now per-file table)
+- **AGENTS.md** — updated test count, coverage stats, CI job descriptions, file listing
+- Fixed flaky `delay` test (100ms → 90ms tolerance for timing variance)
+- **Updated test count**: 491 (was 306)
+
 ## [1.1.0] - 2026-04-23
 
 ### Added

package/README.md

@@ -6,9 +6,10 @@
 
 [![npm version](https://img.shields.io/npm/v/@slbdn/mcp-tester)](https://www.npmjs.com/package/@slbdn/mcp-tester)
 [![npm downloads](https://img.shields.io/npm/dm/@slbdn/mcp-tester)](https://www.npmjs.com/package/@slbdn/mcp-tester)
-[![Node.js Version](https://img.shields.io/node/v/@slbdn/mcp-tester)](https://nodejs.org)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Test Status](https://img.shields.io/badge/tests-227_passing-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)
+[![Test Status](https://img.shields.io/badge/tests-635%20passing-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)
+[![Coverage](https://img.shields.io/badge/coverage-68%2F61%2F60%2F68-brightgreen)](https://github.com/islobodan/mcp-tester/actions/workflows/test.yml)  <!-- statements/branches/functions/lines -->
 
 A production-ready MCP (Model Context Protocol) client for **automated testing** of MCP servers with Jest.
 No more manual clicking through inspectors — write real tests, run them in CI, break builds on regressions.
@@ -25,13 +26,49 @@ No more manual clicking through inspectors — write real tests, run them in CI,
 | **Notifications** | React to resource changes, logging messages, tool list updates |
 | **Error Handling** | Custom error classes for timeouts, connection failures, server errors |
 | **Retries** | Exponential backoff with configurable attempts and delay |
+| **Benchmarks** | Measure latency, throughput, and payload performance with `npm run benchmark` |
 | **CLI** | Smoke-test any server from the terminal in seconds |
 
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        Your Test Suite                             │
+│  ┌──────────┐  ┌───────────┐  ┌────────┐  ┌───────────────────┐  │
+│  │   Jest    │  │  Vitest   │  │ assert │  │  Custom Runner   │  │
+│  │ matchers │  │ matchers  │  │ module │  │  (any framework)  │  │
+│  └────┬─────┘  └─────┬─────┘  └───┬────┘  └────────┬──────────┘  │
+│       │              │             │                 │              │
+│  ┌────▼──────────────▼─────────────▼─────────────────▼──────────┐    │
+│  │                      MCPClient                              │    │
+│  │  ┌──────────────────────────────────────────────────────┐  │    │
+│  │  │  start() │ stop() │ listTools() │ callTool() │ ...   │  │    │
+│  │  └──────────────────────┬───────────────────────────────────┘  │    │
+│  │                         │                                      │    │
+│  │  ┌──────────────────────▼───────────────────────────────┐    │    │
+│  │  │         Retry │ Timeout │ Error Handling              │    │    │
+│  │  │    MCPTimeoutError │ MCPConnectionError │ ...        │    │    │
+│  │  └──────────────────────┬───────────────────────────────┘    │    │
+│  └─────────────────────────┼─────────────────────────────────────┘    │
+│                            │ stdio (JSON-RPC)                        │
+│  ┌─────────────────────────▼─────────────────────────────────────┐  │
+│  │              MCP Server (child process)                       │  │
+│  │  ┌────────┐  ┌───────────┐  ┌──────────┐  ┌────────────┐   │  │
+│  │  │ Tools  │  │ Resources │  │ Prompts  │  │ Sampling   │   │  │
+│  │  └────────┘  └───────────┘  └──────────┘  └────────────┘   │  │
+│  └──────────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+**Data flow**: Your test calls `MCPClient` → which sends JSON-RPC over stdio → to the MCP server process → server responds → `MCPClient` returns typed results → your assertion validates them.
+
+**Key design**: `MCPClient` manages the server lifecycle (spawn/kill) and protocol handling. Your tests never deal with the transport layer directly.
+
 ## Why MCP Tester?
 
 - **Full protocol support** — tools, resources, prompts, sampling, elicitation, notifications
 - **Built on the official SDK** — `@modelcontextprotocol/sdk` v1.29.0
-- **Works out of the box** — mock server included, 227 tests passing
+- **Works out of the box** — mock server included, 257 tests passing
 - **CLI included** — test any server from the command line
 - **TypeScript first** — strict types, ESM, full IntelliSense
 - **Parallel execution** — fire multiple tool calls concurrently with `Promise.all` for blazing-fast test suites
@@ -39,6 +76,30 @@ No more manual clicking through inspectors — write real tests, run them in CI,
 - **In-memory mock server** — unit test your test logic without spawning real processes
 - **Custom Jest matchers** — `toHaveTool()`, `toHaveResource()`, `toHavePrompt()` — and Vitest support
 
+## Test Coverage
+
+| Metric | Coverage |
+|--------|----------|
+| Statements | 68% |
+| Branches | 61% |
+| Functions | 60% |
+| Lines | 68% |
+| Tests | 635 passing |
+
+Per-file coverage thresholds are set in `jest.config.js` to catch regressions while avoiding CI noise. Run `npm run test:coverage` to see the full breakdown by file. PRs automatically receive a coverage comment via GitHub Actions.
+
+## Test Reports
+
+Every `npm test` run auto-generates an HTML test report:
+
+```bash
+npm test                # generates reports/test-report.html
+open reports/test-report.html   # macOS
+xdg-open reports/test-report.html  # Linux
+```
+
+The report includes collapsible test trees, timing per test, and failure details with stack traces. CI uploads reports as artifacts (14-day retention).
+
 ## Install
 
 ```bash
@@ -124,12 +185,90 @@ npx @slbdn/mcp-tester list-tools node ./server.js --json
 # Call a tool
 npx @slbdn/mcp-tester call-tool echo node ./server.js --params '{"message":"Hello"}'
 
-# Short aliases: lt, ct, rr, gp
+# Generate test file from server inspection
+npx @slbdn/mcp-tester generate node ./server.js -o server.test.ts
+npx @slbdn/mcp-tester gen node ./server.js --framework vitest --no-resources
+
+# Short aliases: lt, ct, rr, gp, gen
 npx @slbdn/mcp-tester lt node ./server.js
 ```
 
 See [CLI Reference](./docs/cli.md) for all commands and options.
 
+### Generate Test Files
+
+Connect to any MCP server and generate a ready-to-run test file:
+
+```bash
+# Generate Jest test file
+npx @slbdn/mcp-tester generate node ./server.js -o server.test.ts
+
+# Generate Vitest test file
+npx @slbdn/mcp-tester gen node ./server.js --framework vitest
+
+# Skip specific sections
+npx @slbdn/mcp-tester generate node ./server.js --no-resources --no-prompts -o tools-only.test.ts
+```
+
+Or use the API:
+
+```typescript
+import { generateTests } from '@slbdn/mcp-tester';
+
+const code = await generateTests({
+  command: 'node',
+  args: ['./server.js'],
+  framework: 'jest',
+  description: 'My Server Tests',
+});
+
+fs.writeFileSync('server.test.ts', code);
+```
+
+The generator connects to the server, inspects all tools/resources/prompts, and generates:
+- Connection and lifecycle tests
+- Tool call tests with **sample arguments derived from JSON Schema**
+- Resource read tests
+- Prompt tests with sample arguments
+- Proper `beforeEach`/`afterEach` cleanup
+
+### Generate TypeScript Types
+
+Connect to any MCP server and generate typed `.d.ts` declarations from tool schemas:
+
+```bash
+# Generate TypeScript types
+npx @slbdn/mcp-tester generate-types node ./server.js -o server.d.ts
+```
+
+Or use the API:
+
+```typescript
+import { generateTypes } from '@slbdn/mcp-tester';
+import { writeFileSync } from 'fs';
+
+const types = await generateTypes({
+  command: 'node',
+  args: ['./server.js'],
+});
+
+writeFileSync('server.d.ts', types);
+```
+
+This produces typed interfaces you can use for type-safe tool calls:
+
+```typescript
+import type { ToolArgsMap } from './server.d.ts';
+
+// TypeScript knows: { a: number; b: number }
+const result = await client.callTool({
+  name: 'add',
+  arguments: { a: 1, b: 2 } as ToolArgsMap['add'],
+});
+```
+
+Supports: primitives, enums, nested objects, arrays, `oneOf`/`anyOf`/`allOf`, `$ref`, `const`.
+
 ## Speed Up Your Tests with Parallel Execution
 
 MCP Tester is built for concurrency. Fire off multiple tool calls at once — no waiting in line:
@@ -167,6 +306,10 @@ No extra config needed. Just `Promise.all` and go.
 | `start(config)` | `Promise<void>` | Connect to an MCP server |
 | `stop()` | `Promise<void>` | Disconnect and clean up |
 | `isConnected()` | `boolean` | Check connection state |
+| `isHealthy()` | `Promise<HealthStatus>` | Check server health and responsiveness |
+| `getServerPid()` | `number | null` | Get server process PID |
+| `startHealthMonitor(opts)` | `void` | Start periodic health monitoring |
+| `stopHealthMonitor()` | `void` | Stop health monitoring |
 | `listTools()` | `Promise<Tool[]>` | List available tools |
 | `callTool(options)` | `Promise<CallToolResult>` | Call a tool with arguments |
 | `listResources()` | `Promise<Resource[]>` | List available resources |
@@ -179,6 +322,25 @@ No extra config needed. Just `Promise.all` and go.
 
 See [API Reference](./docs/api-reference.md) for full details including types, options, and error classes.
 
+## Server Health Checks
+
+Detect crashed servers and zombie processes during long test runs:
+
+```typescript
+// One-time check
+const health = await client.isHealthy();
+console.log(`Healthy: ${health.healthy}, PID: ${health.pid}, latency: ${health.latencyMs}ms`);
+
+// Periodic monitoring
+client.startHealthMonitor({
+  interval: 3000,
+  onUnhealthy: (status) => console.error('Server down:', status.message),
+  onRecovery: (status) => console.log('Server recovered!'),
+});
+```
+
+Health checks detect zombie processes (killed/crashed but `isConnected()` still returns `true`) using `process.kill(pid, 0)`.
+
 ## Custom Jest Matchers
 
 Built-in matchers so your assertions read like English:
@@ -317,7 +479,7 @@ mcp-tester/
 │   │   ├── errors.ts            # Error classes
 │   │   ├── logger.ts            # Logging
 │   │   └── env.ts               # Environment utilities
-│   └── __tests__/               # 227 tests
+│   └── __tests__/               # 306 tests
 │       ├── everything-server.test.ts  # Integration tests (server-everything)
 │       ├── real-server.test.ts        # Integration tests (stdio transport)
 │       ├── cli.test.ts                # CLI tool tests
@@ -328,7 +490,10 @@ mcp-tester/
 │   ├── jest-matchers-example.ts # Jest matchers usage
 │   ├── assert-example.ts        # Assert utilities usage
 │   ├── everything-server-test.ts # Test against real MCP server
-│   └── mock-server.js           # Standalone MCP server
+│   ├── stateful-server-test.ts  # Stateful server testing pattern
+│   ├── mock-server.js           # Basic standalone MCP server
+│   ├── simple-server.ts         # Minimal TypeScript MCP server
+│   └── stateful-server.ts        # Stateful MCP server (counter + todos)
 └── docs/                        # Documentation
 ```
 
@@ -337,11 +502,117 @@ mcp-tester/
 ```bash
 npm install          # Install dependencies
 npm run build        # Compile TypeScript
-npm test             # Run tests (227 tests)
+npm run dev          # Watch mode — auto-rebuild on source changes
+npm test             # Run tests (auto-generates reports/test-report.html)
 npm run lint         # Lint code
 npm run format       # Format with Prettier
 ```
 
+## Troubleshooting
+
+### "Client not started" Error
+
+Calling methods before `start()`:
+
+```typescript
+// ✗ Wrong
+const client = new MCPClient();
+const tools = await client.listTools(); // throws MCPNotStartedError
+
+// ✓ Correct
+const client = new MCPClient();
+await client.start({ command: 'node', args: ['./server.js'] });
+const tools = await client.listTools();
+```
+
+### Timeout Errors
+
+```typescript
+// Global timeout
+const client = new MCPClient({ timeout: 60000 });
+
+// Per-call override
+await client.callTool({ name: 'slow-tool', arguments: {}, timeout: 30000 });
+```
+
+### Server Won't Start
+
+```bash
+# Verify the server runs standalone first
+node ./my-server.js
+```
+
+Check that the command and args are correct — `MCPConnectionError` includes the command and suggestions.
+
+### ESM Import Errors
+
+```typescript
+// ✗ Wrong — missing .js extension
+import { MCPClient } from './client/MCPClient';
+
+// ✓ Correct
+import { MCPClient } from './client/MCPClient.js';
+```
+
+### Tests Fail in CI
+
+- Set `maxWorkers: 1` in Jest config (parallel workers can crash)
+- Verify Node.js >= 18
+- Check that server paths are correct
+
+### Debug Mode
+
+```typescript
+const client = new MCPClient({ logLevel: 'debug', enableProtocolLogging: true });
+```
+
+All logs go to stderr — they won't interfere with test output.
+
+New logging features:
+- **Timing**: operations log elapsed time (e.g., `Listed 4 tools in 12ms`)
+- **Secret masking**: API keys, tokens, and passwords are auto-masked (e.g., `sk-ab...789`)
+- **Pretty-printed JSON**: protocol messages are formatted and masked
+- **Timestamps**: enable with `{ timestamps: true }`
+- **Colors**: auto-enabled in terminals (cyan=debug, green=info, yellow=warn, red=error)
+
+```typescript
+import { startTimer, prettyPrint } from '@slbdn/mcp-tester';
+
+// Measure operation timing
+const elapsed = startTimer();
+await someOperation();
+console.log(`Took ${elapsed()}ms`);
+
+// Pretty-print objects with secret masking
+prettyPrint({ apiKey: 'sk-proj-abc123...', count: 42 });
+```
+
+See [Troubleshooting Guide](./docs/troubleshooting.md) for more details.
+
+## VS Code Snippets
+
+Type `mcp` in any TypeScript file to get started — 15 built-in snippets:
+
+| Prefix | Inserts |
+|--------|--------|
+| `mcp-test` | Full test suite with lifecycle setup |
+| `mcp-tool` | Tool call test + assertion |
+| `mcp-resource` | Resource read test |
+| `mcp-prompt` | Prompt get test |
+| `mcp-client` | `new MCPClient()` + `start()` |
+| `mcp-client-opts` | Client with timeout, retries, log level |
+| `mcp-error` | Error handling test (`rejects.toThrow`) |
+| `mcp-parallel` | `Promise.all` parallel tool calls |
+| `mcp-list-tools` | List tools + `toHaveTool` assertion |
+| `mcp-list-resources` | List resources + `toHaveResource` assertion |
+| `mcp-list-prompts` | List prompts + `toHavePrompt` assertion |
+| `mcp-assert-text` | `assert.toolTextEquals()` |
+| `mcp-assert-json` | `assert.toolJsonEquals()` |
+| `mcp-notifications` | Notification handler setup |
+| `mcp-import` / `mcp-import-full` | Import statements |
+
+Snippets are in `.vscode/mcp-tester.code-snippets` — works out of the box when you open the project in VS Code.
+
 ## Contributing
 
 1. Fork the repository

package/dist/cli/index.js

@@ -3,11 +3,27 @@
 import { Command } from 'commander';
 import { MCPClient } from '../client/MCPClient.js';
 import { MCPConnectionError, MCPTimeoutError, MCPServerError } from '../utils/errors.js';
+import { generateTests } from '../generate-tests.js';
+import { generateTypes } from '../generate-types.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Read version from package.json (works in both src and dist)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getPackageVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
 const program = new Command();
 program
     .name('mcp-tester')
     .description('CLI tool for testing MCP servers')
-    .version('1.0.0', '-V, --version');
+    .version(getPackageVersion(), '-V, --version');
 // Global options - use string type since commander passes strings
 program
     .option('-t, --timeout <ms>', 'Request timeout in milliseconds', '30000')
@@ -290,6 +306,101 @@ program
         await client.stop();
     }
 });
+// Generate test file command
+program
+    .command('generate')
+    .alias('gen')
+    .description('Generate test file from MCP server inspection')
+    .argument('<command>', 'Command to run the MCP server')
+    .argument('[args...]', 'Arguments for the server command')
+    .option('-o, --output <file>', 'Output file path (prints to stdout if omitted)')
+    .option('--framework <fw>', 'Test framework: jest or vitest', 'jest')
+    .option('--description <desc>', 'Description for the test suite')
+    .option('--no-resources', 'Skip resource tests')
+    .option('--no-prompts', 'Skip prompt tests')
+    .option('--no-tools', 'Skip tool tests')
+    .option('--no-matchers', 'Skip custom matchers import')
+    .action(async (command, serverArgs, opts) => {
+    const framework = String(opts['framework'] || 'jest');
+    if (framework !== 'jest' && framework !== 'vitest') {
+        console.error('❌ Framework must be "jest" or "vitest"');
+        process.exit(1);
+    }
+    try {
+        console.error('🔍 Inspecting MCP server...');
+        const code = await generateTests({
+            command,
+            args: serverArgs,
+            framework: framework,
+            description: opts['description'],
+            includeResources: opts['resources'] !== false,
+            includePrompts: opts['prompts'] !== false,
+            includeTools: opts['tools'] !== false,
+            includeMatchers: opts['matchers'] !== false,
+            timeout: parseInt(String(opts['timeout'] || '30000')),
+        });
+        if (opts['output']) {
+            const fs = await import('fs');
+            const path = await import('path');
+            const outputPath = String(opts['output']);
+            const dir = path.dirname(outputPath);
+            if (dir && dir !== '.') {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(outputPath, code, 'utf-8');
+            console.error(`✅ Generated test file: ${outputPath}`);
+        }
+        else {
+            process.stdout.write(code);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});
+// Generate TypeScript types command
+program
+    .command('generate-types')
+    .alias('gen-types')
+    .description('Generate TypeScript type declarations from MCP server tool schemas')
+    .argument('<command>', 'Command to run the MCP server')
+    .argument('[args...]', 'Arguments for the server command')
+    .option('-o, --output <file>', 'Output file path (prints to stdout if omitted)')
+    .option('--module-name <name>', 'Module name for import hints', '@slbdn/mcp-tester')
+    .option('--no-resources', 'Skip resource URI types')
+    .option('--no-prompts', 'Skip prompt argument types')
+    .action(async (command, serverArgs, opts) => {
+    try {
+        console.error('🔍 Inspecting MCP server for type generation...');
+        const types = await generateTypes({
+            command,
+            args: serverArgs,
+            moduleName: opts['moduleName'],
+            includeResources: opts['resources'] !== false,
+            includePrompts: opts['prompts'] !== false,
+            timeout: parseInt(String(opts['timeout'] || '30000')),
+        });
+        if (opts['output']) {
+            const fs = await import('fs');
+            const path = await import('path');
+            const outputPath = String(opts['output']);
+            const dir = path.dirname(outputPath);
+            if (dir && dir !== '.') {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(outputPath, types, 'utf-8');
+            console.error(`✅ Generated type declarations: ${outputPath}`);
+        }
+        else {
+            process.stdout.write(types);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});
 // Add custom help with examples using Commander's built-in help system
 program.addHelpText('after', `
 Examples:
@@ -300,6 +411,8 @@ Examples:
   mcp-tester get-prompt greet node ./server.js --args '{"name":"World"}'
   mcp-tester lt node ./server.js                          # short alias for list-tools
   mcp-tester ct echo node ./server.js --params '{}'       # short alias for call-tool
+  mcp-tester generate node ./server.js -o server.test.ts  # generate test file
+  mcp-tester generate-types node ./server.js -o server.d.ts  # generate TypeScript types
 `);
 // Show help when invoked with no arguments
 const args = process.argv.slice(2);