@opensumi/ide-ai-native 3.7.1-next-1739430207.0 → 3.7.1-next-1739439717.0

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

@@ -6,18 +6,12 @@ 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';
@@ -33,8 +27,6 @@ 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';
 
@@ -46,68 +38,106 @@ 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 previewerStore: Map<string, IInlineDiffPreviewer>;
-  private currentPreviewer: ISettableObservable<IInlineDiffPreviewer | undefined>;
-  private modelChangeObs: IObservable<monaco.editor.ITextModel, unknown>;
+  private previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined;
+  private _previewerNodeStore = new Map<string, InlineStreamDiffHandler | null>();
 
   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(
-      autorun((reader) => {
-        const model = this.modelChangeObs.read(reader);
-        if (!model) {
-          return;
-        }
+      this.eventBus.on(EditorGroupCloseEvent, (e: EditorGroupCloseEvent) => {
+        const uriString = e.payload.resource.uri.toString();
+        const node = this.getStoredState(uriString);
 
-        /**
-         * 切换到其他 model 且 previewer 未卸载时
-         * 保留 previewer 的实例，仅卸载 previewer 的渲染层
-         */
-        const id = model.id;
-        const previewer = this.currentPreviewer.read(reader);
-        if (previewer && previewer.modelId !== id && !previewer.disposed) {
-          previewer.hide();
+        if (node && node.previewerOptions.disposeWhenEditorClosed) {
+          this.destroyPreviewer(uriString);
         }
-
-        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;
   }
 
-  getPreviewer(): IInlineDiffPreviewer | undefined {
-    return this.currentPreviewer.get();
+  storeState(key: string) {
+    if (!this.previewer) {
+      return;
+    }
+
+    // 存储的是快照
+    const node = this.previewer.createNodeSnapshot();
+    if (node) {
+      this._previewerNodeStore.set(key, node as InlineStreamDiffHandler);
+    }
   }
 
-  private renderDiff(previewer: IInlineDiffPreviewer, data: ReplyResponse) {
-    if (!previewer) {
+  tryRestoreState(monacoEditor: monaco.ICodeEditor, key: string) {
+    const node = this.getStoredState(key);
+    if (!node) {
       return;
     }
 
-    previewer.onData(data);
+    if (node.disposed) {
+      this.destroyPreviewer(key);
+      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());
+      }),
+    );
 
-    // 仅在当前 model 中进行流式渲染
-    if (this.modelChangeObs.get()?.id === previewer.modelId) {
-      previewer.render();
+    if (model) {
+      this.featureDisposable.addDispose(
+        model.onWillDispose(() => {
+          const uriString = model.uri.toString();
+          this.destroyPreviewer(uriString);
+        }),
+      );
     }
   }
 
@@ -124,10 +154,6 @@ 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();
@@ -142,7 +168,7 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
           disposable.addDispose([
             controller.onData((data) => {
               if (ReplyResponse.is(data)) {
-                this.renderDiff(previewer, data);
+                previewer.onData(data);
               }
             }),
             controller.onError((error) => {
@@ -177,61 +203,59 @@ export class InlineDiffController extends BaseAIMonacoEditorController {
       EInlineDiffPreviewMode.inlineLive,
     );
 
-    let previewer: IInlineDiffPreviewer;
+    this.destroyPreviewer();
 
     if (inlineDiffMode === EInlineDiffPreviewMode.sideBySide) {
-      previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
+      this.previewer = this.injector.get(SideBySideInlineDiffWidget, [monacoEditor]);
     } else {
-      previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
+      this.previewer = this.injector.get(LiveInlineDiffPreviewer, [monacoEditor]);
     }
 
-    previewer.create(selection, options);
-    previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
+    this.previewer.create(selection, options);
+    this.previewer.show(selection.startLineNumber - 1, selection.endLineNumber - selection.startLineNumber + 2);
 
-    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
+    this.listenPreviewer(this.previewer);
 
-    previewer.addDispose(
-      Disposable.create(() => {
-        this.previewerStore.delete(previewer.modelId);
-      }),
-    );
-
-    return previewer;
+    return this.previewer;
   }
 
-  handleAction(action: EResultKind): void {
-    const previewer = this.getPreviewer();
+  private listenPreviewer(previewer: BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined) {
     if (!previewer) {
       return;
     }
 
-    previewer.handleAction(action);
+    previewer.addDispose(previewer.onLineCount((lineCount) => this._onMaxLineCount.fire(lineCount)));
   }
 
-  getModifyContent() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
-    }
+  getPreviewer(): BaseInlineDiffPreviewer<InlineDiffWidget | InlineStreamDiffHandler> | undefined {
+    return this.previewer;
+  }
 
-    return previewer.getValue();
+  getStoredState(uri: string) {
+    return this._previewerNodeStore.get(uri);
   }
 
-  getOriginContent() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
-    }
+  handleAction(action: EResultKind): void {
+    this.previewer?.handleAction(action);
+  }
+
+  getModifyContent() {
+    return this.previewer?.getValue();
+  }
 
-    return previewer.getOriginValue();
+  getOriginContent() {
+    return this.previewer?.getOriginValue();
   }
 
-  revealFirstDiff() {
-    const previewer = this.getPreviewer();
-    if (!previewer) {
-      return;
+  destroyPreviewer(uriString?: string) {
+    this.previewer?.dispose();
+    this.previewer = undefined;
+    if (uriString) {
+      this._previewerNodeStore.delete(uriString);
     }
+  }
 
-    previewer.revealFirstDiff();
+  revealFirstDiff() {
+    this.previewer?.revealFirstDiff();
   }
 }

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

@@ -1,12 +1,13 @@
 import throttle from 'lodash/throttle';
 
 import { Disposable, IDisposable } from '@opensumi/ide-core-common';
-import * as monaco from '@opensumi/ide-monaco';
 import { ICodeEditor } from '@opensumi/ide-monaco';
+import * as monaco 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';
@@ -22,6 +23,10 @@ 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);
   }
@@ -54,6 +59,7 @@ 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,9 +1,8 @@
 import React, { ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
 
-import { Injectable } from '@opensumi/di';
-import { AINativeConfigService, useInjectable } from '@opensumi/ide-core-browser';
+import { Autowired, Injectable } from '@opensumi/di';
 import { AIAction, InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
-import { AIInlineInputChatContentWidgetId, Disposable, Emitter, Event, localize } from '@opensumi/ide-core-common';
+import { AIInlineInputChatContentWidgetId, Disposable, 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';
@@ -11,24 +10,19 @@ 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 type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco';
+import { InlineInputChatService } from './inline-input.service';
 
 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 { defaultValue, onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick, onValueChange } =
-    props;
+  const { onClose, onInteractiveInputSend, onLayoutChange, onChatStatus, onResultClick } = props;
   const [status, setStatus] = useState<EInlineChatStatus>(EInlineChatStatus.READY);
-  const aiNativeConfigService = useInjectable<AINativeConfigService>(AINativeConfigService);
 
   useEffect(() => {
     const dis = new Disposable();
@@ -70,12 +64,10 @@ 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={aiNativeConfigService.inlineChat.inputWidth}
+          width={320}
           disabled={isLoading}
           onSend={handleInteractiveInputSend}
         />
@@ -85,26 +77,16 @@ const InlineInputWidgetRender = (props: IInlineInputWidgetRenderProps) => {
 };
 
 @Injectable({ multiple: true })
-export class InlineInputWidget extends AIInlineContentWidget {
+export class InlineInputChatWidget extends AIInlineContentWidget {
+  @Autowired(InlineInputChatService)
+  private inlineInputChatService: InlineInputChatService;
+
   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.inlineInputService.hide();
+    this.inlineInputChatService.hide();
   }
 
   override id(): string {
@@ -115,18 +97,14 @@ export class InlineInputWidget extends AIInlineContentWidget {
     return (
       <div className={styles.input_wrapper}>
         <InlineInputWidgetRender
-          defaultValue={this.defaultValue}
-          onClose={() => this._onClose.fire()}
+          onClose={() => this.dispose()}
           onChatStatus={this.onStatusChange.bind(this)}
           onLayoutChange={() => {
             this.editor.layoutContentWidget(this);
           }}
-          onValueChange={(value) => {
-            this._onValueChange.fire(value);
-          }}
           onInteractiveInputSend={(value) => {
             this.launchChatStatus(EInlineChatStatus.THINKING);
-            this._onSend.fire(value);
+            this._onInteractiveInputValue.fire(value);
           }}
           onResultClick={(k: EResultKind) => {
             this._onResultClick.fire(k);