@opensumi/ide-ai-native 3.8.1-next-1740571693.0 → 3.8.1-next-1740625266.0

package/src/browser/mcp/base-apply.service.ts

@@ -1,16 +1,22 @@
 import { createPatch } from 'diff';
 
 import { Autowired } from '@opensumi/di';
-import { AppConfig, ChatMessageRole, IMarker, MarkerSeverity, OnEvent, WithEventBus } from '@opensumi/ide-core-browser';
+import { AppConfig, IChatProgress, IMarker, MarkerSeverity, OnEvent, WithEventBus } from '@opensumi/ide-core-browser';
 import { WorkbenchEditorService } from '@opensumi/ide-editor';
-import { EditorGroupCloseEvent } from '@opensumi/ide-editor/lib/browser';
+import {
+  EditorGroupCloseEvent,
+  EditorGroupOpenEvent,
+  RegisterEditorSideComponentEvent,
+} from '@opensumi/ide-editor/lib/browser';
 import { IMarkerService } from '@opensumi/ide-markers';
-import { Position, Range, Selection, SelectionDirection } from '@opensumi/ide-monaco';
-import { observableValue, transaction } from '@opensumi/ide-monaco/lib/common/observable';
-import { Deferred, URI, path } from '@opensumi/ide-utils';
+import { ICodeEditor, Position, Range, Selection, SelectionDirection } from '@opensumi/ide-monaco';
+import { Deferred, Emitter, URI, path } from '@opensumi/ide-utils';
+import { SumiReadableStream } from '@opensumi/ide-utils/lib/stream';
 
 import { IChatInternalService } from '../../common';
+import { CodeBlockData, CodeBlockStatus } from '../../common/types';
 import { ChatInternalService } from '../chat/chat.internal.service';
