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

package/src/browser/contrib/intelligent-completions/multi-line.decoration.ts

@@ -0,0 +1,325 @@
+import { isUndefined } from '@opensumi/ide-core-common';
+import { ICodeEditor, IModelDeltaDecoration, IPosition, Position, Range } from '@opensumi/ide-monaco';
+import { empty } from '@opensumi/ide-utils/lib/strings';
+
+import { EnhanceDecorationsCollection } from '../../model/enhanceDecorationsCollection';
+
+import { IDiffChangeResult } from './diff-computer';
+
+export interface IModificationsInline {
+  newValue: string;
+  oldValue: string;
+  lineNumber?: number;
+  column?: number;
+  isEolLine?: boolean;
+}
+
+enum EProcessStatus {
+  beginning = 'beginning',
+  end = 'end',
+}
+
+interface IProcessModificationsInline extends IModificationsInline {
+  status: EProcessStatus;
+}
+
+// https://github.com/microsoft/vscode/blob/main/src/vs/editor/contrib/inlineCompletions/browser/ghostTextWidget.ts#L156
+export const GHOST_TEXT_DESCRIPTION = 'ghost-text-decoration';
+export const GHOST_TEXT = 'ghost-text';
+
+export class MultiLineDecorationModel {
+  private ghostTextDecorations: EnhanceDecorationsCollection;
+
+  constructor(private readonly editor: ICodeEditor) {
+    this.ghostTextDecorations = new EnhanceDecorationsCollection(this.editor);
+  }
+
+  /**
+   * 切割 diff 计算结果的换行符
+   */
+  private splitDiffChanges(lines: IDiffChangeResult[], eol: string): IDiffChangeResult[] {
+    const modifiedLines = lines.flatMap((line) => {
+      const segments = line.value.split(eol);
+      const wrap = (value: string): IDiffChangeResult => ({ value, added: line.added, removed: line.removed });
+
+      return segments
+        .flatMap((segment, index) => {
+          if (index < segments.length - 1) {
+            return [wrap(segment), wrap(eol)];
+          }
+
+          return wrap(segment);
+        })
+        .filter((line) => line.value !== empty);
+    });
+
+    // 对处理后的结果进行调整，确保相邻的添加和删除操作合并
+    for (let i = 0; i < modifiedLines.length - 1; i++) {
+      const currentLine = modifiedLines[i];
+      const nextLine = modifiedLines[i + 1];
+      // 如果当前行是删除操作，下一行是添加操作，并且下一行的值以当前行的值开头，则合并这两个操作
+      if (currentLine.removed && nextLine.added && nextLine.value.startsWith(currentLine.value)) {
+        currentLine.added = true;
+        currentLine.removed = true;
+      }
+    }
+
+    return modifiedLines;
+  }
+
+  /**
+   * 合并连续的修改操作
+   */
+  private combineContinuousMods(changes: IModificationsInline[]) {
+    const lines: string[] = [];
+    let currentLineContent = empty;
+    for (const change of changes) {
+      if (change.isEolLine) {
+        lines.push(currentLineContent);
+        currentLineContent = empty;
+      } else {
+        currentLineContent += change.newValue;
+      }
+    }
+    if (currentLineContent !== empty) {
+      lines.push(currentLineContent);
+    }
+    return lines;
+  }
+
+  private processLineModifications(
+    waitAddModificationsLines: IModificationsInline[],
+    eol: string,
+    previous: IDiffChangeResult,
+    next?: IDiffChangeResult,
+  ) {
+    const lines = this.combineContinuousMods(waitAddModificationsLines);
+    const len = lines.length;
+
+    const fullLineMods: string[] = [];
+    const inlineMods: IProcessModificationsInline[] = [];
+
+    if (len === 0) {
+      return {
+        fullLineMods,
+        inlineMods,
+      };
+    }
+
+    const firstLine = lines[0];
+    const lastLine = lines[len - 1];
+
+    if (len === 1) {
+      if (!isUndefined(previous) && previous.value !== eol) {
+        inlineMods.push({
+          status: EProcessStatus.beginning,
+          newValue: previous.value + firstLine,
+          oldValue: previous.value,
+        });
+      } else if (!isUndefined(next) && next.value !== eol) {
+        inlineMods.push({
+          status: EProcessStatus.end,
+          newValue: lastLine + next.value,
+          oldValue: next.value,
+        });
+      } else {
+        fullLineMods.push(firstLine);
+      }
+
+      return {
+        fullLineMods,
+        inlineMods,
+      };
+    }
+
+    if (isUndefined(previous) || previous.value === eol) {
+      fullLineMods.push(firstLine);
+    } else {
+      inlineMods.push({
+        status: EProcessStatus.beginning,
+        newValue: previous.value + firstLine,
+        oldValue: previous.value,
+      });
+    }
+
+    if (len > 2) {
+      const middleLines = lines.slice(1, -1);
+      for (const line of middleLines) {
+        fullLineMods.push(line);
+      }
+    }
+
+    if (isUndefined(next) || next.value === eol) {
+      fullLineMods.push(lastLine);
+    } else {
+      inlineMods.push({
+        status: EProcessStatus.end,
+        newValue: lastLine + next.value,
+        oldValue: next.value,
+      });
+    }
+
+    return {
+      fullLineMods,
+      inlineMods,
+    };
+  }
+
+  public clearDecorations(): void {
+    this.ghostTextDecorations.clear();
+  }
+
+  public getEdits() {
+    const decorations = this.ghostTextDecorations.getDecorations();
+    const edits = decorations.map(({ editorDecoration, range }) => {
+      const options = editorDecoration.options;
+      const text = options.after?.content || '';
+
+      return { range, text };
+    });
+
+    return edits;
+  }
+
+  public updateLineModificationDecorations(modifications: IModificationsInline[]) {
+    if (modifications.length === 0) {
+      this.clearDecorations();
+      return;
+    }
+
+    const decorations: IModelDeltaDecoration[] = modifications.map((modification) => {
+      let content: string;
+
+      if (modification.newValue.startsWith(modification.oldValue)) {
+        content = modification.newValue.slice(modification.oldValue.length);
+      } else {
+        const oldValueIndex = modification.newValue.indexOf(modification.oldValue);
+        content = oldValueIndex !== -1 ? modification.newValue.slice(0, oldValueIndex) : modification.newValue;
+      }
+
+      return {
+        range: Range.fromPositions(new Position(modification.lineNumber!, modification.column!)),
+        options: {
+          description: GHOST_TEXT,
+          showIfCollapsed: true,
+          after: {
+            content,
+            inlineClassName: GHOST_TEXT_DESCRIPTION,
+          },
+        },
+      };
+    });
+
+    this.ghostTextDecorations.set(decorations);
+  }
+
+  public applyInlineDecorations(
+    editor: ICodeEditor,
+    changes: IDiffChangeResult[],
+    startLine: number,
+    cursorPosition: IPosition,
+  ): IModificationsInline[] | undefined {
+    startLine = Math.max(startLine - 1, 0);
+
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+
+    const eol = model.getEOL();
+
+    changes = this.splitDiffChanges(changes, eol);
+    changes.unshift({
+      value: eol,
+      added: undefined,
+      removed: undefined,
+    });
+
+    const currentLineText = model.getLineContent(cursorPosition.lineNumber);
+    const resultModifications: IModificationsInline[] = [];
+
+    let lastChange: IDiffChangeResult;
+    let waitAddModificationsLines: IModificationsInline[] = [];
+    let columnNumber = 1;
+
+    const processChange = (change: IDiffChangeResult | undefined) => {
+      const { fullLineMods, inlineMods } = this.processLineModifications(
+        waitAddModificationsLines,
+        eol,
+        lastChange,
+        change,
+      );
+
+      inlineMods.forEach((mod) =>
+        resultModifications.push({
+          lineNumber: mod.status === EProcessStatus.beginning ? startLine : startLine + 1,
+          column: mod.status === EProcessStatus.beginning ? columnNumber : 1,
+          newValue: mod.newValue,
+          oldValue: mod.oldValue,
+        }),
+      );
+
+      return {
+        fullLineMods,
+        inlineMods,
+      };
+    };
+
+    let currentLineIndex = startLine;
+    let previousValue = empty;
+    let isEmptyLine = currentLineText.trim() === empty;
+
+    for (const change of changes) {
+      if (change.added) {
+        const isEolLine = change.value === eol;
+
+        if (isEolLine) {
+          previousValue = empty;
+        }
+
+        waitAddModificationsLines.push({
+          isEolLine,
+          lineNumber: startLine,
+          newValue: isEolLine ? empty : change.value,
+          oldValue: isEolLine ? empty : previousValue,
+        });
+      } else {
+        const { inlineMods } = processChange(change);
+
+        if (startLine === cursorPosition.lineNumber && inlineMods.length > 0) {
+          isEmptyLine = false;
+
+          if (startLine <= cursorPosition.lineNumber && columnNumber < cursorPosition.column) {
+            return;
+          }
+        }
+
+        lastChange = change;
+        waitAddModificationsLines = [];
+
+        // 如果 change 的值是 eol，则开启新的一行进行计算
+        if (change.value === eol) {
+          currentLineIndex++;
+          columnNumber = 1;
+          previousValue = empty;
+        } else {
+          startLine = Math.max(startLine, currentLineIndex);
+          columnNumber += change.value.length;
+          previousValue += change.value;
+        }
+      }
+    }
+
+    const { fullLineMods } = processChange(undefined);
+
+    if (startLine <= cursorPosition.lineNumber && columnNumber < cursorPosition.column) {
+      return;
+    }
+
+    if (!isEmptyLine && fullLineMods.length > 0) {
+      return;
+    }
+
+    return resultModifications;
+  }
+}

