@opensumi/ide-ai-native 3.2.5 → 3.2.6-next-1724809247.0

package/src/browser/contrib/inline-completions/promptCache.ts

@@ -3,13 +3,14 @@ import {
   AINativeSettingSectionsId,
   DisposableStore,
   IAICompletionOption,
-  IAICompletionResultModel,
   IDisposable,
   PreferenceService,
   StaleLRUMap,
 } from '@opensumi/ide-core-browser';
 import { IHashCalculateService } from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
 
+import { IIntelligentCompletionsResult } from '../intelligent-completions/intelligent-completions';
+
 /**
  * 缓存服务
  * 1. 过期时间为 1min
@@ -25,7 +26,7 @@ export class PromptCache implements IDisposable {
   @Autowired(PreferenceService)
   private preferenceService: PreferenceService;
 
-  private cacheMap = new StaleLRUMap<string, IAICompletionResultModel & { relationId: string }>(15, 10, 60 * 1000);
+  private cacheMap = new StaleLRUMap<string, IIntelligentCompletionsResult & { relationId: string }>(15, 10, 60 * 1000);
 
   protected calculateCacheKey(requestBean: IAICompletionOption) {
     const content = requestBean.prompt;

package/src/browser/contrib/inline-completions/service/ai-completions.service.ts

@@ -10,11 +10,13 @@ import {
   IAICompletionOption,
   IAICompletionResultModel,
   IAIReportCompletionOption,
+  IntelligentCompletionsRegistryToken,
 } from '@opensumi/ide-core-common';
 import { CompletionRT, IAIReporter } from '@opensumi/ide-core-common/lib/types/ai-native/reporter';
-import * as monaco from '@opensumi/ide-monaco';
 
-import { IProvideInlineCompletionsSignature } from '../../../types';
+import { IIntelligentCompletionsResult } from '../../intelligent-completions/intelligent-completions';
+import { IntelligentCompletionsRegistry } from '../../intelligent-completions/intelligent-completions.feature.registry';
+import { IntelligentCompletionsHandler } from '../../intelligent-completions/intelligent-completions.handler';
 
 @Injectable()
 export class AICompletionsService extends Disposable {
@@ -29,6 +31,12 @@ export class AICompletionsService extends Disposable {
   @Autowired(IAIReporter)
   private readonly aiReporter: IAIReporter;
 
+  @Autowired(IntelligentCompletionsRegistryToken)
+  private readonly intelligentCompletionsRegistry: IntelligentCompletionsRegistry;
+
+  @Autowired(IntelligentCompletionsHandler)
+  private readonly intelligentCompletionsHandler: IntelligentCompletionsHandler;
+
   private readonly _onVisibleCompletion = new Emitter<boolean>();
   public readonly onVisibleCompletion: Event<boolean> = this._onVisibleCompletion.event;
 
@@ -43,8 +51,6 @@ export class AICompletionsService extends Disposable {
   private lastRelationId: string;
   private lastRenderTime: number;
   private lastCompletionUseTime: number;
-  // 中间件拓展 inlinecompletion
-  private lastMiddlewareInlineCompletion?: IProvideInlineCompletionsSignature;
 
   protected validCompletionThreshold = 750;
 
@@ -60,41 +66,36 @@ export class AICompletionsService extends Disposable {
     return this._isVisibleCompletion;
   }
 
-  public async complete(
-    data: IAICompletionOption,
-    model: monaco.editor.ITextModel,
-    position: monaco.Position,
-    token: monaco.CancellationToken,
-  ): Promise<IAICompletionResultModel | null> {
-    const doCompletion = async (data: IAICompletionOption) => {
-      if (!this.aiBackService.requestCompletion) {
-        return null;
-      }
-
-      try {
-        this.isDefaultCompletionModel = true;
-        const completionStart = Date.now();
-        const result = (await this.aiBackService.requestCompletion(
-          data,
-          this.cancelIndicator.token,
-        )) as IAICompletionResultModel;
-        this.recordCompletionUseTime(completionStart);
-        return result;
-      } catch (error) {
-        return null;
-      }
-    };
+  public async complete(data: IAICompletionOption): Promise<IIntelligentCompletionsResult | undefined> {
+    this.isDefaultCompletionModel = true;
+    const completionStart = Date.now();
 
-    if (this.lastMiddlewareInlineCompletion) {
-      this.isDefaultCompletionModel = false;
-      return this.lastMiddlewareInlineCompletion(model, position, token, doCompletion, data);
-    }
+    const provider = this.intelligentCompletionsRegistry.getProvider();
 
-    return doCompletion(data);
-  }
+    if (provider) {
+      return this.intelligentCompletionsHandler.fetchProvider(data);
+    }
 
-  public setMiddlewareComplete(provideInlineCompletions: IProvideInlineCompletionsSignature): void {
-    this.lastMiddlewareInlineCompletion = provideInlineCompletions;
+    // 兼容旧的 requestCompletion 接口
+    try {
+      const result = (await this.aiBackService.requestCompletion?.(
+        data,
+        this.cancelIndicator.token,
+      )) as IAICompletionResultModel;
+      this.recordCompletionUseTime(completionStart);
+
+      const { sessionId, codeModelList, isCancel } = result;
+
+      return {
+        items: codeModelList.map((model) => ({ ...model, insertText: model.content })),
+        extra: {
+          sessionId,
+          isCancel,
+        },
+      };
+    } catch (error) {
+      return;
+    }
   }
 
   public async report(data: IAIReportCompletionOption) {

package/src/browser/contrib/intelligent-completions/diff-computer.ts

@@ -0,0 +1,185 @@
+import { empty } from '@opensumi/ide-utils/lib/strings';
+
+/**
+ * @internal
+ */
+export interface IDiffChangeResult {
+  added?: boolean;
+  removed?: boolean;
+  value: string;
+}
+
+interface IResultWithCount extends IDiffChangeResult {
+  count: number;
+}
+
+interface IElement {
+  newPos: number;
+  changeResult: IResultWithCount[];
+}
+
+export class MultiLineDiffComputer {
+  private equals(a: string, b: string | undefined): boolean {
+    return a === b;
+  }
+
+  private extractCommon(element: IElement, modified: string[], original: string[], diagonal: number): number {
+    const modifiedLength = modified.length;
+    const originalLength = original.length;
+
+    let newPos = element.newPos;
+    let originalPos = newPos - diagonal;
+    let commonCount = 0;
+
+    while (
+      newPos + 1 < modifiedLength &&
+      originalPos + 1 < originalLength &&
+      this.equals(modified[newPos + 1], original[originalPos + 1])
+    ) {
+      // 如果相等，则移动到下一个位置并计数加一
+      newPos++;
+      originalPos++;
+      commonCount++;
+    }
+
+    // 如果找到公共部分，则记录新位置
+    if (commonCount) {
+      element.changeResult.push({ count: commonCount, value: empty });
+      element.newPos = newPos;
+    }
+
+    return originalPos;
+  }
+
+  public diff(originalContent: string, modifiedContent: string): IResultWithCount[] | undefined {
+    const cloneElement = (element: IElement): IElement => ({
+      newPos: element.newPos,
+      changeResult: [...element.changeResult],
+    });
+    const join = (content: string[]) => content.join(empty);
+
+    const processElements = (changeResult: IResultWithCount[], modified: string[], original: string[]) => {
+      const modifiedLength = changeResult.length;
+
+      let originalIndex = 0;
+      let modifiedIndex = 0;
+      let originalCount = 0;
+
+      for (; originalIndex < modifiedLength; originalIndex++) {
+        const changeItem = changeResult[originalIndex];
+        // 如果标记为删除，则从原始内容中提取对应的值
+        if (changeItem.removed) {
+          changeItem.value = join(original.slice(originalCount, originalCount + changeItem.count));
+          originalCount += changeItem.count;
+          // 如果前一个元素被标记为添加，则交换位置
+          if (originalIndex && changeResult[originalIndex - 1].added) {
+            [changeResult[originalIndex - 1], changeResult[originalIndex]] = [
+              changeResult[originalIndex],
+              changeResult[originalIndex - 1],
+            ];
+          }
+        } else {
+          changeItem.value = join(modified.slice(modifiedIndex, modifiedIndex + changeItem.count));
+          modifiedIndex += changeItem.count;
+
+          if (!changeItem.added) {
+            originalCount += changeItem.count;
+          }
+        }
+      }
+
+      // 如果最后一个元素是空字符串，则合并到前一个元素当中
+      if (
+        modifiedLength > 1 &&
+        typeof changeResult[modifiedLength - 1].value === 'string' &&
+        (changeResult[modifiedLength - 1].added || changeResult[modifiedLength - 1].removed) &&
+        this.equals(empty, changeResult[modifiedLength - 1].value)
+      ) {
+        changeResult[modifiedLength - 2].value += changeResult[modifiedLength - 1].value;
+        changeResult.pop();
+      }
+      return changeResult;
+    };
+
+    const tokenizeOriginal = originalContent.split(empty).filter(Boolean);
+    const tokenizeModified = modifiedContent.split(empty).filter(Boolean);
+    const originalLength = tokenizeOriginal.length;
+    const modifiedLength = tokenizeModified.length;
+    const maxLength = originalLength + modifiedLength;
+
+    const elements: Array<IElement | undefined> = [{ newPos: -1, changeResult: [] }];
+    const initialDiagonal = this.extractCommon(elements[0]!, tokenizeModified, tokenizeOriginal, 0);
+
+    const pushElement = (changeResult: IResultWithCount[], added?: boolean, removed?: boolean) => {
+      const len = changeResult.length;
+      const latestResult = changeResult[len - 1];
+      if (len > 0 && latestResult.added === added && latestResult.removed === removed) {
+        changeResult[len - 1] = { count: latestResult.count + 1, added, removed, value: empty };
+      } else {
+        changeResult.push({ count: 1, added, removed, value: empty });
+      }
+    };
+
+    let diagonal = 1;
+
+    // 如果初始位置加 1 大于或等于原始长度，并且初始的公共部分的位置加 1 大于或等于修改后的长度，则直接返回修改后的内容
+    if (elements[0]!.newPos + 1 >= originalLength && initialDiagonal + 1 >= modifiedLength) {
+      return [
+        {
+          value: join(tokenizeModified),
+          count: tokenizeModified.length,
+        },
+      ];
+    }
+
+    const execDiff = () => {
+      for (let diagonalIndex = -diagonal; diagonalIndex <= diagonal; diagonalIndex += 2) {
+        const leftElement = elements[diagonalIndex - 1];
+        const rightElement = elements[diagonalIndex + 1];
+
+        let element: IElement;
+        let originalPos = (rightElement ? rightElement.newPos : 0) - diagonalIndex;
+
+        // 如果左边有元素，则将其标记为未知
+        if (leftElement) {
+          elements[diagonalIndex - 1] = undefined;
+        }
+
+        const canMoveLeft = leftElement && leftElement.newPos + 1 < modifiedLength;
+        const canMoveRight = rightElement && 0 <= originalPos && originalPos < originalLength;
+
+        // 如果不能向左或向右移动，则跳过
+        if (!canMoveLeft && !canMoveRight) {
+          elements[diagonalIndex] = undefined;
+          continue;
+        }
+
+        // 根据移动方向选择元素
+        if (!canMoveLeft || (canMoveRight && leftElement.newPos < rightElement.newPos)) {
+          element = cloneElement(rightElement!);
+          pushElement(element.changeResult, undefined, true);
+        } else {
+          element = leftElement;
+          element.newPos++;
+          pushElement(element.changeResult, true, undefined);
+        }
+
+        originalPos = this.extractCommon(element, tokenizeModified, tokenizeOriginal, diagonalIndex);
+
+        if (element.newPos + 1 >= modifiedLength && originalPos + 1 >= originalLength) {
+          return processElements(element.changeResult, tokenizeModified, tokenizeOriginal);
+        }
+
+        elements[diagonalIndex] = element;
+      }
+      diagonal++;
+    };
+
+    while (diagonal <= maxLength) {
+      const diffResult = execDiff();
+      if (diffResult) {
+        return diffResult;
+      }
+    }
+  }
+}

