Fabel/Fabelous-Autocoder
Fabel
/
Fabelous-Autocoder
0
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases 3 Wiki Activity

Compare commits

base: Fabel:e234969638214e02083dd03702f667cc6b0b77a9
Branches Tags
Fabel:main
Fabel:develop
Fabel:remove_compeltion_items
Fabel:docs
Fabel:preview_lines
Fabel:0.2.1
Fabel:0.2.0
Fabel:0.1.7
Fabel:0.0.35
..
compare: Fabel:678c4823b3b20f352d6cde2abdf5e1312e76b204
Branches Tags
Fabel:develop
Fabel:remove_compeltion_items
Fabel:main
Fabel:docs
Fabel:preview_lines
Fabel:0.2.1
Fabel:0.2.0
Fabel:0.1.7
Fabel:0.0.35

No commits in common. "e234969638214e02083dd03702f667cc6b0b77a9" and "678c4823b3b20f352d6cde2abdf5e1312e76b204" have entirely different histories.
e234969638 ... 678c4823b3

2 changed files with 204 additions and 248 deletions
Show Stats Expand all files Collapse all files

9
package.json
View File

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

443
src/extension.ts
View File

@ -1,298 +1,253 @@
import * as vscode from 'vscode'; import * as vscode from "vscode";
import axios from 'axios'; import axios from "axios";
let config: { let VSConfig: vscode.WorkspaceConfiguration;
apiEndpoint: string; let apiEndpoint: string;
apiAuthentication: string; let apiAuthentication: string;
apiModel: string; let apiModel: string;
apiTemperature: number; let apiTemperature: number;
numPredict: number; let numPredict: number;
promptWindowSize: number; let promptWindowSize: number;
completionKeys: string[]; let completionKeys: string;
responsePreview: boolean; let responsePreview: boolean | undefined;
responsePreviewMaxTokens: number; let responsePreviewMaxTokens: number;
responsePreviewDelay: number; let responsePreviewDelay: number;
continueInline: boolean; let continueInline: boolean | undefined;
keepAlive: number; let keepAlive: number | undefined;
topP: number; let topP: number | undefined;
};
let previewDecorationType: vscode.TextEditorDecorationType; function updateVSConfig() {
let activeCompletionManager: CompletionManager | null = null; 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,
};
} }
function createPreviewDecorationType() { updateVSConfig();
previewDecorationType = vscode.window.createTextEditorDecorationType({ vscode.workspace.onDidChangeConfiguration(updateVSConfig);
after: {
color: '#888888',
fontStyle: 'italic',
},
textDecoration: 'none; display: none;',
});
}
function getContextLines(document: vscode.TextDocument, position: vscode.Position): string { function getContextLines(document: vscode.TextDocument, position: vscode.Position): string {
const lines = [];
const startLine = Math.max(0, position.line - 1); const startLine = Math.max(0, position.line - 1);
const endLine = position.line; 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 { function createFIMPrompt(prefix: string, language: string): string {
return `<fim_prefix>${prefix}<fim_middle><fim_suffix>${language}\n`; return `<fim_prefix>${prefix}<fim_middle><fim_suffix>${language}\n`;
} }
async function generateCompletion(prompt: string, cancellationToken: vscode.CancellationToken): Promise<string> { const previewDecorationType = vscode.window.createTextEditorDecorationType({
const axiosCancelToken = new axios.CancelToken((c) => { color: '#888888', // Grayed-out preview text
cancellationToken.onCancellationRequested(() => c('Request cancelled')); fontStyle: 'italic',
}); rangeBehavior: vscode.DecorationRangeBehavior.ClosedOpen, // Ensure proper handling of multiline decorations
});
const response = await axios.post(config.apiEndpoint, { async function autocompleteCommand(textEditor: vscode.TextEditor, cancellationToken?: vscode.CancellationToken) {
model: config.apiModel, const document = textEditor.document;
prompt: prompt, const position = textEditor.selection.active;
stream: false,
raw: true,
options: {
num_predict: config.numPredict,
temperature: config.apiTemperature,
stop: ['<fim_suffix>', '```'],
keep_alive: config.keepAlive,
top_p: config.topP,
}
}, {
cancelToken: axiosCancelToken,
headers: {
'Authorization': config.apiAuthentication
}
});
return response.data.response.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim(); const context = getContextLines(document, position);
} const fimPrompt = createFIMPrompt(context, document.languageId);
class CompletionManager { vscode.window.withProgress(
private textEditor: vscode.TextEditor; {
private document: vscode.TextDocument;
private startPosition: vscode.Position;
private completionText: string;
constructor(textEditor: vscode.TextEditor, startPosition: vscode.Position, completionText: string) {
this.textEditor = textEditor;
this.document = textEditor.document;
this.startPosition = startPosition;
this.completionText = completionText;
}
public async showPreview() {
this.completionText = '\n' + this.completionText;
const completionLines = this.completionText.split('\n');
const emptyLine = ''; // Empty line for spacing
const previewLines = [emptyLine, ...completionLines, emptyLine];
const previewRanges: vscode.DecorationOptions[] = previewLines.map((line, index) => {
const actualLineNumber = this.startPosition.line + index;
const totalLines = this.textEditor.document.lineCount;
const lineNumber = Math.min(totalLines - 1, actualLineNumber);
return {
range: new vscode.Range(
new vscode.Position(lineNumber, 0),
new vscode.Position(lineNumber, Number.MAX_VALUE)
),
renderOptions: {
after: {
contentText: line.length > 0 ? ` ${line}` : '',
},
},
};
});
this.textEditor.setDecorations(previewDecorationType, previewRanges);
}
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 document = textEditor.document;
const position = textEditor.selection.active;
const context = getContextLines(document, position);
const fimPrompt = createFIMPrompt(context, document.languageId);
const completionText = await vscode.window.withProgress({
location: vscode.ProgressLocation.Notification, location: vscode.ProgressLocation.Notification,
title: 'Fabelous Autocoder', title: "Fabelous Autocoder",
cancellable: true, cancellable: true,
}, async (progress, progressCancellationToken) => { },
progress.report({ message: 'Generating...' }); async (progress, progressCancellationToken) => {
return await generateCompletion(fimPrompt, progressCancellationToken); try {
}); progress.report({ message: "Starting model..." });
console.log('Completion generated:', completionText); let axiosCancelPost: () => void;
const axiosCancelToken = new axios.CancelToken((c) => {
axiosCancelPost = () => {
c("Autocompletion request terminated by user cancel");
};
if (cancellationToken) cancellationToken.onCancellationRequested(axiosCancelPost);
progressCancellationToken.onCancellationRequested(axiosCancelPost);
vscode.workspace.onDidCloseTextDocument(axiosCancelPost);
});
const response = await axios.post(apiEndpoint, {
model: apiModel,
prompt: fimPrompt,
stream: false,
raw: true,
options: {
num_predict: numPredict,
temperature: apiTemperature,
stop: ["<fim_suffix>", "```"]
}
}, {
cancelToken: axiosCancelToken,
headers: {
'Authorization': apiAuthentication
}
});
const completionManager = new CompletionManager(textEditor, position, completionText); progress.report({ message: "Generating..." });
await completionManager.showPreview();
activeCompletionManager = completionManager;
let isDisposed = false; let completionText = response.data.response;
completionText = completionText.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim();
const dispose = () => { // Split the completion text by new lines
if (!isDisposed) { const lines = completionText.split('\n');
console.log('Disposing listeners');
disposable.dispose(); // Create a decoration for each line of the response
typeDisposable.dispose(); const previewRanges = lines.map((line: string, idx: number) => {
activeCompletionManager = null; const linePos = new vscode.Position(position.line + idx, 0);
isDisposed = true; const range = new vscode.Range(linePos, linePos); // Set range at the start of each new line
return {
range,
renderOptions: {
before: {
contentText: line,
color: '#888888',
fontStyle: 'italic',
}
}
};
});
// Apply the decorations for multiline preview
textEditor.setDecorations(previewDecorationType, previewRanges);
const disposable = vscode.workspace.onDidChangeTextDocument(async (event) => {
if (event.document.uri.toString() === document.uri.toString()) {
const change = event.contentChanges[0];
// Handle Backspace to decline the preview
if (change && change.text === '' && change.rangeLength === 1) {
textEditor.setDecorations(previewDecorationType, []); // Remove preview decorations
disposable.dispose();
}
// Handle Ctrl + Enter (or Cmd + Enter on macOS) to accept the preview
const isCtrlOrCmdPressed = event.contentChanges.some(
(change) => {
const isMac = process.platform === 'darwin';
const isCtrlOrCmd = isMac ? change.text.includes('\u0010') : change.text.includes('\n');
return isCtrlOrCmd;
}
);
if (isCtrlOrCmdPressed) {
// Remove the preview decoration before applying the final completion
textEditor.setDecorations(previewDecorationType, []);
const edit = new vscode.WorkspaceEdit();
const insertPosition = new vscode.Position(position.line, 0);
// Insert the completion only once
if (!document.getText().includes(completionText)) {
edit.insert(document.uri, insertPosition, '\n' + completionText);
await vscode.workspace.applyEdit(edit);
}
const newPosition = new vscode.Position(position.line + lines.length, lines[lines.length - 1].length);
textEditor.selection = new vscode.Selection(newPosition, newPosition);
disposable.dispose(); // Clean up the listener after accepting the completion
}
}
});
} catch (err: any) {
vscode.window.showErrorMessage(
"Fabelous Autocoder encountered an error: " + err.message
);
console.log(err);
} }
};
const disposable = vscode.Disposable.from(
vscode.window.onDidChangeTextEditorSelection(async (event) => {
if (event.textEditor !== textEditor) return;
if (event.kind === vscode.TextEditorSelectionChangeKind.Keyboard) {
console.log('Accepting completion');
await completionManager.acceptCompletion();
dispose();
}
}),
vscode.window.onDidChangeActiveTextEditor(() => {
console.log('Active editor changed, clearing preview');
completionManager.clearPreview();
dispose();
}),
vscode.workspace.onDidChangeTextDocument((event) => {
if (event.document === document) {
console.log('Document changed, clearing preview');
completionManager.clearPreview();
dispose();
}
})
);
const typeDisposable = vscode.commands.registerCommand('type', async (args) => {
if (args.text === '\b') { // Backspace key
console.log('Declining completion');
completionManager.declineCompletion();
dispose();
}
});
} catch (err: any) {
console.error('Error in autocompleteCommand:', err);
vscode.window.showErrorMessage(`Fabelous Autocoder encountered an error: ${err.message}`);
} finally {
cancellationTokenSource.dispose();
}
}
async function acceptCompletion() {
if (activeCompletionManager) {
await activeCompletionManager.acceptCompletion();
const editor = vscode.window.activeTextEditor;
if (editor) {
const lastLine = editor.document.lineAt(editor.document.lineCount - 1);
const newPosition = new vscode.Position(lastLine.lineNumber, lastLine.text.length);
editor.selection = new vscode.Selection(newPosition, newPosition);
} }
activeCompletionManager = null; );
}
} }
async function handleTab() {
if (activeCompletionManager) {
await acceptCompletion();
} else {
await vscode.commands.executeCommand('tab');
}
}
async function provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, cancellationToken: vscode.CancellationToken) { 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.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) { if (cancellationToken.isCancellationRequested) {
return [item]; return [ item ];
} }
const context = getContextLines(document, position); const context = getContextLines(document, position);
const fimPrompt = createFIMPrompt(context, document.languageId); const fimPrompt = createFIMPrompt(context, document.languageId);
try { try {
const result = await generateCompletion(fimPrompt, cancellationToken); const response_preview = await axios.post(apiEndpoint, {
const preview = (result as any).preview; model: apiModel,
if (preview) { prompt: fimPrompt,
item.detail = preview.split('\n')[0]; stream: false,
} 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) { } catch (error) {
console.error('Error fetching preview:', error); console.error("Error fetching preview:", error);
} }
} }
if (config.continueInline || !config.responsePreview) { item.documentation = new vscode.MarkdownString('Press `Enter` to get an autocompletion from Fabelous Autocoder');
if (continueInline || !responsePreview) {
item.command = { item.command = {
command: 'fabelous-autocoder.autocomplete', command: 'fabelous-autocoder.autocomplete',
title: 'Fabelous Autocomplete', title: 'Fabelous Autocomplete',
arguments: [] arguments: [cancellationToken]
}; };
} }
return [item]; return [item];
} }
export function activate(context: vscode.ExtensionContext) {
updateConfig();
createPreviewDecorationType();
context.subscriptions.push( function activate(context: vscode.ExtensionContext) {
vscode.workspace.onDidChangeConfiguration(updateConfig), const completionProvider = vscode.languages.registerCompletionItemProvider("*", {
vscode.languages.registerCompletionItemProvider('*', { provideCompletionItems }, ...config.completionKeys), provideCompletionItems
vscode.commands.registerTextEditorCommand('fabelous-autocoder.autocomplete', autocompleteCommand), },
vscode.commands.registerCommand('fabelous-autocoder.acceptCompletion', acceptCompletion), ...completionKeys.split("")
vscode.commands.registerCommand('fabelous-autocoder.handleTab', handleTab)
); );
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,
};