= ({ children, language }) => (
35 |
36 | {children}
37 |
38 | );
39 |
40 | // Configure TurndownService for consistent Markdown conversion
41 | const turndownService = new TurndownService({
42 | headingStyle: "atx",
43 | hr: "---",
44 | bulletListMarker: "-",
45 | codeBlockStyle: "fenced",
46 | fence: "```",
47 | emDelimiter: "*",
48 | strongDelimiter: "**",
49 | linkStyle: "inlined",
50 | linkReferenceStyle: "full",
51 | preformattedCode: true,
52 | });
53 |
54 | /**
55 | * Converts a JSX Message element to a core message object.
56 | * @param jsx - The JSX Message element to convert.
57 | * @returns A core message object.
58 | * @throws {Error} if the JSX element is invalid or has an invalid role.
59 | */
60 | export const jsxToCoreMessage = (jsx: React.ReactElement): CoreMessage => {
61 | const html = ReactDOMServer.renderToStaticMarkup(jsx);
62 | if (jsx.type !== Message) {
63 | throw new Error("Invalid JSX element: expected Message component");
64 | }
65 | const content = turndownService.turndown(html);
66 | switch (jsx.props.role) {
67 | case "assistant":
68 | case "user":
69 | case "system":
70 | return { role: jsx.props.role, content: content };
71 | default:
72 | throw new Error(`Invalid role in JSX element: ${jsx.props.role}`);
73 | }
74 | };
75 |
76 | /**
77 | * Converts a JSX element to a VS Code MarkdownString.
78 | * @param jsx - The JSX element to convert.
79 | * @returns A VS Code MarkdownString representation of the JSX element.
80 | */
81 | export const jsxToMarkdown = (
82 | jsx: React.ReactElement,
83 | ): vscode.MarkdownString => {
84 | return new vscode.MarkdownString(
85 | turndownService.turndown(ReactDOMServer.renderToStaticMarkup(jsx)),
86 | );
87 | };
88 |
--------------------------------------------------------------------------------
/src/prompts/panel-chat.tsx:
--------------------------------------------------------------------------------
1 | import { CoreMessage } from "ai";
2 | import * as vscode from "vscode";
3 | import { logger } from "../logger";
4 | import {
5 | Code,
6 | Message,
7 | jsxToCoreMessage,
8 | jsxToMarkdown,
9 | } from "./jsx-utilities";
10 |
11 | /**
12 | * PanelChatPrompt class handles the generation of prompts for panel chat functionality.
13 | * It manages the context, history, and prompt generation for various chat scenarios.
14 | */
15 | export class PanelChatPrompt {
16 | /**
17 | * Generates history prompts from the chat context.
18 | * @param {vscode.ChatContext} context - The chat context.
19 | * @returns {CoreMessage[]} An array of CoreMessages representing the chat history.
20 | */
21 | public static getHistoryPrompts(context: vscode.ChatContext): CoreMessage[] {
22 | logger.debug("Generating history prompts");
23 | return context.history.map((item) => {
24 | if ("prompt" in item) {
25 | return jsxToCoreMessage({item.prompt});
26 | } else {
27 | // Check if the response has metadata
28 | if (item.result.metadata?.response?.length) {
29 | return {
30 | role: "assistant",
31 | content: item.result.metadata.response?.trim() || "Empty Response",
32 | };
33 | }
34 | // Check if the response has a `response` property
35 | logger.debug("Parsing chat response from response");
36 | return {
37 | role: "assistant",
38 | content:
39 | item.response
40 | .map((x) =>
41 | x.value instanceof vscode.MarkdownString ? x.value.value : "",
42 | )
43 | .join("\n\n")
44 | .trim() || "Empty Response",
45 | };
46 | }
47 | });
48 | }
49 |
50 | /**
51 | * Generates the system prompt.
52 | * @param {string} model - The name of the AI model.
53 | * @returns {CoreMessage} The system prompt as a CoreMessage.
54 | */
55 | public static getChatProviderSystemPrompt(model: string): CoreMessage {
56 | logger.debug("Generating system prompt");
57 | return jsxToCoreMessage(
58 |
59 |
60 | - You are an AI programming assistant named "Flexpilot"
61 | - Follow the user's requirements carefully & to the letter.
62 | - Avoid content that violates copyrights.
63 | -
64 | If you are asked to generate content that is harmful, hateful,
65 | racist, sexist, lewd or violent only respond with "Sorry, I can't
66 | assist with that."
67 |
68 | - Keep your answers short and impersonal.
69 | -
70 | You are powered by {model} Large Language Model
71 |
72 | - Use Markdown formatting in your answers.
73 | -
74 | Make sure to include the programming language name at the start of
75 | the Markdown code blocks like below
76 |
77 | print("hello world")
78 | - Avoid wrapping the whole response in triple backticks.
79 | - The user works in an IDE called Visual Studio Code
80 | -
81 | The user is working on a {process.platform} operating system.
82 | Please respond with system specific commands if applicable.
83 |
84 | -
85 | The active file or document is the source code the user is looking
86 | at right now.
87 |
88 |
89 | ,
90 | );
91 | }
92 |
93 | /**
94 | * Generates the context prompt including the current file content and selection.
95 | * @param {vscode.TextDocument} document - The active document.
96 | * @param {vscode.Selection} selection - The active selection.
97 | * @returns {CoreMessage} The context prompt as a CoreMessage.
98 | */
99 | public static getFollowUpProviderSystemPrompt(): CoreMessage {
100 | logger.debug("Generating follow-up system prompt");
101 | return jsxToCoreMessage(
102 |
103 | Follow-Up Question Creator for Chatbot Conversations
104 |
105 | You specialize in generating follow-up questions for chatbot
106 | dialogues. When presented with a conversation, provide a short,
107 | one-sentence question that the user can ask naturally that follows
108 | from the previous few questions and answers.
109 |
110 | Guidelines:
111 |
112 | -
113 | Refrain from harmful, hateful, racist, sexist, lewd, violent, or
114 | irrelevant content
115 |
116 | - Keep responses brief and impersonal
117 | - Aim for questions of about 10 words or fewer
118 |
119 | Sample Follow-Up Questions:
120 |
121 | - How can I optimize this SQL query?
122 | - What are the best practices for using Docker?
123 | - How can I improve the performance of my React app?
124 | - What are the common pitfalls of using Node.js?
125 | - How can I secure my Kubernetes cluster?
126 |
127 | ,
128 | );
129 | }
130 |
131 | /**
132 | * Generates the follow-up prompt.
133 | * @returns {CoreMessage} The follow-up prompt as a CoreMessage.
134 | */
135 | public static getFollowUpProviderUserPrompt(): CoreMessage {
136 | logger.debug("Generating follow-up prompt");
137 | return jsxToCoreMessage(
138 |
139 | Write a short (under 10 words) one-sentence follow up question that the
140 | user can ask naturally that follows from the previous few questions and
141 | answers. Reply with only the text of the question and nothing else.
142 | ,
143 | );
144 | }
145 |
146 | /**
147 | * Generates the help text prefix.
148 | * @returns {string} The help text prefix as a Markdown string.
149 | */
150 | public static getHelpTextPrefix(): vscode.MarkdownString {
151 | logger.debug("Generating help text prefix");
152 | return jsxToMarkdown(
153 |
154 |
155 | You can ask me general programming questions, or chat with the
156 | participants who have specialized expertise and can perform actions.
157 |
158 |
159 | Available Commands:
160 |
172 |
173 | To get started, please configure the language model provider by using
174 | the above commands from the Visual Studio Code command palette (
175 | Ctrl+Shift+P on Windows/Linux or Cmd+Shift+P{" "}
176 | on macOS).
177 |
178 | ,
179 | );
180 | }
181 |
182 | /**
183 | * Generates the help text postfix.
184 | * @returns {string} The help text postfix as a Markdown string.
185 | */
186 | public static getHelpTextPostfix(): vscode.MarkdownString {
187 | logger.debug("Generating help text postfix");
188 | return jsxToMarkdown(
189 |
190 |
191 | To have a great conversation, ask me questions as if I was a real
192 | programmer:
193 |
194 |
195 | -
196 | Show me the code you want to talk about by having
197 | the files open and selecting the most important lines.
198 |
199 | -
200 | Make refinements by asking me follow-up questions,
201 | adding clarifications, providing errors, etc.
202 |
203 | -
204 | Review my suggested code and tell me about issues
205 | or improvements, so I can iterate on it.
206 |
207 |
208 |
209 | You can also ask me questions about your editor selection by{" "}
210 | starting an inline chat session
211 |
212 |
213 | Learn more about Flexpilot from our official docs{" "}
214 | here
215 |
216 | ,
217 | );
218 | }
219 |
220 | /**
221 | * Generates the welcome message.
222 | * @param {string} username - The username to include in the welcome message.
223 | * @returns {string} The welcome message as a Markdown string.
224 | */
225 | public static getWelcomeMessage(username: string): vscode.MarkdownString {
226 | logger.debug(`Generating welcome message for user: ${username}`);
227 | return jsxToMarkdown(
228 |
229 |
230 | Welcome, @{username}, I'm your pair programmer and I'm here to
231 | help you get things done faster.
232 |
233 | ,
234 | );
235 | }
236 |
237 | /**
238 | * Generates the help text variables prefix.
239 | * @returns {string} The help text variables prefix as a Markdown string.
240 | */
241 | public static getHelpTextVariablesPrefix(): vscode.MarkdownString {
242 | logger.debug("Generating help text variables prefix");
243 | return jsxToMarkdown(
244 |
245 | Use the variables below to add more information to your question
246 | ,
247 | );
248 | }
249 |
250 | /**
251 | * Generates the title provider system prompt.
252 | * @returns {CoreMessage} The title provider system prompt as a CoreMessage.
253 | */
254 | public static getTitleProviderSystemPrompt(): CoreMessage {
255 | logger.debug("Generating title provider system prompt");
256 | return jsxToCoreMessage(
257 |
258 | Expert Title Creator for Chatbot Conversations
259 |
260 | You specialize in generating concise titles for chatbot discussions.
261 | When presented with a conversation, provide a brief title that
262 | encapsulates the main topic.
263 |
264 | Guidelines:
265 |
266 | -
267 | Refrain from harmful, hateful, racist, sexist, lewd, violent, or
268 | irrelevant content
269 |
270 | - Keep responses brief and impersonal
271 | - Aim for titles of about 10 words or fewer
272 | - Do not use quotation marks
273 |
274 | Sample Titles:
275 |
276 | - Docker container networking issues
277 | - Optimizing SQL query performance
278 | - Implementing JWT authentication in Node.js
279 | - Debugging memory leaks in C++ applications
280 | - Configuring Kubernetes ingress controllers
281 |
282 | ,
283 | );
284 | }
285 |
286 | /**
287 | * Generates the title provider user prompt.
288 | * @returns {CoreMessage} The title provider user prompt as a CoreMessage.
289 | */
290 | public static getTitleProviderUserPrompt(): CoreMessage {
291 | logger.debug("Generating title provider user prompt");
292 | return jsxToCoreMessage(
293 |
294 | Kindly provide a concise title for the preceding chat dialogue. In case
295 | the conversation encompasses multiple subjects, you may concentrate on
296 | the most recent topic discussed. Reply with only the text of the title
297 | and nothing else.
298 | ,
299 | );
300 | }
301 | }
302 |
--------------------------------------------------------------------------------
/src/providers/anthropic.ts:
--------------------------------------------------------------------------------
1 | import { createAnthropic } from "@ai-sdk/anthropic";
2 | import { generateText, LanguageModelV1 } from "ai";
3 | import * as vscode from "vscode";
4 | import { IChatModelProvider, IModelConfig } from "../interfaces";
5 | import { logger } from "../logger";
6 | import { storage } from "../storage";
7 |
8 | /**
9 | * Extended interface for Anthropic chat model configuration
10 | */
11 | interface IAnthropicChatModelConfig extends IModelConfig {
12 | apiKey: string;
13 | baseUrl: string;
14 | }
15 |
16 | /**
17 | * Default help prompt for Anthropic API key configuration
18 | */
19 | const DEFAULT_HELP_PROMPT =
20 | "Click [here](https://docs.flexpilot.ai/model-providers/anthropic.html) for more information";
21 |
22 | /**
23 | * Anthropic Chat Model Provider class
24 | * Manages the configuration and creation of Anthropic chat models
25 | */
26 | export class AnthropicChatModelProvider extends IChatModelProvider {
27 | static readonly providerName = "Anthropic";
28 | static readonly providerId = "anthropic-chat";
29 | static readonly providerType = "chat" as const;
30 | public readonly config: IAnthropicChatModelConfig;
31 |
32 | /**
33 | * Constructor for AnthropicChatModelProvider
34 | * @param {string} nickname - The nickname for the model configuration
35 | * @throws {Error} If the model configuration is not found
36 | */
37 | constructor(nickname: string) {
38 | super(nickname);
39 | logger.debug(
40 | `Initializing AnthropicChatModelProvider with nickname: ${nickname}`,
41 | );
42 | const config = storage.models.get(nickname);
43 | if (!config) {
44 | throw new Error(`Model configuration not found for ${nickname}`);
45 | }
46 | this.config = config;
47 | logger.info(`AnthropicChatModelProvider initialized for ${nickname}`);
48 | }
49 |
50 | /**
51 | * Configures a new Anthropic model
52 | * @param {string} nickname - The nickname for the new model configuration
53 | * @throws {Error} If configuration process is cancelled or fails
54 | */
55 | static readonly configure = async (nickname: string): Promise => {
56 | logger.info(`Configuring Anthropic model with nickname: ${nickname}`);
57 |
58 | const config = storage.models.get(nickname);
59 |
60 | // Prompt user for API key
61 | let apiKey = await vscode.window.showInputBox({
62 | ignoreFocusOut: true,
63 | value: config?.apiKey ?? "",
64 | valueSelection: [0, 0],
65 | placeHolder: "e.g., sk-ant-api03-qojTF59pEBxB7DZ...", // cspell:disable-line
66 | prompt: DEFAULT_HELP_PROMPT,
67 | title: "Flexpilot: Enter your Anthropic API key",
68 | });
69 | if (apiKey === undefined) {
70 | throw new Error("User cancelled API key input");
71 | }
72 | apiKey = apiKey.trim();
73 |
74 | // Prompt user for base URL
75 | const defaultBaseUrl = "https://api.anthropic.com/v1";
76 | let baseUrl = await vscode.window.showInputBox({
77 | ignoreFocusOut: true,
78 | value: config?.baseUrl ?? defaultBaseUrl,
79 | valueSelection: [0, 0],
80 | placeHolder: `e.g., ${defaultBaseUrl}`,
81 | prompt: DEFAULT_HELP_PROMPT,
82 | title: "Flexpilot: Enter the base URL for Anthropic API",
83 | });
84 | if (baseUrl === undefined) {
85 | throw new Error("User cancelled base URL input");
86 | }
87 | baseUrl = baseUrl.trim();
88 |
89 | // Prompt user to enter model name
90 | const defaultModel = "claude-3-5-sonnet-20240620";
91 | let model = await vscode.window.showInputBox({
92 | ignoreFocusOut: true,
93 | value: config?.model ?? "",
94 | valueSelection: [0, 0],
95 | placeHolder: `e.g., ${defaultModel}`,
96 | prompt: "Enter the model name",
97 | title: "Flexpilot: Enter the Anthropic API model name",
98 | });
99 | if (model === undefined) {
100 | throw new Error("User cancelled model input");
101 | }
102 | model = model.trim();
103 |
104 | // Test the connection credentials
105 | await vscode.window.withProgress(
106 | {
107 | location: vscode.ProgressLocation.Notification,
108 | title: "Flexpilot",
109 | cancellable: false,
110 | },
111 | async (progress) => {
112 | progress.report({
113 | message: "Testing connection credentials",
114 | });
115 | const anthropic = createAnthropic({
116 | apiKey: apiKey,
117 | baseURL: baseUrl,
118 | });
119 | logger.debug("Testing connection with a simple prompt");
120 | await generateText({
121 | prompt: "Hello",
122 | maxTokens: 3,
123 | model: anthropic.languageModel(model),
124 | });
125 | logger.info("Connection credentials test successful");
126 | },
127 | );
128 |
129 | // Save the selected model configuration
130 | logger.debug(`Saving model configuration for ${nickname}`);
131 | await storage.models.set(nickname, {
132 | baseUrl: baseUrl,
133 | apiKey: apiKey,
134 | model: model,
135 | nickname: nickname,
136 | providerId: AnthropicChatModelProvider.providerId,
137 | });
138 |
139 | logger.info(`Model configuration saved for ${nickname}`);
140 | };
141 |
142 | /**
143 | * Creates and returns a LanguageModelV1 instance
144 | * @returns {Promise} A promise that resolves to a LanguageModelV1 instance
145 | */
146 | async model(): Promise {
147 | logger.debug(`Creating LanguageModelV1 instance for ${this.config.model}`);
148 | const anthropic = createAnthropic({
149 | baseURL: this.config.baseUrl,
150 | apiKey: this.config.apiKey,
151 | });
152 | logger.info(`LanguageModelV1 instance created for ${this.config.model}`);
153 | return anthropic.languageModel(this.config.model);
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/src/providers/azure.ts:
--------------------------------------------------------------------------------
1 | import { createAzure } from "@ai-sdk/azure";
2 | import { Tokenizer } from "@flexpilot-ai/tokenizers";
3 | import { generateText, LanguageModelV1 } from "ai";
4 | import { AzureOpenAI } from "openai";
5 | import * as vscode from "vscode";
6 | import {
7 | IChatModelProvider,
8 | ICompletionModelConfig,
9 | ICompletionModelInvokeOptions,
10 | ICompletionModelProvider,
11 | IModelConfig,
12 | } from "../interfaces";
13 | import { logger } from "../logger";
14 | import { storage } from "../storage";
15 | import { Tokenizers } from "../tokenizers";
16 | import { getCompletionModelMetadata } from "../utilities";
17 |
18 | /**
19 | * Configuration interface for Azure OpenAI Chat Model.
20 | */
21 | interface AzureOpenAIChatModelConfig extends IModelConfig {
22 | apiKey: string;
23 | baseUrl: string;
24 | }
25 |
26 | /**
27 | * Configuration interface for Azure OpenAI Completion Model.
28 | */
29 | interface IAzureOpenAICompletionModelConfig extends ICompletionModelConfig {
30 | apiKey: string;
31 | baseUrl: string;
32 | }
33 |
34 | /**
35 | * Default help prompt for Azure OpenAI configuration.
36 | */
37 | const DEFAULT_HELP_PROMPT =
38 | "Click [here](https://docs.flexpilot.ai/model-providers/azure-openai.html) for more information";
39 |
40 | /**
41 | * Prompts the user to input their Azure OpenAI API key.
42 | * @param {string} [apiKey] - The current API key, if any.
43 | * @returns {Promise} A promise that resolves to the input API key.
44 | * @throws {Error} If the user cancels the input.
45 | */
46 | const getApiKeyInput = async (apiKey?: string): Promise => {
47 | logger.debug("Prompting user for Azure OpenAI API key");
48 | const newApiKey = await vscode.window.showInputBox({
49 | title: "Flexpilot: Enter your Azure OpenAI API key",
50 | ignoreFocusOut: true,
51 | value: apiKey ?? "",
52 | validateInput: (value) =>
53 | !value?.trim() ? "API key cannot be empty" : undefined,
54 | valueSelection: [0, 0],
55 | placeHolder: "e.g., upydshyx1rlleghhe1zw4hri4z80pvdn", // cspell:disable-line
56 | prompt: DEFAULT_HELP_PROMPT,
57 | });
58 | if (newApiKey === undefined) {
59 | throw new Error("User cancelled Azure OpenAI API key input");
60 | }
61 | logger.debug("Azure OpenAI API key input received");
62 | return newApiKey.trim();
63 | };
64 |
65 | /**
66 | * Prompts the user to input their Azure OpenAI base URL.
67 | * @param {string} [baseUrl] - The current base URL, if any.
68 | * @returns {Promise} A promise that resolves to the input base URL.
69 | * @throws {Error} If the user cancels the input.
70 | */
71 | const getBaseUrlInput = async (baseUrl?: string): Promise => {
72 | logger.debug("Prompting user for Azure OpenAI base URL");
73 | const newBaseUrl = await vscode.window.showInputBox({
74 | placeHolder:
75 | "e.g., https://{resourceName}.openai.azure.com/openai/deployments/{deploymentId}",
76 | ignoreFocusOut: true,
77 | value: baseUrl ?? "",
78 | validateInput: (value) =>
79 | !value?.trim() ? "Base URL cannot be empty" : undefined,
80 | valueSelection: [0, 0],
81 | prompt: DEFAULT_HELP_PROMPT,
82 | title: "Flexpilot: Enter your Azure OpenAI base URL",
83 | });
84 | if (newBaseUrl === undefined) {
85 | throw new Error("User cancelled Azure OpenAI base URL input");
86 | }
87 | logger.debug("Azure OpenAI base URL input received");
88 | return newBaseUrl.trim();
89 | };
90 |
91 | /**
92 | * Azure OpenAI Completion Model Provider class
93 | */
94 | export class AzureOpenAICompletionModelProvider extends ICompletionModelProvider {
95 | static readonly providerName = "Azure OpenAI";
96 | static readonly providerId = "azure-openai-completion";
97 | static readonly providerType = "completion" as const;
98 | private tokenizer!: Tokenizer;
99 | public readonly config: IAzureOpenAICompletionModelConfig;
100 |
101 | /**
102 | * Constructor for AzureOpenAICompletionModelProvider
103 | * @param {string} nickname - The nickname for the model configuration
104 | * @throws {Error} If the model configuration is not found
105 | */
106 | constructor(nickname: string) {
107 | super(nickname);
108 | logger.info(
109 | `Initializing AzureOpenAICompletionModelProvider with nickname: ${nickname}`,
110 | );
111 | const config =
112 | storage.models.get(nickname);
113 | if (!config) {
114 | throw new Error(`Model configuration not found for ${nickname}`);
115 | }
116 | this.config = config;
117 | logger.debug(
118 | `AzureOpenAICompletionModelProvider initialized for ${nickname}`,
119 | );
120 | }
121 |
122 | /**
123 | * Initializes the OpenAI model provider.
124 | * @returns {Promise} A promise that resolves when the provider is initialized.
125 | */
126 | async initialize(): Promise {
127 | this.tokenizer = await Tokenizers.get(this.config.model);
128 | }
129 |
130 | /**
131 | * Encodes the given text into tokens.
132 | * @param {string} text - The text to encode.
133 | * @returns {Promise} A promise that resolves to an array of token ids.
134 | */
135 | readonly encode = async (text: string): Promise => {
136 | logger.debug(`Encoding text: ${text.substring(0, 50)}...`);
137 | return this.tokenizer.encode(text, false);
138 | };
139 |
140 | /**
141 | * Decodes the given tokens into text.
142 | * @param {number[]} tokens - The tokens to decode.
143 | * @returns {Promise} A promise that resolves to the decoded text.
144 | */
145 | readonly decode = async (tokens: number[]): Promise => {
146 | logger.debug(`Decoding ${tokens.length} tokens`);
147 | return this.tokenizer.decode(tokens, false);
148 | };
149 |
150 | /**
151 | * Configures a new Azure OpenAI model
152 | * @param {string} nickname - The nickname for the new model configuration
153 | * @returns {Promise} A promise that resolves when the configuration is complete
154 | * @throws {Error} If the configuration process fails
155 | */
156 | static readonly configure = async (nickname: string): Promise => {
157 | logger.info(`Configuring Azure OpenAI model with nickname: ${nickname}`);
158 |
159 | // Load existing configuration
160 | const config =
161 | storage.models.get(nickname);
162 |
163 | // Prompt user for Azure OpenAI API key
164 | const apiKey = await getApiKeyInput(config?.apiKey);
165 |
166 | // Prompt user for Azure OpenAI base URL
167 | const baseUrl = await getBaseUrlInput(config?.baseUrl);
168 |
169 | // Test the connection credentials
170 | let modelId!: string;
171 | await vscode.window.withProgress(
172 | {
173 | location: vscode.ProgressLocation.Notification,
174 | title: "Flexpilot",
175 | cancellable: false,
176 | },
177 | async (progress) => {
178 | progress.report({
179 | message: "Testing connection credentials",
180 | });
181 | logger.debug("Testing connection credentials");
182 | const openai = new AzureOpenAI({
183 | apiKey: apiKey,
184 | apiVersion: "2024-06-01",
185 | baseURL: baseUrl,
186 | });
187 | const response = await openai.completions.create({
188 | prompt: "How",
189 | suffix: "are you?",
190 | max_tokens: 3,
191 | model: baseUrl.split("/").pop() ?? "",
192 | });
193 | modelId = response.model;
194 | logger.info("Connection credentials test successful");
195 | },
196 | );
197 |
198 | // Get the model metadata
199 | const metadata = getCompletionModelMetadata(modelId);
200 | if (!metadata) {
201 | throw new Error(`Model metadata not found for: ${modelId}`);
202 | }
203 |
204 | // Download the selected model's tokenizer
205 | logger.info(`Downloading tokenizer for model: ${modelId}`);
206 | await Tokenizers.download(modelId);
207 |
208 | // Save the model configuration
209 | logger.info(`Saving model configuration for: ${nickname}`);
210 | await storage.models.set(nickname, {
211 | contextWindow: metadata.contextWindow,
212 | baseUrl: baseUrl,
213 | apiKey: apiKey,
214 | model: modelId,
215 | nickname: nickname,
216 | providerId: AzureOpenAICompletionModelProvider.providerId,
217 | });
218 |
219 | logger.info(`Successfully configured Azure OpenAI model: ${nickname}`);
220 | };
221 |
222 | /**
223 | * Invokes the Azure OpenAI model with the given options.
224 | * @param {ICompletionModelInvokeOptions} options - The options for invoking the model.
225 | * @returns {Promise} A promise that resolves to the model's response.
226 | * @throws {Error} If the invocation fails.
227 | */
228 | async invoke(options: ICompletionModelInvokeOptions): Promise {
229 | logger.info(`Invoking Azure OpenAI model: ${this.config.model}`);
230 | logger.debug("Generating text with Azure OpenAI model");
231 |
232 | const openai = new AzureOpenAI({
233 | apiKey: this.config.apiKey,
234 | apiVersion: "2024-06-01",
235 | baseURL: this.config.baseUrl,
236 | });
237 | const response = await openai.completions.create(
238 | {
239 | prompt: options.messages.prefix,
240 | model: this.config.model,
241 | max_tokens: options.maxTokens,
242 | stop: options.stop,
243 | suffix: options.messages.suffix,
244 | temperature: options.temperature,
245 | },
246 | { signal: options.signal },
247 | );
248 | logger.debug(
249 | `Model output: ${response.choices[0].text.substring(0, 50)}...`,
250 | );
251 | return response.choices[0].text;
252 | }
253 | }
254 |
255 | /**
256 | * Azure OpenAI Chat Model Provider class
257 | */
258 | export class AzureOpenAIChatModelProvider extends IChatModelProvider {
259 | static readonly providerName = "Azure OpenAI";
260 | static readonly providerId = "azure-openai-chat";
261 | static readonly providerType = "chat" as const;
262 | public readonly config: AzureOpenAIChatModelConfig;
263 |
264 | /**
265 | * Constructor for AzureOpenAIChatModelProvider
266 | * @param {string} nickname - The nickname for the model configuration
267 | * @throws {Error} If the model configuration is not found
268 | */
269 | constructor(nickname: string) {
270 | super(nickname);
271 | logger.debug(
272 | `Initializing AzureOpenAIChatModelProvider with nickname: ${nickname}`,
273 | );
274 | const config = storage.models.get(nickname);
275 | if (!config) {
276 | throw new Error(`Model configuration not found for ${nickname}`);
277 | }
278 | this.config = config;
279 | logger.info(`AzureOpenAIChatModelProvider initialized for ${nickname}`);
280 | }
281 |
282 | /**
283 | * Configures a new Azure OpenAI chat model
284 | * @param {string} nickname - The nickname for the new model configuration
285 | * @returns {Promise} A promise that resolves when the configuration is complete
286 | * @throws {Error} If the configuration process fails
287 | */
288 | static readonly configure = async (nickname: string): Promise => {
289 | logger.info(
290 | `Configuring Azure OpenAI chat model with nickname: ${nickname}`,
291 | );
292 |
293 | const config = storage.models.get(nickname);
294 |
295 | // Prompt user for Azure OpenAI API key
296 | const apiKey = await getApiKeyInput(config?.apiKey);
297 |
298 | // Prompt user for Azure OpenAI base URL
299 | const baseUrl = await getBaseUrlInput(config?.baseUrl);
300 |
301 | // Test the connection credentials
302 | let modelId!: string;
303 | await vscode.window.withProgress(
304 | {
305 | location: vscode.ProgressLocation.Notification,
306 | title: "Flexpilot",
307 | cancellable: false,
308 | },
309 | async (progress) => {
310 | progress.report({
311 | message: "Testing connection credentials",
312 | });
313 | const openai = createAzure({
314 | apiKey: apiKey,
315 | baseURL: baseUrl,
316 | });
317 | logger.debug("Testing connection credentials");
318 | const response = await generateText({
319 | prompt: "Hello",
320 | maxTokens: 3,
321 | model: openai.chat(""),
322 | });
323 | modelId = response.response.modelId;
324 | logger.info("Connection credentials test successful");
325 | },
326 | );
327 |
328 | // Save the model configuration
329 | logger.info(`Saving model configuration for: ${nickname}`);
330 | await storage.models.set(nickname, {
331 | baseUrl: baseUrl,
332 | apiKey: apiKey,
333 | model: modelId,
334 | nickname: nickname,
335 | providerId: AzureOpenAIChatModelProvider.providerId,
336 | });
337 |
338 | logger.info(`Successfully configured Azure OpenAI chat model: ${nickname}`);
339 | };
340 |
341 | /**
342 | * Creates and returns a LanguageModelV1 instance
343 | * @returns {Promise} A promise that resolves to a LanguageModelV1 instance
344 | * @throws {Error} If the model creation fails
345 | */
346 | async model(): Promise {
347 | logger.debug(`Creating LanguageModelV1 instance for ${this.config.model}`);
348 |
349 | const openai = createAzure({
350 | baseURL: this.config.baseUrl,
351 | apiKey: this.config.apiKey,
352 | });
353 | const model = openai.chat("");
354 | logger.debug(`LanguageModelV1 instance created for ${this.config.model}`);
355 | return model;
356 | }
357 | }
358 |
--------------------------------------------------------------------------------
/src/providers/generic.ts:
--------------------------------------------------------------------------------
1 | import { createOpenAI } from "@ai-sdk/openai";
2 | import { generateText, LanguageModelV1 } from "ai";
3 | import OpenAI from "openai";
4 | import * as vscode from "vscode";
5 | import { IChatModelProvider, IModelConfig } from "../interfaces";
6 | import { logger } from "../logger";
7 | import { storage } from "../storage";
8 |
9 | /**
10 | * Configuration interface for Generic Chat Model.
11 | */
12 | interface IGenericChatModelConfig extends IModelConfig {
13 | apiKey: string;
14 | baseUrl: string;
15 | }
16 |
17 | /**
18 | * Default help prompt for Generic configuration.
19 | */
20 | const DEFAULT_HELP_PROMPT =
21 | "Click [here](https://docs.flexpilot.ai/model-providers/generic.html) for more information";
22 |
23 | /**
24 | * Generic Chat Model Provider class
25 | */
26 | export class GenericChatModelProvider extends IChatModelProvider {
27 | static readonly providerName = "OpenAI Compatible";
28 | static readonly providerId = "generic-chat";
29 | static readonly providerType = "chat" as const;
30 | public readonly config: IGenericChatModelConfig;
31 |
32 | /**
33 | * Constructor for GenericChatModelProvider
34 | * @param {string} nickname - The nickname for the model configuration
35 | * @throws {Error} If the model configuration is not found
36 | */
37 | constructor(nickname: string) {
38 | super(nickname);
39 | logger.debug(
40 | `Initializing GenericChatModelProvider with nickname: ${nickname}`,
41 | );
42 | const config = storage.models.get(nickname);
43 | if (!config) {
44 | throw new Error(`Model configuration not found for ${nickname}`);
45 | }
46 | this.config = config;
47 | logger.info(`GenericChatModelProvider initialized for ${nickname}`);
48 | }
49 |
50 | /**
51 | * Configures a new Generic chat model
52 | * @param {string} nickname - The nickname for the new model configuration
53 | * @returns {Promise} A promise that resolves when the configuration is complete
54 | * @throws {Error} If the configuration process fails
55 | */
56 | static readonly configure = async (nickname: string): Promise => {
57 | logger.info(`Configuring Generic chat model with nickname: ${nickname}`);
58 |
59 | const config = storage.models.get(nickname);
60 |
61 | // Prompt user for base URL
62 | logger.debug("Prompting user for base URL");
63 |
64 | let baseUrl = await vscode.window.showInputBox({
65 | ignoreFocusOut: true,
66 | value: config?.baseUrl ?? "",
67 | validateInput: (value) =>
68 | !value?.trim() ? "Base URL cannot be empty" : undefined,
69 | valueSelection: [0, 0],
70 | placeHolder: `e.g., http://localhost:11434/v1`,
71 | prompt: DEFAULT_HELP_PROMPT,
72 | title: "Flexpilot: Enter your base URL",
73 | });
74 |
75 | if (baseUrl === undefined) {
76 | throw new Error("User cancelled base URL input");
77 | }
78 | baseUrl = baseUrl.trim();
79 | logger.debug("base URL input received");
80 |
81 | // Prompt user for API key
82 | logger.debug("Prompting user for API key");
83 |
84 | let apiKey = await vscode.window.showInputBox({
85 | title: "Flexpilot: Enter your API key",
86 | ignoreFocusOut: true,
87 | value: config?.apiKey ?? "",
88 | validateInput: (value) =>
89 | !value?.trim() ? "API key cannot be empty" : undefined,
90 | valueSelection: [0, 0],
91 | placeHolder: "e.g., ollama", // cspell:disable-line
92 | prompt: DEFAULT_HELP_PROMPT,
93 | });
94 |
95 | if (apiKey === undefined) {
96 | throw new Error("User cancelled API key input");
97 | }
98 | apiKey = apiKey.trim();
99 | logger.debug("API key input received");
100 |
101 | // Declare variables for model selection
102 | let modelsList: string[] = [];
103 | let model: string | undefined;
104 |
105 | // Auto Fetch available models
106 | try {
107 | const openai = new OpenAI({ apiKey: apiKey, baseURL: baseUrl });
108 | const models = await openai.models.list();
109 | logger.debug(`Fetched ${models.data.length} models`);
110 | modelsList = models.data.map((model) => model.id);
111 | } catch (error) {
112 | // Log error and continue with manual model entry
113 | logger.error(error as Error);
114 | }
115 |
116 | if (modelsList.length) {
117 | // Prompt user to select model ID
118 | model = await vscode.window.showQuickPick(modelsList, {
119 | placeHolder: "Select a chat model",
120 | ignoreFocusOut: true,
121 | title: "Flexpilot: Select the chat model",
122 | });
123 | } else {
124 | // Prompt user to manually enter model ID
125 | model = await vscode.window.showInputBox({
126 | title: "Flexpilot: Enter your model name",
127 | ignoreFocusOut: true,
128 | value: config?.model ?? "",
129 | validateInput: (value) =>
130 | !value?.trim() ? "Model name cannot be empty" : undefined,
131 | valueSelection: [0, 0],
132 | placeHolder: "e.g., llama3.2:1b",
133 | prompt: DEFAULT_HELP_PROMPT,
134 | });
135 | }
136 |
137 | // Check if user cancelled model selection
138 | if (model === undefined) {
139 | throw new Error("User cancelled model selection");
140 | }
141 | model = model.trim();
142 |
143 | // Test the connection credentials
144 | await vscode.window.withProgress(
145 | {
146 | location: vscode.ProgressLocation.Notification,
147 | title: "Flexpilot",
148 | cancellable: false,
149 | },
150 | async (progress) => {
151 | progress.report({
152 | message: "Testing connection credentials",
153 | });
154 | const openai = createOpenAI({
155 | compatibility: "compatible",
156 | baseURL: baseUrl,
157 | apiKey: apiKey,
158 | });
159 | logger.debug("Testing connection credentials");
160 | await generateText({
161 | prompt: "Hello",
162 | maxTokens: 3,
163 | model: openai.chat(model),
164 | });
165 | logger.info("Connection credentials test successful");
166 | },
167 | );
168 |
169 | // Save the model configuration
170 | logger.info(`Saving model configuration for: ${nickname}`);
171 | await storage.models.set(nickname, {
172 | baseUrl: baseUrl,
173 | apiKey: apiKey,
174 | model: model,
175 | nickname: nickname,
176 | providerId: GenericChatModelProvider.providerId,
177 | });
178 |
179 | logger.info(`Successfully configured Generic chat model: ${nickname}`);
180 | };
181 |
182 | /**
183 | * Creates and returns a LanguageModelV1 instance
184 | * @returns {Promise} A promise that resolves to a LanguageModelV1 instance
185 | */
186 | async model(): Promise {
187 | logger.debug(`Creating LanguageModelV1 instance for ${this.config.model}`);
188 | const openai = createOpenAI({
189 | compatibility: "compatible",
190 | baseURL: this.config.baseUrl,
191 | apiKey: this.config.apiKey,
192 | });
193 | const model = openai.chat(this.config.model);
194 | logger.debug(`LanguageModelV1 instance created for ${this.config.model}`);
195 | return model;
196 | }
197 | }
198 |
--------------------------------------------------------------------------------
/src/providers/google.ts:
--------------------------------------------------------------------------------
1 | import { createGoogleGenerativeAI } from "@ai-sdk/google";
2 | import { generateText, LanguageModelV1 } from "ai";
3 | import axios from "axios";
4 | import * as vscode from "vscode";
5 | import { IChatModelProvider, IModelConfig } from "../interfaces";
6 | import { logger } from "../logger";
7 | import { storage } from "../storage";
8 |
9 | /**
10 | * Extended interface for Google Generative AI chat model configuration
11 | */
12 | interface IGoogleGenerativeAIChatModelConfig extends IModelConfig {
13 | apiKey: string;
14 | baseUrl: string;
15 | }
16 |
17 | /**
18 | * Interface representing a Google AI model
19 | * @see https://ai.google.dev/api/models#Model
20 | */
21 | interface IGoogleModel {
22 | name: string;
23 | supportedGenerationMethods: string[];
24 | }
25 |
26 | const DEFAULT_HELP_PROMPT =
27 | "Click [here](https://docs.flexpilot.ai/model-providers/google-gemini.html) for more information";
28 |
29 | /**
30 | * Google Generative AI Chat Model Provider class
31 | */
32 | export class GoogleChatModelProvider extends IChatModelProvider {
33 | static readonly providerName = "Google Generative AI";
34 | static readonly providerId = "google-generative-ai-chat";
35 | static readonly providerType = "chat" as const;
36 | public readonly config: IGoogleGenerativeAIChatModelConfig;
37 |
38 | /**
39 | * Constructor for GoogleChatModelProvider
40 | * @param {string} nickname - The nickname for the model configuration
41 | * @throws {Error} If the model configuration is not found
42 | */
43 | constructor(nickname: string) {
44 | super(nickname);
45 | logger.debug(
46 | `Initializing GoogleChatModelProvider with nickname: ${nickname}`,
47 | );
48 | const config =
49 | storage.models.get(nickname);
50 | if (!config) {
51 | throw new Error(`Model configuration not found for ${nickname}`);
52 | }
53 | this.config = config;
54 | logger.info(`GoogleChatModelProvider initialized for ${nickname}`);
55 | }
56 |
57 | /**
58 | * Configures a new Google Generative AI model
59 | * @param {string} nickname - The nickname for the new model configuration
60 | * @throws {Error} If configuration process is cancelled or fails
61 | */
62 | static readonly configure = async (nickname: string): Promise => {
63 | logger.info(
64 | `Configuring Google Generative AI model with nickname: ${nickname}`,
65 | );
66 |
67 | const config =
68 | storage.models.get(nickname);
69 |
70 | // Prompt user for API key
71 | let apiKey = await vscode.window.showInputBox({
72 | ignoreFocusOut: true,
73 | value: config?.apiKey ?? "",
74 | valueSelection: [0, 0],
75 | placeHolder: "e.g., A123SyBMH486BbQe684JHG2ASZ2-RKmmVe-X11M", // cspell:disable-line
76 | prompt: DEFAULT_HELP_PROMPT,
77 | title: "Flexpilot: Enter your Google Generative AI API key",
78 | });
79 | if (apiKey === undefined) {
80 | throw new Error("User cancelled API key input");
81 | }
82 | apiKey = apiKey.trim();
83 |
84 | // Prompt user for base URL
85 | const defaultBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
86 | let baseUrl = await vscode.window.showInputBox({
87 | ignoreFocusOut: true,
88 | value: config?.baseUrl ?? defaultBaseUrl,
89 | valueSelection: [0, 0],
90 | placeHolder: `e.g., ${defaultBaseUrl}`,
91 | prompt: DEFAULT_HELP_PROMPT,
92 | title: "Flexpilot: Enter the base URL for Google Generative AI",
93 | });
94 | if (baseUrl === undefined) {
95 | throw new Error("User cancelled base URL input");
96 | }
97 | baseUrl = baseUrl.trim();
98 |
99 | // Fetch available models from Google Generative AI API
100 | const response = await vscode.window.withProgress(
101 | {
102 | location: vscode.ProgressLocation.Notification,
103 | title: "Flexpilot",
104 | cancellable: true,
105 | },
106 | async (progress) => {
107 | progress.report({
108 | message: "Fetching available models",
109 | });
110 | return await axios.get(`${baseUrl}/models?key=${apiKey}`);
111 | },
112 | );
113 |
114 | // Filter out models that are not supported for content generation
115 | const modelPickUpItems: vscode.QuickPickItem[] = [];
116 | for (const model of response.data.models as IGoogleModel[]) {
117 | if (
118 | model.name.split("-")[0].split("/")[1] === "gemini" &&
119 | parseFloat(model.name.split("-")[1]) > 1 &&
120 | model.supportedGenerationMethods.includes("generateContent")
121 | ) {
122 | modelPickUpItems.push({ label: model.name });
123 | }
124 | }
125 |
126 | // Prompt user to select a model
127 | const model = await vscode.window.showQuickPick(modelPickUpItems, {
128 | placeHolder: "Select a chat model",
129 | ignoreFocusOut: true,
130 | title: "Flexpilot: Select the Google Generative AI model",
131 | });
132 | if (model === undefined) {
133 | throw new Error("User cancelled model selection");
134 | }
135 |
136 | // Test the connection credentials
137 | await vscode.window.withProgress(
138 | {
139 | location: vscode.ProgressLocation.Notification,
140 | title: "Flexpilot",
141 | cancellable: false,
142 | },
143 | async (progress) => {
144 | progress.report({
145 | message: "Testing connection credentials",
146 | });
147 | const google = createGoogleGenerativeAI({
148 | apiKey: apiKey,
149 | baseURL: baseUrl,
150 | });
151 | await generateText({
152 | prompt: "Hello",
153 | maxTokens: 3,
154 | model: google.chat(model.label),
155 | });
156 | logger.info("Connection credentials test successful");
157 | },
158 | );
159 |
160 | // Save the selected model configuration
161 | await storage.models.set(nickname, {
162 | baseUrl: baseUrl,
163 | apiKey: apiKey,
164 | model: model.label,
165 | nickname: nickname,
166 | providerId: GoogleChatModelProvider.providerId,
167 | });
168 |
169 | logger.info(`Model configuration saved for ${nickname}`);
170 | };
171 |
172 | /**
173 | * Creates and returns a LanguageModelV1 instance
174 | * @returns {Promise} A promise that resolves to a LanguageModelV1 instance
175 | */
176 | async model(): Promise {
177 | logger.debug(`Creating LanguageModelV1 instance for ${this.config.model}`);
178 | const google = createGoogleGenerativeAI({
179 | baseURL: this.config.baseUrl,
180 | apiKey: this.config.apiKey,
181 | });
182 | return google.chat(this.config.model);
183 | }
184 | }
185 |
--------------------------------------------------------------------------------
/src/providers/groq.ts:
--------------------------------------------------------------------------------
1 | import { createOpenAI } from "@ai-sdk/openai";
2 | import { generateText, LanguageModelV1 } from "ai";
3 | import OpenAI from "openai";
4 | import * as vscode from "vscode";
5 | import { IChatModelProvider, IModelConfig } from "../interfaces";
6 | import { logger } from "../logger";
7 | import { storage } from "../storage";
8 |
9 | /**
10 | * Extended interface for GroqCloud chat model configuration
11 | */
12 | interface IGroqCloudChatModelConfig extends IModelConfig {
13 | apiKey: string;
14 | baseUrl: string;
15 | }
16 |
17 | /**
18 | * Interface representing a GroqCloud model
19 | * @see https://console.groqcloud.com/docs/api-reference#models
20 | */
21 | interface IGroqCloudModel {
22 | id: string;
23 | active: boolean;
24 | }
25 |
26 | /**
27 | * Default help prompt for GroqCloud API key configuration
28 | */
29 | const DEFAULT_HELP_PROMPT =
30 | "Click [here](https://docs.flexpilot.ai/model-providers/groq.html) for more information";
31 |
32 | /**
33 | * GroqCloud Chat Model Provider class
34 | * Manages the configuration and creation of GroqCloud chat models
35 | */
36 | export class GroqCloudChatModelProvider extends IChatModelProvider {
37 | static readonly providerName = "GroqCloud";
38 | static readonly providerId = "groqcloud-chat";
39 | static readonly providerType = "chat" as const;
40 | public readonly config: IGroqCloudChatModelConfig;
41 |
42 | /**
43 | * Constructor for GroqCloudChatModelProvider
44 | * @param {string} nickname - The nickname for the model configuration
45 | * @throws {Error} If the model configuration is not found
46 | */
47 | constructor(nickname: string) {
48 | super(nickname);
49 | logger.debug(
50 | `Initializing GroqCloudChatModelProvider with nickname: ${nickname}`,
51 | );
52 | const config = storage.models.get(nickname);
53 | if (!config) {
54 | throw new Error(`Model configuration not found for ${nickname}`);
55 | }
56 | this.config = config;
57 | logger.info(`GroqCloudChatModelProvider initialized for ${nickname}`);
58 | }
59 |
60 | /**
61 | * Configures a new GroqCloud model
62 | * @param {string} nickname - The nickname for the new model configuration
63 | * @throws {Error} If configuration process is cancelled or fails
64 | */
65 | static readonly configure = async (nickname: string): Promise => {
66 | logger.info(`Configuring GroqCloud model with nickname: ${nickname}`);
67 |
68 | const config = storage.models.get(nickname);
69 |
70 | // Prompt user for API key
71 | let apiKey = await vscode.window.showInputBox({
72 | ignoreFocusOut: true,
73 | value: config?.apiKey ?? "",
74 | valueSelection: [0, 0],
75 | placeHolder: "e.g., gsk_vgAcnlKOXdklg2AWLUv...", // cspell:disable-line
76 | prompt: DEFAULT_HELP_PROMPT,
77 | title: "Flexpilot: Enter your GroqCloud API key",
78 | });
79 | if (apiKey === undefined) {
80 | throw new Error("User cancelled API key input");
81 | }
82 | apiKey = apiKey.trim();
83 |
84 | // Prompt user for base URL
85 | const defaultBaseUrl = "https://api.groq.com/openai/v1";
86 | let baseUrl = await vscode.window.showInputBox({
87 | ignoreFocusOut: true,
88 | value: config?.baseUrl ?? defaultBaseUrl,
89 | valueSelection: [0, 0],
90 | placeHolder: `e.g., ${defaultBaseUrl}`,
91 | prompt: DEFAULT_HELP_PROMPT,
92 | title: "Flexpilot: Enter the base URL for GroqCloud API",
93 | });
94 | if (baseUrl === undefined) {
95 | throw new Error("User cancelled base URL input");
96 | }
97 | baseUrl = baseUrl.trim();
98 |
99 | // Fetch available models from GroqCloud API
100 | const response = await vscode.window.withProgress(
101 | {
102 | location: vscode.ProgressLocation.Notification,
103 | title: "Flexpilot",
104 | cancellable: true,
105 | },
106 | async (progress) => {
107 | progress.report({
108 | message: "Fetching available models",
109 | });
110 | const openai = new OpenAI({
111 | apiKey: apiKey,
112 | baseURL: baseUrl,
113 | });
114 | logger.debug("Fetching models from GroqCloud API");
115 | const models = await openai.models.list();
116 | logger.debug(`Fetched ${models.data.length} models`);
117 | return models.data as unknown as IGroqCloudModel[];
118 | },
119 | );
120 |
121 | // Filter out models that are not supported for content generation
122 | const modelPickUpItems: vscode.QuickPickItem[] = [];
123 | for (const model of response) {
124 | if (model.active) {
125 | modelPickUpItems.push({ label: model.id });
126 | }
127 | }
128 |
129 | // Prompt user to select a model
130 | const model = await vscode.window.showQuickPick(modelPickUpItems, {
131 | placeHolder: "Select a chat model",
132 | ignoreFocusOut: true,
133 | title: "Flexpilot: Select the GroqCloud model",
134 | });
135 | if (model === undefined) {
136 | throw new Error("User cancelled model selection");
137 | }
138 |
139 | // Test the connection credentials
140 | await vscode.window.withProgress(
141 | {
142 | location: vscode.ProgressLocation.Notification,
143 | title: "Flexpilot",
144 | cancellable: false,
145 | },
146 | async (progress) => {
147 | progress.report({
148 | message: "Testing connection credentials",
149 | });
150 | const groqcloud = createOpenAI({
151 | apiKey: apiKey,
152 | baseURL: baseUrl,
153 | });
154 | logger.debug("Testing connection with a simple prompt");
155 | await generateText({
156 | prompt: "Hello",
157 | maxTokens: 3,
158 | model: groqcloud.chat(model.label),
159 | });
160 | logger.info("Connection credentials test successful");
161 | },
162 | );
163 |
164 | // Save the selected model configuration
165 | logger.debug(`Saving model configuration for ${nickname}`);
166 | await storage.models.set(nickname, {
167 | baseUrl: baseUrl,
168 | apiKey: apiKey,
169 | model: model.label,
170 | nickname: nickname,
171 | providerId: GroqCloudChatModelProvider.providerId,
172 | });
173 |
174 | logger.info(`Model configuration saved for ${nickname}`);
175 | };
176 |
177 | /**
178 | * Creates and returns a LanguageModelV1 instance
179 | * @returns {Promise} A promise that resolves to a LanguageModelV1 instance
180 | */
181 | async model(): Promise {
182 | logger.debug(`Creating LanguageModelV1 instance for ${this.config.model}`);
183 | const groqcloud = createOpenAI({
184 | baseURL: this.config.baseUrl,
185 | apiKey: this.config.apiKey,
186 | });
187 | logger.info(`LanguageModelV1 instance created for ${this.config.model}`);
188 | return groqcloud.chat(this.config.model);
189 | }
190 | }
191 |
--------------------------------------------------------------------------------
/src/providers/index.ts:
--------------------------------------------------------------------------------
1 | import { LOCATIONS } from "../constants";
2 | import { events } from "../events";
3 | import { ILocationName, IModelType } from "../interfaces";
4 | import { logger } from "../logger";
5 | import { storage } from "../storage";
6 | import { AnthropicChatModelProvider } from "./anthropic";
7 | import {
8 | AzureOpenAIChatModelProvider,
9 | AzureOpenAICompletionModelProvider,
10 | } from "./azure";
11 | import { GenericChatModelProvider } from "./generic";
12 | import { GoogleChatModelProvider } from "./google";
13 | import { GroqCloudChatModelProvider } from "./groq";
14 | import {
15 | MistralAIChatModelProvider,
16 | MistralAICompletionModelProvider,
17 | } from "./mistral-ai";
18 | import {
19 | OpenAIChatModelProvider,
20 | OpenAICompletionModelProvider,
21 | } from "./openai";
22 |
23 | /**
24 | * Array of available model provider classes.
25 | */
26 | export const ModelProviders = [
27 | OpenAIChatModelProvider,
28 | GoogleChatModelProvider,
29 | MistralAIChatModelProvider,
30 | AzureOpenAIChatModelProvider,
31 | AnthropicChatModelProvider,
32 | GroqCloudChatModelProvider,
33 | GenericChatModelProvider,
34 | OpenAICompletionModelProvider,
35 | MistralAICompletionModelProvider,
36 | AzureOpenAICompletionModelProvider,
37 | ] as const;
38 |
39 | /**
40 | * Interfaces for the model provider class.
41 | */
42 | export type IModelProvider = InstanceType<
43 | Extract<(typeof ModelProviders)[number], { providerType: T }>
44 | >;
45 |
46 | export class Test123 {}
47 |
48 | /**
49 | * Manages model providers for different locations.
50 | * Implements the Singleton pattern to ensure a single instance across the application.
51 | */
52 | export class ModelProviderManager {
53 | private readonly modelProviders: Map =
54 | new Map();
55 | private static instance: ModelProviderManager;
56 |
57 | private constructor(extensionContext = storage.getContext()) {
58 | // Check for changes in the lastProviderUpdatedAt secret to re-initialize providers
59 | extensionContext.subscriptions.push(
60 | events.onFire(async (event) => {
61 | logger.debug(`Event Action Started: ${event.name}`);
62 | if (event.name === "modelProvidersUpdated") {
63 | logger.info("Re-initializing model providers");
64 | this.updateProviders();
65 | }
66 | }),
67 | );
68 | logger.info("ModelProviderManager instance created");
69 | }
70 |
71 | /**
72 | * Gets the singleton instance of ModelProviderManager.
73 | * @returns The ModelProviderManager instance
74 | */
75 | public static getInstance(): ModelProviderManager {
76 | if (!ModelProviderManager.instance) {
77 | ModelProviderManager.instance = new ModelProviderManager();
78 | logger.debug("New ModelProviderManager instance created");
79 | }
80 | return ModelProviderManager.instance;
81 | }
82 |
83 | /**
84 | * Gets the provider for a specific location.
85 | * @param locationName - The name of the location
86 | * @returns The model provider for the specified location, or undefined if not found
87 | */
88 | public getProvider(
89 | locationName: ILocationName,
90 | ): IModelProvider | undefined {
91 | const provider = this.modelProviders.get(locationName);
92 | if (!provider) {
93 | logger.info(`No provider found for location ${locationName}`);
94 | return undefined;
95 | }
96 | logger.debug(`Provider retrieved for location: ${locationName}`);
97 | return provider as IModelProvider;
98 | }
99 |
100 | /**
101 | * Updates the provider for all locations based on the usage preference.
102 | */
103 | public async updateProviders(): Promise {
104 | logger.info("Initializing providers for all locations");
105 | await Promise.all(
106 | LOCATIONS.map(async (location) => {
107 | try {
108 | logger.info(`Updating provider for location: ${location.name}`);
109 |
110 | // Trigger once before updating provider
111 | if (location.name === "Inline Completion") {
112 | events.fire({
113 | name: "inlineCompletionProviderUpdated",
114 | payload: { updatedAt: Date.now() },
115 | });
116 | }
117 |
118 | // Delete the existing provider
119 | this.modelProviders.delete(location.name);
120 |
121 | // Get usage preference for the location
122 | const usagePreference = storage.usage.get(location.name);
123 |
124 | if (!usagePreference) {
125 | return logger.info(
126 | `No usage preference found for location: ${location.name}`,
127 | );
128 | }
129 |
130 | // Find the appropriate ModelProvider based on the usage preference
131 | const ModelProvider = ModelProviders.find(
132 | (item) => item.providerId === usagePreference.providerId,
133 | );
134 | if (!ModelProvider) {
135 | return logger.info(
136 | `No matching ModelProvider found for providerId: ${usagePreference.providerId}`,
137 | );
138 | }
139 |
140 | // Create and set the new provider
141 | const modelProvider = new ModelProvider(usagePreference.nickname);
142 | await modelProvider.initialize();
143 | this.modelProviders.set(location.name, modelProvider);
144 | logger.info(
145 | `Provider updated successfully for location: ${location.name}`,
146 | );
147 |
148 | // Trigger once after updating provider
149 | if (location.name === "Inline Completion") {
150 | events.fire({
151 | name: "inlineCompletionProviderUpdated",
152 | payload: { updatedAt: Date.now() },
153 | });
154 | }
155 | } catch (error) {
156 | logger.error(error as Error);
157 | logger.notifyError("Error updating model provider configuration");
158 | }
159 | }),
160 | );
161 | }
162 | }
163 |
--------------------------------------------------------------------------------
/src/session.ts:
--------------------------------------------------------------------------------
1 | import axios from "axios";
2 | import * as vscode from "vscode";
3 | import packageJson from "../package.json";
4 | import InlineCompletionProvider from "./completion";
5 | import InlineChatParticipant from "./inline-chat";
6 | import { logger } from "./logger";
7 | import PanelChatParticipant from "./panel-chat";
8 | import { ModelProviderManager } from "./providers";
9 | import { storage } from "./storage";
10 | import { setContext } from "./utilities";
11 |
12 | /**
13 | * SessionManager class to handle VSCode extension session management and related events.
14 | * This class follows the Singleton pattern to ensure only one instance exists.
15 | */
16 | export class SessionManager extends vscode.Disposable {
17 | private readonly disposables: vscode.Disposable[] = [];
18 | private static instance: SessionManager;
19 |
20 | private constructor(
21 | private readonly extensionContext = storage.getContext(),
22 | ) {
23 | // Call the parent constructor
24 | super(() => {
25 | this.disposables.forEach((disposable) => disposable.dispose());
26 | this.disposeSessionFeatures();
27 | logger.info("Session manager disposed");
28 | });
29 |
30 | // Register the session manager
31 | extensionContext.subscriptions.push(this);
32 |
33 | // Handle the session change
34 | this.disposables.push(
35 | vscode.authentication.onDidChangeSessions(() =>
36 | this.handleSessionChange(),
37 | ),
38 | );
39 |
40 | // Initialize the session manager
41 | logger.info("Session manager initialized");
42 | }
43 |
44 | /**
45 | * Gets the singleton instance of SessionManager.
46 | */
47 | public static async register() {
48 | if (!SessionManager.instance) {
49 | SessionManager.instance = new SessionManager();
50 | SessionManager.instance.handleSessionChange();
51 | logger.debug("New SessionManager instance created");
52 | }
53 | }
54 |
55 | private async checkNewlyInstalled() {
56 | const globalStorageUri = this.extensionContext.globalStorageUri;
57 | const flagUri = vscode.Uri.joinPath(globalStorageUri, "installed_at");
58 |
59 | // Check if the globalStorageUri folder exists in storage
60 | try {
61 | await vscode.workspace.fs.stat(globalStorageUri);
62 | } catch (error) {
63 | logger.warn(`Folder not found at: ${globalStorageUri}`);
64 | logger.warn(String(error));
65 | vscode.workspace.fs.createDirectory(globalStorageUri);
66 | }
67 |
68 | // Check if the flag URI file exists in storage
69 | try {
70 | await vscode.workspace.fs.stat(flagUri);
71 | logger.debug(`Extension already installed, restoring state`);
72 | } catch (error) {
73 | logger.warn(String(error));
74 | logger.debug("Extension newly installed, clearing state");
75 | await this.clearGlobalState();
76 | await vscode.workspace.fs.writeFile(flagUri, new Uint8Array(0));
77 | }
78 | }
79 |
80 | /**
81 | * Handles changes in authentication sessions.
82 | */
83 | public async handleSessionChange(): Promise {
84 | const session = await vscode.authentication.getSession(
85 | "github",
86 | ["public_repo", "user:email"],
87 | { createIfNone: false },
88 | );
89 | await this.checkNewlyInstalled();
90 | storage.session.set(session);
91 | setContext("isLoggedIn", !!session);
92 | if (session) {
93 | this.handleActiveSession();
94 | } else {
95 | this.handleNoSession();
96 | }
97 | logger.debug("Session change handled successfully");
98 | }
99 |
100 | /**
101 | * Handles the case when there's no active session.
102 | */
103 | private handleNoSession(): void {
104 | this.disposeSessionFeatures();
105 | this.clearGlobalState();
106 | this.showSignInPrompt();
107 | logger.info("No active session, extension deactivated");
108 | }
109 |
110 | /**
111 | * Handles the case when there's an active session.
112 | */
113 | private async handleActiveSession(): Promise {
114 | logger.info("GitHub session established");
115 | if (await storage.get("github.support")) {
116 | this.starGitHubRepository();
117 | } else {
118 | this.showGithubSupportNotification();
119 | }
120 | this.registerSessionFeatures();
121 | await ModelProviderManager.getInstance().updateProviders();
122 | }
123 |
124 | /**
125 | * Clears the global state.
126 | */
127 | private async clearGlobalState(): Promise {
128 | const keys = this.extensionContext.globalState.keys();
129 | for (const key of keys) {
130 | await this.extensionContext.globalState.update(key, undefined);
131 | }
132 | logger.debug("Global state cleared");
133 | }
134 |
135 | /**
136 | * Shows a sign-in prompt to the user.
137 | */
138 | private showSignInPrompt(): void {
139 | vscode.window
140 | .showInformationMessage(
141 | "Please sign in to your GitHub account to start using Flexpilot",
142 | "Sign in to Chat",
143 | )
144 | .then((selection) => {
145 | if (selection === "Sign in to Chat") {
146 | vscode.commands.executeCommand("flexpilot.github.signin");
147 | }
148 | });
149 | }
150 |
151 | /**
152 | * Displays a notification to support the project on GitHub.
153 | */
154 | private showGithubSupportNotification(): void {
155 | vscode.window
156 | .showInformationMessage(
157 | "Support our mission to make AI accessible - give us a GitHub star by just clicking `Yes` button!",
158 | "Yes (recommended)",
159 | "No, I don't like to support",
160 | )
161 | .then(async (support) => {
162 | if (support === "Yes (recommended)") {
163 | storage.set("github.support", true);
164 | this.starGitHubRepository().then(() => this.showSponsorPrompt());
165 | }
166 | });
167 | }
168 |
169 | /**
170 | * Shows a prompt to become a sponsor.
171 | */
172 | private showSponsorPrompt(): void {
173 | vscode.window
174 | .showInformationMessage(
175 | "Thanks for helping us make AI open and accessible to everyone!",
176 | "Become a Sponsor",
177 | )
178 | .then(async (sponsor) => {
179 | if (sponsor === "Become a Sponsor") {
180 | vscode.env.openExternal(vscode.Uri.parse(packageJson.repository.url));
181 | }
182 | });
183 | }
184 |
185 | /**
186 | * Stars the GitHub repository to support the project.
187 | */
188 | private async starGitHubRepository(): Promise {
189 | try {
190 | const githubSession = storage.session.get();
191 | if (!githubSession) {
192 | return;
193 | }
194 | await axios.put(
195 | "https://api.github.com/user/starred/flexpilot-ai/vscode-extension",
196 | null,
197 | {
198 | headers: {
199 | Accept: "application/vnd.github+json",
200 | "X-GitHub-Api-Version": "2022-11-28",
201 | Authorization: `Bearer ${githubSession.accessToken}`,
202 | },
203 | },
204 | );
205 | } catch (error) {
206 | logger.warn(`Unable to star the GitHub repository: ${error}`);
207 | }
208 | }
209 |
210 | /**
211 | * Disposes of the current session features.
212 | */
213 | private disposeSessionFeatures(): void {
214 | PanelChatParticipant.dispose();
215 | InlineCompletionProvider.dispose();
216 | InlineChatParticipant.dispose();
217 | logger.debug("Session features disposed");
218 | }
219 |
220 | /**
221 | * Registers the features for the current session.
222 | */
223 | private registerSessionFeatures(): void {
224 | try {
225 | PanelChatParticipant.register();
226 | InlineCompletionProvider.register();
227 | InlineChatParticipant.register();
228 | logger.info("Session features registered");
229 | } catch (error) {
230 | logger.error(error as Error);
231 | logger.notifyError(`Failed to register session features: ${error}`);
232 | }
233 | }
234 | }
235 |
--------------------------------------------------------------------------------
/src/startup.ts:
--------------------------------------------------------------------------------
1 | import {
2 | CommentJSONValue,
3 | parse,
4 | stringify,
5 | type CommentObject,
6 | } from "comment-json";
7 | import * as path from "path";
8 | import * as vscode from "vscode";
9 | import { IPackageJson } from "./interfaces";
10 | import { logger } from "./logger";
11 | import { storage } from "./storage";
12 | import { isFileExists } from "./utilities";
13 |
14 | /**
15 | * Show notification to restart VS Code to apply changes
16 | */
17 | const triggerVscodeRestart = async () => {
18 | // Get the current value of the titleBarStyle setting
19 | const existingValue = vscode.workspace
20 | .getConfiguration("window")
21 | .get("titleBarStyle");
22 |
23 | // Toggle the value of the titleBarStyle setting
24 | await vscode.workspace
25 | .getConfiguration("window")
26 | .update(
27 | "titleBarStyle",
28 | existingValue === "native" ? "custom" : "native",
29 | vscode.ConfigurationTarget.Global,
30 | );
31 |
32 | // Sleep for few milliseconds
33 | await new Promise((resolve) => setTimeout(resolve, 200));
34 |
35 | // Toggle the value back to the original value
36 | await vscode.workspace
37 | .getConfiguration("window")
38 | .update(
39 | "titleBarStyle",
40 | existingValue === "native" ? "native" : "custom",
41 | vscode.ConfigurationTarget.Global,
42 | );
43 | };
44 |
45 | /**
46 | * Checks if the proposed API is disabled in the current environment.
47 | */
48 | const isProposedApiDisabled = async () => {
49 | try {
50 | await vscode.lm.fileIsIgnored(vscode.Uri.file("/"), {
51 | isCancellationRequested: false,
52 | onCancellationRequested: () => new vscode.EventEmitter(),
53 | });
54 | return false;
55 | } catch (error) {
56 | logger.error(error as Error);
57 | logger.error("Proposed API disabled for Flexpilot");
58 | return true;
59 | }
60 | };
61 |
62 | /**
63 | * Checks if GitHub Copilot is active in the current environment.
64 | */
65 | const isGitHubCopilotActive = () => {
66 | // Get the extension by its identifier
67 | const extension = vscode.extensions.getExtension("GitHub.copilot");
68 |
69 | // Check if the extension is installed
70 | if (extension) {
71 | logger.info("GitHub Copilot is installed");
72 | return true;
73 | } else {
74 | logger.info("GitHub Copilot is not installed.");
75 | return false;
76 | }
77 | };
78 |
79 | /**
80 | * Checks if the package.json file is outdated and updates it.
81 | */
82 | const isPackageJsonOutdated = async () => {
83 | // Get the path of the package.json file
84 | const packageJsonUri = vscode.Uri.joinPath(
85 | storage.getContext().extensionUri,
86 | "package.json",
87 | );
88 | logger.debug(`Package JSON Path: ${packageJsonUri}`);
89 |
90 | // Get the loaded package.json content
91 | const loadedPackageJson = storage.getContext().extension.packageJSON;
92 |
93 | // Check if the package.json file is outdated
94 | let isPackageJsonOutdated = false;
95 |
96 | // Parse the package.json content
97 | const packageJsonBuffer = await vscode.workspace.fs.readFile(packageJsonUri);
98 | const packageJson: IPackageJson = JSON.parse(
99 | Buffer.from(packageJsonBuffer).toString("utf8"),
100 | );
101 |
102 | if (loadedPackageJson.contributes.menus["scm/inputBox"] === undefined) {
103 | // Add the "scm/inputBox" menu to the "contributes" section
104 | packageJson.contributes.menus["scm/inputBox"] = [
105 | {
106 | when: "scmProvider == git",
107 | command: "flexpilot.git.generateCommitMessage",
108 | },
109 | ];
110 |
111 | // Set flag to update the package.json file
112 | isPackageJsonOutdated = true;
113 | logger.info("Successfully updated package with 'scm/inputBox'");
114 | }
115 |
116 | if (loadedPackageJson.enabledApiProposals === undefined) {
117 | // Add the proposed API to the "contributes" section
118 | packageJson.enabledApiProposals = packageJson.enabledApiProposalsOriginal;
119 |
120 | // Set flag to update the package.json file
121 | isPackageJsonOutdated = true;
122 | logger.info("Successfully updated package with 'enabledApiProposals'");
123 | }
124 |
125 | if (loadedPackageJson.contributes.languageModels === undefined) {
126 | // Add the "languageModels" section to the "contributes" section
127 | packageJson.contributes.languageModels = {
128 | vendor: "flexpilot",
129 | };
130 |
131 | // Set flag to update the package.json file
132 | isPackageJsonOutdated = true;
133 | logger.info("Successfully updated package with 'scm/inputBox'");
134 | }
135 |
136 | if (isPackageJsonOutdated) {
137 | // Write the changes to the package.json file
138 | await vscode.workspace.fs.writeFile(
139 | packageJsonUri,
140 | Buffer.from(JSON.stringify(packageJson, null, 2), "utf8"),
141 | );
142 | }
143 |
144 | // Return the flag indicating if the package.json file was updated
145 | return isPackageJsonOutdated;
146 | };
147 |
148 | /**
149 | * Checks if the argv.json file is outdated and updates it.
150 | */
151 | const isArgvJsonOutdated = async () => {
152 | // Get the path of the argv.json file from storage
153 | let argvPath = storage.get("argv.path");
154 | let argvJsonOutdated = false;
155 |
156 | // Check if the argv.json file is outdated and trigger the update
157 | if (argvPath && !isFileExists(vscode.Uri.parse(argvPath))) {
158 | argvPath = undefined;
159 | }
160 |
161 | if (!argvPath) {
162 | // Open runtime arguments configuration
163 | await vscode.commands.executeCommand(
164 | "workbench.action.configureRuntimeArguments",
165 | );
166 |
167 | // Find the argv.json file in visible text editors
168 | const argvDocument = vscode.window.visibleTextEditors
169 | .map((item) => item.document)
170 | .filter((item) => path.basename(item.uri.fsPath) === "argv.json")
171 | .pop();
172 |
173 | // throw an error if the file is not found
174 | if (!argvDocument) {
175 | throw new Error("argv.json file not found in visible editors");
176 | }
177 |
178 | // Set the argv path in storage
179 | argvPath = argvDocument.uri.toString();
180 | await storage.set("argv.path", argvPath);
181 |
182 | // Make the argv file active and close it
183 | await vscode.window.showTextDocument(argvDocument);
184 | await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
185 | }
186 |
187 | // Create the URI for the argv.json file
188 | const argvFileUri = vscode.Uri.parse(argvPath);
189 |
190 | // Get the extension ID
191 | const extensionId = storage.getContext().extension.id;
192 | logger.debug(`Extension ID: ${extensionId}`);
193 |
194 | // Parse the argv.json content
195 | const buffer = await vscode.workspace.fs.readFile(argvFileUri);
196 | const argvJson = parse(Buffer.from(buffer).toString("utf8")) as CommentObject;
197 |
198 | // Add the extension ID to the "enable-proposed-api" array
199 | if (Array.isArray(argvJson["enable-proposed-api"])) {
200 | if (!argvJson["enable-proposed-api"].includes(extensionId)) {
201 | argvJsonOutdated = true;
202 | argvJson["enable-proposed-api"].push(extensionId);
203 | logger.debug(`Added ${extensionId} to existing array`);
204 | } else {
205 | logger.debug(`${extensionId} already in array`);
206 | }
207 | } else if (typeof argvJson["enable-proposed-api"] === "string") {
208 | argvJsonOutdated = true;
209 | argvJson["enable-proposed-api"] = [
210 | argvJson["enable-proposed-api"],
211 | extensionId,
212 | ] as CommentJSONValue;
213 | logger.debug(`Created new array with ${extensionId}`);
214 | } else {
215 | argvJsonOutdated = true;
216 | argvJson["enable-proposed-api"] = [extensionId] as CommentJSONValue;
217 | logger.debug(`Created new array with ${extensionId}`);
218 | }
219 |
220 | // Add the extension ID to the "log-level" array
221 | const logLevel = `${extensionId}=debug`;
222 | if (Array.isArray(argvJson["log-level"])) {
223 | if (!argvJson["log-level"].includes(logLevel)) {
224 | argvJsonOutdated = true;
225 | argvJson["log-level"].push(logLevel);
226 | logger.debug(`Added ${logLevel} to existing array`);
227 | } else {
228 | logger.debug(`${logLevel} already in array`);
229 | }
230 | } else if (typeof argvJson["log-level"] === "string") {
231 | argvJsonOutdated = true;
232 | argvJson["log-level"] = [
233 | argvJson["log-level"],
234 | logLevel,
235 | ] as CommentJSONValue;
236 | logger.debug(`Created new array with ${logLevel}`);
237 | } else {
238 | argvJsonOutdated = true;
239 | argvJson["log-level"] = [logLevel] as CommentJSONValue;
240 | logger.debug(`Created new array with ${logLevel}`);
241 | }
242 |
243 | // If the argv.json file was updated, write the changes
244 | if (argvJsonOutdated) {
245 | await vscode.workspace.fs.writeFile(
246 | argvFileUri,
247 | Buffer.from(stringify(argvJson, null, 4), "utf8"),
248 | );
249 | logger.info("Successfully updated argv.json");
250 | }
251 |
252 | // Return the flag indicating if the argv.json file was updated
253 | return argvJsonOutdated;
254 | };
255 |
256 | /**
257 | * updates the runtime arguments configuration to enable proposed API, log level, etc ...
258 | */
259 | export const updateRuntimeArguments = async () => {
260 | // Initialize the flag to require a restart
261 | let requireRestart = false;
262 | let restartMessage =
263 | "Flexpilot: Please restart VS Code to apply the latest updates";
264 |
265 | // Update `chat.commandCenter.enabled` to always true
266 | vscode.workspace.onDidChangeConfiguration(() => {
267 | vscode.workspace
268 | .getConfiguration("chat.commandCenter")
269 | .update("enabled", true, vscode.ConfigurationTarget.Global);
270 | });
271 |
272 | // Check if the argv.json file is outdated
273 | if (await isArgvJsonOutdated()) {
274 | logger.warn("Updated runtime arguments, restart required");
275 | requireRestart = true;
276 | }
277 |
278 | // Check if the package.json file is outdated
279 | if (await isPackageJsonOutdated()) {
280 | logger.warn("Updated package.json, restart required");
281 | requireRestart = true;
282 | }
283 |
284 | // Check if the proposed API is disabled
285 | if (await isProposedApiDisabled()) {
286 | logger.warn("Proposed API is disabled, restart required");
287 | requireRestart = true;
288 | }
289 |
290 | // Check if GitHub Copilot is active
291 | if (isGitHubCopilotActive()) {
292 | logger.warn("GitHub Copilot is active, restart required");
293 | restartMessage =
294 | "Flexpilot: To ensure Flexpilot functions correctly, kindly disable `GitHub Copilot` and Restart";
295 | }
296 |
297 | // Notify the user about the required restart
298 | if (requireRestart) {
299 | // Show a notification to restart VS Code
300 | vscode.window
301 | .showInformationMessage(restartMessage, "Restart", "View Logs")
302 | .then((selection) => {
303 | if (selection === "Restart") {
304 | triggerVscodeRestart();
305 | } else if (selection === "View Logs") {
306 | logger.showOutputChannel();
307 | }
308 | });
309 |
310 | // Throw an error to stop the execution
311 | throw new Error("Flexpilot: VS Code restart required");
312 | }
313 |
314 | // Log the successful activation
315 | logger.info("Successfully updated runtime arguments");
316 | };
317 |
--------------------------------------------------------------------------------
/src/status-icon.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import { events } from "./events";
3 | import { logger } from "./logger";
4 | import { ModelProviderManager } from "./providers";
5 | import { storage } from "./storage";
6 |
7 | /**
8 | * Status icon manager to handle the status icon and state.
9 | * Created as a singleton to ensure a single instance across the application.
10 | */
11 | class StatusIconManager {
12 | private static instance: StatusIconManager;
13 | private readonly statusBarItem: vscode.StatusBarItem;
14 | public state: "enabled" | "disabled" = "enabled";
15 |
16 | private constructor(extensionContext = storage.getContext()) {
17 | // Create the status bar item
18 | logger.info("StatusIconManager instance created");
19 | this.statusBarItem = vscode.window.createStatusBarItem(
20 | vscode.StatusBarAlignment.Right,
21 | );
22 |
23 | extensionContext.subscriptions.push(this.statusBarItem);
24 |
25 | // Update the status bar icon when the inline completion provider is updated
26 | extensionContext.subscriptions.push(
27 | events.onFire((event) => {
28 | if (event.name === "inlineCompletionProviderUpdated") {
29 | this.updateStatusBarIcon();
30 | }
31 | }),
32 | );
33 |
34 | // Initialize the status bar item
35 | this.initializeStatusBar();
36 | this.updateStatusBarIcon();
37 |
38 | // Update the status bar icon when the active text editor changes
39 | vscode.window.onDidChangeActiveTextEditor(() => this.updateStatusBarIcon());
40 | }
41 |
42 | /**
43 | * Get the singleton instance of StatusIconManager.
44 | * @returns {StatusIconManager} The singleton instance.
45 | */
46 | public static getInstance(): StatusIconManager {
47 | if (!StatusIconManager.instance) {
48 | // Create a new instance if not already created
49 | StatusIconManager.instance = new StatusIconManager();
50 | logger.debug("New StatusIconManager instance created");
51 | }
52 | return StatusIconManager.instance;
53 | }
54 |
55 | /**
56 | * Initialize the status bar item with default properties.
57 | */
58 | private initializeStatusBar(): void {
59 | logger.debug("Initializing status bar");
60 | this.statusBarItem.accessibilityInformation = {
61 | label: "Flexpilot Status",
62 | };
63 | this.statusBarItem.tooltip = "Flexpilot Status";
64 | this.statusBarItem.name = "Flexpilot Status";
65 | this.statusBarItem.command = "flexpilot.status.icon.menu";
66 | this.statusBarItem.show();
67 | logger.debug("Status bar initialized");
68 | }
69 |
70 | /**
71 | * Update the status bar icon based on the current state.
72 | */
73 | private updateStatusBarIcon(): void {
74 | let isCompletionsEnabled = true;
75 |
76 | // Check if the completions are enabled
77 | logger.debug("Updating status bar icon");
78 | const editor = vscode.window.activeTextEditor;
79 | if (!editor) {
80 | logger.debug("No active editor, setting status to disabled");
81 | isCompletionsEnabled = false;
82 | }
83 |
84 | // Check if the inline completion provider is available
85 | const provider =
86 | ModelProviderManager.getInstance().getProvider("Inline Completion");
87 | if (!provider) {
88 | logger.debug("No provider found, setting status to disabled");
89 | isCompletionsEnabled = false;
90 | }
91 |
92 | // Check if the language is disabled
93 | const config = storage.get("completions.disabled.languages") || [];
94 | if (editor && config.includes(editor.document.languageId)) {
95 | logger.debug("Language disabled, setting status to disabled");
96 | isCompletionsEnabled = false;
97 | }
98 | logger.debug("Setting status to enabled");
99 |
100 | // Update the status bar icon
101 | if (isCompletionsEnabled) {
102 | this.state = "enabled";
103 | this.statusBarItem.text = "$(flexpilot-default)";
104 | } else {
105 | this.state = "disabled";
106 | this.statusBarItem.text = "$(flexpilot-disabled)";
107 | }
108 | }
109 |
110 | /**
111 | * Reset the status bar item to default state.
112 | */
113 | public reset(): void {
114 | logger.debug("Resetting status bar");
115 | if (this.state === "disabled") {
116 | this.statusBarItem.text = "$(flexpilot-disabled)";
117 | } else {
118 | this.statusBarItem.text = "$(flexpilot-default)";
119 | }
120 | }
121 |
122 | /**
123 | * Set the status bar item to loading state.
124 | */
125 | public setLoading(): void {
126 | logger.debug("Setting status bar to loading");
127 | this.statusBarItem.text = "$(loading~spin)";
128 | }
129 | }
130 |
131 | // Export the StatusIconManager instance
132 | export const statusIcon = StatusIconManager.getInstance();
133 |
--------------------------------------------------------------------------------
/src/storage.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import packageJson from "../package.json";
3 | import { ILocationName, IModelConfig, IUsagePreference } from "./interfaces";
4 | import { logger } from "./logger";
5 |
6 | /**
7 | * IKeyValueStore interface to define the structure of permanent key-value store.
8 | */
9 | interface IKeyValueStore {
10 | "github.support": boolean;
11 | "completions.disabled.languages": string[];
12 | "argv.path": string;
13 | }
14 |
15 | /**
16 | * IWorkspaceConfigKeys type to define the keys of workspace configuration.
17 | */
18 | type IWorkspaceConfigKeys =
19 | keyof (typeof packageJson)["contributes"]["configuration"]["properties"];
20 |
21 | /**
22 | * StorageManager class provides a centralized state management mechanism for the extension.
23 | * It implements the Singleton pattern to ensure a single instance of the state across the application.
24 | */
25 | class StorageManager {
26 | private githubSession: vscode.AuthenticationSession | undefined;
27 | private context: vscode.ExtensionContext | undefined;
28 |
29 | /**
30 | * Creates a new instance of StorageManager.
31 | * @param {vscode.ExtensionContext} extensionContext - The extension context provided by VS Code
32 | */
33 | constructor() {
34 | logger.info("StorageManager instance created");
35 | }
36 |
37 | /**
38 | * Sets the extension context for the storage manager.
39 | * @param {vscode.ExtensionContext} extensionContext - The extension context provided by VS Code
40 | */
41 | public setContext(extensionContext: vscode.ExtensionContext) {
42 | this.context = extensionContext;
43 | }
44 |
45 | /**
46 | * Retrieves the extension context
47 | * @returns {vscode.ExtensionContext} The extension context provided by VS Code or undefined
48 | */
49 | public getContext(): vscode.ExtensionContext {
50 | if (!this.context) {
51 | throw new Error("Storage manager not initialized");
52 | }
53 | return this.context;
54 | }
55 |
56 | /**
57 | * Retrieves a value from permanent storage.
58 | */
59 | public get = (
60 | key: T1,
61 | ): IKeyValueStore[T1] | undefined => {
62 | if (!this.context) {
63 | throw new Error("Storage manager not initialized");
64 | }
65 | logger.debug(`Getting global state for key: ${key}`);
66 | return this.context.globalState.get(key);
67 | };
68 |
69 | /**
70 | * Sets a value in permanent storage.
71 | */
72 | public set = async (
73 | key: T1,
74 | value: IKeyValueStore[T1] | undefined,
75 | ): Promise => {
76 | if (!this.context) {
77 | throw new Error("Storage manager not initialized");
78 | }
79 | logger.debug(`Setting global state for key: ${key}`);
80 | return this.context.globalState.update(key, value);
81 | };
82 |
83 | public session = {
84 | /**
85 | * Retrieves the GitHub session from the storage.
86 | */
87 | get: (): vscode.AuthenticationSession => {
88 | if (!this.githubSession) {
89 | throw new Error("GitHub session not found");
90 | }
91 | return this.githubSession;
92 | },
93 |
94 | /**
95 | * Sets the GitHub session.
96 | */
97 | set: (session: vscode.AuthenticationSession | undefined) => {
98 | this.githubSession = session;
99 | },
100 | };
101 |
102 | public models = {
103 | /**
104 | * Retrieves a value from model providers.
105 | */
106 | get: (key: string): T | undefined => {
107 | if (!this.context) {
108 | throw new Error("Storage manager not initialized");
109 | }
110 | const storageKey = `model.providers.${key}`;
111 | logger.debug(`Getting model config for key: ${storageKey}`);
112 | return this.context.globalState.get(storageKey);
113 | },
114 |
115 | /**
116 | * Sets a value in model providers.
117 | */
118 | set: async (key: string, value?: T) => {
119 | if (!this.context) {
120 | throw new Error("Storage manager not initialized");
121 | }
122 | const storageKey = `model.providers.${key}`;
123 | logger.debug(`Setting model config for key: ${storageKey}`);
124 | return this.context.globalState.update(storageKey, value);
125 | },
126 |
127 | /**
128 | * Lists all the model providers.
129 | */
130 | list: (): string[] => {
131 | if (!this.context) {
132 | throw new Error("Storage manager not initialized");
133 | }
134 | logger.debug(`Listing global state for key: model.providers`);
135 | return this.context.globalState
136 | .keys()
137 | .filter((item) => item.startsWith("model.providers."))
138 | .map((item) => item.replace("model.providers.", ""));
139 | },
140 | };
141 |
142 | public usage = {
143 | /**
144 | * Retrieves a value from usage preferences.
145 | */
146 | get: (key: ILocationName): IUsagePreference | undefined => {
147 | if (!this.context) {
148 | throw new Error("Storage manager not initialized");
149 | }
150 | const storageKey = `usage.preferences.${key}`;
151 | logger.debug(`Getting usage preference for key: ${storageKey}`);
152 | return this.context.globalState.get(storageKey);
153 | },
154 |
155 | /**
156 | * Sets a value in usage preferences.
157 | */
158 | set: async (
159 | key: ILocationName,
160 | value: T | undefined,
161 | ) => {
162 | if (!this.context) {
163 | throw new Error("Storage manager not initialized");
164 | }
165 | const storageKey = `usage.preferences.${key}`;
166 | logger.debug(`Setting usage preference for key: ${storageKey}`);
167 | return this.context.globalState.update(storageKey, value);
168 | },
169 | };
170 |
171 | public workspace = {
172 | /**
173 | * Retrieves a value from workspace configuration.
174 | */
175 | get: (key: IWorkspaceConfigKeys): T => {
176 | logger.debug(`Getting workspace config for key: flexpilot.${key}`);
177 | return vscode.workspace.getConfiguration().get(key) as T;
178 | },
179 |
180 | /**
181 | * Sets a value in workspace configuration.
182 | */
183 | set: async (key: IWorkspaceConfigKeys, value: T): Promise => {
184 | logger.debug(`Setting workspace config for key: flexpilot.${key}`);
185 | return vscode.workspace
186 | .getConfiguration()
187 | .update(key, value, vscode.ConfigurationTarget.Global);
188 | },
189 | };
190 | }
191 |
192 | // Export the storage manager instance
193 | export const storage = new StorageManager();
194 |
--------------------------------------------------------------------------------
/src/tokenizers.ts:
--------------------------------------------------------------------------------
1 | import { Tokenizer } from "@flexpilot-ai/tokenizers";
2 | import assert from "assert";
3 | import axios from "axios";
4 | import { createHash } from "crypto";
5 | import * as vscode from "vscode";
6 | import { logger } from "./logger";
7 | import { storage } from "./storage";
8 | import { getCompletionModelMetadata } from "./utilities";
9 |
10 | export class Tokenizers {
11 | /**
12 | * Get the tokenizer metadata for the given model.
13 | * @param {string} model - The name of the model.
14 | */
15 | private static async metadata(model: string) {
16 | // Get the configuration for the model
17 | const metadata = getCompletionModelMetadata(model);
18 |
19 | // Check if the model configuration exists
20 | if (!metadata) {
21 | throw new Error("No tokenizer URL found for model");
22 | }
23 |
24 | // Prepare the tokenizer file paths
25 | const globalStorageUri = storage.getContext().globalStorageUri;
26 | const fileId = createHash("sha512")
27 | .update(metadata.tokenizerUrl)
28 | .digest("hex");
29 | const tokenizerFolder = vscode.Uri.joinPath(globalStorageUri, "tokenizers");
30 | const tokenizerFileUri = vscode.Uri.joinPath(tokenizerFolder, fileId);
31 |
32 | // Check if the tokenizer folder exists in storage
33 | try {
34 | await vscode.workspace.fs.stat(tokenizerFolder);
35 | } catch (error) {
36 | logger.warn(`Folder not found at: ${tokenizerFolder}`);
37 | logger.error(error as Error);
38 | vscode.workspace.fs.createDirectory(tokenizerFolder);
39 | }
40 |
41 | // Return the metadata and the path to the tokenizer file
42 | return { metadata, tokenizerFileUri };
43 | }
44 |
45 | /**
46 | * Get the tokenizer for the given model.
47 | * @param {string} model - The name of the model.
48 | */
49 | public static async get(model: string): Promise {
50 | const { tokenizerFileUri } = await this.metadata(model);
51 | logger.debug(`Loading tokenizer from: ${tokenizerFileUri}`);
52 | return new Tokenizer(
53 | Array.from(await vscode.workspace.fs.readFile(tokenizerFileUri)),
54 | );
55 | }
56 |
57 | /**
58 | * Download the tokenizer for the given model.
59 | * @param {string} model - The name of the model.
60 | * @returns {Promise} The tokenizer object.
61 | */
62 | public static async download(model: string): Promise {
63 | const { metadata, tokenizerFileUri } = await this.metadata(model);
64 | const response = await vscode.window.withProgress(
65 | {
66 | location: vscode.ProgressLocation.Notification,
67 | title: "Flexpilot",
68 | cancellable: false,
69 | },
70 | async (progress) => {
71 | progress.report({
72 | message: "Downloading tokenizer.json",
73 | });
74 | return await axios.get(metadata.tokenizerUrl, {
75 | responseType: "arraybuffer",
76 | });
77 | },
78 | );
79 | const byteArray = Array.from(new Uint8Array(response.data));
80 | const tokenizer = new Tokenizer(byteArray);
81 | assert(tokenizer.encode("test string", false).length > 0);
82 | await vscode.workspace.fs.writeFile(
83 | tokenizerFileUri,
84 | new Uint8Array(response.data),
85 | );
86 | return tokenizer;
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/utilities.ts:
--------------------------------------------------------------------------------
1 | import { basename } from "path";
2 | import * as vscode from "vscode";
3 | import { ALLOWED_COMPLETION_MODELS } from "./constants";
4 | import { ILanguageConfig } from "./interfaces";
5 | import { logger } from "./logger";
6 |
7 | /**
8 | * Set the context value for a given key in the extension context
9 | * @param {string} key - The context key
10 | * @param {any} value - The context value
11 | * @returns {Promise} The promise
12 | */
13 | export const setContext = async (key: string, value: boolean) => {
14 | await vscode.commands.executeCommand("setContext", `flexpilot:${key}`, value);
15 | logger.debug(`Set context: ${key} = ${value}`);
16 | };
17 |
18 | /**
19 | * Get the completion model metadata for a given model
20 | * @param {string} model - The model name
21 | * @returns {Promise<(typeof ALLOWED_COMPLETION_MODELS)[number] | undefined>} The completion model metadata
22 | */
23 | export const getCompletionModelMetadata = (
24 | model: string,
25 | ): (typeof ALLOWED_COMPLETION_MODELS)[number] | undefined => {
26 | logger.debug("Searching for completion models");
27 | return ALLOWED_COMPLETION_MODELS.find((metadata) =>
28 | new RegExp(metadata.regex).test(model),
29 | );
30 | };
31 |
32 | /**
33 | * Check if a file exists and return a boolean
34 | * @param {string} fileUri - The URI of the file
35 | */
36 | export const isFileExists = async (fileUri: vscode.Uri): Promise => {
37 | try {
38 | return !!(await vscode.workspace.fs.stat(fileUri));
39 | } catch (error) {
40 | logger.warn(String(error));
41 | logger.warn(`checkFileExists: ${fileUri} File not found`);
42 | }
43 | return false;
44 | };
45 |
46 | /**
47 | * Get the terminal type from the terminal object
48 | * @param {vscode.Terminal} terminal - The terminal object
49 | * @returns {string} The type of terminal
50 | */
51 | export const getTerminalType = (terminal: vscode.Terminal): string => {
52 | logger.debug("Getting terminal type");
53 | if (
54 | terminal &&
55 | "shellPath" in terminal.creationOptions &&
56 | terminal.creationOptions.shellPath
57 | ) {
58 | const shellName = basename(terminal.creationOptions.shellPath);
59 | switch (true) {
60 | case shellName === "bash.exe":
61 | logger.debug("Terminal type: Git Bash");
62 | return "Git Bash";
63 | case shellName.startsWith("pwsh"):
64 | case shellName.startsWith("powershell"):
65 | logger.debug("Terminal type: powershell");
66 | return "powershell";
67 | case Boolean(shellName.trim()):
68 | logger.debug(`Terminal type: ${shellName.split(".")[0]}`);
69 | return shellName.split(".")[0];
70 | }
71 | }
72 | const defaultType = process.platform === "win32" ? "powershell" : "bash";
73 | logger.debug(`Returning terminal type: ${defaultType}`);
74 | return defaultType;
75 | };
76 |
77 | /**
78 | * Get the end of line sequence for a document
79 | * @param {vscode.TextDocument} document - The document
80 | * @returns {string} The end of line sequence
81 | */
82 | export const getEol = (document: vscode.TextDocument): string => {
83 | logger.debug("Getting end of line sequence for document");
84 | return document.eol === vscode.EndOfLine.CRLF ? "\r\n" : "\n";
85 | };
86 |
87 | /**
88 | * Retrieves the language configuration for a given language ID.
89 | * @param {string} languageId - The ID of the language.
90 | * @returns {ILanguageConfig} The configuration for the specified language.
91 | */
92 | export const getLanguageConfig = (languageId: string): ILanguageConfig => {
93 | if (LANGUAGES[languageId]) {
94 | return LANGUAGES[languageId];
95 | } else {
96 | return { markdown: languageId, comment: { start: "//", end: "" } };
97 | }
98 | };
99 |
100 | /**
101 | * A mapping of language IDs to their respective configurations.
102 | */
103 | const LANGUAGES: { [key: string]: ILanguageConfig } = {
104 | abap: {
105 | markdown: "abap",
106 | comment: { start: "* ", end: " */" },
107 | },
108 | bibtex: {
109 | markdown: "bibtex",
110 | comment: { start: "% ", end: "" },
111 | },
112 | d: {
113 | markdown: "d",
114 | comment: { start: "/* ", end: " */" },
115 | },
116 | pascal: {
117 | markdown: "pascal",
118 | comment: { start: "{ ", end: " }" },
119 | },
120 | erlang: {
121 | markdown: "erlang",
122 | comment: { start: "%% ", end: " %%" },
123 | },
124 | haml: {
125 | markdown: "haml",
126 | comment: { start: "-# ", end: " -#" },
127 | },
128 | haskell: {
129 | markdown: "haskell",
130 | comment: { start: "{- ", end: " -}" },
131 | },
132 | ocaml: {
133 | markdown: "ocaml",
134 | comment: { start: "(* ", end: " *)" },
135 | },
136 | perl6: {
137 | markdown: "perl6",
138 | comment: { start: "/* ", end: " */" },
139 | },
140 | sass: {
141 | markdown: "scss",
142 | comment: { start: "/* ", end: " */" },
143 | },
144 | slim: {
145 | markdown: "slim",
146 | comment: { start: "/ ", end: "" },
147 | },
148 | stylus: {
149 | markdown: "stylus",
150 | comment: { start: "// ", end: "" },
151 | },
152 | svelte: {
153 | markdown: "svelte",
154 | comment: { start: "/* ", end: " */" },
155 | },
156 | vue: {
157 | markdown: "vue",
158 | comment: { start: "/* ", end: " */" },
159 | },
160 | "vue-html": {
161 | markdown: "html",
162 | comment: { start: "" },
163 | },
164 | razor: {
165 | markdown: "razor",
166 | comment: { start: "" },
167 | },
168 | shaderlab: {
169 | markdown: "shader",
170 | comment: { start: "/* ", end: " */" },
171 | },
172 | dockerfile: {
173 | markdown: "dockerfile",
174 | comment: { start: "# ", end: "" },
175 | },
176 | go: {
177 | markdown: "go",
178 | comment: { start: "/* ", end: " */" },
179 | },
180 | python: {
181 | markdown: "py",
182 | comment: { start: '""" ', end: ' """' },
183 | },
184 | css: {
185 | markdown: "css",
186 | comment: { start: "/* ", end: " */" },
187 | },
188 | clojure: {
189 | markdown: "clj",
190 | comment: { start: ";; ", end: "" },
191 | },
192 | less: {
193 | markdown: "less",
194 | comment: { start: "/* ", end: " */" },
195 | },
196 | dart: {
197 | markdown: "dart",
198 | comment: { start: "/* ", end: " */" },
199 | },
200 | tex: {
201 | markdown: "tex",
202 | comment: { start: "% ", end: "" },
203 | },
204 | latex: {
205 | markdown: "latex",
206 | comment: { start: "% ", end: "" },
207 | },
208 | scss: {
209 | markdown: "scss",
210 | comment: { start: "/* ", end: " */" },
211 | },
212 | perl: {
213 | markdown: "pl",
214 | comment: { start: "# ", end: "" },
215 | },
216 | raku: {
217 | markdown: "raku",
218 | comment: { start: "# ", end: "" },
219 | },
220 | rust: {
221 | markdown: "rs",
222 | comment: { start: "/* ", end: " */" },
223 | },
224 | jade: {
225 | markdown: "pug",
226 | comment: { start: "//- ", end: "" },
227 | },
228 | fsharp: {
229 | markdown: "fs",
230 | comment: { start: "(* ", end: " *)" },
231 | },
232 | r: {
233 | markdown: "r",
234 | comment: { start: "# ", end: "" },
235 | },
236 | java: {
237 | markdown: "java",
238 | comment: { start: "/* ", end: " */" },
239 | },
240 | diff: {
241 | markdown: "diff",
242 | comment: { start: "# ", end: " " },
243 | },
244 | html: {
245 | markdown: "html",
246 | comment: { start: "" },
247 | },
248 | php: {
249 | markdown: "php",
250 | comment: { start: "/* ", end: " */" },
251 | },
252 | lua: {
253 | markdown: "lua",
254 | comment: { start: "--[[ ", end: " ]]" },
255 | },
256 | xml: {
257 | markdown: "xml",
258 | comment: { start: "" },
259 | },
260 | xsl: {
261 | markdown: "xsl",
262 | comment: { start: "" },
263 | },
264 | vb: {
265 | markdown: "vb",
266 | comment: { start: "' ", end: "" },
267 | },
268 | powershell: {
269 | markdown: "ps1",
270 | comment: { start: "<# ", end: " #>" },
271 | },
272 | typescript: {
273 | markdown: "ts",
274 | comment: { start: "/* ", end: " */" },
275 | },
276 | typescriptreact: {
277 | markdown: "tsx",
278 | comment: { start: "/* ", end: " */" },
279 | },
280 | ini: {
281 | markdown: "ini",
282 | comment: { start: "; ", end: " " },
283 | },
284 | properties: {
285 | markdown: "conf",
286 | comment: { start: "# ", end: " " },
287 | },
288 | json: {
289 | markdown: "json",
290 | comment: { start: "/* ", end: " */" },
291 | },
292 | jsonc: {
293 | markdown: "jsonc",
294 | comment: { start: "/* ", end: " */" },
295 | },
296 | jsonl: {
297 | markdown: "jsonl",
298 | comment: { start: "/* ", end: " */" },
299 | },
300 | snippets: {
301 | markdown: "code-snippets",
302 | comment: { start: "/* ", end: " */" },
303 | },
304 | "git-commit": {
305 | markdown: "git-commit",
306 | comment: { start: "# ", end: " " },
307 | },
308 | "git-rebase": {
309 | markdown: "git-rebase",
310 | comment: { start: "# ", end: " " },
311 | },
312 | ignore: {
313 | markdown: "gitignore_global",
314 | comment: { start: "# ", end: "" },
315 | },
316 | handlebars: {
317 | markdown: "handlebars",
318 | comment: { start: "{{!-- ", end: " --}}" },
319 | },
320 | c: {
321 | markdown: "c",
322 | comment: { start: "/* ", end: " */" },
323 | },
324 | cpp: {
325 | markdown: "cpp",
326 | comment: { start: "/* ", end: " */" },
327 | },
328 | "cuda-cpp": {
329 | markdown: "cpp",
330 | comment: { start: "/* ", end: " */" },
331 | },
332 | swift: {
333 | markdown: "swift",
334 | comment: { start: "/* ", end: " */" },
335 | },
336 | makefile: {
337 | markdown: "mak",
338 | comment: { start: "# ", end: "" },
339 | },
340 | shellscript: {
341 | markdown: "sh",
342 | comment: { start: "# ", end: "" },
343 | },
344 | markdown: {
345 | markdown: "md",
346 | comment: { start: "" },
347 | },
348 | dockercompose: {
349 | markdown: "dockercompose",
350 | comment: { start: "# ", end: "" },
351 | },
352 | yaml: {
353 | markdown: "yaml",
354 | comment: { start: "# ", end: "" },
355 | },
356 | csharp: {
357 | markdown: "cs",
358 | comment: { start: "/* ", end: " */" },
359 | },
360 | julia: {
361 | markdown: "jl",
362 | comment: { start: "#= ", end: " =#" },
363 | },
364 | bat: {
365 | markdown: "bat",
366 | comment: { start: "@REM ", end: "" },
367 | },
368 | groovy: {
369 | markdown: "groovy",
370 | comment: { start: "/* ", end: " */" },
371 | },
372 | coffeescript: {
373 | markdown: "coffee",
374 | comment: { start: "### ", end: " ###" },
375 | },
376 | javascriptreact: {
377 | markdown: "jsx",
378 | comment: { start: "/* ", end: " */" },
379 | },
380 | javascript: {
381 | markdown: "js",
382 | comment: { start: "/* ", end: " */" },
383 | },
384 | "jsx-tags": {
385 | markdown: "jsx-tags",
386 | comment: { start: "{/* ", end: " */}" },
387 | },
388 | hlsl: {
389 | markdown: "hlsl",
390 | comment: { start: "/* ", end: " */" },
391 | },
392 | restructuredtext: {
393 | markdown: "rst",
394 | comment: { start: ".. ", end: "" },
395 | },
396 | "objective-c": {
397 | markdown: "m",
398 | comment: { start: "/* ", end: " */" },
399 | },
400 | "objective-cpp": {
401 | markdown: "cpp",
402 | comment: { start: "/* ", end: " */" },
403 | },
404 | ruby: {
405 | markdown: "rb",
406 | comment: { start: "=begin ", end: " =end" },
407 | },
408 | sql: {
409 | markdown: "sql",
410 | comment: { start: "/* ", end: " */" },
411 | },
412 | };
413 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "exclude": ["launch_folder"],
3 | "compilerOptions": {
4 | "resolveJsonModule": true,
5 | "module": "Node16",
6 | "target": "ES2022",
7 | "lib": ["ES2022"],
8 | "sourceMap": true,
9 | "skipLibCheck": true,
10 | "rootDir": "src",
11 | "jsx": "react-jsx",
12 | "strict": true /* enable all strict type-checking options */
13 | /* Additional Checks */
14 | // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
15 | // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
16 | // "noUnusedParameters": true, /* Report errors on unused parameters. */
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/webpack.config.mjs:
--------------------------------------------------------------------------------
1 | "use strict";
2 | import path from "path";
3 |
4 | /** @typedef {import('webpack').Configuration} WebpackConfig **/
5 |
6 | /** @type WebpackConfig */
7 | const extensionConfig = {
8 | target: "node", // VS Code extensions run in a Node.js-context 📖 -> https://webpack.js.org/configuration/node/
9 | mode: "none", // this leaves the source code as close as possible to the original (when packaging we set this to 'production')
10 |
11 | entry: "./src/extension.ts", // the entry point of this extension, 📖 -> https://webpack.js.org/configuration/entry-context/
12 | output: {
13 | // the bundle is stored in the 'out' folder (check package.json), 📖 -> https://webpack.js.org/configuration/output/
14 | path: path.resolve(path.dirname(new URL(import.meta.url).pathname), "out"),
15 | filename: "extension.js",
16 | clean: true,
17 | libraryTarget: "commonjs2",
18 | },
19 | externals: {
20 | vscode: "commonjs vscode", // the vscode-module is created on-the-fly and must be excluded. Add other modules that cannot be webpack'ed, 📖 -> https://webpack.js.org/configuration/externals/
21 | // modules added here also need to be added in the .vscodeignore file
22 | },
23 | resolve: {
24 | // support reading TypeScript and JavaScript files, 📖 -> https://github.com/TypeStrong/ts-loader
25 | extensions: [".ts", ".js", ".json", ".tsx", ".node"],
26 | extensionAlias: {
27 | ".js": [".ts", ".js"],
28 | },
29 | },
30 | module: {
31 | rules: [
32 | {
33 | test: /\.node$/,
34 | use: [
35 | {
36 | loader: "node-loader",
37 | options: { name: "[name].[ext]" },
38 | },
39 | ],
40 | },
41 | {
42 | test: /\.(ts|tsx)$/,
43 | exclude: /node_modules/,
44 | use: [
45 | {
46 | loader: "ts-loader",
47 | },
48 | ],
49 | },
50 | {
51 | test: /\.json$/,
52 | type: "json",
53 | },
54 | ],
55 | },
56 | devtool: "nosources-source-map",
57 | infrastructureLogging: {
58 | level: "log", // enables logging required for problem matchers
59 | },
60 | };
61 | export default [extensionConfig];
62 |
--------------------------------------------------------------------------------
3 |