windmill-components 1.493.9 → 1.501.4

package/package/components/copilot/autocomplete/Autocompletor.js

@@ -0,0 +1,148 @@
+import { sleep } from '../../../utils';
+import { Position, languages } from 'monaco-editor';
+import { LRUCache } from 'lru-cache';
+import { autocompleteRequest } from './request';
+import { FIM_MAX_TOKENS } from '../lib';
+function filterCompletion(completion, suffix) {
+    const trimmedCompletion = completion.replaceAll('\n', '');
+    const trimmedSuffix = suffix.slice(0, FIM_MAX_TOKENS).replaceAll('\n', '');
+    if (trimmedSuffix.startsWith(trimmedCompletion)) {
+        console.log('suffix starts with completion', suffix, completion);
+        return;
+    }
+    return completion;
+}
+export class Autocompletor {
+    #lastTs = Date.now();
+    #cache = new LRUCache({
+        max: 10
+    });
+    #scriptLang;
+    #abortController = new AbortController();
+    #completionDisposable;
+    #cursorDisposable;
+    constructor(editor, scriptLang) {
+        this.#scriptLang = scriptLang;
+        this.#completionDisposable = languages.registerInlineCompletionsProvider({ pattern: '**' }, {
+            provideInlineCompletions: async (model, position, context, token) => {
+                if (token.isCancellationRequested ||
+                    model.uri.toString() !== editor.getModel()?.uri.toString()) {
+                    return { items: [] };
+                }
+                const result = await this.#autocomplete(model, position);
+                if (result) {
+                    const completion = filterCompletion(result.completion, result.suffix);
+                    if (!completion) {
+                        return { items: [] };
+                    }
+                    let range = {
+                        startLineNumber: position.lineNumber,
+                        startColumn: position.column,
+                        endLineNumber: position.lineNumber,
+                        endColumn: position.column
+                    };
+                    const multiline = completion.indexOf('\n') !== -1;
+                    if (multiline) {
+                        // if multiline the range should span until the end of the line
+                        range.endColumn = model.getLineMaxColumn(position.lineNumber);
+                    }
+                    return {
+                        items: [
+                            {
+                                insertText: completion,
+                                range
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        items: []
+                    };
+                }
+            },
+            freeInlineCompletions: () => { }
+        });
+        this.#cursorDisposable = editor.onDidChangeCursorPosition(async (e) => {
+            if (e.source === 'mouse') {
+                const model = editor.getModel();
+                if (model) {
+                    this.#autocomplete(model, e.position);
+                }
+            }
+        });
+    }
+    static isProviderModelSupported(providerModel) {
+        return (providerModel &&
+            providerModel.provider === 'mistral' &&
+            providerModel.model.startsWith('codestral-') &&
+            !providerModel.model.startsWith('codestral-embed'));
+    }
+    dispose() {
+        this.#completionDisposable.dispose();
+        this.#cursorDisposable.dispose();
+    }
+    async #autocomplete(model, position) {
+        const thisTs = Date.now();
+        this.#lastTs = thisTs;
+        await sleep(200);
+        if (model.isDisposed()) {
+            return;
+        }
+        if (thisTs !== this.#lastTs) {
+            return;
+        }
+        const linePrefix = model.getValueInRange({
+            startLineNumber: position.lineNumber,
+            startColumn: 1,
+            endLineNumber: position.lineNumber,
+            endColumn: position.column
+        });
+        const suffix = model.getValueInRange({
+            startLineNumber: position.lineNumber,
+            startColumn: position.column,
+            endLineNumber: model.getLineCount(),
+            endColumn: model.getLineMaxColumn(model.getLineCount())
+        });
+        const cachedCompletion = this.#cache.get(position.lineNumber);
+        if (cachedCompletion) {
+            if (position.column > cachedCompletion.column &&
+                linePrefix.length < cachedCompletion.linePrefix.length + cachedCompletion.completion.length) {
+                const completeLine = cachedCompletion.linePrefix + cachedCompletion.completion;
+                const newLinePrefix = completeLine.substring(0, position.column - 1);
+                if (newLinePrefix === linePrefix) {
+                    const modifiedCompletion = cachedCompletion.completion.slice(position.column - cachedCompletion.column);
+                    console.debug('autocomplete partial cache hit', modifiedCompletion);
+                    return { completion: modifiedCompletion, suffix };
+                }
+            }
+            else if (position.column === cachedCompletion.column &&
+                cachedCompletion.linePrefix === linePrefix) {
+                console.debug('autocomplete exact cache hit', cachedCompletion.completion);
+                return { completion: cachedCompletion.completion, suffix };
+            }
+        }
+        this.#abortController.abort();
+        this.#abortController = new AbortController();
+        const prefix = model.getValueInRange({
+            startLineNumber: 1,
+            startColumn: 1,
+            endLineNumber: position.lineNumber,
+            endColumn: position.column
+        });
+        const completion = await autocompleteRequest({
+            prefix,
+            suffix,
+            scriptLang: this.#scriptLang
+        }, this.#abortController);
+        if (!completion) {
+            return;
+        }
+        this.#cache.set(position.lineNumber, {
+            linePrefix,
+            completion,
+            column: position.column
+        });
+        return { completion, suffix };
+    }
+}

