solver-sdk 2.8.0 → 3.1.1

package/docs/VSCODE_INTEGRATION.md

@@ -1,432 +1,269 @@
-# VS Code Integration v2.7.0
+# VS Code Extension Integration
 
-**Детальное руководство для разработчиков VS Code Extension** (продолжение [Quick Start](QUICK_START.md))
+> **Практическое руководство интеграции SDK с VS Code Extension**
 
-## 🎯 Архитектура
+## 🚀 Быстрая интеграция
 
-```
-AI Модель → Backend → SDK → VS Code Extension → VS Code Native API
-                    ↑─── HTTP Streaming (45ms) ───↑
-```
-
-**Результат:** **10x ускорение** команд - 45ms вместо 443ms! 🚀
-
-## 🚀 Быстрый старт
-
-### 1. Установка и инициализация
+### 1. Базовая настройка
 
 ```typescript
-import { CodeSolverSDK, VSCodeCommandEvent, CommandExecutionResult } from 'solver-sdk';
+import { CodeSolverSDK } from 'solver-sdk';
 import * as vscode from 'vscode';
 
-const sdk = await CodeSolverSDK.create({
-  baseURL: 'http://localhost:3000',
-  apiKey: 'your-api-key'
-});
+// Инициализация SDK
+let sdk: CodeSolverSDK;
+
+export async function activate(context: vscode.ExtensionContext) {
+  // Создание SDK
+  sdk = await CodeSolverSDK.create({
+    baseURL: 'http://localhost:3000'
+  });
+  
+  // Регистрация команд
+  const indexCommand = vscode.commands.registerCommand(
+    'myExtension.indexProject',
+    indexCurrentWorkspace
+  );
+  
+  const searchCommand = vscode.commands.registerCommand(
+    'myExtension.searchFunctions',
+    searchAndNavigate
+  );
+  
+  context.subscriptions.push(indexCommand, searchCommand);
+}
 ```
 
-### 2. Базовая интеграция
+## 📊 Индексация с прогресс-баром
 
 ```typescript
-async function integrateWithVSCode() {
-  const stream = await sdk.chat.streamChat(
-    [{ role: 'user', content: 'Создай компонент Button в React' }],
-    {
-      thinking: true, // Адаптивный budget: 15000→12000→10000...→5000
+async function indexCurrentWorkspace() {
+  if (!vscode.workspace.workspaceFolders) {
+    vscode.window.showErrorMessage('Откройте папку проекта');
+    return;
+  }
+  
+  const folder = vscode.workspace.workspaceFolders[0];
+  const projectPath = folder.uri.fsPath;
+  const projectName = folder.name;
+  
+  return vscode.window.withProgress({
+    location: vscode.ProgressLocation.Notification,
+    title: 'Индексация проекта',
+    cancellable: true
+  }, async (progress, token) => {
+    try {
+      progress.report({ message: 'Создание проекта...' });
+      const project = await sdk.projects.findOrCreateProject(projectPath, projectName);
+      
+      progress.report({ message: 'Запуск индексации...' });
+      await sdk.projects.startIndexing(project.id);
       
-      // 🎯 Главная функция - обработчик VS Code команд
-      onVSCodeCommand: async (command: VSCodeCommandEvent) => {
-        return await executeVSCodeCommand(command);
+      while (!token.isCancellationRequested) {
+        const status = await sdk.projects.getProjectStatus(project.id);
+        
+        if (status.status === 'ready') {
+          vscode.window.showInformationMessage('✅ Проект проиндексирован!');
+          return project;
+        }
+        
+        if (status.status === 'error') {
+          throw new Error(status.error);
+        }
+        
+        const percentage = status.progress || 0;
+        progress.report({ 
+          increment: percentage,
+          message: `${percentage}% - ${status.currentFile || 'Обработка...'}`
+        });
+        
+        await new Promise(resolve => setTimeout(resolve, 2000));
       }
+      
+    } catch (error) {
+      vscode.window.showErrorMessage(`Ошибка: ${error.message}`);
     }
-  );
-
-  // Обработка потока
-  for await (const chunk of stream) {
-    if (chunk.type === 'command_executed') {
-      console.log('✅ Команда выполнена:', chunk.commandResult);
-    } else if (chunk.type === 'text') {
-      console.log('💬 AI ответ:', chunk.text);
-    }
-  }
+  });
 }
 ```
 
