@mixpeek/contentful 1.0.0

package/dist/modules/webhookHandler.js

@@ -0,0 +1,92 @@
+/**
+ * @mixpeek/contentful — WebhookHandler
+ *
+ * Handles Contentful webhooks (entry publish/unpublish/archive) and triggers enrichment
+ */
+
+import { createClient } from '../api/mixpeekClient.js';
+import { createCacheManager } from '../cache/cacheManager.js';
+import { getLogger } from '../utils/logger.js';
+import { DEFAULT_CONFIG } from '../config/constants.js';
+
+class WebhookHandler {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Mixpeek API key
+   * @param {string} [config.endpoint] - API endpoint
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {number} [config.cacheTTL] - Cache TTL in seconds
+   * @param {boolean} [config.enableCache] - Enable caching
+   * @param {boolean} [config.debug] - Enable debug logging
+   */
+  constructor(config = {}) {
+    if (!config.apiKey) throw new Error('apiKey is required for WebhookHandler');
+
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.client = createClient({
+      apiKey: config.apiKey,
+      endpoint: this.config.endpoint,
+      timeout: this.config.timeout,
+      debug: this.config.debug
+    });
+    this.cache = this.config.enableCache ? createCacheManager({ ttl: this.config.cacheTTL, debug: this.config.debug }) : null;
+    this.logger = getLogger({ debug: this.config.debug });
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    this.logger.info('WebhookHandler initialized');
+  }
+
+  async handleWebhook(...args) {
+    this.logger.debug('WebhookHandler.handleWebhook called');
+    // TODO: Implement handleWebhook
+    throw new Error('WebhookHandler.handleWebhook not yet implemented');
+  }
+
+  verifySignature(...args) {
+    this.logger.debug('WebhookHandler.verifySignature called');
+    // TODO: Implement verifySignature
+    throw new Error('WebhookHandler.verifySignature not yet implemented');
+  }
+
+  async registerWebhook(...args) {
+    this.logger.debug('WebhookHandler.registerWebhook called');
+    // TODO: Implement registerWebhook
+    throw new Error('WebhookHandler.registerWebhook not yet implemented');
+  }
+
+  async listWebhooks(...args) {
+    this.logger.debug('WebhookHandler.listWebhooks called');
+    // TODO: Implement listWebhooks
+    throw new Error('WebhookHandler.listWebhooks not yet implemented');
+  }
+
+  async deleteWebhook(...args) {
+    this.logger.debug('WebhookHandler.deleteWebhook called');
+    // TODO: Implement deleteWebhook
+    throw new Error('WebhookHandler.deleteWebhook not yet implemented');
+  }
+
+  getMetrics() {
+    return {
+      ...this.metrics,
+      avgLatencyMs: this.metrics.requests > 0 ? this.metrics.totalLatencyMs / this.metrics.requests : 0,
+      cache: this.cache ? this.cache.getStats() : null
+    };
+  }
+
+  resetMetrics() {
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    if (this.cache) this.cache.resetStats();
+  }
+
+  destroy() {
+    if (this.cache) this.cache.destroy();
+    this.logger.info('WebhookHandler destroyed');
+  }
+}
+
+export function createWebhookHandler(config) {
+  return new WebhookHandler(config);
+}
+
+export { WebhookHandler };
+export default { createWebhookHandler, WebhookHandler };

package/dist/utils/helpers.js

