@outfitter/testing 0.2.1 → 0.2.2

package/README.md

@@ -261,12 +261,12 @@ 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";
+All harness utilities are available from the main package export:
 
-// Just MCP harness
-import { createMcpHarness } from "@outfitter/testing/mcp-harness";
+```typescript
+import { createCliHarness, createMcpHarness } from "@outfitter/testing";
 ```
 
 ## API Reference

package/dist/cli-harness.d.ts

@@ -0,0 +1,2 @@
+import { CliHarness, CliResult, createCliHarness } from "./shared/@outfitter/testing-wes8smnv";
+export { createCliHarness, CliResult, CliHarness };

package/dist/cli-harness.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  createCliHarness
+} from "./shared/@outfitter/testing-wfp5f7pq.js";
+export {
+  createCliHarness
+};

package/dist/cli-helpers.d.ts

@@ -0,0 +1,2 @@
+import { CliTestResult, captureCLI, mockStdin } from "./shared/@outfitter/testing-ark2sn92";
+export { mockStdin, captureCLI, CliTestResult };

package/dist/cli-helpers.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  captureCLI,
+  mockStdin
+} from "./shared/@outfitter/testing-xsfjh1n3.js";
+export {
+  mockStdin,
+  captureCLI
+};

package/dist/fixtures.d.ts

@@ -0,0 +1,2 @@
+import { createFixture, loadFixture, withEnv, withTempDir } from "./shared/@outfitter/testing-98fsks4n";
+export { withTempDir, withEnv, loadFixture, createFixture };

package/dist/fixtures.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  createFixture,
+  loadFixture,
+  withEnv,
+  withTempDir
+} from "./shared/@outfitter/testing-1wd76sr8.js";
+export {
+  withTempDir,
+  withEnv,
+  loadFixture,
+  createFixture
+};

package/dist/mcp-harness.d.ts

@@ -0,0 +1,2 @@
+import { McpHarness, McpHarnessOptions, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-6e1425qr";
+export { createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, McpToolResponse, McpTestHarnessOptions, McpHarnessOptions, McpHarness };

package/dist/mcp-harness.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  createMCPTestHarness,
+  createMcpHarness
+} from "./shared/@outfitter/testing-05hzzr8n.js";
+import"./shared/@outfitter/testing-1wd76sr8.js";
+export {
+  createMCPTestHarness as createMcpTestHarness,
+  createMcpHarness,
+  createMCPTestHarness
+};

package/dist/mock-factories.d.ts

@@ -0,0 +1,2 @@
+import { LogEntry, TestLogger, createTestConfig, createTestContext, createTestLogger } from "./shared/@outfitter/testing-qnrap0h2";
+export { createTestLogger, createTestContext, createTestConfig, TestLogger, LogEntry };

package/dist/mock-factories.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  createTestConfig,
+  createTestContext,
+  createTestLogger
+} from "./shared/@outfitter/testing-kdwa417a.js";
+export {
+  createTestLogger,
+  createTestContext,
+  createTestConfig
+};

package/dist/shared/@outfitter/testing-05hzzr8n.js

@@ -0,0 +1,48 @@
+// @bun
+import {
+  loadFixture
+} from "./testing-1wd76sr8.js";
+
+// packages/testing/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 } : {}
+  });
+}
+export { createMcpHarness, createMCPTestHarness };

package/dist/shared/@outfitter/testing-1wd76sr8.js

