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

package/src/browser/widget/inline-input/inline-input.module.less

@@ -5,3 +5,7 @@
 .input_wrapper {
   transform: translateY(-4px);
 }
+
+.input_decoration_pending_container {
+  background-color: var(--vscode-diffEditor-unchangedCodeBackground);
+}

package/src/browser/widget/inline-input/inline-input.service.ts

@@ -1,27 +1,106 @@
-import { Injectable } from '@opensumi/di';
-import { Emitter, Event } from '@opensumi/ide-core-common';
-import { Position } from '@opensumi/ide-monaco';
+import { Autowired, Injectable } from '@opensumi/di';
+import { KeybindingRegistry } from '@opensumi/ide-core-browser';
+import { AI_INLINE_CHAT_INTERACTIVE_INPUT_VISIBLE } from '@opensumi/ide-core-browser/lib/ai-native/command';
+import { Disposable, Emitter, Event, IDisposable } from '@opensumi/ide-core-common';
+import { ICodeEditor, Position, Selection } from '@opensumi/ide-monaco';
+
+import { LanguageParserService } from '../../languages/service';
+import { ERunStrategy, IInteractiveInputHandler, IInteractiveInputRunStrategy } from '../../types';
+
+import { InteractiveInputModel } from './model';
 
 @Injectable()
