@opensumi/ide-ai-native 3.4.4 → 3.4.5-next-1729482152.0

package/src/browser/contrib/{intelligent-completions/intelligent-completions.source.ts → inline-completions/inline-completions.controller.ts}

@@ -1,13 +1,13 @@
 import debounce from 'lodash/debounce';
 
-import { Autowired, INJECTOR_TOKEN, Injectable, Injector, Optional } from '@opensumi/di';
 import { AI_INLINE_COMPLETION_VISIBLE } from '@opensumi/ide-core-browser/lib/ai-native/command';
 import {
   CommandService,
   CommandServiceImpl,
-  Disposable,
+  IAICompletionOption,
   IDisposable,
   IEventBus,
+  IntelligentCompletionsRegistryToken,
   Sequencer,
   runWhenIdle,
 } from '@opensumi/ide-core-common';
@@ -18,28 +18,40 @@ import { empty } from '@opensumi/ide-utils/lib/strings';
 import { InlineCompletionContextKeys } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionContextKeys';
 
 import { IAIInlineCompletionsProvider } from '../../../common';
+import { AINativeContextKey } from '../../contextkey/ai-native.contextkey.service';
+import { BaseAIMonacoEditorController } from '../base';
+import { IIntelligentCompletionsResult } from '../intelligent-completions';
+import { IntelligentCompletionsRegistry } from '../intelligent-completions/intelligent-completions.feature.registry';
 
