@auto-engineer/pipeline 0.0.1

package/src/testing/real-execution.e2e.specs.ts

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { config } from 'dotenv';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { loadPipelineConfig } from '../config/pipeline-config';
+import { PipelineServer } from '../server/pipeline-server';
+import { resetKanbanState } from './fixtures/kanban-full.pipeline';
+import kanbanTodoConfig from './fixtures/kanban-todo.config';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PIPELINE_ROOT = path.resolve(__dirname, '../..');
+const PACKAGES_DIR = path.resolve(__dirname, '../../..');
+const EXAMPLE_DIR = path.resolve(PACKAGES_DIR, '../examples/kanban-todo');
+const CLI_SNAPSHOTS_DIR = path.join(PACKAGES_DIR, 'cli/src/__tests__/e2e/__snapshots__/kanban-todo');
+
+config({ path: path.join(PIPELINE_ROOT, '.env') });
+
+interface StoredMessage {
+  message: {
+    type: string;
+    data: Record<string, unknown>;
+  };
+  position: string;
+  revision: string;
+  messageType: string;
+}
+
+interface CliEventSnapshot {
+  type: string;
+  data: Record<string, unknown>;
+  position: string;
+}
+
+function loadCliEventStream(): CliEventSnapshot[] | null {
+  const snapshotPath = path.join(CLI_SNAPSHOTS_DIR, 'event-stream.snapshot.json');
+  if (!existsSync(snapshotPath)) {
+    console.log(`Event stream snapshot not found: ${snapshotPath}`);
+    return null;
+  }
+  const content = readFileSync(snapshotPath, 'utf-8');
+  return JSON.parse(content) as CliEventSnapshot[];
+}
+
+async function waitForPipelineCompletion(
+  server: PipelineServer,
+  timeoutMs: number,
+  pollIntervalMs: number,
+): Promise<StoredMessage[]> {
+  const startTime = Date.now();
+  let lastMessageCount = 0;
+  let stableCount = 0;
+  const stableThreshold = 15;
+
+  while (Date.now() - startTime < timeoutMs) {
+    const response = await fetch(`http://localhost:${server.port}/messages`);
+    const messages = (await response.json()) as StoredMessage[];
+
+    if (messages.length === lastMessageCount) {
+      stableCount++;
+      if (stableCount >= stableThreshold) {
+        console.log(`  Pipeline stable after ${stableThreshold} polls`);
+        return messages;
+      }
+    } else {
+      if (stableCount > 0) {
+        console.log(`  New activity after ${stableCount} stable polls`);
+      }
+      stableCount = 0;
+      lastMessageCount = messages.length;
+      console.log(`  Messages: ${messages.length}`);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+
+  console.log(`  Timeout reached after ${timeoutMs}ms`);
+  const response = await fetch(`http://localhost:${server.port}/messages`);
+  return (await response.json()) as StoredMessage[];
+}
+
+describe('Real Execution E2E', () => {
+  let server: PipelineServer;
+
+  beforeAll(async () => {
+    const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+    console.log('=== Environment Check ===');
+    console.log(`ANTHROPIC_API_KEY set: ${process.env.ANTHROPIC_API_KEY !== undefined}`);
+    console.log(`Example directory: ${EXAMPLE_DIR}`);
+    console.log(`Example exists: ${existsSync(EXAMPLE_DIR)}`);
+    console.log(`Handlers loaded: ${loaded.handlers.length}`);
+    console.log(`Handler names: ${loaded.handlers.map((h) => h.name).join(', ')}`);
+
+    server = new PipelineServer({ port: 0 });
+    server.registerCommandHandlers(loaded.handlers);
+    server.registerPipeline(loaded.pipeline);
+    await server.start();
+
+    console.log(`Server started on port ${server.port}`);
+  }, 60000);
+
+  afterAll(async () => {
+    await server.stop();
+  });
+
+  beforeEach(() => {
+    resetKanbanState();
+  });
+
+  describe('Full Pipeline Execution', () => {
+    it(
+      'should execute ExportSchema and trigger full pipeline chain',
+      async () => {
+        console.log('\n=== Dispatching ExportSchema ===');
+        console.log(`Target directory: ${EXAMPLE_DIR}`);
+
+        const dispatchResponse = await fetch(`http://localhost:${server.port}/command`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            type: 'ExportSchema',
+            data: {
+              directory: EXAMPLE_DIR,
+            },
+          }),
+        });
+
+        const dispatchResult = (await dispatchResponse.json()) as { status: string; commandId: string };
+        console.log(`Dispatch response: ${JSON.stringify(dispatchResult)}`);
+        expect(dispatchResult.status).toBe('ack');
+
+        console.log('\n=== Waiting for pipeline completion (5 minute timeout) ===');
+        const messages = await waitForPipelineCompletion(server, 5 * 60 * 1000, 2000);
+
+        console.log(`\n=== Pipeline Results ===`);
+        console.log(`Total messages: ${messages.length}`);
+
+        const events = messages.filter((m) => m.messageType === 'event');
+        const commands = messages.filter((m) => m.messageType === 'command');
+
+        console.log(`Events: ${events.length}`);
+        console.log(`Commands: ${commands.length}`);
+
+        console.log('\n=== Event Types (in order) ===');
+        events.forEach((e, i) => {
+          console.log(`  ${i + 1}. ${e.message.type}`);
+          if (e.message.type.includes('Failed')) {
+            console.log(`      Error: ${JSON.stringify(e.message.data)}`);
+          }
+        });
+
+        console.log('\n=== Command Types (in order) ===');
+        commands.forEach((c, i) => {
+          console.log(`  ${i + 1}. ${c.message.type}`);
+        });
+
+        const cliEvents = loadCliEventStream();
+        if (cliEvents !== null) {
+          console.log('\n=== CLI Event Types (for comparison) ===');
+          const cliEventTypes = [...new Set(cliEvents.map((e) => e.type))];
+          cliEventTypes.forEach((t) => {
+            const count = cliEvents.filter((e) => e.type === t).length;
+            console.log(`  ${t}: ${count}`);
+          });
+
+          console.log('\n=== Pipeline Event Types (for comparison) ===');
+          const pipelineEventTypes = [...new Set(events.map((e) => e.message.type))];
+          pipelineEventTypes.forEach((t) => {
+            const count = events.filter((e) => e.message.type === t).length;
+            console.log(`  ${t}: ${count}`);
+          });
+
+          console.log('\n=== Event Type Comparison ===');
+          const cliTypeSet = new Set(cliEventTypes);
+          const pipelineTypeSet = new Set(pipelineEventTypes);
+
+          const missingFromPipeline = cliEventTypes.filter((t) => !pipelineTypeSet.has(t));
+          const extraInPipeline = pipelineEventTypes.filter((t) => !cliTypeSet.has(t));
+
+          console.log(`Missing from pipeline: ${missingFromPipeline.join(', ') || 'none'}`);
+          console.log(`Extra in pipeline: ${extraInPipeline.join(', ') || 'none'}`);
+        }
+
+        expect(events.length).toBeGreaterThan(0);
+
+        const hasSchemaExported = events.some((e) => e.message.type === 'SchemaExported');
+        expect(hasSchemaExported).toBe(true);
+      },
+      10 * 60 * 1000,
+    );
+  });
+});