package/package/components/copilot/autocomplete/request.d.ts

@@ -1,10 +1,6 @@
 import { type ScriptLang } from '../../../gen/types.gen';
 export declare function autocompleteRequest(context: {
     prefix: string;
-    modifiablePrefix: string;
-    modifiableSuffix: string;
     suffix: string;
-    language: string;
     scriptLang: ScriptLang | 'bunnative' | 'jsx' | 'tsx' | 'json';
-    events: string[];
 }, abortController: AbortController): Promise<string | undefined>;

package/package/components/copilot/autocomplete/request.js

@@ -1,86 +1,28 @@
-import { codeCompletionLoading, copilotInfo } from '../../../stores';
+import { copilotInfo } from '../../../stores';
 import { get } from 'svelte/store';
-import { getNonStreamingCompletion } from '../lib';
-import { getLangContext } from '../chat/core';
+import { getFimCompletion } from '../lib';
+import { getLangContext } from '../chat/script/core';
 import {} from '../../../gen/types.gen';
-const AUTOCOMPLETE_SYSTEM_PROMPT = `You're a code assistant. Your task is to help the user write code by suggesting the next edit for the user.
-
-As an intelligent code assistant, your role is to analyze what the user has been doing and then to suggest the most likely next modification.
-
-## Task
-
-Your task is to rewrite the <EDITABLE_CODE> section of the code I send you to include an edit the user should make.
-The <CURSOR> tag marks the position of the user's cursor.
-
-Follow the following criteria.
-
-### High-level Guidelines
-
-- Consider the overall intent and direction of the changes
-- Take into account what the user has been doing
-- Maintain the code style and formatting conventions of the language used in the file
-- Your edit suggestions **must** be small and self-contained. Example: if there are two statements that logically need to be added together, suggest them together instead of one by one.
-
-### Constraints
-
-- Preserve indentation and braces/parentheses/brackets balance.
-- Prefer suggesting actual implementations over suggesting placeholders
-- Dont explain the code, only return the complete <EDITABLE_CODE> section with your edits. DO NOT return any code after the <EDITABLE_CODE> tag.
-- If there are no useful edits to make, return the the <EDITABLE_CODE> section unmodified, without the <CURSOR> tag.
-- Never include the <CURSOR> tag in the response.
-- Never remove line breaks inside the <EDITABLE_CODE> section.`;
-const AUTOCOMPLETE_USER_PROMPT = `
-WINDMILL LANGUAGE CONTEXT:
-{lang_context}
-
-<CODE>
-{prefix}<EDITABLE_CODE>
-{modifiablePrefix}<CURSOR>{modifiableSuffix}
-</EDITABLE_CODE>
-{suffix}</CODE>
-
-Return the EDITABLE_CODE section in the form \`\`\`{language}
-<EDITABLE_CODE>
-...complete editable code section with your modifications
-</EDITABLE_CODE>
-\`\`\``;
-function postProcessing(response) {
-    const code = response.match(/<EDITABLE_CODE>\n?(.*?)\n?<\/EDITABLE_CODE>/s)?.[1];
-    if (!code) {
-        throw new Error('No code found in response');
-    }
-    return code;
-}
+import { getCommentSymbol } from '../utils';
 export async function autocompleteRequest(context, abortController) {
-    codeCompletionLoading.set(true);
-    const systemPrompt = AUTOCOMPLETE_SYSTEM_PROMPT;
-    const userPrompt = AUTOCOMPLETE_USER_PROMPT.replace('{lang_context}', getLangContext(context.scriptLang))
-        .replace('{prefix}', context.prefix)
-        .replace('{modifiablePrefix}', context.modifiablePrefix)
-        .replace('{modifiableSuffix}', context.modifiableSuffix)
-        .replace('{suffix}', context.suffix)
-        .replace('{language}', context.language)
-        .replace('{events}', context.events.join('\n\n'));
-    const info = get(copilotInfo);
-    const providerModel = info.codeCompletionModel;
+    const langContext = getLangContext(context.scriptLang);
+    const commentSymbol = getCommentSymbol(context.scriptLang);
+    if (langContext) {
+        const contextLines = langContext.split('\n');
+        const commentedContext = contextLines.map((line) => `${commentSymbol} ${line}`).join('\n');
+        context.prefix = commentedContext + '\n' + context.prefix;
+    }
+    const providerModel = get(copilotInfo).codeCompletionModel;
     if (!providerModel) {
         throw new Error('No code completion model selected');
     }
     try {
-        const completion = await getNonStreamingCompletion([
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: userPrompt }
-        ], abortController, {
-            forceModelProvider: providerModel
-        });
-        return postProcessing(completion);
+        const completion = await getFimCompletion(context.prefix, context.suffix, providerModel, abortController);
+        return completion;
     }
     catch (err) {
         if (!abortController.signal.aborted) {
             console.log('Could not generate autocomplete', err.message);
         }
     }
-    finally {
-        codeCompletionLoading.set(false);
-    }
 }