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

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

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

@@ -0,0 +1,174 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { FileSearchQuickCommandHandler } from '@opensumi/ide-addons/lib/browser/file-search.contribution';
+import { AppConfig } from '@opensumi/ide-core-browser';
+import { CancellationToken, URI } from '@opensumi/ide-core-common';
+import { IEditorDocumentModelRef, IEditorDocumentModelService } from '@opensumi/ide-editor/lib/browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+@Injectable()
+export class FileHandler {
+  private static readonly MAX_FILE_SIZE_BYTES = 2e6;
+  private static readonly MAX_LINES = 250;
+  private static readonly MAX_CHARS = 1e5;
+  private static readonly NEWLINE = '\n';
+
+  @Autowired(IEditorDocumentModelService)
+  protected modelService: IEditorDocumentModelService;
+
+  @Autowired(FileSearchQuickCommandHandler)
+  protected fileSearchQuickCommandHandler: FileSearchQuickCommandHandler;
+
+  @Autowired(AppConfig)
+  protected appConfig: AppConfig;
+
+  @Autowired(IFileServiceClient)
+  protected fileSystemService: IFileServiceClient;
+
+  async findSimilarFiles(filePath: string, maxResults: number): Promise<string[]> {
+    const items = await this.fileSearchQuickCommandHandler.getQueryFiles(filePath, new Set(), CancellationToken.None);
+    return items
+      .slice(0, maxResults)
+      .map((item) => item.getUri()?.codeUri.fsPath)
+      .filter(Boolean) as string[];
+  }
+  // TODO: 错误应该给模型？
+  private createFileNotFoundError(filePath: string, similarFiles: string[]): Error {
+    const errorMessage =
+      similarFiles.length > 0
+        ? `Could not find file '${filePath}'. Did you mean one of:\n${similarFiles
+            .map((file) => `- ${file}`)
+            .join('\n')}`
+        : `Could not find file '${filePath}' in the workspace.`;
+
+    return new Error(
+      JSON.stringify({
+        clientVisibleErrorMessage: errorMessage,
+        modelVisibleErrorMessage: errorMessage,
+        actualErrorMessage: `File not found: ${filePath}`,
+      }),
+    );
+  }
+
+  private createFileTooLargeError(fileSizeMB: string, fileStatsSize: number): Error {
+    return new Error(
+      JSON.stringify({
+        clientVisibleErrorMessage: `File is too large, >${fileSizeMB}MB`,
+        modelVisibleErrorMessage: `The file is too large to read, was >${fileSizeMB}MB`,
+        actualErrorMessage: `File is too large to read, was >${fileSizeMB}MB, size: ${fileStatsSize} bytes`,
+      }),
+    );
+  }
+
+  private trimContent(content: string, maxChars: number): string {
+    return content.slice(0, maxChars).split(FileHandler.NEWLINE).slice(0, -1).join(FileHandler.NEWLINE);
+  }
+
+  private getLineRange(
+    fileParams: {
+      startLineOneIndexed?: number;
+      endLineOneIndexedInclusive?: number;
+    },
+    forceLimit: boolean,
+  ): { start: number; end: number; didShorten: boolean; didSetDefault: boolean } {
+    let start = fileParams.startLineOneIndexed ?? 1;
+    let end = fileParams.endLineOneIndexedInclusive ?? start + FileHandler.MAX_LINES - 1;
+    let didShorten = false;
+    let didSetDefault = false;
+
+    if (forceLimit) {
+      return { start, end, didShorten, didSetDefault };
+    }
+
+    if (fileParams.endLineOneIndexedInclusive === undefined || fileParams.startLineOneIndexed === undefined) {
+      start = 1;
+      end = FileHandler.MAX_LINES;
+      didSetDefault = true;
+    } else if (fileParams.endLineOneIndexedInclusive - fileParams.startLineOneIndexed > FileHandler.MAX_LINES) {
+      end = fileParams.startLineOneIndexed + FileHandler.MAX_LINES;
+      didShorten = true;
+    }
+
+    return { start, end, didShorten, didSetDefault };
+  }
+
+  async readFile(fileParams: {
+    relativeWorkspacePath: string;
+    readEntireFile: boolean;
+    fileIsAllowedToBeReadEntirely?: boolean;
+    startLineOneIndexed?: number;
+    endLineOneIndexedInclusive?: number;
+  }) {
+    if (!fileParams) {
+      throw new Error('No read file parameters provided. Need to give at least the path.');
+    }
+
+    const uri = new URI(`${this.appConfig.workspaceDir}/${fileParams.relativeWorkspacePath}`);
+    if (!uri) {
+      const similarFiles = await this.findSimilarFiles(fileParams.relativeWorkspacePath, 3);
+      throw this.createFileNotFoundError(fileParams.relativeWorkspacePath, similarFiles);
+    }
+
+    const fileSizeMB = (FileHandler.MAX_FILE_SIZE_BYTES / 1e6).toFixed(2);
+    const fileStats = await this.fileSystemService.getFileStat(uri.toString());
+
+    if (fileStats?.size && fileStats.size > FileHandler.MAX_FILE_SIZE_BYTES) {
+      throw this.createFileTooLargeError(fileSizeMB, fileStats.size);
+    }
+
+    let modelReference: IEditorDocumentModelRef | undefined;
+    try {
+      modelReference = await this.modelService.createModelReference(uri);
+      const fileContent = modelReference.instance.getMonacoModel().getValue();
+      const fileLines = fileContent.split(FileHandler.NEWLINE);
+
+      const shouldLimitLines = !(fileParams.readEntireFile && fileParams.fileIsAllowedToBeReadEntirely);
+      const shouldForceLimitLines = fileParams.readEntireFile && !fileParams.fileIsAllowedToBeReadEntirely;
+      let didShortenCharRange = false;
+
+      if (shouldLimitLines) {
+        const {
+          start,
+          end,
+          didShorten: didShortenLineRange,
+          didSetDefault: didSetDefaultLineRange,
+        } = this.getLineRange(fileParams, shouldForceLimitLines);
+
+        const adjustedStart = Math.max(start, 1);
+        const adjustedEnd = Math.min(end, fileLines.length);
+        let selectedContent = fileLines.slice(adjustedStart - 1, adjustedEnd).join(FileHandler.NEWLINE);
+
+        if (selectedContent.length > FileHandler.MAX_CHARS) {
+          didShortenCharRange = true;
+          selectedContent = this.trimContent(selectedContent, FileHandler.MAX_CHARS);
+        }
+
+        return {
+          contents: selectedContent,
+          didDowngradeToLineRange: shouldForceLimitLines,
+          didShortenLineRange,
+          didShortenCharRange,
+          didSetDefaultLineRange,
+          fullFileContents: fileContent,
+          startLineOneIndexed: adjustedStart,
+          endLineOneIndexedInclusive: adjustedEnd,
+          relativeWorkspacePath: fileParams.relativeWorkspacePath,
+        };
+      }
+
+      let fullContent = fileContent;
+      if (fullContent.length > FileHandler.MAX_CHARS) {
+        didShortenCharRange = true;
+        fullContent = this.trimContent(fullContent, FileHandler.MAX_CHARS);
+      }
+
+      return {
+        contents: fullContent,
+        fullFileContents: fileContent,
+        didDowngradeToLineRange: false,
+        didShortenCharRange,
+      };
+    } finally {
+      modelReference?.dispose();
+    }
+  }
+}

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+import { ListDirHandler } from './handlers/ListDir';
+
+const inputSchema = z
+  .object({
+    relative_workspace_path: z
+      .string()
+      .describe("Path to list contents of, relative to the workspace root. Ex: './' is the root of the workspace"),
+    explanation: z
+      .string()
+      .describe('One sentence explanation as to why this tool is being used, and how it contributes to the goal.'),
+  })
+  .transform((data) => ({
+    relativeWorkspacePath: data.relative_workspace_path,
+  }));
+
+@Domain(MCPServerContribution)
+export class ListDirTool implements MCPServerContribution {
+  @Autowired(ListDirHandler)
+  private readonly listDirHandler: ListDirHandler;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'list_dir',
+      description:
+        'List the contents of a directory. The quick tool to use for discovery, before using more targeted tools like semantic search or file reading. Useful to try to understand the file structure before diving deeper into specific files. Can be used to explore the codebase.',
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    // TODO: 应该添加统一的 validate 逻辑
+    args = inputSchema.parse(args);
+    const result = await this.listDirHandler.handler(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Contents of directory:
+
+
+          ${result.files
+            .map(
+              (file) =>
+                `[${file.isDirectory ? 'dir' : 'file'}] ${file.name} ${
+                  file.isDirectory ? `(${file.numChildren ?? '?'} items)` : `(${file.size}KB, ${file.numLines} lines)`
+                } - ${new Date(file.lastModified).toLocaleString()}`,
+            )
+            .join('\n')}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common';
+
+import { IMCPServerRegistry, MCPLogger, MCPServerContribution, MCPToolDefinition } from '../../types';
+
+import { FileHandler } from './handlers/ReadFile';
+
+const inputSchema = z
+  .object({
+    relative_workspace_path: z.string().describe('The path of the file to read, relative to the workspace root.'),
+    should_read_entire_file: z.boolean().describe('Whether to read the entire file. Defaults to false.'),
+    start_line_one_indexed: z.number().describe('The one-indexed line number to start reading from (inclusive).'),
+    end_line_one_indexed_inclusive: z.number().describe('The one-indexed line number to end reading at (inclusive).'),
+    explanation: z
+      .string()
+      .describe('One sentence explanation as to why this tool is being used, and how it contributes to the goal.'),
+  })
+  .transform((data) => ({
+    relativeWorkspacePath: data.relative_workspace_path,
+    readEntireFile: data.should_read_entire_file,
+    startLineOneIndexed: data.start_line_one_indexed,
+    endLineOneIndexedInclusive: data.end_line_one_indexed_inclusive,
+  }));
+
+@Domain(MCPServerContribution)
+export class ReadFileTool implements MCPServerContribution {
+  @Autowired(FileHandler)
+  private readonly fileHandler: FileHandler;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'read_file',
+      description: `Read the contents of a file (and the outline).
+
+When using this tool to gather information, it's your responsibility to ensure you have the COMPLETE context. Each time you call this command you should:
+1) Assess if contents viewed are sufficient to proceed with the task.
+2) Take note of lines not shown.
+3) If file contents viewed are insufficient, and you suspect they may be in lines not shown, proactively call the tool again to view those lines.
+4) When in doubt, call this tool again to gather more information. Partial file views may miss critical dependencies, imports, or functionality.
+
+If reading a range of lines is not enough, you may choose to read the entire file.
+Reading entire files is often wasteful and slow, especially for large files (i.e. more than a few hundred lines). So you should use this option sparingly.
+Reading the entire file is not allowed in most cases. You are only allowed to read the entire file if it has been edited or manually attached to the conversation by the user.`,
+      inputSchema: zodToJsonSchema(inputSchema),
+      handler: this.handler.bind(this),
+    };
+  }
+
+  private async handler(args: z.infer<typeof inputSchema>, logger: MCPLogger) {
+    // TODO: 应该添加统一的 validate 逻辑
+    args = inputSchema.parse(args);
+    const result = await this.fileHandler.readFile(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.didShortenLineRange
+            ? `Contents of ${result.relativeWorkspacePath}, from line ${args.startLineOneIndexed}-${
+                args.endLineOneIndexedInclusive
+              }:
+
+\`\`\`
+// ${result.relativeWorkspacePath!.split('/').pop()}
+${result.contents}
+\`\`\``
+            : `Full contents of ${args.relativeWorkspacePath}:
+
+\`\`\`
+${result.contents}
+\`\`\``,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,80 @@
+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({
+  text: z.string().describe('The new content to replace the entire file with'),
+});
+
+@Domain(MCPServerContribution)
+export class ReplaceOpenEditorFileTool implements MCPServerContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  registerMCPServer(registry: IMCPServerRegistry): void {
+    registry.registerMCPTool(this.getToolDefinition());
+  }
+
+  getToolDefinition(): MCPToolDefinition {
+    return {
+      name: 'replace_open_in_editor_file_text',
+      description:
+        'Replaces the entire content of the currently active file in the IDE editor with specified new text. ' +
+        'Use this tool when you need to completely overwrite the current file\'s content. ' +
+        'Requires a text parameter containing the new content. ' +
+        'Returns one of three possible responses: ' +
+        '"ok" if the file content was successfully replaced, ' +
+        '"no file open" if no editor is active, ' +
+        '"unknown error" if the operation fails.',
+      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.monacoEditor) {
+        logger.appendLine('Error: No active text editor found');
+        return {
+          content: [{ type: 'text', text: 'no file open' }],
+          isError: true,
+        };
+      }
+
+      // Get the model and its full range
+      const model = editor.monacoEditor.getModel();
+      if (!model) {
+        logger.appendLine('Error: No model found for current editor');
+        return {
+          content: [{ type: 'text', text: 'unknown error' }],
+          isError: true,
+        };
+      }
+
+      const fullRange = model.getFullModelRange();
+
+      // Execute the replacement
+      editor.monacoEditor.executeEdits('mcp.tool.replace-file', [{
+        range: fullRange,
+        text: args.text,
+      }]);
+
+      logger.appendLine('Successfully replaced file content');
+      return {
+        content: [{ type: 'text', text: 'ok' }],
+      };
+    } catch (error) {
+      logger.appendLine(`Error during file content replacement: ${error}`);
+      return {
+        content: [{ type: 'text', text: 'unknown error' }],
+        isError: true,
+      };
+    }
+  }
+}