package/src/testing/real-plugin.e2e.specs.ts

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { loadPipelineConfig } from '../config/pipeline-config';
+import { PipelineServer } from '../server/pipeline-server';
+import { resetKanbanState } from './fixtures/kanban-full.pipeline';
+import kanbanTodoConfig from './fixtures/kanban-todo.config';
+
+describe('Real Plugin E2E', () => {
+  beforeEach(() => {
+    resetKanbanState();
+  });
+
+  describe('Load and Run Pipeline Config', () => {
+    it('should load handlers from config and register them', async () => {
+      const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+      console.log('=== Loaded Handlers ===');
+      console.log(`Total handlers loaded: ${loaded.handlers.length}`);
+      console.log('Handler names:', loaded.handlers.map((h) => h.name).join(', '));
+
+      expect(loaded.handlers.length).toBeGreaterThan(0);
+      expect(loaded.pipeline.descriptor.name).toBe('kanban-full');
+    });
+
+    it('should start server with real config', async () => {
+      const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers(loaded.handlers);
+      server.registerPipeline(loaded.pipeline);
+      await server.start();
+
+      const registeredCommands = server.getRegisteredCommands();
+      console.log('=== Registered Commands ===');
+      registeredCommands.forEach((cmd) => console.log(`  - ${cmd}`));
+
+      expect(registeredCommands.length).toBe(loaded.handlers.length);
+
+      await server.stop();
+    });
+
+    it('should serve pipeline graph via API', async () => {
+      const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers(loaded.handlers);
+      server.registerPipeline(loaded.pipeline);
+      await server.start();
+
+      const response = await fetch(`http://localhost:${server.port}/pipeline`);
+      const text = await response.text();
+
+      expect(response.status).toBe(200);
+      expect(response.headers.get('content-type')).toContain('application/json');
+
+      const graph = JSON.parse(text) as {
+        nodes: Array<{ id: string; name: string }>;
+        edges: Array<{ from: string; to: string }>;
+      };
+
+      console.log('=== Pipeline Graph ===');
+      console.log(`Nodes: ${graph.nodes.length}`);
+      console.log(`Edges: ${graph.edges.length}`);
+
+      expect(graph.nodes.length).toBeGreaterThan(0);
+      expect(graph.edges.length).toBeGreaterThan(0);
+
+      await server.stop();
+    });
+
+    it('should serve registry via API', async () => {
+      const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers(loaded.handlers);
+      server.registerPipeline(loaded.pipeline);
+      await server.start();
+
+      const response = await fetch(`http://localhost:${server.port}/registry`);
+      const registry = (await response.json()) as {
+        eventHandlers: string[];
+        commandHandlers: string[];
+        commandsWithMetadata: Array<{ name: string; alias: string; description: string }>;
+      };
+
+      console.log('=== Registry ===');
+      console.log('Event handlers:', registry.eventHandlers.join(', '));
+      console.log('Command handlers:', registry.commandHandlers.join(', '));
+
+      expect(registry.commandHandlers.length).toBeGreaterThan(0);
+
+      await server.stop();
+    });
+  });
+});