package/src/browser/contrib/intelligent-completions/intelligent-completions.contribution.ts

@@ -0,0 +1,54 @@
+import { Autowired } from '@opensumi/di';
+import { Key } from '@opensumi/ide-core-browser';
+import {
+  ClientAppContribution,
+  KeybindingContribution,
+  KeybindingRegistry,
+  KeybindingScope,
+} from '@opensumi/ide-core-browser';
+import {
+  AI_MULTI_LINE_COMPLETION_ACCEPT,
+  AI_MULTI_LINE_COMPLETION_HIDE,
+} from '@opensumi/ide-core-browser/lib/ai-native/command';
+import { MultiLineCompletionsIsVisible } from '@opensumi/ide-core-browser/lib/contextkey/ai-native';
+import { CommandContribution, CommandRegistry, Domain } from '@opensumi/ide-core-common';
+
+import { IntelligentCompletionsHandler } from './intelligent-completions.handler';
+
+@Domain(ClientAppContribution, KeybindingContribution, CommandContribution)
+export class IntelligentCompletionsContribution implements KeybindingContribution, CommandContribution {
+  @Autowired(IntelligentCompletionsHandler)
+  private readonly intelligentCompletionsHandler: IntelligentCompletionsHandler;
+
+  registerCommands(commands: CommandRegistry): void {
+    commands.registerCommand(AI_MULTI_LINE_COMPLETION_HIDE, {
+      execute: () => {
+        this.intelligentCompletionsHandler.hide();
+      },
+    });
+
+    commands.registerCommand(AI_MULTI_LINE_COMPLETION_ACCEPT, {
+      execute: () => {
+        this.intelligentCompletionsHandler.accept();
+      },
+    });
+  }
+
+  registerKeybindings(keybindings: KeybindingRegistry): void {
+    keybindings.registerKeybinding({
+      command: AI_MULTI_LINE_COMPLETION_HIDE.id,
+      keybinding: Key.ESCAPE.code,
+      when: MultiLineCompletionsIsVisible.raw,
+      priority: 100,
+    });
+
+    keybindings.registerKeybinding(
+      {
+        command: AI_MULTI_LINE_COMPLETION_ACCEPT.id,
+        keybinding: Key.TAB.code,
+        when: MultiLineCompletionsIsVisible.raw,
+      },
+      KeybindingScope.USER,
+    );
+  }
+}

