@adpal/shared-lib 1.0.0

package/dist/index.js

@@ -0,0 +1,577 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/errors.ts
+var AppError = class extends Error {
+  /** Машиночитаемый код ошибки */
+  code;
+  /** Дополнительный контекст для отладки */
+  context;
+  /** Можно ли повторить операцию */
+  retryable;
+  /** Временная метка создания ошибки */
+  timestamp;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "AppError";
+    this.code = options.code || "APP_ERROR";
+    this.context = options.context;
+    this.retryable = options.retryable ?? false;
+    this.timestamp = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Преобразовать в JSON для логирования
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      retryable: this.retryable,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack
+    };
+  }
+};
+var ApiError = class extends AppError {
+  /** HTTP статус код */
+  statusCode;
+  /** Имя сервиса */
+  service;
+  constructor(message, options) {
+    super(message, {
+      code: `${options.service.toUpperCase()}_API_ERROR`,
+      context: { ...options.context, statusCode: options.statusCode },
+      retryable: options.retryable ?? isRetryableStatus(options.statusCode),
+      cause: options.cause
+    });
+    this.name = "ApiError";
+    this.statusCode = options.statusCode;
+    this.service = options.service;
+  }
+};
+var VoyageApiError = class extends ApiError {
+  constructor(message, statusCode, context) {
+    super(message, {
+      statusCode,
+      service: "voyage",
+      context
+    });
+    this.name = "VoyageApiError";
+  }
+};
+var AnthropicApiError = class extends ApiError {
+  constructor(message, statusCode, context) {
+    super(message, {
+      statusCode,
+      service: "anthropic",
+      context
+    });
+    this.name = "AnthropicApiError";
+  }
+};
+var TurbopufferApiError = class extends ApiError {
+  constructor(message, statusCode, context) {
+    super(message, {
+      statusCode,
+      service: "turbopuffer",
+      context
+    });
+    this.name = "TurbopufferApiError";
+  }
+};
+var ValidationError = class extends AppError {
+  /** Поле, в котором обнаружена ошибка */
+  field;
+  /** Ожидаемое значение или тип */
+  expected;
+  /** Полученное значение */
+  received;
+  constructor(message, options = {}) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      context: {
+        ...options.context,
+        field: options.field,
+        expected: options.expected,
+        received: options.received
+      },
+      retryable: false
+    });
+    this.name = "ValidationError";
+    this.field = options.field;
+    this.expected = options.expected;
+    this.received = options.received;
+  }
+};
+var ConfigError = class extends AppError {
+  /** Имя отсутствующей переменной */
+  variableName;
+  constructor(variableName) {
+    super(`\u041E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u0430\u044F \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0430\u044F \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F: ${variableName}`, {
+      code: "CONFIG_ERROR",
+      context: { variableName },
+      retryable: false
+    });
+    this.name = "ConfigError";
+    this.variableName = variableName;
+  }
+};
+function isRetryableStatus(statusCode) {
+  return [408, 429, 500, 502, 503, 504].includes(statusCode);
+}
+function isAppError(error) {
+  return error instanceof AppError;
+}
+function wrapError(error, defaultMessage = "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430") {
+  if (error instanceof AppError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new AppError(error.message || defaultMessage, {
+      cause: error,
+      context: { originalName: error.name }
+    });
+  }
+  return new AppError(defaultMessage, {
+    context: { originalError: error }
+  });
+}
+
+// src/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  debug: "\x1B[36m",
+  // Cyan
+  info: "\x1B[32m",
+  // Green
+  warn: "\x1B[33m",
+  // Yellow
+  error: "\x1B[31m"
+  // Red
+};
+var RESET = "\x1B[0m";
+function getCurrentLogLevel() {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+  if (envLevel && envLevel in LOG_LEVEL_PRIORITY) {
+    return envLevel;
+  }
+  return process.env.NODE_ENV === "production" ? "info" : "debug";
+}
+function isDev() {
+  return process.env.NODE_ENV !== "production";
+}
+function formatLogEntry(entry) {
+  if (isDev()) {
+    const color = COLORS[entry.level];
+    const levelStr = entry.level.toUpperCase().padEnd(5);
+    const time = new Date(entry.timestamp).toLocaleTimeString();
+    let output = `${color}[${levelStr}]${RESET} ${time} ${entry.message}`;
+    if (entry.meta && Object.keys(entry.meta).length > 0) {
+      output += ` ${JSON.stringify(entry.meta)}`;
+    }
+    if (entry.error) {
+      output += `
+  Error: ${entry.error.name}: ${entry.error.message}`;
+      if (entry.error.stack) {
+        output += `
+  ${entry.error.stack.split("\n").slice(1).join("\n  ")}`;
+      }
+    }
+    return output;
+  }
+  return JSON.stringify(entry);
+}
+function serializeError(error) {
+  return {
+    name: error.name,
+    message: error.message,
+    stack: error.stack
+  };
+}
+var Logger = class {
+  module;
+  minLevel;
+  constructor(module) {
+    this.module = module;
+    this.minLevel = getCurrentLogLevel();
+  }
+  /**
+   * Проверить, включён ли данный уровень
+   */
+  isEnabled(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.minLevel];
+  }
+  /**
+   * Записать лог
+   */
+  log(level, message, meta, error) {
+    if (!this.isEnabled(level)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      meta: { module: this.module, ...meta }
+    };
+    if (error) {
+      entry.error = serializeError(error);
+    }
+    const formatted = formatLogEntry(entry);
+    switch (level) {
+      case "error":
+        console.error(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      default:
+        console.log(formatted);
+    }
+  }
+  /**
+   * Debug уровень — детальная информация для отладки
+   */
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  /**
+   * Info уровень — информационные сообщения
+   */
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  /**
+   * Warn уровень — предупреждения
+   */
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  /**
+   * Error уровень — ошибки
+   */
+  error(message, error, meta) {
+    const err = error instanceof Error ? error : void 0;
+    this.log("error", message, meta, err);
+  }
+  /**
+   * Создать child logger с дополнительным контекстом
+   */
+  child(context) {
+    return new ChildLogger(this, context);
+  }
+};
+var ChildLogger = class {
+  constructor(parent, context) {
+    this.parent = parent;
+    this.context = context;
+  }
+  debug(message, meta) {
+    this.parent.debug(message, { ...this.context, ...meta });
+  }
+  info(message, meta) {
+    this.parent.info(message, { ...this.context, ...meta });
+  }
+  warn(message, meta) {
+    this.parent.warn(message, { ...this.context, ...meta });
+  }
+  error(message, error, meta) {
+    this.parent.error(message, error, { ...this.context, ...meta });
+  }
+};
+var voyageLogger = new Logger("voyage");
+var turbopufferLogger = new Logger("turbopuffer");
+var anthropicLogger = new Logger("anthropic");
+var apiLogger = new Logger("api");
+var logger = new Logger("app");
+function createTimer() {
+  const start = performance.now();
+  return () => Math.round(performance.now() - start);
+}
+
+// src/retry.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_BASE_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+var DEFAULT_JITTER = 0.1;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs, jitter) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt - 1);
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  const jitterAmount = cappedDelay * jitter * Math.random();
+  return Math.round(cappedDelay + jitterAmount);
+}
+function defaultShouldRetry(error) {
+  if (isAppError(error) && error.retryable) {
+    return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    const networkErrors = [
+      "fetch failed",
+      "network error",
+      "timeout",
+      "econnreset",
+      "econnrefused",
+      "socket hang up"
+    ];
+    return networkErrors.some((e) => message.includes(e));
+  }
+  return false;
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    baseDelayMs = DEFAULT_BASE_DELAY_MS,
+    maxDelayMs = DEFAULT_MAX_DELAY_MS,
+    jitter = DEFAULT_JITTER,
+    shouldRetry = defaultShouldRetry,
+    onRetry,
+    logger: logger2
+  } = options;
+  const startTime = performance.now();
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const data = await fn();
+      return {
+        data,
+        attempts: attempt,
+        totalTimeMs: Math.round(performance.now() - startTime)
+      };
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxAttempts) {
+        logger2?.error(`\u0412\u0441\u0435 ${maxAttempts} \u043F\u043E\u043F\u044B\u0442\u043E\u043A \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D\u044B`, error);
+        break;
+      }
+      if (!shouldRetry(error, attempt)) {
+        logger2?.warn(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043D\u0435 \u043F\u043E\u0434\u043B\u0435\u0436\u0438\u0442 \u043F\u043E\u0432\u0442\u043E\u0440\u0435\u043D\u0438\u044E \u043D\u0430 \u043F\u043E\u043F\u044B\u0442\u043A\u0435 ${attempt}`, {
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+        break;
+      }
+      const delayMs = calculateDelay(attempt, baseDelayMs, maxDelayMs, jitter);
+      logger2?.info(`\u041F\u043E\u043F\u044B\u0442\u043A\u0430 ${attempt}/${maxAttempts} \u043D\u0435 \u0443\u0434\u0430\u043B\u0430\u0441\u044C, \u043F\u043E\u0432\u0442\u043E\u0440 \u0447\u0435\u0440\u0435\u0437 ${delayMs}\u043C\u0441`, {
+        errorMessage: error instanceof Error ? error.message : String(error),
+        delayMs
+      });
+      onRetry?.(error, attempt, delayMs);
+      await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+async function retryApiCall(fn, options = {}) {
+  const result = await withRetry(fn, {
+    maxAttempts: options.maxAttempts ?? 3,
+    baseDelayMs: 1e3,
+    maxDelayMs: 1e4,
+    jitter: 0.2,
+    logger: options.logger,
+    onRetry: options.onRetry
+  });
+  return result.data;
+}
+async function retryCritical(fn, options = {}) {
+  const result = await withRetry(fn, {
+    maxAttempts: 5,
+    baseDelayMs: 500,
+    maxDelayMs: 3e4,
+    jitter: 0.3,
+    logger: options.logger,
+    onRetry: options.onRetry,
+    shouldRetry: () => true
+    // Повторяем всегда
+  });
+  return result.data;
+}
+var VoyageEmbeddingResponseSchema = zod.z.object({
+  /** Массив эмбеддингов */
+  data: zod.z.array(
+    zod.z.object({
+      /** Вектор эмбеддинга */
+      embedding: zod.z.array(zod.z.number()),
+      /** Индекс в исходном массиве */
+      index: zod.z.number().optional()
+    })
+  ),
+  /** Статистика использования */
+  usage: zod.z.object({
+    /** Общее количество токенов */
+    total_tokens: zod.z.number()
+  }),
+  /** Модель, использованная для генерации */
+  model: zod.z.string().optional()
+});
+var VoyageRerankResponseSchema = zod.z.object({
+  /** Массив результатов реранкинга */
+  data: zod.z.array(
+    zod.z.object({
+      /** Индекс документа в исходном массиве */
+      index: zod.z.number(),
+      /** Оценка релевантности (0-1) */
+      relevance_score: zod.z.number().min(0).max(1)
+    })
+  ),
+  /** Статистика использования */
+  usage: zod.z.object({
+    /** Общее количество токенов */
+    total_tokens: zod.z.number()
+  }),
+  /** Модель, использованная для реранкинга */
+  model: zod.z.string().optional()
+});
+var VectorAttributesSchema = zod.z.object({
+  /** ID записи в Supabase */
+  supabase_id: zod.z.number(),
+  /** Уникальный ID сообщения/документа */
+  message_id: zod.z.string(),
+  /** Тип источника */
+  source_type: zod.z.enum(["email", "pdf", "website"]),
+  /** Тип чанка */
+  chunk_type: zod.z.string(),
+  /** Email отправителя */
+  sender: zod.z.string().optional(),
+  /** Email получателя */
+  recipient: zod.z.string().optional(),
+  /** Дата источника */
+  source_date: zod.z.string().optional(),
+  /** ID цепочки писем */
+  thread_id: zod.z.string().optional(),
+  /** ID клиента */
+  client_id: zod.z.string().optional(),
+  /** URL источника */
+  source_url: zod.z.string().optional(),
+  /** Номер страницы */
+  page_number: zod.z.number().optional(),
+  /** Заголовок секции */
+  section_title: zod.z.string().optional(),
+  /** ID в content_sources */
+  content_source_id: zod.z.number().optional(),
+  /** Тема письма */
+  subject: zod.z.string().optional(),
+  /** Превью контента */
+  content_preview: zod.z.string().optional(),
+  /** Заголовок документа */
+  title: zod.z.string().optional(),
+  /** Полный контент */
+  content: zod.z.string().optional(),
+  /** Категория */
+  category: zod.z.string().optional(),
+  /** Тональность */
+  sentiment: zod.z.enum(["positive", "negative", "neutral"]).optional(),
+  /** Дата создания */
+  created_at: zod.z.string().optional()
+});
+var TurbopufferSearchResultSchema = zod.z.object({
+  /** ID вектора */
+  id: zod.z.string(),
+  /** Расстояние до запроса */
+  dist: zod.z.number(),
+  /** Атрибуты вектора */
+  attributes: VectorAttributesSchema.partial()
+});
+var ClaudeMessageSchema = zod.z.object({
+  /** ID сообщения */
+  id: zod.z.string(),
+  /** Тип объекта */
+  type: zod.z.literal("message"),
+  /** Роль */
+  role: zod.z.enum(["assistant", "user"]),
+  /** Контент */
+  content: zod.z.array(
+    zod.z.object({
+      type: zod.z.enum(["text", "tool_use"]),
+      text: zod.z.string().optional()
+    })
+  ),
+  /** Модель */
+  model: zod.z.string(),
+  /** Причина остановки */
+  stop_reason: zod.z.enum(["end_turn", "max_tokens", "stop_sequence", "tool_use"]).nullable(),
+  /** Использование токенов */
+  usage: zod.z.object({
+    input_tokens: zod.z.number(),
+    output_tokens: zod.z.number()
+  })
+});
+var ChatRequestSchema = zod.z.object({
+  /** Сообщение пользователя */
+  message: zod.z.string().min(1).max(1e4),
+  /** История сообщений */
+  history: zod.z.array(
+    zod.z.object({
+      role: zod.z.enum(["user", "assistant"]),
+      content: zod.z.string()
+    })
+  ).optional().default([]),
+  /** ID сессии */
+  sessionId: zod.z.string().optional(),
+  /** Режим (customer/internal) */
+  mode: zod.z.enum(["customer", "internal"]).optional().default("customer")
+});
+var SourceSchema = zod.z.object({
+  /** Тип источника */
+  type: zod.z.enum(["email", "pdf", "website"]),
+  /** Заголовок */
+  title: zod.z.string(),
+  /** URL или идентификатор */
+  url: zod.z.string().optional(),
+  /** Превью контента */
+  preview: zod.z.string().optional(),
+  /** Оценка релевантности */
+  relevance: zod.z.number().optional()
+});
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  return result.success ? result.data : null;
+}
+function parseOrThrow(schema, data, errorMessage = "Validation failed") {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new Error(`${errorMessage}: ${issues}`);
+  }
+  return result.data;
+}
+
+exports.AnthropicApiError = AnthropicApiError;
+exports.ApiError = ApiError;
+exports.AppError = AppError;
+exports.ChatRequestSchema = ChatRequestSchema;
+exports.ClaudeMessageSchema = ClaudeMessageSchema;
+exports.ConfigError = ConfigError;
+exports.Logger = Logger;
+exports.SourceSchema = SourceSchema;
+exports.TurbopufferApiError = TurbopufferApiError;
+exports.TurbopufferSearchResultSchema = TurbopufferSearchResultSchema;
+exports.ValidationError = ValidationError;
+exports.VectorAttributesSchema = VectorAttributesSchema;
+exports.VoyageApiError = VoyageApiError;
+exports.VoyageEmbeddingResponseSchema = VoyageEmbeddingResponseSchema;
+exports.VoyageRerankResponseSchema = VoyageRerankResponseSchema;
+exports.anthropicLogger = anthropicLogger;
+exports.apiLogger = apiLogger;
+exports.createTimer = createTimer;
+exports.isAppError = isAppError;
+exports.logger = logger;
+exports.parseOrThrow = parseOrThrow;
+exports.retryApiCall = retryApiCall;
+exports.retryCritical = retryCritical;
+exports.safeParse = safeParse;
+exports.sleep = sleep;
+exports.turbopufferLogger = turbopufferLogger;
+exports.voyageLogger = voyageLogger;
+exports.withRetry = withRetry;
+exports.wrapError = wrapError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map