package/src/testing/server-startup.e2e.specs.ts

@@ -0,0 +1,162 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { loadPipelineConfig } from '../config/pipeline-config';
+import { PipelineServer } from '../server/pipeline-server';
+import { resetKanbanState } from './fixtures/kanban-full.pipeline';
+import kanbanTodoConfig from './fixtures/kanban-todo.config';
+
+interface StoredMessage {
+  message: {
+    type: string;
+    data: Record<string, unknown>;
+    requestId?: string;
+    correlationId?: string;
+  };
+  messageType: 'command' | 'event';
+  position: string;
+}
+
+describe('Server Startup E2E', () => {
+  let server: PipelineServer;
+
+  beforeAll(async () => {
+    const loaded = await loadPipelineConfig(kanbanTodoConfig);
+    server = new PipelineServer({ port: 0 });
+    server.registerCommandHandlers(loaded.handlers);
+    server.registerPipeline(loaded.pipeline);
+    await server.start();
+  }, 30000);
+
+  afterAll(async () => {
+    await server.stop();
+  });
+
+  beforeEach(() => {
+    resetKanbanState();
+  });
+
+  describe('StartServer and StartClient handlers', () => {
+    it('should have StartServer handler registered', () => {
+      const commands = server.getRegisteredCommands();
+      expect(commands).toContain('StartServer');
+    });
+
+    it('should have StartClient handler registered', () => {
+      const commands = server.getRegisteredCommands();
+      expect(commands).toContain('StartClient');
+    });
+
+    it('should expose StartServer in registry API', async () => {
+      const response = await fetch(`http://localhost:${server.port}/registry`);
+      const registry = (await response.json()) as {
+        commandHandlers: string[];
+        commandsWithMetadata: Array<{ name: string; alias?: string; description?: string }>;
+      };
+
+      expect(registry.commandHandlers).toContain('StartServer');
+
+      const startServerMeta = registry.commandsWithMetadata.find((c) => c.name === 'StartServer');
+      expect(startServerMeta).toBeDefined();
+      expect(startServerMeta?.alias).toBe('start:server');
+      expect(startServerMeta?.description).toBe('Start the development server');
+    });
+
+    it('should expose StartClient in registry API', async () => {
+      const response = await fetch(`http://localhost:${server.port}/registry`);
+      const registry = (await response.json()) as {
+        commandHandlers: string[];
+        commandsWithMetadata: Array<{ name: string; alias?: string; description?: string }>;
+      };
+
+      expect(registry.commandHandlers).toContain('StartClient');
+
+      const startClientMeta = registry.commandsWithMetadata.find((c) => c.name === 'StartClient');
+      expect(startClientMeta).toBeDefined();
+      expect(startClientMeta?.alias).toBe('start:client');
+      expect(startClientMeta?.description).toBe('Start the development client');
+    });
+  });
+
+  describe('Pipeline routing for StartServer and StartClient', () => {
+    it('should have ServerGenerated -> StartServer edge in pipeline graph', async () => {
+      const response = await fetch(`http://localhost:${server.port}/pipeline`);
+      const graph = (await response.json()) as {
+        edges: Array<{ from: string; to: string }>;
+        eventToCommand: Record<string, string>;
+      };
+
+      const serverGeneratedEdge = graph.edges.find(
+        (e) => e.from === 'evt:ServerGenerated' && e.to === 'cmd:StartServer',
+      );
+      expect(serverGeneratedEdge).toBeDefined();
+    });
+
+    it('should have ClientGenerated -> StartClient edge in pipeline graph', async () => {
+      const response = await fetch(`http://localhost:${server.port}/pipeline`);
+      const graph = (await response.json()) as {
+        edges: Array<{ from: string; to: string }>;
+        eventToCommand: Record<string, string>;
+      };
+
+      const clientGeneratedEdge = graph.edges.find(
+        (e) => e.from === 'evt:ClientGenerated' && e.to === 'cmd:StartClient',
+      );
+      expect(clientGeneratedEdge).toBeDefined();
+    });
+  });
+
+  describe('StartServer command dispatch', () => {
+    it('should accept StartServer command and return ServerStartFailed for missing directory', async () => {
+      const response = await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'StartServer',
+          data: { serverDirectory: '/nonexistent/path' },
+        }),
+      });
+
+      const result = (await response.json()) as { status: string; commandId: string };
+      expect(result.status).toBe('ack');
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const messagesResponse = await fetch(`http://localhost:${server.port}/messages`);
+      const messages = (await messagesResponse.json()) as StoredMessage[];
+
+      const serverEvent = messages.find(
+        (m) => m.message.type === 'ServerStarted' || m.message.type === 'ServerStartFailed',
+      );
+
+      expect(serverEvent).toBeDefined();
+      expect(serverEvent?.message.type).toBe('ServerStartFailed');
+    });
+  });
+
+  describe('StartClient command dispatch', () => {
+    it('should accept StartClient command and return ClientStartFailed for missing directory', async () => {
+      const response = await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'StartClient',
+          data: { clientDirectory: '/nonexistent/path' },
+        }),
+      });
+
+      const result = (await response.json()) as { status: string; commandId: string };
+      expect(result.status).toBe('ack');
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      const messagesResponse = await fetch(`http://localhost:${server.port}/messages`);
+      const messages = (await messagesResponse.json()) as StoredMessage[];
+
+      const clientEvent = messages.find(
+        (m) => m.message.type === 'ClientStarted' || m.message.type === 'ClientStartFailed',
+      );
+
+      expect(clientEvent).toBeDefined();
+      expect(clientEvent?.message.type).toBe('ClientStartFailed');
+    });
+  });
+});