-import { IIntelligentCompletionsResult } from './intelligent-completions';
+export class InlineCompletionsController extends BaseAIMonacoEditorController {
+  public static readonly ID = 'editor.contrib.ai.inline.completions';
 
-@Injectable({ multiple: true })
-export class InlineCompletionsSource extends Disposable {
-  @Autowired(INJECTOR_TOKEN)
-  protected readonly injector: Injector;
+  public static get(editor: ICodeEditor): InlineCompletionsController | null {
+    return editor.getContribution<InlineCompletionsController>(InlineCompletionsController.ID);
+  }
+
+  private get eventBus(): IEventBus {
+    return this.injector.get(IEventBus);
+  }
 
-  @Autowired(IEventBus)
-  private eventBus: IEventBus;
+  private get commandService(): CommandServiceImpl {
+    return this.injector.get(CommandService);
+  }
 
-  @Autowired(CommandService)
-  private commandService: CommandServiceImpl;
+  private get aiInlineCompletionsProvider(): IAIInlineCompletionsProvider {
+    return this.injector.get(IAIInlineCompletionsProvider);
+  }
 
-  @Autowired(IAIInlineCompletionsProvider)
-  private readonly aiInlineCompletionsProvider: IAIInlineCompletionsProvider;
+  private get intelligentCompletionsRegistry(): IntelligentCompletionsRegistry {
+    return this.injector.get(IntelligentCompletionsRegistryToken);
+  }
 
+  private aiNativeContextKey: AINativeContextKey;
   private sequencer = new Sequencer();
   private preDidShowItems: InlineCompletions | undefined;
 
-  constructor(@Optional() private readonly monacoEditor: ICodeEditor) {
-    super();
+  public mount(): IDisposable {
+    this.aiNativeContextKey = this.injector.get(AINativeContextKey, [this.monacoEditor.contextKeyService]);
 
     // 判断用户是否选择了一块区域或者移动光标 取消掉请补全请求
     const selectionChange = () => {
@@ -62,7 +74,7 @@ export class InlineCompletionsSource extends Disposable {
     });
 
     const inlineVisibleKey = new Set([InlineCompletionContextKeys.inlineSuggestionVisible.key]);
-    this.addDispose(
+    this.featureDisposable.addDispose(
       this.monacoEditor.contextKeyService.onDidChangeContext((e) => {
         // inline completion 真正消失时
         if (e.affectsSome(inlineVisibleKey)) {
@@ -79,7 +91,7 @@ export class InlineCompletionsSource extends Disposable {
       }),
     );
 
-    this.addDispose(
+    this.featureDisposable.addDispose(
       this.eventBus.on(EditorSelectionChangeEvent, (e) => {
         if (e.payload.source === 'mouse') {
           debouncedSelectionChange();
@@ -90,7 +102,7 @@ export class InlineCompletionsSource extends Disposable {
       }),
     );
 
-    this.addDispose(
+    this.featureDisposable.addDispose(
       this.monacoEditor.onDidChangeModelContent((e) => {
         const changes = e.changes;
         for (const change of changes) {
@@ -104,17 +116,15 @@ export class InlineCompletionsSource extends Disposable {
       }),
     );
 
-    this.addDispose(
+    this.featureDisposable.addDispose(
       this.monacoEditor.onDidBlurEditorText(() => {
         this.commandService.executeCommand(AI_INLINE_COMPLETION_VISIBLE.id, false);
       }),
     );
-  }
 
-  public fetch(): IDisposable {
     let prePosition: Position | undefined;
 
-    this.addDispose(
+    this.featureDisposable.addDispose(
       monacoApi.languages.registerInlineCompletionsProvider('*', {
         groupId: 'ai-native-intelligent-completions',
         provideInlineCompletions: async (model, position, context, token) => {
@@ -150,6 +160,24 @@ export class InlineCompletionsSource extends Disposable {
       }),
     );
 
-    return this;
+    return this.featureDisposable;
+  }
+
+  public async fetchProvider(bean: IAICompletionOption): Promise<IIntelligentCompletionsResult | undefined> {
+    const provider = this.intelligentCompletionsRegistry.getInlineCompletionsProvider();
+    if (!provider) {
+      return;
+    }
+
+    // 如果上一次补全结果还在，则不重复请求
+    const isVisible = this.aiNativeContextKey.multiLineEditsIsVisible.get();
+    if (isVisible) {
+      return;
+    }
+
+    const position = this.monacoEditor.getPosition()!;
+    const inlineCompletionModel = await provider(this.monacoEditor, position, bean, this.token);
+
+    return inlineCompletionModel;
   }
 }

package/src/browser/contrib/inline-completions/model/competionModel.ts

@@ -1,6 +1,6 @@
 import * as monaco from '@opensumi/ide-monaco';
 
-import { IIntelligentCompletionsResult } from '../../intelligent-completions/intelligent-completions';
+import { IIntelligentCompletionsResult } from '../../intelligent-completions';
 
 /**
  * 缓存的结果

package/src/browser/contrib/inline-completions/model/inlineCompletionRequestTask.ts

@@ -16,9 +16,9 @@ import { WorkbenchEditorService } from '@opensumi/ide-editor';
 import { WorkbenchEditorServiceImpl } from '@opensumi/ide-editor/lib/browser/workbench-editor.service';
 import * as monaco from '@opensumi/ide-monaco';
 
-import { IIntelligentCompletionsResult } from '../../intelligent-completions/intelligent-completions';
-import { IntelligentCompletionsController } from '../../intelligent-completions/intelligent-completions.controller';
+import { IIntelligentCompletionsResult } from '../../intelligent-completions';
 import { IntelligentCompletionsRegistry } from '../../intelligent-completions/intelligent-completions.feature.registry';
+import { InlineCompletionsController } from '../inline-completions.controller';
 import { InlineCompletionItem } from '../model/competionModel';
 import { PromptCache } from '../promptCache';
 import { lineBasedPromptProcessor } from '../provider';
@@ -174,14 +174,14 @@ export class InlineCompletionRequestTask extends Disposable {
     } else {
       try {
         this.aiCompletionsService.updateStatusBarItem('running', true);
-        const provider = this.intelligentCompletionsRegistry.getProvider();
+        const provider = this.intelligentCompletionsRegistry.getInlineCompletionsProvider();
         if (provider) {
           const editor = this.workbenchEditorService.currentCodeEditor;
           if (!editor) {
             return [];
           }
-          const intelligentCompletionsHandler = IntelligentCompletionsController.get(editor.monacoEditor);
-          completeResult = await intelligentCompletionsHandler?.fetchProvider(requestBean);
+          const inlineCompletionsHandler = InlineCompletionsController.get(editor.monacoEditor);
+          completeResult = await inlineCompletionsHandler?.fetchProvider(requestBean);
         } else {
           completeResult = await this.aiCompletionsService.complete(requestBean);
         }

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

@@ -1,5 +1,4 @@
-// @ts-ignore
-import { Tiktoken } from 'js-tiktoken';
+import { Tiktoken } from 'tiktoken/lite';
 
 import { Injector } from '@opensumi/di';
 
@@ -59,7 +58,12 @@ export const getMarkerForSnippets = (text: string, language: string) => {
   return lines.map((line) => getMarkerByLanguage(line, language)).join('\n');
 };
 
-export const getCroppedTextByLine = (text: string, maxTokenSize: number, textTokens: number[][], reverse = false) => {
+export const getCroppedTextByLine = (
+  text: string,
+  maxTokenSize: number,
+  textTokens: Uint32Array[],
+  reverse = false,
+) => {
   const currentTokenSize = textTokens.reduce((prev, cur) => prev + cur.length, 0);
   if (currentTokenSize < maxTokenSize) {
     return text;
@@ -110,7 +114,7 @@ export const getCroppedTextByLine = (text: string, maxTokenSize: number, textTok
 export const getCroppedText = async (
   text: string,
   maxTokenSize: number,
-  textTokens: number[][],
+  textTokens: Uint32Array[],
   strategy = StrategyType.InterceptBasedOnLine,
   tokenizer: Tiktoken,
   parser?: LanguageParser,
@@ -118,7 +122,7 @@ export const getCroppedText = async (
   reverse = false,
   token?: monaco.CancellationToken,
 ): Promise<string> => {
-  let tokens: number[];
+  let tokens: Uint32Array;
   if (strategy === StrategyType.InterceptBasedOnLine) {
     // 按行进行裁剪
     text = getCroppedTextByLine(text, maxTokenSize, textTokens, reverse);

package/src/browser/contrib/inline-completions/prompt/tokenizer.ts

@@ -1,5 +1,4 @@
-// @ts-ignore
-import { Tiktoken, getEncoding } from 'js-tiktoken';
+import { Tiktoken, get_encoding } from 'tiktoken';
 
 import { TokenizerName } from '../types';
 
@@ -10,7 +9,7 @@ export const getTokenizer = (tokenizerName = TokenizerName.cl100k_base) => {
   if (tokenizer) {
     return tokenizer;
   }
-  tokenizer = getEncoding('cl100k_base');
+  tokenizer = get_encoding('cl100k_base');
   TOKENIZER_CACHE.set(tokenizerName, tokenizer);
   return tokenizer;
 };

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

@@ -9,7 +9,7 @@ import {
 } from '@opensumi/ide-core-browser';
 import { IHashCalculateService } from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
 
-import { IIntelligentCompletionsResult } from '../intelligent-completions/intelligent-completions';
+import { IIntelligentCompletionsResult } from '../intelligent-completions';
 
 /**
  * 缓存服务

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

@@ -15,7 +15,7 @@ import {
 } from '@opensumi/ide-core-common';
 import { CompletionRT, IAIReporter } from '@opensumi/ide-core-common/lib/types/ai-native/reporter';
 
-import { IIntelligentCompletionsResult } from '../../intelligent-completions/intelligent-completions';
+import { IIntelligentCompletionsResult } from '../../intelligent-completions';
 
 @Injectable()
 export class AICompletionsService extends Disposable {

package/src/browser/contrib/intelligent-completions/{additions-deletions.decoration.ts → decoration/additions-deletions.decoration.ts}

@@ -1,10 +1,9 @@
 import { ICodeEditor, IModelDeltaDecoration, IRange, TrackedRangeStickiness } from '@opensumi/ide-monaco';
 
-import { EnhanceDecorationsCollection } from '../../model/enhanceDecorationsCollection';
-import { REWRITE_DECORATION_INLINE_ADD } from '../../widget/rewrite/rewrite-widget';
-
-import { IMultiLineDiffChangeResult } from './diff-computer';
-import styles from './intelligent-completions.module.less';
+import { EnhanceDecorationsCollection } from '../../../model/enhanceDecorationsCollection';
+import { REWRITE_DECORATION_INLINE_ADD } from '../../../widget/rewrite/rewrite-widget';
+import { IMultiLineDiffChangeResult } from '../diff-computer';
+import styles from '../intelligent-completions.module.less';
 
 export class AdditionsDeletionsDecorationModel {
   private deletionsDecorations: EnhanceDecorationsCollection;

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

@@ -4,9 +4,8 @@ import { empty } from '@opensumi/ide-utils/lib/strings';
 import { EditOperation } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/editOperation';
 import { LineDecoration } from '@opensumi/monaco-editor-core/esm/vs/editor/common/viewLayout/lineDecorations';
 
-import { EnhanceDecorationsCollection } from '../../model/enhanceDecorationsCollection';
-
-import { IMultiLineDiffChangeResult } from './diff-computer';
+import { EnhanceDecorationsCollection } from '../../../model/enhanceDecorationsCollection';
+import { IMultiLineDiffChangeResult } from '../diff-computer';
 
 export interface IModificationsInline {
   newValue: string;

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

@@ -0,0 +1,34 @@
+import { IRange, InlineCompletion } from '@opensumi/ide-monaco';
+
+import type { ILinterErrorData } from './lint-error.source';
+
+export interface IIntelligentCompletionsResult<T = any> {
+  readonly items: InlineCompletion[];
+  /**
+   * 定义的额外信息
+   */
+  extra?: T;
+}
+
+export enum ECodeEditsSource {
+  LinterErrors = 'lint_errors',
+}
+
+export interface ICodeEditsContextBean {
+  typing: ECodeEditsSource.LinterErrors;
+  data: ILinterErrorData;
+}
+
+export interface ICodeEdit {
+  /**
+   * 插入的文本
+   */
+  readonly insertText: string;
+  /**
+   * 替换的文本范围
+   */
+  readonly range: IRange;
+}
+export interface ICodeEditsResult {
+  readonly items: ICodeEdit[];
+}

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

@@ -1,14 +1,6 @@
 import { Key, KeybindingRegistry, KeybindingScope, PreferenceService } from '@opensumi/ide-core-browser';
 import { MultiLineEditsIsVisible } from '@opensumi/ide-core-browser/lib/contextkey/ai-native';
-import {
-  AINativeSettingSectionsId,
-  Disposable,
-  Event,
-  IAICompletionOption,
-  IDisposable,
-  IntelligentCompletionsRegistryToken,
-  runWhenIdle,
-} from '@opensumi/ide-core-common';
+import { AINativeSettingSectionsId, Disposable, Event, IDisposable, runWhenIdle } from '@opensumi/ide-core-common';
 import { ICodeEditor, ICursorPositionChangedEvent, IRange, ITextModel, Range } from '@opensumi/ide-monaco';
 import { empty } from '@opensumi/ide-utils/lib/strings';
 import { autorun, transaction } from '@opensumi/monaco-editor-core/esm/vs/base/common/observable';
@@ -21,23 +13,24 @@ import {
   SuggestItemInfo,
   SuggestWidgetAdaptor,
 } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/inlineCompletions/browser/suggestWidgetInlineCompletionProvider';
+import { SuggestController } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/suggest/browser/suggestController';
 import { ContextKeyExpr } from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
 
 import { AINativeContextKey } from '../../contextkey/ai-native.contextkey.service';
 import { REWRITE_DECORATION_INLINE_ADD, RewriteWidget } from '../../widget/rewrite/rewrite-widget';
 import { BaseAIMonacoEditorController } from '../base';
 
-import { AdditionsDeletionsDecorationModel } from './additions-deletions.decoration';
+import { AdditionsDeletionsDecorationModel } from './decoration/additions-deletions.decoration';
+import { MultiLineDecorationModel } from './decoration/multi-line.decoration';
 import {
   IMultiLineDiffChangeResult,
   computeMultiLineDiffChanges,
   mergeMultiLineDiffChanges,
   wordChangesToLineChangesMap,
 } from './diff-computer';
-import { IIntelligentCompletionsResult } from './intelligent-completions';
-import { IntelligentCompletionsRegistry } from './intelligent-completions.feature.registry';
-import { InlineCompletionsSource } from './intelligent-completions.source';
-import { MultiLineDecorationModel } from './multi-line.decoration';
+import { LintErrorCodeEditsSource } from './lint-error.source';
+
+import { ICodeEditsResult } from '.';
 
 export class IntelligentCompletionsController extends BaseAIMonacoEditorController {
   public static readonly ID = 'editor.contrib.ai.intelligent.completions';
@@ -46,10 +39,6 @@ export class IntelligentCompletionsController extends BaseAIMonacoEditorControll
     return editor.getContribution<IntelligentCompletionsController>(IntelligentCompletionsController.ID);
   }
 
-  private get intelligentCompletionsRegistry(): IntelligentCompletionsRegistry {
-    return this.injector.get(IntelligentCompletionsRegistryToken);
-  }
-
   private get model(): ITextModel {
     return this.monacoEditor.getModel()!;
   }
@@ -129,6 +118,19 @@ export class IntelligentCompletionsController extends BaseAIMonacoEditorControll
             }
           }),
         );
+
+        observableDisposable.addDispose(
+          autorun((reader) => {
+            const state = inlineCompletionsController.model.read(reader)?.state.read(reader);
+            const suggestController = SuggestController.get(this.monacoEditor);
+            // 当阴影字符超出一行的时候，强制让 suggest 面板向上展示，避免遮挡补全内容
+            if (state && state.primaryGhostText?.lineCount >= 2) {
+              suggestController?.forceRenderingAbove();
+            } else {
+              suggestController?.stopForceRenderingAbove();
+            }
+          }),
+        );
       }
     };
 
@@ -169,45 +171,30 @@ export class IntelligentCompletionsController extends BaseAIMonacoEditorControll
     }
   }
 
-  public async fetchProvider(bean: IAICompletionOption): Promise<IIntelligentCompletionsResult | undefined> {
-    const provider = this.intelligentCompletionsRegistry.getProvider();
-    if (!provider) {
-      return;
-    }
-
+  public async fetchProvider(editsResult: ICodeEditsResult): Promise<void> {
     // 如果上一次补全结果还在，则不重复请求
     const isVisible = this.aiNativeContextKey.multiLineEditsIsVisible.get();
     if (isVisible) {
       return;
     }
 
-    const position = this.monacoEditor.getPosition()!;
-    const intelligentCompletionModel = await provider(this.monacoEditor, position, bean, this.token);
-
-    if (
-      intelligentCompletionModel &&
-      intelligentCompletionModel.enableMultiLine &&
-      intelligentCompletionModel.items.length > 0
-    ) {
-      return this.applyInlineDecorations(intelligentCompletionModel);
+    if (editsResult && editsResult.items.length > 0) {
+      this.applyInlineDecorations(editsResult);
     }
-
-    return intelligentCompletionModel;
   }
 
-  private applyInlineDecorations(completionModel: IIntelligentCompletionsResult) {
+  private applyInlineDecorations(completionModel: ICodeEditsResult) {
     const { items } = completionModel;
-
-    const position = this.monacoEditor.getPosition()!;
-    const model = this.monacoEditor.getModel();
     const { range, insertText } = items[0];
-    const insertTextString = insertText.toString();
 
-    // 如果只是开启了 enableMultiLine 而没有传递 range ，则不显示 multi line
+    // code edits 必须提供 range
     if (!range) {
-      return completionModel;
+      return;
     }
 
+    const position = this.monacoEditor.getPosition()!;
+    const model = this.monacoEditor.getModel();
+    const insertTextString = insertText.toString();
     const originalContent = model?.getValueInRange(range);
     const eol = this.model.getEOL();
 
@@ -390,7 +377,7 @@ export class IntelligentCompletionsController extends BaseAIMonacoEditorControll
       }),
     );
 
-    const inlineCompletionsSource = this.injector.get(InlineCompletionsSource, [this.monacoEditor]);
-    this.featureDisposable.addDispose(inlineCompletionsSource.fetch());
+    const lintErrorCodeEditsSource = this.injector.get(LintErrorCodeEditsSource, [this.monacoEditor, this.token]);
+    this.featureDisposable.addDispose(lintErrorCodeEditsSource.mount());
   }
 }

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

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

package/src/browser/contrib/intelligent-completions/lint-error.source.ts

@@ -0,0 +1,130 @@
+import { Autowired, Injectable, Optional } from '@opensumi/di';
+import {
+  CancellationToken,
+  Disposable,
+  IDisposable,
+  IntelligentCompletionsRegistryToken,
+} from '@opensumi/ide-core-common';
+import { ICodeEditor, ICursorPositionChangedEvent, IPosition, Position } from '@opensumi/ide-monaco';
+import { URI } from '@opensumi/ide-monaco/lib/browser/monaco-api';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+import { StandaloneServices } from '@opensumi/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import {
+  IMarker,
+  IMarkerService,
+  IRelatedInformation,
+  MarkerSeverity,
+} from '@opensumi/monaco-editor-core/esm/vs/platform/markers/common/markers';
+
+import { IntelligentCompletionsController } from './intelligent-completions.controller';
+import { IntelligentCompletionsRegistry } from './intelligent-completions.feature.registry';
+
+import { ECodeEditsSource } from '.';
+
+export interface ILinterErrorData {
+  relativeWorkspacePath: string;
+  errors: Array<IMarkerErrorData>;
+}
+
+export interface IMarkerErrorData {
+  message: string;
+  range: {
+    startPosition: IPosition;
+    endPosition: IPosition;
+  };
+  source: URI;
+  severity: string;
+  relatedInformation?: IRelatedInformation[];
+}
+
+namespace MarkerErrorData {
+  export function toData(marker: IMarker): IMarkerErrorData {
+    return {
+      message: marker.message,
+      range: {
+        startPosition: {
+          lineNumber: marker.startLineNumber,
+          column: marker.startColumn,
+        },
+        endPosition: {
+          lineNumber: marker.endLineNumber,
+          column: marker.endColumn,
+        },
+      },
+      source: marker.resource,
+      relatedInformation: marker.relatedInformation,
+      severity: MarkerSeverity.toString(marker.severity),
+    };
+  }
+}
+
+@Injectable({ multiple: true })
+export class LintErrorCodeEditsSource extends Disposable {
+  @Autowired(IntelligentCompletionsRegistryToken)
+  private readonly intelligentCompletionsRegistry: IntelligentCompletionsRegistry;
+
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  private get model() {
+    return this.monacoEditor.getModel();
+  }
+
+  constructor(
+    @Optional() private readonly monacoEditor: ICodeEditor,
+    @Optional() private readonly token: CancellationToken,
+  ) {
+    super();
+  }
+
+  public mount(): IDisposable {
+    let prePosition = this.monacoEditor.getPosition();
+
+    this.addDispose(
+      // 仅在光标的行号发生变化时，才触发
+      this.monacoEditor.onDidChangeCursorPosition((event: ICursorPositionChangedEvent) => {
+        const currentPosition = event.position;
+        if (prePosition && prePosition.lineNumber !== currentPosition.lineNumber) {
+          this.doTrigger(currentPosition);
+        }
+        prePosition = currentPosition;
+      }),
+    );
+    return this;
+  }
+
+  private async doTrigger(position: Position) {
+    if (!this.model) {
+      return;
+    }
+
+    const markerService = StandaloneServices.get(IMarkerService);
+    const resource = this.model.uri;
+
+    let markers = markerService.read({ resource, severities: MarkerSeverity.Error });
+    markers = markers.filter((marker) => Math.abs(marker.startLineNumber - position.lineNumber) <= 1);
+
+    if (markers.length) {
+      const provider = this.intelligentCompletionsRegistry.getCodeEditsProvider();
+      if (provider) {
+        const relativeWorkspacePath = await this.workspaceService.asRelativePath(resource.path);
+        const result = await provider(
+          this.monacoEditor,
+          position,
+          {
+            typing: ECodeEditsSource.LinterErrors,
+            data: {
+              relativeWorkspacePath: relativeWorkspacePath?.path ?? resource.path,
+              errors: markers.map((marker) => MarkerErrorData.toData(marker)),
+            },
+          },
+          this.token,
+        );
+
+        if (result) {
+          IntelligentCompletionsController.get(this.monacoEditor)?.fetchProvider(result);
+        }
+      }
+    }
+  }
+}

package/src/browser/contrib/terminal/ai-terminal.service.ts

@@ -1,4 +1,4 @@
-import { IMarker } from 'xterm';
+import { IMarker } from '@xterm/xterm';
 
 import { Autowired, Injectable } from '@opensumi/di';
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native';

package/src/browser/contrib/terminal/decoration/terminal-decoration.tsx

@@ -1,6 +1,6 @@
+import { IDecoration, IMarker, Terminal } from '@xterm/xterm';
 import React from 'react';
 import { Root, createRoot } from 'react-dom/client';
-import { IDecoration, IMarker, Terminal } from 'xterm';
 
 import { Autowired, Injectable } from '@opensumi/di';
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native';

package/src/browser/contrib/terminal/ps1-terminal.service.tsx

@@ -1,7 +1,7 @@
+import { IDecoration, IDisposable, IMarker, Terminal } from '@xterm/xterm';
 import domAlign from 'dom-align';
 import React from 'react';
 import { Root, createRoot } from 'react-dom/client';
-import { IDecoration, IDisposable, IMarker, Terminal } from 'xterm';
 
 import { Autowired, Injectable } from '@opensumi/di';
 import { localize } from '@opensumi/ide-core-browser';