@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/contract-testing/services/schema-validator.ts

@@ -1,1102 +0,0 @@
-/**
- * Agentic QE v3 - Schema Validation Service
- * Implements ISchemaValidationService for schema validation (JSON Schema, OpenAPI, GraphQL)
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err } from '../../../shared/types/index.js';
-import type { MemoryBackend } from '../../../kernel/interfaces.js';
-import type {
-  ISchemaValidationService,
-  SchemaDefinition,
-  SchemaValidationResult,
-  SchemaError,
-  GraphQLValidationResult,
-  GraphQLError,
-  SchemaComparisonResult,
-  SchemaModification,
-} from '../interfaces.js';
-
-/**
- * Configuration for the schema validator
- */
-export interface SchemaValidatorConfig {
-  strictMode: boolean;
-  allowAdditionalProperties: boolean;
-  maxRecursionDepth: number;
-  inferenceMinSamples: number;
-}
-
-const DEFAULT_CONFIG: SchemaValidatorConfig = {
-  strictMode: false,
-  allowAdditionalProperties: true,
-  maxRecursionDepth: 10,
-  inferenceMinSamples: 3,
-};
-
-/**
- * Schema Validation Service Implementation
- * Validates data against various schema formats
- */
-export class SchemaValidatorService implements ISchemaValidationService {
-  private readonly config: SchemaValidatorConfig;
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<SchemaValidatorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Validate JSON Schema
-   */
-  async validateJsonSchema(
-    data: unknown,
-    schema: object
-  ): Promise<Result<SchemaValidationResult>> {
-    try {
-      const errors: SchemaError[] = [];
-
-      this.validateValue(data, schema as Record<string, unknown>, '', errors, 0);
-
-      const result: SchemaValidationResult = {
-        isValid: errors.length === 0,
-        errors,
-      };
-
-      return ok(result);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Validate GraphQL schema
-   */
-  async validateGraphQLSchema(schema: string): Promise<Result<GraphQLValidationResult>> {
-    try {
-      const errors: GraphQLError[] = [];
-      let typeCount = 0;
-      let queryCount = 0;
-      let mutationCount = 0;
-
-      // GraphQL schema parsing and validation using line-based analysis
-      const lines = schema.split('\n');
-      let inType = false;
-      let inQuery = false;
-      let inMutation = false;
-      let braceDepth = 0;
-
-      for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-        const line = lines[lineNum].trim();
-
-        // Skip comments and empty lines
-        if (line.startsWith('#') || line === '') continue;
-
-        // Detect type definitions
-        if (line.startsWith('type ')) {
-          const typeName = line.split(/\s+/)[1]?.replace(/{.*/, '').trim();
-
-          if (typeName === 'Query') {
-            inQuery = true;
-          } else if (typeName === 'Mutation') {
-            inMutation = true;
-          } else {
-            typeCount++;
-          }
-          inType = true;
-        }
-
-        // Track brace depth
-        braceDepth += (line.match(/{/g) || []).length;
-        braceDepth -= (line.match(/}/g) || []).length;
-
-        // Count fields in Query/Mutation
-        if (inQuery && line.includes(':') && !line.startsWith('type')) {
-          queryCount++;
-        }
-        if (inMutation && line.includes(':') && !line.startsWith('type')) {
-          mutationCount++;
-        }
-
-        // Reset when type ends
-        if (braceDepth === 0 && inType) {
-          inType = false;
-          inQuery = false;
-          inMutation = false;
-        }
-
-        // Basic syntax validation
-        if (line.includes('::')) {
-          errors.push({
-            message: 'Invalid double colon in type definition',
-            locations: [{ line: lineNum + 1, column: line.indexOf('::') + 1 }],
-          });
-        }
-      }
-
-      // Check for unbalanced braces
-      if (braceDepth !== 0) {
-        errors.push({
-          message: 'Unbalanced braces in schema',
-          locations: [{ line: lines.length, column: 1 }],
-        });
-      }
-
-      // Check for required types
-      if (!schema.includes('type Query') && !schema.includes('schema {')) {
-        errors.push({
-          message: 'GraphQL schema must have a Query type or schema definition',
-          locations: [{ line: 1, column: 1 }],
-        });
-      }
-
-      return ok({
-        isValid: errors.length === 0,
-        errors,
-        typeCount,
-        queryCount,
-        mutationCount,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Compare schemas for compatibility
-   */
-  async compareSchemas(
-    oldSchema: SchemaDefinition,
-    newSchema: SchemaDefinition
-  ): Promise<Result<SchemaComparisonResult>> {
-    try {
-      const additions: string[] = [];
-      const removals: string[] = [];
-      const modifications: SchemaModification[] = [];
-
-      // Only compare same type schemas
-      if (oldSchema.type !== newSchema.type) {
-        return ok({
-          isCompatible: false,
-          additions: [],
-          removals: [],
-          modifications: [
-            {
-              path: 'type',
-              oldType: oldSchema.type,
-              newType: newSchema.type,
-              isBreaking: true,
-            },
-          ],
-        });
-      }
-
-      switch (oldSchema.type) {
-        case 'json-schema':
-        case 'openapi':
-          this.compareJsonSchemas(
-            oldSchema.content,
-            newSchema.content,
-            additions,
-            removals,
-            modifications
-          );
-          break;
-
-        case 'graphql':
-          this.compareGraphQLSchemas(
-            oldSchema.content,
-            newSchema.content,
-            additions,
-            removals,
-            modifications
-          );
-          break;
-
-        case 'protobuf':
-          this.compareProtobufSchemas(
-            oldSchema.content,
-            newSchema.content,
-            additions,
-            removals,
-            modifications
-          );
-          break;
-
-        case 'avro':
-          this.compareAvroSchemas(
-            oldSchema.content,
-            newSchema.content,
-            additions,
-            removals,
-            modifications
-          );
-          break;
-      }
-
-      const hasBreakingChanges = modifications.some((m) => m.isBreaking) || removals.length > 0;
-
-      // Store comparison result
-      await this.storeComparisonResult(oldSchema, newSchema, {
-        isCompatible: !hasBreakingChanges,
-        additions,
-        removals,
-        modifications,
-      });
-
-      return ok({
-        isCompatible: !hasBreakingChanges,
-        additions,
-        removals,
-        modifications,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate schema from sample data
-   */
-  async inferSchema(samples: unknown[]): Promise<Result<SchemaDefinition>> {
-    try {
-      if (samples.length === 0) {
-        return err(new Error('At least one sample is required for schema inference'));
-      }
-
-      if (samples.length < this.config.inferenceMinSamples) {
-        // Warning: fewer samples may lead to incomplete schema
-      }
-
-      const inferredSchema = this.inferFromSamples(samples);
-
-      const schemaDefinition: SchemaDefinition = {
-        id: `inferred-${uuidv4().slice(0, 8)}`,
-        name: 'InferredSchema',
-        type: 'json-schema',
-        content: JSON.stringify(inferredSchema, null, 2),
-      };
-
-      // Store inferred schema
-      await this.memory.set(
-        `contract-testing:schema:${schemaDefinition.id}`,
-        schemaDefinition,
-        { namespace: 'contract-testing' }
-      );
-
-      return ok(schemaDefinition);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Private Validation Methods
-  // ============================================================================
-
-  private validateValue(
-    value: unknown,
-    schema: Record<string, unknown>,
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    if (depth > this.config.maxRecursionDepth) {
-      errors.push({
-        path,
-        keyword: 'maxDepth',
-        message: 'Maximum recursion depth exceeded',
-        params: { maxDepth: this.config.maxRecursionDepth },
-      });
-      return;
-    }
-
-    // Handle nullable
-    if (value === null) {
-      if (schema.nullable === true || schema.type === 'null') {
-        return;
-      }
-      if (this.config.strictMode) {
-        errors.push({
-          path,
-          keyword: 'type',
-          message: 'Value cannot be null',
-          params: {},
-        });
-      }
-      return;
-    }
-
-    const schemaType = schema.type as string | string[] | undefined;
-
-    // Handle oneOf, anyOf, allOf
-    if (schema.oneOf) {
-      this.validateOneOf(value, schema.oneOf as Record<string, unknown>[], path, errors, depth);
-      return;
-    }
-    if (schema.anyOf) {
-      this.validateAnyOf(value, schema.anyOf as Record<string, unknown>[], path, errors, depth);
-      return;
-    }
-    if (schema.allOf) {
-      this.validateAllOf(value, schema.allOf as Record<string, unknown>[], path, errors, depth);
-      return;
-    }
-
-    // Validate type
-    if (schemaType) {
-      const types = Array.isArray(schemaType) ? schemaType : [schemaType];
-      const actualType = this.getJsonType(value);
-
-      if (!types.some((t) => this.typesMatch(actualType, t))) {
-        errors.push({
-          path,
-          keyword: 'type',
-          message: `Expected type '${types.join(' | ')}' but got '${actualType}'`,
-          params: { expectedType: types, actualType },
-        });
-        return;
-      }
-    }
-
-    // Type-specific validation
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      this.validateObject(value as Record<string, unknown>, schema, path, errors, depth);
-    } else if (Array.isArray(value)) {
-      this.validateArray(value, schema, path, errors, depth);
-    } else if (typeof value === 'string') {
-      this.validateString(value, schema, path, errors);
-    } else if (typeof value === 'number') {
-      this.validateNumber(value, schema, path, errors);
-    }
-
-    // Validate enum
-    if (schema.enum) {
-      const enumValues = schema.enum as unknown[];
-      if (!enumValues.includes(value)) {
-        errors.push({
-          path,
-          keyword: 'enum',
-          message: `Value must be one of: ${enumValues.map((v) => JSON.stringify(v)).join(', ')}`,
-          params: { allowedValues: enumValues },
-        });
-      }
-    }
-
-    // Validate const
-    if ('const' in schema) {
-      if (value !== schema.const) {
-        errors.push({
-          path,
-          keyword: 'const',
-          message: `Value must be ${JSON.stringify(schema.const)}`,
-          params: { expected: schema.const },
-        });
-      }
-    }
-  }
-
-  private validateObject(
-    value: Record<string, unknown>,
-    schema: Record<string, unknown>,
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    const properties = (schema.properties as Record<string, Record<string, unknown>>) || {};
-    const required = (schema.required as string[]) || [];
-    const additionalProperties = schema.additionalProperties;
-
-    // Check required properties
-    for (const prop of required) {
-      if (!(prop in value)) {
-        errors.push({
-          path: path ? `${path}.${prop}` : prop,
-          keyword: 'required',
-          message: `Required property '${prop}' is missing`,
-          params: { missingProperty: prop },
-        });
-      }
-    }
-
-    // Validate each property
-    for (const [prop, propValue] of Object.entries(value)) {
-      const propPath = path ? `${path}.${prop}` : prop;
-
-      if (prop in properties) {
-        this.validateValue(propValue, properties[prop], propPath, errors, depth + 1);
-      } else if (this.config.strictMode && additionalProperties === false) {
-        errors.push({
-          path: propPath,
-          keyword: 'additionalProperties',
-          message: `Property '${prop}' is not allowed`,
-          params: { additionalProperty: prop },
-        });
-      } else if (typeof additionalProperties === 'object') {
-        this.validateValue(
-          propValue,
-          additionalProperties as Record<string, unknown>,
-          propPath,
-          errors,
-          depth + 1
-        );
-      }
-    }
-
-    // Validate minProperties / maxProperties
-    const propCount = Object.keys(value).length;
-    if (typeof schema.minProperties === 'number' && propCount < schema.minProperties) {
-      errors.push({
-        path,
-        keyword: 'minProperties',
-        message: `Object must have at least ${schema.minProperties} properties`,
-        params: { limit: schema.minProperties, actual: propCount },
-      });
-    }
-    if (typeof schema.maxProperties === 'number' && propCount > schema.maxProperties) {
-      errors.push({
-        path,
-        keyword: 'maxProperties',
-        message: `Object must have at most ${schema.maxProperties} properties`,
-        params: { limit: schema.maxProperties, actual: propCount },
-      });
-    }
-  }
-
-  private validateArray(
-    value: unknown[],
-    schema: Record<string, unknown>,
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    const items = schema.items as Record<string, unknown> | undefined;
-
-    // Validate items
-    if (items) {
-      for (let i = 0; i < value.length; i++) {
-        this.validateValue(value[i], items, `${path}[${i}]`, errors, depth + 1);
-      }
-    }
-
-    // Validate minItems / maxItems
-    if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
-      errors.push({
-        path,
-        keyword: 'minItems',
-        message: `Array must have at least ${schema.minItems} items`,
-        params: { limit: schema.minItems, actual: value.length },
-      });
-    }
-    if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
-      errors.push({
-        path,
-        keyword: 'maxItems',
-        message: `Array must have at most ${schema.maxItems} items`,
-        params: { limit: schema.maxItems, actual: value.length },
-      });
-    }
-
-    // Validate uniqueItems
-    if (schema.uniqueItems === true) {
-      const seen = new Set<string>();
-      for (let i = 0; i < value.length; i++) {
-        const serialized = JSON.stringify(value[i]);
-        if (seen.has(serialized)) {
-          errors.push({
-            path: `${path}[${i}]`,
-            keyword: 'uniqueItems',
-            message: 'Array items must be unique',
-            params: { duplicateIndex: i },
-          });
-        }
-        seen.add(serialized);
-      }
-    }
-  }
-
-  private validateString(
-    value: string,
-    schema: Record<string, unknown>,
-    path: string,
-    errors: SchemaError[]
-  ): void {
-    if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
-      errors.push({
-        path,
-        keyword: 'minLength',
-        message: `String must be at least ${schema.minLength} characters`,
-        params: { limit: schema.minLength, actual: value.length },
-      });
-    }
-    if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
-      errors.push({
-        path,
-        keyword: 'maxLength',
-        message: `String must be at most ${schema.maxLength} characters`,
-        params: { limit: schema.maxLength, actual: value.length },
-      });
-    }
-    if (typeof schema.pattern === 'string') {
-      const regex = new RegExp(schema.pattern);
-      if (!regex.test(value)) {
-        errors.push({
-          path,
-          keyword: 'pattern',
-          message: `String must match pattern '${schema.pattern}'`,
-          params: { pattern: schema.pattern },
-        });
-      }
-    }
-
-    // Validate format
-    if (typeof schema.format === 'string') {
-      this.validateFormat(value, schema.format, path, errors);
-    }
-  }
-
-  private validateNumber(
-    value: number,
-    schema: Record<string, unknown>,
-    path: string,
-    errors: SchemaError[]
-  ): void {
-    if (typeof schema.minimum === 'number') {
-      if (schema.exclusiveMinimum === true) {
-        if (value <= schema.minimum) {
-          errors.push({
-            path,
-            keyword: 'exclusiveMinimum',
-            message: `Number must be greater than ${schema.minimum}`,
-            params: { limit: schema.minimum, actual: value },
-          });
-        }
-      } else if (value < schema.minimum) {
-        errors.push({
-          path,
-          keyword: 'minimum',
-          message: `Number must be at least ${schema.minimum}`,
-          params: { limit: schema.minimum, actual: value },
-        });
-      }
-    }
-
-    if (typeof schema.maximum === 'number') {
-      if (schema.exclusiveMaximum === true) {
-        if (value >= schema.maximum) {
-          errors.push({
-            path,
-            keyword: 'exclusiveMaximum',
-            message: `Number must be less than ${schema.maximum}`,
-            params: { limit: schema.maximum, actual: value },
-          });
-        }
-      } else if (value > schema.maximum) {
-        errors.push({
-          path,
-          keyword: 'maximum',
-          message: `Number must be at most ${schema.maximum}`,
-          params: { limit: schema.maximum, actual: value },
-        });
-      }
-    }
-
-    if (typeof schema.multipleOf === 'number') {
-      const remainder = value % schema.multipleOf;
-      if (Math.abs(remainder) > 1e-10) {
-        errors.push({
-          path,
-          keyword: 'multipleOf',
-          message: `Number must be a multiple of ${schema.multipleOf}`,
-          params: { multipleOf: schema.multipleOf, actual: value },
-        });
-      }
-    }
-  }
-
-  private validateFormat(
-    value: string,
-    format: string,
-    path: string,
-    errors: SchemaError[]
-  ): void {
-    let isValid = true;
-
-    switch (format) {
-      case 'email':
-        isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-        break;
-      case 'uri':
-      case 'url':
-        try {
-          new URL(value);
-        } catch {
-          isValid = false;
-        }
-        break;
-      case 'uuid':
-        isValid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
-        break;
-      case 'date':
-        isValid = !isNaN(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}$/.test(value);
-        break;
-      case 'date-time':
-        isValid = !isNaN(Date.parse(value));
-        break;
-      case 'time':
-        isValid = /^\d{2}:\d{2}(:\d{2})?/.test(value);
-        break;
-      case 'ipv4':
-        isValid = /^(\d{1,3}\.){3}\d{1,3}$/.test(value);
-        break;
-      case 'ipv6':
-        isValid = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/.test(value);
-        break;
-      default:
-        // Unknown format, skip validation
-        return;
-    }
-
-    if (!isValid) {
-      errors.push({
-        path,
-        keyword: 'format',
-        message: `String must be a valid ${format}`,
-        params: { format },
-      });
-    }
-  }
-
-  private validateOneOf(
-    value: unknown,
-    schemas: Record<string, unknown>[],
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    const validCount = schemas.reduce((count, schema) => {
-      const subErrors: SchemaError[] = [];
-      this.validateValue(value, schema, path, subErrors, depth + 1);
-      return count + (subErrors.length === 0 ? 1 : 0);
-    }, 0);
-
-    if (validCount !== 1) {
-      errors.push({
-        path,
-        keyword: 'oneOf',
-        message: `Value must match exactly one schema (matched ${validCount})`,
-        params: { matched: validCount },
-      });
-    }
-  }
-
-  private validateAnyOf(
-    value: unknown,
-    schemas: Record<string, unknown>[],
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    const hasValid = schemas.some((schema) => {
-      const subErrors: SchemaError[] = [];
-      this.validateValue(value, schema, path, subErrors, depth + 1);
-      return subErrors.length === 0;
-    });
-
-    if (!hasValid) {
-      errors.push({
-        path,
-        keyword: 'anyOf',
-        message: 'Value must match at least one schema',
-        params: {},
-      });
-    }
-  }
-
-  private validateAllOf(
-    value: unknown,
-    schemas: Record<string, unknown>[],
-    path: string,
-    errors: SchemaError[],
-    depth: number
-  ): void {
-    for (const schema of schemas) {
-      this.validateValue(value, schema, path, errors, depth + 1);
-    }
-  }
-
-  private getJsonType(value: unknown): string {
-    if (value === null) return 'null';
-    if (Array.isArray(value)) return 'array';
-    if (typeof value === 'number') {
-      return Number.isInteger(value) ? 'integer' : 'number';
-    }
-    return typeof value;
-  }
-
-  private typesMatch(actual: string, expected: string): boolean {
-    if (actual === expected) return true;
-    if (expected === 'number' && actual === 'integer') return true;
-    return false;
-  }
-
-  // ============================================================================
-  // Schema Comparison Methods
-  // ============================================================================
-
-  private compareJsonSchemas(
-    oldContent: string,
-    newContent: string,
-    additions: string[],
-    removals: string[],
-    modifications: SchemaModification[]
-  ): void {
-    try {
-      const oldSchema = JSON.parse(oldContent) as Record<string, unknown>;
-      const newSchema = JSON.parse(newContent) as Record<string, unknown>;
-
-      this.compareSchemaObjects(oldSchema, newSchema, '', additions, removals, modifications);
-    } catch {
-      modifications.push({
-        path: '',
-        oldType: 'unparseable',
-        newType: 'unparseable',
-        isBreaking: true,
-      });
-    }
-  }
-
-  private compareSchemaObjects(
-    oldSchema: Record<string, unknown>,
-    newSchema: Record<string, unknown>,
-    path: string,
-    additions: string[],
-    removals: string[],
-    modifications: SchemaModification[]
-  ): void {
-    const oldProps = (oldSchema.properties as Record<string, unknown>) || {};
-    const newProps = (newSchema.properties as Record<string, unknown>) || {};
-    const oldRequired = new Set((oldSchema.required as string[]) || []);
-    const newRequired = new Set((newSchema.required as string[]) || []);
-
-    // Check for removed properties
-    for (const prop of Object.keys(oldProps)) {
-      if (!(prop in newProps)) {
-        const propPath = path ? `${path}.${prop}` : prop;
-        removals.push(propPath);
-      }
-    }
-
-    // Check for added properties
-    for (const prop of Object.keys(newProps)) {
-      if (!(prop in oldProps)) {
-        const propPath = path ? `${path}.${prop}` : prop;
-        additions.push(propPath);
-
-        // New required property is breaking
-        if (newRequired.has(prop)) {
-          modifications.push({
-            path: propPath,
-            oldType: 'undefined',
-            newType: 'required',
-            isBreaking: true,
-          });
-        }
-      }
-    }
-
-    // Check for type changes
-    if (oldSchema.type !== newSchema.type) {
-      modifications.push({
-        path: path || 'root',
-        oldType: String(oldSchema.type || 'any'),
-        newType: String(newSchema.type || 'any'),
-        isBreaking: true,
-      });
-    }
-
-    // Check for required changes
-    const newRequiredArray = Array.from(newRequired);
-    for (const prop of newRequiredArray) {
-      if (!oldRequired.has(prop) && prop in oldProps) {
-        const propPath = path ? `${path}.${prop}` : prop;
-        modifications.push({
-          path: propPath,
-          oldType: 'optional',
-          newType: 'required',
-          isBreaking: true,
-        });
-      }
-    }
-  }
-
-  private compareGraphQLSchemas(
-    oldContent: string,
-    newContent: string,
-    additions: string[],
-    removals: string[],
-    _modifications: SchemaModification[]
-  ): void {
-    // Extract types from both schemas (simplified)
-    const oldTypes = this.extractGraphQLTypes(oldContent);
-    const newTypes = this.extractGraphQLTypes(newContent);
-
-    for (const typeName of oldTypes) {
-      if (!newTypes.includes(typeName)) {
-        removals.push(`type:${typeName}`);
-      }
-    }
-
-    for (const typeName of newTypes) {
-      if (!oldTypes.includes(typeName)) {
-        additions.push(`type:${typeName}`);
-      }
-    }
-  }
-
-  private extractGraphQLTypes(schema: string): string[] {
-    const types: string[] = [];
-    const typeRegex = /type\s+(\w+)/g;
-    let match;
-    while ((match = typeRegex.exec(schema)) !== null) {
-      types.push(match[1]);
-    }
-    return types;
-  }
-
-  private compareProtobufSchemas(
-    oldContent: string,
-    newContent: string,
-    additions: string[],
-    removals: string[],
-    _modifications: SchemaModification[]
-  ): void {
-    // Extract messages from both schemas
-    const oldMessages = this.extractProtobufMessages(oldContent);
-    const newMessages = this.extractProtobufMessages(newContent);
-
-    for (const msg of oldMessages) {
-      if (!newMessages.includes(msg)) {
-        removals.push(`message:${msg}`);
-      }
-    }
-
-    for (const msg of newMessages) {
-      if (!oldMessages.includes(msg)) {
-        additions.push(`message:${msg}`);
-      }
-    }
-  }
-
-  private extractProtobufMessages(schema: string): string[] {
-    const messages: string[] = [];
-    const msgRegex = /message\s+(\w+)/g;
-    let match;
-    while ((match = msgRegex.exec(schema)) !== null) {
-      messages.push(match[1]);
-    }
-    return messages;
-  }
-
-  private compareAvroSchemas(
-    oldContent: string,
-    newContent: string,
-    _additions: string[],
-    _removals: string[],
-    modifications: SchemaModification[]
-  ): void {
-    try {
-      const oldSchema = JSON.parse(oldContent) as Record<string, unknown>;
-      const newSchema = JSON.parse(newContent) as Record<string, unknown>;
-
-      // Compare type
-      if (oldSchema.type !== newSchema.type) {
-        modifications.push({
-          path: 'type',
-          oldType: String(oldSchema.type),
-          newType: String(newSchema.type),
-          isBreaking: true,
-        });
-      }
-
-      // Compare name
-      if (oldSchema.name !== newSchema.name) {
-        modifications.push({
-          path: 'name',
-          oldType: String(oldSchema.name),
-          newType: String(newSchema.name),
-          isBreaking: true,
-        });
-      }
-    } catch {
-      modifications.push({
-        path: '',
-        oldType: 'unparseable',
-        newType: 'unparseable',
-        isBreaking: true,
-      });
-    }
-  }
-
-  // ============================================================================
-  // Schema Inference
-  // ============================================================================
-
-  private inferFromSamples(samples: unknown[]): Record<string, unknown> {
-    if (samples.length === 0) {
-      return { type: 'null' };
-    }
-
-    // Merge inferred types from all samples
-    const types = samples.map((s) => this.inferType(s));
-    return this.mergeTypes(types);
-  }
-
-  private inferType(value: unknown): Record<string, unknown> {
-    if (value === null) {
-      return { type: 'null' };
-    }
-
-    if (Array.isArray(value)) {
-      if (value.length === 0) {
-        return { type: 'array', items: {} };
-      }
-      const itemTypes = value.map((item) => this.inferType(item));
-      return { type: 'array', items: this.mergeTypes(itemTypes) };
-    }
-
-    if (typeof value === 'object') {
-      const properties: Record<string, Record<string, unknown>> = {};
-      const required: string[] = [];
-
-      for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-        properties[key] = this.inferType(val);
-        if (val !== undefined) {
-          required.push(key);
-        }
-      }
-
-      return { type: 'object', properties, required };
-    }
-
-    if (typeof value === 'string') {
-      const format = this.inferStringFormat(value);
-      return format ? { type: 'string', format } : { type: 'string' };
-    }
-
-    if (typeof value === 'number') {
-      return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
-    }
-
-    if (typeof value === 'boolean') {
-      return { type: 'boolean' };
-    }
-
-    return {};
-  }
-
-  private inferStringFormat(value: string): string | null {
-    if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return 'email';
-    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) return 'uuid';
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) return 'date-time';
-    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return 'date';
-    try {
-      new URL(value);
-      return 'uri';
-    } catch {
-      return null;
-    }
-  }
-
-  private mergeTypes(types: Record<string, unknown>[]): Record<string, unknown> {
-    if (types.length === 0) return {};
-    if (types.length === 1) return types[0];
-
-    // Get unique types
-    const typeSet = new Set(types.map((t) => t.type as string));
-
-    if (typeSet.size === 1) {
-      // All same type, merge properties if object
-      const baseType = types[0].type as string;
-
-      if (baseType === 'object') {
-        const allProperties = new Map<string, Record<string, unknown>[]>();
-        const allRequired = new Set<string>();
-
-        for (const type of types) {
-          const props = (type.properties as Record<string, Record<string, unknown>>) || {};
-          const req = (type.required as string[]) || [];
-
-          for (const [key, val] of Object.entries(props)) {
-            if (!allProperties.has(key)) {
-              allProperties.set(key, []);
-            }
-            allProperties.get(key)!.push(val);
-          }
-
-          for (const r of req) {
-            allRequired.add(r);
-          }
-        }
-
-        const mergedProps: Record<string, Record<string, unknown>> = {};
-        const allPropertiesEntries = Array.from(allProperties.entries());
-        for (const [key, vals] of allPropertiesEntries) {
-          mergedProps[key] = this.mergeTypes(vals);
-        }
-
-        // Only required if in all samples
-        const allRequiredArray = Array.from(allRequired);
-        const commonRequired = allRequiredArray.filter((r) =>
-          types.every((t) => ((t.required as string[]) || []).includes(r))
-        );
-
-        return {
-          type: 'object',
-          properties: mergedProps,
-          required: commonRequired,
-        };
-      }
-
-      if (baseType === 'array') {
-        const itemTypes = types
-          .map((t) => t.items as Record<string, unknown>)
-          .filter((i) => i && Object.keys(i).length > 0);
-        return {
-          type: 'array',
-          items: itemTypes.length > 0 ? this.mergeTypes(itemTypes) : {},
-        };
-      }
-
-      return types[0];
-    }
-
-    // Multiple types - use anyOf
-    return {
-      anyOf: types,
-    };
-  }
-
-  private async storeComparisonResult(
-    oldSchema: SchemaDefinition,
-    newSchema: SchemaDefinition,
-    result: SchemaComparisonResult
-  ): Promise<void> {
-    const key = `contract-testing:schema-comparison:${oldSchema.id}:${newSchema.id}:${Date.now()}`;
-    await this.memory.set(
-      key,
-      {
-        oldSchemaId: oldSchema.id,
-        newSchemaId: newSchema.id,
-        isCompatible: result.isCompatible,
-        timestamp: new Date().toISOString(),
-      },
-      {
-        namespace: 'contract-testing',
-        ttl: 86400 * 30, // 30 days
-      }
-    );
-  }
-}