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

package/src/browser/widget/inline-diff/inline-diff.controller.ts

@@ -6,12 +6,18 @@ import {
   Emitter,
   Event,
   IDisposable,
-  IEventBus,
   ReplyResponse,
 } from '@opensumi/ide-core-common';
-import { EditorGroupCloseEvent } from '@opensumi/ide-editor/lib/browser';
 import * as monaco from '@opensumi/ide-monaco';
 import { ICodeEditor } from '@opensumi/ide-monaco';
+import {
+  IObservable,
+  ISettableObservable,
+  autorun,
+  observableFromEvent,
+  observableValue,
+  transaction,
+} from '@opensumi/ide-monaco/lib/common/observable';
 
 import { BaseAIMonacoEditorController } from '../../contrib/base';
 import { EInlineDiffPreviewMode } from '../../preferences/schema';
@@ -27,6 +33,8 @@ import {
 } from './inline-diff-previewer';
 import { InlineDiffWidget } from './inline-diff-widget';
 
+type IInlineDiffPreviewer = BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler>;
+
 export class InlineDiffController extends BaseAIMonacoEditorController {
   public static readonly ID = 'editor.contrib.ai.inline.diff';
 
@@ -38,106 +46,68 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
     return this.injector.get(PreferenceService);
   }
 
-  private get eventBus(): IEventBus {
-    return this.injector.get(IEventBus);
-  }
-
   private readonly _onMaxLineCount = new Emitter<number>();
   public readonly onMaxLineCount: Event<number> = this._onMaxLineCount.event;
 
