remove test file

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fabelous-autocoder",
-	"version": "0.2.74",
+	"version": "0.2.0",
 	"displayName": "Fabelous Autocoder",
 	"description": "A simple to use Ollama autocompletion Plugin",
 	"icon": "icon.png",
@@ -110,10 +110,9 @@
 		},
 		"commands": [
 			{
-			  "command": "fabelous-autocoder.autocomplete",
+				"command": "fabelous-autocoder.autocomplete",
-			  "title": "Fabelous autocompletion"
+				"title": "Fabelous Autocompletion"
-			}
+			}]
-		  ]
 	},
 	"scripts": {
 		"vscode:prepublish": "npm run compile",

src/extension.ts

@@ -113,93 +113,139 @@ async function autocompleteCommand(textEditor: vscode.TextEditor, cancellationTo
                 let completionText = response.data.response;
                 completionText = completionText.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim();
 
-                // Split the completion text by new lines
+                let previewInserted = false;
-                const newLines = completionText.split('\n');
+                let originalContent: string;
-
+                let previewStartLine: number;
-                // Calculate the number of new lines in the completion, plus 2 extra lines
+                const storeAndInsertPreview = async () => {
-                const totalNewLines = newLines.length + 2;
+                    previewStartLine = startLine;
-
+                    const endLine = document.lineCount - 1;
-                // Create preview decorations and insert new lines
+                    const endCharacter = document.lineAt(endLine).text.length;
-                const previewRanges: vscode.DecorationOptions[] = [];
+                    const fullRange = new vscode.Range(startLine, 0, endLine, endCharacter);
-                const edit = new vscode.WorkspaceEdit();
+                    originalContent = document.getText(fullRange);
-                const document = textEditor.document;
+                
-
+                    const previewContent = completionText + '\n'.repeat(1);
-                for (let i = 0; i < totalNewLines; i++) {
+                    const edit = new vscode.WorkspaceEdit();
-                    const lineContent = i < newLines.length ? newLines[i] : '';
+                    edit.replace(document.uri, fullRange, previewContent); // Overwrite the content
-                    const position = new vscode.Position(startLine + i, 0);
+                    await vscode.workspace.applyEdit(edit);
+                
+                    // Split the preview content into lines
+                    const previewLines = previewContent.split('\n');
                     
-                    // Insert a new line
+                    // Calculate the exact position of the last character of the preview content
-                    edit.insert(document.uri, position, '\n');
+                    const lastPreviewLineIndex = previewStartLine + previewLines.length - 1;
+                    const lastPreviewLine = previewLines[previewLines.length - 2]; // Second to last line (last line is newline)
+                    const newPosition = new vscode.Position(lastPreviewLineIndex - 1, lastPreviewLine.length); // Place cursor at end of last line
                     
-                    // Create a range for the newly inserted line
+                    // Set the new cursor position after inserting preview
-                    const range = new vscode.Range(position, position.translate(1, 0));
+                    textEditor.selection = new vscode.Selection(newPosition, newPosition);
-                    
+                
-                    previewRanges.push({
+                    // Explicitly scroll to reveal the cursor position at the end of the preview
-                        range,
+                    textEditor.revealRange(new vscode.Range(newPosition, newPosition), vscode.TextEditorRevealType.InCenter);
-                        renderOptions: {
+                
-                            after: {
+                    // Set decorations on the newly inserted lines
-                                contentText: lineContent,
+                    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],
+                                }
                             }
+                        });
+                    }
+                    textEditor.setDecorations(previewDecorationType, previewRanges);
+                    previewInserted = true;
+                };
+                
+                const disposable = vscode.workspace.onDidChangeTextDocument(async (event) => {
+                    const textEditor = vscode.window.activeTextEditor;
+                    if (!textEditor || event.document.uri.toString() !== textEditor.document.uri.toString() || !previewInserted) {
+                        return;
+                    }
+                
+                    // Determine tab size setting
+                    const tabSize = textEditor.options.tabSize as number || 4;
+                
+                    for (const change of event.contentChanges) {
+                        const changeStartLine = change.range.start.line;
+                
+                        // Detect Backspace by a single-character deletion
+                        if (change.text === '' && change.rangeLength === 1 && changeStartLine >= previewStartLine) {
+                            await restoreOriginalContent();
+                        }
+                
+                        // Detect Tab by checking if the change is a multiple of spaces equal to the tab size
+                        if (/^[ ]+$/.test(change.text) && change.text.length === tabSize && changeStartLine >= previewStartLine) {
+                            await acceptPreview(textEditor, document, startLine, position, completionText);
                         }
-                    });
-                }
-
-                // Apply the edit to insert new lines
-                await vscode.workspace.applyEdit(edit);
-
-                // Set decorations on the newly inserted lines
-                textEditor.setDecorations(previewDecorationType, previewRanges);
-
-                let previewInserted = true;
-
-               // Handle preview acceptance or dismissal
-               const disposable = vscode.workspace.onDidChangeTextDocument(async (event) => {
-                if (event.document.uri.toString() === document.uri.toString()) {
-                    const change = event.contentChanges[0];
-
-                    // Dismiss preview with Backspace
-                    if (change && change.text === '' && change.rangeLength === 1) {
-                        textEditor.setDecorations(previewDecorationType, []);
-                        disposable.dispose();
-                        previewInserted = false;
                     }
+                });
 
-                    // Accept preview with Tab key
+                
-                    if (change && change.text === '\t' && previewInserted) {
+                const restoreOriginalContent = async () => {
-                        textEditor.setDecorations(previewDecorationType, []);
+                    if (!previewInserted) return;
-                        const edit = new vscode.WorkspaceEdit();
 
-                        // Insert the completion text
+                    const endLine = document.lineCount - 1;
-                        const insertText = '\n'.repeat(1) + completionText + '\n'.repeat(1); // Add 2 extra newlines
+                    const fullRange = new vscode.Range(previewStartLine, 0, endLine, document.lineAt(endLine).text.length);
+                    const edit = new vscode.WorkspaceEdit();
 
-                        // Replace the entire range from the start of the context to the current position
+                    edit.replace(document.uri, fullRange, originalContent);
-                        const replaceRange = new vscode.Range(startLine, 0, position.line, position.character);
+                    await vscode.workspace.applyEdit(edit);
-                        edit.replace(document.uri, replaceRange, insertText);
 
-                        await vscode.workspace.applyEdit(edit);
+                    textEditor.setDecorations(previewDecorationType, []);
-                        await document.save(); // Optionally save after inserting
+                    previewInserted = false;
+                    disposable.dispose();
 
-                        // Move the cursor to the end of the inserted completion
+                    // Move cursor back to the end of the original content
-                        const newPosition = new vscode.Position(startLine + totalNewLines - 2, 0);
+                    const lastOriginalLineNumber = previewStartLine + originalContent.split('\n').length - 1;
-                        textEditor.selection = new vscode.Selection(newPosition, newPosition);
+                    const lastLineLength = originalContent.split('\n').pop()?.length || 0;
+                    const newPosition = new vscode.Position(lastOriginalLineNumber, lastLineLength);
+                    textEditor.selection = new vscode.Selection(newPosition, newPosition);
+                };
 
-                        disposable.dispose();
+                // Modify the acceptPreview function to match the working version
-                        previewInserted = false;
+                const acceptPreview = async (textEditor: vscode.TextEditor, document: vscode.TextDocument, startLine: number, position: vscode.Position, completionText: string) => {
-                    }
+                    console.log("Accepting preview");
-                }
+                    textEditor.setDecorations(previewDecorationType, []);
-            });
+                    const edit = new vscode.WorkspaceEdit();
 
