import { CodeSolverSDK } from 'solver-sdk';

const sdk = await CodeSolverSDK.create({
  baseURL: 'http://localhost:3000',
  apiKey: 'your-api-key'
});

const sdk = await CodeSolverSDK.create({
  baseURL: 'https://workai.su/api/v1',
  headers: { Authorization: `Bearer ${oauth_token}` },
  webSocket: { enabled: true }
});

const sdk = await CodeSolverSDK.create({
  baseURL: 'https://workai.su/api/v1',
  getAuthToken: async () => {
    if (authManager.isTokenExpired()) {
      await authManager.refreshAccessToken();
    }
    return authManager.getAccessToken();
  }
});

// Управление проектами
getAllProjects(): Promise<Project[]>
getProject(projectId: string): Promise<Project>
createProject(name: string, data?: any): Promise<Project>
findOrCreateProject(projectName: string): Promise<Project>
deleteProject(projectId: string): Promise<void>

// Состояние и синхронизация
getProjectState(projectId: string, clientRootHash?: string): Promise<ProjectState>
getIndexingStatus(projectId: string): Promise<any>
startIndexing(projectId: string, options?: any): Promise<any>
cancelIndexing(projectId: string): Promise<boolean>
resetIndexing(projectId: string): Promise<any>
restartIndexing(projectId: string): Promise<any>
clearIndexingError(projectId: string): Promise<boolean>

// Session Recovery
getRecoveryStatus(projectId: string): Promise<any>
resumeSync(projectId: string, options?: any): Promise<any>
cancelRecovery(projectId: string): Promise<any>
initializeDeltaSync(projectId: string, clientRootHash: string): Promise<any>

// Диагностика
getFilePathMapping(projectId: string): Promise<any>

// Синхронизация чанков (автоматическая инициализация + батчинг + финализация)
syncEncryptedChunks(
  projectId: string, 
  encryptedChunks: any[], 
  rootHash: string, 
  options?: { batchSize?: number; onProgress?: (current, total) => void }
): Promise<any>

getSyncStatus(projectId: string): Promise<SyncStatus>
cancelSync(projectId: string): Promise<boolean>
cleanupDeletedFiles(projectId: string, activeFiles: any[]): Promise<any>

// Основные методы
chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
chatCompletion(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
streamChat(messages: ChatMessage[], options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>
streamPrompt(prompt: string, options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>
sendContinuation(messages: ChatMessage[], options?: ChatStreamOptions): AsyncGenerator<ChatStreamChunk>

// Failover
chatWithRegionFailover(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>
sendPromptWithRegionFailover(prompt: string, options?: ChatOptions): Promise<string>
checkAvailability(): Promise<boolean>

searchCode(projectId: string, query: string, options?: any): Promise<any[]>
searchFunctions(projectId: string, query: string, options?: any): Promise<any[]>
getFunctionStats(projectId: string): Promise<{stats: {totalFunctions: number}}>
semanticSearch(projectId: string, query: string, options?: any): Promise<any[]>

getAllModels(): Promise<any[]>
getProviderModels(providerId: string): Promise<any>
getAvailableModels(): Promise<any[]>
getModelInfo(modelId: string): Promise<any>

checkForUpdates(options: UpdateCheckOptions): Promise<UpdateResponse>
getChangelog(version: string, locale: string): Promise<string>
getLatestVersion(channel?: string): Promise<LatestVersionInfo>
sendStats(event: UpdateStatsEvent): Promise<void>
checkAvailability(): Promise<boolean>

// Подключение
await sdk.connectWebSocket()
sdk.disconnectWebSocket()
sdk.isWebSocketConnected

// Подписка
sdk.projectSync.subscribeToProject(projectId)
sdk.projectSync.unsubscribeFromProject(projectId)

// События
sdk.projectSync.on('sync-status-update', callback)  // {projectId, status, timestamp}
sdk.projectSync.on('sync-progress', callback)       // {projectId, progress, stage, currentChunk, totalChunks}
sdk.projectSync.on('sync-completed', callback)      // {projectId, processedChunks, embeddingsCreated}
sdk.projectSync.on('sync-error', callback)          // {projectId, error, timestamp}

// ✅ Единственный правильный способ:
await sdk.deltaManager.syncEncryptedChunks(projectId, chunks, rootHash, {
  batchSize: 50,
  onProgress: (current, total) => console.log(`${current}/${total}`)
});

// Всегда проверять при старте проекта
const recovery = await sdk.projects.getRecoveryStatus(projectId);
if (recovery.needsRecovery) {
  // Показать диалог: Continue (67%) | Start Fresh
  await sdk.projects.resumeSync(projectId);  // или cancelRecovery()
}

const sdk = await CodeSolverSDK.create({
  baseURL: 'https://workai.su/api/v1',
  getAuthToken: () => authManager.getAccessToken()
});

// 1. Найти/создать проект
const project = await sdk.projects.findOrCreateProject('/path/to/project');

// 2. Проверить recovery
const recovery = await sdk.projects.getRecoveryStatus(project.id);
if (recovery.needsRecovery) {
  await sdk.projects.resumeSync(project.id);
  return;
}

// 3. Проверить нужна ли синхронизация
const state = await sdk.projects.getProjectState(project.id, clientRootHash);
if (!state.syncRequired) {
  console.log('Проект синхронизирован');
  return;
}

// 4. Подключить WebSocket для прогресса
await sdk.connectWebSocket();
sdk.projectSync.subscribeToProject(project.id);
sdk.projectSync.on('sync-progress', (data) => {
  console.log(`Прогресс: ${data.progress}%`);
});

// 5. Синхронизировать
await sdk.deltaManager.syncEncryptedChunks(project.id, chunks, rootHash);

// 6. Поиск по проекту
const results = await sdk.search.searchCode(project.id, 'function handleClick');

for await (const chunk of sdk.chat.streamChat(messages, { model: 'claude-3-5-sonnet' })) {
  if (chunk.type === 'content_block_delta') {
    process.stdout.write(chunk.delta.text);
  }
}

import { ChatMessage, ChatOptions, Project, ProjectState } from 'solver-sdk';

try {
  await sdk.projects.getProject(projectId);
} catch (error) {
  console.error(`[HTTP ${error.status}] ${error.message}`);
  // v6.1.3+: читаемые сообщения ошибок вместо [object Object]
}

const sdk = await CodeSolverSDK.create({
  baseURL: 'https://workai.su/api/v1',
  debug: 'verbose',  // silent | error | warn | info | debug | verbose
  webSocket: { debug: true }
});