solver-sdk
Version:
SDK for API integration
434 lines • 19.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeSolverSDK = void 0;
const http_client_js_1 = require("./utils/http-client.js");
const projects_api_js_1 = require("./api/projects-api.js");
const search_api_js_1 = require("./api/search-api.js");
const index_js_1 = require("./api/chat-api/index.js");
const tools_api_js_1 = require("./api/tools-api.js");
const updates_api_js_1 = require("./api/updates-api.js");
const user_api_js_1 = require("./api/user-api.js");
const models_api_js_1 = require("./api/models-api.js");
const version_js_1 = require("./version.js");
// 🔄 Delta-Chunking imports
const delta_chunking_api_js_1 = require("./api/delta-chunking-api.js");
const delta_chunking_manager_js_1 = require("./delta-chunking/delta-chunking-manager.js");
const delta_chunking_utils_js_1 = require("./delta-chunking/delta-chunking-utils.js");
// 🔌 WebSocket imports
const project_sync_client_js_1 = require("./utils/project-sync-client.js");
/**
* Определение типа среды выполнения
* @returns 'browser' | 'node' | 'unknown'
*/
function getEnvironment() {
if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
return 'browser';
}
else if (typeof process !== 'undefined' && process.versions && process.versions.node) {
return 'node';
}
return 'unknown';
}
/**
* Основной класс SDK для работы с Code Solver API
* Версия 5.1+ - HTTP + WebSocket для real-time уведомлений
*/
class CodeSolverSDK {
/**
* ✅ РЕКОМЕНДУЕМЫЙ СПОСОБ: Создает и валидирует SDK
* @param {CodeSolverSDKOptions} options Опции SDK
* @returns {Promise<CodeSolverSDK>} Инициализированный SDK
*/
static async create(options) {
const sdk = new CodeSolverSDK(options);
// Проверяем здоровье API при создании
const isHealthy = await sdk.checkHealth();
if (!isHealthy) {
sdk.logger.warn('API недоступен при создании SDK');
}
return sdk;
}
/**
* Создает новый экземпляр SDK
* @param {CodeSolverSDKOptions} options Опции SDK
*/
constructor(options) {
/** Logger для внутреннего использования */
this.logger = {
log: (message) => {
const debugLevel = this._options.debug;
if (debugLevel && debugLevel !== 'silent' && debugLevel !== 'error' && debugLevel !== 'warn') {
console.log(`${message}`);
}
},
warn: (message) => {
const debugLevel = this._options.debug;
if (debugLevel && debugLevel !== 'silent' && debugLevel !== 'error') {
console.warn(`⚠️ ${message}`);
}
},
error: (message) => {
const debugLevel = this._options.debug;
if (debugLevel !== 'silent') {
console.error(`🔴 ${message}`);
}
},
debug: (message) => {
const debugLevel = this._options.debug;
if (debugLevel === 'verbose' || debugLevel === 'debug') {
console.debug(`🔍 ${message}`);
}
},
// ✅ НОВЫЕ методы для контроля стрим логирования
streamEvent: (message, data) => {
const debugLevel = this._options.debug;
const streamLogging = this._options.streamLogging;
if (debugLevel === 'silent')
return;
if (streamLogging?.sseEvents || (debugLevel === 'verbose' || debugLevel === 'debug')) {
console.log(`STREAM: ${message}`, data);
}
},
streamChunk: (message, data) => {
const debugLevel = this._options.debug;
const streamLogging = this._options.streamLogging;
if (debugLevel === 'silent')
return;
if (streamLogging?.streamChunks || (debugLevel === 'verbose' || debugLevel === 'debug')) {
console.log(`CHUNK: ${message}`, data);
}
},
eventCallback: (message, data) => {
const debugLevel = this._options.debug;
const streamLogging = this._options.streamLogging;
if (debugLevel === 'silent')
return;
if (streamLogging?.eventCallbacks || (debugLevel === 'verbose' || debugLevel === 'debug')) {
console.log(`EVENT: ${message}`, data);
}
}
};
this._options = {
...options,
mode: options.mode || 'auto'
};
// Определяем среду выполнения
this.environment = this._options.mode === 'auto'
? getEnvironment()
: this._options.mode === 'browser' ? 'browser' : 'node';
// Инициализируем HTTP клиент
this.httpClient = new http_client_js_1.HttpClient(this._options.baseURL, {
headers: {
...(this._options.apiKey ? { 'Authorization': `Bearer ${this._options.apiKey}` } : {}),
...(this._options.headers || {})
},
timeout: this._options.timeout,
httpsAgent: this.environment === 'node' ? this._options.httpsAgent : undefined,
getAuthToken: this._options.getAuthToken // 🔑 Динамическое получение токена
});
// Инициализируем API клиенты
this._projects = new projects_api_js_1.ProjectsApi(this.httpClient);
this._search = new search_api_js_1.SearchApi(this.httpClient);
// this._indexing = new IndexingApi(this.httpClient); // УДАЛЕН
this._chat = new index_js_1.ChatApi(this.httpClient, {
debug: this._options.debug,
streamLogging: this._options.streamLogging
});
// 🔧 Инициализация Tools API
this._tools = new tools_api_js_1.ToolsApi(this.httpClient);
this._models = new models_api_js_1.ModelsApi(this.httpClient);
this._updates = new updates_api_js_1.UpdatesApi(this.httpClient);
this._user = new user_api_js_1.UserApi(this.httpClient);
// 🔄 Инициализируем Delta-Chunking если включен
if (this._options.deltaChunking?.enabled) {
// Создаем отдельный DeltaChunkingApi для delta операций
const deltaApi = new delta_chunking_api_js_1.DeltaChunkingApi(this.httpClient);
const deltaUtils = new delta_chunking_utils_js_1.DeltaChunkingUtils(this._projects, this._options, this.environment, this.logger);
this._deltaManager = new delta_chunking_manager_js_1.DeltaChunkingManager(deltaApi, // ✅ Передаем правильный DeltaChunkingApi
deltaUtils, this._options, this.logger);
this.logger.log('🔄 Delta-Chunking инициализирован');
}
// 🔌 Инициализируем WebSocket клиент если включен
if (this._options.webSocket?.enabled !== false) { // По умолчанию включен
// Формируем WebSocket URL из baseURL
const wsUrl = this._options.baseURL
.replace(/^http/, 'ws') // http -> ws, https -> wss
.replace(/\/api\/v\d+$/, ''); // Убираем /api/v1 если есть
const wsOptions = {
baseURL: wsUrl,
headers: this._options.headers,
connectionTimeout: this._options.webSocket?.connectionTimeout || 10000,
maxRetries: this._options.webSocket?.maxRetries || 3,
retryDelay: this._options.webSocket?.retryDelay || 2000,
debug: this._options.webSocket?.debug || false,
};
this._projectSyncClient = new project_sync_client_js_1.ProjectSyncClient(wsOptions);
this.logger.log(`🔌 WebSocket клиент инициализирован: ${wsUrl}/socket.io/project-sync`);
}
}
/**
* Получает версию SDK
* @returns {string} Версия SDK
*/
static getVersion() {
return version_js_1.VERSION;
}
/**
* Обновляет опции SDK
* @param {Partial<CodeSolverSDKOptions>} newOptions Новые опции
*/
updateOptions(newOptions) {
Object.assign(this._options, newOptions);
// Обновляем HTTP клиент при необходимости
if (newOptions.apiKey || newOptions.headers || newOptions.timeout) {
this.httpClient = new http_client_js_1.HttpClient(this._options.baseURL, {
headers: {
...(this._options.apiKey ? { 'Authorization': `Bearer ${this._options.apiKey}` } : {}),
...(this._options.headers || {})
},
timeout: this._options.timeout,
httpsAgent: this.environment === 'node' ? this._options.httpsAgent : undefined
});
}
}
/**
* Проверяет здоровье API
* @returns {Promise<boolean>} Результат проверки
*/
async checkHealth() {
try {
const response = await this.httpClient.get('/health');
return response?.status === 'ok';
}
catch (error) {
this.logger.error(`Ошибка проверки здоровья API: ${error instanceof Error ? error.message : 'неизвестная ошибка'}`);
return false;
}
}
/**
* Диагностирует состояние API - правильная диагностика
* @returns {Promise<object>} Результат диагностики
*/
async diagnoseAPI() {
const diagnosis = {
healthy: true,
endpoints: {},
errors: []
};
// Проверяем основные эндпоинты согласно актуальной документации
const endpoints = [
'/health',
'/api/v1/projects'
// Убираем несуществующие endpoints: '/api/v1/status', '/api/v1/models'
];
for (const endpoint of endpoints) {
try {
await this.httpClient.get(endpoint);
diagnosis.endpoints[endpoint] = true;
}
catch (error) {
diagnosis.endpoints[endpoint] = false;
diagnosis.healthy = false;
diagnosis.errors.push(`${endpoint}: ${error instanceof Error ? error.message : 'неизвестная ошибка'}`);
}
}
return diagnosis;
}
/**
* Получает API для работы с проектами
* @returns {ProjectsApi} API для работы с проектами
*/
get projects() {
return this._projects;
}
/**
* Получает API для поиска кода
* @returns {SearchApi} API для поиска кода
*/
get search() {
return this._search;
}
/**
* Получает API для работы с чатом
* @returns {ChatApi} API для работы с чатом
*/
get chat() {
return this._chat;
}
/**
* Получает API для работы с инструментами
* @returns {ToolsApi} API для работы с инструментами
*/
get tools() {
return this._tools;
}
/**
* Получает API для работы с моделями
* @returns {ModelsApi} API для работы с моделями
*/
get models() {
return this._models;
}
/**
* Получает экземпляр API для работы с обновлениями
* @returns {UpdatesApi} API для работы с обновлениями
*/
get updates() {
return this._updates;
}
/**
* Получает API для работы с профилем пользователя
* @returns {UserApi} API для работы с профилем пользователя
*/
get user() {
return this._user;
}
// 🔄 DELTA-CHUNKING МЕТОДЫ
/**
* Проверяет активность delta-chunking функциональности
* @returns {boolean} true если delta-chunking включен и инициализирован
*/
get isDeltaChunkingEnabled() {
return !!this._deltaManager?.isEnabled;
}
/**
* 📤 Синхронизация готовых зашифрованных чанков (для Extension)
* @param {string} projectId ID проекта
* @param {any[]} encryptedChunks Готовые зашифрованные чанки
* @param {string} rootHash Root hash для синхронизации
* @param {SyncOptions} options Опции синхронизации
* @returns {Promise<SyncResult>} Результат синхронизации
*/
async syncEncryptedChunks(projectId, encryptedChunks, rootHash, options = {}) {
if (!this._deltaManager) {
throw new Error('Delta-chunking не включен. Установите deltaChunking.enabled = true в конфигурации SDK');
}
return await this._deltaManager.syncEncryptedChunks(projectId, encryptedChunks, rootHash, options);
}
/**
* 📊 Получение статуса синхронизации
* @param {string} projectId ID проекта
* @returns {Promise<SyncStatus>} Статус синхронизации
*/
async getSyncStatus(projectId) {
if (!this._deltaManager) {
throw new Error('Delta-chunking не включен. Установите deltaChunking.enabled = true в конфигурации SDK');
}
return await this._deltaManager.getSyncStatus(projectId);
}
/**
* ❌ Отмена активной синхронизации
* @param {string} projectId ID проекта
* @returns {Promise<boolean>} true если синхронизация отменена
*/
async cancelSync(projectId) {
if (!this._deltaManager) {
throw new Error('Delta-chunking не включен. Установите deltaChunking.enabled = true в конфигурации SDK');
}
return await this._deltaManager.cancelSync(projectId);
}
/**
* 🧹 Очистка удаленных файлов из векторной базы (отдельный метод)
* @param {string} projectId ID проекта
* @param {ActiveFile[]} activeFiles Список активных файлов
* @returns {Promise<FileCleanupResult>} Результат очистки
*/
async cleanupDeletedFiles(projectId, activeFiles) {
if (!this._deltaManager) {
throw new Error('Delta-chunking не включен. Установите deltaChunking.enabled = true в конфигурации SDK');
}
// Используем публичный метод DeltaChunkingManager
return await this._deltaManager.performCleanup(projectId, activeFiles);
}
/**
* Обрабатывает ошибки SDK
* @param {Error} error Ошибка
*/
static handleError(error) {
if (CodeSolverSDK.errorHandler) {
CodeSolverSDK.errorHandler(error);
}
else {
console.error('Необработанная ошибка:', error);
}
}
/**
* Устанавливает глобальный обработчик ошибок
* @param {Function} handler Обработчик ошибок
*/
static setErrorHandler(handler) {
CodeSolverSDK.errorHandler = handler;
}
/**
* Освобождает ресурсы SDK
*/
async dispose() {
this.logger.debug('Освобождение ресурсов SDK');
}
/**
* Устанавливает новый API ключ
* @param {string} apiKey Новый API ключ
*/
setApiKey(apiKey) {
this._options.apiKey = apiKey;
this.updateOptions({ apiKey });
}
/**
* Получает информацию о SDK
* @returns {object} Информация о SDK
*/
getInfo() {
return {
version: version_js_1.VERSION,
environment: this.environment,
baseURL: this._options.baseURL,
hasApiKey: !!this._options.apiKey,
deltaChunkingEnabled: this.isDeltaChunkingEnabled
};
}
/**
* 🔄 Получение менеджера Delta-Chunking для расширенного API
* @returns {DeltaChunkingManager | undefined} Менеджер delta-chunking или undefined если отключен
*/
get deltaManager() {
return this._deltaManager;
}
/**
* 🔌 Получение WebSocket клиента для project-sync уведомлений
* @returns {ProjectSyncClient | undefined} WebSocket клиент или undefined если не включен
*/
get projectSync() {
return this._projectSyncClient;
}
/**
* 🔌 Подключение к WebSocket для получения real-time уведомлений
* @returns {Promise<void>} Promise который разрешается при успешном подключении
*/
async connectWebSocket() {
if (!this._projectSyncClient) {
throw new Error('WebSocket клиент не инициализирован. Включите webSocket.enabled в опциях SDK.');
}
await this._projectSyncClient.connect();
this.logger.log('🔌 WebSocket подключение установлено');
}
/**
* 🔌 Отключение от WebSocket
*/
disconnectWebSocket() {
if (this._projectSyncClient) {
this._projectSyncClient.disconnect();
this.logger.log('🔌 WebSocket отключен');
}
}
/**
* 🔌 Проверка статуса WebSocket подключения
* @returns {boolean} true если WebSocket подключен
*/
get isWebSocketConnected() {
return this._projectSyncClient?.isConnected || false;
}
}
exports.CodeSolverSDK = CodeSolverSDK;
/** Глобальный обработчик ошибок */
CodeSolverSDK.errorHandler = null;
//# sourceMappingURL=code-solver-sdk.js.map