preview added

src/extension.ts

@@ -1,297 +1,231 @@
-import * as vscode from "vscode";
+import * as vscode from 'vscode';
-import axios from "axios";
+import axios from 'axios';
 
-let VSConfig: vscode.WorkspaceConfiguration;
+let config: {
-let apiEndpoint: string;
+    apiEndpoint: string;
-let apiAuthentication: string;
+    apiAuthentication: string;
-let apiModel: string;
+    apiModel: string;
-let apiTemperature: number;
+    apiTemperature: number;
-let numPredict: number;
+    numPredict: number;
-let promptWindowSize: number;
+    promptWindowSize: number;
-let completionKeys: string;
+    completionKeys: string[];
-let responsePreview: boolean | undefined;
+    responsePreview: boolean;
-let responsePreviewMaxTokens: number;
+    responsePreviewMaxTokens: number;
-let responsePreviewDelay: number;
+    responsePreviewDelay: number;
-let continueInline: boolean | undefined;
+    continueInline: boolean;
-let keepAlive: number | undefined;
+    keepAlive: number;
-let topP: number | undefined;
+    topP: number;
+};
 
-function updateVSConfig() {
+let previewDecorationType: vscode.TextEditorDecorationType;
-    VSConfig = vscode.workspace.getConfiguration("fabelous-autocoder");
+
-    apiEndpoint = VSConfig.get("endpoint") || "http://localhost:11434/api/generate";
+function updateConfig() {
-    apiAuthentication = VSConfig.get("authentication") || "";
+    const vsConfig = vscode.workspace.getConfiguration('fabelous-autocoder');
-    apiModel = VSConfig.get("model") || "fabelous-coder:latest";
+    config = {
-    numPredict = VSConfig.get("max tokens predicted") || 1000;
+        apiEndpoint: vsConfig.get('endpoint') || 'http://localhost:11434/api/generate',
-    promptWindowSize = VSConfig.get("prompt window size") || 2000;
+        apiAuthentication: vsConfig.get('authentication') || '',
-    completionKeys = VSConfig.get("completion keys") || " ";
+        apiModel: vsConfig.get('model') || 'fabelous-coder:latest',
-    responsePreview = VSConfig.get("response preview");
+        apiTemperature: vsConfig.get('temperature') || 0.7,
-    responsePreviewMaxTokens = VSConfig.get("preview max tokens") || 50;
+        numPredict: vsConfig.get('max tokens predicted') || 1000,
-    responsePreviewDelay = VSConfig.get("preview delay") || 0;
+        promptWindowSize: vsConfig.get('prompt window size') || 2000,
-    continueInline = VSConfig.get("continue inline");
+        completionKeys: (vsConfig.get('completion keys') as string || ' ').split(''),
-    apiTemperature = VSConfig.get("temperature") || 0.7;
+        responsePreview: vsConfig.get('response preview') || false,
-    keepAlive = VSConfig.get("keep alive") || 30;
+        responsePreviewMaxTokens: vsConfig.get('preview max tokens') || 50,
-    topP = VSConfig.get("top p") || 1;
+        responsePreviewDelay: vsConfig.get('preview delay') || 0,
+        continueInline: vsConfig.get('continue inline') || false,
+        keepAlive: vsConfig.get('keep alive') || 30,
+        topP: vsConfig.get('top p') || 1,
+    };
 }
 
-updateVSConfig();
+function createPreviewDecorationType() {
-vscode.workspace.onDidChangeConfiguration(updateVSConfig);
+    previewDecorationType = vscode.window.createTextEditorDecorationType({
+        after: {
+            color: '#888888',
+            fontStyle: 'italic',
+        },
+        textDecoration: 'none; display: none;',
+    });
+}
 
 function getContextLines(document: vscode.TextDocument, position: vscode.Position): string {
-    const lines = [];
     const startLine = Math.max(0, position.line - 1);
     const endLine = position.line;
-
+    return document.getText(new vscode.Range(startLine, 0, endLine, position.character));
-    for (let i = startLine; i <= endLine; i++) {
-        lines.push(document.lineAt(i).text);
 }
 
-    return lines.join("\n");
-}
-
-
 function createFIMPrompt(prefix: string, language: string): string {
     return `<fim_prefix>${prefix}<fim_middle><fim_suffix>${language}\n`;
 }
 
-const previewDecorationType = vscode.window.createTextEditorDecorationType({
+async function generateCompletion(prompt: string, cancellationToken: vscode.CancellationToken): Promise<string> {
-    after: {
-        color: '#888888', // Grayed-out preview text
-        fontStyle: 'italic',
-    },
-    textDecoration: 'none; display: none;', // Hide the original text
-});
-
-async function autocompleteCommand(textEditor: vscode.TextEditor, cancellationToken?: vscode.CancellationToken) {
-    const document = textEditor.document;
-    const position = textEditor.selection.active;
-    const contextLines = 2;
-    const startLine = Math.max(0, position.line - contextLines);
-    const context = getContextLines(document, position);
-    let isHandlingChange = false;
-    const fimPrompt = createFIMPrompt(context, document.languageId);
-
-    vscode.window.withProgress(
-        {
-            location: vscode.ProgressLocation.Notification,
-            title: "Fabelous Autocoder",
-            cancellable: true,
-        },
-        async (progress, progressCancellationToken) => {
-            try {
-                progress.report({ message: "Starting model..." });
-
-                let axiosCancelPost: () => void;
     const axiosCancelToken = new axios.CancelToken((c) => {
-                    axiosCancelPost = () => {
+        cancellationToken.onCancellationRequested(() => c('Request cancelled'));
-                        c("Autocompletion request terminated by user cancel");
-                    };
-                    if (cancellationToken) cancellationToken.onCancellationRequested(axiosCancelPost);
-                    progressCancellationToken.onCancellationRequested(axiosCancelPost);
-                    vscode.workspace.onDidCloseTextDocument(axiosCancelPost);
     });
 
-                // Make the API request
+    const response = await axios.post(config.apiEndpoint, {
-                const response = await axios.post(apiEndpoint, {
+        model: config.apiModel,
-                    model: apiModel,
+        prompt: prompt,
-                    prompt: fimPrompt,
         stream: false,
         raw: true,
         options: {
-                        num_predict: numPredict,
+            num_predict: config.numPredict,
-                        temperature: apiTemperature,
+            temperature: config.apiTemperature,
-                        stop: ["<fim_suffix>", "```"]
+            stop: ['<fim_suffix>', '```'],
+            keep_alive: config.keepAlive,
+            top_p: config.topP,
         }
     }, {
         cancelToken: axiosCancelToken,
         headers: {
-                        'Authorization': apiAuthentication
+            'Authorization': config.apiAuthentication
         }
     });
 
-                progress.report({ message: "Generating..." });
+    return response.data.response.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim();
+}
 
-                let completionText = response.data.response;
+class CompletionManager {
-                completionText = completionText.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim();
+    private textEditor: vscode.TextEditor;
+    private document: vscode.TextDocument;
+    private startPosition: vscode.Position;
+    private completionText: string;
 
-                let previewInserted = false;
+    constructor(textEditor: vscode.TextEditor, startPosition: vscode.Position, completionText: string) {
-                let originalContent: string;
+        this.textEditor = textEditor;
-                let previewStartLine: number;
+        this.document = textEditor.document;
+        this.startPosition = startPosition;
+        this.completionText = completionText;
+    }
 
+    public async showPreview() {
+        const completionLines = this.completionText.split('\n');
+        const previewLines = [
+            '',  // Empty line before
+            ...completionLines,
+            ''   // Empty line after
+        ];
         
-                const storeAndInsertPreview = async () => {
+        const previewRanges: vscode.DecorationOptions[] = previewLines.map((line, index) => {
-                    previewStartLine = startLine;
+            const lineNumber = Math.max(0, this.startPosition.line + index - 1);
-                    const endLine = document.lineCount - 1;
+            return {
-                    const endCharacter = document.lineAt(endLine).text.length;
+                range: new vscode.Range(
-                    const fullRange = new vscode.Range(startLine, 0, endLine, endCharacter);
+                    new vscode.Position(lineNumber, 0),
-                    originalContent = document.getText(fullRange);
+                    new vscode.Position(lineNumber, Number.MAX_VALUE)
-                
+                ),
-                    const previewContent = completionText + '\n'.repeat(1);
-                    const edit = new vscode.WorkspaceEdit();
-                    edit.replace(document.uri, fullRange, previewContent); // Overwrite the content
-                    await vscode.workspace.applyEdit(edit);
-                
-                    // Split the preview content into lines
-                    const previewLines = previewContent.split('\n');
-                    
-                
-                    // Set decorations on the newly inserted lines
-                    const previewRanges: vscode.DecorationOptions[] = [];
-                    for (let i = 0; i < previewLines.length; i++) {
-                        const range = new vscode.Range(previewStartLine + i, 0, previewStartLine + i, previewLines[i].length);
-                        previewRanges.push({
-                            range,
                 renderOptions: {
                     after: {
-                                    contentText: previewLines[i],
+                        contentText: line,
                     }
                 }
-                        });
-                    }
-                    textEditor.setDecorations(previewDecorationType, previewRanges);
-                    previewInserted = true;
             };
-                const disposable = vscode.window.onDidChangeTextEditorSelection(async (event) => {
+        });
-                    const textEditor = vscode.window.activeTextEditor;
+        this.textEditor.setDecorations(previewDecorationType, previewRanges);
-                    if (!textEditor || !previewInserted || isHandlingChange) {
-                        return;
     }
     
-                    isHandlingChange = true;
+
+    public async acceptCompletion() {
+        const edit = new vscode.WorkspaceEdit();
+        const startLine = Math.max(0, this.startPosition.line - 1);
+        const range = new vscode.Range(
+            new vscode.Position(startLine, 0),
+            this.startPosition.translate(0, Number.MAX_VALUE)
+        );
+        edit.replace(this.document.uri, range, this.completionText);
+        await vscode.workspace.applyEdit(edit);
+        this.clearPreview();
+    }
+    
+    public clearPreview() {
+        this.textEditor.setDecorations(previewDecorationType, []);
+    }
+    public declineCompletion() {
+        this.clearPreview();
+    }
+}
+
+async function autocompleteCommand(textEditor: vscode.TextEditor, edit: vscode.TextEditorEdit, ...args: any[]) {
+    const cancellationTokenSource = new vscode.CancellationTokenSource();
+    const cancellationToken = cancellationTokenSource.token;
 
     try {
-                        const activeSelection = textEditor.selection;
+        const document = textEditor.document;
-                        const changeStartLine = activeSelection.active.line;
+        const position = textEditor.selection.active;
+        const context = getContextLines(document, position);
+        const fimPrompt = createFIMPrompt(context, document.languageId);
 
-                        // Detect Tab key press by checking the active selection
+        const completionText = await vscode.window.withProgress({
-                        if (event.kind === vscode.TextEditorSelectionChangeKind.Keyboard && changeStartLine >= previewStartLine) {
+            location: vscode.ProgressLocation.Notification,
-                            const changeText = textEditor.document.getText(activeSelection);
+            title: 'Fabelous Autocoder',
-
+            cancellable: true,
-                            if (changeText === '') {
+        }, async (progress, progressCancellationToken) => {
-                                // Tab key (empty selection) -> Accept the preview
+            progress.report({ message: 'Generating...' });
-                                await acceptPreview(textEditor, textEditor.document, startLine, activeSelection.active, completionText);
+            return await generateCompletion(fimPrompt, progressCancellationToken);
-                            }
-                        }
-                    } finally {
-                        isHandlingChange = false;
-                    }
         });
 
-                // Handles Enter key separately
+        console.log('Completion generated:', completionText);
-                vscode.workspace.onDidChangeTextDocument(async (event) => {
-                    const textEditor = vscode.window.activeTextEditor;
-                    if (!textEditor || event.document.uri.toString() !== textEditor.document.uri.toString() || !previewInserted || isHandlingChange) {
-                        return;
-                    }
 
-                    isHandlingChange = true;
+        const completionManager = new CompletionManager(textEditor, position, completionText);
+        await completionManager.showPreview();
 
-                    try {
+        let isDisposed = false;
-                        for (const change of event.contentChanges) {
-                            const changeStartLine = change.range.start.line;
 
-                            if (change.text.includes('\n') && changeStartLine >= previewStartLine) {
+        const dispose = () => {
-                                // Accept the preview and move to the next line
+            if (!isDisposed) {
-                                await acceptPreview(textEditor, textEditor.document, startLine, textEditor.selection.active, completionText);
+                console.log('Disposing listeners');
-                                await vscode.commands.executeCommand('default:type', { text: '\n' });
+                disposable.dispose();
-                                break;
+                declineDisposable.dispose();
+                isDisposed = true;
             }
+        };
 
-                            // Handle Backspace
+        const disposable = vscode.Disposable.from(
-                            if (change.text === '' && change.rangeLength === 1 && changeStartLine >= previewStartLine) {
-                                // Discard the preview if Backspace is pressed
-                                await restoreOriginalContent();
-                                break;
-                            }
-                        }
-                    } finally {
-                        isHandlingChange = false;
-                    }
-                });
-
             vscode.window.onDidChangeTextEditorSelection(async (event) => {
-                    const textEditor = vscode.window.activeTextEditor;
+                if (event.textEditor !== textEditor) return;
-                    if (!textEditor || !previewInserted || isHandlingChange) {
+
-                        return;
+                if (event.kind === vscode.TextEditorSelectionChangeKind.Keyboard) {
+                    console.log('Accepting completion');
+                    await completionManager.acceptCompletion();
+                    dispose();
                 }
-
+            }),
-                    isHandlingChange = true;
+            vscode.window.onDidChangeActiveTextEditor(() => {
-
+                console.log('Active editor changed, clearing preview');
-                    try {
+                completionManager.clearPreview();
-                        // Handle arrow keys or any other navigation keys
+                dispose();
-                        const currentSelection = event.selections[0];
+            }),
-                        const { document } = textEditor;
+            vscode.workspace.onDidChangeTextDocument((event) => {
-
+                if (event.document === document) {
-                        // Detect unwanted acceptance from simple navigation
+                    console.log('Document changed, clearing preview');
-                        if (currentSelection.start.line < previewStartLine) {
+                    completionManager.clearPreview();
-                            await restoreOriginalContent();
+                    dispose();
                 }
-                    } finally {
+            })
-                        isHandlingChange = false;
+        );
+
+        const declineDisposable = vscode.commands.registerCommand('type', async (args) => {
+            if (args.text === '\b') { // Backspace key
+                console.log('Declining completion');
+                completionManager.declineCompletion();
+                dispose();
             }
         });
 
-
-
-                
-                // Restore original content if Backspace is pressed (decline the preview)
-                const restoreOriginalContent = async () => {
-                    if (!previewInserted) return;
-                
-                    const endLine = document.lineCount - 1;
-                    const fullRange = new vscode.Range(previewStartLine, 0, endLine, document.lineAt(endLine).text.length);
-                    const edit = new vscode.WorkspaceEdit();
-                
-                    edit.replace(document.uri, fullRange, originalContent);
-                    await vscode.workspace.applyEdit(edit);
-                
-                    textEditor.setDecorations(previewDecorationType, []);
-                    previewInserted = false;
-                    disposable.dispose(); // Cancel listener when preview is discarded
-                };
-                
-                // Accept the preview when Tab is pressed
-                const acceptPreview = async (textEditor: vscode.TextEditor, document: vscode.TextDocument, startLine: number, position: vscode.Position, completionText: string) => {
-                    textEditor.setDecorations(previewDecorationType, []);
-                    const edit = new vscode.WorkspaceEdit();
-                    
-                    // Adjust the insertion logic to avoid duplicate newlines
-                    const insertText = completionText;
-                    
-                    // Replace the range from the start of the context to the current position
-                    const replaceRange = new vscode.Range(startLine, 0, position.line, position.character);
-                    edit.replace(document.uri, replaceRange, insertText);
-                    
-                    await vscode.workspace.applyEdit(edit);
-                    await document.save();
-                    
-                    disposable.dispose(); // Cancel listener when preview is accepted
-                    previewInserted = false;
-                };
-                
-                // Call this function to initiate the preview
-                await storeAndInsertPreview();
-                
-
-                                
-
     } catch (err: any) {
-                vscode.window.showErrorMessage(
+        console.error('Error in autocompleteCommand:', err);
-                    "Fabelous Autocoder encountered an error: " + err.message
+        vscode.window.showErrorMessage(`Fabelous Autocoder encountered an error: ${err.message}`);
-                );
+    } finally {
-                console.log(err);
+        cancellationTokenSource.dispose();
     }
 }
-    );
-}
-
-
 
 async function provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, cancellationToken: vscode.CancellationToken) {
-    const item = new vscode.CompletionItem("Fabelous autocompletion");
+    const item = new vscode.CompletionItem('Fabelous autocompletion');
     item.insertText = new vscode.SnippetString('${1:}');
+    item.documentation = new vscode.MarkdownString('Press `Enter` to get an autocompletion from Fabelous Autocoder');
 
-    if (responsePreview) {
+    if (config.responsePreview) {
-        await new Promise(resolve => setTimeout(resolve, responsePreviewDelay * 1000));
+        await new Promise(resolve => setTimeout(resolve, config.responsePreviewDelay * 1000));
         if (cancellationToken.isCancellationRequested) {
             return [item];
         }
@@ -300,58 +234,36 @@ async function provideCompletionItems(document: vscode.TextDocument, position: v
         const fimPrompt = createFIMPrompt(context, document.languageId);
 
         try {
-            const response_preview = await axios.post(apiEndpoint, {
+            const result = await generateCompletion(fimPrompt, cancellationToken);
-                model: apiModel,
+            const preview = (result as any).preview;
-                prompt: fimPrompt,
+            if (preview) {
-                stream: false,
+            item.detail = preview.split('\n')[0];
-                raw: true,
-                options: {
-                    num_predict: responsePreviewMaxTokens,
-                    temperature: apiTemperature,
-                    stop: ['<fim_suffix>', '\n', '```'],
-                    ...(keepAlive && { keep_alive: keepAlive }),
-                    ...(topP && { top_p: topP }),
             }
-            }, {
-                cancelToken: new axios.CancelToken((c) => {
-                    cancellationToken.onCancellationRequested(() => c("Autocompletion request terminated by completion cancel"));
-                })
-            });
         } catch (error) {
-            console.error("Error fetching preview:", error);
+            console.error('Error fetching preview:', error);
         }
     }
 
-    item.documentation = new vscode.MarkdownString('Press `Enter` to get an autocompletion from Fabelous Autocoder');
+    if (config.continueInline || !config.responsePreview) {
-    if (continueInline || !responsePreview) {
         item.command = {
             command: 'fabelous-autocoder.autocomplete',
             title: 'Fabelous Autocomplete',
-            arguments: [cancellationToken]
+            arguments: []
         };
     }
+
     return [item];
 }
 
-function activate(context: vscode.ExtensionContext) {
+export function activate(context: vscode.ExtensionContext) {
-    const completionProvider = vscode.languages.registerCompletionItemProvider("*", {
+    updateConfig();
-        provideCompletionItems
+    createPreviewDecorationType();
-    },
+
-        ...completionKeys.split("")
+    context.subscriptions.push(
+        vscode.workspace.onDidChangeConfiguration(updateConfig),
+        vscode.languages.registerCompletionItemProvider('*', { provideCompletionItems }, ...config.completionKeys),
+        vscode.commands.registerTextEditorCommand('fabelous-autocoder.autocomplete', autocompleteCommand)
     );
-    const externalAutocompleteCommand = vscode.commands.registerTextEditorCommand(
-        "fabelous-autocoder.autocomplete",
-        (textEditor, _, cancellationToken?) => {
-            autocompleteCommand(textEditor, cancellationToken);
-        }
-    );
-    context.subscriptions.push(completionProvider);
-    context.subscriptions.push(externalAutocompleteCommand);
 }
 
-function deactivate() { }
+export function deactivate() {}
-
-module.exports = {
-    activate,
-    deactivate,
-};