@opensumi/ide-ai-native 3.7.2-next-1739859371.0 → 3.7.2-next-1739945875.0

package/src/browser/mcp/tools/getCurrentFilePath.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetCurrentFilePathTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_open_in_editor_file_path',
+      description:
+        'Retrieves the absolute path of the currently active file in the VS Code editor. ' +
+        'Use this tool to get the file location for tasks requiring file path information. ' +
+        'Returns an empty string if no file is currently open.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    const editor = this.editorService.currentEditor;
+    if (!editor || !editor.currentUri) {
+      logger.appendLine('Error: No active text editor found');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const path = editor.currentUri.toString();
+    logger.appendLine(`Current file path: ${path}`);
+
+    return {
+      content: [{ type: 'text', text: path }],
+    };
+  }
+}

package/src/browser/mcp/tools/getDiagnosticsByPath.ts

@@ -0,0 +1,123 @@
+import * as path from 'path';
+
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain, URI } from '@opensumi/ide-core-common';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+import { URI as MonacoURI } from '@opensumi/monaco-editor-core/esm/vs/base/common/uri';
+import { IMarkerService, MarkerSeverity } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({
+  filePathInProject: z.string().describe('The relative path to the file to get diagnostics for'),
+});
+
+@Domain(MCPServerContribution)
+export class GetDiagnosticsByPathTool implements MCPServerContribution {
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IMarkerService)
+  private readonly markerService: IMarkerService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_diagnostics_by_path',
+      description:
+        'Retrieves diagnostic information (errors, warnings, etc.) from a specific file in the project. ' +
+        'Use this tool to get information about problems in any project file. ' +
+        'IMPORTANT: This tool should be called after any code generation or modification operations to verify and fix potential issues. ' +
+        'Requires a filePathInProject parameter specifying the target file path relative to project root. ' +
+        'Returns a JSON-formatted list of diagnostics, where each entry contains: ' +
+        '- path: The file path where the diagnostic was found ' +
+        '- line: The line number (1-based) of the diagnostic ' +
+        '- severity: The severity level ("error", "warning", "information", or "hint") ' +
+        '- message: The diagnostic message ' +
+        "Returns an empty list ([]) if no diagnostics are found or the file doesn't exist. " +
+        'Best Practice: Always check diagnostics after code generation to ensure code quality and fix any issues immediately. ' +
+        'Use this tool in combination with get_open_in_editor_file_diagnostics to verify all affected files after code changes. ' +
+        'Diagnostic Severity Handling Guidelines: ' +
+        '- "error": Must be fixed immediately as they indicate critical issues that will prevent code from working correctly. ' +
+        '- "warning": For user code, preserve unless the warning indicates a clear improvement opportunity. For generated code, optimize to remove warnings. ' +
+        '- "information"/"hint": For user code, preserve as they might reflect intentional patterns. For generated code, optimize if it improves code quality without changing functionality.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    try {
+      // 获取工作区根目录
+      const workspaceRoots = this.workspaceService.tryGetRoots();
+      if (!workspaceRoots || workspaceRoots.length === 0) {
+        logger.appendLine('Error: Cannot determine project directory');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 构建完整的文件路径
+      const rootUri = URI.parse(workspaceRoots[0].uri);
+      const fullPath = path.join(rootUri.codeUri.fsPath, args.filePathInProject);
+      const uri = MonacoURI.file(fullPath);
+
+      // 检查文件是否在项目目录内
+      const relativePath = path.relative(rootUri.codeUri.fsPath, fullPath);
+      if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        logger.appendLine('Error: File is outside of project scope');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 获取文件的诊断信息
+      const markers = this.markerService.read({ resource: uri });
+
+      // 转换诊断信息
+      const diagnosticInfos = markers.map((marker) => ({
+        path: args.filePathInProject,
+        line: marker.startLineNumber,
+        severity: this.getSeverityString(marker.severity),
+        message: marker.message,
+      }));
+
+      // 将结果转换为 JSON 字符串
+      const resultJson = JSON.stringify(diagnosticInfos, null, 2);
+      logger.appendLine(`Found ${diagnosticInfos.length} diagnostics in ${args.filePathInProject}`);
+
+      return {
+        content: [{ type: 'text', text: resultJson }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error getting diagnostics: ${error}`);
+      return {
+        content: [{ type: 'text', text: '[]' }],
+        isError: true,
+      };
+    }
+  }
+
+  private getSeverityString(severity: MarkerSeverity): string {
+    switch (severity) {
+      case MarkerSeverity.Error:
+        return 'error';
+      case MarkerSeverity.Warning:
+        return 'warning';
+      case MarkerSeverity.Info:
+        return 'information';
+      case MarkerSeverity.Hint:
+        return 'hint';
+      default:
+        return 'unknown';
+    }
+  }
+}

package/src/browser/mcp/tools/getFileTextByPath.ts

@@ -0,0 +1,97 @@
+import * as path from 'path';
+
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain, URI } from '@opensumi/ide-core-common';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({
+  pathInProject: z.string().describe('The file location relative to project root'),
+});
+
+@Domain(MCPServerContribution)
+export class GetFileTextByPathTool implements MCPServerContribution {
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IFileServiceClient)
+  private readonly fileService: IFileServiceClient;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_file_text_by_path',
+      description:
+        'Retrieves the text content of a file using its path relative to project root. ' +
+        "Use this tool to read file contents when you have the file's project-relative path. " +
+        'Requires a pathInProject parameter specifying the file location from project root. ' +
+        'Returns one of these responses: ' +
+        "- The file's content if the file exists and belongs to the project " +
+        '- error "project dir not found" if project directory cannot be determined ' +
+        '- error "file not found" if the file doesn\'t exist or is outside project scope ' +
+        'Note: Automatically refreshes the file system before reading',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    try {
+      // 获取工作区根目录
+      const workspaceRoots = this.workspaceService.tryGetRoots();
+      if (!workspaceRoots || workspaceRoots.length === 0) {
+        logger.appendLine('Error: Cannot determine project directory');
+        return {
+          content: [{ type: 'text', text: 'project dir not found' }],
+          isError: true,
+        };
+      }
+
+      // 构建完整的文件路径
+      const rootUri = URI.parse(workspaceRoots[0].uri);
+      const fullPath = path.join(rootUri.codeUri.fsPath, args.pathInProject);
+      const fileUri = URI.file(fullPath);
+
+      // 检查文件是否在项目目录内
+      const relativePath = path.relative(rootUri.codeUri.fsPath, fullPath);
+      if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        logger.appendLine('Error: File is outside of project scope');
+        return {
+          content: [{ type: 'text', text: 'file not found' }],
+          isError: true,
+        };
+      }
+
+      // 检查文件是否存在并读取内容
+      try {
+        const result = await this.fileService.readFile(fileUri.toString());
+        const content = result.content.toString();
+        logger.appendLine(`Successfully read file: ${args.pathInProject}`);
+
+        return {
+          content: [{ type: 'text', text: content }],
+        };
+      } catch (error) {
+        logger.appendLine('Error: File does not exist');
+        return {
+          content: [{ type: 'text', text: 'file not found' }],
+          isError: true,
+        };
+      }
+    } catch (error) {
+      logger.appendLine(`Error reading file: ${error}`);
+      return {
+        content: [{ type: 'text', text: 'file not found' }],
+        isError: true,
+      };
+    }
+  }
+}

package/src/browser/mcp/tools/getOpenEditorFileDiagnostics.ts

@@ -0,0 +1,121 @@
+import * as path from 'path';
+
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain, URI } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+import { URI as MonacoURI } from '@opensumi/monaco-editor-core/esm/vs/base/common/uri';
+import { IMarkerService, MarkerSeverity } from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetOpenEditorFileDiagnosticsTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IMarkerService)
+  private readonly markerService: IMarkerService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_open_in_editor_file_diagnostics',
+      description:
+        'Retrieves diagnostic information (errors, warnings, etc.) from the currently active file in VS Code editor. ' +
+        'Use this tool to get information about problems in your current file. ' +
+        'IMPORTANT: This tool should be called after any code generation or modification operations to verify and fix potential issues. ' +
+        'Returns a JSON-formatted list of diagnostics, where each entry contains: ' +
+        '- path: The file path where the diagnostic was found ' +
+        '- line: The line number (1-based) of the diagnostic ' +
+        '- severity: The severity level ("error", "warning", "information", or "hint") ' +
+        '- message: The diagnostic message ' +
+        'Returns an empty list ([]) if no diagnostics are found or no file is open. ' +
+        'Best Practice: Always check diagnostics after code generation to ensure code quality and fix any issues immediately. ' +
+        'Diagnostic Severity Handling Guidelines: ' +
+        '- "error": Must be fixed immediately as they indicate critical issues that will prevent code from working correctly. ' +
+        '- "warning": For user code, preserve unless the warning indicates a clear improvement opportunity. For generated code, optimize to remove warnings. ' +
+        '- "information"/"hint": For user code, preserve as they might reflect intentional patterns. For generated code, optimize if it improves code quality without changing functionality.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    try {
+      // 获取当前活动的编辑器
+      const editor = this.editorService.currentEditor;
+      if (!editor || !editor.currentUri) {
+        logger.appendLine('Error: No active text editor found');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 获取工作区根目录
+      const workspaceRoots = this.workspaceService.tryGetRoots();
+      if (!workspaceRoots || workspaceRoots.length === 0) {
+        logger.appendLine('Error: Cannot determine project directory');
+        return {
+          content: [{ type: 'text', text: '[]' }],
+          isError: true,
+        };
+      }
+
+      // 获取当前文件的诊断信息
+      const monacoUri = MonacoURI.parse(editor.currentUri.toString());
+      const markers = this.markerService.read({ resource: monacoUri });
+      const rootUri = URI.parse(workspaceRoots[0].uri);
+      const relativePath = path.relative(rootUri.codeUri.fsPath, editor.currentUri.codeUri.fsPath);
+
+      // 转换诊断信息
+      const diagnosticInfos = markers.map((marker) => ({
+        path: relativePath,
+        line: marker.startLineNumber,
+        severity: this.getSeverityString(marker.severity),
+        message: marker.message,
+      }));
+
+      // 将结果转换为 JSON 字符串
+      const resultJson = JSON.stringify(diagnosticInfos, null, 2);
+      logger.appendLine(`Found ${diagnosticInfos.length} diagnostics in current file`);
+
+      return {
+        content: [{ type: 'text', text: resultJson }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error getting diagnostics: ${error}`);
+      return {
+        content: [{ type: 'text', text: '[]' }],
+        isError: true,
+      };
+    }
+  }
+
+  private getSeverityString(severity: MarkerSeverity): string {
+    switch (severity) {
+      case MarkerSeverity.Error:
+        return 'error';
+      case MarkerSeverity.Warning:
+        return 'warning';
+      case MarkerSeverity.Info:
+        return 'information';
+      case MarkerSeverity.Hint:
+        return 'hint';
+      default:
+        return 'unknown';
+    }
+  }
+}