@@ -0,0 +1,49 @@
+/**
+ * @mixpeek/contentful — Helper Utilities
+ */
+
+export function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+export function createCacheKey(content) {
+  const str = JSON.stringify(content);
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return `mixpeek_${Math.abs(hash).toString(36)}`;
+}
+
+export function sanitizeText(text, maxLength = 50000) {
+  if (!text || typeof text !== 'string') return '';
+  return text.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim().substring(0, maxLength);
+}
+
+export function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])
+        ? deepMerge(target[key], source[key]) : { ...source[key] };
+    } else if (Array.isArray(source[key])) {
+      result[key] = [...source[key]];
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+export function isValidUrl(url) {
+  if (!url || typeof url !== 'string') return false;
+  try { new URL(url); return true; } catch { return false; }
+}
+
+export function extractDomain(url) {
+  if (!isValidUrl(url)) return null;
+  try { return new URL(url).hostname; } catch { return null; }
+}
+
+export default { generateId, createCacheKey, sanitizeText, deepMerge, isValidUrl, extractDomain };

package/dist/utils/logger.js

@@ -0,0 +1,63 @@
+/**
+ * @mixpeek/contentful — Logger Utility
+ */
+
+const LOG_LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 };
+
+class Logger {
+  constructor(options = {}) {
+    this.prefix = options.prefix || '[Mixpeek-Contentful]';
+    this.level = options.debug ? LOG_LEVELS.DEBUG : LOG_LEVELS.INFO;
+    this.enabled = options.enabled !== false;
+    this.timers = new Map();
+  }
+
+  setLevel(level) {
+    this.level = typeof level === 'string' ? (LOG_LEVELS[level.toUpperCase()] ?? LOG_LEVELS.INFO) : level;
+  }
+  setEnabled(enabled) { this.enabled = enabled; }
+
+  _log(level, levelName, ...args) {
+    if (!this.enabled || level < this.level) return;
+    const ts = new Date().toISOString();
+    const formatted = args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : a);
+    const msg = `${ts} ${this.prefix} [${levelName}]`;
+    if (level === LOG_LEVELS.ERROR) console.error(msg, ...formatted);
+    else if (level === LOG_LEVELS.WARN) console.warn(msg, ...formatted);
+    else if (level === LOG_LEVELS.DEBUG) console.debug(msg, ...formatted);
+    else console.log(msg, ...formatted);
+  }
+
+  debug(...args) { this._log(LOG_LEVELS.DEBUG, 'DEBUG', ...args); }
+  info(...args) { this._log(LOG_LEVELS.INFO, 'INFO', ...args); }
+  warn(...args) { this._log(LOG_LEVELS.WARN, 'WARN', ...args); }
+  error(...args) { this._log(LOG_LEVELS.ERROR, 'ERROR', ...args); }
+
+  time(label) { this.timers.set(label, performance.now ? performance.now() : Date.now()); }
+  timeEnd(label) {
+    const start = this.timers.get(label);
+    if (!start) return 0;
+    const elapsed = (performance.now ? performance.now() : Date.now()) - start;
+    this.timers.delete(label);
+    this.debug(`${label}: ${elapsed.toFixed(2)}ms`);
+    return elapsed;
+  }
+
+  child(subPrefix) {
+    return new Logger({ prefix: `${this.prefix}[${subPrefix}]`, debug: this.level === LOG_LEVELS.DEBUG, enabled: this.enabled });
+  }
+}
+
+let defaultLogger = null;
+export function getLogger(options = {}) {
+  if (!defaultLogger) { defaultLogger = new Logger(options); }
+  else if (Object.keys(options).length > 0) {
+    if (options.debug !== undefined) defaultLogger.setLevel(options.debug ? 'DEBUG' : 'INFO');
+    if (options.enabled !== undefined) defaultLogger.setEnabled(options.enabled);
+  }
+  return defaultLogger;
+}
+
+export function createLogger(options = {}) { return new Logger(options); }
+export { Logger, LOG_LEVELS };
+export default { getLogger, createLogger, Logger, LOG_LEVELS };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mixpeek/contentful",
+  "version": "1.0.0",
+  "description": "Contentful integration for Mixpeek — webhook handling, content enrichment, and management API integration",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "src/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.js",
+    "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.js --testPathPattern=tests/unit",
+    "test:e2e": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.e2e.js --testPathPattern=tests/e2e",
+    "test:live": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.live.js --testPathPattern=tests/live-api",
+    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.js --watch",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.js --coverage",
+    "lint": "eslint src tests",
+    "lint:fix": "eslint src tests --fix",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "contentful",
+    "cms",
+    "headless-cms",
+    "content-enrichment",
+    "webhook",
+    "content-management",
+    "mixpeek",
+    "multimodal",
+    "enrichment",
+    "connector"
+  ],
+  "author": "Mixpeek <info@mixpeek.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mixpeek/connectors.git",
+    "directory": "contentful"
+  },
+  "bugs": {
+    "url": "https://github.com/mixpeek/connectors/issues"
+  },
+  "homepage": "https://github.com/mixpeek/connectors/tree/main/contentful#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "eslint": "^8.57.0"
+  },
+  "peerDependencies": {
+    "contentful-management": ">=10.0.0"
+  },
+  "dependencies": {}
+}

package/src/api/mixpeekClient.js