package/src/browser/contrib/intelligent-completions/intelligent-completions.feature.registry.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@opensumi/di';
+import { Disposable } from '@opensumi/ide-core-common';
+
+import { IIntelligentCompletionProvider, IIntelligentCompletionsRegistry } from '../../types';
+
+@Injectable()
+export class IntelligentCompletionsRegistry extends Disposable implements IIntelligentCompletionsRegistry {
+  private provider: IIntelligentCompletionProvider | undefined;
+
+  registerIntelligentCompletionProvider(provider: IIntelligentCompletionProvider): void {
+    this.provider = provider;
+  }
+
+  getProvider(): IIntelligentCompletionProvider | undefined {
+    return this.provider;
+  }
+}

package/src/browser/contrib/intelligent-completions/intelligent-completions.handler.ts

@@ -0,0 +1,130 @@
+import { Autowired, INJECTOR_TOKEN, Injectable, Injector } from '@opensumi/di';
+import {
+  CancellationTokenSource,
+  Disposable,
+  IAICompletionOption,
+  IDisposable,
+  IntelligentCompletionsRegistryToken,
+} from '@opensumi/ide-core-common';
+import { IEditor } from '@opensumi/ide-editor';
+import { ICodeEditor, Position } from '@opensumi/ide-monaco';
+import { EditOperation } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/editOperation';
+
+import { AINativeContextKey } from '../../contextkey/ai-native.contextkey.service';
+
+import { MultiLineDiffComputer } from './diff-computer';
+import { IIntelligentCompletionsResult } from './intelligent-completions';
+import { IntelligentCompletionsRegistry } from './intelligent-completions.feature.registry';
+import { MultiLineDecorationModel } from './multi-line.decoration';
+
+@Injectable()
+export class IntelligentCompletionsHandler extends Disposable {
+  @Autowired(INJECTOR_TOKEN)
+  private readonly injector: Injector;
+
+  @Autowired(IntelligentCompletionsRegistryToken)
+  private intelligentCompletionsRegistry: IntelligentCompletionsRegistry;
+
+  private cancelIndicator = new CancellationTokenSource();
+
+  private cancelToken() {
+    this.cancelIndicator.cancel();
+    this.cancelIndicator = new CancellationTokenSource();
+  }
+
+  private multiLineDiffComputer: MultiLineDiffComputer = new MultiLineDiffComputer();
+  private multiLineDecorationModel: MultiLineDecorationModel;
+
+  private editor: IEditor;
+  private aiNativeContextKey: AINativeContextKey;
+
+  private get monacoEditor(): ICodeEditor {
+    return this.editor.monacoEditor;
+  }
+
+  public async fetchProvider(bean: IAICompletionOption): Promise<IIntelligentCompletionsResult | undefined> {
+    const provider = this.intelligentCompletionsRegistry.getProvider();
+    if (!provider) {
+      return;
+    }
+
+    const position = this.monacoEditor.getPosition()!;
+    const intelligentCompletionModel = await provider(this.monacoEditor, position, bean, this.cancelIndicator.token);
+
+    if (
+      intelligentCompletionModel &&
+      intelligentCompletionModel.enableMultiLine &&
+      intelligentCompletionModel.items.length > 0
+    ) {
+      return this.applyInlineDecorations(intelligentCompletionModel);
+    }
+
+    return intelligentCompletionModel;
+  }
+
+  public applyInlineDecorations(completionModel: IIntelligentCompletionsResult) {
+    const { items } = completionModel;
+
+    const position = this.monacoEditor.getPosition()!;
+    const model = this.monacoEditor.getModel();
+    const { range, insertText } = items[0];
+
+    // 如果只是开启了 enableMultiLine 而没有传递 range ，则不显示 multi line
+    if (!range) {
+      return completionModel;
+    }
+
+    const originalContent = model?.getValueInRange(range);
+
+    const diffComputerResult = this.multiLineDiffComputer.diff(originalContent!, insertText.toString());
+
+    if (diffComputerResult) {
+      const inlineModifications = this.multiLineDecorationModel.applyInlineDecorations(
+        this.monacoEditor,
+        diffComputerResult,
+        position.lineNumber,
+        position,
+      );
+
+      if (inlineModifications) {
+        this.aiNativeContextKey.multiLineCompletionsIsVisible.set(true);
+        this.multiLineDecorationModel.updateLineModificationDecorations(inlineModifications);
+      } else {
+        this.aiNativeContextKey.multiLineCompletionsIsVisible.reset();
+        this.multiLineDecorationModel.clearDecorations();
+      }
+    }
+  }
+
+  public hide() {
+    this.cancelToken();
+    this.aiNativeContextKey.multiLineCompletionsIsVisible.reset();
+    this.multiLineDecorationModel.clearDecorations();
+  }
+
+  public accept() {
+    const edits = this.multiLineDecorationModel.getEdits();
+
+    this.editor.monacoEditor.pushUndoStop();
+    this.editor.monacoEditor.executeEdits(
+      'multiLineCompletions.accept',
+      edits.map((edit) =>
+        EditOperation.insert(
+          Position.lift({ lineNumber: edit.range.startLineNumber, column: edit.range.startColumn }),
+          edit.text,
+        ),
+      ),
+    );
+
+    this.hide();
+  }
+
+  public registerFeature(editor: IEditor): IDisposable {
+    this.editor = editor;
+    const { monacoEditor } = editor;
+
+    this.multiLineDecorationModel = new MultiLineDecorationModel(monacoEditor);
+    this.aiNativeContextKey = this.injector.get(AINativeContextKey, [monacoEditor.contextKeyService]);
+    return this;
+  }
+}

package/src/browser/contrib/intelligent-completions/intelligent-completions.ts

@@ -0,0 +1,15 @@
+import { InlineCompletion } from '@opensumi/ide-monaco';
+
+export interface IIntelligentCompletionsResult<T = any> {
+  readonly items: InlineCompletion[];
+  /**
+   * 是否开启多行补全
+   * 开启后，items 中的 range 必填
+   * 否则显示默认的 inline completion
+   */
+  readonly enableMultiLine?: boolean | undefined;
+  /**
+   * 定义的额外信息
+   */
+  extra?: T;
+}