package/src/browser/mcp/tools/getOpenEditorFileText.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetOpenEditorFileTextTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_open_in_editor_file_text',
+      description:
+        'Retrieves the complete text content of the currently active file in the IDE editor. ' +
+        "Use this tool to access and analyze the file's contents for tasks such as code review, content inspection, or text processing. " +
+        'Returns empty string if no file is currently open.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    const editor = this.editorService.currentEditor;
+    if (!editor || !editor.currentDocumentModel) {
+      logger.appendLine('Error: No active text editor found');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const document = editor.currentDocumentModel;
+    logger.appendLine(`Reading content from: ${document.uri.toString()}`);
+    const content = document.getText();
+
+    return {
+      content: [{ type: 'text', text: content }],
+    };
+  }
+}

package/src/browser/mcp/tools/getSelectedText.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired, Injectable } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({});
+
+@Domain(MCPServerContribution)
+export class GetSelectedTextTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'get_selected_in_editor_text',
+      description:
+        'Retrieves the currently selected text from the active editor in VS Code. ' +
+        'Use this tool when you need to access and analyze text that has been highlighted/selected by the user. ' +
+        'Returns an empty string if no text is selected or no editor is open.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    const editor = this.editorService.currentEditor;
+    if (!editor || !editor.monacoEditor) {
+      logger.appendLine('Error: No active text editor found');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const selection = editor.monacoEditor.getSelection();
+    if (!selection) {
+      logger.appendLine('No text is currently selected');
+      return {
+        content: [{ type: 'text', text: '' }],
+      };
+    }
+
+    const selectedText = editor.monacoEditor.getModel()?.getValueInRange(selection) || '';
+    logger.appendLine(`Retrieved selected text of length: ${selectedText.length}`);
+
+    return {
+      content: [{ type: 'text', text: selectedText }],
+    };
+  }
+}