@@ -0,0 +1,111 @@
+/**
+ * @mixpeek/contentful — Mixpeek API Client
+ *
+ * HTTP client for Mixpeek API integration with retry logic and timeout handling.
+ */
+
+import {
+  API_ENDPOINT, API_VERSION, DEFAULT_TIMEOUT,
+  RETRY_ATTEMPTS, RETRY_DELAY, ERROR_CODES, HEADERS
+} from '../config/constants.js';
+import { getLogger } from '../utils/logger.js';
+
+class MixpeekClient {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Mixpeek API key
+   * @param {string} [config.endpoint] - API endpoint
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {boolean} [config.debug] - Enable debug logging
+   */
+  constructor(config) {
+    if (!config.apiKey) throw new Error('API key is required');
+
+    this.apiKey = config.apiKey;
+    this.endpoint = (config.endpoint || API_ENDPOINT).replace(/\/$/, '');
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.logger = getLogger({ debug: config.debug });
+  }
+
+  async request(method, path, body = null) {
+    const url = `${this.endpoint}/${API_VERSION}${path}`;
+    const headers = {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'Content-Type': HEADERS.CONTENT_TYPE,
+      'Accept': HEADERS.ACCEPT,
+      'User-Agent': HEADERS.USER_AGENT
+    };
+
+    let lastError;
+    for (let attempt = 0; attempt <= RETRY_ATTEMPTS; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+        this.logger.debug(`API ${method} ${path} (attempt ${attempt + 1})`);
+
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : null,
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          const errorBody = await response.text();
+          throw new Error(`HTTP ${response.status}: ${errorBody}`);
+        }
+
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error.name === 'AbortError') {
+          lastError = new Error(`Request timeout after ${this.timeout}ms`);
+          lastError.code = ERROR_CODES.TIMEOUT;
+        }
+        if (attempt < RETRY_ATTEMPTS) {
+          await new Promise(r => setTimeout(r, RETRY_DELAY));
+        }
+      }
+    }
+
+    this.logger.error('API request failed after retries:', lastError.message);
+    throw lastError;
+  }
+
+  async healthCheck() {
+    try {
+      const start = Date.now();
+      const response = await this.request('GET', '/health');
+      return { status: 'healthy', latency: Date.now() - start, timestamp: new Date().toISOString(), response };
+    } catch (error) {
+      return { status: 'unhealthy', error: error.message, timestamp: new Date().toISOString() };
+    }
+  }
+
+  async search(query, options = {}) {
+    return this.request('POST', '/features/search', { query, ...options });
+  }
+
+  async getDocument(collectionId, documentId) {
+    return this.request('GET', `/collections/${collectionId}/documents/${documentId}`);
+  }
+
+  async createDocument(collectionId, payload) {
+    return this.request('POST', `/collections/${collectionId}/documents`, payload);
+  }
+
+  async listDocuments(collectionId, options = {}) {
+    const params = new URLSearchParams(options).toString();
+    return this.request('GET', `/collections/${collectionId}/documents${params ? '?' + params : ''}`);
+  }
+}
+
+export function createClient(config) {
+  return new MixpeekClient(config);
+}
+
+export { MixpeekClient };
+export default { createClient, MixpeekClient };

package/src/cache/cacheManager.js

