fix: better code

astandrik · astandrik · commit 66c28e3670df · 2025-02-04T14:29:43.000+03:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -28,7 +28,7 @@
     "@hookform/resolvers": "^3.10.0",
     "@reduxjs/toolkit": "^2.5.0",
     "@tanstack/react-table": "^8.20.6",
-    "@ydb-platform/monaco-ghost": "^0.1.8",
+    "@ydb-platform/monaco-ghost": "^0.1.10",
     "axios": "^1.7.9",
     "axios-retry": "^4.5.0",
     "colord": "^2.9.3",
diff --git a/src/containers/Tenant/Query/QueryEditor/YqlEditor.tsx b/src/containers/Tenant/Query/QueryEditor/YqlEditor.tsx
@@ -6,7 +6,6 @@ import throttle from 'lodash/throttle';
 import type Monaco from 'monaco-editor';
 
 import {MonacoEditor} from '../../../../components/MonacoEditor/MonacoEditor';
-import {codeAssistApi} from '../../../../store/reducers/codeAssist/codeAssist';
 import {
     goToNextQuery,
     goToPreviousQuery,
@@ -26,8 +25,9 @@ import {useUpdateErrorsHighlighting} from '../../../../utils/monaco/highlightErr
 import {QUERY_ACTIONS} from '../../../../utils/query';
 import {SAVE_QUERY_DIALOG} from '../SaveQuery/SaveQuery';
 import i18n from '../i18n';
+import {useSavedQueries} from '../utils/useSavedQueries';
 
-import {useEditorOptions} from './helpers';
+import {useCodeAssist, useEditorOptions} from './helpers';
 import {getKeyBindings} from './keybindings';
 
 const CONTEXT_MENU_GROUP_ID = 'navigation';
@@ -48,6 +48,7 @@ export function YqlEditor({
     const input = useTypedSelector(selectUserInput);
     const dispatch = useTypedDispatch();
     const historyQueries = useTypedSelector(selectQueriesHistory);
+    const savedQueries = useSavedQueries();
     const editorOptions = useEditorOptions();
     const updateErrorsHighlighting = useUpdateErrorsHighlighting();
 
@@ -72,21 +73,24 @@ export function YqlEditor({
         window.ydbEditor = undefined;
     };
 
-    const [sendCodeAssistPrompt] = codeAssistApi.useLazyGetCodeAssistSuggestionsQuery();
+    const {
+        getCodeAssistSuggestions,
+        onCompletionAccept,
+        onCompletionDecline,
+        onCompletionIgnore,
+        prepareUserQueriesCache,
+    } = useCodeAssist();
 
     const {registerMonacoGhost, dispose} = useMonacoGhost({
         api: {
-            getCodeAssistSuggestions: async (prompt) => {
-                try {
-                    return await sendCodeAssistPrompt(prompt).unwrap();
-                } catch {
-                    return {items: []};
-                }
-            },
+            getCodeAssistSuggestions,
         },
         config: {
             language: YQL_LANGUAGE_ID,
         },
+        onCompletionAccept,
+        onCompletionDecline,
+        onCompletionIgnore,
     });
 
     const editorDidMount = React.useCallback(
@@ -105,6 +109,16 @@ export function YqlEditor({
 
             if (window.api.codeAssist) {
                 registerMonacoGhost(editor);
+                prepareUserQueriesCache([
+                    ...historyQueries.map((query, index) => ({
+                        name: `query${index}.yql`,
+                        text: query.queryText,
+                    })),
+                    ...savedQueries.map((query) => ({
+                        name: query.name,
+                        text: query.body,
+                    })),
+                ]);
             }
             initResizeHandler(editor);
             initUserPrompt(editor, getLastQueryText);
@@ -198,7 +212,10 @@ export function YqlEditor({
             getLastQueryText,
             handleSendExecuteClick,
             handleSendQuery,
+            historyQueries,
+            prepareUserQueriesCache,
             registerMonacoGhost,
+            savedQueries,
         ],
     );
 
diff --git a/src/containers/Tenant/Query/QueryEditor/helpers.ts b/src/containers/Tenant/Query/QueryEditor/helpers.ts
@@ -1,7 +1,10 @@
 import React from 'react';
 
+import type {AcceptEvent, DeclineEvent, IgnoreEvent, PromptFile} from '@ydb-platform/monaco-ghost';
 import type Monaco from 'monaco-editor';
 
+import type {TelemetryOpenTabs} from '../../../../services/api/codeAssist';
+import {codeAssistApi} from '../../../../store/reducers/codeAssist/codeAssist';
 import {AUTOCOMPLETE_ON_ENTER, ENABLE_AUTOCOMPLETE} from '../../../../utils/constants';
 import {useSetting} from '../../../../utils/hooks';
 
@@ -32,3 +35,80 @@ export function useEditorOptions() {
 
     return options;
 }
+
+export function useCodeAssist() {
+    const [sendCodeAssistPrompt] = codeAssistApi.useLazyGetCodeAssistSuggestionsQuery();
+    const [acceptSuggestion] = codeAssistApi.useLazyAcceptSuggestionQuery();
+    const [discardSuggestion] = codeAssistApi.useLazyDiscardSuggestionQuery();
+    const [ignoreSuggestion] = codeAssistApi.useLazyIgnoreSuggestionQuery();
+    const [sendUserQueriesData] = codeAssistApi.useLazySendUserQueriesDataQuery();
+
+    const getCodeAssistSuggestions = React.useCallback(
+        async (prompt: PromptFile[]) => {
+            try {
+                const {items} = await sendCodeAssistPrompt(prompt).unwrap();
+
+                return {items};
+            } catch {
+                return {items: []};
+            }
+        },
+        [sendCodeAssistPrompt],
+    );
+
+    const onCompletionAccept = React.useCallback(
+        async (event: AcceptEvent) => {
+            try {
+                return await acceptSuggestion(event).unwrap();
+            } catch {
+                return {items: []};
+            }
+        },
+        [acceptSuggestion],
+    );
+
+    const onCompletionDecline = React.useCallback(
+        async (event: DeclineEvent) => {
+            try {
+                return await discardSuggestion(event).unwrap();
+            } catch {
+                return {items: []};
+            }
+        },
+        [discardSuggestion],
+    );
+
+    const onCompletionIgnore = React.useCallback(
+        async (event: IgnoreEvent) => {
+            try {
+                return await ignoreSuggestion(event).unwrap();
+            } catch {
+                return {items: []};
+            }
+        },
+        [ignoreSuggestion],
+    );
+
+    const prepareUserQueriesCache = React.useCallback(
+        async (queries: {text: string; name?: string}[]) => {
+            const preparedData: TelemetryOpenTabs = queries.map((query, index) => ({
+                FileName: query.name || `query${index}.yql`,
+                Text: query.text,
+            }));
+            try {
+                return await sendUserQueriesData(preparedData).unwrap();
+            } catch {
+                return {items: []};
+            }
+        },
+        [sendUserQueriesData],
+    );
+
+    return {
+        getCodeAssistSuggestions,
+        onCompletionAccept,
+        onCompletionDecline,
+        onCompletionIgnore,
+        prepareUserQueriesCache,
+    };
+}
diff --git a/src/services/api/codeAssist.ts b/src/services/api/codeAssist.ts
@@ -9,6 +9,40 @@ const ideInfo = {
     PluginFamily: 'ydb',
     PluginVersion: '0.2',
 };
+
+interface AcceptSuggestionEvent {
+    Accepted: {
+        RequestId: string;
+        Timestamp: number;
+        AcceptedText: string;
+        ConvertedText: string;
+    };
+}
+interface DiscardSuggestionEvent {
+    Discarded: {
+        RequestId: string;
+        Timestamp: number;
+        DiscardReason: 'OnCancel';
+        DiscardedText: string;
+        CacheHitCount: number;
+    };
+}
+interface IgnoreSuggestionEvent {
+    Ignored: {
+        RequestId: string;
+        Timestamp: number;
+        IgnoredText: string;
+    };
+}
+
+type OpenTab = {
+    FileName: string;
+    Text: string;
+};
+
+export type TelemetryOpenTabs = OpenTab[];
+
+export type TelemetryEvent = AcceptSuggestionEvent | DiscardSuggestionEvent | IgnoreSuggestionEvent;
 export class CodeAssistAPI extends BaseYdbAPI {
     getPath(path: string) {
         return `${CODE_ASSISTANT_BACKEND ?? ''}${path}`;
@@ -29,4 +63,23 @@ export class CodeAssistAPI extends BaseYdbAPI {
             },
         );
     }
+
+    sendCodeAssistTelemetry(data: TelemetryEvent) {
+        return this.post('/code-assist-telemetry', data, null, {
+            concurrentId: 'code-assist-telemetry',
+            collectRequest: true,
+        });
+    }
+
+    sendCodeAssistOpenTabs(data: TelemetryOpenTabs) {
+        return this.post(
+            '/code-assist-telemetry',
+            {OpenTabs: {Tabs: data, IdeInfo: ideInfo}},
+            null,
+            {
+                concurrentId: 'code-assist-telemetry',
+                collectRequest: false,
+            },
+        );
+    }
 }
diff --git a/src/store/reducers/codeAssist/codeAssist.ts b/src/store/reducers/codeAssist/codeAssist.ts
@@ -1,5 +1,12 @@
-import type {PromptFile, Suggestions} from '@ydb-platform/monaco-ghost';
+import type {
+    AcceptEvent,
+    DeclineEvent,
+    IgnoreEvent,
+    PromptFile,
+    Suggestions,
+} from '@ydb-platform/monaco-ghost';
 
+import type {TelemetryOpenTabs} from '../../../services/api/codeAssist';
 import {api} from '../api';
 
 export const codeAssistApi = api.injectEndpoints({
@@ -19,6 +26,92 @@ export const codeAssistApi = api.injectEndpoints({
             },
             providesTags: ['All'],
         }),
+
+        acceptSuggestion: builder.query({
+            queryFn: async (event: AcceptEvent) => {
+                try {
+                    if (window.api.codeAssist) {
+                        const data = await window.api.codeAssist.sendCodeAssistTelemetry({
+                            Accepted: {
+                                AcceptedText: event.acceptedText,
+                                ConvertedText: event.acceptedText,
+                                Timestamp: Date.now(),
+                                RequestId: event.requestId,
+                            },
+                        });
+                        return {data};
+                    } else {
+                        throw new Error('Method is not implemented.');
+                    }
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
+
+        discardSuggestion: builder.query({
+            queryFn: async (event: DeclineEvent) => {
+                try {
+                    if (window.api.codeAssist) {
+                        const data = await window.api.codeAssist.sendCodeAssistTelemetry({
+                            Discarded: {
+                                RequestId: event.requestId,
+                                Timestamp: Date.now(),
+                                DiscardReason: 'OnCancel',
+                                DiscardedText: event.suggestionText,
+                                CacheHitCount: event.hitCount,
+                            },
+                        });
+                        return {data};
+                    } else {
+                        throw new Error('Method is not implemented.');
+                    }
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
+
+        ignoreSuggestion: builder.query({
+            queryFn: async (event: IgnoreEvent) => {
+                try {
+                    if (window.api.codeAssist) {
+                        const data = await window.api.codeAssist.sendCodeAssistTelemetry({
+                            Ignored: {
+                                RequestId: event.requestId,
+                                Timestamp: Date.now(),
+                                IgnoredText: event.suggestionText,
+                            },
+                        });
+                        return {data};
+                    } else {
+                        throw new Error('Method is not implemented.');
+                    }
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
+
+        sendUserQueriesData: builder.query({
+            queryFn: async (userQueries: TelemetryOpenTabs) => {
+                try {
+                    if (window.api.codeAssist) {
+                        const data =
+                            await window.api.codeAssist.sendCodeAssistOpenTabs(userQueries);
+                        return {data};
+                    } else {
+                        throw new Error('Method is not implemented.');
+                    }
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
     }),
     overrideExisting: 'throw',
 });