-### 3. Реализация обработчика команд
+## 🔍 Поиск функций с навигацией
 
 ```typescript
-async function executeVSCodeCommand(
-  command: VSCodeCommandEvent
-): Promise<CommandExecutionResult> {
-  const startTime = Date.now();
+async function searchAndNavigate() {
+  const projects = await sdk.projects.getReadyProjects();
+  
+  if (projects.length === 0) {
+    vscode.window.showWarningMessage('Нет проиндексированных проектов');
+    return;
+  }
+  
+  const query = await vscode.window.showInputBox({
+    prompt: 'Поиск функций',
+    placeholder: 'Введите название функции или описание...'
+  });
+  
+  if (!query) return;
   
   try {
-    console.log(`🚀 Выполнение: ${command.command}`, command.args);
+    const results = await sdk.search.searchFunctions(projects[0].id, {
+      query,
+      limit: 20
+    });
     
-    // Выполнение через VS Code API
-    const result = await vscode.commands.executeCommand(
-      command.command,
-      ...(command.args || [])
-    );
+    if (results.results.length === 0) {
+      vscode.window.showInformationMessage('Ничего не найдено');
+      return;
+    }
     
-    return {
-      requestId: command.requestId,
-      success: true,
-      result,
-      executionTime: Date.now() - startTime,
-      timestamp: Date.now()
-    };
+    const functionItems = results.results.map(fn => ({
+      label: `$(symbol-function) ${fn.name}`,
+      description: fn.signature,
+      detail: `${fn.filePath}:${fn.startLine}`,
+      function: fn
+    }));
     
-  } catch (error: any) {
-    return {
-      requestId: command.requestId,
-      success: false,
-      error: error.message,
-      executionTime: Date.now() - startTime,
-      timestamp: Date.now()
-    };
-  }
-}
-```
-
-## 📋 Поддерживаемые команды
-
-```typescript
-import { VSCodeCommands } from 'solver-sdk';
-
-// Создание файлов
-VSCodeCommands.CREATE_FILE = 'aiSolver.native.createFile'
-// Использование: ['src/Button.tsx', 'export const Button = () => <button>Click</button>']
-
-// Редактирование файлов  
-VSCodeCommands.EDIT_FILE = 'aiSolver.native.editFile'
-// Использование: ['src/App.tsx', { line: 10, content: 'new code' }]
-
-// Bulk операции
-VSCodeCommands.BULK_EDIT = 'aiSolver.native.bulkEdit'
-// Использование: [{ file: 'src/A.tsx', changes: [...] }, { file: 'src/B.tsx', changes: [...] }]
-
-// Поиск файлов
-VSCodeCommands.FIND_FILES = 'vscode.workspace.findFiles'
-// Использование: ['**/*.tsx', '**/node_modules/**']
-
-// Текстовый поиск
-VSCodeCommands.FIND_TEXT = 'vscode.workspace.findTextInFiles'  
-// Использование: ['useState', { include: '**/*.tsx' }]
-
-// Терминал
-VSCodeCommands.TERMINAL = 'aiSolver.native.terminal'
-// Использование: ['npm install react', { cwd: '/path/to/project' }]
-
-// Стандартные команды
-VSCodeCommands.SAVE_FILE = 'workbench.action.files.save'
-VSCodeCommands.SAVE_ALL = 'workbench.action.files.saveAll'
-```
-
-## 🛠️ Продвинутые сценарии
-
-### Обработка различных типов команд
-
-```typescript
-async function advancedCommandHandler(command: VSCodeCommandEvent) {
-  const { command: cmd, args, metadata } = command;
-  
-  switch (cmd) {
-    case VSCodeCommands.CREATE_FILE:
-      return await handleCreateFile(args[0], args[1]);
-      
-    case VSCodeCommands.EDIT_FILE:
-      return await handleEditFile(args[0], args[1]);
-      
-    case VSCodeCommands.BULK_EDIT:
-      return await handleBulkEdit(args[0]);
-      
-    case VSCodeCommands.FIND_FILES:
-      return await handleFindFiles(args[0], args[1]);
-      
-    case VSCodeCommands.TERMINAL:
-      return await handleTerminal(args[0], args[1]);
-      
-    default:
-      // Fallback для любых других команд
-      return await handleGenericCommand(cmd, args);
+    const selectedFunction = await vscode.window.showQuickPick(functionItems);
+    
+    if (selectedFunction) {
+      await navigateToFunction(selectedFunction.function);
+    }
+    
+  } catch (error) {
+    vscode.window.showErrorMessage(`Ошибка поиска: ${error.message}`);
   }
 }
 
-async function handleCreateFile(path: string, content: string) {
+async function navigateToFunction(fn: any) {
   try {
-    const uri = vscode.Uri.file(path);
-    const encoder = new TextEncoder();
-    await vscode.workspace.fs.writeFile(uri, encoder.encode(content));
+    const doc = await vscode.workspace.openTextDocument(fn.filePath);
+    const editor = await vscode.window.showTextDocument(doc);
     
-    // Открываем файл в редакторе
-    await vscode.window.showTextDocument(uri);
+    const range = new vscode.Range(
+      fn.startLine - 1, 0,
+      fn.endLine - 1, 0
+    );
+    
+    editor.selection = new vscode.Selection(range.start, range.end);
+    editor.revealRange(range, vscode.TextEditorRevealType.InCenter);
     
-    return {
-      success: true,
-      result: { created: true, path, opened: true }
-    };
   } catch (error) {
-    return {
-      success: false,
-      error: `Не удалось создать файл: ${error.message}`
-    };
-  }
-}
-
-async function handleBulkEdit(operations: Array<{file: string, changes: any[]}>) {
-  const edit = new vscode.WorkspaceEdit();
-  const results = [];
-  
-  for (const op of operations) {
-    try {
-      const uri = vscode.Uri.file(op.file);
-      
-      for (const change of op.changes) {
-        const range = new vscode.Range(
-          change.startLine, change.startChar,
-          change.endLine, change.endChar
-        );
-        edit.replace(uri, range, change.newText);
-      }
-      
-      results.push({ file: op.file, success: true });
-    } catch (error) {
-      results.push({ 
-        file: op.file, 
-        success: false, 
-        error: error.message 
-      });
-    }
+    vscode.window.showErrorMessage(`Ошибка навигации: ${error.message}`);
   }
-  
-  const applied = await vscode.workspace.applyEdit(edit);
-  
-  return {
-    success: applied,
-    result: { operations: results, totalApplied: applied }
-  };
 }
 ```
 