@@ -0,0 +1,90 @@
+/**
+ * @mixpeek/contentful — Cache Manager
+ *
+ * In-memory LRU caching with TTL support.
+ */
+
+import { DEFAULT_CACHE_TTL, MAX_CACHE_ITEMS, CACHE_KEY_PREFIX } from '../config/constants.js';
+import { getLogger } from '../utils/logger.js';
+
+class CacheManager {
+  constructor(options = {}) {
+    this.ttl = (options.ttl || DEFAULT_CACHE_TTL) * 1000;
+    this.maxItems = options.maxItems || MAX_CACHE_ITEMS;
+    this.cache = new Map();
+    this.stats = { hits: 0, misses: 0, sets: 0, evictions: 0 };
+    this.logger = getLogger({ debug: options.debug });
+    this.cleanupInterval = setInterval(() => this.prune(), 60000);
+    if (this.cleanupInterval.unref) this.cleanupInterval.unref();
+  }
+
+  _prefixKey(key) { return `${CACHE_KEY_PREFIX}${key}`; }
+
+  get(key) {
+    const item = this.cache.get(this._prefixKey(key));
+    if (!item) { this.stats.misses++; return null; }
+    if (Date.now() > item.expiry) { this.cache.delete(this._prefixKey(key)); this.stats.misses++; return null; }
+    this.stats.hits++;
+    item.lastAccess = Date.now();
+    return item.data;
+  }
+
+  set(key, data, ttl = null) {
+    if (this.cache.size >= this.maxItems) this._evictLRU();
+    this.cache.set(this._prefixKey(key), {
+      data, expiry: Date.now() + (ttl ? ttl * 1000 : this.ttl),
+      createdAt: Date.now(), lastAccess: Date.now()
+    });
+    this.stats.sets++;
+  }
+
+  has(key) {
+    const item = this.cache.get(this._prefixKey(key));
+    if (!item) return false;
+    if (Date.now() > item.expiry) { this.cache.delete(this._prefixKey(key)); return false; }
+    return true;
+  }
+
+  delete(key) { return this.cache.delete(this._prefixKey(key)); }
+  clear() { this.cache.clear(); }
+
+  prune() {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [key, item] of this.cache.entries()) {
+      if (now > item.expiry) { this.cache.delete(key); pruned++; }
+    }
+    return pruned;
+  }
+
+  _evictLRU() {
+    let oldestKey = null, oldestAccess = Infinity;
+    for (const [key, item] of this.cache.entries()) {
+      if (item.lastAccess < oldestAccess) { oldestAccess = item.lastAccess; oldestKey = key; }
+    }
+    if (oldestKey) { this.cache.delete(oldestKey); this.stats.evictions++; }
+  }
+
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    return {
+      size: this.cache.size, maxSize: this.maxItems,
+      hits: this.stats.hits, misses: this.stats.misses,
+      hitRate: total > 0 ? Math.round((this.stats.hits / total) * 10000) / 100 : 0,
+      sets: this.stats.sets, evictions: this.stats.evictions, ttlSeconds: this.ttl / 1000
+    };
+  }
+
+  resetStats() { this.stats = { hits: 0, misses: 0, sets: 0, evictions: 0 }; }
+
+  destroy() {
+    if (this.cleanupInterval) { clearInterval(this.cleanupInterval); this.cleanupInterval = null; }
+    this.cache.clear();
+  }
+
+  get size() { return this.cache.size; }
+}
+
+export function createCacheManager(options = {}) { return new CacheManager(options); }
+export { CacheManager };
+export default { createCacheManager, CacheManager };

package/src/config/constants.js

@@ -0,0 +1,48 @@
+/**
+ * @mixpeek/contentful — Configuration Constants
+ */
+
+// API Configuration
+export const API_ENDPOINT = 'https://api.mixpeek.com';
+export const API_VERSION = 'v1';
+export const DEFAULT_TIMEOUT = 30000; // milliseconds
+export const MAX_TIMEOUT = 60000;
+export const RETRY_ATTEMPTS = 1;
+export const RETRY_DELAY = 100; // milliseconds
+
+// Cache Configuration
+export const DEFAULT_CACHE_TTL = 300; // seconds (5 minutes)
+export const MAX_CACHE_ITEMS = 1000;
+export const CACHE_KEY_PREFIX = 'mixpeek_ctfl_';
+
+// Error Codes
+export const ERROR_CODES = {
+  API_ERROR: 'MIXPEEK_API_ERROR',
+  TIMEOUT: 'MIXPEEK_TIMEOUT',
+  INVALID_CONFIG: 'MIXPEEK_INVALID_CONFIG',
+  INVALID_REQUEST: 'MIXPEEK_INVALID_REQUEST',
+  RATE_LIMITED: 'MIXPEEK_RATE_LIMITED',
+  CACHE_ERROR: 'MIXPEEK_CACHE_ERROR'
+};
+
+// HTTP Headers
+export const HEADERS = {
+  CONTENT_TYPE: 'application/json',
+  ACCEPT: 'application/json',
+  USER_AGENT: 'Mixpeek-Contentful-Connector/1.0.0'
+};
+
+// Default Configuration
+export const DEFAULT_CONFIG = {
+  endpoint: API_ENDPOINT,
+  timeout: DEFAULT_TIMEOUT,
+  cacheTTL: DEFAULT_CACHE_TTL,
+  enableCache: true,
+  debug: false
+};
+
+export default {
+  API_ENDPOINT, API_VERSION, DEFAULT_TIMEOUT, MAX_TIMEOUT,
+  RETRY_ATTEMPTS, RETRY_DELAY, DEFAULT_CACHE_TTL, MAX_CACHE_ITEMS,
+  CACHE_KEY_PREFIX, ERROR_CODES, HEADERS, DEFAULT_CONFIG
+};

package/src/index.js