package/src/testing/snapshot-compare.specs.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest';
+import {
+  compareEventSequence,
+  containsSubsequence,
+  findMissingEvents,
+  findUnexpectedEvents,
+  formatSnapshotDiff,
+} from './snapshot-compare';
+
+describe('snapshot-compare', () => {
+  describe('compareEventSequence', () => {
+    it('should match identical sequences', () => {
+      const result = compareEventSequence(['A', 'B', 'C'], ['A', 'B', 'C']);
+      expect(result.matches).toBe(true);
+      expect(result.differences).toHaveLength(0);
+    });
+
+    it('should detect mismatches', () => {
+      const result = compareEventSequence(['A', 'B', 'C'], ['A', 'X', 'C']);
+      expect(result.matches).toBe(false);
+      expect(result.differences).toHaveLength(1);
+      expect(result.differences[0]).toEqual({
+        type: 'mismatch',
+        index: 1,
+        expected: 'B',
+        actual: 'X',
+      });
+    });
+
+    it('should detect missing events', () => {
+      const result = compareEventSequence(['A', 'B', 'C'], ['A', 'B']);
+      expect(result.matches).toBe(false);
+      expect(result.differences).toContainEqual({
+        type: 'missing',
+        index: 2,
+        expected: 'C',
+      });
+    });
+
+    it('should detect extra events', () => {
+      const result = compareEventSequence(['A', 'B'], ['A', 'B', 'C']);
+      expect(result.matches).toBe(false);
+      expect(result.differences).toContainEqual({
+        type: 'extra',
+        index: 2,
+        actual: 'C',
+      });
+    });
+
+    it('should report counts', () => {
+      const result = compareEventSequence(['A', 'B', 'C'], ['A', 'B']);
+      expect(result.expectedCount).toBe(3);
+      expect(result.actualCount).toBe(2);
+    });
+  });
+
+  describe('containsSubsequence', () => {
+    it('should find exact subsequence', () => {
+      expect(containsSubsequence(['A', 'B', 'C', 'D'], ['B', 'C'])).toBe(true);
+    });
+
+    it('should find non-contiguous subsequence', () => {
+      expect(containsSubsequence(['A', 'B', 'C', 'D'], ['A', 'C'])).toBe(true);
+    });
+
+    it('should return false for missing subsequence', () => {
+      expect(containsSubsequence(['A', 'B', 'C'], ['X', 'Y'])).toBe(false);
+    });
+
+    it('should return true for empty subsequence', () => {
+      expect(containsSubsequence(['A', 'B'], [])).toBe(true);
+    });
+
+    it('should return false for empty sequence with non-empty subsequence', () => {
+      expect(containsSubsequence([], ['A'])).toBe(false);
+    });
+
+    it('should require order', () => {
+      expect(containsSubsequence(['A', 'B', 'C'], ['C', 'A'])).toBe(false);
+    });
+  });
+
+  describe('findMissingEvents', () => {
+    it('should find missing events', () => {
+      const missing = findMissingEvents(['A', 'B', 'C'], ['A', 'B', 'D']);
+      expect(missing).toEqual(['D']);
+    });
+
+    it('should return empty for all present', () => {
+      const missing = findMissingEvents(['A', 'B', 'C'], ['A', 'B']);
+      expect(missing).toEqual([]);
+    });
+  });
+
+  describe('findUnexpectedEvents', () => {
+    it('should find unexpected events', () => {
+      const unexpected = findUnexpectedEvents(['A', 'B', 'X'], ['A', 'B', 'C']);
+      expect(unexpected).toEqual(['X']);
+    });
+
+    it('should return empty when all allowed', () => {
+      const unexpected = findUnexpectedEvents(['A', 'B'], ['A', 'B', 'C']);
+      expect(unexpected).toEqual([]);
+    });
+  });
+
+  describe('formatSnapshotDiff', () => {
+    it('should format matching result', () => {
+      const result = compareEventSequence(['A', 'B'], ['A', 'B']);
+      const formatted = formatSnapshotDiff(result);
+      expect(formatted).toContain('✓');
+      expect(formatted).toContain('matches');
+    });
+
+    it('should format mismatching result', () => {
+      const result = compareEventSequence(['A', 'B'], ['A', 'X']);
+      const formatted = formatSnapshotDiff(result);
+      expect(formatted).toContain('✗');
+      expect(formatted).toContain('mismatch');
+      expect(formatted).toContain('Expected "B"');
+      expect(formatted).toContain('got "X"');
+    });
+
+    it('should format missing events', () => {
+      const result = compareEventSequence(['A', 'B', 'C'], ['A', 'B']);
+      const formatted = formatSnapshotDiff(result);
+      expect(formatted).toContain('Missing "C"');
+    });
+
+    it('should format extra events', () => {
+      const result = compareEventSequence(['A', 'B'], ['A', 'B', 'C']);
+      const formatted = formatSnapshotDiff(result);
+      expect(formatted).toContain('Unexpected "C"');
+    });
+  });
+});