package/src/browser/contrib/merge-conflict/merge-conflict.feature.registry.ts

@@ -15,10 +15,6 @@ export class ResolveConflictRegistry
 {
   private readonly providerMap = new Map<MergeConflictEditorMode, IResolveConflictHandler>();
 
-  override dispose() {
-    super.dispose();
-  }
-
   registerResolveConflictProvider(editorMode: MergeConflictEditorMode, handler: IResolveConflictHandler): void {
     if (this.providerMap.has(editorMode)) {
       throw new Error(`Conflict provider for ${editorMode} already exists`);

package/src/browser/index.ts

@@ -13,7 +13,7 @@ import {
   RenameCandidatesProviderRegistryToken,
   ResolveConflictRegistryToken,
 } from '@opensumi/ide-core-browser';
-import { TerminalRegistryToken } from '@opensumi/ide-core-common';
+import { IntelligentCompletionsRegistryToken, TerminalRegistryToken } from '@opensumi/ide-core-common';
 
 import { ChatProxyServiceToken, IChatAgentService, IChatInternalService, IChatManagerService } from '../common';
 
@@ -27,6 +27,8 @@ import { ChatFeatureRegistry } from './chat/chat.feature.registry';
 import { ChatInternalService } from './chat/chat.internal.service';
 import { ChatRenderRegistry } from './chat/chat.render.registry';
 import { AICodeActionContribution } from './contrib/code-action/code-action.contribution';
+import { IntelligentCompletionsContribution } from './contrib/intelligent-completions/intelligent-completions.contribution';
+import { IntelligentCompletionsRegistry } from './contrib/intelligent-completions/intelligent-completions.feature.registry';
 import { InterfaceNavigationContribution } from './contrib/interface-navigation/interface-navigation.contribution';
 import { MergeConflictContribution } from './contrib/merge-conflict';
 import { ResolveConflictRegistry } from './contrib/merge-conflict/merge-conflict.feature.registry';
@@ -57,6 +59,7 @@ export class AINativeModule extends BrowserModule {
     MergeConflictContribution,
     AICodeActionContribution,
     AINativePreferencesContribution,
+    IntelligentCompletionsContribution,
     {
       token: InlineChatFeatureRegistryToken,
       useClass: InlineChatFeatureRegistry,
@@ -73,6 +76,10 @@ export class AINativeModule extends BrowserModule {
       token: ResolveConflictRegistryToken,
       useClass: ResolveConflictRegistry,
     },
+    {
+      token: IntelligentCompletionsRegistryToken,
+      useClass: IntelligentCompletionsRegistry,
+    },
     {
       token: IAIInlineChatService,
       useClass: AIInlineChatService,

package/src/browser/layout/ai-layout.tsx

@@ -33,7 +33,13 @@ export const AILayout = () => {
           />
           <SplitPanel id='main-vertical' minResize={300} flexGrow={1} direction='top-to-bottom'>
             <SlotRenderer flex={2} flexGrow={1} minResize={200} slot='main' />
-            <SlotRenderer flex={1} defaultSize={layout.bottom?.size} minResize={160} slot='bottom' isTabbar={true} />
+            <SlotRenderer
+              flex={1}
+              defaultSize={layout.bottom?.currentId ? layout.bottom?.size : 24}
+              minResize={160}
+              slot='bottom'
+              isTabbar={true}
+            />
           </SplitPanel>
           <SlotRenderer
             slot='right'

package/src/browser/layout/layout.module.less

@@ -1,15 +1,6 @@
-/**
-* -------------------------------------------- 右侧 chat 面板样式 --------------------------------------------
-*/
 #ai_chat_panel {
   height: 100%;
 
-  div[class*='tab_panel'] {
-    &::before {
-      content: none;
-    }
-  }
-
   :global {
     .rce-mbox-left-notch,
     .rce-mbox-right-notch {

package/src/browser/model/enhanceDecorationsCollection.ts

@@ -1,6 +1,4 @@
-import throttle from 'lodash/throttle';
-
-import { Disposable, Emitter, Event, isUndefined } from '@opensumi/ide-core-common';
+import { Disposable, Emitter, Event, isDefined, isUndefined } from '@opensumi/ide-core-common';
 import {
   ICodeEditor,
   IContentSizeChangedEvent,
@@ -13,6 +11,7 @@ import {
   Range,
 } from '@opensumi/ide-monaco';
 import { space } from '@opensumi/ide-utils/lib/strings';
+import { UndoRedoGroup } from '@opensumi/monaco-editor-core/esm/vs/platform/undoRedo/common/undoRedo';
 
 import styles from './styles.module.less';
 
@@ -35,8 +34,17 @@ export interface IEnhanceModelDeltaDecoration extends IDeltaData {
   resume(): void;
   getRange(): IRange;
   setRange(newRange: IRange): void;
+  group?: UndoRedoGroup;
+  setGroup(group: UndoRedoGroup): void;
+}
 
-  serializeState(): IDecorationSerializableState;
+export interface IDeltaDecorationsOptions {
+  id: string;
+  editorDecoration: IModelDeltaDecoration;
+  codeEditor: ICodeEditor;
+  deltaData: Partial<IDeltaData>;
+  isHidden?: boolean;
+  group?: UndoRedoGroup;
 }
 
 class DeltaDecorations implements IEnhanceModelDeltaDecoration {
@@ -45,18 +53,36 @@ class DeltaDecorations implements IEnhanceModelDeltaDecoration {
   options: IModelDecorationOptions;
 
   private resumeRange: IRange;
+  private _group: UndoRedoGroup;
 
   private _hidden = false;
   get isHidden(): boolean {
     return this._hidden;
   }
 
-  constructor(
-    public readonly id: string,
-    public readonly editorDecoration: IModelDeltaDecoration,
-    private readonly codeEditor: ICodeEditor,
-    private readonly deltaData: Partial<IDeltaData>,
-  ) {
+  get codeEditor(): ICodeEditor {
+    return this.metadata.codeEditor;
+  }
+
+  get deltaData(): Partial<IDeltaData> {
+    return this.metadata.deltaData;
+  }
+
+  get id(): string {
+    return this.metadata.id;
+  }
+
+  get editorDecoration(): IModelDeltaDecoration {
+    return this.metadata.editorDecoration;
+  }
+
+  public get group(): UndoRedoGroup {
+    return this._group;
+  }
+
+  constructor(protected readonly metadata: IDeltaDecorationsOptions) {
+    const { editorDecoration, deltaData, isHidden, group } = metadata;
+
     if (isUndefined(deltaData.length)) {
       this.length = editorDecoration.range.endLineNumber - editorDecoration.range.startLineNumber;
     } else {
@@ -67,6 +93,19 @@ class DeltaDecorations implements IEnhanceModelDeltaDecoration {
     this.options = editorDecoration.options;
 
     this.resumeRange = this.range;
+
+    this._hidden = !!isHidden;
+    if (this._hidden) {
+      this.hide();
+    }
+
+    if (isDefined(group)) {
+      this.setGroup(group);
+    }
+  }
+
+  setGroup(group): void {
+    this._group = group;
   }
 
   private changeVisibility(newClassName: string, newRange: Range): void {
@@ -112,16 +151,6 @@ class DeltaDecorations implements IEnhanceModelDeltaDecoration {
     this._hidden = false;
     this.changeVisibility(styles.visible, Range.lift(this.resumeRange));
   }
-
-  serializeState(): IDecorationSerializableState {
-    const { range } = this;
-    const startPosition = { lineNumber: range.startLineNumber, column: range.startColumn };
-    const endPosition = {
-      lineNumber: range.endLineNumber,
-      column: range.endColumn,
-    };
-    return { startPosition, endPosition, len: this.length };
-  }
 }
 
 export class EnhanceDecorationsCollection extends Disposable {
@@ -137,12 +166,6 @@ export class EnhanceDecorationsCollection extends Disposable {
   constructor(private readonly codeEditor: ICodeEditor) {
     super();
 
-    this.addDispose(
-      Disposable.create(() => {
-        this.clear();
-      }),
-    );
-
     this.addDispose(
       this.codeEditor.onDidContentSizeChange((event: IContentSizeChangedEvent) => {
         const { contentHeightChanged } = event;
@@ -180,7 +203,14 @@ export class EnhanceDecorationsCollection extends Disposable {
     });
   }
 
-  set(decorations: (IModelDeltaDecoration & Partial<Pick<IEnhanceModelDeltaDecoration, 'length'>>)[]): void {
+  protected createDecorations(metaData: IDeltaDecorationsOptions) {
+    return new DeltaDecorations(metaData);
+  }
+
+  set(
+    decorations: (IModelDeltaDecoration &
+      Partial<Pick<IEnhanceModelDeltaDecoration, 'length' | 'isHidden' | 'group'>>)[],
+  ): void {
     this.clear();
 
     this.codeEditor.changeDecorations((accessor: IModelDecorationsChangeAccessor) => {
@@ -189,9 +219,16 @@ export class EnhanceDecorationsCollection extends Disposable {
       for (const decoration of decorations) {
         const id = accessor.addDecoration(decoration.range, decoration.options);
         newDecorations.push(
-          new DeltaDecorations(id, decoration, this.codeEditor, {
-            length: decoration.length,
-            dispose: () => this.delete(id),
+          this.createDecorations({
+            id,
+            editorDecoration: decoration,
+            codeEditor: this.codeEditor,
+            isHidden: decoration.isHidden,
+            group: decoration.group,
+            deltaData: {
+              dispose: () => this.delete(id),
+              length: decoration.length,
+            },
           }),
         );
       }
@@ -204,12 +241,12 @@ export class EnhanceDecorationsCollection extends Disposable {
     return this.deltaDecorations;
   }
 
-  getDecorationByLineNumber(lineNumber: number): IEnhanceModelDeltaDecoration | undefined {
-    return this.deltaDecorations.find((d) => d.getRange().startLineNumber === lineNumber);
+  getDecorationByGroup(group: UndoRedoGroup): IEnhanceModelDeltaDecoration | undefined {
+    return this.deltaDecorations.find((d) => d.group === group);
   }
 
-  serializeState(): IDecorationSerializableState[] {
-    return this.deltaDecorations.filter((d) => !d.isHidden).map((d) => d.serializeState());
+  getDecorationByLineNumber(lineNumber: number): IEnhanceModelDeltaDecoration | undefined {
+    return this.deltaDecorations.find((d) => d.getRange().startLineNumber === lineNumber);
   }
 
   clear(): void {

package/src/browser/types.ts

@@ -8,15 +8,17 @@ import {
   IAICompletionOption,
   IAICompletionResultModel,
   IDisposable,
+  IPosition,
   IResolveConflictHandler,
   MaybePromise,
   MergeConflictEditorMode,
 } from '@opensumi/ide-core-common';
-import { ICodeEditor, ITextModel, NewSymbolNamesProvider, Position } from '@opensumi/ide-monaco';
+import { ICodeEditor, IRange, ITextModel, NewSymbolNamesProvider, Position } from '@opensumi/ide-monaco';
 import { SumiReadableStream } from '@opensumi/ide-utils/lib/stream';
 
 import { IChatWelcomeMessageContent, ISampleQuestions, ITerminalCommandSuggestionDesc } from '../common';
 
+import { IIntelligentCompletionsResult } from './contrib/intelligent-completions/intelligent-completions';
 import { BaseTerminalDetectionLineMatcher } from './contrib/terminal/matcher';
 import { InlineChatController } from './widget/inline-chat/inline-chat-controller';
 
@@ -26,13 +28,13 @@ interface IBaseInlineChatHandler<T extends any[]> {
    */
   execute?: (...args: T) => MaybePromise<void>;
   /**
-   * 提供 diff editor 的预览策略
+   * 在 editor 里预览输出的结果
    */
-  providerDiffPreviewStrategy?: (...args: T) => MaybePromise<ChatResponse | InlineChatController>;
+  providePreviewStrategy?: (...args: T) => MaybePromise<ChatResponse | InlineChatController>;
   /**
-   * 在 editor 里直接预览输出的结果
+   * @deprecated use providePreviewStrategy api
    */
-  providerPreviewStrategy?: (...args: T) => MaybePromise<ChatResponse | InlineChatController>;
+  providerDiffPreviewStrategy?: (...args: T) => MaybePromise<ChatResponse | InlineChatController>;
 }
 
 export type IEditorInlineChatHandler = IBaseInlineChatHandler<[editor: ICodeEditor, token: CancellationToken]>;
@@ -45,10 +47,6 @@ export enum ERunStrategy {
    * 正常执行，执行后 input 直接消失
    */
   EXECUTE = 'EXECUTE',
-  /**
-   * 预览 diff，执行后 input 保留，显示 inline diff editor
-   */
-  DIFF_PREVIEW = 'DIFF_PREVIEW',
   /**
    * 预览输出结果，执行后 input 保留，并在 editor 里直接展示输出结果
    */
@@ -198,14 +196,19 @@ export interface ITerminalProviderRegistry {
   registerCommandSuggestionsProvider(provider: TTerminalCommandSuggestionsProviderFn): void;
 }
 
+export type IIntelligentCompletionProvider = (
+  editor: ICodeEditor,
+  position: IPosition,
+  contextBean: IAICompletionOption,
+  token: CancellationToken,
+) => MaybePromise<IIntelligentCompletionsResult>;
+export interface IIntelligentCompletionsRegistry {
+  registerIntelligentCompletionProvider(provider: IIntelligentCompletionProvider): void;
+}
+
 export const AINativeCoreContribution = Symbol('AINativeCoreContribution');
 
 export interface AINativeCoreContribution {
-  /**
-   * 通过中间件扩展部分 ai 能力
-   */
-  middleware?: IAIMiddleware;
-
   /**
    * 注册 inline chat 相关功能
    * @param registry: IInlineChatFeatureRegistry
@@ -231,6 +234,10 @@ export interface AINativeCoreContribution {
    * 注册智能终端相关功能
    */
   registerTerminalProvider?(registry: ITerminalProviderRegistry): void;
+  /**
+   * 注册智能代码补全相关功能
+   */
+  registerIntelligentCompletionFeature?(registry: IIntelligentCompletionsRegistry): void;
 }
 
 export interface IChatComponentConfig {
@@ -245,6 +252,9 @@ export interface IChatAgentViewService {
   getChatComponentDeferred(componentId: string): Deferred<IChatComponentConfig> | null;
 }
 
+/**
+ * @deprecated use registerIntelligentCompletionProvider API
+ */
 export type IProvideInlineCompletionsSignature = (
   this: void,
   model: ITextModel,
@@ -254,6 +264,9 @@ export type IProvideInlineCompletionsSignature = (
   requestOption: IAICompletionOption,
 ) => MaybePromise<IAICompletionResultModel | null>;
 
+/**
+ * @deprecated use registerIntelligentCompletionProvider API
+ */
 export interface IAIMiddleware {
   language?: {
     provideInlineCompletions?: IProvideInlineCompletionsSignature;