@@ -0,0 +1,46 @@
+/**
+ * @mixpeek/contentful — Mixpeek Contentful Connector
+ *
+ * Contentful integration for Mixpeek — webhook handling, content enrichment, and management API integration
+ *
+ * @module @mixpeek/contentful
+ * @version 1.0.0
+ */
+
+// Modules
+export { createWebhookHandler, WebhookHandler } from './modules/webhookHandler.js';
+export { createContentEnricher, ContentEnricher } from './modules/contentEnricher.js';
+export { createContentfulClient, ContentfulClient } from './modules/contentfulClient.js';
+
+// API client
+export { createClient, MixpeekClient } from './api/mixpeekClient.js';
+
+// Cache manager
+export { createCacheManager, CacheManager } from './cache/cacheManager.js';
+
+// Utilities
+export {
+  generateId,
+  createCacheKey,
+  sanitizeText,
+  deepMerge,
+  isValidUrl,
+  extractDomain
+} from './utils/helpers.js';
+
+// Logger
+export { getLogger, createLogger, Logger, LOG_LEVELS } from './utils/logger.js';
+
+// Constants
+export {
+  API_ENDPOINT,
+  API_VERSION,
+  DEFAULT_TIMEOUT,
+  DEFAULT_CACHE_TTL,
+  ERROR_CODES,
+  DEFAULT_CONFIG
+} from './config/constants.js';
+
+// Default export
+import { createWebhookHandler } from './modules/webhookHandler.js';
+export default createWebhookHandler;

package/src/modules/contentEnricher.js

@@ -0,0 +1,92 @@
+/**
+ * @mixpeek/contentful — ContentEnricher
+ *
+ * Enriches Contentful entries with Mixpeek multimodal analysis stored in custom fields
+ */
+
+import { createClient } from '../api/mixpeekClient.js';
+import { createCacheManager } from '../cache/cacheManager.js';
+import { getLogger } from '../utils/logger.js';
+import { DEFAULT_CONFIG } from '../config/constants.js';
+
+class ContentEnricher {
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - Mixpeek API key
+   * @param {string} [config.endpoint] - API endpoint
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {number} [config.cacheTTL] - Cache TTL in seconds
+   * @param {boolean} [config.enableCache] - Enable caching
+   * @param {boolean} [config.debug] - Enable debug logging
+   */
+  constructor(config = {}) {
+    if (!config.apiKey) throw new Error('apiKey is required for ContentEnricher');
+
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.client = createClient({
+      apiKey: config.apiKey,
+      endpoint: this.config.endpoint,
+      timeout: this.config.timeout,
+      debug: this.config.debug
+    });
+    this.cache = this.config.enableCache ? createCacheManager({ ttl: this.config.cacheTTL, debug: this.config.debug }) : null;
+    this.logger = getLogger({ debug: this.config.debug });
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    this.logger.info('ContentEnricher initialized');
+  }
+
+  async enrichEntry(...args) {
+    this.logger.debug('ContentEnricher.enrichEntry called');
+    // TODO: Implement enrichEntry
+    throw new Error('ContentEnricher.enrichEntry not yet implemented');
+  }
+
+  async enrichAsset(...args) {
+    this.logger.debug('ContentEnricher.enrichAsset called');
+    // TODO: Implement enrichAsset
+    throw new Error('ContentEnricher.enrichAsset not yet implemented');
+  }
+
+  async enrichBatch(...args) {
+    this.logger.debug('ContentEnricher.enrichBatch called');
+    // TODO: Implement enrichBatch
+    throw new Error('ContentEnricher.enrichBatch not yet implemented');
+  }
+
+  async getEnrichment(...args) {
+    this.logger.debug('ContentEnricher.getEnrichment called');
+    // TODO: Implement getEnrichment
+    throw new Error('ContentEnricher.getEnrichment not yet implemented');
+  }
+
+  async writeField(...args) {
+    this.logger.debug('ContentEnricher.writeField called');
+    // TODO: Implement writeField
+    throw new Error('ContentEnricher.writeField not yet implemented');
+  }
+
+  getMetrics() {
+    return {
+      ...this.metrics,
+      avgLatencyMs: this.metrics.requests > 0 ? this.metrics.totalLatencyMs / this.metrics.requests : 0,
+      cache: this.cache ? this.cache.getStats() : null
+    };
+  }
+
+  resetMetrics() {
+    this.metrics = { requests: 0, errors: 0, totalLatencyMs: 0 };
+    if (this.cache) this.cache.resetStats();
+  }
+
+  destroy() {
+    if (this.cache) this.cache.destroy();
+    this.logger.info('ContentEnricher destroyed');
+  }
+}
+
+export function createContentEnricher(config) {
+  return new ContentEnricher(config);
+}
+
+export { ContentEnricher };
+export default { createContentEnricher, ContentEnricher };