@@ -0,0 +1,126 @@
+// @bun
+// packages/testing/src/fixtures.ts
+var cachedRequire;
+function getNodeRequire() {
+  if (cachedRequire !== undefined) {
+    if (cachedRequire === null) {
+      throw new Error("Node.js built-ins are unavailable in this runtime.");
+    }
+    return cachedRequire;
+  }
+  const metaRequire = import.meta.require;
+  if (typeof metaRequire === "function") {
+    cachedRequire = metaRequire;
+    return metaRequire;
+  }
+  const globalRequire = globalThis.require;
+  if (typeof globalRequire === "function") {
+    cachedRequire = globalRequire;
+    return globalRequire;
+  }
+  cachedRequire = null;
+  throw new Error("Node.js built-ins are unavailable in this runtime.");
+}
+function getNodeFs() {
+  return getNodeRequire()("node:fs");
+}
+function getNodeFsPromises() {
+  return getNodeRequire()("node:fs/promises");
+}
+function getNodeOs() {
+  return getNodeRequire()("node:os");
+}
+function getNodePath() {
+  return getNodeRequire()("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 { tmpdir } = getNodeOs();
+  const { join } = getNodePath();
+  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 { mkdir, rm } = getNodeFsPromises();
+  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 { readFileSync } = getNodeFs();
+  const { extname, join } = getNodePath();
+  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;
+}
+
+export { createFixture, withTempDir, withEnv, loadFixture };

package/dist/shared/@outfitter/testing-6e1425qr.d.ts

@@ -0,0 +1,66 @@
+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;
+export { McpToolResponse, McpHarness, McpHarnessOptions, McpTestHarnessOptions, createMcpHarness, createMCPTestHarness };

package/dist/shared/@outfitter/testing-98fsks4n.d.ts

@@ -0,0 +1,97 @@
+/**
+* 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 loadFixture<T = string>(name: string, options?: LoadFixtureOptions): T;
+export { createFixture, withTempDir, withEnv, loadFixture };

package/dist/shared/@outfitter/testing-ark2sn92.d.ts

@@ -0,0 +1,28 @@
+/**
+* @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;
+};
+export { CliTestResult, captureCLI, mockStdin };

package/dist/shared/@outfitter/testing-kdwa417a.js

@@ -0,0 +1,111 @@
+// @bun
+// packages/testing/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 { createTestLogger, createTestConfig, createTestContext };

package/dist/shared/@outfitter/testing-qnrap0h2.d.ts

@@ -0,0 +1,17 @@
+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 { LogEntry, TestLogger, createTestLogger, createTestConfig, createTestContext };

package/dist/shared/@outfitter/testing-wes8smnv.d.ts

@@ -0,0 +1,64 @@
+/**
+* @outfitter/testing - CLI Harness
+*
+* Test harness for executing and capturing CLI command output.
+* Provides a simple interface for running CLI commands in tests
+* and capturing their stdout, stderr, and exit code.
+*
+* @packageDocumentation
+*/
+/**
+* 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;
+export { CliResult, CliHarness, createCliHarness };

package/dist/shared/@outfitter/testing-wfp5f7pq.js

@@ -0,0 +1,29 @@
+// @bun
+// packages/testing/src/cli-harness.ts
+function createCliHarness(command) {
+  return {
+    async run(args) {
+      const child = Bun.spawn([command, ...args], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      child.stdin?.end();
+      const stdoutPromise = child.stdout ? new Response(child.stdout).text() : Promise.resolve("");
+      const stderrPromise = child.stderr ? new Response(child.stderr).text() : Promise.resolve("");
+      const exitCodePromise = child.exited;
+      const [stdout, stderr, exitCode] = await Promise.all([
+        stdoutPromise,
+        stderrPromise,
+        exitCodePromise
+      ]);
+      return {
+        stdout,
+        stderr,
+        exitCode: typeof exitCode === "number" ? exitCode : 1
+      };
+    }
+  };
+}
+
+export { createCliHarness };

package/dist/shared/@outfitter/testing-xsfjh1n3.js

@@ -0,0 +1,94 @@
+// @bun
+// packages/testing/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;
+}
+
+export { captureCLI, mockStdin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outfitter/testing",
   "description": "Test harnesses, fixtures, and utilities for Outfitter packages",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "files": [
     "dist"
@@ -15,12 +15,36 @@
         "default": "./dist/index.js"
       }
     },
+    "./cli-harness": {
+      "import": {
+        "types": "./dist/cli-harness.d.ts",
+        "default": "./dist/cli-harness.js"
+      }
+    },
+    "./cli-helpers": {
+      "import": {
+        "types": "./dist/cli-helpers.d.ts",
+        "default": "./dist/cli-helpers.js"
+      }
+    },
     "./fixtures": {
       "import": {
         "types": "./dist/fixtures.d.ts",
         "default": "./dist/fixtures.js"
       }
     },
+    "./mcp-harness": {
+      "import": {
+        "types": "./dist/mcp-harness.d.ts",
+        "default": "./dist/mcp-harness.js"
+      }
+    },
+    "./mock-factories": {
+      "import": {
+        "types": "./dist/mock-factories.d.ts",
+        "default": "./dist/mock-factories.js"
+      }
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -33,8 +57,8 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@outfitter/contracts": "0.2.0",
-    "@outfitter/mcp": "0.3.0",
+    "@outfitter/contracts": "0.3.0",
+    "@outfitter/mcp": "0.4.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {