@opensumi/ide-ai-native 3.7.1-next-1737628160.0 → 3.7.1-next-1737703128.0

package/src/browser/index.ts

@@ -19,8 +19,16 @@ import {
   TerminalRegistryToken,
 } from '@opensumi/ide-core-common';
 
-import { ChatProxyServiceToken, IChatAgentService, IChatInternalService, IChatManagerService } from '../common';
-import { IAIInlineCompletionsProvider } from '../common';
+import {
+  ChatProxyServiceToken,
+  IAIInlineCompletionsProvider,
+  IChatAgentService,
+  IChatInternalService,
+  IChatManagerService,
+  SumiMCPServerProxyServicePath,
+  TokenMCPServerProxyService,
+} from '../common';
+import { MCPServerManager, MCPServerManagerPath } from '../common/mcp-server-manager';
 
 import { AINativeBrowserContribution } from './ai-core.contribution';
 import { ChatAgentService } from './chat/chat-agent.service';
@@ -43,8 +51,18 @@ import { RenameCandidatesProviderRegistry } from './contrib/rename/rename.featur
 import { TerminalAIContribution } from './contrib/terminal/terminal-ai.contributon';
 import { TerminalFeatureRegistry } from './contrib/terminal/terminal.feature.registry';
 import { LanguageParserService } from './languages/service';
+import { MCPServerProxyService } from './mcp/mcp-server-proxy.service';
+import { MCPServerRegistry } from './mcp/mcp-server.feature.registry';
+import { CreateNewFileWithTextTool } from './mcp/tools/createNewFileWithText';
+import { FindFilesByNameSubstringTool } from './mcp/tools/findFilesByNameSubstring';
+import { GetCurrentFilePathTool } from './mcp/tools/getCurrentFilePath';
+import { GetDiagnosticsByPathTool } from './mcp/tools/getDiagnosticsByPath';
+import { GetFileTextByPathTool } from './mcp/tools/getFileTextByPath';
+import { GetOpenEditorFileDiagnosticsTool } from './mcp/tools/getOpenEditorFileDiagnostics';
+import { GetOpenEditorFileTextTool } from './mcp/tools/getOpenEditorFileText';
+import { GetSelectedTextTool } from './mcp/tools/getSelectedText';
 import { AINativePreferencesContribution } from './preferences';
-import { AINativeCoreContribution } from './types';
+import { AINativeCoreContribution, MCPServerContribution, TokenMCPServerRegistry } from './types';
 import { InlineChatFeatureRegistry } from './widget/inline-chat/inline-chat.feature.registry';
 import { AIInlineChatService } from './widget/inline-chat/inline-chat.service';
 import { InlineDiffService } from './widget/inline-diff';
@@ -59,7 +77,7 @@ export class AINativeModule extends BrowserModule {
     this.aiNativeConfig.setAINativeModuleLoaded(true);
   }
 
-  contributionProvider = AINativeCoreContribution;
+  contributionProvider = [AINativeCoreContribution, MCPServerContribution];
   providers: Provider[] = [
     AINativeBrowserContribution,
     InterfaceNavigationContribution,
@@ -68,6 +86,26 @@ export class AINativeModule extends BrowserModule {
     AICodeActionContribution,
     AINativePreferencesContribution,
     IntelligentCompletionsContribution,
+
+    // MCP Server Contributions START
+    CreateNewFileWithTextTool,
+    GetSelectedTextTool,
+    GetOpenEditorFileDiagnosticsTool,
+    GetOpenEditorFileTextTool,
+    GetFileTextByPathTool,
+    GetCurrentFilePathTool,
+    FindFilesByNameSubstringTool,
+    GetDiagnosticsByPathTool,
+    // MCP Server Contributions END
+
+    {
+      token: TokenMCPServerRegistry,
+      useClass: MCPServerRegistry,
+    },
+    {
+      token: TokenMCPServerProxyService,
+      useClass: MCPServerProxyService,
+    },
     {
       token: InlineChatFeatureRegistryToken,
       useClass: InlineChatFeatureRegistry,
@@ -148,5 +186,13 @@ export class AINativeModule extends BrowserModule {
       token: AIBackSerivceToken,
       clientToken: ChatProxyServiceToken,
     },
+    {
+      servicePath: MCPServerManagerPath,
+      token: MCPServerManager,
+    },
+    {
+      clientToken: TokenMCPServerProxyService,
+      servicePath: SumiMCPServerProxyServicePath,
+    },
   ];
 }

package/src/browser/mcp/mcp-server-proxy.service.ts

@@ -0,0 +1,32 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { ILogger } from '@opensumi/ide-core-browser';
+
+import { IMCPServerRegistry, TokenMCPServerRegistry } from '../types';
+
+@Injectable()
+export class MCPServerProxyService {
+  @Autowired(TokenMCPServerRegistry)
+  private readonly mcpServerRegistry: IMCPServerRegistry;
+
+  @Autowired(ILogger)
+  private readonly logger: ILogger;
+
+  $callMCPTool(name: string, args: any) {
+    return this.mcpServerRegistry.callMCPTool(name, args);
+  }
+
+  async $getMCPTools() {
+    const tools = await this.mcpServerRegistry.getMCPTools().map((tool) =>
+      // 不要传递 handler
+       ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      }),
+    );
+
+    this.logger.log('SUMI MCP tools', tools);
+
+    return tools;
+  }
+}

package/src/browser/mcp/mcp-server.feature.registry.ts

@@ -0,0 +1,47 @@
+// OpenSumi as MCP Server 前端的代理服务
+import { Autowired, Injectable } from '@opensumi/di';
+import { IAIBackService, ILogger } from '@opensumi/ide-core-common';
+
+import { IMCPServerRegistry, MCPLogger, MCPToolDefinition } from '../types';
+
+class LoggerAdapter implements MCPLogger {
+  constructor(private readonly logger: ILogger) {}
+
+  appendLine(message: string): void {
+    this.logger.log(message);
+  }
+}
+
+@Injectable()
+export class MCPServerRegistry implements IMCPServerRegistry {
+  private tools: MCPToolDefinition[] = [];
+
+  @Autowired(ILogger)
+  private readonly baseLogger: ILogger;
+
+  private get logger(): MCPLogger {
+    return new LoggerAdapter(this.baseLogger);
+  }
+
+  registerMCPTool(tool: MCPToolDefinition): void {
+    this.tools.push(tool);
+  }
+
+  getMCPTools(): MCPToolDefinition[] {
+    return this.tools;
+  }
+
+  callMCPTool(
+    name: string,
+    args: any,
+  ): Promise<{
+    content: { type: string; text: string }[];
+    isError?: boolean;
+  }> {
+    const tool = this.tools.find((tool) => tool.name === name);
+    if (!tool) {
+      throw new Error(`MCP tool ${name} not found`);
+    }
+    return tool.handler(args, this.logger);
+  }
+}

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

@@ -0,0 +1,85 @@
+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, path as UriPath } 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 relative path where the file should be created'),
+  text: z.string().describe('The content to write into the new file'),
+});
+
+@Domain(MCPServerContribution)
+export class CreateNewFileWithTextTool 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: 'create_new_file_with_text',
+      description:
+        'Creates a new file at the specified path within the project directory and populates it with the provided text. ' +
+        'Use this tool to generate new files in your project structure. ' +
+        'Requires two parameters: ' +
+        '- pathInProject: The relative path where the file should be created ' +
+        '- text: The content to write into the new file ' +
+        'Returns one of two possible responses: ' +
+        '"ok" if the file was successfully created and populated, ' +
+        '"can\'t find project dir" if the project directory cannot be determined. ' +
+        'Note: Creates any necessary parent directories automatically.',
+      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: "can't find project dir" }],
+          isError: true,
+        };
+      }
+
+      // 构建完整的文件路径
+      const rootUri = URI.parse(workspaceRoots[0].uri);
+      const fullPath = UriPath.join(rootUri.codeUri.fsPath, args.pathInProject);
+      const fileUri = URI.file(fullPath);
+
+      // 创建父目录
+      const parentDir = path.dirname(fullPath);
+      const parentUri = URI.file(parentDir);
+      await this.fileService.createFolder(parentUri.toString());
+
+      // 写入文件内容
+      await this.fileService.createFile(fileUri.toString(), { content: args.text });
+
+      logger.appendLine(`Successfully created file at: ${args.pathInProject}`);
+      return {
+        content: [{ type: 'text', text: 'ok' }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error during file creation: ${error}`);
+      return {
+        content: [{ type: 'text', text: 'unknown error' }],
+        isError: true,
+      };
+    }
+  }
+}

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

@@ -0,0 +1,93 @@
+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 { IFileSearchService } from '@opensumi/ide-file-search/lib/common';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+const inputSchema = z.object({
+  nameSubstring: z.string().describe('The substring to search for in file names'),
+});
+
+@Domain(MCPServerContribution)
+export class FindFilesByNameSubstringTool implements MCPServerContribution {
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IFileSearchService)
+  private readonly fileSearchService: IFileSearchService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'find_files_by_name_substring',
+      description:
+        'Searches for all files in the project whose names contain the specified substring (case-insensitive). ' +
+        'Use this tool to locate files when you know part of the filename. ' +
+        'Requires a nameSubstring parameter for the search term. ' +
+        'Returns a JSON array of objects containing file information: ' +
+        '- path: Path relative to project root ' +
+        '- name: File name ' +
+        'Returns an empty array ([]) if no matching files are found. ' +
+        'Note: Only searches through files within the project directory, excluding libraries and external dependencies.',
+      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,
+        };
+      }
+
+      // 使用 OpenSumi 的文件搜索 API
+      const searchPattern = `**/*${args.nameSubstring}*`;
+      const searchResults = await this.fileSearchService.find(searchPattern, {
+        rootUris: [workspaceRoots[0].uri],
+        excludePatterns: ['**/node_modules/**'],
+        limit: 1000,
+      });
+
+      // 转换结果为所需的格式
+      const results = searchResults.map((file) => {
+        const uri = URI.parse(file);
+        const rootUri = URI.parse(workspaceRoots[0].uri);
+        const relativePath = path.relative(rootUri.codeUri.fsPath, uri.codeUri.fsPath);
+        const fileName = path.basename(uri.codeUri.fsPath);
+        return {
+          path: relativePath,
+          name: fileName,
+        };
+      });
+
+      // 将结果转换为 JSON 字符串
+      const resultJson = JSON.stringify(results, null, 2);
+      logger.appendLine(`Found ${results.length} files matching "${args.nameSubstring}"`);
+
+      return {
+        content: [{ type: 'text', text: resultJson }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error during file search: ${error}`);
+      return {
+        content: [{ type: 'text', text: '[]' }],
+        isError: true,
+      };
+    }
+  }
+}

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,
+      };
+    }
+  }
+}