package/src/browser/mcp/tools/handlers/ListDir.ts

@@ -0,0 +1,117 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { AppConfig, Throttler, URI } from '@opensumi/ide-core-browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+/**
+ * 并发限制器
+ */
+class ConcurrencyLimiter {
+  private maxConcurrent: number;
+  private currentCount: number;
+  private pendingQueue: (() => void)[];
+  /**
+   * @param {number} maxConcurrent - 最大并发数
+   */
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent; // 最大并发数
+    this.currentCount = 0; // 当前执行的任务数
+    this.pendingQueue = []; // 等待执行的任务队列
+  }
+
+  /**
+   * 执行异步任务
+   * @param {Function} fn - 要执行的异步函数
+   * @returns {Promise} 任务执行的结果
+   */
+  async execute(fn) {
+    // 如果当前执行的任务数达到最大并发数，则加入等待队列
+    if (this.currentCount >= this.maxConcurrent) {
+      await new Promise<void>((resolve) => this.pendingQueue.push(resolve));
+    }
+
+    this.currentCount++;
+
+    try {
+      // 执行任务
+      const result = await fn();
+      return result;
+    } finally {
+      this.currentCount--;
+      // 如果等待队列中有任务，则允许执行下一个任务
+      if (this.pendingQueue.length > 0) {
+        const next = this.pendingQueue.shift();
+        next?.();
+      }
+    }
+  }
+}
+
+@Injectable()
+export class ListDirHandler {
+  private readonly MAX_FILE_SIZE = 1024 * 1024; // 1MB
+  private readonly MAX_INDEXED_FILES = 50;
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  @Autowired(IFileServiceClient)
+  private readonly fileSystemService: IFileServiceClient;
+
+  async handler(args: { relativeWorkspacePath: string }) {
+    const { relativeWorkspacePath } = args;
+    if (!relativeWorkspacePath) {
+      throw new Error('No list dir parameters provided. Need to give at least the path.');
+    }
+
+    // 解析相对路径
+    const absolutePath = `${this.appConfig.workspaceDir}/${relativeWorkspacePath}`;
+    const fileStat = await this.fileSystemService.getFileStat(absolutePath, true);
+    // 验证路径有效性
+    if (!fileStat || !fileStat.isDirectory) {
+      throw new Error(`Could not find file ${relativeWorkspacePath} in the workspace.`);
+    }
+    // 过滤符合大小限制的文件
+    const filesWithinSizeLimit =
+      fileStat.children
+        ?.filter((file) => !file.isDirectory && file.size !== void 0 && file.size <= this.MAX_FILE_SIZE)
+        .slice(0, this.MAX_INDEXED_FILES) || [];
+
+    // 记录需要分析的文件名
+    const filesToAnalyze = new Set(filesWithinSizeLimit.map((file) => new URI(file.uri).displayName));
+
+    // 创建并发限制器
+    const concurrencyLimiter = new ConcurrencyLimiter(4);
+    // 处理所有文件信息
+    const fileInfos = await Promise.all(
+      fileStat.children
+        ?.sort((a, b) => b.lastModification - a.lastModification)
+        .map(async (file) => {
+          const uri = new URI(file.uri);
+          const filePath = `${absolutePath}/${uri.displayName}`;
+          let lineCount: number | undefined;
+
+          // 如果文件需要分析，则计算行数
+          if (filesToAnalyze.has(uri.displayName)) {
+            lineCount = await concurrencyLimiter.execute(async () => this.countFileLines(filePath));
+          }
+          return {
+            name: uri.displayName,
+            isDirectory: file.isDirectory,
+            size: file.size,
+            lastModified: file.lastModification,
+            numChildren: file.children?.length,
+            numLines: lineCount,
+          };
+        }) || [],
+    );
+    // TODO: 过滤忽略文件
+    return {
+      files: fileInfos,
+      directoryRelativeWorkspacePath: relativeWorkspacePath,
+    };
+  }
+
+  async countFileLines(filePath: string) {
+    const file = await this.fileSystemService.readFile(URI.file(filePath).toString());
+    return file.toString().split('\n').length;
+  }
+}