-export class InlineInputChatService {
-  private _currentVisiblePosition: Position | undefined;
-  public get currentVisiblePosition(): Position | undefined {
-    return this._currentVisiblePosition;
-  }
+export class InlineInputService extends Disposable {
+  @Autowired(KeybindingRegistry)
+  private readonly keybindingRegistry: KeybindingRegistry;
+
+  @Autowired(LanguageParserService)
+  private readonly languageParserService: LanguageParserService;
+
+  private interactiveInputModel: InteractiveInputModel = new InteractiveInputModel();
 
   private readonly _onInteractiveInputVisibleInPosition = new Emitter<Position | undefined>();
   public readonly onInteractiveInputVisibleInPosition: Event<Position | undefined> =
     this._onInteractiveInputVisibleInPosition.event;
 
-  public setCurrentVisiblePosition(position: Position | undefined): void {
-    this._currentVisiblePosition = position;
+  private readonly _onInteractiveInputVisibleInSelection = new Emitter<Selection | undefined>();
+  public readonly onInteractiveInputVisibleInSelection: Event<Selection | undefined> =
+    this._onInteractiveInputVisibleInSelection.event;
+
+  private readonly _onHidden = new Emitter<void>();
+  public readonly onHidden: Event<void> = this._onHidden.event;
+
+  public visibleByPosition(position: Position): void {
+    this._onInteractiveInputVisibleInPosition.fire(position);
+  }
+
+  public visibleBySelection(selection: Selection): void {
+    this._onInteractiveInputVisibleInSelection.fire(selection);
   }
 
-  public visible(): void {
-    this._onInteractiveInputVisibleInPosition.fire(this._currentVisiblePosition);
+  public async visibleByNearestCodeBlock(position: Position, monacoEditor: ICodeEditor): Promise<void> {
+    const codeBlock = await this.findNearestCodeBlockWithPosition(position, monacoEditor);
+    if (codeBlock) {
+      this.visibleBySelection(codeBlock);
+    }
   }
 
   public hide(): void {
-    this._onInteractiveInputVisibleInPosition.fire(undefined);
+    this._onHidden.fire();
+  }
+
+  public getInteractiveInputHandler(): IInteractiveInputHandler | undefined {
+    return this.interactiveInputModel.handler();
+  }
+
+  public getInteractiveInputStrategyHandler() {
+    return this.interactiveInputModel.strategyHandler();
+  }
+
+  // 根据光标位置自动检测并选中临近的代码块
+  private async findNearestCodeBlockWithPosition(
+    position: Position,
+    monacoEditor: ICodeEditor,
+  ): Promise<Selection | undefined> {
+    const editorModel = monacoEditor.getModel();
+    const cursor = editorModel?.getOffsetAt(position);
+    const language = editorModel?.getLanguageId();
+    const parser = this.languageParserService.createParser(language!);
+    const codeBlock = await parser?.findNearestCodeBlockWithPosition(editorModel?.getValue() || '', cursor!);
+
+    if (codeBlock) {
+      return new Selection(
+        codeBlock.range.start.line + 1,
+        codeBlock.range.start.character,
+        codeBlock.range.end.line + 1,
+        codeBlock.range.end.character,
+      );
+    }
+
+    return undefined;
+  }
+
+  public getSequenceKeyString() {
+    const keybindings = this.keybindingRegistry.getKeybindingsForCommand(AI_INLINE_CHAT_INTERACTIVE_INPUT_VISIBLE.id);
+    const resolved = keybindings[0]?.resolved;
+    if (!resolved) {
+      return '';
+    }
+    return this.keybindingRegistry.acceleratorForSequence(resolved, '+');
+  }
+
+  public registerInlineInput(
+    runStrategy: IInteractiveInputRunStrategy,
+    handler: IInteractiveInputHandler,
+  ): IDisposable {
+    this.interactiveInputModel.setHandler(handler);
+
+    if (runStrategy.handleStrategy) {
+      this.interactiveInputModel.setStrategyHandler(runStrategy.handleStrategy);
+    } else {
+      this.interactiveInputModel.setStrategyHandler(() => runStrategy.strategy || ERunStrategy.EXECUTE);
+    }
+
+    return this.interactiveInputModel;
   }
 }

package/src/browser/widget/inline-input/model.ts

@@ -0,0 +1,74 @@
+import { InteractiveInput } from '@opensumi/ide-core-browser/lib/components/ai-native';
+import { MaybePromise, uuid } from '@opensumi/ide-core-common';
+import { ICodeEditor, IPosition, Selection } from '@opensumi/ide-monaco';
+
+import { ERunStrategy, IInteractiveInputHandler } from '../../types';
+
+type TRunStrategyFn = (editor: ICodeEditor, value: string) => MaybePromise<ERunStrategy>;
+
+export class InteractiveInputModel {
+  static ID: string = `${InteractiveInput.displayName}:${uuid(4)}`;
+
+  private _handler: IInteractiveInputHandler | undefined;
+  private _strategyHandler: TRunStrategyFn;
+
+  public setHandler(h: IInteractiveInputHandler): void {
+    this._handler = h;
+  }
+
+  public handler(): IInteractiveInputHandler | undefined {
+    return this._handler;
+  }
+
+  public setStrategyHandler(fn: TRunStrategyFn): void {
+    this._strategyHandler = fn;
+  }
+
+  public strategyHandler(): TRunStrategyFn {
+    return this._strategyHandler;
+  }
+
+  public dispose(): void {
+    this._handler = undefined;
+  }
+}
+
+export class InlineInputWidgetStoreInEmptyLine {
+  constructor(private position: IPosition, private value?: string) {}
+
+  public getPosition(): IPosition {
+    return this.position;
+  }
+
+  public setPosition(position: IPosition): void {
+    this.position = position;
+  }
+
+  public getValue(): string | undefined {
+    return this.value;
+  }
+
+  public setValue(value: string): void {
+    this.value = value;
+  }
+}
+
+export class InlineInputWidgetStoreInSelection {
+  constructor(private selection: Selection, private value?: string) {}
+
+  public getSelection(): Selection {
+    return this.selection;
+  }
+
+  public setSelection(selection: Selection): void {
+    this.selection = selection;
+  }
+
+  public getValue(): string | undefined {
+    return this.value;
+  }
+
+  public setValue(value: string): void {
+    this.value = value;
+  }
+}

package/src/browser/widget/inline-stream-diff/inline-stream-diff.handler.tsx

@@ -3,6 +3,7 @@ import { Disposable, Emitter, Event, FRAME_THREE, Schemes, Uri, randomString, sl
 import { ISingleEditOperation } from '@opensumi/ide-editor';
 import { ICodeEditor, ITextModel, Range, Selection } from '@opensumi/ide-monaco';
 import { StandaloneServices } from '@opensumi/ide-monaco/lib/browser/monaco-api/services';
+import { ISettableObservable, observableValue, transaction } from '@opensumi/ide-monaco/lib/common/observable';
 import { LineRange } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/lineRange';
 import { linesDiffComputers } from '@opensumi/monaco-editor-core/esm/vs/editor/common/diff/linesDiffComputers';
 import { DetailedLineRangeMapping } from '@opensumi/monaco-editor-core/esm/vs/editor/common/diff/rangeMapping';
@@ -15,7 +16,7 @@ import { IDiffPreviewerOptions, IInlineDiffPreviewerNode } from '../inline-diff/
 
 import { InlineStreamDiffComputer } from './inline-stream-diff-computer';
 import { IRemovedWidgetState } from './live-preview.component';
-import { ILivePreviewDiffDecorationSnapshotData, LivePreviewDiffDecorationModel } from './live-preview.decoration';
+import { LivePreviewDiffDecorationModel } from './live-preview.decoration';
 
 interface IRangeChangeData {
   removedTextLines: string[];
@@ -29,7 +30,7 @@ interface IRangeChangeData {
     | undefined;
 }
 
-interface IComputeDiffData {
+export interface IComputeDiffData {
   newFullRangeTextLines: string[];
   changes: IRangeChangeData[];
   activeLine: number;
@@ -41,14 +42,6 @@ export enum EComputerMode {
   default = 'default',
 }
 
-export interface IInlineStreamDiffSnapshotData {
-  rawOriginalTextLines: string[];
-  rawOriginalTextLinesTokens: LineTokens[];
-  undoRedoGroup: UndoRedoGroup;
-  decorationSnapshotData: ILivePreviewDiffDecorationSnapshotData;
-  previewerOptions: IDiffPreviewerOptions;
-}
-
 const inlineStreamDiffComputer = new InlineStreamDiffComputer();
 
 @Injectable({ multiple: true })
@@ -64,18 +57,21 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
   private originalModel: ITextModel;
   private virtualModel: ITextModel;
 
-  // Parts that require snapshots
   private rawOriginalTextLines: string[];
   private rawOriginalTextLinesTokens: LineTokens[] = [];
-  private undoRedoGroup: UndoRedoGroup;
+  private undoRedoGroup: UndoRedoGroup = new UndoRedoGroup();
+
+  private readonly diffModel: ISettableObservable<IComputeDiffData | undefined> = observableValue(this, undefined);
+  private readonly finallyDiffModel: ISettableObservable<IComputeDiffData | undefined> = observableValue(
+    this,
+    undefined,
+  );
 
   public livePreviewDiffDecorationModel: LivePreviewDiffDecorationModel;
 
   constructor(private readonly monacoEditor: ICodeEditor) {
     super();
 
-    this.undoRedoGroup = new UndoRedoGroup();
-
     const modelService = StandaloneServices.get(IModelService);
     this.virtualModel = modelService.createModel(
       '',
@@ -136,44 +132,6 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
     this.livePreviewDiffDecorationModel.initialize(zone);
   }
 
-  private _snapshotStore: IInlineStreamDiffSnapshotData | undefined;
-  restoreSnapshot(snapshot: IInlineStreamDiffSnapshotData): void {
-    this._snapshotStore = snapshot;
-    const {
-      rawOriginalTextLines,
-      rawOriginalTextLinesTokens,
-      undoRedoGroup,
-      decorationSnapshotData,
-      previewerOptions,
-    } = snapshot;
-
-    this.setPreviewerOptions(previewerOptions);
-
-    this.rawOriginalTextLines = rawOriginalTextLines;
-    this.rawOriginalTextLinesTokens = rawOriginalTextLinesTokens;
-    this.undoRedoGroup = undoRedoGroup;
-
-    this.livePreviewDiffDecorationModel.initialize(decorationSnapshotData.zone);
-  }
-
-  get currentSnapshotStore(): IInlineStreamDiffSnapshotData | undefined {
-    return this._snapshotStore;
-  }
-
-  restoreDecorationSnapshot(decorationSnapshotData: ILivePreviewDiffDecorationSnapshotData): void {
-    this.livePreviewDiffDecorationModel.restoreSnapshot(decorationSnapshotData);
-  }
-
-  createSnapshot(): IInlineStreamDiffSnapshotData {
-    return {
-      rawOriginalTextLines: this.rawOriginalTextLines,
-      rawOriginalTextLinesTokens: this.rawOriginalTextLinesTokens,
-      undoRedoGroup: this.undoRedoGroup,
-      decorationSnapshotData: this.livePreviewDiffDecorationModel.createSnapshot(),
-      previewerOptions: this.previewerOptions,
-    };
-  }
-
   getVirtualModelValue() {
     return this.virtualModel.getValue();
   }
@@ -328,7 +286,9 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
       preRemovedLen += removedLinesOriginalRange.length - addedRange.length;
     }
 
-    this.livePreviewDiffDecorationModel.touchRemovedWidget(states);
+    this.livePreviewDiffDecorationModel.touchRemovedWidget(states, () => {
+      this._onDidEditChange.fire();
+    });
   }
 
   /**
@@ -343,7 +303,7 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
     });
   }
 
-  private handleEdits(diffModel: IComputeDiffData): void {
+  private renderDiffEdits(diffModel: IComputeDiffData): void {
     const { activeLine, newFullRangeTextLines, pendingRange } = diffModel;
     const eol = this.originalModel.getEOL();
     const zone = this.getZone();
@@ -464,9 +424,8 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
   }
 
   private currentEditLine = 0;
-  private finallyDiffModel: IComputeDiffData | null = null;
   private isEditing = false;
-  private async rateEditController(): Promise<void> {
+  public async rateRenderEditController(): Promise<void> {
     if (this.isEditing === false) {
       this.isEditing = true;
 
@@ -478,15 +437,22 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
         const virtualTextLines = this.virtualModel.getLinesContent();
         const currentText = virtualTextLines.slice(0, this.currentEditLine);
         const currentDiffModel = this.computeDiff(this.rawOriginalTextLines, currentText);
-        this.handleEdits(currentDiffModel);
+        transaction((tx) => {
+          this.diffModel.set(currentDiffModel, tx);
+        });
+
+        if (this.originalModel.id === this.monacoEditor.getModel()?.id) {
+          this.renderDiffEdits(currentDiffModel);
+        }
 
         this.currentEditLine += 1;
 
         await sleep(FRAME_THREE);
       }
 
-      if (this.finallyDiffModel) {
-        this.finallyRender(this.finallyDiffModel);
+      const finallyDiffModel = this.finallyDiffModel.get();
+      if (finallyDiffModel) {
+        this.finallyRender(finallyDiffModel);
       }
 
       this.isEditing = false;
@@ -494,27 +460,48 @@ export class InlineStreamDiffHandler extends Disposable implements IInlineDiffPr
   }
 
   public addLinesToDiff(newText: string, computerMode: EComputerMode = EComputerMode.default): void {
-    this.recompute(computerMode, newText);
-    this.rateEditController();
+    const diffModel = this.recompute(computerMode, newText);
+    transaction((tx) => {
+      this.diffModel.set(diffModel, tx);
+    });
   }
 
   public pushRateFinallyDiffStack(diffModel: IComputeDiffData): void {
-    this.finallyDiffModel = diffModel;
-
-    // 可能存在 rate editr controller 处理完之后接口层流式才结束
+    // 可能存在 rate editor controller 处理完之后接口层流式才结束
     if (this.isEditing === false) {
-      this.finallyRender(this.finallyDiffModel);
+      this.finallyRender(diffModel);
     }
   }
 
   public finallyRender(diffModel: IComputeDiffData): void {
-    // 流式结束后才会确定所有的 added range，再渲染 partial edit widgets
+    transaction((tx) => {
+      this.finallyDiffModel.set(diffModel, tx);
+      this.diffModel.set(diffModel, tx);
+    });
+
+    if (this.originalModel.id !== this.monacoEditor.getModel()?.id) {
+      return;
+    }
+
     this.renderPartialEditWidgets(diffModel);
-    this.handleEdits(diffModel);
+    this.renderDiffEdits(diffModel);
     this.pushStackElement();
     this.monacoEditor.focus();
   }
 
+  public hide(): void {
+    this.livePreviewDiffDecorationModel.hide();
+  }
+
+  public resume(): void {
+    const finallyDiffModel = this.finallyDiffModel.get();
+    if (!finallyDiffModel) {
+      this.rateRenderEditController();
+    }
+
+    this.livePreviewDiffDecorationModel.resume();
+  }
+
   acceptAll(): void {
     this.livePreviewDiffDecorationModel.acceptUnProcessed();
     this.dispose();

package/src/browser/widget/inline-stream-diff/live-preview.component.tsx

@@ -21,6 +21,11 @@ import { LineTokens } from '@opensumi/monaco-editor-core/esm/vs/editor/common/to
 import { IOptions, ZoneWidget } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget';
 import { UndoRedoGroup } from '@opensumi/monaco-editor-core/esm/vs/platform/undoRedo/common/undoRedo';
 
+import {
+  DeltaDecorations,
+  EnhanceDecorationsCollection,
+  IDeltaDecorationsOptions,
+} from '../../model/enhanceDecorationsCollection';
 import { renderLines } from '../ghost-text-widget/index';
 
 import styles from './inline-stream-diff.module.less';
@@ -34,7 +39,7 @@ interface IPartialEditWidgetComponent {
   discardSequence: string;
 }
 
-export type IWidgetStatus = 'accept' | 'discard' | 'pending';
+type IWidgetStatus = 'accept' | 'discard' | 'pending';
 
 export interface IRemovedWidgetState {
   textLines: ITextLinesTokens[];
@@ -141,7 +146,7 @@ export class AcceptPartialEditWidget extends ReactInlineContentWidget {
   private readonly keybindingRegistry: KeybindingRegistry;
 
   private _id: string;
-  private _decorationId: string;
+  private _addedRangeId: string;
 
   private readonly _onAccept = this.registerDispose(new Emitter<void>());
   public readonly onAccept: Event<void> = this._onAccept.event;
@@ -209,12 +214,12 @@ export class AcceptPartialEditWidget extends ReactInlineContentWidget {
     return styles.accept_partial_edit_widget_id;
   }
 
-  public recordDecorationId(id: string): void {
-    this._decorationId = id;
+  public recordAddedRangeId(id: string): void {
+    this._addedRangeId = id;
   }
 
-  public getDecorationId(): string {
-    return this._decorationId;
+  public getAddedRangeId(): string {
+    return this._addedRangeId;
   }
 
   public resume(): void {
@@ -314,6 +319,8 @@ export class RemovedZoneWidget extends ZoneWidget {
     return this._group;
   }
 
+  public status: IWidgetStatus = 'pending';
+
   constructor(editor: ICodeEditor, public readonly textLines: ITextLinesTokens[], options: IRemovedZoneWidgetOptions) {
     super(editor, options);
 
@@ -362,12 +369,23 @@ export class RemovedZoneWidget extends ZoneWidget {
     return this.position || this._recordPosition;
   }
 
+  accept(): void {
+    this.status = 'accept';
+    this.hide();
+  }
+
+  discard(): void {
+    this.status = 'discard';
+    super.hide();
+  }
+
   hide(): void {
     this._hidden = true;
     super.hide();
   }
 
   resume(): void {
+    this.status = 'pending';
     const position = this.getLastPosition();
     if (position) {
       this.show(position, this.height);
@@ -376,6 +394,7 @@ export class RemovedZoneWidget extends ZoneWidget {
 
   override show(pos: IPosition, heightInLines: number): void {
     this._hidden = false;
+    this.status = 'pending';
     super.show(pos, heightInLines);
   }
 
@@ -407,3 +426,23 @@ export class RemovedZoneWidget extends ZoneWidget {
     super.dispose();
   }
 }
+
+class AddedRangeDeltaDecorations extends DeltaDecorations {
+  public status: IWidgetStatus = 'pending';
+
+  accept(): void {
+    this.status = 'accept';
+    super.hide();
+  }
+
+  discard(): void {
+    this.status = 'discard';
+    super.hide();
+  }
+}
+
+export class AddedRangeDecorationsCollection extends EnhanceDecorationsCollection<AddedRangeDeltaDecorations> {
+  protected override createDecorations(metaData: IDeltaDecorationsOptions) {
+    return new AddedRangeDeltaDecorations(metaData);
+  }
+}