package/src/testing/snapshot-compare.ts

@@ -0,0 +1,106 @@
+export interface SnapshotDiff {
+  type: 'match' | 'mismatch' | 'missing' | 'extra';
+  index: number;
+  expected?: string;
+  actual?: string;
+}
+
+export interface SnapshotResult {
+  matches: boolean;
+  differences: SnapshotDiff[];
+  expectedCount: number;
+  actualCount: number;
+}
+
+export function compareEventSequence(expected: string[], actual: string[]): SnapshotResult {
+  const differences: SnapshotDiff[] = [];
+  const maxLen = Math.max(expected.length, actual.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const expectedItem = expected[i];
+    const actualItem = actual[i];
+
+    if (expectedItem === undefined) {
+      differences.push({
+        type: 'extra',
+        index: i,
+        actual: actualItem,
+      });
+    } else if (actualItem === undefined) {
+      differences.push({
+        type: 'missing',
+        index: i,
+        expected: expectedItem,
+      });
+    } else if (expectedItem !== actualItem) {
+      differences.push({
+        type: 'mismatch',
+        index: i,
+        expected: expectedItem,
+        actual: actualItem,
+      });
+    }
+  }
+
+  return {
+    matches: differences.length === 0,
+    differences,
+    expectedCount: expected.length,
+    actualCount: actual.length,
+  };
+}
+
+export function containsSubsequence(sequence: string[], subsequence: string[]): boolean {
+  if (subsequence.length === 0) return true;
+  if (sequence.length === 0) return false;
+
+  let subIndex = 0;
+  for (const item of sequence) {
+    if (item === subsequence[subIndex]) {
+      subIndex++;
+      if (subIndex === subsequence.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function findMissingEvents(sequence: string[], required: string[]): string[] {
+  const present = new Set(sequence);
+  return required.filter((r) => !present.has(r));
+}
+
+export function findUnexpectedEvents(sequence: string[], allowed: string[]): string[] {
+  const allowedSet = new Set(allowed);
+  return sequence.filter((s) => !allowedSet.has(s));
+}
+
+export function formatSnapshotDiff(result: SnapshotResult): string {
+  if (result.matches) {
+    return `✓ Event sequence matches (${result.expectedCount} events)`;
+  }
+
+  const lines: string[] = [
+    `✗ Event sequence mismatch:`,
+    `  Expected: ${result.expectedCount} events`,
+    `  Actual: ${result.actualCount} events`,
+    `  Differences:`,
+  ];
+
+  for (const diff of result.differences) {
+    switch (diff.type) {
+      case 'mismatch':
+        lines.push(`    [${diff.index}] Expected "${diff.expected}", got "${diff.actual}"`);
+        break;
+      case 'missing':
+        lines.push(`    [${diff.index}] Missing "${diff.expected}"`);
+        break;
+      case 'extra':
+        lines.push(`    [${diff.index}] Unexpected "${diff.actual}"`);
+        break;
+    }
+  }
+
+  return lines.join('\n');
+}