-        } catch (err: any) {
+                    // Insert the completion text
-            vscode.window.showErrorMessage(
+                    const insertText = '\n'.repeat(1) + completionText + '\n'.repeat(1); // Add 2 extra newlines
-                "Fabelous Autocoder encountered an error: " + err.message
+
-            );
+                    // Replace the entire range from the start of the context to the current position
-            console.log(err);
+                    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(); // Optionally save after inserting
+
+                    // Move the cursor to the end of the inserted completion
+                    const totalNewLines = insertText.split('\n').length;
+                    const newPosition = new vscode.Position(startLine + totalNewLines - 2, 0);
+                    textEditor.selection = new vscode.Selection(newPosition, newPosition);
+
+                    disposable.dispose();
+                    previewInserted = false;
+                    console.log("Preview accepted");
+                };
+
+                // Call this function to initiate the preview
+                await storeAndInsertPreview();
+
+            } catch (err: any) {
+                vscode.window.showErrorMessage(
+                    "Fabelous Autocoder encountered an error: " + err.message
+                );
+                console.log(err);
+            }
         }
-    }
+    );
-);
 }
 
 
+
 async function provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, cancellationToken: vscode.CancellationToken) {
     const item = new vscode.CompletionItem("Fabelous autocompletion");
     item.insertText = new vscode.SnippetString('${1:}');