Membina Copilot GitHub Anda Sendiri: Panduan Langkah demi Langkah untuk Alat Penyiapan Kod

. ├── client // Language Client │ ├── src │ │ ├── test // End to End tests for Language Client / Server │ │ └── extension.ts // Language Client entry point ├── package.json // The extension manifest. └── server // Language Server └── src └── server.ts // Language Server entry point

export function activate(context: ExtensionContext) { }

export function activate(context: ExtensionContext) { const serverModule = context.asAbsolutePath( path.join("server", "out", "server.js") ); const debugOptions = { execArgv: ['--nolazy', '-- inspect=6009'] }; // communication with the server using Stdio const serverOptions: ServerOptions = { run: { module: serverModule, transport: TransportKind.stdio, }, debug: { module: serverModule, transport: TransportKind.stdio, options: debugOptions } }; const clientOptions: LanguageClientOptions = { documentSelector: [{ scheme: 'file' }], initializationOptions: serverConfiguration }; client = new LanguageClient( 'LSP Server Name', serverOptions, clientOptions ); client.start(); }

const methodStore: Record = { exit, initialize, shutdown, }; process.stdin.on("data", async (bufferChuck) => { buffer += bufferChuck; while (true) { try { // Check for the Content-Length line const lengthMatch = buffer.match(/Content-Length: (\d+)\r\n/); if (!lengthMatch) break; const contentLength = parseInt(lengthMatch[1], 10); const messageStart = buffer.indexOf("\r\n\r\n") + 4; // Continue unless the full message is in the buffer if (buffer.length < messageStart + contentLength) break; const rawMessage = buffer.slice(messageStart, messageStart + contentLength); const message = JSON.parse(rawMessage); const method = methodStore[message.method]; if (method) { const result = await method(message); if (result !== undefined) { respond(message.id, result); } } buffer = buffer.slice(messageStart + contentLength); } catch (error: any) { const errorMessage = { jsonrpc: "2.0", method: "window/showMessage", params: { type: 1, // Error type message: `Error processing request: ${error.message}` } }; const errorNotification = JSON.stringify(errorMessage); const errorNotificationLength = Buffer.byteLength(errorNotification, "utf-8"); const errorHeader = `Content-Length: ${errorNotificationLength}\r\n\r\n`; process.stdout.write(errorHeader + errorNotification); } } });

export const initialize = (message: RequestMessage): InitializeResult => { return { capabilities: { completionProvider: { resolveProvider: true }, textDocumentSync: TextDocumentSyncKind.Incremental, codeActionProvider: { resolveProvider: true } }, serverInfo: { name: "LSP-Server", version: "1.0.0", }, }; };

export const exit = () => { process.exit(0); };

export const shutdown = () => { return null; };

const methodStore: Record = { exit, initialize, shutdown, "textDocument/generation": generation };

export const generation = async (message: any) => { if(!message && message !== undefined) return {}; const text = message.params.textDocument.text as string; if(!text) return {}; const cursorText = getNewCursorText(text, message.params.position.line, message.params.position.character); const response = await getResponseFromOpenAI(cursorText, message.params.fsPath); return { generatedText: response, } } function getNewCursorText(text: string, line: number, character: number): string { const lines = text.split('\n'); if (line < 0 || line >= lines.length) return text; const targetLine = lines[line]; if (character < 0 || character > targetLine.length) return text; lines[line] = targetLine.slice(0, character) + '' + targetLine.slice(character); return lines.join('\n'); } const getResponseFromOpenAI = async (text: string, fsPath: stiring): Promise => { const message = { "role": "user", "content": text }; const systemMetaData: Paramaters = { max_token: 128, max_context: 1024, messages: [], fsPath: fsPath } const messages = [systemPrompt(systemMetaData), message] const chatCompletion: OpenAI.Chat.ChatCompletion | undefined = await this.open_ai_client?.chat.completions.create({ messages: messages, model: "gpt-3.5-turbo", max_tokens: systemMetaData?.max_tokens ?? 128, }); if (!chatCompletion) return ""; const generatedResponse = chatCompletion.choices[0].message.content; if (!generatedResponse) return ""; return generatedResponse; }

interface Parameters { max_tokens: number; max_context: number; messages: any[]; fsPath: string; } export const systemPrompt = (paramaters: Parameters | null) => { return { "role": "system", "content": ` Instructions: - You are an AI programming assistant. - Given a piece of code with the cursor location marked by , replace  with the correct code. - First, think step-by-step. - Describe your plan for what to build in pseudocode, written out in great detail. - Then output the code replacing the . - Ensure that your completion fits within the language context of the provided code snippet. - Ensure, completion is what ever is needed, dont write beyond 1 or 2 line, unless the  is on start of a function, class or any control statment(if, switch, for, while). Rules: - Only respond with code. - Only replace ; do not include any previously written code. - Never include  in your response. - Handle ambiguous cases by providing the most contextually appropriate completion. - Be consistent with your responses. - You should only generate code in the language specified in the META_DATA. - Never mix text with code. - your code should have appropriate spacing. META_DATA: ${paramaters?.fsPath}` }; };

import {languages} from "vscode"; function getConfiguration(configName: string) { if(Object.keys(workspace.getConfiguration(EXTENSION_ID).get(configName)).length > 0){ return workspace.getConfiguration(EXTENSION_ID).get(configName); } return null; } const inLineCompletionConfig = getConfiguration("inlineCompletionConfiguration"); export function activate(context: ExtensionContext) { // OTHER CODE languages.registerInlineCompletionItemProvider( { pattern: "**" }, { provideInlineCompletionItems: (document: TextDocument, position: Position) => { const mode = inLineCompletionConfig["mode"] || 'slow'; return provideInlineCompletionItems(document, position, mode); }, } ); } let lastInlineCompletion = Date.now(); let lastPosition: Position | null = null; let inlineCompletionRequestCounter = 0; const provideInlineCompletionItems = async (document: TextDocument, position: Position, mode: 'fast' | 'slow') => { const params = { textDocument: { uri: document.uri.toString(), text: document.getText(), }, position: position, fsPath: document.uri.fsPath.toString() }; inlineCompletionRequestCounter += 1; const localInCompletionRequestCounter = inlineCompletionRequestCounter; const timeSinceLastCompletion = (Date.now() - lastInlineCompletion) / 1000; const minInterval = mode === 'fast' ? 0 : 1 / inLineCompletionConfig["maxCompletionsPerSecond"]; if (timeSinceLastCompletion < minInterval) { await new Promise(r => setTimeout(r, (minInterval - timeSinceLastCompletion) * 1000)); } if (inlineCompletionRequestCounter === localInCompletionRequestCounter) { lastInlineCompletion = Date.now(); let cancelRequest = CancellationToken.None; if (lastPosition && position.isAfter(lastPosition)) { cancelRequest = CancellationToken.Cancelled; } lastPosition = position; try { const result = await client.sendRequest("textDocument/generation", params, cancelRequest); const snippetCode = new SnippetString(result["generatedText"]); return [new InlineCompletionItem(snippetCode)]; } catch (error) { console.error("Error during inline completion request", error); client.sendNotification("window/showMessage", { type: 1, // Error type message: "An error occurred during inline completion: " + error.message }); return []; } } else { return []; } };