-### Логирование и мониторинг
+## 💬 AI Chat интеграция
 
 ```typescript
-class VSCodeIntegrationLogger {
-  private outputChannel: vscode.OutputChannel;
-  
-  constructor() {
-    this.outputChannel = vscode.window.createOutputChannel('AI Solver');
+async function askAI() {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showWarningMessage('Откройте файл в редакторе');
+    return;
   }
   
-  logCommand(command: VSCodeCommandEvent, result: CommandExecutionResult) {
-    const status = result.success ? '✅' : '❌';
-    const time = result.executionTime;
-    
-    this.outputChannel.appendLine(
-      `${status} [${time}ms] ${command.command} - ${command.requestId}`
-    );
-    
-    if (!result.success) {
-      this.outputChannel.appendLine(`   Error: ${result.error}`);
-    }
-    
-    // Показываем панель при ошибках
-    if (!result.success) {
-      this.outputChannel.show();
-    }
-  }
+  const selection = editor.selection;
+  const selectedText = editor.document.getText(selection);
   
-  logPerformance(commands: CommandExecutionResult[]) {
-    const avgTime = commands.reduce((sum, cmd) => sum + cmd.executionTime, 0) / commands.length;
-    const successRate = commands.filter(cmd => cmd.success).length / commands.length * 100;
-    
-    this.outputChannel.appendLine(`📊 Performance: ${avgTime.toFixed(1)}ms avg, ${successRate.toFixed(1)}% success`);
+  let contextText = '';
+  if (selectedText) {
+    contextText = `
+
+Выделенный код:
+\`\`\`${editor.document.languageId}
+${selectedText}
+\`\`\``;
   }
