@outfitter/testing 0.1.0-rc.1

package/README.md

@@ -0,0 +1,281 @@
+# @outfitter/testing
+
+Test harnesses, fixtures, and utilities for Outfitter packages.
+
+## Installation
+
+```bash
+bun add -d @outfitter/testing
+```
+
+## Quick Start
+
+```typescript
+import {
+  createFixture,
+  createCliHarness,
+  createMcpHarness,
+  withTempDir,
+  withEnv,
+} from "@outfitter/testing";
+
+// Create reusable test fixtures
+const createUser = createFixture({
+  id: 1,
+  name: "Test User",
+  email: "test@example.com",
+});
+
+// Test CLI commands
+const cli = createCliHarness("./bin/my-cli");
+const result = await cli.run(["--help"]);
+expect(result.exitCode).toBe(0);
+
+// Test MCP tools
+const harness = createMcpHarness(myMcpServer);
+const tools = await harness.listTools();
+const output = await harness.invoke("my-tool", { input: "value" });
+```
+
+## Fixtures
+
+Factory functions for creating test data with sensible defaults.
+
+### createFixture
+
+Creates a fixture factory that returns new objects with optional overrides.
+
+```typescript
+import { createFixture } from "@outfitter/testing";
+
+// Define defaults
+const createUser = createFixture({
+  id: 1,
+  name: "John Doe",
+  email: "john@example.com",
+  settings: { theme: "dark", notifications: true },
+});
+
+// Use defaults
+const user1 = createUser();
+
+// Override specific fields (supports deep merge)
+const user2 = createUser({
+  name: "Jane Doe",
+  settings: { theme: "light" },
+});
+// Result: { id: 1, name: "Jane Doe", email: "john@example.com", settings: { theme: "light", notifications: true } }
+```
+
+Each call returns a fresh copy, preventing test pollution from shared mutable state.
+
+### withTempDir
+
+Runs a function with an isolated temporary directory that is automatically cleaned up.
+
+```typescript
+import { withTempDir } from "@outfitter/testing";
+import { join } from "node:path";
+
+const result = await withTempDir(async (dir) => {
+  // Write test files
+  await Bun.write(join(dir, "config.json"), JSON.stringify({ key: "value" }));
+
+  // Run code that operates on the directory
+  return await processDirectory(dir);
+});
+// Directory is automatically removed after the callback
+```
+
+Cleanup occurs even if the callback throws an error.
+
+### withEnv
+
+Runs a function with temporary environment variables, restoring originals after.
+
+```typescript
+import { withEnv } from "@outfitter/testing";
+
+await withEnv({ API_KEY: "test-key", DEBUG: "true" }, async () => {
+  // process.env.API_KEY is "test-key"
+  // process.env.DEBUG is "true"
+  await runTests();
+});
+// Original environment is restored
+```
+
+## CLI Test Harness
+
+Execute CLI commands and capture their output for assertions.
+
+### createCliHarness
+
+Creates a harness for testing command-line tools.
+
+```typescript
+import { createCliHarness } from "@outfitter/testing";
+
+const harness = createCliHarness("./bin/my-cli");
+
+// Test help output
+const helpResult = await harness.run(["--help"]);
+expect(helpResult.stdout).toContain("Usage:");
+expect(helpResult.exitCode).toBe(0);
+
+// Test error handling
+const errorResult = await harness.run(["--invalid-flag"]);
+expect(errorResult.stderr).toContain("Unknown option");
+expect(errorResult.exitCode).toBe(1);
+
+// Test with arguments
+const result = await harness.run(["process", "--input", "data.json"]);
+expect(result.stdout).toContain("Processed successfully");
+```
+
+### CliResult Interface
+
+```typescript
+interface CliResult {
+  /** Standard output from the command */
+  stdout: string;
+  /** Standard error output from the command */
+  stderr: string;
+  /** Exit code (0 typically indicates success) */
+  exitCode: number;
+}
+```
+
+## MCP Test Harness
+
+Test MCP (Model Context Protocol) server tool invocations.
+
+### createMcpHarness
+
+Creates a test harness from an MCP server for invoking and inspecting tools.
+
+```typescript
+import { createMcpHarness, type McpServer } from "@outfitter/testing";
+
+// Create or mock an MCP server
+const server: McpServer = {
+  tools: [
+    {
+      name: "add",
+      description: "Add two numbers",
+      handler: ({ a, b }) => a + b,
+    },
+    {
+      name: "greet",
+      description: "Generate a greeting",
+      handler: ({ name }) => `Hello, ${name}!`,
+    },
+  ],
+  async invoke(toolName, input) {
+    const tool = this.tools.find(t => t.name === toolName);
+    if (!tool) throw new Error(`Tool not found: ${toolName}`);
+    return tool.handler(input);
+  },
+};
+
+// Create harness
+const harness = createMcpHarness(server);
+
+// List available tools
+const tools = await harness.listTools();
+expect(tools).toEqual(["add", "greet"]);
+
+// Invoke tools with type inference
+const sum = await harness.invoke<number>("add", { a: 2, b: 3 });
+expect(sum).toBe(5);
+
+const greeting = await harness.invoke<string>("greet", { name: "World" });
+expect(greeting).toBe("Hello, World!");
+```
+
+### McpHarness Interface
+
+```typescript
+interface McpHarness {
+  /** Invoke a tool by name with input parameters */
+  invoke<T>(toolName: string, input: unknown): Promise<T>;
+  /** List all available tool names */
+  listTools(): Promise<string[]>;
+}
+```
+
+### McpServer Interface
+
+Minimal interface for MCP servers (can be real or mocked).
+
+```typescript
+interface McpServer {
+  /** Array of tools registered on the server */
+  tools: McpTool[];
+  /** Invoke a tool by name with input */
+  invoke(toolName: string, input: unknown): Promise<unknown>;
+}
+
+interface McpTool {
+  /** Unique name of the tool */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Handler function for the tool */
+  handler: McpToolHandler;
+}
+
+type McpToolHandler = (input: unknown) => unknown | Promise<unknown>;
+```
+
+## Subpath Exports
+
+Import specific modules directly for smaller bundles:
+
+```typescript
+// Just fixtures
+import { createFixture, withTempDir, withEnv } from "@outfitter/testing/fixtures";
+
+// Just CLI harness
+import { createCliHarness } from "@outfitter/testing/cli-harness";
+
+// Just MCP harness
+import { createMcpHarness } from "@outfitter/testing/mcp-harness";
+```
+
+## API Reference
+
+### Fixtures
+
+| Export | Description |
+|--------|-------------|
+| `createFixture<T>(defaults)` | Create a fixture factory with deep merge support |
+| `withTempDir<T>(fn)` | Run callback with auto-cleaned temp directory |
+| `withEnv<T>(vars, fn)` | Run callback with temporary environment variables |
+
+### CLI Harness
+
+| Export | Description |
+|--------|-------------|
+| `createCliHarness(command)` | Create a CLI test harness |
+| `CliHarness` | Interface for CLI harness |
+| `CliResult` | Interface for command execution result |
+
+### MCP Harness
+
+| Export | Description |
+|--------|-------------|
+| `createMcpHarness(server)` | Create an MCP test harness |
+| `McpHarness` | Interface for MCP harness |
+| `McpServer` | Interface for MCP server |
+| `McpTool` | Interface for tool definition |
+| `McpToolHandler` | Type for tool handler functions |
+
+## Related Packages
+
+- `@outfitter/cli` - CLI framework for building command-line tools
+- `@outfitter/mcp` - MCP server framework with typed tools
+- `@outfitter/contracts` - Result types and error patterns
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,259 @@
+/**
+* Deep partial type that makes all nested properties optional.
+* Used for fixture overrides.
+*/
+type DeepPartial<T> = T extends object ? { [P in keyof T]? : DeepPartial<T[P]> } : T;
+/**
+* Creates a fixture factory for generating test data with defaults.
+*
+* The factory returns a new object each time it's called, preventing
+* test pollution from shared mutable state. Supports deep merging
+* for nested objects.
+*
+* @typeParam T - The shape of the fixture object
+* @param defaults - Default values for the fixture
+* @returns A factory function that creates fixtures with optional overrides
+*
+* @example
+* ```typescript
+* const createUser = createFixture({
+*   id: 1,
+*   name: "John Doe",
+*   email: "john@example.com",
+*   settings: { theme: "dark", notifications: true }
+* });
+*
+* // Use defaults
+* const user1 = createUser();
+*
+* // Override specific fields
+* const user2 = createUser({ name: "Jane Doe", settings: { theme: "light" } });
+* ```
+*/
+declare function createFixture<T extends object>(defaults: T): (overrides?: DeepPartial<T>) => T;
+/**
+* Runs a function with a temporary directory, cleaning up after.
+*
+* Creates a unique temporary directory before invoking the callback,
+* and removes it (including all contents) after the callback completes.
+* Cleanup occurs even if the callback throws an error.
+*
+* @typeParam T - Return type of the callback
+* @param fn - Async function that receives the temp directory path
+* @returns The value returned by the callback
+*
+* @example
+* ```typescript
+* const result = await withTempDir(async (dir) => {
+*   await Bun.write(join(dir, "test.txt"), "content");
+*   return await processFiles(dir);
+* });
+* // Directory is automatically cleaned up
+* ```
+*/
+declare function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T>;
+/**
+* Runs a function with temporary environment variables, restoring after.
+*
+* Sets the specified environment variables before invoking the callback,
+* then restores the original values after the callback completes.
+* Restoration occurs even if the callback throws an error.
+*
+* @typeParam T - Return type of the callback
+* @param vars - Environment variables to set
+* @param fn - Async function to run with the modified environment
+* @returns The value returned by the callback
+*
+* @example
+* ```typescript
+* await withEnv({ API_KEY: "test-key", DEBUG: "true" }, async () => {
+*   // process.env.API_KEY is "test-key"
+*   // process.env.DEBUG is "true"
+*   await runTests();
+* });
+* // Original environment is restored
+* ```
+*/
+declare function withEnv<T>(vars: Record<string, string>, fn: () => Promise<T>): Promise<T>;
+interface LoadFixtureOptions {
+	/**
+	* Base fixtures directory.
+	* Defaults to `${process.cwd()}/__fixtures__`.
+	*/
+	readonly fixturesDir?: string;
+}
+/**
+* Load a fixture from the fixtures directory.
+*
+* JSON fixtures are parsed automatically; all other file types are returned as strings.
+*
+* @example
+* ```typescript
+* const note = loadFixture<{ id: string }>("mcp/notes.json");
+* const config = loadFixture("mcp/config.toml");
+* ```
+*/
+declare function loadFixture2<T = string>(name: string, options?: LoadFixtureOptions): T;
+/**
+* Result of a CLI command execution.
+*
+* Contains the captured output streams and exit code from the command.
+*/
+interface CliResult {
+	/** Standard output from the command */
+	stdout: string;
+	/** Standard error output from the command */
+	stderr: string;
+	/** Exit code from the command (0 typically indicates success) */
+	exitCode: number;
+}
+/**
+* Harness for executing CLI commands in tests.
+*
+* Provides a simple interface to run a pre-configured command
+* with various arguments and capture the results.
+*/
+interface CliHarness {
+	/**
+	* Runs the command with the given arguments.
+	*
+	* @param args - Command-line arguments to pass to the command
+	* @returns Promise resolving to the execution result
+	*/
+	run(args: string[]): Promise<CliResult>;
+}
+/**
+* Creates a CLI harness for testing command-line tools.
+*
+* The harness wraps a command and provides a simple interface for
+* executing it with different arguments, capturing stdout, stderr,
+* and exit code for assertions.
+*
+* @param command - The command to execute (e.g., "echo", "node", "./bin/cli")
+* @returns A CliHarness instance for running the command
+*
+* @example
+* ```typescript
+* const harness = createCliHarness("./bin/my-cli");
+*
+* // Test help output
+* const helpResult = await harness.run(["--help"]);
+* expect(helpResult.stdout).toContain("Usage:");
+* expect(helpResult.exitCode).toBe(0);
+*
+* // Test error case
+* const errorResult = await harness.run(["--invalid-flag"]);
+* expect(errorResult.stderr).toContain("Unknown option");
+* expect(errorResult.exitCode).toBe(1);
+* ```
+*/
+declare function createCliHarness(command: string): CliHarness;
+/**
+* @outfitter/testing - CLI Helpers
+*
+* Utilities for capturing CLI output and mocking stdin in tests.
+*
+* @packageDocumentation
+*/
+interface CliTestResult {
+	/** Captured stdout */
+	stdout: string;
+	/** Captured stderr */
+	stderr: string;
+	/** Process exit code */
+	exitCode: number;
+}
+/**
+* Capture stdout/stderr and exit code from an async CLI function.
+*/
+declare function captureCLI(fn: () => Promise<void> | void): Promise<CliTestResult>;
+/**
+* Mock stdin with provided input.
+*
+* Returns a restore function for convenience.
+*/
+declare function mockStdin(input: string): {
+	restore: () => void;
+};
+import { OutfitterError, Result } from "@outfitter/contracts";
+import { McpError, McpServer, SerializedTool, ToolDefinition } from "@outfitter/mcp";
+/**
+* MCP tool response content.
+* Matches the MCP protocol shape used in the spec.
+*/
+interface McpToolResponse {
+	content: Array<{
+		type: "text" | "image";
+		text?: string;
+		data?: string;
+	}>;
+	isError?: boolean;
+}
+/**
+* Test harness for MCP servers.
+*/
+interface McpHarness {
+	/**
+	* Call a tool by name with input parameters.
+	* Returns the MCP-formatted response.
+	*/
+	callTool(name: string, input: Record<string, unknown>): Promise<Result<McpToolResponse, InstanceType<typeof McpError>>>;
+	/**
+	* List all registered tools with schemas.
+	*/
+	listTools(): SerializedTool[];
+	/**
+	* Search tools by name or description (case-insensitive).
+	*/
+	searchTools(query: string): SerializedTool[];
+	/**
+	* Load fixture data by name (relative to __fixtures__).
+	*/
+	loadFixture<T = string>(name: string): T;
+	/**
+	* Reset harness state between tests.
+	*/
+	reset(): void;
+}
+interface McpHarnessOptions {
+	/** Base fixtures directory (defaults to `${process.cwd()}/__fixtures__`). */
+	readonly fixturesDir?: string;
+}
+interface McpTestHarnessOptions {
+	/** Tools to register on the test MCP server. */
+	readonly tools: ToolDefinition<unknown, unknown, OutfitterError>[];
+	/** Base fixtures directory (defaults to `${process.cwd()}/__fixtures__`). */
+	readonly fixturesDir?: string;
+	/** Optional server name for diagnostics. */
+	readonly name?: string;
+	/** Optional server version for diagnostics. */
+	readonly version?: string;
+}
+/**
+* Creates an MCP test harness from an MCP server.
+*/
+declare function createMcpHarness(server: McpServer, options?: McpHarnessOptions): McpHarness;
+/**
+* Creates an MCP test harness from tool definitions.
+*
+* This is a spec-compatible wrapper that builds a test server,
+* registers tools, and returns the standard MCP harness.
+*/
+declare function createMCPTestHarness(options: McpTestHarnessOptions): McpHarness;
+import { HandlerContext, Logger, ResolvedConfig } from "@outfitter/contracts";
+import { z } from "zod";
+interface LogEntry {
+	level: "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+	message: string;
+	data?: Record<string, unknown>;
+}
+interface TestLogger extends Logger {
+	/** Captured log entries for assertions */
+	logs: LogEntry[];
+	/** Clear captured logs */
+	clear(): void;
+}
+declare function createTestLogger(context?: Record<string, unknown>): TestLogger;
+declare function createTestConfig<T>(schema: z.ZodType<T>, values: Partial<T>): ResolvedConfig;
+declare function createTestContext(overrides?: Partial<HandlerContext>): HandlerContext;
+export { withTempDir, withEnv, mockStdin, loadFixture2 as loadFixture, createTestLogger, createTestContext, createTestConfig, createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, createFixture, createCliHarness, captureCLI, TestLogger, McpToolResponse, McpTestHarnessOptions, McpHarness, LogEntry, CliTestResult, CliResult, CliHarness };