-  private previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined;
-  private _previewerNodeStore = new Map<string, InlineStreamDiffHandler | null>();
+  private previewerStore: Map<string, IInlineDiffPreviewer>;
+  private currentPreviewer: ISettableObservable<IInlineDiffPreviewer | undefined>;
+  private modelChangeObs: IObservable<monaco.editor.ITextModel>;
 
   mount(): IDisposable {
+    this.previewerStore = new Map();
+    this.currentPreviewer = observableValue(this, undefined);
+    this.modelChangeObs = observableFromEvent<monaco.editor.ITextModel>(
+      this,
+      this.monacoEditor.onDidChangeModel,
+      () => this.monacoEditor.getModel()!,
+    );
+
     this.featureDisposable.addDispose(
-      this.eventBus.on(EditorGroupCloseEvent, (e: EditorGroupCloseEvent) => {
-        const uriString = e.payload.resource.uri.toString();
-        const node = this.getStoredState(uriString);
+      autorun((reader) => {
+        const model = this.modelChangeObs.read(reader);
+        if (!model) {
+          return;
+        }
 
-        if (node && node.previewerOptions.disposeWhenEditorClosed) {
-          this.destroyPreviewer(uriString);
+        /**
+         * 切换到其他 model 且 previewer 未卸载时
+         * 保留 previewer 的实例，仅卸载 previewer 的渲染层
+         */
+        const id = model.id;
+        const previewer = this.currentPreviewer.get();
+        if (previewer && previewer.modelId !== id && !previewer.disposed) {
+          previewer.hide();
         }
+
+        const storedPreview = this.previewerStore.get(model.id);
+        transaction((tx) => {
+          if (storedPreview && storedPreview.modelId === id) {
+            this.currentPreviewer.set(storedPreview, tx);
+            storedPreview.resume();
+          } else {
+            this.currentPreviewer.set(undefined, tx);
+          }
+        });
       }),
     );
 
-    this.registerInlineDiffFeature(this.monacoEditor);
-
     return this.featureDisposable;
   }
 
-  storeState(key: string) {
-    if (!this.previewer) {
-      return;
-    }
-
-    // 存储的是快照
-    const node = this.previewer.createNodeSnapshot();
-    if (node) {
-      this._previewerNodeStore.set(key, node as InlineStreamDiffHandler);
-    }
+  getPreviewer(): IInlineDiffPreviewer | undefined {
+    return this.currentPreviewer.get();
   }
 
-  tryRestoreState(monacoEditor: monaco.ICodeEditor, key: string) {
-    const node = this.getStoredState(key);
-    if (!node) {
-      return;
-    }
-
-    if (node.disposed) {
-      this.destroyPreviewer(key);
+  private renderDiff(previewer: IInlineDiffPreviewer, data: ReplyResponse) {
+    if (!previewer) {
       return;
     }
 
-    return this.restoreState(monacoEditor, node);
-  }
-
-  restoreState(monacoEditor: monaco.ICodeEditor, node: InlineStreamDiffHandler) {
-    const uri = monacoEditor.getModel()?.uri;
-
-    if (uri) {
-      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
-      this.previewer.attachNode(node);
-      this.listenPreviewer(this.previewer);
-
-      const dispose = this.previewer.onDispose(() => {
-        this.destroyPreviewer();
-        dispose.dispose();
-      });
-    }
-  }
-
-  registerInlineDiffFeature(monacoEditor: monaco.ICodeEditor): void {
-    const model = monacoEditor.getModel();
-
-    this.featureDisposable.addDispose(
-      monacoEditor.onWillChangeModel((e) => {
-        if (!e.oldModelUrl) {
-          return;
-        }
-
-        const urlString = e.oldModelUrl.toString();
-        this.storeState(urlString);
-
-        this.destroyPreviewer();
-      }),
-    );
-
-    this.featureDisposable.addDispose(
-      monacoEditor.onDidChangeModel((e) => {
-        if (!e.newModelUrl) {
-          return;
-        }
-        this.tryRestoreState(monacoEditor, e.newModelUrl.toString());
-      }),
-    );
+    previewer.onData(data);
 
-    if (model) {
-      this.featureDisposable.addDispose(
-        model.onWillDispose(() => {
-          const uriString = model.uri.toString();
-          this.destroyPreviewer(uriString);
-        }),
-      );
+    // 仅在当前 model 中进行流式渲染
+    if (this.modelChangeObs.get()?.id === previewer.modelId) {
+      previewer.render();
     }
   }
 
@@ -154,6 +124,10 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
     const disposable = new Disposable();
 
     const previewer = this.createDiffPreviewer(monacoEditor, crossSelection, options.previewerOptions);
+    transaction((tx) => {
+      this.currentPreviewer.set(previewer, tx);
+      this.previewerStore.set(previewer.modelId, previewer);
+    });
 
     const onFinish = () => {
       previewer.layout();
@@ -168,7 +142,7 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
           disposable.addDispose([
             controller.onData((data) => {
               if (ReplyResponse.is(data)) {
-                previewer.onData(data);
+                this.renderDiff(previewer, data);
               }
             }),
             controller.onError((error) => {
@@ -203,59 +177,61 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
       EInlineDiffPreviewMode.inlineLive,
     );
 
-    this.destroyPreviewer();
+    let previewer: IInlineDiffPreviewer;
 
     if (inlineDiffMode === EInlineDiffPreviewMode.sideBySide) {
-      this.previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
+      previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
     } else {
-      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
+      previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
     }
 
-    this.previewer.create(selection, options);
-    this.previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
+    previewer.create(selection, options);
+    previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
 
-    this.listenPreviewer(this.previewer);
+    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
 
-    return this.previewer;
+    previewer.addDispose(
+      Disposable.create(() => {
+        this.previewerStore.delete(previewer.modelId);
+      }),
+    );
+
+    return previewer;
   }
 
-  private listenPreviewer(previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined) {
+  handleAction(action: EResultKind): void {
+    const previewer = this.getPreviewer();
     if (!previewer) {
       return;
     }
 
-    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
-  }
-
-  getPreviewer(): BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined {
-    return this.previewer;
-  }
-
-  getStoredState(uri: string) {
-    return this._previewerNodeStore.get(uri);
-  }
-
-  handleAction(action: EResultKind): void {
-    this.previewer?.handleAction(action);
+    previewer.handleAction(action);
   }
 
   getModifyContent() {
-    return this.previewer?.getValue();
-  }
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
+    }
 
-  getOriginContent() {
-    return this.previewer?.getOriginValue();
+    return previewer.getValue();
   }
 
-  destroyPreviewer(uriString?: string) {
-    this.previewer?.dispose();
-    this.previewer = undefined;
-    if (uriString) {
-      this._previewerNodeStore.delete(uriString);
+  getOriginContent() {
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
     }
+
+    return previewer.getOriginValue();
   }
 
   revealFirstDiff() {
-    this.previewer?.revealFirstDiff();
+    const previewer = this.getPreviewer();
+    if (!previewer) {
+      return;
+    }
+
+    previewer.revealFirstDiff();
   }
 }

package/src/browser/widget/inline-hint/inline-hint.controller.ts

@@ -1,13 +1,12 @@
 import throttle from 'lodash/throttle';
 
 import { Disposable, IDisposable } from '@opensumi/ide-core-common';
-import { ICodeEditor } from '@opensumi/ide-monaco';
 import * as monaco from '@opensumi/ide-monaco';
+import { ICodeEditor } from '@opensumi/ide-monaco';
 
 import { AINativeContextKey } from '../../ai-core.contextkeys';
 import { BaseAIMonacoEditorController } from '../../contrib/base';
 import { AICompletionsService } from '../../contrib/inline-completions/service/ai-completions.service';
-import { InlineInputChatService } from '../inline-input/inline-input.service';
 import { InlineInputPreviewDecorationID } from '../internal.type';
 
 import { InlineHintLineDecoration } from './inline-hint-line-widget';
@@ -23,10 +22,6 @@ export class InlineHintController extends BaseAIMonacoEditorController {
     return this.injector.get(AICompletionsService);
   }
 
-  private get inlineInputChatService(): InlineInputChatService {
-    return this.injector.get(InlineInputChatService);
-  }
-
   mount(): IDisposable {
     return this.registerHintLineFeature(this.monacoEditor);
   }
@@ -59,7 +54,6 @@ export class InlineHintController extends BaseAIMonacoEditorController {
         if (!lineContent?.trim()) {
           inlineHintLineDecoration.show(position);
         }
-        this.inlineInputChatService.setCurrentVisiblePosition(position);
 
         aiNativeContextKey.inlineHintWidgetIsVisible.set(true);
 

package/src/browser/widget/inline-input/inline-input-widget.tsx

@@ -1,8 +1,9 @@
 import React, { ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 
-import { Autowired, Injectable } from '@opensumi/di';
+import { Injectable } from '@opensumi/di';
+import { AINativeConfigService, useInjectable } from '@opensumi/ide-core-browser';
 import { AIAction, InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
-import { AIInlineInputChatContentWidgetId, Disposable, Event, localize } from '@opensumi/ide-core-common';
+import { AIInlineInputChatContentWidgetId, Disposable, Emitter, Event, localize } from '@opensumi/ide-core-common';
 import { ContentWidgetPositionPreference } from '@opensumi/ide-monaco/lib/browser/monaco-exports/editor';
 
 import { InlineResultAction } from '../inline-actions/result-items/index';
@@ -10,19 +11,24 @@ import { EInlineChatStatus, EResultKind } from '../inline-chat/inline-chat.servi
 import { AIInlineContentWidget } from '../inline-chat/inline-content-widget';
 
 import styles from './inline-input.module.less';
-import { InlineInputChatService } from './inline-input.service';
+
+import type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco';
 
 interface IInlineInputWidgetRenderProps {
+  defaultValue?: string;
   onLayoutChange: (height: number) => void;
   onClose?: () => void;
   onInteractiveInputSend?: (value: string) => void;
   onChatStatus: Event<EInlineChatStatus>;
   onResultClick: (k: EResultKind) => void;
+  onValueChange?: (value: string) => void;
 }
 
 const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
-  const { onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick } = props;
+  const { defaultValue, onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick, onValueChange } =
+    props;
   const [status, setStatus] = useState<EInlineChatStatus>(EInlineChatStatus.READY);
+  const aiNativeConfigService = useInjectable<AINativeConfigService>(AINativeConfigService);
 
   useEffect(() => {
     const dis = new Disposable();
@@ -64,10 +70,12 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
       customOperationRender={
         <InteractiveInput
           autoFocus
+          defaultValue={defaultValue}
+          onValueChange={onValueChange}
           onHeightChange={(height) => onLayoutChange(height)}
           size='small'
           placeholder={localize('aiNative.inline.chat.input.placeholder.default')}
-          width={320}
+          width={aiNativeConfigService.inlineChat.inputWidth}
           disabled={isLoading}
           onSend={handleInteractiveInputSend}
         />
@@ -77,16 +85,26 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
 };
 
 @Injectable({ multiple: true })
-export class InlineInputChatWidget extends AIInlineContentWidget {
-  @Autowired(InlineInputChatService)
-  private inlineInputChatService: InlineInputChatService;
-
+export class InlineInputWidget extends AIInlineContentWidget {
   allowEditorOverflow = true;
   positionPreference = [ContentWidgetPositionPreference.ABOVE];
 
+  protected readonly _onSend = new Emitter<string>();
+  public readonly onSend = this._onSend.event;
+
+  protected readonly _onClose = new Emitter<void>();
+  public readonly onClose = this._onClose.event;
+
+  protected readonly _onValueChange = new Emitter<string>();
+  public readonly onValueChange = this._onValueChange.event;
+
+  constructor(protected readonly editor: IMonacoCodeEditor, protected readonly defaultValue?: string) {
+    super(editor);
+  }
+
   override dispose(): void {
     super.dispose();
-    this.inlineInputChatService.hide();
+    this.inlineInputService.hide();
   }
 
   override id(): string {
@@ -97,14 +115,18 @@ export class InlineInputChatWidget extends AIInlineContentWidget {
     return (
       <div className={styles.input_wrapper}>
         <InlineInputWidgetRender
-          onClose={() => this.dispose()}
+          defaultValue={this.defaultValue}
+          onClose={() => this._onClose.fire()}
           onChatStatus={this.onStatusChange.bind(this)}
           onLayoutChange={() => {
             this.editor.layoutContentWidget(this);
           }}
+          onValueChange={(value) => {
+            this._onValueChange.fire(value);
+          }}
           onInteractiveInputSend={(value) => {
             this.launchChatStatus(EInlineChatStatus.THINKING);
-            this._onInteractiveInputValue.fire(value);
+            this._onSend.fire(value);
           }}
           onResultClick={(k: EResultKind) => {
             this._onResultClick.fire(k);