+import { InlineChatController } from '../widget/inline-chat/inline-chat-controller';
 import {
   BaseInlineDiffPreviewer,
   InlineDiffController,
@@ -41,6 +47,9 @@ export abstract class BaseApplyService extends WithEventBus {
   @Autowired(IMarkerService)
   private readonly markerService: IMarkerService;
 
+  private onCodeBlockUpdateEmitter = new Emitter<CodeBlockData>();
+  public onCodeBlockUpdate = this.onCodeBlockUpdateEmitter.event;
+
   constructor() {
     super();
     this.addDispose(
@@ -52,23 +61,32 @@ export abstract class BaseApplyService extends WithEventBus {
       this.chatInternalService.onRegenerateRequest(() => {
         const messages = this.chatInternalService.sessionModel.history.getMessages();
         const messageId = messages[messages.length - 1].id;
-        messageId && this.disposeApplyForMessage(messageId);
+        const codeBlockMap = this.getMessageCodeBlocks(messageId);
+        if (!codeBlockMap) {
+          return;
+        }
+        Object.values(codeBlockMap).forEach((blockData) => {
+          this.cancelApply(blockData);
+        });
       }),
     );
   }
 
-  public readonly codeBlockMapObservable = observableValue<Map<string, CodeBlockData>>(this, new Map());
+  private getMessageCodeBlocks(
+    messageId: string,
+    sessionId?: string,
+  ): { [toolCallId: string]: CodeBlockData } | undefined {
+    sessionId = sessionId || this.chatInternalService.sessionModel.sessionId;
+    const sessionModel = this.chatInternalService.getSession(sessionId);
+    if (!sessionModel) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const message = sessionModel.history.getMessageAdditional(messageId);
+    return message?.codeBlockMap;
+  }
 
   private activePreviewer: BaseInlineDiffPreviewer<InlineStreamDiffHandler> | undefined;
 
-  private pendingApplyParams:
-    | {
-        relativePath: string;
-        newContent: string;
-        range?: Range;
-      }
-    | undefined;
-
   @OnEvent(EditorGroupCloseEvent)
   onEditorGroupClose(event: EditorGroupCloseEvent) {
     if (this.activePreviewer?.getNode()?.uri.path.toString() === event.payload.resource.uri.path.toString()) {
@@ -77,187 +95,195 @@ export abstract class BaseApplyService extends WithEventBus {
     }
   }
 
-  /**
-   * Get the code block data by relative or absolute path of the last assistant message
-   */
-  getCodeBlock(relativeOrAbsolutePath: string, messageId?: string): CodeBlockData | undefined {
-    if (!relativeOrAbsolutePath) {
-      return undefined;
+  @OnEvent(EditorGroupOpenEvent)
+  async onEditorGroupOpen(event: EditorGroupOpenEvent) {
+    if (!this.chatInternalService.sessionModel.history.getMessages().length) {
+      return;
+    }
+    const relativePath = path.relative(this.appConfig.workspaceDir, event.payload.resource.uri.path.toString());
+    const filePendingApplies = Object.values(
+      this.getMessageCodeBlocks(this.chatInternalService.sessionModel.history.lastMessageId!) || {},
+    ).filter((block) => block.relativePath === relativePath && block.status === 'pending');
+    // TODO: 刷新后重新应用，事件无法恢复 & 恢复继续请求，需要改造成批量apply形式
+    // TODO: 暂时只支持 pending 串行的 apply，后续支持批量apply后统一accept
+    if (filePendingApplies.length > 0) {
+      this.renderApplyResult(filePendingApplies[0], filePendingApplies[0].updatedCode!);
     }
-    const blockId = this.generateBlockId(relativeOrAbsolutePath, messageId);
-    return this.codeBlockMapObservable.get().get(blockId);
   }
 
-  getCodeBlockById(id: string): CodeBlockData | undefined {
-    return this.codeBlockMapObservable.get().get(id);
+  getUriPendingCodeBlock(uri: URI): CodeBlockData | undefined {
+    const messageId = this.chatInternalService.sessionModel.history.lastMessageId;
+    if (!messageId) {
+      return undefined;
+    }
+    const codeBlockMap = this.getMessageCodeBlocks(messageId);
+    if (!codeBlockMap) {
+      return undefined;
+    }
+    return Object.values(codeBlockMap).find(
+      (block) =>
+        block.relativePath === path.relative(this.appConfig.workspaceDir, uri.path.toString()) &&
+        block.status === 'pending',
+    );
   }
 
-  protected updateCodeBlock(codeBlock: CodeBlockData) {
-    const codeBlockMap = new Map(this.codeBlockMapObservable.get());
-    codeBlockMap.set(codeBlock.id, codeBlock);
-    transaction((tx) => {
-      this.codeBlockMapObservable.set(codeBlockMap, tx);
-    });
+  getCodeBlock(toolCallId: string, messageId?: string): CodeBlockData | undefined {
+    messageId = messageId || this.chatInternalService.sessionModel.history.lastMessageId;
+    if (!messageId) {
+      throw new Error('Message ID is required');
+    }
+    const codeBlockMap = this.getMessageCodeBlocks(messageId);
+    if (!codeBlockMap) {
+      return undefined;
+    }
+    return codeBlockMap[toolCallId];
   }
 
-  /**
-   * Register a new code block and return its unique ID
-   */
-  registerCodeBlock(relativePath: string, content: string): string {
-    const blockId = this.generateBlockId(relativePath);
-
-    if (!this.codeBlockMapObservable.get().has(blockId)) {
-      this.codeBlockMapObservable.get().set(blockId, {
-        id: blockId,
-        content,
-        relativePath,
-        status: 'generating',
-        iterationCount: 0,
-        createdAt: Date.now(),
-      });
+  protected updateCodeBlock(codeBlock: CodeBlockData, messageId?: string) {
+    messageId = messageId || this.chatInternalService.sessionModel.history.lastMessageId;
+    if (!messageId) {
+      throw new Error('Message ID is required');
     }
-
-    return blockId;
+    const codeBlockMap = this.getMessageCodeBlocks(messageId);
+    if (!codeBlockMap) {
+      throw new Error('Code block not found');
+    }
+    codeBlockMap[codeBlock.toolCallId] = codeBlock;
+    this.chatInternalService.sessionModel.history.setMessageAdditional(messageId, {
+      codeBlockMap,
+    });
+    this.onCodeBlockUpdateEmitter.fire(codeBlock);
   }
 
-  initToolCallId(blockId: string, toolCallId: string): void {
-    const blockData = this.getCodeBlockById(blockId);
-    if (blockData && !blockData.initToolCallId) {
-      blockData.initToolCallId = toolCallId;
+  registerCodeBlock(relativePath: string, content: string, toolCallId: string): CodeBlockData {
+    const lastMessageId = this.chatInternalService.sessionModel.history.lastMessageId!;
+    const savedCodeBlockMap = this.getMessageCodeBlocks(lastMessageId) || {};
+    const newBlock: CodeBlockData = {
+      codeEdit: content,
+      relativePath,
+      status: 'generating' as CodeBlockStatus,
+      iterationCount: 1,
+      version: 1,
+      createdAt: Date.now(),
+      toolCallId,
+    };
+    const samePathCodeBlocks = Object.values(savedCodeBlockMap).filter((block) => block.relativePath === relativePath);
+    if (samePathCodeBlocks.length > 0) {
+      newBlock.version = samePathCodeBlocks.length;
+      for (const block of samePathCodeBlocks.sort((a, b) => b.version - a.version)) {
+        // 如果连续的上一个同文件apply结果存在LintError，则iterationCount++
+        if (block.relativePath === relativePath && block.applyResult?.diagnosticInfos?.length) {
+          newBlock.iterationCount++;
+        } else {
+          break;
+        }
+      }
     }
+    savedCodeBlockMap[toolCallId] = newBlock;
+    this.chatInternalService.sessionModel.history.setMessageAdditional(lastMessageId, {
+      codeBlockMap: savedCodeBlockMap,
+    });
+    this.onCodeBlockUpdateEmitter.fire(newBlock);
+    return newBlock;
   }
 
   /**
    * Apply changes of a code block
    */
-  async apply(relativePath: string, newContent: string, instructions?: string): Promise<CodeBlockData> {
-    const blockData = this.getCodeBlock(relativePath);
-    if (!blockData) {
-      throw new Error('Code block not found');
-    }
+  async apply(codeBlock: CodeBlockData): Promise<CodeBlockData> {
     try {
-      if (++blockData.iterationCount > 3) {
-        throw new Error('Max iteration count exceeded');
+      if (codeBlock.iterationCount > 3) {
+        throw new Error('Lint error max iteration count exceeded');
       }
-      blockData.status = 'generating';
-      blockData.content = newContent;
-      this.updateCodeBlock(blockData);
-      const applyDiffResult = await this.doApply(relativePath, newContent, instructions);
-      blockData.applyResult = applyDiffResult;
-      this.updateCodeBlock(blockData);
-      return blockData;
+      const fastApplyFileResult = await this.doApply(codeBlock);
+      if (!fastApplyFileResult.stream && !fastApplyFileResult.result) {
+        throw new Error('No apply content provided');
+      }
+
+      // trigger diffPreivewer & return expected diff result directly
+      const applyResult = await this.renderApplyResult(
+        codeBlock,
+        (fastApplyFileResult.result || fastApplyFileResult.stream)!,
+        fastApplyFileResult.range,
+      );
+      if (applyResult) {
+        // 用户实际接受的 apply 结果
+        codeBlock.applyResult = applyResult;
+        this.updateCodeBlock(codeBlock);
+      }
+
+      return codeBlock;
     } catch (err) {
-      blockData.status = 'failed';
-      this.updateCodeBlock(blockData);
+      codeBlock.status = 'failed';
+      this.updateCodeBlock(codeBlock);
       throw err;
     }
   }
 
-  async reRenderPendingApply() {
-    if (!this.pendingApplyParams) {
-      throw new Error('No pending apply params');
-    }
-    const result = await this.renderApplyResult(
-      this.pendingApplyParams.relativePath,
-      this.pendingApplyParams.newContent,
-      this.pendingApplyParams.range,
-    );
-    if (result) {
-      const blockData = this.getCodeBlock(this.pendingApplyParams.relativePath)!;
-      blockData.applyResult = result;
-      this.updateCodeBlock(blockData);
-    }
-  }
-
   async renderApplyResult(
-    relativePath: string,
-    newContent: string,
+    codeBlock: CodeBlockData,
+    updatedContentOrStream: string | SumiReadableStream<IChatProgress>,
     range?: Range,
   ): Promise<{ diff: string; diagnosticInfos: IMarker[] } | undefined> {
-    // 用户可能会关闭编辑器，所以需要缓存参数
-    this.pendingApplyParams = {
-      relativePath,
-      newContent,
-      range,
-    };
-    const blockData = this.getCodeBlock(relativePath);
-    if (!blockData) {
-      throw new Error('Code block not found');
-    }
+    const { relativePath } = codeBlock;
     const openResult = await this.editorService.open(URI.file(path.join(this.appConfig.workspaceDir, relativePath)));
     if (!openResult) {
       throw new Error('Failed to open editor');
     }
     const editor = openResult.group.codeEditor.monacoEditor;
     const inlineDiffController = InlineDiffController.get(editor)!;
-    blockData.status = 'pending';
-    this.updateCodeBlock(blockData);
-
-    range = range || editor.getModel()?.getFullModelRange()!;
-    // Create diff previewer
-    const previewer = inlineDiffController.createDiffPreviewer(
-      editor,
-      Selection.fromRange(range, SelectionDirection.LTR),
-      {
-        disposeWhenEditorClosed: true,
-        renderRemovedWidgetImmediately: true,
-      },
-    ) as LiveInlineDiffPreviewer;
-    this.activePreviewer = previewer;
+    codeBlock.status = 'pending';
+    // 强刷展示 manager 视图
+    this.eventBus.fire(new RegisterEditorSideComponentEvent());
+    this.updateCodeBlock(codeBlock);
 
     const fullOriginalContent = editor.getModel()!.getValue();
-    const savedContent = editor.getModel()!.getValueInRange(range);
-    const deferred = new Deferred<{ diff: string; diagnosticInfos: IMarker[] }>();
-    if (newContent === savedContent) {
-      blockData.status = 'success';
-      deferred.resolve();
+    range = range || editor.getModel()?.getFullModelRange()!;
+    // const savedRangeContent = editor.getModel()!.getValueInRange(range);
+
+    if (typeof updatedContentOrStream === 'string') {
+      // Create diff previewer
+      const previewer = inlineDiffController.createDiffPreviewer(
+        editor,
+        Selection.fromRange(range, SelectionDirection.LTR),
+        {
+          disposeWhenEditorClosed: true,
+          renderRemovedWidgetImmediately: true,
+        },
+      ) as LiveInlineDiffPreviewer;
+      // TODO: 支持多个diffPreviewer
+      this.activePreviewer = previewer;
+      codeBlock.updatedCode = updatedContentOrStream;
+      previewer.setValue(updatedContentOrStream);
     } else {
-      previewer.setValue(newContent);
+      const controller = new InlineChatController();
+      controller.mountReadable(updatedContentOrStream);
+      const inlineDiffHandler = InlineDiffController.get(editor)!;
+
+      this.activePreviewer = inlineDiffHandler.showPreviewerByStream(editor, {
+        crossSelection: Selection.fromRange(range, SelectionDirection.LTR),
+        chatResponse: controller,
+        previewerOptions: {
+          disposeWhenEditorClosed: true,
+          renderRemovedWidgetImmediately: false,
+        },
+      }) as LiveInlineDiffPreviewer;
       this.addDispose(
-        this.inlineDiffService.onPartialEdit((event) => {
-          // TODO 支持自动保存
-          if (event.totalPartialEditCount === event.resolvedPartialEditCount) {
-            if (event.acceptPartialEditCount > 0) {
-              blockData.status = 'success';
-              const appliedResult = editor.getModel()!.getValue();
-              const diffResult = createPatch(relativePath, fullOriginalContent, appliedResult)
-                .split('\n')
-                .slice(4)
-                .join('\n');
-              const rangesFromDiffHunk = diffResult
-                .split('\n')
-                .map((line) => {
-                  if (line.startsWith('@@')) {
-                    const [, , , start, end] = line.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
-                    return new Range(parseInt(start, 10), 0, parseInt(end, 10), 0);
-                  }
-                  return null;
-                })
-                .filter((range) => range !== null);
-              const diagnosticInfos = this.getdiagnosticInfos(editor.getModel()!.uri.toString(), rangesFromDiffHunk);
-              // 移除开头的几个固定信息，避免浪费 tokens
-              deferred.resolve({
-                diff: diffResult,
-                diagnosticInfos,
-              });
-            } else {
-              // 用户全部取消
-              blockData.status = 'cancelled';
-              deferred.resolve();
-            }
-          }
+        this.activePreviewer.getNode()!.onDiffFinished((diffModel) => {
+          codeBlock.updatedCode = diffModel.newFullRangeTextLines.join('\n');
+          this.updateCodeBlock(codeBlock);
         }),
       );
     }
-    return deferred.promise;
+
+    return this.listenPartialEdit(editor, codeBlock, fullOriginalContent);
   }
 
   /**
    * Cancel an ongoing apply operation
    */
-  cancelApply(relativePath: string): void {
-    const blockData = this.getCodeBlock(relativePath);
-    if (blockData && (blockData.status === 'generating' || blockData.status === 'pending')) {
+  cancelApply(blockData: CodeBlockData): void {
+    if (blockData.status === 'generating' || blockData.status === 'pending') {
       if (this.activePreviewer) {
         this.activePreviewer.getNode()?.livePreviewDiffDecorationModel.discardUnProcessed();
         this.activePreviewer.dispose();
@@ -267,62 +293,105 @@ export abstract class BaseApplyService extends WithEventBus {
     }
   }
 
+  // TODO: 目前的设计下，有一个工具 apply 没返回，是不会触发下一个的(cursor 是会全部自动 apply 的），所以这个方法目前还没有必要
   cancelAllApply(): void {
-    this.codeBlockMapObservable.get().forEach((blockData) => {
-      if (blockData.status === 'generating' || blockData.status === 'pending') {
-        this.cancelApply(blockData.relativePath);
-      }
+    const messageId = this.chatInternalService.sessionModel.history.lastMessageId!;
+    const codeBlockMap = this.getMessageCodeBlocks(messageId);
+    if (!codeBlockMap) {
+      return;
+    }
+    Object.values(codeBlockMap).forEach((blockData) => {
+      this.cancelApply(blockData);
     });
   }
 
-  disposeApplyForMessage(messageId: string): void {
-    this.codeBlockMapObservable.get().forEach((blockData) => {
-      if (blockData.id.endsWith(':' + messageId)) {
-        if (blockData.status === 'generating') {
-          this.cancelApply(blockData.relativePath);
-        }
-        this.codeBlockMapObservable.get().delete(blockData.id);
-      }
-    });
+  revealApplyPosition(blockData: CodeBlockData): void {
+    const hunkInfo = blockData.applyResult?.diff.split('\n').find((line) => line.startsWith('@@'));
+    let startLine = 0;
+    let endLine = 0;
+    if (hunkInfo) {
+      // 取改动后的区间
+      const [, , , start, end] = hunkInfo.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
+      startLine = parseInt(start, 10) - 1;
+      endLine = parseInt(end, 10) - 1;
+    }
+    this.editorService.open(URI.file(path.join(this.appConfig.workspaceDir, blockData.relativePath)));
+    const editor = this.editorService.currentEditor;
+    if (editor) {
+      editor.setSelection(new Selection(startLine, 0, endLine, 0));
+    }
   }
 
-  revealApplyPosition(blockId: string): void {
-    const blockData = this.codeBlockMapObservable.get().get(blockId);
-    if (blockData) {
-      const hunkInfo = blockData.applyResult?.diff.split('\n').find((line) => line.startsWith('@@'));
-      let startLine = 0;
-      let endLine = 0;
-      if (hunkInfo) {
-        // 取改动后的区间
-        const [, , , start, end] = hunkInfo.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
-        startLine = parseInt(start, 10) - 1;
-        endLine = parseInt(end, 10) - 1;
-      }
-      this.editorService.open(URI.file(path.join(this.appConfig.workspaceDir, blockData.relativePath)));
-      const editor = this.editorService.currentEditor;
-      if (editor) {
-        editor.setSelection(new Selection(startLine, 0, endLine, 0));
-      }
+  processAll(uri: URI, type: 'accept' | 'reject'): void {
+    const codeBlock = this.getUriPendingCodeBlock(uri);
+    if (!codeBlock) {
+      throw new Error('No pending code block found');
     }
+    const decorationModel = this.activePreviewer?.getNode()?.livePreviewDiffDecorationModel;
+    if (!decorationModel) {
+      throw new Error('No active previewer found');
+    }
+    if (type === 'accept') {
+      decorationModel.acceptUnProcessed();
+    } else {
+      decorationModel.discardUnProcessed();
+    }
+    this.editorService.save(uri);
+    codeBlock.status = type === 'accept' ? 'success' : 'cancelled';
+    this.updateCodeBlock(codeBlock);
   }
 
-  protected abstract doApply(
-    relativePath: string,
-    newContent: string,
-    instructions?: string,
-  ): Promise<{ diff: string; diagnosticInfos: IMarker[] } | undefined>;
-
-  protected generateBlockId(absoluteOrRelativePath: string, messageId?: string): string {
-    if (!absoluteOrRelativePath.startsWith('/')) {
-      absoluteOrRelativePath = path.join(this.appConfig.workspaceDir, absoluteOrRelativePath);
-    }
-    const sessionId = this.chatInternalService.sessionModel.sessionId;
-    const messages = this.chatInternalService.sessionModel.history.getMessages();
-    messageId = messageId || messages[messages.length - 1].id;
-    return `${sessionId}:${absoluteOrRelativePath}:${messageId || '-'}`;
+  protected listenPartialEdit(editor: ICodeEditor, codeBlock: CodeBlockData, fullOriginalContent: string) {
+    const deferred = new Deferred<{ diff: string; diagnosticInfos: IMarker[] }>();
+    const toDispose = this.inlineDiffService.onPartialEdit((event) => {
+      // TODO 支持自动保存
+      if (event.totalPartialEditCount === event.resolvedPartialEditCount) {
+        if (event.acceptPartialEditCount > 0) {
+          codeBlock.status = 'success';
+          const appliedResult = editor.getModel()!.getValue();
+          const diffResult = createPatch(codeBlock.relativePath, fullOriginalContent, appliedResult)
+            .split('\n')
+            .slice(4)
+            .join('\n');
+          const rangesFromDiffHunk = diffResult
+            .split('\n')
+            .map((line) => {
+              if (line.startsWith('@@')) {
+                const [, , , start, end] = line.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)!;
+                return new Range(parseInt(start, 10), 0, parseInt(end, 10), 0);
+              }
+              return null;
+            })
+            .filter((range) => range !== null);
+          const diagnosticInfos = this.getDiagnosticInfos(editor.getModel()!.uri.toString(), rangesFromDiffHunk);
+          // 移除开头的几个固定信息，避免浪费 tokens
+          deferred.resolve({
+            diff: diffResult,
+            diagnosticInfos,
+          });
+        } else {
+          // 用户全部取消
+          codeBlock.status = 'cancelled';
+          deferred.resolve();
+        }
+        toDispose.dispose();
+      }
+    });
+    return deferred.promise;
   }
 
-  protected getdiagnosticInfos(uri: string, ranges: Range[]) {
+  /**
+   * Apply changes of a code block, return stream to render inline diff in stream mode, result to render inline diff directly
+   * range is optional, if not provided, the result will be applied to the the full file
+   */
+  protected abstract doApply(codeBlock: CodeBlockData): Promise<{
+    range?: Range;
+    stream?: SumiReadableStream<IChatProgress, Error>;
+    result?: string;
+  }>;
+
+  // TODO: 支持使用内存中的document获取诊断信息，实现并行apply accept
+  protected getDiagnosticInfos(uri: string, ranges: Range[]) {
     const markers = this.markerService.getManager().getMarkers({ resource: uri });
     return markers.filter(
       (marker) =>
@@ -331,19 +400,3 @@ export abstract class BaseApplyService extends WithEventBus {
     );
   }
 }
-
-export interface CodeBlockData {
-  id: string;
-  initToolCallId?: string;
-  content: string;
-  relativePath: string;
-  status: CodeBlockStatus;
-  iterationCount: number;
-  createdAt: number;
-  applyResult?: {
-    diff: string;
-    diagnosticInfos: IMarker[];
-  };
-}
-
-export type CodeBlockStatus = 'generating' | 'pending' | 'success' | 'rejected' | 'failed' | 'cancelled';