package/dist/index.js

@@ -0,0 +1,399 @@
+// src/fixtures.ts
+import { readFileSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue === undefined) {
+      continue;
+    }
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    cloned[key] = deepClone(obj[key]);
+  }
+  return cloned;
+}
+function createFixture(defaults) {
+  return (overrides) => {
+    const cloned = deepClone(defaults);
+    if (overrides === undefined) {
+      return cloned;
+    }
+    return deepMerge(cloned, overrides);
+  };
+}
+function generateTempDirPath() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).slice(2, 10);
+  return join(tmpdir(), `outfitter-test-${timestamp}-${random}`);
+}
+async function withTempDir(fn) {
+  const dir = generateTempDirPath();
+  await mkdir(dir, { recursive: true });
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+async function withEnv(vars, fn) {
+  const originalValues = new Map;
+  for (const key of Object.keys(vars)) {
+    originalValues.set(key, process.env[key]);
+  }
+  for (const [key, value] of Object.entries(vars)) {
+    process.env[key] = value;
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const [key, originalValue] of originalValues) {
+      if (originalValue === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = originalValue;
+      }
+    }
+  }
+}
+function loadFixture(name, options) {
+  const baseDir = options?.fixturesDir ?? join(process.cwd(), "__fixtures__");
+  const filePath = join(baseDir, name);
+  const content = readFileSync(filePath, "utf-8");
+  if (extname(filePath) === ".json") {
+    return JSON.parse(content);
+  }
+  return content;
+}
+// src/cli-harness.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:os";
+function createCliHarness(command) {
+  return {
+    run(args) {
+      return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+          shell: false,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        child.stdin.end();
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => {
+          stdoutChunks.push(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+          stderrChunks.push(chunk);
+        });
+        child.on("error", (err) => {
+          reject(err);
+        });
+        child.on("close", (exitCode, signal) => {
+          const decoder = new TextDecoder("utf-8");
+          let finalExitCode;
+          if (exitCode !== null) {
+            finalExitCode = exitCode;
+          } else if (signal !== null) {
+            const signalNumber = constants.signals[signal];
+            finalExitCode = signalNumber !== undefined ? 128 + signalNumber : 1;
+          } else {
+            finalExitCode = 1;
+          }
+          resolve({
+            stdout: decoder.decode(concatUint8Arrays(stdoutChunks)),
+            stderr: decoder.decode(concatUint8Arrays(stderrChunks)),
+            exitCode: finalExitCode
+          });
+        });
+      });
+    }
+  };
+}
+function concatUint8Arrays(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+// src/cli-helpers.ts
+class ExitError extends Error {
+  code;
+  constructor(code) {
+    super(`Process exited with code ${code}`);
+    this.code = code;
+  }
+}
+async function captureCLI(fn) {
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const originalExit = process.exit.bind(process);
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  process.stdout.write = (chunk, _encoding, cb) => {
+    stdoutChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  process.stderr.write = (chunk, _encoding, cb) => {
+    stderrChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  console.log = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stdoutChunks.push(new TextEncoder().encode(line));
+  };
+  console.error = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stderrChunks.push(new TextEncoder().encode(line));
+  };
+  process.exit = (code) => {
+    throw new ExitError(code ?? 0);
+  };
+  let exitCode = 0;
+  try {
+    await fn();
+  } catch (error) {
+    if (error instanceof ExitError) {
+      exitCode = error.code;
+    } else {
+      exitCode = 1;
+    }
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+    process.exit = originalExit;
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  }
+  const decoder = new TextDecoder("utf-8");
+  return {
+    stdout: decoder.decode(concatChunks(stdoutChunks)),
+    stderr: decoder.decode(concatChunks(stderrChunks)),
+    exitCode
+  };
+}
+function mockStdin(input) {
+  const originalStdin = process.stdin;
+  const encoded = new TextEncoder().encode(input);
+  const mockStream = {
+    async* [Symbol.asyncIterator]() {
+      yield encoded;
+    },
+    fd: 0,
+    isTTY: false
+  };
+  process.stdin = mockStream;
+  return {
+    restore: () => {
+      process.stdin = originalStdin;
+    }
+  };
+}
+function concatChunks(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+// src/mcp-harness.ts
+import {
+  createMcpServer
+} from "@outfitter/mcp";
+function createMcpHarness(server, options = {}) {
+  return {
+    callTool(name, input) {
+      return server.invokeTool(name, input);
+    },
+    listTools() {
+      return server.getTools();
+    },
+    searchTools(query) {
+      const normalized = query.trim().toLowerCase();
+      const tools = server.getTools();
+      if (normalized.length === 0) {
+        return tools;
+      }
+      return tools.filter((tool) => {
+        const nameMatch = tool.name.toLowerCase().includes(normalized);
+        const descriptionMatch = tool.description.toLowerCase().includes(normalized);
+        return nameMatch || descriptionMatch;
+      });
+    },
+    loadFixture(name) {
+      return loadFixture(name, options.fixturesDir ? { fixturesDir: options.fixturesDir } : undefined);
+    },
+    reset() {}
+  };
+}
+function createMCPTestHarness(options) {
+  const server = createMcpServer({
+    name: options.name ?? "mcp-test",
+    version: options.version ?? "0.0.0"
+  });
+  for (const tool of options.tools) {
+    server.registerTool(tool);
+  }
+  return createMcpHarness(server, {
+    ...options.fixturesDir !== undefined ? { fixturesDir: options.fixturesDir } : {}
+  });
+}
+// src/mock-factories.ts
+import {
+  generateRequestId
+} from "@outfitter/contracts";
+function createTestLogger(context = {}) {
+  return createTestLoggerWithContext(context, []);
+}
+function createTestLoggerWithContext(context, logs) {
+  const write = (level, message, data) => {
+    const merged = { ...context, ...data ?? {} };
+    const entry = {
+      level,
+      message
+    };
+    if (Object.keys(merged).length > 0) {
+      entry.data = merged;
+    }
+    logs.push(entry);
+  };
+  return {
+    logs,
+    clear() {
+      logs.length = 0;
+    },
+    trace(message, metadata) {
+      write("trace", message, metadata);
+    },
+    debug(message, metadata) {
+      write("debug", message, metadata);
+    },
+    info(message, metadata) {
+      write("info", message, metadata);
+    },
+    warn(message, metadata) {
+      write("warn", message, metadata);
+    },
+    error(message, metadata) {
+      write("error", message, metadata);
+    },
+    fatal(message, metadata) {
+      write("fatal", message, metadata);
+    },
+    child(childContext) {
+      return createTestLoggerWithContext({ ...context, ...childContext }, logs);
+    }
+  };
+}
+function createTestConfig(schema, values) {
+  const parsed = schema.safeParse(values);
+  let data;
+  if (parsed.success) {
+    data = parsed.data;
+  } else {
+    const maybePartial = schema.partial;
+    if (typeof maybePartial !== "function") {
+      throw parsed.error;
+    }
+    const partialSchema = maybePartial.call(schema);
+    const partialParsed = partialSchema.safeParse(values);
+    if (!partialParsed.success) {
+      throw partialParsed.error;
+    }
+    data = partialParsed.data;
+  }
+  return {
+    get(key) {
+      return getPath(data, key);
+    },
+    getRequired(key) {
+      const value = getPath(data, key);
+      if (value === undefined) {
+        throw new Error(`Missing required config value: ${key}`);
+      }
+      return value;
+    }
+  };
+}
+function createTestContext(overrides = {}) {
+  const logger = overrides.logger ?? createTestLogger();
+  const requestId = overrides.requestId ?? generateRequestId();
+  const context = {
+    requestId,
+    logger,
+    cwd: overrides.cwd ?? process.cwd(),
+    env: overrides.env ?? { ...process.env }
+  };
+  if (overrides.config !== undefined) {
+    context.config = overrides.config;
+  }
+  if (overrides.signal !== undefined) {
+    context.signal = overrides.signal;
+  }
+  if (overrides.workspaceRoot !== undefined) {
+    context.workspaceRoot = overrides.workspaceRoot;
+  }
+  return context;
+}
+function getPath(obj, key) {
+  const parts = key.split(".").filter((part) => part.length > 0);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+export {
+  withTempDir,
+  withEnv,
+  mockStdin,
+  loadFixture,
+  createTestLogger,
+  createTestContext,
+  createTestConfig,
+  createMCPTestHarness as createMcpTestHarness,
+  createMcpHarness,
+  createMCPTestHarness,
+  createFixture,
+  createCliHarness,
+  captureCLI
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@outfitter/testing",
+  "description": "Test harnesses, fixtures, and utilities for Outfitter packages",
+  "version": "0.1.0-rc.1",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./fixtures": {
+      "import": {
+        "types": "./dist/fixtures.d.ts",
+        "default": "./dist/fixtures.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "bunup --filter @outfitter/testing",
+    "lint": "biome lint ./src",
+    "lint:fix": "biome lint --write ./src",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@outfitter/contracts": "workspace:*",
+    "@outfitter/mcp": "workspace:*",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "outfitter",
+    "testing",
+    "fixtures",
+    "harness",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outfitter-dev/outfitter.git",
+    "directory": "packages/testing"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}