+  
+  const question = await vscode.window.showInputBox({
+    prompt: 'Задайте вопрос AI',
+    placeholder: 'Что делает этот код? Как его улучшить?'
+  });
+  
+  if (!question) return;
+  
+  return vscode.window.withProgress({
+    location: vscode.ProgressLocation.Notification,
+    title: 'AI анализирует код...',
+    cancellable: false
+  }, async (progress) => {
+    try {
+      const response = await sdk.chat.chat([{
+        role: 'user',
+        content: question + contextText
+      }], {
+        model: 'claude-3-5-sonnet-20241022',
+        maxTokens: 8192
+      });
+      
+      const doc = await vscode.workspace.openTextDocument({
+        content: `Q: ${question}
+
+A: ${response.content[0].text}`,
+        language: 'markdown'
+      });
+      
+      await vscode.window.showTextDocument(doc);
+      
+    } catch (error) {
+      vscode.window.showErrorMessage(`Ошибка AI: ${error.message}`);
+    }
+  });
 }
 ```
 
-## 🔧 Конфигурация Extension
-
-### package.json
+## ⚙️ Конфигурация package.json
 
 ```json
 {
+  "name": "my-code-assistant",
+  "displayName": "AI Code Assistant",
+  "description": "AI помощник для анализа и поиска кода",
+  "version": "1.0.0",
+  "engines": {
+    "vscode": "^1.60.0"
+  },
+  "categories": ["Other"],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "main": "./out/extension.js",
   "contributes": {
     "commands": [
       {
-        "command": "aiSolver.native.createFile",
-        "title": "AI Solver: Create File"
-      },
-      {
-        "command": "aiSolver.native.editFile", 
-        "title": "AI Solver: Edit File"
+        "command": "myExtension.indexProject",
+        "title": "📊 Проиндексировать проект",
+        "category": "AI Assistant"
       },
       {
-        "command": "aiSolver.native.bulkEdit",
-        "title": "AI Solver: Bulk Edit"
+        "command": "myExtension.searchFunctions",
+        "title": "🔍 Поиск функций",
+        "category": "AI Assistant"
       },
       {
-        "command": "aiSolver.native.terminal",
-        "title": "AI Solver: Execute Terminal Command"
+        "command": "myExtension.askAI",
+        "title": "💬 Спросить AI",
+        "category": "AI Assistant"
       }
     ],
-    "configuration": {
-      "title": "AI Solver",
-      "properties": {
-        "aiSolver.apiUrl": {
-          "type": "string",
-          "default": "http://localhost:3000",
-          "description": "AI Solver API URL"
-        },
-        "aiSolver.commandTimeout": {
-          "type": "number", 
-          "default": 30000,
-          "description": "Command execution timeout (ms)"
-        }
-      }
-    }
-  }
-}
-```
-
-### Активация extension
-
-```typescript
-export function activate(context: vscode.ExtensionContext) {
-  const logger = new VSCodeIntegrationLogger();
-  const sdk = initializeSDK();
-  
-  // Регистрация команд
-  const createFileCommand = vscode.commands.registerCommand(
-    'aiSolver.native.createFile',
-    async (path: string, content: string) => {
-      // Реализация создания файла
-    }
-  );
-  
-  const editFileCommand = vscode.commands.registerCommand(
-    'aiSolver.native.editFile',
-    async (path: string, changes: any) => {
-      // Реализация редактирования файла
-    }
-  );
-  
-  context.subscriptions.push(createFileCommand, editFileCommand);
-  
-  // Инициализация сервиса интеграции
-  const integrationService = new VSCodeIntegrationService(sdk, logger);
-  integrationService.start();
-}
-```
-
-## 📈 Performance Optimization
-
-### Кэширование команд
-
-```typescript
-class CommandCache {
-  private cache = new Map<string, any>();
-  
-  async executeWithCache(command: VSCodeCommandEvent): Promise<CommandExecutionResult> {
-    // Кэшируем результаты для идемпотентных команд
-    if (this.isIdempotent(command.command)) {
-      const cacheKey = this.getCacheKey(command);
-      const cached = this.cache.get(cacheKey);
-      
-      if (cached) {
-        return {
-          ...cached,
-          requestId: command.requestId,
-          executionTime: 5, // Кэш-хит
-          timestamp: Date.now()
-        };
+    "keybindings": [
+      {
+        "command": "myExtension.searchFunctions",
+        "key": "ctrl+shift+f",
+        "mac": "cmd+shift+f"
+      },
+      {
+        "command": "myExtension.askAI",
+        "key": "ctrl+shift+a",
+        "mac": "cmd+shift+a"
       }
-    }
-    
-    const result = await executeVSCodeCommand(command);
-    
-    // Сохраняем в кэш
-    if (result.success && this.isIdempotent(command.command)) {
-      const cacheKey = this.getCacheKey(command);
-      this.cache.set(cacheKey, result);
-    }
-    
-    return result;
-  }
-  
-  private isIdempotent(command: string): boolean {
-    return [
-      VSCodeCommands.FIND_FILES,
-      VSCodeCommands.FIND_TEXT
-    ].includes(command as VSCodeCommands);
-  }
-}
-```
-
-## 🐛 Error Handling
-
-### Comprehensive error handling
-
-```typescript
-import { CommandErrorType, COMMAND_TIMEOUT } from 'solver-sdk';
-
-async function executeWithTimeout(command: VSCodeCommandEvent): Promise<CommandExecutionResult> {
-  const timeout = new Promise<CommandExecutionResult>((_, reject) => {
-    setTimeout(() => {
-      reject(new Error(`Command timeout after ${COMMAND_TIMEOUT}ms`));
-    }, COMMAND_TIMEOUT);
-  });
-  
-  const execution = executeVSCodeCommand(command);
-  
-  try {
-    return await Promise.race([execution, timeout]);
-  } catch (error: any) {
-    let errorType: CommandErrorType;
-    
-    if (error.message.includes('timeout')) {
-      errorType = CommandErrorType.TIMEOUT;
-    } else if (error.message.includes('not found')) {
-      errorType = CommandErrorType.NOT_FOUND;
-    } else if (error.message.includes('invalid')) {
-      errorType = CommandErrorType.INVALID_ARGS;
-    } else {
-      errorType = CommandErrorType.EXECUTION_ERROR;
-    }
-    
-    return {
-      requestId: command.requestId,
-      success: false,
-      error: `[${errorType}] ${error.message}`,
-      executionTime: COMMAND_TIMEOUT,
-      timestamp: Date.now()
-    };
+    ]
+  },
+  "dependencies": {
+    "solver-sdk": "^3.0.0"
   }
 }
 ```
 
-## 🎯 Результат интеграции
-
-### До интеграции:
-- ⏱️ **443ms** среднее время выполнения команд
-- 🔄 Сложная архитектура с множественными хопами
-- 🐛 Проблемы с синхронизацией
-
-### После интеграции v2.7.0:
-- ⚡ **45ms** среднее время выполнения команд (**10x ускорение!**)
-- 🎯 Прямое взаимодействие с VS Code API
-- 🛡️ Надежная error handling
-- 📊 Real-time мониторинг производительности
-
-```typescript
-// Пример конечного результата
-const performanceMetrics = {
-  averageLatency: '45ms',        // vs 443ms old
-  successRate: '99.2%',          // vs 87% old  
-  commandsPerSecond: 22,         // vs 2.3 old
-  errorRecoveryTime: '150ms'     // vs 2.1s old
-};
-```
-
-🎉 **VS Code Extension теперь работает со скоростью нативного IDE!** 
+SDK готов для интеграции в VS Code Extension! 🚀