261 lines
11 KiB
TypeScript
261 lines
11 KiB
TypeScript
import * as vscode from "vscode";
|
|
import axios from "axios";
|
|
|
|
let VSConfig: vscode.WorkspaceConfiguration;
|
|
let apiEndpoint: string;
|
|
let apiAuthentication: string;
|
|
let apiModel: string;
|
|
let apiTemperature: number;
|
|
let numPredict: number;
|
|
let promptWindowSize: number;
|
|
let completionKeys: string;
|
|
let responsePreview: boolean | undefined;
|
|
let responsePreviewMaxTokens: number;
|
|
let responsePreviewDelay: number;
|
|
let continueInline: boolean | undefined;
|
|
let keepAlive: number | undefined;
|
|
let topP: number | undefined;
|
|
|
|
function updateVSConfig() {
|
|
VSConfig = vscode.workspace.getConfiguration("fabelous-autocoder");
|
|
apiEndpoint = VSConfig.get("endpoint") || "http://localhost:11434/api/generate";
|
|
apiAuthentication = VSConfig.get("authentication") || "";
|
|
apiModel = VSConfig.get("model") || "fabelous-coder:latest";
|
|
numPredict = VSConfig.get("max tokens predicted") || 1000;
|
|
promptWindowSize = VSConfig.get("prompt window size") || 2000;
|
|
completionKeys = VSConfig.get("completion keys") || " ";
|
|
responsePreview = VSConfig.get("response preview");
|
|
responsePreviewMaxTokens = VSConfig.get("preview max tokens") || 50;
|
|
responsePreviewDelay = VSConfig.get("preview delay") || 0;
|
|
continueInline = VSConfig.get("continue inline");
|
|
apiTemperature = VSConfig.get("temperature") || 0.7;
|
|
keepAlive = VSConfig.get("keep alive") || 30;
|
|
topP = VSConfig.get("top p") || 1;
|
|
}
|
|
|
|
updateVSConfig();
|
|
vscode.workspace.onDidChangeConfiguration(updateVSConfig);
|
|
|
|
function getContextLines(document: vscode.TextDocument, position: vscode.Position): string {
|
|
const lines = [];
|
|
const startLine = Math.max(0, position.line - 1);
|
|
const endLine = position.line;
|
|
|
|
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({
|
|
color: '#888888', // Grayed-out preview text
|
|
fontStyle: 'italic',
|
|
rangeBehavior: vscode.DecorationRangeBehavior.ClosedOpen, // Ensure proper handling of multiline decorations
|
|
});
|
|
|
|
async function autocompleteCommand(textEditor: vscode.TextEditor, cancellationToken?: vscode.CancellationToken) {
|
|
const document = textEditor.document;
|
|
const position = textEditor.selection.active;
|
|
|
|
const context = getContextLines(document, position);
|
|
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 = () => {
|
|
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
|
|
}
|
|
});
|
|
|
|
progress.report({ message: "Generating..." });
|
|
|
|
let completionText = response.data.response;
|
|
completionText = completionText.replace(/<fim_middle>|<fim_suffix>|<fim_prefix>/g, '').trim();
|
|
|
|
// Split the completion text by new lines
|
|
const lines = completionText.split('\n');
|
|
|
|
// Create a decoration for each line of the response
|
|
const previewRanges = lines.map((line: string, idx: number) => {
|
|
const linePos = new vscode.Position(position.line + idx, 0);
|
|
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);
|
|
|
|
let completionInserted = false; // Flag to track insertion
|
|
|
|
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 && !completionInserted) {
|
|
// Ensure that we insert the completion text only once
|
|
completionInserted = true;
|
|
|
|
// 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);
|
|
|
|
// Avoid duplicating the completion text
|
|
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);
|
|
}
|
|
}
|
|
);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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:}');
|
|
|
|
if (responsePreview) {
|
|
await new Promise(resolve => setTimeout(resolve, responsePreviewDelay * 1000));
|
|
if (cancellationToken.isCancellationRequested) {
|
|
return [ item ];
|
|
}
|
|
|
|
const context = getContextLines(document, position);
|
|
const fimPrompt = createFIMPrompt(context, document.languageId);
|
|
|
|
try {
|
|
const response_preview = await axios.post(apiEndpoint, {
|
|
model: apiModel,
|
|
prompt: fimPrompt,
|
|
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) {
|
|
console.error("Error fetching preview:", error);
|
|
}
|
|
}
|
|
|
|
item.documentation = new vscode.MarkdownString('Press `Enter` to get an autocompletion from Fabelous Autocoder');
|
|
if (continueInline || !responsePreview) {
|
|
item.command = {
|
|
command: 'fabelous-autocoder.autocomplete',
|
|
title: 'Fabelous Autocomplete',
|
|
arguments: [cancellationToken]
|
|
};
|
|
}
|
|
return [item];
|
|
}
|
|
|
|
function activate(context: vscode.ExtensionContext) {
|
|
const completionProvider = vscode.languages.registerCompletionItemProvider("*", {
|
|
provideCompletionItems
|
|
},
|
|
...completionKeys.split("")
|
|
);
|
|
const externalAutocompleteCommand = vscode.commands.registerTextEditorCommand(
|
|
"fabelous-autocoder.autocomplete",
|
|
(textEditor, _, cancellationToken?) => {
|
|
autocompleteCommand(textEditor, cancellationToken);
|
|
}
|
|
);
|
|
context.subscriptions.push(completionProvider);
|
|
context.subscriptions.push(externalAutocompleteCommand);
|
|
}
|
|
|
|
function deactivate() { }
|
|
|
|
module.exports = {
|
|
activate,
|
|
deactivate,
|
|
};
|