instruction
stringclasses 1
value | input
stringlengths 67
168
| output
stringlengths 46
67k
|
|---|---|---|
You are a code assistant | Definition of 'tryParseUrl' in file src/common/utils/try_parse_url.ts in project gitlab-lsp | Definition:
export const tryParseUrl = (url: string): URL | undefined => {
try {
return new URL(url);
} catch (e) {
return undefined;
}
};
References:
- src/common/services/git/git_remote_parser.ts:31
- src/common/services/git/git_remote_parser.ts:73 |
You are a code assistant | Definition of 'GitlabChatSlashCommand' in file packages/webview_duo_chat/src/contract.ts in project gitlab-lsp | Definition:
export interface GitlabChatSlashCommand {
name: string;
description: string;
shouldSubmit?: boolean;
}
export interface WebViewInitialStateInterface {
slashCommands: GitlabChatSlashCommand[];
}
export type Messages = CreatePluginMessageMap<{
pluginToWebview: {
notifications: {
newRecord: Record;
updateRecord: Record;
setLoadingState: boolean;
cleanChat: undefined;
};
};
webviewToPlugin: {
notifications: {
onReady: undefined;
cleanChat: undefined;
newPrompt: {
record: {
content: string;
};
};
trackFeedback: {
data?: {
extendedTextFeedback: string | null;
feedbackChoices: Array<string> | null;
};
};
};
};
pluginToExtension: {
notifications: {
showErrorMessage: {
message: string;
};
};
};
}>;
References:
- packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_slash_commands.ts:28
- packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_slash_commands.ts:7
- packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_slash_commands.ts:18
- packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_slash_commands.ts:23
- packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_slash_commands.ts:13 |
You are a code assistant | Definition of 'NotificationHandler' in file packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts in project gitlab-lsp | Definition:
type NotificationHandler = (payload: unknown) => void;
type RequestHandler = (requestId: RequestId, payload: unknown) => void;
type ResponseHandler = (message: ResponseMessage) => void;
export class WebviewInstanceMessageBus<T extends MessageMap = MessageMap>
implements WebviewMessageBus<T>, Disposable
{
#address: WebviewAddress;
#runtimeMessageBus: WebviewRuntimeMessageBus;
#eventSubscriptions = new CompositeDisposable();
#notificationEvents = new SimpleRegistry<NotificationHandler>();
#requestEvents = new SimpleRegistry<RequestHandler>();
#pendingResponseEvents = new SimpleRegistry<ResponseHandler>();
#logger: Logger;
constructor(
webviewAddress: WebviewAddress,
runtimeMessageBus: WebviewRuntimeMessageBus,
logger: Logger,
) {
this.#address = webviewAddress;
this.#runtimeMessageBus = runtimeMessageBus;
this.#logger = withPrefix(
logger,
`[WebviewInstanceMessageBus:${webviewAddress.webviewId}:${webviewAddress.webviewInstanceId}]`,
);
this.#logger.debug('initializing');
const eventFilter = buildWebviewAddressFilter(webviewAddress);
this.#eventSubscriptions.add(
this.#runtimeMessageBus.subscribe(
'webview:notification',
async (message) => {
try {
await this.#notificationEvents.handle(message.type, message.payload);
} catch (error) {
this.#logger.debug(
`Failed to handle webview instance notification: ${message.type}`,
error instanceof Error ? error : undefined,
);
}
},
eventFilter,
),
this.#runtimeMessageBus.subscribe(
'webview:request',
async (message) => {
try {
await this.#requestEvents.handle(message.type, message.requestId, message.payload);
} catch (error) {
this.#logger.error(error as Error);
}
},
eventFilter,
),
this.#runtimeMessageBus.subscribe(
'webview:response',
async (message) => {
try {
await this.#pendingResponseEvents.handle(message.requestId, message);
} catch (error) {
this.#logger.error(error as Error);
}
},
eventFilter,
),
);
this.#logger.debug('initialized');
}
sendNotification(type: Method, payload?: unknown): void {
this.#logger.debug(`Sending notification: ${type}`);
this.#runtimeMessageBus.publish('plugin:notification', {
...this.#address,
type,
payload,
});
}
onNotification(type: Method, handler: Handler): Disposable {
return this.#notificationEvents.register(type, handler);
}
async sendRequest(type: Method, payload?: unknown): Promise<never> {
const requestId = generateRequestId();
this.#logger.debug(`Sending request: ${type}, ID: ${requestId}`);
let timeout: NodeJS.Timeout | undefined;
return new Promise((resolve, reject) => {
const pendingRequestHandle = this.#pendingResponseEvents.register(
requestId,
(message: ResponseMessage) => {
if (message.success) {
resolve(message.payload as PromiseLike<never>);
} else {
reject(new Error(message.reason));
}
clearTimeout(timeout);
pendingRequestHandle.dispose();
},
);
this.#runtimeMessageBus.publish('plugin:request', {
...this.#address,
requestId,
type,
payload,
});
timeout = setTimeout(() => {
pendingRequestHandle.dispose();
this.#logger.debug(`Request with ID: ${requestId} timed out`);
reject(new Error('Request timed out'));
}, 10000);
});
}
onRequest(type: Method, handler: Handler): Disposable {
return this.#requestEvents.register(type, (requestId: RequestId, payload: unknown) => {
try {
const result = handler(payload);
this.#runtimeMessageBus.publish('plugin:response', {
...this.#address,
requestId,
type,
success: true,
payload: result,
});
} catch (error) {
this.#logger.error(`Error handling request of type ${type}:`, error as Error);
this.#runtimeMessageBus.publish('plugin:response', {
...this.#address,
requestId,
type,
success: false,
reason: (error as Error).message,
});
}
});
}
dispose(): void {
this.#eventSubscriptions.dispose();
this.#notificationEvents.dispose();
this.#requestEvents.dispose();
this.#pendingResponseEvents.dispose();
}
}
References: |
You are a code assistant | Definition of 'SupportedLanguagesService' in file src/common/suggestion/supported_languages_service.ts in project gitlab-lsp | Definition:
export const SupportedLanguagesService = createInterfaceId<SupportedLanguagesService>(
'SupportedLanguagesService',
);
@Injectable(SupportedLanguagesService, [ConfigService])
export class DefaultSupportedLanguagesService implements SupportedLanguagesService {
#enabledLanguages: Set<string>;
#supportedLanguages: Set<string>;
#configService: ConfigService;
#eventEmitter = new EventEmitter();
constructor(configService: ConfigService) {
this.#enabledLanguages = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
this.#supportedLanguages = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
this.#configService = configService;
this.#configService.onConfigChange(() => this.#update());
}
#getConfiguredLanguages() {
const languages: SupportedLanguagesUpdateParam = {};
const additionalLanguages = this.#configService.get(
'client.codeCompletion.additionalLanguages',
);
if (Array.isArray(additionalLanguages)) {
languages.allow = additionalLanguages.map(this.#normalizeLanguageIdentifier);
} else {
log.warn(
'Failed to parse user-configured Code Suggestions languages. Code Suggestions will still work for the default languages.',
);
}
const disabledSupportedLanguages = this.#configService.get(
'client.codeCompletion.disabledSupportedLanguages',
);
if (Array.isArray(disabledSupportedLanguages)) {
languages.deny = disabledSupportedLanguages;
} else {
log.warn(
'Invalid configuration for disabled Code Suggestions languages. All default languages remain enabled.',
);
}
return languages;
}
#update() {
const { allow = [], deny = [] } = this.#getConfiguredLanguages();
const newSet: Set<string> = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
for (const language of allow) {
newSet.add(language.trim());
}
for (const language of deny) {
newSet.delete(language);
}
if (newSet.size === 0) {
log.warn('All languages have been disabled for Code Suggestions.');
}
const previousEnabledLanguages = this.#enabledLanguages;
this.#enabledLanguages = newSet;
if (!isEqual(previousEnabledLanguages, this.#enabledLanguages)) {
this.#triggerChange();
}
}
isLanguageSupported(languageId: string) {
return this.#supportedLanguages.has(languageId);
}
isLanguageEnabled(languageId: string) {
return this.#enabledLanguages.has(languageId);
}
onLanguageChange(listener: () => void): Disposable {
this.#eventEmitter.on('languageChange', listener);
return { dispose: () => this.#eventEmitter.removeListener('configChange', listener) };
}
#triggerChange() {
this.#eventEmitter.emit('languageChange');
}
#normalizeLanguageIdentifier(language: string) {
return language.trim().toLowerCase().replace(/^\./, '');
}
}
References:
- src/common/feature_state/supported_language_check.ts:32
- src/common/advanced_context/advanced_context_service.ts:37
- src/common/advanced_context/advanced_context_service.ts:30
- src/common/feature_state/supported_language_check.ts:24 |
You are a code assistant | Definition of 'processCompletion' in file src/common/suggestion_client/post_processors/post_processor_pipeline.test.ts in project gitlab-lsp | Definition:
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
class Processor2 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return { ...input, completion: `${input.completion} [2]` };
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
pipeline.addProcessor(new Processor1());
pipeline.addProcessor(new Processor2());
const streamInput: StreamingCompletionResponse = { id: '1', completion: 'test', done: false };
const result = await pipeline.run({
documentContext: mockContext,
input: streamInput,
type: 'stream',
});
expect(result).toEqual({ id: '1', completion: 'test [1] [2]', done: false });
});
test('should chain multiple processors correctly for completion input', async () => {
class Processor1 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input.map((option) => ({ ...option, text: `${option.text} [1]` }));
}
}
class Processor2 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input.map((option) => ({ ...option, text: `${option.text} [2]` }));
}
}
pipeline.addProcessor(new Processor1());
pipeline.addProcessor(new Processor2());
const completionInput: SuggestionOption[] = [{ text: 'option1', uniqueTrackingId: '1' }];
const result = await pipeline.run({
documentContext: mockContext,
input: completionInput,
type: 'completion',
});
expect(result).toEqual([{ text: 'option1 [1] [2]', uniqueTrackingId: '1' }]);
});
test('should throw an error for unexpected type', async () => {
class TestProcessor extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
pipeline.addProcessor(new TestProcessor());
const invalidInput = { invalid: 'input' };
await expect(
pipeline.run({
documentContext: mockContext,
input: invalidInput as unknown as StreamingCompletionResponse,
type: 'invalid' as 'stream',
}),
).rejects.toThrow('Unexpected type in pipeline processing');
});
});
References: |
You are a code assistant | Definition of 'dispose' in file packages/lib_disposable/src/composite_disposable.ts in project gitlab-lsp | Definition:
dispose(): void {
for (const disposable of this.#disposables) {
disposable.dispose();
}
this.#disposables.clear();
}
}
References: |
You are a code assistant | Definition of 'AiCompletionResponseInput' in file packages/webview_duo_chat/src/plugin/port/api/graphql/ai_completion_response_channel.ts in project gitlab-lsp | Definition:
type AiCompletionResponseInput = {
htmlResponse?: boolean;
userId: string;
aiAction?: string;
clientSubscriptionId?: string;
};
type AiCompletionResponseParams = {
channel: 'GraphqlChannel';
query: string;
variables: string;
operationName: 'aiCompletionResponse';
};
const AI_MESSAGE_SUBSCRIPTION_QUERY = gql`
subscription aiCompletionResponse(
$userId: UserID
$clientSubscriptionId: String
$aiAction: AiAction
$htmlResponse: Boolean = true
) {
aiCompletionResponse(
userId: $userId
aiAction: $aiAction
clientSubscriptionId: $clientSubscriptionId
) {
id
requestId
content
contentHtml @include(if: $htmlResponse)
errors
role
timestamp
type
chunkId
extras {
sources
}
}
}
`;
export type AiCompletionResponseMessageType = {
requestId: string;
role: string;
content: string;
contentHtml?: string;
timestamp: string;
errors: string[];
extras?: {
sources: object[];
};
chunkId?: number;
type?: string;
};
type AiCompletionResponseResponseType = {
result: {
data: {
aiCompletionResponse: AiCompletionResponseMessageType;
};
};
more: boolean;
};
interface AiCompletionResponseChannelEvents
extends ChannelEvents<AiCompletionResponseResponseType> {
systemMessage: (msg: AiCompletionResponseMessageType) => void;
newChunk: (msg: AiCompletionResponseMessageType) => void;
fullMessage: (msg: AiCompletionResponseMessageType) => void;
}
export class AiCompletionResponseChannel extends Channel<
AiCompletionResponseParams,
AiCompletionResponseResponseType,
AiCompletionResponseChannelEvents
> {
static identifier = 'GraphqlChannel';
constructor(params: AiCompletionResponseInput) {
super({
channel: 'GraphqlChannel',
operationName: 'aiCompletionResponse',
query: AI_MESSAGE_SUBSCRIPTION_QUERY,
variables: JSON.stringify(params),
});
}
receive(message: AiCompletionResponseResponseType) {
if (!message.result.data.aiCompletionResponse) return;
const data = message.result.data.aiCompletionResponse;
if (data.role.toLowerCase() === 'system') {
this.emit('systemMessage', data);
} else if (data.chunkId) {
this.emit('newChunk', data);
} else {
this.emit('fullMessage', data);
}
}
}
References:
- packages/webview_duo_chat/src/plugin/port/api/graphql/ai_completion_response_channel.ts:83 |
You are a code assistant | Definition of 'WebviewInstanceId' in file packages/lib_webview_plugin/src/types.ts in project gitlab-lsp | Definition:
export type WebviewInstanceId = string & { readonly _type: 'WebviewInstanceId' };
export type WebviewAddress = {
webviewId: WebviewId;
webviewInstanceId: WebviewInstanceId;
};
export type WebviewMessageBusManagerHandler<T extends MessageMap> = (
webviewInstanceId: WebviewInstanceId,
messageBus: MessageBus<T>,
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) => Disposable | void;
export interface WebviewConnection<T extends MessageMap> {
broadcast: <TMethod extends keyof T['outbound']['notifications'] & string>(
type: TMethod,
payload: T['outbound']['notifications'][TMethod],
) => void;
onInstanceConnected: (handler: WebviewMessageBusManagerHandler<T>) => void;
}
References:
- packages/lib_webview/src/setup/transport/utils/event_filters.ts:10
- packages/lib_webview_plugin/src/types.ts:18
- packages/lib_webview/src/setup/transport/utils/event_filters.ts:4
- packages/lib_webview_plugin/src/types.ts:22
- packages/lib_webview_transport/src/types.ts:6
- packages/lib_webview_transport_socket_io/src/types.ts:5 |
You are a code assistant | Definition of 'messageBus' in file packages/webview_duo_workflow/src/app/message_bus.ts in project gitlab-lsp | Definition:
export const messageBus = resolveMessageBus<{
inbound: DuoWorkflowMessages['pluginToWebview'];
outbound: DuoWorkflowMessages['webviewToPlugin'];
}>({
webviewId: WEBVIEW_ID,
});
References: |
You are a code assistant | Definition of 'findMatchingRepositoryUri' in file src/common/git/repository_service.ts in project gitlab-lsp | Definition:
findMatchingRepositoryUri(fileUri: URI, workspaceFolderUri: WorkspaceFolder): URI | null {
const trie = this.#workspaceRepositoryTries.get(workspaceFolderUri.uri);
if (!trie) return null;
let node = trie;
let lastMatchingRepo: URI | null = null;
const parts = fileUri.path.split('/').filter(Boolean);
for (const part of parts) {
if (node.repository) {
lastMatchingRepo = node.repository;
}
if (!node.children.has(part)) break;
node = node.children.get(part) as RepositoryTrie;
}
return node.repository || lastMatchingRepo;
}
getRepositoryFileForUri(
fileUri: URI,
repositoryUri: URI,
workspaceFolder: WorkspaceFolder,
): RepositoryFile | null {
const repository = this.#getRepositoriesForWorkspace(workspaceFolder.uri).get(
repositoryUri.toString(),
);
if (!repository) {
return null;
}
return repository.getFile(fileUri.toString()) ?? null;
}
#updateRepositoriesForFolder(
workspaceFolder: WorkspaceFolder,
repositoryMap: RepositoryMap,
repositoryTrie: RepositoryTrie,
) {
this.#workspaces.set(workspaceFolder.uri, repositoryMap);
this.#workspaceRepositoryTries.set(workspaceFolder.uri, repositoryTrie);
}
async handleWorkspaceFilesUpdate({ workspaceFolder, files }: WorkspaceFilesUpdate) {
// clear existing repositories from workspace
this.#emptyRepositoriesForWorkspace(workspaceFolder.uri);
const repositories = this.#detectRepositories(files, workspaceFolder);
const repositoryMap = new Map(repositories.map((repo) => [repo.uri.toString(), repo]));
// Build and cache the repository trie for this workspace
const trie = this.#buildRepositoryTrie(repositories);
this.#updateRepositoriesForFolder(workspaceFolder, repositoryMap, trie);
await Promise.all(
repositories.map((repo) =>
repo.addFilesAndLoadGitIgnore(
files.filter((file) => {
const matchingRepo = this.findMatchingRepositoryUri(file, workspaceFolder);
return matchingRepo && matchingRepo.toString() === repo.uri.toString();
}),
),
),
);
}
async handleWorkspaceFileUpdate({ fileUri, workspaceFolder, event }: WorkspaceFileUpdate) {
const repoUri = this.findMatchingRepositoryUri(fileUri, workspaceFolder);
if (!repoUri) {
log.debug(`No matching repository found for file ${fileUri.toString()}`);
return;
}
const repositoryMap = this.#getRepositoriesForWorkspace(workspaceFolder.uri);
const repository = repositoryMap.get(repoUri.toString());
if (!repository) {
log.debug(`Repository not found for URI ${repoUri.toString()}`);
return;
}
if (repository.isFileIgnored(fileUri)) {
log.debug(`File ${fileUri.toString()} is ignored`);
return;
}
switch (event) {
case 'add':
repository.setFile(fileUri);
log.debug(`File ${fileUri.toString()} added to repository ${repoUri.toString()}`);
break;
case 'change':
repository.setFile(fileUri);
log.debug(`File ${fileUri.toString()} updated in repository ${repoUri.toString()}`);
break;
case 'unlink':
repository.removeFile(fileUri.toString());
log.debug(`File ${fileUri.toString()} removed from repository ${repoUri.toString()}`);
break;
default:
log.warn(`Unknown file event ${event} for file ${fileUri.toString()}`);
}
}
#getRepositoriesForWorkspace(workspaceFolderUri: WorkspaceFolderUri): RepositoryMap {
return this.#workspaces.get(workspaceFolderUri) || new Map();
}
#emptyRepositoriesForWorkspace(workspaceFolderUri: WorkspaceFolderUri): void {
log.debug(`Emptying repositories for workspace ${workspaceFolderUri}`);
const repos = this.#workspaces.get(workspaceFolderUri);
if (!repos || repos.size === 0) return;
// clear up ignore manager trie from memory
repos.forEach((repo) => {
repo.dispose();
log.debug(`Repository ${repo.uri} has been disposed`);
});
repos.clear();
const trie = this.#workspaceRepositoryTries.get(workspaceFolderUri);
if (trie) {
trie.dispose();
this.#workspaceRepositoryTries.delete(workspaceFolderUri);
}
this.#workspaces.delete(workspaceFolderUri);
log.debug(`Repositories for workspace ${workspaceFolderUri} have been emptied`);
}
#detectRepositories(files: URI[], workspaceFolder: WorkspaceFolder): Repository[] {
const gitConfigFiles = files.filter((file) => file.toString().endsWith('.git/config'));
return gitConfigFiles.map((file) => {
const projectUri = fsPathToUri(file.path.replace('.git/config', ''));
const ignoreManager = new IgnoreManager(projectUri.fsPath);
log.info(`Detected repository at ${projectUri.path}`);
return new Repository({
ignoreManager,
uri: projectUri,
configFileUri: file,
workspaceFolder,
});
});
}
getFilesForWorkspace(
workspaceFolderUri: WorkspaceFolderUri,
options: { excludeGitFolder?: boolean; excludeIgnored?: boolean } = {},
): RepositoryFile[] {
const repositories = this.#getRepositoriesForWorkspace(workspaceFolderUri);
const allFiles: RepositoryFile[] = [];
repositories.forEach((repository) => {
repository.getFiles().forEach((file) => {
// apply the filters
if (options.excludeGitFolder && this.#isInGitFolder(file.uri, repository.uri)) {
return;
}
if (options.excludeIgnored && file.isIgnored) {
return;
}
allFiles.push(file);
});
});
return allFiles;
}
// Helper method to check if a file is in the .git folder
#isInGitFolder(fileUri: URI, repositoryUri: URI): boolean {
const relativePath = fileUri.path.slice(repositoryUri.path.length);
return relativePath.split('/').some((part) => part === '.git');
}
}
References: |
You are a code assistant | Definition of 'getUri' in file src/common/webview/webview_resource_location_service.test.ts in project gitlab-lsp | Definition:
getUri(): string {
return this.uri;
}
}
describe('WebviewLocationService', () => {
let service: WebviewLocationService;
const TEST_URI_1 = 'http://example.com';
const TEST_URI_2 = 'file:///foo/bar';
const TEST_WEBVIEW_ID: WebviewId = 'webview-1' as WebviewId;
beforeEach(() => {
service = new WebviewLocationService();
});
describe('resolveUris', () => {
it('should resolve URIs from multiple providers', () => {
const provider1 = new MockWebviewUriProvider(TEST_URI_1);
const provider2 = new MockWebviewUriProvider(TEST_URI_2);
service.register(provider1);
service.register(provider2);
const uris = service.resolveUris(TEST_WEBVIEW_ID);
expect(uris).toEqual([TEST_URI_1, TEST_URI_2]);
});
it('should return an empty array if no providers are registered', () => {
const uris = service.resolveUris(TEST_WEBVIEW_ID);
expect(uris).toEqual([]);
});
it('should not register the same provider multiple times', () => {
const provider = new MockWebviewUriProvider(TEST_URI_1);
service.register(provider);
service.register(provider);
const uris = service.resolveUris(TEST_WEBVIEW_ID);
expect(uris).toEqual([TEST_URI_1]);
});
});
});
References: |
You are a code assistant | Definition of 'brandInstance' in file packages/lib_di/src/index.ts in project gitlab-lsp | Definition:
export const brandInstance = <T extends object>(
id: InterfaceId<T>,
instance: T,
): BrandedInstance<T> => {
injectableMetadata.set(instance, { id, dependencies: [] });
return instance;
};
/**
* Container is responsible for initializing a dependency tree.
*
* It receives a list of classes decorated with the `@Injectable` decorator
* and it constructs instances of these classes in an order that ensures class' dependencies
* are initialized before the class itself.
*
* check https://gitlab.com/viktomas/needle for full documentation of this mini-framework
*/
export class Container {
#instances = new Map<string, unknown>();
/**
* addInstances allows you to add pre-initialized objects to the container.
* This is useful when you want to keep mandatory parameters in class' constructor (e.g. some runtime objects like server connection).
* addInstances accepts a list of any objects that have been "branded" by the `brandInstance` method
*/
addInstances(...instances: BrandedInstance<object>[]) {
for (const instance of instances) {
const metadata = injectableMetadata.get(instance);
if (!metadata) {
throw new Error(
'assertion error: addInstance invoked without branded object, make sure all arguments are branded with `brandInstance`',
);
}
if (this.#instances.has(metadata.id)) {
throw new Error(
`you are trying to add instance for interfaceId ${metadata.id}, but instance with this ID is already in the container.`,
);
}
this.#instances.set(metadata.id, instance);
}
}
/**
* instantiate accepts list of classes, validates that they can be managed by the container
* and then initialized them in such order that dependencies of a class are initialized before the class
*/
instantiate(...classes: WithConstructor[]) {
// ensure all classes have been decorated with @Injectable
const undecorated = classes.filter((c) => !injectableMetadata.has(c)).map((c) => c.name);
if (undecorated.length) {
throw new Error(`Classes [${undecorated}] are not decorated with @Injectable.`);
}
const classesWithDeps: ClassWithDependencies[] = classes.map((cls) => {
// we verified just above that all classes are present in the metadata map
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const { id, dependencies } = injectableMetadata.get(cls)!;
return { cls, id, dependencies };
});
const validators: Validator[] = [
interfaceUsedOnlyOnce,
dependenciesArePresent,
noCircularDependencies,
];
validators.forEach((v) => v(classesWithDeps, Array.from(this.#instances.keys())));
const classesById = new Map<string, ClassWithDependencies>();
// Index classes by their interface id
classesWithDeps.forEach((cwd) => {
classesById.set(cwd.id, cwd);
});
// Create instances in topological order
for (const cwd of sortDependencies(classesById)) {
const args = cwd.dependencies.map((dependencyId) => this.#instances.get(dependencyId));
// eslint-disable-next-line new-cap
const instance = new cwd.cls(...args);
this.#instances.set(cwd.id, instance);
}
}
get<T>(id: InterfaceId<T>): T {
const instance = this.#instances.get(id);
if (!instance) {
throw new Error(`Instance for interface '${sanitizeId(id)}' is not in the container.`);
}
return instance as T;
}
}
References:
- packages/lib_di/src/index.test.ts:66
- src/node/main.ts:96
- src/node/main.ts:118
- src/browser/main.ts:72
- src/node/main.ts:98
- src/node/main.ts:115
- src/browser/main.ts:70
- src/browser/main.ts:77
- src/browser/main.ts:68
- packages/lib_di/src/index.test.ts:123
- packages/lib_di/src/index.test.ts:67
- src/browser/main.ts:112
- packages/lib_di/src/index.test.ts:110
- src/node/main.ts:166
- packages/lib_di/src/index.test.ts:73 |
You are a code assistant | Definition of 'constructor' in file src/common/suggestion/supported_languages_service.ts in project gitlab-lsp | Definition:
constructor(configService: ConfigService) {
this.#enabledLanguages = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
this.#supportedLanguages = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
this.#configService = configService;
this.#configService.onConfigChange(() => this.#update());
}
#getConfiguredLanguages() {
const languages: SupportedLanguagesUpdateParam = {};
const additionalLanguages = this.#configService.get(
'client.codeCompletion.additionalLanguages',
);
if (Array.isArray(additionalLanguages)) {
languages.allow = additionalLanguages.map(this.#normalizeLanguageIdentifier);
} else {
log.warn(
'Failed to parse user-configured Code Suggestions languages. Code Suggestions will still work for the default languages.',
);
}
const disabledSupportedLanguages = this.#configService.get(
'client.codeCompletion.disabledSupportedLanguages',
);
if (Array.isArray(disabledSupportedLanguages)) {
languages.deny = disabledSupportedLanguages;
} else {
log.warn(
'Invalid configuration for disabled Code Suggestions languages. All default languages remain enabled.',
);
}
return languages;
}
#update() {
const { allow = [], deny = [] } = this.#getConfiguredLanguages();
const newSet: Set<string> = new Set(BASE_SUPPORTED_CODE_SUGGESTIONS_LANGUAGES);
for (const language of allow) {
newSet.add(language.trim());
}
for (const language of deny) {
newSet.delete(language);
}
if (newSet.size === 0) {
log.warn('All languages have been disabled for Code Suggestions.');
}
const previousEnabledLanguages = this.#enabledLanguages;
this.#enabledLanguages = newSet;
if (!isEqual(previousEnabledLanguages, this.#enabledLanguages)) {
this.#triggerChange();
}
}
isLanguageSupported(languageId: string) {
return this.#supportedLanguages.has(languageId);
}
isLanguageEnabled(languageId: string) {
return this.#enabledLanguages.has(languageId);
}
onLanguageChange(listener: () => void): Disposable {
this.#eventEmitter.on('languageChange', listener);
return { dispose: () => this.#eventEmitter.removeListener('configChange', listener) };
}
#triggerChange() {
this.#eventEmitter.emit('languageChange');
}
#normalizeLanguageIdentifier(language: string) {
return language.trim().toLowerCase().replace(/^\./, '');
}
}
References: |
You are a code assistant | Definition of 'Processor2' in file src/common/suggestion_client/post_processors/post_processor_pipeline.test.ts in project gitlab-lsp | Definition:
class Processor2 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input.map((option) => ({ ...option, text: `${option.text} [2]` }));
}
}
pipeline.addProcessor(new Processor1());
pipeline.addProcessor(new Processor2());
const completionInput: SuggestionOption[] = [{ text: 'option1', uniqueTrackingId: '1' }];
const result = await pipeline.run({
documentContext: mockContext,
input: completionInput,
type: 'completion',
});
expect(result).toEqual([{ text: 'option1 [1] [2]', uniqueTrackingId: '1' }]);
});
test('should throw an error for unexpected type', async () => {
class TestProcessor extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
pipeline.addProcessor(new TestProcessor());
const invalidInput = { invalid: 'input' };
await expect(
pipeline.run({
documentContext: mockContext,
input: invalidInput as unknown as StreamingCompletionResponse,
type: 'invalid' as 'stream',
}),
).rejects.toThrow('Unexpected type in pipeline processing');
});
});
References:
- src/common/suggestion_client/post_processors/post_processor_pipeline.test.ts:163
- src/common/suggestion_client/post_processors/post_processor_pipeline.test.ts:117 |
You are a code assistant | Definition of 'dispose' in file src/common/webview/extension/extension_connection_message_bus_provider.ts in project gitlab-lsp | Definition:
dispose(): void {
this.#disposables.dispose();
}
#setupConnectionSubscriptions() {
this.#disposables.add(
this.#connection.onNotification(
this.#rpcMethods.notification,
handleNotificationMessage(this.#notificationHandlers, this.#logger),
),
);
this.#disposables.add(
this.#connection.onRequest(
this.#rpcMethods.request,
handleRequestMessage(this.#requestHandlers, this.#logger),
),
);
}
}
References: |
You are a code assistant | Definition of 'constructor' in file packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_record.ts in project gitlab-lsp | Definition:
constructor({
chunkId,
type,
role,
content,
contentHtml,
state,
requestId,
errors,
timestamp,
extras,
}: GitLabChatRecordAttributes) {
this.chunkId = chunkId;
this.role = role;
this.content = content;
this.contentHtml = contentHtml;
this.type = type ?? this.#detectType();
this.state = state ?? 'ready';
this.requestId = requestId;
this.errors = errors ?? [];
this.id = uuidv4();
this.timestamp = timestamp ? Date.parse(timestamp) : Date.now();
this.extras = extras;
}
static buildWithContext(attributes: GitLabChatRecordAttributes): GitLabChatRecord {
const record = new GitLabChatRecord(attributes);
record.context = buildCurrentContext();
return record;
}
update(attributes: Partial<GitLabChatRecordAttributes>) {
const convertedAttributes = attributes as Partial<GitLabChatRecord>;
if (attributes.timestamp) {
convertedAttributes.timestamp = Date.parse(attributes.timestamp);
}
Object.assign(this, convertedAttributes);
}
#detectType(): ChatRecordType {
if (this.content === SPECIAL_MESSAGES.RESET) {
return 'newConversation';
}
return 'general';
}
}
References: |
You are a code assistant | Definition of 'DefaultAdvancedContextService' in file src/common/advanced_context/advanced_context_service.ts in project gitlab-lsp | Definition:
export class DefaultAdvancedContextService implements AdvancedContextService {
#configService: ConfigService;
#documentTransformer: DocumentTransformerService;
#supportedLanguagesService: SupportedLanguagesService;
constructor(
configService: ConfigService,
connection: LsConnection,
documentService: DocumentService,
documentTransformer: DocumentTransformerService,
supportedLanguagesService: SupportedLanguagesService,
) {
this.#configService = configService;
this.#documentTransformer = documentTransformer;
this.#supportedLanguagesService = supportedLanguagesService;
const subscription = documentService.onDocumentChange(async ({ document }, handlerType) => {
await this.#updateAdvancedContext(document, handlerType);
});
connection.onShutdown(() => subscription.dispose());
}
/**
* Currently updates the LRU cache with the most recently accessed files in the workspace.
* We only update the advanced context for supported languages. We also ensure to run
* documents through the `DocumentTransformer` to ensure the secret redaction is applied.
*/
async #updateAdvancedContext(
document: TextDocument,
handlerType: TextDocumentChangeListenerType,
) {
const lruCache = LruCache.getInstance(LRU_CACHE_BYTE_SIZE_LIMIT);
// eslint-disable-next-line default-case
switch (handlerType) {
case TextDocumentChangeListenerType.onDidClose: {
// We don't check if the language is supported for `onDidClose` because we want
// always attempt to delete the file from the cache.
const fileDeleted = lruCache.deleteFile(document.uri);
if (fileDeleted) {
log.debug(`Advanced Context: File ${document.uri} was deleted from the LRU cache`);
} else {
log.debug(`Advanced Context: File ${document.uri} was not found in the LRU cache`);
}
break;
}
case TextDocumentChangeListenerType.onDidChangeContent:
case TextDocumentChangeListenerType.onDidSave:
case TextDocumentChangeListenerType.onDidOpen:
case TextDocumentChangeListenerType.onDidSetActive: {
const languageEnabled = this.#supportedLanguagesService.isLanguageEnabled(
document.languageId,
);
if (!languageEnabled) {
return;
}
const context = this.#documentTransformer.getContext(
document.uri,
{ line: 0, character: 0 },
this.#configService.get().client.workspaceFolders ?? [],
undefined,
);
if (!context) {
log.debug(`Advanced Context: document context for ${document.uri} was not found`);
return;
}
lruCache.updateFile(context);
log.debug(`Advanced Context: uri ${document.uri} was updated in the MRU cache`);
break;
}
}
}
}
References:
- src/common/advanced_context/advanced_context_service.test.ts:58 |
You are a code assistant | Definition of 'b' in file packages/lib_di/src/index.test.ts in project gitlab-lsp | Definition:
b(): string;
}
interface C {
c(): string;
}
const A = createInterfaceId<A>('A');
const B = createInterfaceId<B>('B');
const C = createInterfaceId<C>('C');
@Injectable(A, [])
class AImpl implements A {
a = () => 'a';
}
@Injectable(B, [A])
class BImpl implements B {
#a: A;
constructor(a: A) {
this.#a = a;
}
b = () => `B(${this.#a.a()})`;
}
@Injectable(C, [A, B])
class CImpl implements C {
#a: A;
#b: B;
constructor(a: A, b: B) {
this.#a = a;
this.#b = b;
}
c = () => `C(${this.#b.b()}, ${this.#a.a()})`;
}
let container: Container;
beforeEach(() => {
container = new Container();
});
describe('addInstances', () => {
const O = createInterfaceId<object>('object');
it('fails if the instance is not branded', () => {
expect(() => container.addInstances({ say: 'hello' } as BrandedInstance<object>)).toThrow(
/invoked without branded object/,
);
});
it('fails if the instance is already present', () => {
const a = brandInstance(O, { a: 'a' });
const b = brandInstance(O, { b: 'b' });
expect(() => container.addInstances(a, b)).toThrow(/this ID is already in the container/);
});
it('adds instance', () => {
const instance = { a: 'a' };
const a = brandInstance(O, instance);
container.addInstances(a);
expect(container.get(O)).toBe(instance);
});
});
describe('instantiate', () => {
it('can instantiate three classes A,B,C', () => {
container.instantiate(AImpl, BImpl, CImpl);
const cInstance = container.get(C);
expect(cInstance.c()).toBe('C(B(a), a)');
});
it('instantiates dependencies in multiple instantiate calls', () => {
container.instantiate(AImpl);
// the order is important for this test
// we want to make sure that the stack in circular dependency discovery is being cleared
// to try why this order is necessary, remove the `inStack.delete()` from
// the `if (!cwd && instanceIds.includes(id))` condition in prod code
expect(() => container.instantiate(CImpl, BImpl)).not.toThrow();
});
it('detects duplicate ids', () => {
@Injectable(A, [])
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl, AImpl2)).toThrow(
/The following interface IDs were used multiple times 'A' \(classes: AImpl,AImpl2\)/,
);
});
it('detects duplicate id with pre-existing instance', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
expect(() => container.instantiate(AImpl)).toThrow(/classes are clashing/);
});
it('detects missing dependencies', () => {
expect(() => container.instantiate(BImpl)).toThrow(
/Class BImpl \(interface B\) depends on interfaces \[A]/,
);
});
it('it uses existing instances as dependencies', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
container.instantiate(BImpl);
expect(container.get(B).b()).toBe('B(a)');
});
it("detects classes what aren't decorated with @Injectable", () => {
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl2)).toThrow(
/Classes \[AImpl2] are not decorated with @Injectable/,
);
});
it('detects circular dependencies', () => {
@Injectable(A, [C])
class ACircular implements A {
a = () => 'hello';
constructor(c: C) {
// eslint-disable-next-line no-unused-expressions
c;
}
}
expect(() => container.instantiate(ACircular, BImpl, CImpl)).toThrow(
/Circular dependency detected between interfaces \(A,C\), starting with 'A' \(class: ACircular\)./,
);
});
// this test ensures that we don't store any references to the classes and we instantiate them only once
it('does not instantiate classes from previous instantiate call', () => {
let globCount = 0;
@Injectable(A, [])
class Counter implements A {
counter = globCount;
constructor() {
globCount++;
}
a = () => this.counter.toString();
}
container.instantiate(Counter);
container.instantiate(BImpl);
expect(container.get(A).a()).toBe('0');
});
});
describe('get', () => {
it('returns an instance of the interfaceId', () => {
container.instantiate(AImpl);
expect(container.get(A)).toBeInstanceOf(AImpl);
});
it('throws an error for missing dependency', () => {
container.instantiate();
expect(() => container.get(A)).toThrow(/Instance for interface 'A' is not in the container/);
});
});
});
References:
- src/tests/fixtures/intent/ruby_comments.rb:15 |
You are a code assistant | Definition of 'MessageValidator' in file packages/lib_webview_transport/src/utils/message_validators.ts in project gitlab-lsp | Definition:
export type MessageValidator<T> = (message: unknown) => message is T;
export const isWebviewAddress: MessageValidator<WebviewAddress> = (
message: unknown,
): message is WebviewAddress =>
typeof message === 'object' &&
message !== null &&
'webviewId' in message &&
'webviewInstanceId' in message;
export const isWebviewInstanceCreatedEventData: MessageValidator<
WebviewInstanceCreatedEventData
> = (message: unknown): message is WebviewInstanceCreatedEventData => isWebviewAddress(message);
export const isWebviewInstanceDestroyedEventData: MessageValidator<
WebviewInstanceDestroyedEventData
> = (message: unknown): message is WebviewInstanceDestroyedEventData => isWebviewAddress(message);
export const isWebviewInstanceMessageEventData: MessageValidator<
WebviewInstanceNotificationEventData
> = (message: unknown): message is WebviewInstanceNotificationEventData =>
isWebviewAddress(message) && 'type' in message;
References: |
You are a code assistant | Definition of 'REQUEST_TIMEOUT_MILLISECONDS' in file packages/webview_duo_chat/src/plugin/port/constants.ts in project gitlab-lsp | Definition:
export const REQUEST_TIMEOUT_MILLISECONDS = 25000;
// Webview IDs
export const DUO_WORKFLOW_WEBVIEW_ID = 'duo-workflow';
export const DUO_CHAT_WEBVIEW_ID = 'chat';
References: |
You are a code assistant | Definition of 'add' in file packages/lib_disposable/src/composite_disposable.ts in project gitlab-lsp | Definition:
add(...disposables: Disposable[]): void {
for (const disposable of disposables) {
this.#disposables.add(disposable);
}
}
dispose(): void {
for (const disposable of this.#disposables) {
disposable.dispose();
}
this.#disposables.clear();
}
}
References: |
You are a code assistant | Definition of 'dispose' in file src/common/git/repository_trie.ts in project gitlab-lsp | Definition:
dispose(): void {
this.children.forEach((child) => child.dispose());
this.children.clear();
this.repository = null;
}
}
References: |
You are a code assistant | Definition of 'success' in file src/common/circuit_breaker/fixed_time_circuit_breaker.ts in project gitlab-lsp | Definition:
success() {
this.#errorCount = 0;
this.#close();
}
onOpen(listener: () => void): Disposable {
this.#eventEmitter.on('open', listener);
return { dispose: () => this.#eventEmitter.removeListener('open', listener) };
}
onClose(listener: () => void): Disposable {
this.#eventEmitter.on('close', listener);
return { dispose: () => this.#eventEmitter.removeListener('close', listener) };
}
}
References: |
You are a code assistant | Definition of 'constructor' in file packages/webview_duo_chat/src/plugin/port/chat/get_platform_manager_for_chat.ts in project gitlab-lsp | Definition:
constructor(platformManager: GitLabPlatformManager) {
this.#platformManager = platformManager;
}
async getProjectGqlId(): Promise<string | undefined> {
const projectManager = await this.#platformManager.getForActiveProject(false);
return projectManager?.project.gqlId;
}
/**
* Obtains a GitLab Platform to send API requests to the GitLab API
* for the Duo Chat feature.
*
* - It returns a GitLabPlatformForAccount for the first linked account.
* - It returns undefined if there are no accounts linked
*/
async getGitLabPlatform(): Promise<GitLabPlatformForAccount | undefined> {
const platforms = await this.#platformManager.getForAllAccounts();
if (!platforms.length) {
return undefined;
}
let platform: GitLabPlatformForAccount | undefined;
// Using a for await loop in this context because we want to stop
// evaluating accounts as soon as we find one with code suggestions enabled
for await (const result of platforms.map(getChatSupport)) {
if (result.hasSupportForChat) {
platform = result.platform;
break;
}
}
return platform;
}
async getGitLabEnvironment(): Promise<GitLabEnvironment> {
const platform = await this.getGitLabPlatform();
const instanceUrl = platform?.account.instanceUrl;
switch (instanceUrl) {
case GITLAB_COM_URL:
return GitLabEnvironment.GITLAB_COM;
case GITLAB_DEVELOPMENT_URL:
return GitLabEnvironment.GITLAB_DEVELOPMENT;
case GITLAB_STAGING_URL:
return GitLabEnvironment.GITLAB_STAGING;
case GITLAB_ORG_URL:
return GitLabEnvironment.GITLAB_ORG;
default:
return GitLabEnvironment.GITLAB_SELF_MANAGED;
}
}
}
References: |
You are a code assistant | Definition of 'AiContextItemWithContent' in file src/common/ai_context_management_2/ai_context_item.ts in project gitlab-lsp | Definition:
export type AiContextItemWithContent = AiContextItem & {
content: string;
};
References: |
You are a code assistant | Definition of 'DeepPartial' in file packages/webview_duo_chat/src/plugin/port/test_utils/create_fake_partial.ts in project gitlab-lsp | Definition:
type DeepPartial<T> = { [P in keyof T]?: _DeepPartial<T[P]> };
export const createFakePartial = <T>(x: DeepPartial<T>): T => x as T;
References: |
You are a code assistant | Definition of 'DocumentService' in file src/common/document_service.ts in project gitlab-lsp | Definition:
export interface DocumentService {
onDocumentChange(listener: TextDocumentChangeListener): Disposable;
notificationHandler(params: DidChangeDocumentInActiveEditorParams): void;
}
export const DocumentService = createInterfaceId<DocumentService>('DocumentsWrapper');
const DOCUMENT_CHANGE_EVENT_NAME = 'documentChange';
export class DefaultDocumentService
implements DocumentService, HandlesNotification<DidChangeDocumentInActiveEditorParams>
{
#subscriptions: Disposable[] = [];
#emitter = new EventEmitter();
#documents: TextDocuments<TextDocument>;
constructor(documents: TextDocuments<TextDocument>) {
this.#documents = documents;
this.#subscriptions.push(
documents.onDidOpen(this.#createMediatorListener(TextDocumentChangeListenerType.onDidOpen)),
);
documents.onDidChangeContent(
this.#createMediatorListener(TextDocumentChangeListenerType.onDidChangeContent),
);
documents.onDidClose(this.#createMediatorListener(TextDocumentChangeListenerType.onDidClose));
documents.onDidSave(this.#createMediatorListener(TextDocumentChangeListenerType.onDidSave));
}
notificationHandler = (param: DidChangeDocumentInActiveEditorParams) => {
const document = isTextDocument(param) ? param : this.#documents.get(param);
if (!document) {
log.error(`Active editor document cannot be retrieved by URL: ${param}`);
return;
}
const event: TextDocumentChangeEvent<TextDocument> = { document };
this.#emitter.emit(
DOCUMENT_CHANGE_EVENT_NAME,
event,
TextDocumentChangeListenerType.onDidSetActive,
);
};
#createMediatorListener =
(type: TextDocumentChangeListenerType) => (event: TextDocumentChangeEvent<TextDocument>) => {
this.#emitter.emit(DOCUMENT_CHANGE_EVENT_NAME, event, type);
};
onDocumentChange(listener: TextDocumentChangeListener) {
this.#emitter.on(DOCUMENT_CHANGE_EVENT_NAME, listener);
return {
dispose: () => this.#emitter.removeListener(DOCUMENT_CHANGE_EVENT_NAME, listener),
};
}
}
References:
- src/common/connection_service.ts:65
- src/common/feature_state/project_duo_acces_check.ts:41
- src/common/security_diagnostics_publisher.ts:42
- src/common/security_diagnostics_publisher.test.ts:21
- src/common/advanced_context/advanced_context_service.ts:35
- src/common/feature_state/supported_language_check.ts:31
- src/common/feature_state/supported_language_check.ts:18 |
You are a code assistant | Definition of 'DefaultFeatureFlagService' in file src/common/feature_flags.ts in project gitlab-lsp | Definition:
export class DefaultFeatureFlagService {
#api: GitLabApiClient;
#configService: ConfigService;
#featureFlags: Map<string, boolean> = new Map();
constructor(api: GitLabApiClient, configService: ConfigService) {
this.#api = api;
this.#featureFlags = new Map();
this.#configService = configService;
this.#api.onApiReconfigured(async ({ isInValidState }) => {
if (!isInValidState) return;
await this.#updateInstanceFeatureFlags();
});
}
/**
* Fetches the feature flags from the gitlab instance
* and updates the internal state.
*/
async #fetchFeatureFlag(name: string): Promise<boolean> {
try {
const result = await this.#api.fetchFromApi<{ featureFlagEnabled: boolean }>({
type: 'graphql',
query: INSTANCE_FEATURE_FLAG_QUERY,
variables: { name },
});
log.debug(`FeatureFlagService: feature flag ${name} is ${result.featureFlagEnabled}`);
return result.featureFlagEnabled;
} catch (e) {
// FIXME: we need to properly handle graphql errors
// https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp/-/issues/250
if (e instanceof ClientError) {
const fieldDoesntExistError = e.message.match(/field '([^']+)' doesn't exist on type/i);
if (fieldDoesntExistError) {
// we expect graphql-request to throw an error when the query doesn't exist (eg. GitLab 16.9)
// so we debug to reduce noise
log.debug(`FeatureFlagService: query doesn't exist`, e.message);
} else {
log.error(`FeatureFlagService: error fetching feature flag ${name}`, e);
}
}
return false;
}
}
/**
* Fetches the feature flags from the gitlab instance
* and updates the internal state.
*/
async #updateInstanceFeatureFlags(): Promise<void> {
log.debug('FeatureFlagService: populating feature flags');
for (const flag of Object.values(InstanceFeatureFlags)) {
// eslint-disable-next-line no-await-in-loop
this.#featureFlags.set(flag, await this.#fetchFeatureFlag(flag));
}
}
/**
* Checks if a feature flag is enabled on the GitLab instance.
* @see `GitLabApiClient` for how the instance is determined.
* @requires `updateInstanceFeatureFlags` to be called first.
*/
isInstanceFlagEnabled(name: InstanceFeatureFlags): boolean {
return this.#featureFlags.get(name) ?? false;
}
/**
* Checks if a feature flag is enabled on the client.
* @see `ConfigService` for client configuration.
*/
isClientFlagEnabled(name: ClientFeatureFlags): boolean {
const value = this.#configService.get('client.featureFlags')?.[name];
return value ?? false;
}
}
References:
- src/common/feature_flags.test.ts:22 |
You are a code assistant | Definition of 'constructor' in file src/common/git/repository.ts in project gitlab-lsp | Definition:
constructor({
configFileUri,
workspaceFolder,
uri,
ignoreManager,
}: {
workspaceFolder: WorkspaceFolder;
uri: RepositoryUri;
configFileUri: URI;
ignoreManager: IgnoreManager;
}) {
this.workspaceFolder = workspaceFolder;
this.uri = uri;
this.configFileUri = configFileUri;
this.#files = new Map();
this.#ignoreManager = ignoreManager;
}
async addFilesAndLoadGitIgnore(files: URI[]): Promise<void> {
log.info(`Adding ${files.length} files to repository ${this.uri.toString()}`);
await this.#ignoreManager.loadIgnoreFiles(files.map((uri) => uri.fsPath));
for (const file of files) {
if (!this.#ignoreManager.isIgnored(file.fsPath)) {
this.#files.set(file.toString(), {
uri: file,
isIgnored: false,
repositoryUri: this.uri,
workspaceFolder: this.workspaceFolder,
});
} else {
this.#files.set(file.toString(), {
uri: file,
isIgnored: true,
repositoryUri: this.uri,
workspaceFolder: this.workspaceFolder,
});
}
}
}
isFileIgnored(filePath: URI): boolean {
return this.#ignoreManager.isIgnored(filePath.fsPath);
}
setFile(fileUri: URI): void {
if (!this.isFileIgnored(fileUri)) {
this.#files.set(fileUri.toString(), {
uri: fileUri,
isIgnored: false,
repositoryUri: this.uri,
workspaceFolder: this.workspaceFolder,
});
} else {
this.#files.set(fileUri.toString(), {
uri: fileUri,
isIgnored: true,
repositoryUri: this.uri,
workspaceFolder: this.workspaceFolder,
});
}
}
getFile(fileUri: string): RepositoryFile | undefined {
return this.#files.get(fileUri);
}
removeFile(fileUri: string): void {
this.#files.delete(fileUri);
}
getFiles(): Map<string, RepositoryFile> {
return this.#files;
}
dispose(): void {
this.#ignoreManager.dispose();
this.#files.clear();
}
}
References: |
You are a code assistant | Definition of 'WebviewInstanceInfo' in file packages/lib_webview/src/setup/plugin/webview_controller.ts in project gitlab-lsp | Definition:
type WebviewInstanceInfo = {
messageBus: WebviewInstanceMessageBus<MessageMap>;
pluginCallbackDisposables: CompositeDisposable;
};
export interface WebviewMessageBusFactory {
(webviewAddress: WebviewAddress): WebviewInstanceMessageBus<MessageMap>;
}
export class WebviewController<T extends MessageMap> implements WebviewConnection<T>, Disposable {
readonly webviewId: WebviewId;
#messageBusFactory: WebviewMessageBusFactory;
#handlers = new Set<WebviewMessageBusManagerHandler<T>>();
#instanceInfos = new Map<WebviewInstanceId, WebviewInstanceInfo>();
#compositeDisposable = new CompositeDisposable();
#logger: Logger;
constructor(
webviewId: WebviewId,
runtimeMessageBus: WebviewRuntimeMessageBus,
messageBusFactory: WebviewMessageBusFactory,
logger: Logger,
) {
this.#logger = withPrefix(logger, `[WebviewController:${webviewId}]`);
this.webviewId = webviewId;
this.#messageBusFactory = messageBusFactory;
this.#subscribeToEvents(runtimeMessageBus);
}
broadcast<TMethod extends keyof T['outbound']['notifications'] & string>(
type: TMethod,
payload: T['outbound']['notifications'][TMethod],
) {
for (const info of this.#instanceInfos.values()) {
info.messageBus.sendNotification(type.toString(), payload);
}
}
onInstanceConnected(handler: WebviewMessageBusManagerHandler<T>) {
this.#handlers.add(handler);
for (const [instanceId, info] of this.#instanceInfos) {
const disposable = handler(instanceId, info.messageBus);
if (isDisposable(disposable)) {
info.pluginCallbackDisposables.add(disposable);
}
}
}
dispose(): void {
this.#compositeDisposable.dispose();
this.#instanceInfos.forEach((info) => info.messageBus.dispose());
this.#instanceInfos.clear();
}
#subscribeToEvents(runtimeMessageBus: WebviewRuntimeMessageBus) {
const eventFilter = buildWebviewIdFilter(this.webviewId);
this.#compositeDisposable.add(
runtimeMessageBus.subscribe('webview:connect', this.#handleConnected.bind(this), eventFilter),
runtimeMessageBus.subscribe(
'webview:disconnect',
this.#handleDisconnected.bind(this),
eventFilter,
),
);
}
#handleConnected(address: WebviewAddress) {
this.#logger.debug(`Instance connected: ${address.webviewInstanceId}`);
if (this.#instanceInfos.has(address.webviewInstanceId)) {
// we are already connected with this webview instance
return;
}
const messageBus = this.#messageBusFactory(address);
const pluginCallbackDisposables = new CompositeDisposable();
this.#instanceInfos.set(address.webviewInstanceId, {
messageBus,
pluginCallbackDisposables,
});
this.#handlers.forEach((handler) => {
const disposable = handler(address.webviewInstanceId, messageBus);
if (isDisposable(disposable)) {
pluginCallbackDisposables.add(disposable);
}
});
}
#handleDisconnected(address: WebviewAddress) {
this.#logger.debug(`Instance disconnected: ${address.webviewInstanceId}`);
const instanceInfo = this.#instanceInfos.get(address.webviewInstanceId);
if (!instanceInfo) {
// we aren't tracking this instance
return;
}
instanceInfo.pluginCallbackDisposables.dispose();
instanceInfo.messageBus.dispose();
this.#instanceInfos.delete(address.webviewInstanceId);
}
}
References:
- packages/lib_webview_transport_socket_io/src/utils/connection_utils.ts:6
- packages/lib_webview_transport_socket_io/src/socket_io_webview_transport.ts:58 |
You are a code assistant | Definition of 'SuggestionResponseChoice' in file src/common/suggestion_client/suggestion_client.ts in project gitlab-lsp | Definition:
export interface SuggestionResponseChoice {
text: string;
}
export interface SuggestionClient {
getSuggestions(context: SuggestionContext): Promise<SuggestionResponse | undefined>;
}
export type SuggestionClientFn = SuggestionClient['getSuggestions'];
export type SuggestionClientMiddleware = (
context: SuggestionContext,
next: SuggestionClientFn,
) => ReturnType<SuggestionClientFn>;
References: |
You are a code assistant | Definition of 'fetch' in file src/common/fetch.ts in project gitlab-lsp | Definition:
async fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return fetch(input, init);
}
async *streamFetch(
/* eslint-disable @typescript-eslint/no-unused-vars */
_url: string,
_body: string,
_headers: FetchHeaders,
/* eslint-enable @typescript-eslint/no-unused-vars */
): AsyncGenerator<string, void, void> {
// Stub. Should delegate to the node or browser fetch implementations
throw new Error('Not implemented');
yield '';
}
async delete(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('DELETE', init));
}
async get(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('GET', init));
}
async post(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('POST', init));
}
async put(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('PUT', init));
}
async fetchBase(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
// eslint-disable-next-line no-underscore-dangle, no-restricted-globals
const _global = typeof global === 'undefined' ? self : global;
return _global.fetch(input, init);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
updateAgentOptions(_opts: FetchAgentOptions): void {}
}
References:
- src/common/fetch.ts:48
- src/common/security_diagnostics_publisher.ts:101
- src/node/fetch.ts:214
- src/common/suggestion_client/direct_connection_client.ts:104 |
You are a code assistant | Definition of 'ParserInitOptions' in file src/browser/tree_sitter/index.test.ts in project gitlab-lsp | Definition:
type ParserInitOptions = { locateFile: (scriptName: string) => string };
describe('BrowserTreeSitterParser', () => {
let subject: BrowserTreeSitterParser;
let configService: ConfigService;
const baseAssetsUrl = 'http://localhost/assets/tree-sitter/';
describe('init', () => {
beforeEach(async () => {
configService = new DefaultConfigService();
configService.set('client.baseAssetsUrl', baseAssetsUrl);
subject = new BrowserTreeSitterParser(configService);
});
it('initializes languages list with correct wasmPath', async () => {
await subject.init();
const actual = subject.getLanguages();
for (const [, treeSitterLangInfo] of actual) {
expect(treeSitterLangInfo.wasmPath).toContain(baseAssetsUrl);
}
});
it('initializes the Treesitter parser with a locateFile function', async () => {
let options: ParserInitOptions | undefined;
jest.mocked(Parser.init).mockImplementationOnce(async (_options?: object) => {
options = _options as ParserInitOptions;
});
await subject.init();
expect(options?.locateFile).toBeDefined();
expect(options?.locateFile('tree-sitter.wasm')).toBe(`${baseAssetsUrl}node/tree-sitter.wasm`);
});
it.each`
initCall | loadState
${() => jest.mocked(Parser.init).mockResolvedValueOnce()} | ${TreeSitterParserLoadState.READY}
${() => jest.mocked(Parser.init).mockRejectedValueOnce(new Error())} | ${TreeSitterParserLoadState.ERRORED}
`('sets the correct parser load state', async ({ initCall, loadState }) => {
initCall();
await subject.init();
expect(subject.getLoadState()).toBe(loadState);
});
});
});
References: |
You are a code assistant | Definition of 'constructor' in file src/common/circuit_breaker/exponential_backoff_circuit_breaker.ts in project gitlab-lsp | Definition:
constructor(
name: string,
{
initialBackoffMs = DEFAULT_INITIAL_BACKOFF_MS,
maxBackoffMs = DEFAULT_MAX_BACKOFF_MS,
backoffMultiplier = DEFAULT_BACKOFF_MULTIPLIER,
}: ExponentialBackoffCircuitBreakerOptions = {},
) {
this.#name = name;
this.#initialBackoffMs = initialBackoffMs;
this.#maxBackoffMs = maxBackoffMs;
this.#backoffMultiplier = backoffMultiplier;
}
error() {
this.#errorCount += 1;
this.#open();
}
megaError() {
this.#errorCount += 3;
this.#open();
}
#open() {
if (this.#state === CircuitBreakerState.OPEN) {
return;
}
this.#state = CircuitBreakerState.OPEN;
log.warn(
`Excess errors detected, opening '${this.#name}' circuit breaker for ${this.#getBackoffTime() / 1000} second(s).`,
);
this.#timeoutId = setTimeout(() => this.#close(), this.#getBackoffTime());
this.#eventEmitter.emit('open');
}
#close() {
if (this.#state === CircuitBreakerState.CLOSED) {
return;
}
if (this.#timeoutId) {
clearTimeout(this.#timeoutId);
}
this.#state = CircuitBreakerState.CLOSED;
this.#eventEmitter.emit('close');
}
isOpen() {
return this.#state === CircuitBreakerState.OPEN;
}
success() {
this.#errorCount = 0;
this.#close();
}
onOpen(listener: () => void): Disposable {
this.#eventEmitter.on('open', listener);
return { dispose: () => this.#eventEmitter.removeListener('open', listener) };
}
onClose(listener: () => void): Disposable {
this.#eventEmitter.on('close', listener);
return { dispose: () => this.#eventEmitter.removeListener('close', listener) };
}
#getBackoffTime() {
return Math.min(
this.#initialBackoffMs * this.#backoffMultiplier ** (this.#errorCount - 1),
this.#maxBackoffMs,
);
}
}
References: |
You are a code assistant | Definition of 'RepositoryService' in file src/common/git/repository_service.ts in project gitlab-lsp | Definition:
export const RepositoryService = createInterfaceId<RepositoryService>('RepositoryService');
@Injectable(RepositoryService, [VirtualFileSystemService])
export class DefaultRepositoryService {
#virtualFileSystemService: DefaultVirtualFileSystemService;
constructor(virtualFileSystemService: DefaultVirtualFileSystemService) {
this.#virtualFileSystemService = virtualFileSystemService;
this.#setupEventListeners();
}
#setupEventListeners() {
return this.#virtualFileSystemService.onFileSystemEvent(async (eventType, data) => {
switch (eventType) {
case VirtualFileSystemEvents.WorkspaceFilesUpdate:
await this.#handleWorkspaceFilesUpdate(data as WorkspaceFilesUpdate);
break;
case VirtualFileSystemEvents.WorkspaceFileUpdate:
await this.#handleWorkspaceFileUpdate(data as WorkspaceFileUpdate);
break;
default:
break;
}
});
}
async #handleWorkspaceFilesUpdate(update: WorkspaceFilesUpdate) {
log.info(`Workspace files update: ${update.files.length}`);
const perf1 = performance.now();
await this.handleWorkspaceFilesUpdate({
...update,
});
const perf2 = performance.now();
log.info(`Workspace files initialization took ${perf2 - perf1}ms`);
const perf3 = performance.now();
const files = this.getFilesForWorkspace(update.workspaceFolder.uri, {
excludeGitFolder: true,
excludeIgnored: true,
});
const perf4 = performance.now();
log.info(`Fetched workspace files in ${perf4 - perf3}ms`);
log.info(`Workspace git files: ${files.length}`);
// const treeFile = await readFile(
// '/Users/angelo.rivera/gitlab/gitlab-development-kit/gitlab/tree.txt',
// 'utf-8',
// );
// const treeFiles = treeFile.split('\n').filter(Boolean);
// // get the set difference between the files in the tree and the non-ignored files
// // we need the difference between the two sets to know which files are not in the tree
// const diff = new Set(
// files.map((file) =>
// relative('/Users/angelo.rivera/gitlab/gitlab-development-kit/gitlab', file.uri.fsPath),
// ),
// );
// for (const file of treeFiles) {
// diff.delete(file);
// }
// log.info(`Files not in the tree.txt: ${JSON.stringify(Array.from(diff))}`);
}
async #handleWorkspaceFileUpdate(update: WorkspaceFileUpdate) {
log.info(`Workspace file update: ${JSON.stringify(update)}`);
await this.handleWorkspaceFileUpdate({
...update,
});
const perf1 = performance.now();
const files = this.getFilesForWorkspace(update.workspaceFolder.uri, {
excludeGitFolder: true,
excludeIgnored: true,
});
const perf2 = performance.now();
log.info(`Fetched workspace files in ${perf2 - perf1}ms`);
log.info(`Workspace git files: ${files.length}`);
}
/**
* unique map of workspace folders that point to a map of repositories
* We store separate repository maps for each workspace because
* the events from the VFS service are at the workspace level.
* If we combined them, we may get race conditions
*/
#workspaces: Map<WorkspaceFolderUri, RepositoryMap> = new Map();
#workspaceRepositoryTries: Map<WorkspaceFolderUri, RepositoryTrie> = new Map();
#buildRepositoryTrie(repositories: Repository[]): RepositoryTrie {
const root = new RepositoryTrie();
for (const repo of repositories) {
let node = root;
const parts = repo.uri.path.split('/').filter(Boolean);
for (const part of parts) {
if (!node.children.has(part)) {
node.children.set(part, new RepositoryTrie());
}
node = node.children.get(part) as RepositoryTrie;
}
node.repository = repo.uri;
}
return root;
}
findMatchingRepositoryUri(fileUri: URI, workspaceFolderUri: WorkspaceFolder): URI | null {
const trie = this.#workspaceRepositoryTries.get(workspaceFolderUri.uri);
if (!trie) return null;
let node = trie;
let lastMatchingRepo: URI | null = null;
const parts = fileUri.path.split('/').filter(Boolean);
for (const part of parts) {
if (node.repository) {
lastMatchingRepo = node.repository;
}
if (!node.children.has(part)) break;
node = node.children.get(part) as RepositoryTrie;
}
return node.repository || lastMatchingRepo;
}
getRepositoryFileForUri(
fileUri: URI,
repositoryUri: URI,
workspaceFolder: WorkspaceFolder,
): RepositoryFile | null {
const repository = this.#getRepositoriesForWorkspace(workspaceFolder.uri).get(
repositoryUri.toString(),
);
if (!repository) {
return null;
}
return repository.getFile(fileUri.toString()) ?? null;
}
#updateRepositoriesForFolder(
workspaceFolder: WorkspaceFolder,
repositoryMap: RepositoryMap,
repositoryTrie: RepositoryTrie,
) {
this.#workspaces.set(workspaceFolder.uri, repositoryMap);
this.#workspaceRepositoryTries.set(workspaceFolder.uri, repositoryTrie);
}
async handleWorkspaceFilesUpdate({ workspaceFolder, files }: WorkspaceFilesUpdate) {
// clear existing repositories from workspace
this.#emptyRepositoriesForWorkspace(workspaceFolder.uri);
const repositories = this.#detectRepositories(files, workspaceFolder);
const repositoryMap = new Map(repositories.map((repo) => [repo.uri.toString(), repo]));
// Build and cache the repository trie for this workspace
const trie = this.#buildRepositoryTrie(repositories);
this.#updateRepositoriesForFolder(workspaceFolder, repositoryMap, trie);
await Promise.all(
repositories.map((repo) =>
repo.addFilesAndLoadGitIgnore(
files.filter((file) => {
const matchingRepo = this.findMatchingRepositoryUri(file, workspaceFolder);
return matchingRepo && matchingRepo.toString() === repo.uri.toString();
}),
),
),
);
}
async handleWorkspaceFileUpdate({ fileUri, workspaceFolder, event }: WorkspaceFileUpdate) {
const repoUri = this.findMatchingRepositoryUri(fileUri, workspaceFolder);
if (!repoUri) {
log.debug(`No matching repository found for file ${fileUri.toString()}`);
return;
}
const repositoryMap = this.#getRepositoriesForWorkspace(workspaceFolder.uri);
const repository = repositoryMap.get(repoUri.toString());
if (!repository) {
log.debug(`Repository not found for URI ${repoUri.toString()}`);
return;
}
if (repository.isFileIgnored(fileUri)) {
log.debug(`File ${fileUri.toString()} is ignored`);
return;
}
switch (event) {
case 'add':
repository.setFile(fileUri);
log.debug(`File ${fileUri.toString()} added to repository ${repoUri.toString()}`);
break;
case 'change':
repository.setFile(fileUri);
log.debug(`File ${fileUri.toString()} updated in repository ${repoUri.toString()}`);
break;
case 'unlink':
repository.removeFile(fileUri.toString());
log.debug(`File ${fileUri.toString()} removed from repository ${repoUri.toString()}`);
break;
default:
log.warn(`Unknown file event ${event} for file ${fileUri.toString()}`);
}
}
#getRepositoriesForWorkspace(workspaceFolderUri: WorkspaceFolderUri): RepositoryMap {
return this.#workspaces.get(workspaceFolderUri) || new Map();
}
#emptyRepositoriesForWorkspace(workspaceFolderUri: WorkspaceFolderUri): void {
log.debug(`Emptying repositories for workspace ${workspaceFolderUri}`);
const repos = this.#workspaces.get(workspaceFolderUri);
if (!repos || repos.size === 0) return;
// clear up ignore manager trie from memory
repos.forEach((repo) => {
repo.dispose();
log.debug(`Repository ${repo.uri} has been disposed`);
});
repos.clear();
const trie = this.#workspaceRepositoryTries.get(workspaceFolderUri);
if (trie) {
trie.dispose();
this.#workspaceRepositoryTries.delete(workspaceFolderUri);
}
this.#workspaces.delete(workspaceFolderUri);
log.debug(`Repositories for workspace ${workspaceFolderUri} have been emptied`);
}
#detectRepositories(files: URI[], workspaceFolder: WorkspaceFolder): Repository[] {
const gitConfigFiles = files.filter((file) => file.toString().endsWith('.git/config'));
return gitConfigFiles.map((file) => {
const projectUri = fsPathToUri(file.path.replace('.git/config', ''));
const ignoreManager = new IgnoreManager(projectUri.fsPath);
log.info(`Detected repository at ${projectUri.path}`);
return new Repository({
ignoreManager,
uri: projectUri,
configFileUri: file,
workspaceFolder,
});
});
}
getFilesForWorkspace(
workspaceFolderUri: WorkspaceFolderUri,
options: { excludeGitFolder?: boolean; excludeIgnored?: boolean } = {},
): RepositoryFile[] {
const repositories = this.#getRepositoriesForWorkspace(workspaceFolderUri);
const allFiles: RepositoryFile[] = [];
repositories.forEach((repository) => {
repository.getFiles().forEach((file) => {
// apply the filters
if (options.excludeGitFolder && this.#isInGitFolder(file.uri, repository.uri)) {
return;
}
if (options.excludeIgnored && file.isIgnored) {
return;
}
allFiles.push(file);
});
});
return allFiles;
}
// Helper method to check if a file is in the .git folder
#isInGitFolder(fileUri: URI, repositoryUri: URI): boolean {
const relativePath = fileUri.path.slice(repositoryUri.path.length);
return relativePath.split('/').some((part) => part === '.git');
}
}
References: |
You are a code assistant | Definition of 'FileSystemEventMap' in file src/common/services/fs/virtual_file_service.ts in project gitlab-lsp | Definition:
export interface FileSystemEventMap {
[VirtualFileSystemEvents.WorkspaceFileUpdate]: WorkspaceFileUpdate;
[VirtualFileSystemEvents.WorkspaceFilesUpdate]: WorkspaceFilesUpdate;
}
export interface FileSystemEventListener {
<T extends VirtualFileSystemEvents>(eventType: T, data: FileSystemEventMap[T]): void;
}
export type VirtualFileSystemService = typeof DefaultVirtualFileSystemService.prototype;
export const VirtualFileSystemService = createInterfaceId<VirtualFileSystemService>(
'VirtualFileSystemService',
);
@Injectable(VirtualFileSystemService, [DirectoryWalker])
export class DefaultVirtualFileSystemService {
#directoryWalker: DirectoryWalker;
#emitter = new EventEmitter();
constructor(directoryWalker: DirectoryWalker) {
this.#directoryWalker = directoryWalker;
}
#handleFileChange: FileChangeHandler = (event, workspaceFolder, filePath) => {
const fileUri = fsPathToUri(filePath);
this.#emitFileSystemEvent(VirtualFileSystemEvents.WorkspaceFileUpdate, {
event,
fileUri,
workspaceFolder,
});
};
async initialize(workspaceFolders: WorkspaceFolder[]): Promise<void> {
await Promise.all(
workspaceFolders.map(async (workspaceFolder) => {
const files = await this.#directoryWalker.findFilesForDirectory({
directoryUri: workspaceFolder.uri,
});
this.#emitFileSystemEvent(VirtualFileSystemEvents.WorkspaceFilesUpdate, {
files,
workspaceFolder,
});
this.#directoryWalker.setupFileWatcher(workspaceFolder, this.#handleFileChange);
}),
);
}
#emitFileSystemEvent<T extends VirtualFileSystemEvents>(
eventType: T,
data: FileSystemEventMap[T],
) {
this.#emitter.emit(FILE_SYSTEM_EVENT_NAME, eventType, data);
}
onFileSystemEvent(listener: FileSystemEventListener) {
this.#emitter.on(FILE_SYSTEM_EVENT_NAME, listener);
return {
dispose: () => this.#emitter.removeListener(FILE_SYSTEM_EVENT_NAME, listener),
};
}
}
References: |
You are a code assistant | Definition of 'error' in file packages/lib_logging/src/types.ts in project gitlab-lsp | Definition:
error(message: string, e?: Error): void;
}
References:
- scripts/commit-lint/lint.js:72
- scripts/commit-lint/lint.js:77
- scripts/commit-lint/lint.js:85
- scripts/commit-lint/lint.js:94 |
You are a code assistant | Definition of 'retrieve' in file src/common/ai_context_management_2/retrievers/ai_context_retriever.ts in project gitlab-lsp | Definition:
retrieve(item: AiContextItem): Promise<string | null>;
}
References: |
You are a code assistant | Definition of 'API_RECOVERY_NOTIFICATION' in file src/common/circuit_breaker/circuit_breaker.ts in project gitlab-lsp | Definition:
export const API_RECOVERY_NOTIFICATION = '$/gitlab/api/recovered';
export enum CircuitBreakerState {
OPEN = 'Open',
CLOSED = 'Closed',
}
export interface CircuitBreaker {
error(): void;
success(): void;
isOpen(): boolean;
onOpen(listener: () => void): Disposable;
onClose(listener: () => void): Disposable;
}
References: |
You are a code assistant | Definition of 'GitlabRealm' in file src/common/tracking/tracking_types.ts in project gitlab-lsp | Definition:
export enum GitlabRealm {
saas = 'saas',
selfManaged = 'self-managed',
}
export enum SuggestionSource {
cache = 'cache',
network = 'network',
}
export interface IIDEInfo {
name: string;
version: string;
vendor: string;
}
export interface IClientContext {
ide?: IIDEInfo;
extension?: IClientInfo;
}
export interface ITelemetryOptions {
enabled?: boolean;
baseUrl?: string;
trackingUrl?: string;
actions?: Array<{ action: TRACKING_EVENTS }>;
ide?: IIDEInfo;
extension?: IClientInfo;
}
export interface ICodeSuggestionModel {
lang: string;
engine: string;
name: string;
tokens_consumption_metadata?: {
input_tokens?: number;
output_tokens?: number;
context_tokens_sent?: number;
context_tokens_used?: number;
};
}
export interface TelemetryTracker {
isEnabled(): boolean;
setCodeSuggestionsContext(
uniqueTrackingId: string,
context: Partial<ICodeSuggestionContextUpdate>,
): void;
updateCodeSuggestionsContext(
uniqueTrackingId: string,
contextUpdate: Partial<ICodeSuggestionContextUpdate>,
): void;
rejectOpenedSuggestions(): void;
updateSuggestionState(uniqueTrackingId: string, newState: TRACKING_EVENTS): void;
}
export const TelemetryTracker = createInterfaceId<TelemetryTracker>('TelemetryTracker');
References:
- src/common/tracking/snowplow_tracker.ts:154
- src/common/tracking/snowplow_tracker.ts:56 |
You are a code assistant | Definition of 'constructor' in file src/common/ai_context_management_2/providers/ai_file_context_provider.ts in project gitlab-lsp | Definition:
constructor(repositoryService: DefaultRepositoryService) {
this.#repositoryService = repositoryService;
}
async getProviderItems(
query: string,
workspaceFolders: WorkspaceFolder[],
): Promise<AiContextProviderItem[]> {
const items =
query.trim() === ''
? await this.#getOpenTabsItems()
: await this.#getSearchedItems(query, workspaceFolders);
log.info(`Found ${items.length} results for ${query}`);
return items;
}
async #getOpenTabsItems(): Promise<AiContextProviderItem[]> {
const resolutions: ContextResolution[] = [];
for await (const resolution of OpenTabsResolver.getInstance().buildContext({
includeCurrentFile: true,
})) {
resolutions.push(resolution);
}
return resolutions.map((resolution) => this.#providerItemForOpenTab(resolution));
}
async #getSearchedItems(
query: string,
workspaceFolders: WorkspaceFolder[],
): Promise<AiContextProviderItem[]> {
const allFiles: RepositoryFile[] = [];
for (const folder of workspaceFolders) {
const files = this.#repositoryService.getFilesForWorkspace(folder.uri, {
excludeGitFolder: true,
excludeIgnored: true,
});
allFiles.push(...files);
}
const fileNames = allFiles.map((file) => file.uri.fsPath);
const allFilesMap = new Map(allFiles.map((file) => [file.uri.fsPath, file]));
const results = filter(fileNames, query, { maxResults: 100 });
const resultFiles: RepositoryFile[] = [];
for (const result of results) {
if (allFilesMap.has(result)) {
resultFiles.push(allFilesMap.get(result) as RepositoryFile);
}
}
return resultFiles.map((file) => this.#providerItemForSearchResult(file));
}
#openTabResolutionToRepositoryFile(resolution: ContextResolution): [URI, RepositoryFile | null] {
const fileUri = parseURIString(resolution.uri);
const repo = this.#repositoryService.findMatchingRepositoryUri(
fileUri,
resolution.workspaceFolder,
);
if (!repo) {
log.warn(`Could not find repository for ${resolution.uri}`);
return [fileUri, null];
}
const repositoryFile = this.#repositoryService.getRepositoryFileForUri(
fileUri,
repo,
resolution.workspaceFolder,
);
if (!repositoryFile) {
log.warn(`Could not find repository file for ${resolution.uri}`);
return [fileUri, null];
}
return [fileUri, repositoryFile];
}
#providerItemForOpenTab(resolution: ContextResolution): AiContextProviderItem {
const [fileUri, repositoryFile] = this.#openTabResolutionToRepositoryFile(resolution);
return {
fileUri,
workspaceFolder: resolution.workspaceFolder,
providerType: 'file',
subType: 'open_tab',
repositoryFile,
};
}
#providerItemForSearchResult(repositoryFile: RepositoryFile): AiContextProviderItem {
return {
fileUri: repositoryFile.uri,
workspaceFolder: repositoryFile.workspaceFolder,
providerType: 'file',
subType: 'local_file_search',
repositoryFile,
};
}
}
References: |
You are a code assistant | Definition of 'GetRequest' in file src/common/api_types.ts in project gitlab-lsp | Definition:
interface GetRequest<_TReturnType> extends BaseRestRequest<_TReturnType> {
method: 'GET';
searchParams?: Record<string, string>;
supportedSinceInstanceVersion?: SupportedSinceInstanceVersion;
}
export type ApiRequest<_TReturnType> =
| GetRequest<_TReturnType>
| PostRequest<_TReturnType>
| GraphQLRequest<_TReturnType>;
export type AdditionalContext = {
/**
* The type of the context element. Options: `file` or `snippet`.
*/
type: 'file' | 'snippet';
/**
* The name of the context element. A name of the file or a code snippet.
*/
name: string;
/**
* The content of the context element. The body of the file or a function.
*/
content: string;
/**
* Where the context was derived from
*/
resolution_strategy: ContextResolution['strategy'];
};
// FIXME: Rename to SuggestionOptionText and then rename SuggestionOptionOrStream to SuggestionOption
// this refactor can't be done now (2024-05-28) because all the conflicts it would cause with WIP
export interface SuggestionOption {
index?: number;
text: string;
uniqueTrackingId: string;
lang?: string;
}
export interface TelemetryRequest {
event: string;
additional_properties: {
unique_tracking_id: string;
language?: string;
suggestion_size?: number;
timestamp: string;
};
}
References: |
You are a code assistant | Definition of 'FetchHeaders' in file src/common/fetch.ts in project gitlab-lsp | Definition:
export type FetchHeaders = {
[key: string]: string;
};
export interface LsFetch {
initialize(): Promise<void>;
destroy(): Promise<void>;
fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
fetchBase(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
delete(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
get(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
post(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
put(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
updateAgentOptions(options: FetchAgentOptions): void;
streamFetch(url: string, body: string, headers: FetchHeaders): AsyncGenerator<string, void, void>;
}
export const LsFetch = createInterfaceId<LsFetch>('LsFetch');
export class FetchBase implements LsFetch {
updateRequestInit(method: string, init?: RequestInit): RequestInit {
if (typeof init === 'undefined') {
// eslint-disable-next-line no-param-reassign
init = { method };
} else {
// eslint-disable-next-line no-param-reassign
init.method = method;
}
return init;
}
async initialize(): Promise<void> {}
async destroy(): Promise<void> {}
async fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return fetch(input, init);
}
async *streamFetch(
/* eslint-disable @typescript-eslint/no-unused-vars */
_url: string,
_body: string,
_headers: FetchHeaders,
/* eslint-enable @typescript-eslint/no-unused-vars */
): AsyncGenerator<string, void, void> {
// Stub. Should delegate to the node or browser fetch implementations
throw new Error('Not implemented');
yield '';
}
async delete(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('DELETE', init));
}
async get(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('GET', init));
}
async post(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('POST', init));
}
async put(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('PUT', init));
}
async fetchBase(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
// eslint-disable-next-line no-underscore-dangle, no-restricted-globals
const _global = typeof global === 'undefined' ? self : global;
return _global.fetch(input, init);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
updateAgentOptions(_opts: FetchAgentOptions): void {}
}
References:
- src/browser/fetch.ts:16
- src/common/fetch.ts:25
- src/node/fetch.ts:152
- src/common/fetch.ts:55 |
You are a code assistant | Definition of 'DocumentTransformerService' in file src/common/document_transformer_service.ts in project gitlab-lsp | Definition:
export const DocumentTransformerService = createInterfaceId<DocumentTransformerService>(
'DocumentTransformerService',
);
@Injectable(DocumentTransformerService, [LsTextDocuments, SecretRedactor])
export class DefaultDocumentTransformerService implements DocumentTransformerService {
#transformers: IDocTransformer[] = [];
#documents: LsTextDocuments;
constructor(documents: LsTextDocuments, secretRedactor: SecretRedactor) {
this.#documents = documents;
this.#transformers.push(secretRedactor);
}
get(uri: string) {
return this.#documents.get(uri);
}
getContext(
uri: string,
position: Position,
workspaceFolders: WorkspaceFolder[],
completionContext?: InlineCompletionContext,
): IDocContext | undefined {
const doc = this.get(uri);
if (doc === undefined) {
return undefined;
}
return this.transform(getDocContext(doc, position, workspaceFolders, completionContext));
}
transform(context: IDocContext): IDocContext {
return this.#transformers.reduce((ctx, transformer) => transformer.transform(ctx), context);
}
}
export function getDocContext(
document: TextDocument,
position: Position,
workspaceFolders: WorkspaceFolder[],
completionContext?: InlineCompletionContext,
): IDocContext {
let prefix: string;
if (completionContext?.selectedCompletionInfo) {
const { selectedCompletionInfo } = completionContext;
const range = sanitizeRange(selectedCompletionInfo.range);
prefix = `${document.getText({
start: document.positionAt(0),
end: range.start,
})}${selectedCompletionInfo.text}`;
} else {
prefix = document.getText({ start: document.positionAt(0), end: position });
}
const suffix = document.getText({
start: position,
end: document.positionAt(document.getText().length),
});
const workspaceFolder = getMatchingWorkspaceFolder(document.uri, workspaceFolders);
const fileRelativePath = getRelativePath(document.uri, workspaceFolder);
return {
prefix,
suffix,
fileRelativePath,
position,
uri: document.uri,
languageId: document.languageId,
workspaceFolder,
};
}
References:
- src/common/advanced_context/advanced_context_service.ts:36
- src/common/suggestion/suggestion_service.ts:125
- src/common/connection.ts:22
- src/common/advanced_context/advanced_context_service.ts:28
- src/common/suggestion/suggestion_service.ts:81 |
You are a code assistant | Definition of 'init' in file src/common/core/handlers/token_check_notifier.ts in project gitlab-lsp | Definition:
init(callback: NotifyFn<TokenCheckNotificationParams>) {
this.#notify = callback;
}
}
References: |
You are a code assistant | Definition of 'status' in file src/common/fetch_error.ts in project gitlab-lsp | Definition:
get status() {
return this.response.status;
}
isInvalidToken(): boolean {
return (
isInvalidTokenError(this.response, this.#body) || isInvalidRefresh(this.response, this.#body)
);
}
get details() {
const { message, stack } = this;
return {
message,
stack: stackToArray(stack),
response: {
status: this.response.status,
headers: this.response.headers,
body: this.#body,
},
};
}
}
export class TimeoutError extends Error {
constructor(url: URL | RequestInfo) {
const timeoutInSeconds = Math.round(REQUEST_TIMEOUT_MILLISECONDS / 1000);
super(
`Request to ${extractURL(url)} timed out after ${timeoutInSeconds} second${timeoutInSeconds === 1 ? '' : 's'}`,
);
}
}
export class InvalidInstanceVersionError extends Error {}
References: |
You are a code assistant | Definition of 'onRequest' in file packages/lib_webview_client/src/bus/provider/socket_io_message_bus.ts in project gitlab-lsp | Definition:
onRequest<T extends keyof TMessages['inbound']['requests'] & string>(
type: T,
handler: (
payload: TMessages['inbound']['requests'][T]['params'],
) => Promise<ExtractRequestResult<TMessages['inbound']['requests'][T]>>,
): Disposable {
return this.#requestHandlers.register(type, handler);
}
dispose() {
this.#socket.off(SOCKET_NOTIFICATION_CHANNEL, this.#handleNotificationMessage);
this.#socket.off(SOCKET_REQUEST_CHANNEL, this.#handleRequestMessage);
this.#socket.off(SOCKET_RESPONSE_CHANNEL, this.#handleResponseMessage);
this.#notificationHandlers.dispose();
this.#requestHandlers.dispose();
this.#pendingRequests.dispose();
}
#setupSocketEventHandlers = () => {
this.#socket.on(SOCKET_NOTIFICATION_CHANNEL, this.#handleNotificationMessage);
this.#socket.on(SOCKET_REQUEST_CHANNEL, this.#handleRequestMessage);
this.#socket.on(SOCKET_RESPONSE_CHANNEL, this.#handleResponseMessage);
};
#handleNotificationMessage = async (message: {
type: keyof TMessages['inbound']['notifications'] & string;
payload: unknown;
}) => {
await this.#notificationHandlers.handle(message.type, message.payload);
};
#handleRequestMessage = async (message: {
requestId: string;
event: keyof TMessages['inbound']['requests'] & string;
payload: unknown;
}) => {
const response = await this.#requestHandlers.handle(message.event, message.payload);
this.#socket.emit(SOCKET_RESPONSE_CHANNEL, {
requestId: message.requestId,
payload: response,
});
};
#handleResponseMessage = async (message: { requestId: string; payload: unknown }) => {
await this.#pendingRequests.handle(message.requestId, message.payload);
};
}
References: |
You are a code assistant | Definition of 'constructor' in file packages/lib_handler_registry/src/registry/hashed_registry.ts in project gitlab-lsp | Definition:
constructor(hashFunc: HashFunc<TKey>) {
this.#hashFunc = hashFunc;
this.#basicRegistry = new SimpleRegistry<THandler>();
}
get size() {
return this.#basicRegistry.size;
}
register(key: TKey, handler: THandler): Disposable {
const hash = this.#hashFunc(key);
return this.#basicRegistry.register(hash, handler);
}
has(key: TKey): boolean {
const hash = this.#hashFunc(key);
return this.#basicRegistry.has(hash);
}
async handle(key: TKey, ...args: Parameters<THandler>): Promise<ReturnType<THandler>> {
const hash = this.#hashFunc(key);
return this.#basicRegistry.handle(hash, ...args);
}
dispose() {
this.#basicRegistry.dispose();
}
}
References: |
You are a code assistant | Definition of 'debug' in file src/common/log_types.ts in project gitlab-lsp | Definition:
debug(e: Error): void;
debug(message: string, e?: Error): void;
info(e: Error): void;
info(message: string, e?: Error): void;
warn(e: Error): void;
warn(message: string, e?: Error): void;
error(e: Error): void;
error(message: string, e?: Error): void;
}
export const LOG_LEVEL = {
DEBUG: 'debug',
INFO: 'info',
WARNING: 'warning',
ERROR: 'error',
} as const;
export type LogLevel = (typeof LOG_LEVEL)[keyof typeof LOG_LEVEL];
References: |
You are a code assistant | Definition of 'START_WORKFLOW_NOTIFICATION' in file src/common/connection.ts in project gitlab-lsp | Definition:
export const START_WORKFLOW_NOTIFICATION = '$/gitlab/startWorkflow';
export const GET_WEBVIEW_METADATA_REQUEST = '$/gitlab/webview-metadata';
export function setup(
telemetryTracker: TelemetryTracker,
connection: Connection,
documentTransformerService: DocumentTransformerService,
apiClient: GitLabApiClient,
featureFlagService: FeatureFlagService,
configService: ConfigService,
{
treeSitterParser,
}: {
treeSitterParser: TreeSitterParser;
},
webviewMetadataProvider: WebviewMetadataProvider | undefined = undefined,
workflowAPI: WorkflowAPI | undefined = undefined,
duoProjectAccessChecker: DuoProjectAccessChecker,
duoProjectAccessCache: DuoProjectAccessCache,
virtualFileSystemService: VirtualFileSystemService,
) {
const suggestionService = new DefaultSuggestionService({
telemetryTracker,
connection,
configService,
api: apiClient,
featureFlagService,
treeSitterParser,
documentTransformerService,
duoProjectAccessChecker,
});
const messageHandler = new MessageHandler({
telemetryTracker,
connection,
configService,
featureFlagService,
duoProjectAccessCache,
virtualFileSystemService,
workflowAPI,
});
connection.onCompletion(suggestionService.completionHandler);
// TODO: does Visual Studio or Neovim need this? VS Code doesn't
connection.onCompletionResolve((item: CompletionItem) => item);
connection.onRequest(InlineCompletionRequest.type, suggestionService.inlineCompletionHandler);
connection.onDidChangeConfiguration(messageHandler.didChangeConfigurationHandler);
connection.onNotification(TELEMETRY_NOTIFICATION, messageHandler.telemetryNotificationHandler);
connection.onNotification(
START_WORKFLOW_NOTIFICATION,
messageHandler.startWorkflowNotificationHandler,
);
connection.onRequest(GET_WEBVIEW_METADATA_REQUEST, () => {
return webviewMetadataProvider?.getMetadata() ?? [];
});
connection.onShutdown(messageHandler.onShutdownHandler);
}
References: |
You are a code assistant | Definition of 'hasbinAllSync' in file src/tests/int/hasbin.ts in project gitlab-lsp | Definition:
export function hasbinAllSync(bins: string[]) {
return bins.every(hasbin.sync);
}
export function hasbinSome(bins: string[], done: (result: boolean) => void) {
async.some(bins, hasbin.async, done);
}
export function hasbinSomeSync(bins: string[]) {
return bins.some(hasbin.sync);
}
export function hasbinFirst(bins: string[], done: (result: boolean) => void) {
async.detect(bins, hasbin.async, function (result) {
done(result || false);
});
}
export function hasbinFirstSync(bins: string[]) {
const matched = bins.filter(hasbin.sync);
return matched.length ? matched[0] : false;
}
export function getPaths(bin: string) {
const envPath = process.env.PATH || '';
const envExt = process.env.PATHEXT || '';
return envPath
.replace(/["]+/g, '')
.split(delimiter)
.map(function (chunk) {
return envExt.split(delimiter).map(function (ext) {
return join(chunk, bin + ext);
});
})
.reduce(function (a, b) {
return a.concat(b);
});
}
export function fileExists(filePath: string, done: (result: boolean) => void) {
stat(filePath, function (error, stat) {
if (error) {
return done(false);
}
done(stat.isFile());
});
}
export function fileExistsSync(filePath: string) {
try {
return statSync(filePath).isFile();
} catch (error) {
return false;
}
}
References: |
You are a code assistant | Definition of 'Counter' in file packages/lib_di/src/index.test.ts in project gitlab-lsp | Definition:
class Counter implements A {
counter = globCount;
constructor() {
globCount++;
}
a = () => this.counter.toString();
}
container.instantiate(Counter);
container.instantiate(BImpl);
expect(container.get(A).a()).toBe('0');
});
});
describe('get', () => {
it('returns an instance of the interfaceId', () => {
container.instantiate(AImpl);
expect(container.get(A)).toBeInstanceOf(AImpl);
});
it('throws an error for missing dependency', () => {
container.instantiate();
expect(() => container.get(A)).toThrow(/Instance for interface 'A' is not in the container/);
});
});
});
References: |
You are a code assistant | Definition of 'TextDocumentChangeListenerType' in file src/common/text_document_change_listener_type.ts in project gitlab-lsp | Definition:
export enum TextDocumentChangeListenerType {
onDidOpen = 'onDidOpen',
onDidChangeContent = 'onDidChangeContent',
onDidSave = 'onDidSave',
onDidClose = 'onDidClose',
onDidSetActive = 'onDidSetActive',
}
References:
- src/common/document_service.ts:15
- src/common/feature_state/supported_language_check.test.ts:36
- src/common/advanced_context/advanced_context_service.ts:56
- src/common/security_diagnostics_publisher.ts:53
- src/common/document_service.ts:69 |
You are a code assistant | Definition of 'SecurityDiagnosticsPublisher' in file src/common/security_diagnostics_publisher.ts in project gitlab-lsp | Definition:
export const SecurityDiagnosticsPublisher = createInterfaceId<SecurityDiagnosticsPublisher>(
'SecurityDiagnosticsPublisher',
);
@Injectable(SecurityDiagnosticsPublisher, [FeatureFlagService, ConfigService, DocumentService])
export class DefaultSecurityDiagnosticsPublisher implements SecurityDiagnosticsPublisher {
#publish: DiagnosticsPublisherFn | undefined;
#opts?: ISecurityScannerOptions;
#featureFlagService: FeatureFlagService;
constructor(
featureFlagService: FeatureFlagService,
configService: ConfigService,
documentService: DocumentService,
) {
this.#featureFlagService = featureFlagService;
configService.onConfigChange((config: IConfig) => {
this.#opts = config.client.securityScannerOptions;
});
documentService.onDocumentChange(
async (
event: TextDocumentChangeEvent<TextDocument>,
handlerType: TextDocumentChangeListenerType,
) => {
if (handlerType === TextDocumentChangeListenerType.onDidSave) {
await this.#runSecurityScan(event.document);
}
},
);
}
init(callback: DiagnosticsPublisherFn): void {
this.#publish = callback;
}
async #runSecurityScan(document: TextDocument) {
try {
if (!this.#publish) {
throw new Error('The DefaultSecurityService has not been initialized. Call init first.');
}
if (!this.#featureFlagService.isClientFlagEnabled(ClientFeatureFlags.RemoteSecurityScans)) {
return;
}
if (!this.#opts?.enabled) {
return;
}
if (!this.#opts) {
return;
}
const url = this.#opts.serviceUrl ?? DEFAULT_SCANNER_SERVICE_URL;
if (url === '') {
return;
}
const content = document.getText();
const fileName = UriUtils.basename(URI.parse(document.uri));
const formData = new FormData();
const blob = new Blob([content]);
formData.append('file', blob, fileName);
const request = {
method: 'POST',
headers: {
Accept: 'application/json',
},
body: formData,
};
log.debug(`Executing request to url="${url}" with contents of "${fileName}"`);
const response = await fetch(url, request);
await handleFetchError(response, 'security scan');
const json = await response.json();
const { vulnerabilities: vulns } = json;
if (vulns == null || !Array.isArray(vulns)) {
return;
}
const diagnostics: Diagnostic[] = vulns.map((vuln: Vulnerability) => {
let message = `${vuln.name}\n\n${vuln.description.substring(0, 200)}`;
if (vuln.description.length > 200) {
message += '...';
}
const severity =
vuln.severity === 'high' ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning;
// TODO: Use a more precise range when it's available from the service.
return {
message,
range: {
start: {
line: vuln.location.start_line - 1,
character: 0,
},
end: {
line: vuln.location.end_line,
character: 0,
},
},
severity,
source: 'gitlab_security_scan',
};
});
await this.#publish({
uri: document.uri,
diagnostics,
});
} catch (error) {
log.warn('SecurityScan: failed to run security scan', error);
}
}
}
References:
- src/common/connection_service.ts:64
- src/common/security_diagnostics_publisher.test.ts:23 |
You are a code assistant | Definition of 'AiFileContextProvider' in file src/common/ai_context_management_2/providers/ai_file_context_provider.ts in project gitlab-lsp | Definition:
export interface AiFileContextProvider extends DefaultAiFileContextProvider {}
export const AiFileContextProvider =
createInterfaceId<AiFileContextProvider>('AiFileContextProvider');
@Injectable(AiFileContextProvider, [RepositoryService, DuoProjectAccessChecker])
export class DefaultAiFileContextProvider implements AiContextProvider {
#repositoryService: DefaultRepositoryService;
constructor(repositoryService: DefaultRepositoryService) {
this.#repositoryService = repositoryService;
}
async getProviderItems(
query: string,
workspaceFolders: WorkspaceFolder[],
): Promise<AiContextProviderItem[]> {
const items =
query.trim() === ''
? await this.#getOpenTabsItems()
: await this.#getSearchedItems(query, workspaceFolders);
log.info(`Found ${items.length} results for ${query}`);
return items;
}
async #getOpenTabsItems(): Promise<AiContextProviderItem[]> {
const resolutions: ContextResolution[] = [];
for await (const resolution of OpenTabsResolver.getInstance().buildContext({
includeCurrentFile: true,
})) {
resolutions.push(resolution);
}
return resolutions.map((resolution) => this.#providerItemForOpenTab(resolution));
}
async #getSearchedItems(
query: string,
workspaceFolders: WorkspaceFolder[],
): Promise<AiContextProviderItem[]> {
const allFiles: RepositoryFile[] = [];
for (const folder of workspaceFolders) {
const files = this.#repositoryService.getFilesForWorkspace(folder.uri, {
excludeGitFolder: true,
excludeIgnored: true,
});
allFiles.push(...files);
}
const fileNames = allFiles.map((file) => file.uri.fsPath);
const allFilesMap = new Map(allFiles.map((file) => [file.uri.fsPath, file]));
const results = filter(fileNames, query, { maxResults: 100 });
const resultFiles: RepositoryFile[] = [];
for (const result of results) {
if (allFilesMap.has(result)) {
resultFiles.push(allFilesMap.get(result) as RepositoryFile);
}
}
return resultFiles.map((file) => this.#providerItemForSearchResult(file));
}
#openTabResolutionToRepositoryFile(resolution: ContextResolution): [URI, RepositoryFile | null] {
const fileUri = parseURIString(resolution.uri);
const repo = this.#repositoryService.findMatchingRepositoryUri(
fileUri,
resolution.workspaceFolder,
);
if (!repo) {
log.warn(`Could not find repository for ${resolution.uri}`);
return [fileUri, null];
}
const repositoryFile = this.#repositoryService.getRepositoryFileForUri(
fileUri,
repo,
resolution.workspaceFolder,
);
if (!repositoryFile) {
log.warn(`Could not find repository file for ${resolution.uri}`);
return [fileUri, null];
}
return [fileUri, repositoryFile];
}
#providerItemForOpenTab(resolution: ContextResolution): AiContextProviderItem {
const [fileUri, repositoryFile] = this.#openTabResolutionToRepositoryFile(resolution);
return {
fileUri,
workspaceFolder: resolution.workspaceFolder,
providerType: 'file',
subType: 'open_tab',
repositoryFile,
};
}
#providerItemForSearchResult(repositoryFile: RepositoryFile): AiContextProviderItem {
return {
fileUri: repositoryFile.uri,
workspaceFolder: repositoryFile.workspaceFolder,
providerType: 'file',
subType: 'local_file_search',
repositoryFile,
};
}
}
References:
- src/common/ai_context_management_2/ai_context_aggregator.ts:24
- src/common/ai_context_management_2/ai_context_aggregator.ts:29 |
You are a code assistant | Definition of 'DefaultSecretRedactor' in file src/common/secret_redaction/index.ts in project gitlab-lsp | Definition:
export class DefaultSecretRedactor implements SecretRedactor {
#rules: IGitleaksRule[] = [];
#configService: ConfigService;
constructor(configService: ConfigService) {
this.#rules = rules.map((rule) => ({
...rule,
compiledRegex: new RegExp(convertToJavaScriptRegex(rule.regex), 'gmi'),
}));
this.#configService = configService;
}
transform(context: IDocContext): IDocContext {
if (this.#configService.get('client.codeCompletion.enableSecretRedaction')) {
return {
prefix: this.redactSecrets(context.prefix),
suffix: this.redactSecrets(context.suffix),
fileRelativePath: context.fileRelativePath,
position: context.position,
uri: context.uri,
languageId: context.languageId,
workspaceFolder: context.workspaceFolder,
};
}
return context;
}
redactSecrets(raw: string): string {
return this.#rules.reduce((redacted: string, rule: IGitleaksRule) => {
return this.#redactRuleSecret(redacted, rule);
}, raw);
}
#redactRuleSecret(str: string, rule: IGitleaksRule): string {
if (!rule.compiledRegex) return str;
if (!this.#keywordHit(rule, str)) {
return str;
}
const matches = [...str.matchAll(rule.compiledRegex)];
return matches.reduce((redacted: string, match: RegExpMatchArray) => {
const secret = match[rule.secretGroup ?? 0];
return redacted.replace(secret, '*'.repeat(secret.length));
}, str);
}
#keywordHit(rule: IGitleaksRule, raw: string) {
if (!rule.keywords?.length) {
return true;
}
for (const keyword of rule.keywords) {
if (raw.toLowerCase().includes(keyword)) {
return true;
}
}
return false;
}
}
References:
- src/common/secret_redaction/redactor.test.ts:25 |
You are a code assistant | Definition of 'ITelemetryOptions' in file src/common/tracking/tracking_types.ts in project gitlab-lsp | Definition:
export interface ITelemetryOptions {
enabled?: boolean;
baseUrl?: string;
trackingUrl?: string;
actions?: Array<{ action: TRACKING_EVENTS }>;
ide?: IIDEInfo;
extension?: IClientInfo;
}
export interface ICodeSuggestionModel {
lang: string;
engine: string;
name: string;
tokens_consumption_metadata?: {
input_tokens?: number;
output_tokens?: number;
context_tokens_sent?: number;
context_tokens_used?: number;
};
}
export interface TelemetryTracker {
isEnabled(): boolean;
setCodeSuggestionsContext(
uniqueTrackingId: string,
context: Partial<ICodeSuggestionContextUpdate>,
): void;
updateCodeSuggestionsContext(
uniqueTrackingId: string,
contextUpdate: Partial<ICodeSuggestionContextUpdate>,
): void;
rejectOpenedSuggestions(): void;
updateSuggestionState(uniqueTrackingId: string, newState: TRACKING_EVENTS): void;
}
export const TelemetryTracker = createInterfaceId<TelemetryTracker>('TelemetryTracker');
References:
- src/common/tracking/snowplow_tracker.ts:135
- src/common/config_service.ts:62
- src/common/tracking/instance_tracker.ts:39 |
You are a code assistant | Definition of 'MOCK_FILE_2' in file src/tests/int/test_utils.ts in project gitlab-lsp | Definition:
export const MOCK_FILE_2 = {
uri: `${WORKSPACE_FOLDER_URI}/some-other-file.js`,
languageId: 'javascript',
version: 0,
text: '',
};
declare global {
// eslint-disable-next-line @typescript-eslint/no-namespace
namespace jest {
interface Matchers<LspClient> {
toEventuallyContainChildProcessConsoleOutput(
expectedMessage: string,
timeoutMs?: number,
intervalMs?: number,
): Promise<LspClient>;
}
}
}
expect.extend({
/**
* Custom matcher to check the language client child process console output for an expected string.
* This is useful when an operation does not directly run some logic, (e.g. internally emits events
* which something later does the thing you're testing), so you cannot just await and check the output.
*
* await expect(lsClient).toEventuallyContainChildProcessConsoleOutput('foo');
*
* @param lsClient LspClient instance to check
* @param expectedMessage Message to check for
* @param timeoutMs How long to keep checking before test is considered failed
* @param intervalMs How frequently to check the log
*/
async toEventuallyContainChildProcessConsoleOutput(
lsClient: LspClient,
expectedMessage: string,
timeoutMs = 1000,
intervalMs = 25,
) {
const expectedResult = `Expected language service child process console output to contain "${expectedMessage}"`;
const checkOutput = () =>
lsClient.childProcessConsole.some((line) => line.includes(expectedMessage));
const sleep = () =>
new Promise((resolve) => {
setTimeout(resolve, intervalMs);
});
let remainingRetries = Math.ceil(timeoutMs / intervalMs);
while (remainingRetries > 0) {
if (checkOutput()) {
return {
message: () => expectedResult,
pass: true,
};
}
// eslint-disable-next-line no-await-in-loop
await sleep();
remainingRetries--;
}
return {
message: () => `"${expectedResult}", but it was not found within ${timeoutMs}ms`,
pass: false,
};
},
});
References: |
You are a code assistant | Definition of 'ApiReconfiguredData' in file src/common/api.ts in project gitlab-lsp | Definition:
export interface ApiReconfiguredData {
/** is the API client configured in a way that allows it to send request to the API */
isInValidState: boolean;
validationMessage?: string;
}
export interface GitLabApiClient {
checkToken(token: string | undefined): Promise<TokenCheckResponse>;
getCodeSuggestions(request: CodeSuggestionRequest): Promise<CodeSuggestionResponse | undefined>;
getStreamingCodeSuggestions(request: CodeSuggestionRequest): AsyncGenerator<string, void, void>;
fetchFromApi<TReturnType>(request: ApiRequest<TReturnType>): Promise<TReturnType>;
connectToCable(): Promise<ActionCableCable>;
onApiReconfigured(listener: (data: ApiReconfiguredData) => void): Disposable;
readonly instanceVersion?: string;
}
export const GitLabApiClient = createInterfaceId<GitLabApiClient>('GitLabApiClient');
export type GenerationType = 'comment' | 'small_file' | 'empty_function' | undefined;
export interface CodeSuggestionRequest {
prompt_version: number;
project_path: string;
model_provider?: string;
project_id: number;
current_file: CodeSuggestionRequestCurrentFile;
intent?: 'completion' | 'generation';
stream?: boolean;
/** how many suggestion options should the API return */
choices_count?: number;
/** additional context to provide to the model */
context?: AdditionalContext[];
/* A user's instructions for code suggestions. */
user_instruction?: string;
/* The backend can add additional prompt info based on the type of event */
generation_type?: GenerationType;
}
export interface CodeSuggestionRequestCurrentFile {
file_name: string;
content_above_cursor: string;
content_below_cursor: string;
}
export interface CodeSuggestionResponse {
choices?: SuggestionOption[];
model?: ICodeSuggestionModel;
status: number;
error?: string;
isDirectConnection?: boolean;
}
// FIXME: Rename to SuggestionOptionStream when renaming the SuggestionOption
export interface StartStreamOption {
uniqueTrackingId: string;
/** the streamId represents the beginning of a stream * */
streamId: string;
}
export type SuggestionOptionOrStream = SuggestionOption | StartStreamOption;
export interface PersonalAccessToken {
name: string;
scopes: string[];
active: boolean;
}
export interface OAuthToken {
scope: string[];
}
export interface TokenCheckResponse {
valid: boolean;
reason?: 'unknown' | 'not_active' | 'invalid_scopes';
message?: string;
}
export interface IDirectConnectionDetailsHeaders {
'X-Gitlab-Global-User-Id': string;
'X-Gitlab-Instance-Id': string;
'X-Gitlab-Host-Name': string;
'X-Gitlab-Saas-Duo-Pro-Namespace-Ids': string;
}
export interface IDirectConnectionModelDetails {
model_provider: string;
model_name: string;
}
export interface IDirectConnectionDetails {
base_url: string;
token: string;
expires_at: number;
headers: IDirectConnectionDetailsHeaders;
model_details: IDirectConnectionModelDetails;
}
const CONFIG_CHANGE_EVENT_NAME = 'apiReconfigured';
@Injectable(GitLabApiClient, [LsFetch, ConfigService])
export class GitLabAPI implements GitLabApiClient {
#token: string | undefined;
#baseURL: string;
#clientInfo?: IClientInfo;
#lsFetch: LsFetch;
#eventEmitter = new EventEmitter();
#configService: ConfigService;
#instanceVersion?: string;
constructor(lsFetch: LsFetch, configService: ConfigService) {
this.#baseURL = GITLAB_API_BASE_URL;
this.#lsFetch = lsFetch;
this.#configService = configService;
this.#configService.onConfigChange(async (config) => {
this.#clientInfo = configService.get('client.clientInfo');
this.#lsFetch.updateAgentOptions({
ignoreCertificateErrors: this.#configService.get('client.ignoreCertificateErrors') ?? false,
...(this.#configService.get('client.httpAgentOptions') ?? {}),
});
await this.configureApi(config.client);
});
}
onApiReconfigured(listener: (data: ApiReconfiguredData) => void): Disposable {
this.#eventEmitter.on(CONFIG_CHANGE_EVENT_NAME, listener);
return { dispose: () => this.#eventEmitter.removeListener(CONFIG_CHANGE_EVENT_NAME, listener) };
}
#fireApiReconfigured(isInValidState: boolean, validationMessage?: string) {
const data: ApiReconfiguredData = { isInValidState, validationMessage };
this.#eventEmitter.emit(CONFIG_CHANGE_EVENT_NAME, data);
}
async configureApi({
token,
baseUrl = GITLAB_API_BASE_URL,
}: {
token?: string;
baseUrl?: string;
}) {
if (this.#token === token && this.#baseURL === baseUrl) return;
this.#token = token;
this.#baseURL = baseUrl;
const { valid, reason, message } = await this.checkToken(this.#token);
let validationMessage;
if (!valid) {
this.#configService.set('client.token', undefined);
validationMessage = `Token is invalid. ${message}. Reason: ${reason}`;
log.warn(validationMessage);
} else {
log.info('Token is valid');
}
this.#instanceVersion = await this.#getGitLabInstanceVersion();
this.#fireApiReconfigured(valid, validationMessage);
}
#looksLikePatToken(token: string): boolean {
// OAuth tokens will be longer than 42 characters and PATs will be shorter.
return token.length < 42;
}
async #checkPatToken(token: string): Promise<TokenCheckResponse> {
const headers = this.#getDefaultHeaders(token);
const response = await this.#lsFetch.get(
`${this.#baseURL}/api/v4/personal_access_tokens/self`,
{ headers },
);
await handleFetchError(response, 'Information about personal access token');
const { active, scopes } = (await response.json()) as PersonalAccessToken;
if (!active) {
return {
valid: false,
reason: 'not_active',
message: 'Token is not active.',
};
}
if (!this.#hasValidScopes(scopes)) {
const joinedScopes = scopes.map((scope) => `'${scope}'`).join(', ');
return {
valid: false,
reason: 'invalid_scopes',
message: `Token has scope(s) ${joinedScopes} (needs 'api').`,
};
}
return { valid: true };
}
async #checkOAuthToken(token: string): Promise<TokenCheckResponse> {
const headers = this.#getDefaultHeaders(token);
const response = await this.#lsFetch.get(`${this.#baseURL}/oauth/token/info`, {
headers,
});
await handleFetchError(response, 'Information about OAuth token');
const { scope: scopes } = (await response.json()) as OAuthToken;
if (!this.#hasValidScopes(scopes)) {
const joinedScopes = scopes.map((scope) => `'${scope}'`).join(', ');
return {
valid: false,
reason: 'invalid_scopes',
message: `Token has scope(s) ${joinedScopes} (needs 'api').`,
};
}
return { valid: true };
}
async checkToken(token: string = ''): Promise<TokenCheckResponse> {
try {
if (this.#looksLikePatToken(token)) {
log.info('Checking token for PAT validity');
return await this.#checkPatToken(token);
}
log.info('Checking token for OAuth validity');
return await this.#checkOAuthToken(token);
} catch (err) {
log.error('Error performing token check', err);
return {
valid: false,
reason: 'unknown',
message: `Failed to check token: ${err}`,
};
}
}
#hasValidScopes(scopes: string[]): boolean {
return scopes.includes('api');
}
async getCodeSuggestions(
request: CodeSuggestionRequest,
): Promise<CodeSuggestionResponse | undefined> {
if (!this.#token) {
throw new Error('Token needs to be provided to request Code Suggestions');
}
const headers = {
...this.#getDefaultHeaders(this.#token),
'Content-Type': 'application/json',
};
const response = await this.#lsFetch.post(
`${this.#baseURL}/api/v4/code_suggestions/completions`,
{ headers, body: JSON.stringify(request) },
);
await handleFetchError(response, 'Code Suggestions');
const data = await response.json();
return { ...data, status: response.status };
}
async *getStreamingCodeSuggestions(
request: CodeSuggestionRequest,
): AsyncGenerator<string, void, void> {
if (!this.#token) {
throw new Error('Token needs to be provided to stream code suggestions');
}
const headers = {
...this.#getDefaultHeaders(this.#token),
'Content-Type': 'application/json',
};
yield* this.#lsFetch.streamFetch(
`${this.#baseURL}/api/v4/code_suggestions/completions`,
JSON.stringify(request),
headers,
);
}
async fetchFromApi<TReturnType>(request: ApiRequest<TReturnType>): Promise<TReturnType> {
if (!this.#token) {
return Promise.reject(new Error('Token needs to be provided to authorise API request.'));
}
if (
request.supportedSinceInstanceVersion &&
!this.#instanceVersionHigherOrEqualThen(request.supportedSinceInstanceVersion.version)
) {
return Promise.reject(
new InvalidInstanceVersionError(
`Can't ${request.supportedSinceInstanceVersion.resourceName} until your instance is upgraded to ${request.supportedSinceInstanceVersion.version} or higher.`,
),
);
}
if (request.type === 'graphql') {
return this.#graphqlRequest(request.query, request.variables);
}
switch (request.method) {
case 'GET':
return this.#fetch(request.path, request.searchParams, 'resource', request.headers);
case 'POST':
return this.#postFetch(request.path, 'resource', request.body, request.headers);
default:
// the type assertion is necessary because TS doesn't expect any other types
throw new Error(`Unknown request type ${(request as ApiRequest<unknown>).type}`);
}
}
async connectToCable(): Promise<ActionCableCable> {
const headers = this.#getDefaultHeaders(this.#token);
const websocketOptions = {
headers: {
...headers,
Origin: this.#baseURL,
},
};
return connectToCable(this.#baseURL, websocketOptions);
}
async #graphqlRequest<T = unknown, V extends Variables = Variables>(
document: RequestDocument,
variables?: V,
): Promise<T> {
const ensureEndsWithSlash = (url: string) => url.replace(/\/?$/, '/');
const endpoint = new URL('./api/graphql', ensureEndsWithSlash(this.#baseURL)).href; // supports GitLab instances that are on a custom path, e.g. "https://example.com/gitlab"
const graphqlFetch = async (
input: RequestInfo | URL,
init?: RequestInit,
): Promise<Response> => {
const url = input instanceof URL ? input.toString() : input;
return this.#lsFetch.post(url, {
...init,
headers: { ...headers, ...init?.headers },
});
};
const headers = this.#getDefaultHeaders(this.#token);
const client = new GraphQLClient(endpoint, {
headers,
fetch: graphqlFetch,
});
return client.request(document, variables);
}
async #fetch<T>(
apiResourcePath: string,
query: Record<string, QueryValue> = {},
resourceName = 'resource',
headers?: Record<string, string>,
): Promise<T> {
const url = `${this.#baseURL}/api/v4${apiResourcePath}${createQueryString(query)}`;
const result = await this.#lsFetch.get(url, {
headers: { ...this.#getDefaultHeaders(this.#token), ...headers },
});
await handleFetchError(result, resourceName);
return result.json() as Promise<T>;
}
async #postFetch<T>(
apiResourcePath: string,
resourceName = 'resource',
body?: unknown,
headers?: Record<string, string>,
): Promise<T> {
const url = `${this.#baseURL}/api/v4${apiResourcePath}`;
const response = await this.#lsFetch.post(url, {
headers: {
'Content-Type': 'application/json',
...this.#getDefaultHeaders(this.#token),
...headers,
},
body: JSON.stringify(body),
});
await handleFetchError(response, resourceName);
return response.json() as Promise<T>;
}
#getDefaultHeaders(token?: string) {
return {
Authorization: `Bearer ${token}`,
'User-Agent': `code-completions-language-server-experiment (${this.#clientInfo?.name}:${this.#clientInfo?.version})`,
'X-Gitlab-Language-Server-Version': getLanguageServerVersion(),
};
}
#instanceVersionHigherOrEqualThen(version: string): boolean {
if (!this.#instanceVersion) return false;
return semverCompare(this.#instanceVersion, version) >= 0;
}
async #getGitLabInstanceVersion(): Promise<string> {
if (!this.#token) {
return '';
}
const headers = this.#getDefaultHeaders(this.#token);
const response = await this.#lsFetch.get(`${this.#baseURL}/api/v4/version`, {
headers,
});
const { version } = await response.json();
return version;
}
get instanceVersion() {
return this.#instanceVersion;
}
}
References:
- src/common/api.ts:155
- src/common/api.ts:32
- src/common/core/handlers/token_check_notifier.test.ts:18
- src/common/suggestion_client/direct_connection_client.test.ts:100
- src/common/api.ts:149 |
You are a code assistant | Definition of 'trackStructEvent' in file src/common/tracking/snowplow/snowplow.ts in project gitlab-lsp | Definition:
public async trackStructEvent(
event: StructuredEvent,
context?: SelfDescribingJson[] | null,
): Promise<void> {
this.#tracker.track(buildStructEvent(event), context);
}
async stop() {
await this.#emitter.stop();
}
public destroy() {
Snowplow.#instance = undefined;
}
}
References: |
You are a code assistant | Definition of 'GetRequest' in file packages/webview_duo_chat/src/plugin/types.ts in project gitlab-lsp | Definition:
interface GetRequest<_TReturnType> extends BaseRestRequest<_TReturnType> {
method: 'GET';
searchParams?: Record<string, string>;
supportedSinceInstanceVersion?: SupportedSinceInstanceVersion;
}
export type ApiRequest<_TReturnType> =
| GetRequest<_TReturnType>
| PostRequest<_TReturnType>
| GraphQLRequest<_TReturnType>;
export interface GitLabApiClient {
fetchFromApi<TReturnType>(request: ApiRequest<TReturnType>): Promise<TReturnType>;
connectToCable(): Promise<Cable>;
}
References: |
You are a code assistant | Definition of 'ICodeSuggestionContextUpdate' in file src/common/tracking/tracking_types.ts in project gitlab-lsp | Definition:
export interface ICodeSuggestionContextUpdate {
documentContext: IDocContext;
source: SuggestionSource;
language: string;
isStreaming: boolean;
model: ICodeSuggestionModel;
status: number;
debounceInterval: number;
gitlab_global_user_id: string;
gitlab_instance_id: string;
gitlab_host_name: string;
gitlab_saas_duo_pro_namespace_ids: number[];
isInvoked: boolean;
optionsCount: number;
acceptedOption: number;
triggerKind: InlineCompletionTriggerKind;
additionalContexts: AdditionalContext[];
isDirectConnection: boolean;
suggestionOptions: SuggestionOption[];
}
export type IClientInfo = InitializeParams['clientInfo'];
export enum GitlabRealm {
saas = 'saas',
selfManaged = 'self-managed',
}
export enum SuggestionSource {
cache = 'cache',
network = 'network',
}
export interface IIDEInfo {
name: string;
version: string;
vendor: string;
}
export interface IClientContext {
ide?: IIDEInfo;
extension?: IClientInfo;
}
export interface ITelemetryOptions {
enabled?: boolean;
baseUrl?: string;
trackingUrl?: string;
actions?: Array<{ action: TRACKING_EVENTS }>;
ide?: IIDEInfo;
extension?: IClientInfo;
}
export interface ICodeSuggestionModel {
lang: string;
engine: string;
name: string;
tokens_consumption_metadata?: {
input_tokens?: number;
output_tokens?: number;
context_tokens_sent?: number;
context_tokens_used?: number;
};
}
export interface TelemetryTracker {
isEnabled(): boolean;
setCodeSuggestionsContext(
uniqueTrackingId: string,
context: Partial<ICodeSuggestionContextUpdate>,
): void;
updateCodeSuggestionsContext(
uniqueTrackingId: string,
contextUpdate: Partial<ICodeSuggestionContextUpdate>,
): void;
rejectOpenedSuggestions(): void;
updateSuggestionState(uniqueTrackingId: string, newState: TRACKING_EVENTS): void;
}
export const TelemetryTracker = createInterfaceId<TelemetryTracker>('TelemetryTracker');
References: |
You are a code assistant | Definition of 'constructor' in file src/common/ai_context_management_2/retrievers/ai_file_context_retriever.ts in project gitlab-lsp | Definition:
constructor(
private fileResolver: FileResolver,
private secretRedactor: SecretRedactor,
) {}
async retrieve(aiContextItem: AiContextItem): Promise<string | null> {
if (aiContextItem.type !== 'file') {
return null;
}
try {
log.info(`retrieving file ${aiContextItem.id}`);
const fileContent = await this.fileResolver.readFile({
fileUri: aiContextItem.id,
});
log.info(`redacting secrets for file ${aiContextItem.id}`);
const redactedContent = this.secretRedactor.redactSecrets(fileContent);
return redactedContent;
} catch (e) {
log.warn(`Failed to retrieve file ${aiContextItem.id}`, e);
return null;
}
}
}
References: |
You are a code assistant | Definition of 'SyncLoadScriptsPlugin' in file packages/lib_vite_common_config/vite.config.shared.ts in project gitlab-lsp | Definition:
export const SyncLoadScriptsPlugin = {
name: 'sync-load-scripts-plugin',
transformIndexHtml(html) {
const doc = NodeHtmlParser.parse(html);
const body = doc.querySelector('body');
doc.querySelectorAll('head script').forEach((script) => {
script.removeAttribute('type');
script.removeAttribute('crossorigin');
body?.appendChild(script);
});
return doc.toString();
},
};
export const HtmlTransformPlugin = {
name: 'html-transform',
transformIndexHtml(html) {
return html.replace('{{ svg placeholder }}', svgSpriteContent);
},
};
export const InlineSvgPlugin = {
name: 'inline-svg',
transform(code, id) {
if (id.endsWith('@gitlab/svgs/dist/icons.svg')) {
svgSpriteContent = fs.readFileSync(id, 'utf-8');
return 'export default ""';
}
if (id.match(/@gitlab\/svgs\/dist\/illustrations\/.*\.svg$/)) {
const base64Data = imageToBase64(id);
return `export default "data:image/svg+xml;base64,${base64Data}"`;
}
return code;
},
};
export function createViteConfigForWebview(name): UserConfig {
const outDir = path.resolve(__dirname, `../../../../out/webviews/${name}`);
return {
plugins: [vue2(), InlineSvgPlugin, SyncLoadScriptsPlugin, HtmlTransformPlugin],
resolve: {
alias: {
'@': fileURLToPath(new URL('./src/app', import.meta.url)),
},
},
root: './src/app',
base: '',
build: {
target: 'es2022',
emptyOutDir: true,
outDir,
rollupOptions: {
input: [path.join('src', 'app', 'index.html')],
},
},
};
}
References: |
You are a code assistant | Definition of 'IntentTestCase' in file src/tests/unit/tree_sitter/intent_resolver.test.ts in project gitlab-lsp | Definition:
type IntentTestCase = [TestType, Position, Intent];
/**
* Note: We use the language server procotol Ids here because `IDocContext` expects
* these Ids (which is passed into `ParseFile`) and because they are unique.
* `ParseFile` derives the tree sitter gramamr from the file's extension.
* Some grammars apply to multiple extensions, eg. `typescript` applies
* to both `.ts` and `.tsx`.
*/
const testCases: Array<[LanguageServerLanguageId, FileExtension, IntentTestCase[]]> = [
/* [ FIXME: add back support for vue
'vue',
'.vue', // ../../fixtures/intent/vue_comments.vue
[
['on_empty_comment', { line: 2, character: 9 }, 'completion'],
['after_empty_comment', { line: 3, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 30, character: 0 }, undefined],
// TODO: comments in the Vue `script` are not captured
// ['on_comment_in_empty_function', { line: 34, character: 33 }, 'completion'],
// ['after_comment_in_empty_function', { line: 35, character: 0 }, 'generation'],
],
], */
[
'typescript',
'.ts', // ../../fixtures/intent/typescript_comments.ts
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_jsdoc_comment', { line: 14, character: 21 }, 'completion'],
['on_jsdoc_comment', { line: 15, character: 3 }, 'completion'],
['after_jsdoc_comment', { line: 16, character: 0 }, 'generation'],
['no_comment_large_file', { line: 24, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 30, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 31, character: 0 }, 'generation'],
],
],
[
'typescriptreact',
'.tsx', // ../../fixtures/intent/typescriptreact_comments.tsx
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_jsdoc_comment', { line: 14, character: 21 }, 'completion'],
['on_jsdoc_comment', { line: 15, character: 3 }, 'completion'],
['after_jsdoc_comment', { line: 16, character: 0 }, 'generation'],
['no_comment_large_file', { line: 24, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 30, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 31, character: 0 }, 'generation'],
],
],
[
'javascript',
'.js', // ../../fixtures/intent/javascript_comments.js
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_jsdoc_comment', { line: 14, character: 21 }, 'completion'],
['on_jsdoc_comment', { line: 15, character: 3 }, 'completion'],
['after_jsdoc_comment', { line: 16, character: 0 }, 'generation'],
['no_comment_large_file', { line: 24, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 30, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 31, character: 0 }, 'generation'],
],
],
[
'javascriptreact',
'.jsx', // ../../fixtures/intent/javascriptreact_comments.jsx
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_jsdoc_comment', { line: 15, character: 25 }, 'completion'],
['on_jsdoc_comment', { line: 16, character: 3 }, 'completion'],
['after_jsdoc_comment', { line: 17, character: 0 }, 'generation'],
['no_comment_large_file', { line: 24, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 31, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 32, character: 0 }, 'generation'],
],
],
[
'ruby',
'.rb', // ../../fixtures/intent/ruby_comments.rb
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 9, character: 23 }, 'completion'],
['on_block_comment', { line: 10, character: 4 }, 'completion'],
['after_block_comment', { line: 11, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 21, character: 30 }, 'completion'],
['after_comment_in_empty_function', { line: 22, character: 22 }, 'generation'],
],
],
[
'go',
'.go', // ../../fixtures/intent/go_comments.go
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 20, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 24, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 25, character: 0 }, 'generation'],
],
],
[
'java',
'.java', // ../../fixtures/intent/java_comments.java
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_doc_comment', { line: 14, character: 29 }, 'completion'],
['on_doc_comment', { line: 15, character: 3 }, 'completion'],
['after_doc_comment', { line: 16, character: 0 }, 'generation'],
['no_comment_large_file', { line: 23, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 30, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 31, character: 0 }, 'generation'],
],
],
[
'kotlin',
'.kt', // ../../fixtures/intent/kotlin_comments.kt
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_doc_comment', { line: 14, character: 29 }, 'completion'],
['on_doc_comment', { line: 15, character: 3 }, 'completion'],
['after_doc_comment', { line: 16, character: 0 }, 'generation'],
['no_comment_large_file', { line: 23, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 30, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 31, character: 0 }, 'generation'],
],
],
[
'rust',
'.rs', // ../../fixtures/intent/rust_comments.rs
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['in_doc_comment', { line: 11, character: 25 }, 'completion'],
['on_doc_comment', { line: 12, character: 42 }, 'completion'],
['after_doc_comment', { line: 15, character: 0 }, 'generation'],
['no_comment_large_file', { line: 23, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 26, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 27, character: 0 }, 'generation'],
],
],
[
'yaml',
'.yaml', // ../../fixtures/intent/yaml_comments.yaml
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
],
],
[
'html',
'.html', // ../../fixtures/intent/html_comments.html
[
['on_empty_comment', { line: 14, character: 12 }, 'completion'],
['after_empty_comment', { line: 15, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 8, character: 91 }, 'completion'],
['after_non_empty_comment', { line: 9, character: 0 }, 'generation'],
['in_block_comment', { line: 18, character: 29 }, 'completion'],
['on_block_comment', { line: 19, character: 7 }, 'completion'],
['after_block_comment', { line: 20, character: 0 }, 'generation'],
['no_comment_large_file', { line: 12, character: 66 }, undefined],
],
],
[
'c',
'.c', // ../../fixtures/intent/c_comments.c
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 20, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 21, character: 0 }, 'generation'],
],
],
[
'cpp',
'.cpp', // ../../fixtures/intent/cpp_comments.cpp
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 20, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 21, character: 0 }, 'generation'],
],
],
[
'c_sharp',
'.cs', // ../../fixtures/intent/c_sharp_comments.cs
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 4, character: 30 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['in_block_comment', { line: 8, character: 23 }, 'completion'],
['on_block_comment', { line: 9, character: 2 }, 'completion'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 20, character: 31 }, 'completion'],
['after_comment_in_empty_function', { line: 21, character: 22 }, 'generation'],
],
],
[
'css',
'.css', // ../../fixtures/intent/css_comments.css
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 3, character: 31 }, 'completion'],
['after_non_empty_comment', { line: 4, character: 0 }, 'generation'],
['in_block_comment', { line: 7, character: 23 }, 'completion'],
['on_block_comment', { line: 8, character: 2 }, 'completion'],
['after_block_comment', { line: 9, character: 0 }, 'generation'],
['no_comment_large_file', { line: 17, character: 0 }, undefined],
],
],
[
'bash',
'.sh', // ../../fixtures/intent/bash_comments.css
[
['on_empty_comment', { line: 4, character: 1 }, 'completion'],
['after_empty_comment', { line: 5, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 2, character: 65 }, 'completion'],
['after_non_empty_comment', { line: 3, character: 0 }, 'generation'],
['no_comment_large_file', { line: 10, character: 0 }, undefined],
['on_comment_in_empty_function', { line: 19, character: 12 }, 'completion'],
['after_comment_in_empty_function', { line: 20, character: 0 }, 'generation'],
],
],
[
'json',
'.json', // ../../fixtures/intent/json_comments.css
[
['on_empty_comment', { line: 20, character: 3 }, 'completion'],
['after_empty_comment', { line: 21, character: 0 }, 'completion'],
['on_non_empty_comment', { line: 0, character: 38 }, 'completion'],
['after_non_empty_comment', { line: 1, character: 0 }, 'generation'],
['no_comment_large_file', { line: 10, character: 0 }, undefined],
],
],
[
'scala',
'.scala', // ../../fixtures/intent/scala_comments.scala
[
['on_empty_comment', { line: 1, character: 3 }, 'completion'],
['after_empty_comment', { line: 2, character: 3 }, 'completion'],
['after_non_empty_comment', { line: 5, character: 0 }, 'generation'],
['after_block_comment', { line: 10, character: 0 }, 'generation'],
['no_comment_large_file', { line: 12, character: 0 }, undefined],
['after_comment_in_empty_function', { line: 21, character: 0 }, 'generation'],
],
],
[
'powersell',
'.ps1', // ../../fixtures/intent/powershell_comments.ps1
[
['on_empty_comment', { line: 20, character: 3 }, 'completion'],
['after_empty_comment', { line: 21, character: 3 }, 'completion'],
['after_non_empty_comment', { line: 10, character: 0 }, 'generation'],
['after_block_comment', { line: 8, character: 0 }, 'generation'],
['no_comment_large_file', { line: 22, character: 0 }, undefined],
['after_comment_in_empty_function', { line: 26, character: 0 }, 'generation'],
],
],
];
describe.each(testCases)('%s', (language, fileExt, cases) => {
it.each(cases)('should resolve %s intent correctly', async (_, position, expectedIntent) => {
const fixturePath = getFixturePath('intent', `${language}_comments${fileExt}`);
const { treeAndLanguage, prefix, suffix } = await getTreeAndTestFile({
fixturePath,
position,
languageId: language,
});
const intent = await getIntent({ treeAndLanguage, position, prefix, suffix });
expect(intent.intent).toBe(expectedIntent);
if (expectedIntent === 'generation') {
expect(intent.generationType).toBe('comment');
}
});
});
});
describe('Empty Function Intent', () => {
type TestType =
| 'empty_function_declaration'
| 'non_empty_function_declaration'
| 'empty_function_expression'
| 'non_empty_function_expression'
| 'empty_arrow_function'
| 'non_empty_arrow_function'
| 'empty_method_definition'
| 'non_empty_method_definition'
| 'empty_class_constructor'
| 'non_empty_class_constructor'
| 'empty_class_declaration'
| 'non_empty_class_declaration'
| 'empty_anonymous_function'
| 'non_empty_anonymous_function'
| 'empty_implementation'
| 'non_empty_implementation'
| 'empty_closure_expression'
| 'non_empty_closure_expression'
| 'empty_generator'
| 'non_empty_generator'
| 'empty_macro'
| 'non_empty_macro';
type FileExtension = string;
/**
* Position refers to the position of the cursor in the test file.
*/
type IntentTestCase = [TestType, Position, Intent];
const emptyFunctionTestCases: Array<
[LanguageServerLanguageId, FileExtension, IntentTestCase[]]
> = [
[
'typescript',
'.ts', // ../../fixtures/intent/empty_function/typescript.ts
[
['empty_function_declaration', { line: 0, character: 22 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_function_expression', { line: 6, character: 32 }, 'generation'],
['non_empty_function_expression', { line: 10, character: 4 }, undefined],
['empty_arrow_function', { line: 12, character: 26 }, 'generation'],
['non_empty_arrow_function', { line: 15, character: 4 }, undefined],
['empty_class_constructor', { line: 19, character: 21 }, 'generation'],
['empty_method_definition', { line: 21, character: 11 }, 'generation'],
['non_empty_class_constructor', { line: 29, character: 7 }, undefined],
['non_empty_method_definition', { line: 33, character: 0 }, undefined],
['empty_class_declaration', { line: 36, character: 14 }, 'generation'],
['empty_generator', { line: 38, character: 31 }, 'generation'],
['non_empty_generator', { line: 41, character: 4 }, undefined],
],
],
[
'javascript',
'.js', // ../../fixtures/intent/empty_function/javascript.js
[
['empty_function_declaration', { line: 0, character: 22 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_function_expression', { line: 6, character: 32 }, 'generation'],
['non_empty_function_expression', { line: 10, character: 4 }, undefined],
['empty_arrow_function', { line: 12, character: 26 }, 'generation'],
['non_empty_arrow_function', { line: 15, character: 4 }, undefined],
['empty_class_constructor', { line: 19, character: 21 }, 'generation'],
['empty_method_definition', { line: 21, character: 11 }, 'generation'],
['non_empty_class_constructor', { line: 27, character: 7 }, undefined],
['non_empty_method_definition', { line: 31, character: 0 }, undefined],
['empty_class_declaration', { line: 34, character: 14 }, 'generation'],
['empty_generator', { line: 36, character: 31 }, 'generation'],
['non_empty_generator', { line: 39, character: 4 }, undefined],
],
],
[
'go',
'.go', // ../../fixtures/intent/empty_function/go.go
[
['empty_function_declaration', { line: 0, character: 25 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_anonymous_function', { line: 6, character: 32 }, 'generation'],
['non_empty_anonymous_function', { line: 10, character: 0 }, undefined],
['empty_method_definition', { line: 19, character: 25 }, 'generation'],
['non_empty_method_definition', { line: 23, character: 0 }, undefined],
],
],
[
'java',
'.java', // ../../fixtures/intent/empty_function/java.java
[
['empty_function_declaration', { line: 0, character: 26 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_anonymous_function', { line: 7, character: 0 }, 'generation'],
['non_empty_anonymous_function', { line: 10, character: 0 }, undefined],
['empty_class_declaration', { line: 15, character: 18 }, 'generation'],
['non_empty_class_declaration', { line: 19, character: 0 }, undefined],
['empty_class_constructor', { line: 18, character: 13 }, 'generation'],
['empty_method_definition', { line: 20, character: 18 }, 'generation'],
['non_empty_class_constructor', { line: 26, character: 18 }, undefined],
['non_empty_method_definition', { line: 30, character: 18 }, undefined],
],
],
[
'rust',
'.rs', // ../../fixtures/intent/empty_function/rust.vue
[
['empty_function_declaration', { line: 0, character: 23 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_implementation', { line: 8, character: 13 }, 'generation'],
['non_empty_implementation', { line: 11, character: 0 }, undefined],
['empty_class_constructor', { line: 13, character: 0 }, 'generation'],
['non_empty_class_constructor', { line: 23, character: 0 }, undefined],
['empty_method_definition', { line: 17, character: 0 }, 'generation'],
['non_empty_method_definition', { line: 26, character: 0 }, undefined],
['empty_closure_expression', { line: 32, character: 0 }, 'generation'],
['non_empty_closure_expression', { line: 36, character: 0 }, undefined],
['empty_macro', { line: 42, character: 11 }, 'generation'],
['non_empty_macro', { line: 45, character: 11 }, undefined],
['empty_macro', { line: 55, character: 0 }, 'generation'],
['non_empty_macro', { line: 62, character: 20 }, undefined],
],
],
[
'kotlin',
'.kt', // ../../fixtures/intent/empty_function/kotlin.kt
[
['empty_function_declaration', { line: 0, character: 25 }, 'generation'],
['non_empty_function_declaration', { line: 4, character: 0 }, undefined],
['empty_anonymous_function', { line: 6, character: 32 }, 'generation'],
['non_empty_anonymous_function', { line: 9, character: 4 }, undefined],
['empty_class_declaration', { line: 12, character: 14 }, 'generation'],
['non_empty_class_declaration', { line: 15, character: 14 }, undefined],
['empty_method_definition', { line: 24, character: 0 }, 'generation'],
['non_empty_method_definition', { line: 28, character: 0 }, undefined],
],
],
[
'typescriptreact',
'.tsx', // ../../fixtures/intent/empty_function/typescriptreact.tsx
[
['empty_function_declaration', { line: 0, character: 22 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 4 }, undefined],
['empty_function_expression', { line: 6, character: 32 }, 'generation'],
['non_empty_function_expression', { line: 10, character: 4 }, undefined],
['empty_arrow_function', { line: 12, character: 26 }, 'generation'],
['non_empty_arrow_function', { line: 15, character: 4 }, undefined],
['empty_class_constructor', { line: 19, character: 21 }, 'generation'],
['empty_method_definition', { line: 21, character: 11 }, 'generation'],
['non_empty_class_constructor', { line: 29, character: 7 }, undefined],
['non_empty_method_definition', { line: 33, character: 0 }, undefined],
['empty_class_declaration', { line: 36, character: 14 }, 'generation'],
['non_empty_arrow_function', { line: 40, character: 0 }, undefined],
['empty_arrow_function', { line: 41, character: 23 }, 'generation'],
['non_empty_arrow_function', { line: 44, character: 23 }, undefined],
['empty_generator', { line: 54, character: 31 }, 'generation'],
['non_empty_generator', { line: 57, character: 4 }, undefined],
],
],
[
'c',
'.c', // ../../fixtures/intent/empty_function/c.c
[
['empty_function_declaration', { line: 0, character: 24 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 0 }, undefined],
],
],
[
'cpp',
'.cpp', // ../../fixtures/intent/empty_function/cpp.cpp
[
['empty_function_declaration', { line: 0, character: 37 }, 'generation'],
['non_empty_function_declaration', { line: 3, character: 0 }, undefined],
['empty_function_expression', { line: 6, character: 43 }, 'generation'],
['non_empty_function_expression', { line: 10, character: 4 }, undefined],
['empty_class_constructor', { line: 15, character: 37 }, 'generation'],
['empty_method_definition', { line: 17, character: 18 }, 'generation'],
['non_empty_class_constructor', { line: 27, character: 7 }, undefined],
['non_empty_method_definition', { line: 31, character: 0 }, undefined],
['empty_class_declaration', { line: 35, character: 14 }, 'generation'],
],
],
[
'c_sharp',
'.cs', // ../../fixtures/intent/empty_function/c_sharp.cs
[
['empty_function_expression', { line: 2, character: 48 }, 'generation'],
['empty_class_constructor', { line: 4, character: 31 }, 'generation'],
['empty_method_definition', { line: 6, character: 31 }, 'generation'],
['non_empty_class_constructor', { line: 15, character: 0 }, undefined],
['non_empty_method_definition', { line: 20, character: 0 }, undefined],
['empty_class_declaration', { line: 24, character: 22 }, 'generation'],
],
],
[
'bash',
'.sh', // ../../fixtures/intent/empty_function/bash.sh
[
['empty_function_declaration', { line: 3, character: 48 }, 'generation'],
['non_empty_function_declaration', { line: 6, character: 31 }, undefined],
],
],
[
'scala',
'.scala', // ../../fixtures/intent/empty_function/scala.scala
[
['empty_function_declaration', { line: 1, character: 4 }, 'generation'],
['non_empty_function_declaration', { line: 5, character: 4 }, undefined],
['empty_method_definition', { line: 28, character: 3 }, 'generation'],
['non_empty_method_definition', { line: 34, character: 3 }, undefined],
['empty_class_declaration', { line: 22, character: 4 }, 'generation'],
['non_empty_class_declaration', { line: 27, character: 0 }, undefined],
['empty_anonymous_function', { line: 13, character: 0 }, 'generation'],
['non_empty_anonymous_function', { line: 17, character: 0 }, undefined],
],
],
[
'ruby',
'.rb', // ../../fixtures/intent/empty_function/ruby.rb
[
['empty_method_definition', { line: 0, character: 23 }, 'generation'],
['empty_method_definition', { line: 0, character: 6 }, undefined],
['non_empty_method_definition', { line: 3, character: 0 }, undefined],
['empty_anonymous_function', { line: 7, character: 27 }, 'generation'],
['non_empty_anonymous_function', { line: 9, character: 37 }, undefined],
['empty_anonymous_function', { line: 11, character: 25 }, 'generation'],
['empty_class_constructor', { line: 16, character: 22 }, 'generation'],
['non_empty_class_declaration', { line: 18, character: 0 }, undefined],
['empty_method_definition', { line: 20, character: 1 }, 'generation'],
['empty_class_declaration', { line: 33, character: 12 }, 'generation'],
],
],
[
'python',
'.py', // ../../fixtures/intent/empty_function/python.py
[
['empty_function_declaration', { line: 1, character: 4 }, 'generation'],
['non_empty_function_declaration', { line: 5, character: 4 }, undefined],
['empty_class_constructor', { line: 10, character: 0 }, 'generation'],
['empty_method_definition', { line: 14, character: 0 }, 'generation'],
['non_empty_class_constructor', { line: 19, character: 0 }, undefined],
['non_empty_method_definition', { line: 23, character: 4 }, undefined],
['empty_class_declaration', { line: 27, character: 4 }, 'generation'],
['empty_function_declaration', { line: 31, character: 4 }, 'generation'],
['empty_class_constructor', { line: 36, character: 4 }, 'generation'],
['empty_method_definition', { line: 40, character: 4 }, 'generation'],
['empty_class_declaration', { line: 44, character: 4 }, 'generation'],
['empty_function_declaration', { line: 49, character: 4 }, 'generation'],
['empty_class_constructor', { line: 53, character: 4 }, 'generation'],
['empty_method_definition', { line: 56, character: 4 }, 'generation'],
['empty_class_declaration', { line: 59, character: 4 }, 'generation'],
],
],
];
describe.each(emptyFunctionTestCases)('%s', (language, fileExt, cases) => {
it.each(cases)('should resolve %s intent correctly', async (_, position, expectedIntent) => {
const fixturePath = getFixturePath('intent', `empty_function/${language}${fileExt}`);
const { treeAndLanguage, prefix, suffix } = await getTreeAndTestFile({
fixturePath,
position,
languageId: language,
});
const intent = await getIntent({ treeAndLanguage, position, prefix, suffix });
expect(intent.intent).toBe(expectedIntent);
if (expectedIntent === 'generation') {
expect(intent.generationType).toBe('empty_function');
}
});
});
});
});
References: |
You are a code assistant | Definition of 'getFixturePath' in file src/tests/unit/tree_sitter/test_utils.ts in project gitlab-lsp | Definition:
export const getFixturePath = (category: Category, filePath: string) =>
resolve(cwd(), 'src', 'tests', 'fixtures', category, filePath);
/**
* Use this function to get the test file and tree for a given fixture file
* to be used for Tree Sitter testing purposes.
*/
export const getTreeAndTestFile = async ({
fixturePath,
position,
languageId,
}: {
fixturePath: string;
position: Position;
languageId: LanguageServerLanguageId;
}) => {
const parser = new DesktopTreeSitterParser();
const fullText = await readFile(fixturePath, 'utf8');
const { prefix, suffix } = splitTextFileForPosition(fullText, position);
const documentContext = {
uri: fsPathToUri(fixturePath),
prefix,
suffix,
position,
languageId,
fileRelativePath: resolve(cwd(), fixturePath),
workspaceFolder: {
uri: 'file:///',
name: 'test',
},
} satisfies IDocContext;
const treeAndLanguage = await parser.parseFile(documentContext);
if (!treeAndLanguage) {
throw new Error('Failed to parse file');
}
return { prefix, suffix, fullText, treeAndLanguage };
};
/**
* Mimics the "prefix" and "suffix" according
* to the position in the text file.
*/
export const splitTextFileForPosition = (text: string, position: Position) => {
const lines = text.split('\n');
// Ensure the position is within bounds
const maxRow = lines.length - 1;
const row = Math.min(position.line, maxRow);
const maxColumn = lines[row]?.length || 0;
const column = Math.min(position.character, maxColumn);
// Get the part of the current line before the cursor and after the cursor
const prefixLine = lines[row].slice(0, column);
const suffixLine = lines[row].slice(column);
// Combine lines before the current row for the prefix
const prefixLines = lines.slice(0, row).concat(prefixLine);
const prefix = prefixLines.join('\n');
// Combine lines after the current row for the suffix
const suffixLines = [suffixLine].concat(lines.slice(row + 1));
const suffix = suffixLines.join('\n');
return { prefix, suffix };
};
References:
- src/tests/unit/tree_sitter/intent_resolver.test.ts:664
- src/tests/unit/tree_sitter/intent_resolver.test.ts:26
- src/tests/unit/tree_sitter/intent_resolver.test.ts:394
- src/tests/unit/tree_sitter/intent_resolver.test.ts:13 |
You are a code assistant | Definition of 'isCursorInEmptyFunction' in file src/common/tree_sitter/empty_function/empty_function_resolver.ts in project gitlab-lsp | Definition:
isCursorInEmptyFunction({
languageName,
tree,
cursorPosition,
treeSitterLanguage,
}: {
languageName: TreeSitterLanguageName;
tree: Tree;
treeSitterLanguage: Language;
cursorPosition: Point;
}): boolean {
const query = this.#getQueryByLanguage(languageName, treeSitterLanguage);
if (!query) {
return false;
}
const emptyBodyPositions = query.captures(tree.rootNode).map((capture) => {
return EmptyFunctionResolver.#findEmptyBodyPosition(capture.node);
});
const cursorInsideInOneOfTheCaptures = emptyBodyPositions.some(
(emptyBody) =>
EmptyFunctionResolver.#isValidBodyPosition(emptyBody) &&
EmptyFunctionResolver.#isCursorInsideNode(
cursorPosition,
emptyBody.startPosition,
emptyBody.endPosition,
),
);
return (
cursorInsideInOneOfTheCaptures ||
EmptyFunctionResolver.isCursorAfterEmptyPythonFunction({
languageName,
tree,
treeSitterLanguage,
cursorPosition,
})
);
}
static #isCursorInsideNode(
cursorPosition: Point,
startPosition: Point,
endPosition: Point,
): boolean {
const { row: cursorRow, column: cursorColumn } = cursorPosition;
const isCursorAfterNodeStart =
cursorRow > startPosition.row ||
(cursorRow === startPosition.row && cursorColumn >= startPosition.column);
const isCursorBeforeNodeEnd =
cursorRow < endPosition.row ||
(cursorRow === endPosition.row && cursorColumn <= endPosition.column);
return isCursorAfterNodeStart && isCursorBeforeNodeEnd;
}
static #isCursorRightAfterNode(cursorPosition: Point, endPosition: Point): boolean {
const { row: cursorRow, column: cursorColumn } = cursorPosition;
const isCursorRightAfterNode =
cursorRow - endPosition.row === 1 ||
(cursorRow === endPosition.row && cursorColumn > endPosition.column);
return isCursorRightAfterNode;
}
static #findEmptyBodyPosition(node: SyntaxNode): { startPosition?: Point; endPosition?: Point } {
const startPosition = node.lastChild?.previousSibling?.endPosition;
const endPosition = node.lastChild?.startPosition;
return { startPosition, endPosition };
}
static #isValidBodyPosition(arg: {
startPosition?: Point;
endPosition?: Point;
}): arg is { startPosition: Point; endPosition: Point } {
return !isUndefined(arg.startPosition) && !isUndefined(arg.endPosition);
}
static isCursorAfterEmptyPythonFunction({
languageName,
tree,
cursorPosition,
treeSitterLanguage,
}: {
languageName: TreeSitterLanguageName;
tree: Tree;
treeSitterLanguage: Language;
cursorPosition: Point;
}): boolean {
if (languageName !== 'python') return false;
const pythonQuery = treeSitterLanguage.query(`[
(function_definition)
(class_definition)
] @function`);
const captures = pythonQuery.captures(tree.rootNode);
if (captures.length === 0) return false;
// Check if any function or class body is empty and cursor is after it
return captures.some((capture) => {
const bodyNode = capture.node.childForFieldName('body');
return (
bodyNode?.childCount === 0 &&
EmptyFunctionResolver.#isCursorRightAfterNode(cursorPosition, capture.node.endPosition)
);
});
}
}
let emptyFunctionResolver: EmptyFunctionResolver;
export function getEmptyFunctionResolver(): EmptyFunctionResolver {
if (!emptyFunctionResolver) {
emptyFunctionResolver = new EmptyFunctionResolver();
}
return emptyFunctionResolver;
}
References: |
You are a code assistant | Definition of 'StateCheck' in file src/common/feature_state/state_check.ts in project gitlab-lsp | Definition:
export interface StateCheck {
id: StateCheckId;
engaged: boolean;
/** registers a listener that's called when the policy changes */
onChanged: (listener: (data: StateCheckChangedEventData) => void) => Disposable;
details?: string;
}
References: |
You are a code assistant | Definition of 'onOpen' in file src/common/circuit_breaker/fixed_time_circuit_breaker.ts in project gitlab-lsp | Definition:
onOpen(listener: () => void): Disposable {
this.#eventEmitter.on('open', listener);
return { dispose: () => this.#eventEmitter.removeListener('open', listener) };
}
onClose(listener: () => void): Disposable {
this.#eventEmitter.on('close', listener);
return { dispose: () => this.#eventEmitter.removeListener('close', listener) };
}
}
References: |
You are a code assistant | Definition of 'start' in file src/common/tracking/snowplow/emitter.ts in project gitlab-lsp | Definition:
start() {
this.#timeout = setTimeout(async () => {
await this.#drainQueue();
if (this.#currentState !== EmitterState.STOPPING) {
this.start();
}
}, this.#timeInterval);
this.#currentState = EmitterState.STARTED;
}
async stop() {
this.#currentState = EmitterState.STOPPING;
if (this.#timeout) {
clearTimeout(this.#timeout);
}
this.#timeout = undefined;
await this.#drainQueue();
}
}
References: |
You are a code assistant | Definition of 'updateCodeSuggestionsContext' in file src/common/tracking/multi_tracker.ts in project gitlab-lsp | Definition:
updateCodeSuggestionsContext(
uniqueTrackingId: string,
contextUpdate: Partial<ICodeSuggestionContextUpdate>,
) {
this.#enabledTrackers.forEach((t) =>
t.updateCodeSuggestionsContext(uniqueTrackingId, contextUpdate),
);
}
updateSuggestionState(uniqueTrackingId: string, newState: TRACKING_EVENTS) {
this.#enabledTrackers.forEach((t) => t.updateSuggestionState(uniqueTrackingId, newState));
}
rejectOpenedSuggestions() {
this.#enabledTrackers.forEach((t) => t.rejectOpenedSuggestions());
}
}
References: |
You are a code assistant | Definition of 'RequestHandler' in file packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts in project gitlab-lsp | Definition:
type RequestHandler = (requestId: RequestId, payload: unknown) => void;
type ResponseHandler = (message: ResponseMessage) => void;
export class WebviewInstanceMessageBus<T extends MessageMap = MessageMap>
implements WebviewMessageBus<T>, Disposable
{
#address: WebviewAddress;
#runtimeMessageBus: WebviewRuntimeMessageBus;
#eventSubscriptions = new CompositeDisposable();
#notificationEvents = new SimpleRegistry<NotificationHandler>();
#requestEvents = new SimpleRegistry<RequestHandler>();
#pendingResponseEvents = new SimpleRegistry<ResponseHandler>();
#logger: Logger;
constructor(
webviewAddress: WebviewAddress,
runtimeMessageBus: WebviewRuntimeMessageBus,
logger: Logger,
) {
this.#address = webviewAddress;
this.#runtimeMessageBus = runtimeMessageBus;
this.#logger = withPrefix(
logger,
`[WebviewInstanceMessageBus:${webviewAddress.webviewId}:${webviewAddress.webviewInstanceId}]`,
);
this.#logger.debug('initializing');
const eventFilter = buildWebviewAddressFilter(webviewAddress);
this.#eventSubscriptions.add(
this.#runtimeMessageBus.subscribe(
'webview:notification',
async (message) => {
try {
await this.#notificationEvents.handle(message.type, message.payload);
} catch (error) {
this.#logger.debug(
`Failed to handle webview instance notification: ${message.type}`,
error instanceof Error ? error : undefined,
);
}
},
eventFilter,
),
this.#runtimeMessageBus.subscribe(
'webview:request',
async (message) => {
try {
await this.#requestEvents.handle(message.type, message.requestId, message.payload);
} catch (error) {
this.#logger.error(error as Error);
}
},
eventFilter,
),
this.#runtimeMessageBus.subscribe(
'webview:response',
async (message) => {
try {
await this.#pendingResponseEvents.handle(message.requestId, message);
} catch (error) {
this.#logger.error(error as Error);
}
},
eventFilter,
),
);
this.#logger.debug('initialized');
}
sendNotification(type: Method, payload?: unknown): void {
this.#logger.debug(`Sending notification: ${type}`);
this.#runtimeMessageBus.publish('plugin:notification', {
...this.#address,
type,
payload,
});
}
onNotification(type: Method, handler: Handler): Disposable {
return this.#notificationEvents.register(type, handler);
}
async sendRequest(type: Method, payload?: unknown): Promise<never> {
const requestId = generateRequestId();
this.#logger.debug(`Sending request: ${type}, ID: ${requestId}`);
let timeout: NodeJS.Timeout | undefined;
return new Promise((resolve, reject) => {
const pendingRequestHandle = this.#pendingResponseEvents.register(
requestId,
(message: ResponseMessage) => {
if (message.success) {
resolve(message.payload as PromiseLike<never>);
} else {
reject(new Error(message.reason));
}
clearTimeout(timeout);
pendingRequestHandle.dispose();
},
);
this.#runtimeMessageBus.publish('plugin:request', {
...this.#address,
requestId,
type,
payload,
});
timeout = setTimeout(() => {
pendingRequestHandle.dispose();
this.#logger.debug(`Request with ID: ${requestId} timed out`);
reject(new Error('Request timed out'));
}, 10000);
});
}
onRequest(type: Method, handler: Handler): Disposable {
return this.#requestEvents.register(type, (requestId: RequestId, payload: unknown) => {
try {
const result = handler(payload);
this.#runtimeMessageBus.publish('plugin:response', {
...this.#address,
requestId,
type,
success: true,
payload: result,
});
} catch (error) {
this.#logger.error(`Error handling request of type ${type}:`, error as Error);
this.#runtimeMessageBus.publish('plugin:response', {
...this.#address,
requestId,
type,
success: false,
reason: (error as Error).message,
});
}
});
}
dispose(): void {
this.#eventSubscriptions.dispose();
this.#notificationEvents.dispose();
this.#requestEvents.dispose();
this.#pendingResponseEvents.dispose();
}
}
References: |
You are a code assistant | Definition of 'on' in file packages/lib_webview_transport_json_rpc/src/json_rpc_connection_transport.ts in project gitlab-lsp | Definition:
on<K extends keyof MessagesToServer>(
type: K,
callback: TransportMessageHandler<MessagesToServer[K]>,
): Disposable {
this.#messageEmitter.on(type, callback as WebviewTransportEventEmitterMessages[K]);
return {
dispose: () =>
this.#messageEmitter.off(type, callback as WebviewTransportEventEmitterMessages[K]),
};
}
publish<K extends keyof MessagesToClient>(type: K, payload: MessagesToClient[K]): Promise<void> {
if (type === 'webview_instance_notification') {
return this.#connection.sendNotification(this.#notificationChannel, payload);
}
throw new Error(`Unknown message type: ${type}`);
}
dispose(): void {
this.#messageEmitter.removeAllListeners();
this.#disposables.forEach((disposable) => disposable.dispose());
this.#logger?.debug('JsonRpcConnectionTransport disposed');
}
}
References: |
You are a code assistant | Definition of 'WORKFLOW_MESSAGE_NOTIFICATION' in file src/common/message_handler.ts in project gitlab-lsp | Definition:
export const WORKFLOW_MESSAGE_NOTIFICATION = '$/gitlab/workflowMessage';
export interface MessageHandlerOptions {
telemetryTracker: TelemetryTracker;
configService: ConfigService;
connection: Connection;
featureFlagService: FeatureFlagService;
duoProjectAccessCache: DuoProjectAccessCache;
virtualFileSystemService: VirtualFileSystemService;
workflowAPI: WorkflowAPI | undefined;
}
export interface ITelemetryNotificationParams {
category: 'code_suggestions';
action: TRACKING_EVENTS;
context: {
trackingId: string;
optionId?: number;
};
}
export interface IStartWorkflowParams {
goal: string;
image: string;
}
export const waitMs = (msToWait: number) =>
new Promise((resolve) => {
setTimeout(resolve, msToWait);
});
/* CompletionRequest represents LS client's request for either completion or inlineCompletion */
export interface CompletionRequest {
textDocument: TextDocumentIdentifier;
position: Position;
token: CancellationToken;
inlineCompletionContext?: InlineCompletionContext;
}
export class MessageHandler {
#configService: ConfigService;
#tracker: TelemetryTracker;
#connection: Connection;
#circuitBreaker = new FixedTimeCircuitBreaker('Code Suggestion Requests');
#subscriptions: Disposable[] = [];
#duoProjectAccessCache: DuoProjectAccessCache;
#featureFlagService: FeatureFlagService;
#workflowAPI: WorkflowAPI | undefined;
#virtualFileSystemService: VirtualFileSystemService;
constructor({
telemetryTracker,
configService,
connection,
featureFlagService,
duoProjectAccessCache,
virtualFileSystemService,
workflowAPI = undefined,
}: MessageHandlerOptions) {
this.#configService = configService;
this.#tracker = telemetryTracker;
this.#connection = connection;
this.#featureFlagService = featureFlagService;
this.#workflowAPI = workflowAPI;
this.#subscribeToCircuitBreakerEvents();
this.#virtualFileSystemService = virtualFileSystemService;
this.#duoProjectAccessCache = duoProjectAccessCache;
}
didChangeConfigurationHandler = async (
{ settings }: ChangeConfigOptions = { settings: {} },
): Promise<void> => {
this.#configService.merge({
client: settings,
});
// update Duo project access cache
await this.#duoProjectAccessCache.updateCache({
baseUrl: this.#configService.get('client.baseUrl') ?? '',
workspaceFolders: this.#configService.get('client.workspaceFolders') ?? [],
});
await this.#virtualFileSystemService.initialize(
this.#configService.get('client.workspaceFolders') ?? [],
);
};
telemetryNotificationHandler = async ({
category,
action,
context,
}: ITelemetryNotificationParams) => {
if (category === CODE_SUGGESTIONS_CATEGORY) {
const { trackingId, optionId } = context;
if (
trackingId &&
canClientTrackEvent(this.#configService.get('client.telemetry.actions'), action)
) {
switch (action) {
case TRACKING_EVENTS.ACCEPTED:
if (optionId) {
this.#tracker.updateCodeSuggestionsContext(trackingId, { acceptedOption: optionId });
}
this.#tracker.updateSuggestionState(trackingId, TRACKING_EVENTS.ACCEPTED);
break;
case TRACKING_EVENTS.REJECTED:
this.#tracker.updateSuggestionState(trackingId, TRACKING_EVENTS.REJECTED);
break;
case TRACKING_EVENTS.CANCELLED:
this.#tracker.updateSuggestionState(trackingId, TRACKING_EVENTS.CANCELLED);
break;
case TRACKING_EVENTS.SHOWN:
this.#tracker.updateSuggestionState(trackingId, TRACKING_EVENTS.SHOWN);
break;
case TRACKING_EVENTS.NOT_PROVIDED:
this.#tracker.updateSuggestionState(trackingId, TRACKING_EVENTS.NOT_PROVIDED);
break;
default:
break;
}
}
}
};
onShutdownHandler = () => {
this.#subscriptions.forEach((subscription) => subscription?.dispose());
};
#subscribeToCircuitBreakerEvents() {
this.#subscriptions.push(
this.#circuitBreaker.onOpen(() => this.#connection.sendNotification(API_ERROR_NOTIFICATION)),
);
this.#subscriptions.push(
this.#circuitBreaker.onClose(() =>
this.#connection.sendNotification(API_RECOVERY_NOTIFICATION),
),
);
}
async #sendWorkflowErrorNotification(message: string) {
await this.#connection.sendNotification(WORKFLOW_MESSAGE_NOTIFICATION, {
message,
type: 'error',
});
}
startWorkflowNotificationHandler = async ({ goal, image }: IStartWorkflowParams) => {
const duoWorkflow = this.#featureFlagService.isClientFlagEnabled(
ClientFeatureFlags.DuoWorkflow,
);
if (!duoWorkflow) {
await this.#sendWorkflowErrorNotification(`The Duo Workflow feature is not enabled`);
return;
}
if (!this.#workflowAPI) {
await this.#sendWorkflowErrorNotification('Workflow API is not configured for the LSP');
return;
}
try {
await this.#workflowAPI?.runWorkflow(goal, image);
} catch (e) {
log.error('Error in running workflow', e);
await this.#sendWorkflowErrorNotification(`Error occurred while running workflow ${e}`);
}
};
}
References: |
You are a code assistant | Definition of 'resolveMessageBus' in file packages/lib_webview_client/src/bus/resolve_message_bus.ts in project gitlab-lsp | Definition:
export function resolveMessageBus<TMessages extends MessageMap>(
params: ResolveMessageBusParams,
): MessageBus<TMessages> {
const { webviewId } = params;
const logger = params.logger || new NullLogger();
const providers = params.providers || getDefaultProviders();
for (const provider of providers) {
const bus = getMessageBusFromProviderSafe<TMessages>(webviewId, provider, logger);
if (bus) {
return bus;
}
}
throw new Error(`Unable to resolve a message bus for webviewId: ${webviewId}`);
}
function getMessageBusFromProviderSafe<TMessages extends MessageMap>(
webviewId: string,
provider: MessageBusProvider,
logger: Logger,
): MessageBus<TMessages> | null {
try {
logger.debug(`Trying to resolve message bus from provider: ${provider.name}`);
const bus = provider.getMessageBus<TMessages>(webviewId);
logger.debug(`Message bus resolved from provider: ${provider.name}`);
return bus;
} catch (error) {
logger.debug('Failed to resolve message bus', error as Error);
return null;
}
}
References:
- packages/webview-chat/src/app/index.ts:6
- packages/webview_duo_workflow/src/app/index.ts:6
- packages/webview_duo_workflow/src/app/message_bus.ts:4
- packages/lib_webview_client/src/bus/resolve_message_bus.test.ts:66
- packages/lib_webview_client/src/bus/resolve_message_bus.test.ts:31
- packages/webview_duo_chat/src/app/message_bus.ts:4
- packages/lib_webview_client/src/bus/resolve_message_bus.test.ts:48 |
You are a code assistant | Definition of 'WebviewInstanceNotificationEventData' in file packages/lib_webview_transport/src/types.ts in project gitlab-lsp | Definition:
export type WebviewInstanceNotificationEventData = WebviewAddress & WebviewEventInfo;
export type WebviewInstanceRequestEventData = WebviewAddress &
WebviewEventInfo &
WebviewRequestInfo;
export type SuccessfulResponse = {
success: true;
};
export type FailedResponse = {
success: false;
reason: string;
};
export type WebviewInstanceResponseEventData = WebviewAddress &
WebviewRequestInfo &
WebviewEventInfo &
(SuccessfulResponse | FailedResponse);
export type MessagesToServer = {
webview_instance_created: WebviewInstanceCreatedEventData;
webview_instance_destroyed: WebviewInstanceDestroyedEventData;
webview_instance_notification_received: WebviewInstanceNotificationEventData;
webview_instance_request_received: WebviewInstanceRequestEventData;
webview_instance_response_received: WebviewInstanceResponseEventData;
};
export type MessagesToClient = {
webview_instance_notification: WebviewInstanceNotificationEventData;
webview_instance_request: WebviewInstanceRequestEventData;
webview_instance_response: WebviewInstanceResponseEventData;
};
export interface TransportMessageHandler<T> {
(payload: T): void;
}
export interface TransportListener {
on<K extends keyof MessagesToServer>(
type: K,
callback: TransportMessageHandler<MessagesToServer[K]>,
): Disposable;
}
export interface TransportPublisher {
publish<K extends keyof MessagesToClient>(type: K, payload: MessagesToClient[K]): Promise<void>;
}
export interface Transport extends TransportListener, TransportPublisher {}
References:
- packages/lib_webview_transport/src/types.ts:48
- packages/lib_webview_transport/src/types.ts:42 |
You are a code assistant | Definition of 'onLanguageChange' in file src/common/suggestion/supported_languages_service.ts in project gitlab-lsp | Definition:
onLanguageChange(listener: () => void): Disposable {
this.#eventEmitter.on('languageChange', listener);
return { dispose: () => this.#eventEmitter.removeListener('configChange', listener) };
}
#triggerChange() {
this.#eventEmitter.emit('languageChange');
}
#normalizeLanguageIdentifier(language: string) {
return language.trim().toLowerCase().replace(/^\./, '');
}
}
References: |
You are a code assistant | Definition of 'isInvalidToken' in file src/common/fetch_error.ts in project gitlab-lsp | Definition:
isInvalidToken(): boolean {
return (
isInvalidTokenError(this.response, this.#body) || isInvalidRefresh(this.response, this.#body)
);
}
get details() {
const { message, stack } = this;
return {
message,
stack: stackToArray(stack),
response: {
status: this.response.status,
headers: this.response.headers,
body: this.#body,
},
};
}
}
export class TimeoutError extends Error {
constructor(url: URL | RequestInfo) {
const timeoutInSeconds = Math.round(REQUEST_TIMEOUT_MILLISECONDS / 1000);
super(
`Request to ${extractURL(url)} timed out after ${timeoutInSeconds} second${timeoutInSeconds === 1 ? '' : 's'}`,
);
}
}
export class InvalidInstanceVersionError extends Error {}
References: |
You are a code assistant | Definition of 'WebviewAddress' in file packages/lib_webview_plugin/src/types.ts in project gitlab-lsp | Definition:
export type WebviewAddress = {
webviewId: WebviewId;
webviewInstanceId: WebviewInstanceId;
};
export type WebviewMessageBusManagerHandler<T extends MessageMap> = (
webviewInstanceId: WebviewInstanceId,
messageBus: MessageBus<T>,
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) => Disposable | void;
export interface WebviewConnection<T extends MessageMap> {
broadcast: <TMethod extends keyof T['outbound']['notifications'] & string>(
type: TMethod,
payload: T['outbound']['notifications'][TMethod],
) => void;
onInstanceConnected: (handler: WebviewMessageBusManagerHandler<T>) => void;
}
References:
- packages/lib_webview/src/setup/plugin/webview_controller.ts:88
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.test.ts:15
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts:33
- packages/lib_webview/src/setup/plugin/setup_plugins.ts:30
- packages/lib_webview/src/setup/plugin/utils/filters.ts:10
- packages/lib_webview/src/setup/plugin/webview_controller.test.ts:15
- packages/lib_webview/src/setup/transport/utils/setup_transport_event_handlers.ts:16
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts:18
- packages/lib_webview/src/events/webview_runtime_message_bus.ts:31
- packages/lib_webview/src/setup/transport/utils/setup_transport_event_handlers.ts:12
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.test.ts:8
- packages/lib_webview/src/setup/plugin/webview_controller.test.ts:175
- packages/lib_webview/src/events/webview_runtime_message_bus.ts:30
- packages/lib_webview/src/setup/plugin/webview_controller.test.ts:219
- packages/lib_webview/src/setup/plugin/webview_controller.ts:112
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.test.ts:331
- packages/lib_webview/src/setup/plugin/webview_controller.ts:21 |
You are a code assistant | Definition of 'DEFAULT_SCANNER_SERVICE_URL' in file src/common/security_diagnostics_publisher.ts in project gitlab-lsp | Definition:
export const DEFAULT_SCANNER_SERVICE_URL = '';
interface Vulnerability {
name: string;
description: string;
severity: string;
location: { start_line: number; end_line: number };
}
export interface SecurityDiagnosticsPublisher extends DiagnosticsPublisher {}
export const SecurityDiagnosticsPublisher = createInterfaceId<SecurityDiagnosticsPublisher>(
'SecurityDiagnosticsPublisher',
);
@Injectable(SecurityDiagnosticsPublisher, [FeatureFlagService, ConfigService, DocumentService])
export class DefaultSecurityDiagnosticsPublisher implements SecurityDiagnosticsPublisher {
#publish: DiagnosticsPublisherFn | undefined;
#opts?: ISecurityScannerOptions;
#featureFlagService: FeatureFlagService;
constructor(
featureFlagService: FeatureFlagService,
configService: ConfigService,
documentService: DocumentService,
) {
this.#featureFlagService = featureFlagService;
configService.onConfigChange((config: IConfig) => {
this.#opts = config.client.securityScannerOptions;
});
documentService.onDocumentChange(
async (
event: TextDocumentChangeEvent<TextDocument>,
handlerType: TextDocumentChangeListenerType,
) => {
if (handlerType === TextDocumentChangeListenerType.onDidSave) {
await this.#runSecurityScan(event.document);
}
},
);
}
init(callback: DiagnosticsPublisherFn): void {
this.#publish = callback;
}
async #runSecurityScan(document: TextDocument) {
try {
if (!this.#publish) {
throw new Error('The DefaultSecurityService has not been initialized. Call init first.');
}
if (!this.#featureFlagService.isClientFlagEnabled(ClientFeatureFlags.RemoteSecurityScans)) {
return;
}
if (!this.#opts?.enabled) {
return;
}
if (!this.#opts) {
return;
}
const url = this.#opts.serviceUrl ?? DEFAULT_SCANNER_SERVICE_URL;
if (url === '') {
return;
}
const content = document.getText();
const fileName = UriUtils.basename(URI.parse(document.uri));
const formData = new FormData();
const blob = new Blob([content]);
formData.append('file', blob, fileName);
const request = {
method: 'POST',
headers: {
Accept: 'application/json',
},
body: formData,
};
log.debug(`Executing request to url="${url}" with contents of "${fileName}"`);
const response = await fetch(url, request);
await handleFetchError(response, 'security scan');
const json = await response.json();
const { vulnerabilities: vulns } = json;
if (vulns == null || !Array.isArray(vulns)) {
return;
}
const diagnostics: Diagnostic[] = vulns.map((vuln: Vulnerability) => {
let message = `${vuln.name}\n\n${vuln.description.substring(0, 200)}`;
if (vuln.description.length > 200) {
message += '...';
}
const severity =
vuln.severity === 'high' ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning;
// TODO: Use a more precise range when it's available from the service.
return {
message,
range: {
start: {
line: vuln.location.start_line - 1,
character: 0,
},
end: {
line: vuln.location.end_line,
character: 0,
},
},
severity,
source: 'gitlab_security_scan',
};
});
await this.#publish({
uri: document.uri,
diagnostics,
});
} catch (error) {
log.warn('SecurityScan: failed to run security scan', error);
}
}
}
References: |
You are a code assistant | Definition of 'WebviewMessageBusFactory' in file packages/lib_webview/src/setup/plugin/webview_controller.ts in project gitlab-lsp | Definition:
export interface WebviewMessageBusFactory {
(webviewAddress: WebviewAddress): WebviewInstanceMessageBus<MessageMap>;
}
export class WebviewController<T extends MessageMap> implements WebviewConnection<T>, Disposable {
readonly webviewId: WebviewId;
#messageBusFactory: WebviewMessageBusFactory;
#handlers = new Set<WebviewMessageBusManagerHandler<T>>();
#instanceInfos = new Map<WebviewInstanceId, WebviewInstanceInfo>();
#compositeDisposable = new CompositeDisposable();
#logger: Logger;
constructor(
webviewId: WebviewId,
runtimeMessageBus: WebviewRuntimeMessageBus,
messageBusFactory: WebviewMessageBusFactory,
logger: Logger,
) {
this.#logger = withPrefix(logger, `[WebviewController:${webviewId}]`);
this.webviewId = webviewId;
this.#messageBusFactory = messageBusFactory;
this.#subscribeToEvents(runtimeMessageBus);
}
broadcast<TMethod extends keyof T['outbound']['notifications'] & string>(
type: TMethod,
payload: T['outbound']['notifications'][TMethod],
) {
for (const info of this.#instanceInfos.values()) {
info.messageBus.sendNotification(type.toString(), payload);
}
}
onInstanceConnected(handler: WebviewMessageBusManagerHandler<T>) {
this.#handlers.add(handler);
for (const [instanceId, info] of this.#instanceInfos) {
const disposable = handler(instanceId, info.messageBus);
if (isDisposable(disposable)) {
info.pluginCallbackDisposables.add(disposable);
}
}
}
dispose(): void {
this.#compositeDisposable.dispose();
this.#instanceInfos.forEach((info) => info.messageBus.dispose());
this.#instanceInfos.clear();
}
#subscribeToEvents(runtimeMessageBus: WebviewRuntimeMessageBus) {
const eventFilter = buildWebviewIdFilter(this.webviewId);
this.#compositeDisposable.add(
runtimeMessageBus.subscribe('webview:connect', this.#handleConnected.bind(this), eventFilter),
runtimeMessageBus.subscribe(
'webview:disconnect',
this.#handleDisconnected.bind(this),
eventFilter,
),
);
}
#handleConnected(address: WebviewAddress) {
this.#logger.debug(`Instance connected: ${address.webviewInstanceId}`);
if (this.#instanceInfos.has(address.webviewInstanceId)) {
// we are already connected with this webview instance
return;
}
const messageBus = this.#messageBusFactory(address);
const pluginCallbackDisposables = new CompositeDisposable();
this.#instanceInfos.set(address.webviewInstanceId, {
messageBus,
pluginCallbackDisposables,
});
this.#handlers.forEach((handler) => {
const disposable = handler(address.webviewInstanceId, messageBus);
if (isDisposable(disposable)) {
pluginCallbackDisposables.add(disposable);
}
});
}
#handleDisconnected(address: WebviewAddress) {
this.#logger.debug(`Instance disconnected: ${address.webviewInstanceId}`);
const instanceInfo = this.#instanceInfos.get(address.webviewInstanceId);
if (!instanceInfo) {
// we aren't tracking this instance
return;
}
instanceInfo.pluginCallbackDisposables.dispose();
instanceInfo.messageBus.dispose();
this.#instanceInfos.delete(address.webviewInstanceId);
}
}
References:
- packages/lib_webview/src/setup/plugin/webview_controller.ts:40
- packages/lib_webview/src/setup/plugin/webview_controller.ts:27 |
You are a code assistant | Definition of 'filterContextResolutions' in file src/common/advanced_context/advanced_context_filters.ts in project gitlab-lsp | Definition:
export const filterContextResolutions = async ({
contextResolutions,
dependencies,
documentContext,
byteSizeLimit,
}: AdvancedContextFilterArgs): Promise<ContextResolution[]> => {
return advancedContextFilters.reduce(async (prevPromise, filter) => {
const resolutions = await prevPromise;
return filter({
contextResolutions: resolutions,
dependencies,
documentContext,
byteSizeLimit,
});
}, Promise.resolve(contextResolutions));
};
References:
- src/common/advanced_context/advanced_context_filters.test.ts:132
- src/common/advanced_context/advanced_context_filters.test.ts:176
- src/common/advanced_context/advanced_context_filters.test.ts:295
- src/common/advanced_context/advanced_context_filters.test.ts:75
- src/common/advanced_context/advanced_context_filters.test.ts:228
- src/common/advanced_context/advanced_context_factory.ts:35 |
You are a code assistant | Definition of 'AiContextAggregator' in file src/common/ai_context_management_2/ai_context_aggregator.ts in project gitlab-lsp | Definition:
export interface AiContextAggregator extends DefaultAiContextAggregator {}
export const AiContextAggregator = createInterfaceId<AiContextAggregator>('AiContextAggregator');
export type AiContextQuery = {
query: string;
providerType: 'file';
textDocument?: TextDocument;
workspaceFolders: WorkspaceFolder[];
};
@Injectable(AiContextAggregator, [AiFileContextProvider, AiContextPolicyManager])
export class DefaultAiContextAggregator {
#AiFileContextProvider: AiFileContextProvider;
#AiContextPolicyManager: AiContextPolicyManager;
constructor(
aiFileContextProvider: AiFileContextProvider,
aiContextPolicyManager: AiContextPolicyManager,
) {
this.#AiFileContextProvider = aiFileContextProvider;
this.#AiContextPolicyManager = aiContextPolicyManager;
}
async getContextForQuery(query: AiContextQuery): Promise<AiContextItem[]> {
switch (query.providerType) {
case 'file': {
const providerItems = await this.#AiFileContextProvider.getProviderItems(
query.query,
query.workspaceFolders,
);
const contextItems = await Promise.all(
providerItems.map((providerItem) => this.#providerItemToContextItem(providerItem)),
);
return contextItems;
}
default:
return [];
}
}
async #providerItemToContextItem(providerItem: AiContextProviderItem): Promise<AiContextItem> {
if (providerItem.providerType === 'file') {
const { fileUri, workspaceFolder, providerType, subType, repositoryFile } = providerItem;
const policyResult = await this.#AiContextPolicyManager.runPolicies(providerItem);
return {
id: fileUri.toString(),
isEnabled: policyResult.allowed,
info: {
project: repositoryFile?.repositoryUri.fsPath,
disabledReasons: policyResult.reasons,
relFilePath: repositoryFile
? this.#getBasePath(fileUri, parseURIString(workspaceFolder.uri))
: undefined,
},
name: Utils.basename(fileUri),
type: providerType,
subType,
};
}
throw new Error('Unknown provider type');
}
#getBasePath(targetUri: URI, baseUri: URI): string {
const targetPath = targetUri.fsPath;
const basePath = baseUri.fsPath;
return targetPath.replace(basePath, '').replace(/^[/\\]+/, '');
}
}
References:
- src/common/connection_service.ts:66
- src/common/connection_service.ts:55 |
You are a code assistant | Definition of 'C' in file packages/lib_di/src/index.test.ts in project gitlab-lsp | Definition:
interface C {
c(): string;
}
const A = createInterfaceId<A>('A');
const B = createInterfaceId<B>('B');
const C = createInterfaceId<C>('C');
@Injectable(A, [])
class AImpl implements A {
a = () => 'a';
}
@Injectable(B, [A])
class BImpl implements B {
#a: A;
constructor(a: A) {
this.#a = a;
}
b = () => `B(${this.#a.a()})`;
}
@Injectable(C, [A, B])
class CImpl implements C {
#a: A;
#b: B;
constructor(a: A, b: B) {
this.#a = a;
this.#b = b;
}
c = () => `C(${this.#b.b()}, ${this.#a.a()})`;
}
let container: Container;
beforeEach(() => {
container = new Container();
});
describe('addInstances', () => {
const O = createInterfaceId<object>('object');
it('fails if the instance is not branded', () => {
expect(() => container.addInstances({ say: 'hello' } as BrandedInstance<object>)).toThrow(
/invoked without branded object/,
);
});
it('fails if the instance is already present', () => {
const a = brandInstance(O, { a: 'a' });
const b = brandInstance(O, { b: 'b' });
expect(() => container.addInstances(a, b)).toThrow(/this ID is already in the container/);
});
it('adds instance', () => {
const instance = { a: 'a' };
const a = brandInstance(O, instance);
container.addInstances(a);
expect(container.get(O)).toBe(instance);
});
});
describe('instantiate', () => {
it('can instantiate three classes A,B,C', () => {
container.instantiate(AImpl, BImpl, CImpl);
const cInstance = container.get(C);
expect(cInstance.c()).toBe('C(B(a), a)');
});
it('instantiates dependencies in multiple instantiate calls', () => {
container.instantiate(AImpl);
// the order is important for this test
// we want to make sure that the stack in circular dependency discovery is being cleared
// to try why this order is necessary, remove the `inStack.delete()` from
// the `if (!cwd && instanceIds.includes(id))` condition in prod code
expect(() => container.instantiate(CImpl, BImpl)).not.toThrow();
});
it('detects duplicate ids', () => {
@Injectable(A, [])
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl, AImpl2)).toThrow(
/The following interface IDs were used multiple times 'A' \(classes: AImpl,AImpl2\)/,
);
});
it('detects duplicate id with pre-existing instance', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
expect(() => container.instantiate(AImpl)).toThrow(/classes are clashing/);
});
it('detects missing dependencies', () => {
expect(() => container.instantiate(BImpl)).toThrow(
/Class BImpl \(interface B\) depends on interfaces \[A]/,
);
});
it('it uses existing instances as dependencies', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
container.instantiate(BImpl);
expect(container.get(B).b()).toBe('B(a)');
});
it("detects classes what aren't decorated with @Injectable", () => {
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl2)).toThrow(
/Classes \[AImpl2] are not decorated with @Injectable/,
);
});
it('detects circular dependencies', () => {
@Injectable(A, [C])
class ACircular implements A {
a = () => 'hello';
constructor(c: C) {
// eslint-disable-next-line no-unused-expressions
c;
}
}
expect(() => container.instantiate(ACircular, BImpl, CImpl)).toThrow(
/Circular dependency detected between interfaces \(A,C\), starting with 'A' \(class: ACircular\)./,
);
});
// this test ensures that we don't store any references to the classes and we instantiate them only once
it('does not instantiate classes from previous instantiate call', () => {
let globCount = 0;
@Injectable(A, [])
class Counter implements A {
counter = globCount;
constructor() {
globCount++;
}
a = () => this.counter.toString();
}
container.instantiate(Counter);
container.instantiate(BImpl);
expect(container.get(A).a()).toBe('0');
});
});
describe('get', () => {
it('returns an instance of the interfaceId', () => {
container.instantiate(AImpl);
expect(container.get(A)).toBeInstanceOf(AImpl);
});
it('throws an error for missing dependency', () => {
container.instantiate();
expect(() => container.get(A)).toThrow(/Instance for interface 'A' is not in the container/);
});
});
});
References:
- packages/lib_di/src/index.test.ts:146 |
You are a code assistant | Definition of 'constructor' in file packages/lib_di/src/index.test.ts in project gitlab-lsp | Definition:
constructor(c: C) {
// eslint-disable-next-line no-unused-expressions
c;
}
}
expect(() => container.instantiate(ACircular, BImpl, CImpl)).toThrow(
/Circular dependency detected between interfaces \(A,C\), starting with 'A' \(class: ACircular\)./,
);
});
// this test ensures that we don't store any references to the classes and we instantiate them only once
it('does not instantiate classes from previous instantiate call', () => {
let globCount = 0;
@Injectable(A, [])
class Counter implements A {
counter = globCount;
constructor() {
globCount++;
}
a = () => this.counter.toString();
}
container.instantiate(Counter);
container.instantiate(BImpl);
expect(container.get(A).a()).toBe('0');
});
});
describe('get', () => {
it('returns an instance of the interfaceId', () => {
container.instantiate(AImpl);
expect(container.get(A)).toBeInstanceOf(AImpl);
});
it('throws an error for missing dependency', () => {
container.instantiate();
expect(() => container.get(A)).toThrow(/Instance for interface 'A' is not in the container/);
});
});
});
References: |
You are a code assistant | Definition of 'DefaultAiContextFileRetriever' in file src/common/ai_context_management_2/retrievers/ai_file_context_retriever.ts in project gitlab-lsp | Definition:
export class DefaultAiContextFileRetriever implements AiContextRetriever {
constructor(
private fileResolver: FileResolver,
private secretRedactor: SecretRedactor,
) {}
async retrieve(aiContextItem: AiContextItem): Promise<string | null> {
if (aiContextItem.type !== 'file') {
return null;
}
try {
log.info(`retrieving file ${aiContextItem.id}`);
const fileContent = await this.fileResolver.readFile({
fileUri: aiContextItem.id,
});
log.info(`redacting secrets for file ${aiContextItem.id}`);
const redactedContent = this.secretRedactor.redactSecrets(fileContent);
return redactedContent;
} catch (e) {
log.warn(`Failed to retrieve file ${aiContextItem.id}`, e);
return null;
}
}
}
References: |
You are a code assistant | Definition of 'Disposable' in file packages/lib_disposable/src/types.ts in project gitlab-lsp | Definition:
export interface Disposable {
dispose(): void;
}
References:
- packages/lib_message_bus/src/types/bus.ts:47
- src/common/circuit_breaker/circuit_breaker.ts:17
- src/common/circuit_breaker/exponential_backoff_circuit_breaker.ts:95
- src/common/feature_state/supported_language_check.ts:45
- packages/lib_webview_client/src/bus/provider/socket_io_message_bus.ts:72
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts:139
- packages/lib_message_bus/src/types/bus.ts:103
- packages/lib_webview/src/setup/setup_webview_runtime.ts:17
- packages/lib_webview_transport_socket_io/src/socket_io_webview_transport.ts:172
- src/common/services/duo_access/project_access_cache.ts:240
- packages/lib_webview/src/setup/transport/setup_transport.ts:12
- src/common/api.ts:149
- packages/lib_webview/src/events/message_bus.ts:18
- packages/lib_disposable/src/composite_disposable.test.ts:6
- packages/lib_webview/src/setup/plugin/webview_instance_message_bus.ts:99
- packages/lib_webview_transport_json_rpc/src/json_rpc_connection_transport.ts:105
- src/common/circuit_breaker/fixed_time_circuit_breaker.ts:75
- src/common/suggestion/supported_languages_service.ts:21
- src/common/suggestion/supported_languages_service.ts:107
- packages/lib_message_bus/src/types/bus.ts:51
- src/common/circuit_breaker/exponential_backoff_circuit_breaker.ts:90
- src/common/circuit_breaker/circuit_breaker.ts:18
- src/common/core/handlers/token_check_notifier.test.ts:18
- packages/lib_webview/src/setup/transport/setup_transport.ts:39
- packages/lib_handler_registry/src/registry/simple_registry.ts:14
- src/common/config_service.ts:142
- packages/lib_disposable/src/composite_disposable.test.ts:7
- src/common/api.ts:32
- packages/lib_handler_registry/src/types.ts:9
- src/common/webview/extension/extension_connection_message_bus.ts:37
- src/common/config_service.ts:94
- src/common/advanced_context/advanced_context_service.test.ts:24
- src/common/webview/extension/extension_connection_message_bus.ts:44
- src/common/circuit_breaker/fixed_time_circuit_breaker.ts:80
- packages/lib_webview_transport_json_rpc/src/json_rpc_connection_transport.test.ts:13
- src/common/services/duo_access/project_access_cache.ts:79
- packages/lib_message_bus/src/types/bus.ts:107
- packages/lib_webview_transport/src/types.ts:61
- src/common/feature_state/project_duo_acces_check.ts:68
- src/common/document_service.ts:19
- packages/lib_webview_client/src/bus/provider/socket_io_message_bus.ts:81
- packages/lib_webview/src/events/utils/subscribe.ts:8
- packages/lib_handler_registry/src/registry/hashed_registry.ts:23 |
You are a code assistant | Definition of 'cleanChat' in file packages/webview_duo_chat/src/plugin/port/chat/gitlab_chat_api.ts in project gitlab-lsp | Definition:
async cleanChat(): Promise<AiActionResponseType> {
return this.#sendAiAction({ question: SPECIAL_MESSAGES.CLEAN });
}
async #currentPlatform() {
const platform = await this.#manager.getGitLabPlatform();
if (!platform) throw new Error('Platform is missing!');
return platform;
}
async #getAiMessage(requestId: string, role: string): Promise<AiMessageResponseType | undefined> {
const request: GraphQLRequest<AiMessagesResponseType> = {
type: 'graphql',
query: AI_MESSAGES_QUERY,
variables: { requestIds: [requestId], roles: [role.toUpperCase()] },
};
const platform = await this.#currentPlatform();
const history = await platform.fetchFromApi(request);
return history.aiMessages.nodes[0];
}
async subscribeToUpdates(
messageCallback: (message: AiCompletionResponseMessageType) => Promise<void>,
subscriptionId?: string,
) {
const platform = await this.#currentPlatform();
const channel = new AiCompletionResponseChannel({
htmlResponse: true,
userId: `gid://gitlab/User/${extractUserId(platform.account.id)}`,
aiAction: 'CHAT',
clientSubscriptionId: subscriptionId,
});
const cable = await platform.connectToCable();
// we use this flag to fix https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/issues/1397
// sometimes a chunk comes after the full message and it broke the chat
let fullMessageReceived = false;
channel.on('newChunk', async (msg) => {
if (fullMessageReceived) {
log.info(`CHAT-DEBUG: full message received, ignoring chunk`);
return;
}
await messageCallback(msg);
});
channel.on('fullMessage', async (message) => {
fullMessageReceived = true;
await messageCallback(message);
if (subscriptionId) {
cable.disconnect();
}
});
cable.subscribe(channel);
}
async #sendAiAction(variables: object): Promise<AiActionResponseType> {
const platform = await this.#currentPlatform();
const { query, defaultVariables } = await this.#actionQuery();
const projectGqlId = await this.#manager.getProjectGqlId();
const request: GraphQLRequest<AiActionResponseType> = {
type: 'graphql',
query,
variables: {
...variables,
...defaultVariables,
resourceId: projectGqlId ?? null,
},
};
return platform.fetchFromApi(request);
}
async #actionQuery(): Promise<ChatInputTemplate> {
if (!this.#cachedActionQuery) {
const platform = await this.#currentPlatform();
try {
const { version } = await platform.fetchFromApi(versionRequest);
this.#cachedActionQuery = ifVersionGte<ChatInputTemplate>(
version,
MINIMUM_PLATFORM_ORIGIN_FIELD_VERSION,
() => CHAT_INPUT_TEMPLATE_17_3_AND_LATER,
() => CHAT_INPUT_TEMPLATE_17_2_AND_EARLIER,
);
} catch (e) {
log.debug(`GitLab version check for sending chat failed:`, e as Error);
this.#cachedActionQuery = CHAT_INPUT_TEMPLATE_17_3_AND_LATER;
}
}
return this.#cachedActionQuery;
}
}
References: |
You are a code assistant | Definition of 'getCodeSuggestions' in file src/common/api.ts in project gitlab-lsp | Definition:
async getCodeSuggestions(
request: CodeSuggestionRequest,
): Promise<CodeSuggestionResponse | undefined> {
if (!this.#token) {
throw new Error('Token needs to be provided to request Code Suggestions');
}
const headers = {
...this.#getDefaultHeaders(this.#token),
'Content-Type': 'application/json',
};
const response = await this.#lsFetch.post(
`${this.#baseURL}/api/v4/code_suggestions/completions`,
{ headers, body: JSON.stringify(request) },
);
await handleFetchError(response, 'Code Suggestions');
const data = await response.json();
return { ...data, status: response.status };
}
async *getStreamingCodeSuggestions(
request: CodeSuggestionRequest,
): AsyncGenerator<string, void, void> {
if (!this.#token) {
throw new Error('Token needs to be provided to stream code suggestions');
}
const headers = {
...this.#getDefaultHeaders(this.#token),
'Content-Type': 'application/json',
};
yield* this.#lsFetch.streamFetch(
`${this.#baseURL}/api/v4/code_suggestions/completions`,
JSON.stringify(request),
headers,
);
}
async fetchFromApi<TReturnType>(request: ApiRequest<TReturnType>): Promise<TReturnType> {
if (!this.#token) {
return Promise.reject(new Error('Token needs to be provided to authorise API request.'));
}
if (
request.supportedSinceInstanceVersion &&
!this.#instanceVersionHigherOrEqualThen(request.supportedSinceInstanceVersion.version)
) {
return Promise.reject(
new InvalidInstanceVersionError(
`Can't ${request.supportedSinceInstanceVersion.resourceName} until your instance is upgraded to ${request.supportedSinceInstanceVersion.version} or higher.`,
),
);
}
if (request.type === 'graphql') {
return this.#graphqlRequest(request.query, request.variables);
}
switch (request.method) {
case 'GET':
return this.#fetch(request.path, request.searchParams, 'resource', request.headers);
case 'POST':
return this.#postFetch(request.path, 'resource', request.body, request.headers);
default:
// the type assertion is necessary because TS doesn't expect any other types
throw new Error(`Unknown request type ${(request as ApiRequest<unknown>).type}`);
}
}
async connectToCable(): Promise<ActionCableCable> {
const headers = this.#getDefaultHeaders(this.#token);
const websocketOptions = {
headers: {
...headers,
Origin: this.#baseURL,
},
};
return connectToCable(this.#baseURL, websocketOptions);
}
async #graphqlRequest<T = unknown, V extends Variables = Variables>(
document: RequestDocument,
variables?: V,
): Promise<T> {
const ensureEndsWithSlash = (url: string) => url.replace(/\/?$/, '/');
const endpoint = new URL('./api/graphql', ensureEndsWithSlash(this.#baseURL)).href; // supports GitLab instances that are on a custom path, e.g. "https://example.com/gitlab"
const graphqlFetch = async (
input: RequestInfo | URL,
init?: RequestInit,
): Promise<Response> => {
const url = input instanceof URL ? input.toString() : input;
return this.#lsFetch.post(url, {
...init,
headers: { ...headers, ...init?.headers },
});
};
const headers = this.#getDefaultHeaders(this.#token);
const client = new GraphQLClient(endpoint, {
headers,
fetch: graphqlFetch,
});
return client.request(document, variables);
}
async #fetch<T>(
apiResourcePath: string,
query: Record<string, QueryValue> = {},
resourceName = 'resource',
headers?: Record<string, string>,
): Promise<T> {
const url = `${this.#baseURL}/api/v4${apiResourcePath}${createQueryString(query)}`;
const result = await this.#lsFetch.get(url, {
headers: { ...this.#getDefaultHeaders(this.#token), ...headers },
});
await handleFetchError(result, resourceName);
return result.json() as Promise<T>;
}
async #postFetch<T>(
apiResourcePath: string,
resourceName = 'resource',
body?: unknown,
headers?: Record<string, string>,
): Promise<T> {
const url = `${this.#baseURL}/api/v4${apiResourcePath}`;
const response = await this.#lsFetch.post(url, {
headers: {
'Content-Type': 'application/json',
...this.#getDefaultHeaders(this.#token),
...headers,
},
body: JSON.stringify(body),
});
await handleFetchError(response, resourceName);
return response.json() as Promise<T>;
}
#getDefaultHeaders(token?: string) {
return {
Authorization: `Bearer ${token}`,
'User-Agent': `code-completions-language-server-experiment (${this.#clientInfo?.name}:${this.#clientInfo?.version})`,
'X-Gitlab-Language-Server-Version': getLanguageServerVersion(),
};
}
#instanceVersionHigherOrEqualThen(version: string): boolean {
if (!this.#instanceVersion) return false;
return semverCompare(this.#instanceVersion, version) >= 0;
}
async #getGitLabInstanceVersion(): Promise<string> {
if (!this.#token) {
return '';
}
const headers = this.#getDefaultHeaders(this.#token);
const response = await this.#lsFetch.get(`${this.#baseURL}/api/v4/version`, {
headers,
});
const { version } = await response.json();
return version;
}
get instanceVersion() {
return this.#instanceVersion;
}
}
References: |
You are a code assistant | Definition of 'toEventuallyContainChildProcessConsoleOutput' in file src/tests/int/test_utils.ts in project gitlab-lsp | Definition:
async toEventuallyContainChildProcessConsoleOutput(
lsClient: LspClient,
expectedMessage: string,
timeoutMs = 1000,
intervalMs = 25,
) {
const expectedResult = `Expected language service child process console output to contain "${expectedMessage}"`;
const checkOutput = () =>
lsClient.childProcessConsole.some((line) => line.includes(expectedMessage));
const sleep = () =>
new Promise((resolve) => {
setTimeout(resolve, intervalMs);
});
let remainingRetries = Math.ceil(timeoutMs / intervalMs);
while (remainingRetries > 0) {
if (checkOutput()) {
return {
message: () => expectedResult,
pass: true,
};
}
// eslint-disable-next-line no-await-in-loop
await sleep();
remainingRetries--;
}
return {
message: () => `"${expectedResult}", but it was not found within ${timeoutMs}ms`,
pass: false,
};
},
});
References: |
You are a code assistant | Definition of 'startStream' in file src/common/suggestion/streaming_handler.ts in project gitlab-lsp | Definition:
async startStream() {
return startStreaming(this.#params);
}
}
const startStreaming = async ({
additionalContexts,
api,
circuitBreaker,
connection,
documentContext,
parser,
postProcessorPipeline,
streamId,
tracker,
uniqueTrackingId,
userInstruction,
generationType,
}: StartStreamParams) => {
const language = parser.getLanguageNameForFile(documentContext.fileRelativePath);
tracker.setCodeSuggestionsContext(uniqueTrackingId, {
documentContext,
additionalContexts,
source: SuggestionSource.network,
language,
isStreaming: true,
});
let streamShown = false;
let suggestionProvided = false;
let streamCancelledOrErrored = false;
const cancellationTokenSource = new CancellationTokenSource();
const disposeStopStreaming = connection.onNotification(CancelStreaming, (stream) => {
if (stream.id === streamId) {
streamCancelledOrErrored = true;
cancellationTokenSource.cancel();
if (streamShown) {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.REJECTED);
} else {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.CANCELLED);
}
}
});
const cancellationToken = cancellationTokenSource.token;
const endStream = async () => {
await connection.sendNotification(StreamingCompletionResponse, {
id: streamId,
done: true,
});
if (!streamCancelledOrErrored) {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.STREAM_COMPLETED);
if (!suggestionProvided) {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.NOT_PROVIDED);
}
}
};
circuitBreaker.success();
const request: CodeSuggestionRequest = {
prompt_version: 1,
project_path: '',
project_id: -1,
current_file: {
content_above_cursor: documentContext.prefix,
content_below_cursor: documentContext.suffix,
file_name: documentContext.fileRelativePath,
},
intent: 'generation',
stream: true,
...(additionalContexts?.length && {
context: additionalContexts,
}),
...(userInstruction && {
user_instruction: userInstruction,
}),
generation_type: generationType,
};
const trackStreamStarted = once(() => {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.STREAM_STARTED);
});
const trackStreamShown = once(() => {
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.SHOWN);
streamShown = true;
});
try {
for await (const response of api.getStreamingCodeSuggestions(request)) {
if (cancellationToken.isCancellationRequested) {
break;
}
if (circuitBreaker.isOpen()) {
break;
}
trackStreamStarted();
const processedCompletion = await postProcessorPipeline.run({
documentContext,
input: { id: streamId, completion: response, done: false },
type: 'stream',
});
await connection.sendNotification(StreamingCompletionResponse, processedCompletion);
if (response.replace(/\s/g, '').length) {
trackStreamShown();
suggestionProvided = true;
}
}
} catch (err) {
circuitBreaker.error();
if (isFetchError(err)) {
tracker.updateCodeSuggestionsContext(uniqueTrackingId, { status: err.status });
}
tracker.updateSuggestionState(uniqueTrackingId, TRACKING_EVENTS.ERRORED);
streamCancelledOrErrored = true;
log.error('Error streaming code suggestions.', err);
} finally {
await endStream();
disposeStopStreaming.dispose();
cancellationTokenSource.dispose();
}
};
References:
- src/common/suggestion/streaming_handler.test.ts:156
- src/common/suggestion/streaming_handler.test.ts:305
- src/common/suggestion/streaming_handler.test.ts:119
- src/common/suggestion/streaming_handler.test.ts:362
- src/common/suggestion/streaming_handler.test.ts:268
- src/common/suggestion/streaming_handler.test.ts:104
- src/common/suggestion/streaming_handler.test.ts:328
- src/common/suggestion/streaming_handler.test.ts:170
- src/common/suggestion/streaming_handler.test.ts:227
- src/common/suggestion/streaming_handler.test.ts:185
- src/common/suggestion/streaming_handler.test.ts:420
- src/common/suggestion/streaming_handler.test.ts:246
- src/common/suggestion/streaming_handler.test.ts:383
- src/common/suggestion/streaming_handler.test.ts:256 |
You are a code assistant | Definition of 'ExtensionConnectionMessageBusProviderProps' in file src/common/webview/extension/extension_connection_message_bus_provider.ts in project gitlab-lsp | Definition:
type ExtensionConnectionMessageBusProviderProps = {
connection: Connection;
logger: Logger;
notificationRpcMethod?: string;
requestRpcMethod?: string;
};
export class ExtensionConnectionMessageBusProvider
implements ExtensionMessageBusProvider, Disposable
{
#connection: Connection;
#rpcMethods: RpcMethods;
#handlers: Handlers;
#logger: Logger;
#notificationHandlers = new ExtensionMessageHandlerRegistry();
#requestHandlers = new ExtensionMessageHandlerRegistry();
#disposables = new CompositeDisposable();
constructor({
connection,
logger,
notificationRpcMethod = DEFAULT_NOTIFICATION_RPC_METHOD,
requestRpcMethod = DEFAULT_REQUEST_RPC_METHOD,
}: ExtensionConnectionMessageBusProviderProps) {
this.#connection = connection;
this.#logger = withPrefix(logger, '[ExtensionConnectionMessageBusProvider]');
this.#rpcMethods = {
notification: notificationRpcMethod,
request: requestRpcMethod,
};
this.#handlers = {
notification: new ExtensionMessageHandlerRegistry(),
request: new ExtensionMessageHandlerRegistry(),
};
this.#setupConnectionSubscriptions();
}
getMessageBus<T extends MessageMap>(webviewId: WebviewId): MessageBus<T> {
return new ExtensionConnectionMessageBus({
webviewId,
connection: this.#connection,
rpcMethods: this.#rpcMethods,
handlers: this.#handlers,
});
}
dispose(): void {
this.#disposables.dispose();
}
#setupConnectionSubscriptions() {
this.#disposables.add(
this.#connection.onNotification(
this.#rpcMethods.notification,
handleNotificationMessage(this.#notificationHandlers, this.#logger),
),
);
this.#disposables.add(
this.#connection.onRequest(
this.#rpcMethods.request,
handleRequestMessage(this.#requestHandlers, this.#logger),
),
);
}
}
References:
- src/common/webview/extension/extension_connection_message_bus_provider.ts:45 |
You are a code assistant | Definition of 'Listener' in file packages/lib_webview/src/events/message_bus.ts in project gitlab-lsp | Definition:
type Listener<T = unknown> = (data: T) => void;
type FilterFunction<T> = (data: T) => boolean;
interface Subscription<T> {
listener: Listener<T>;
filter?: FilterFunction<T>;
}
export class MessageBus<TMessageMap extends Record<string, unknown>> implements Disposable {
#subscriptions = new Map<keyof TMessageMap, Set<Subscription<unknown>>>();
public subscribe<K extends keyof TMessageMap>(
messageType: K,
listener: Listener<TMessageMap[K]>,
filter?: FilterFunction<TMessageMap[K]>,
): Disposable {
const subscriptions = this.#subscriptions.get(messageType) ?? new Set<Subscription<unknown>>();
const subscription: Subscription<unknown> = {
listener: listener as Listener<unknown>,
filter: filter as FilterFunction<unknown> | undefined,
};
subscriptions.add(subscription);
this.#subscriptions.set(messageType, subscriptions);
return {
dispose: () => {
const targetSubscriptions = this.#subscriptions.get(messageType);
if (targetSubscriptions) {
targetSubscriptions.delete(subscription);
if (targetSubscriptions.size === 0) {
this.#subscriptions.delete(messageType);
}
}
},
};
}
public publish<K extends keyof TMessageMap>(messageType: K, data: TMessageMap[K]): void {
const targetSubscriptions = this.#subscriptions.get(messageType);
if (targetSubscriptions) {
Array.from(targetSubscriptions).forEach((subscription) => {
const { listener, filter } = subscription as Subscription<TMessageMap[K]>;
if (!filter || filter(data)) {
listener(data);
}
});
}
}
public hasListeners<K extends keyof TMessageMap>(messageType: K): boolean {
return this.#subscriptions.has(messageType);
}
public listenerCount<K extends keyof TMessageMap>(messageType: K): number {
return this.#subscriptions.get(messageType)?.size ?? 0;
}
public clear(): void {
this.#subscriptions.clear();
}
public dispose(): void {
this.clear();
}
}
References: |
You are a code assistant | Definition of 'SPECIAL_MESSAGES' in file packages/webview_duo_chat/src/plugin/port/chat/constants.ts in project gitlab-lsp | Definition:
export const SPECIAL_MESSAGES = {
RESET: '/reset',
CLEAN: '/clean',
};
export const PLATFORM_ORIGIN = 'vs_code_extension';
References: |
You are a code assistant | Definition of 'processStream' in file src/common/suggestion_client/post_processors/post_processor_pipeline.test.ts in project gitlab-lsp | Definition:
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return { ...input, completion: `${input.completion} [2]` };
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
pipeline.addProcessor(new Processor1());
pipeline.addProcessor(new Processor2());
const streamInput: StreamingCompletionResponse = { id: '1', completion: 'test', done: false };
const result = await pipeline.run({
documentContext: mockContext,
input: streamInput,
type: 'stream',
});
expect(result).toEqual({ id: '1', completion: 'test [1] [2]', done: false });
});
test('should chain multiple processors correctly for completion input', async () => {
class Processor1 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input.map((option) => ({ ...option, text: `${option.text} [1]` }));
}
}
class Processor2 extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input.map((option) => ({ ...option, text: `${option.text} [2]` }));
}
}
pipeline.addProcessor(new Processor1());
pipeline.addProcessor(new Processor2());
const completionInput: SuggestionOption[] = [{ text: 'option1', uniqueTrackingId: '1' }];
const result = await pipeline.run({
documentContext: mockContext,
input: completionInput,
type: 'completion',
});
expect(result).toEqual([{ text: 'option1 [1] [2]', uniqueTrackingId: '1' }]);
});
test('should throw an error for unexpected type', async () => {
class TestProcessor extends PostProcessor {
async processStream(
_context: IDocContext,
input: StreamingCompletionResponse,
): Promise<StreamingCompletionResponse> {
return input;
}
async processCompletion(
_context: IDocContext,
input: SuggestionOption[],
): Promise<SuggestionOption[]> {
return input;
}
}
pipeline.addProcessor(new TestProcessor());
const invalidInput = { invalid: 'input' };
await expect(
pipeline.run({
documentContext: mockContext,
input: invalidInput as unknown as StreamingCompletionResponse,
type: 'invalid' as 'stream',
}),
).rejects.toThrow('Unexpected type in pipeline processing');
});
});
References: |
You are a code assistant | Definition of 'streamFetch' in file src/common/fetch.ts in project gitlab-lsp | Definition:
async *streamFetch(
/* eslint-disable @typescript-eslint/no-unused-vars */
_url: string,
_body: string,
_headers: FetchHeaders,
/* eslint-enable @typescript-eslint/no-unused-vars */
): AsyncGenerator<string, void, void> {
// Stub. Should delegate to the node or browser fetch implementations
throw new Error('Not implemented');
yield '';
}
async delete(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('DELETE', init));
}
async get(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('GET', init));
}
async post(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('POST', init));
}
async put(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
return this.fetch(input, this.updateRequestInit('PUT', init));
}
async fetchBase(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
// eslint-disable-next-line no-underscore-dangle, no-restricted-globals
const _global = typeof global === 'undefined' ? self : global;
return _global.fetch(input, init);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
updateAgentOptions(_opts: FetchAgentOptions): void {}
}
References: |
You are a code assistant | Definition of 'BImpl' in file packages/lib_di/src/index.test.ts in project gitlab-lsp | Definition:
class BImpl implements B {
#a: A;
constructor(a: A) {
this.#a = a;
}
b = () => `B(${this.#a.a()})`;
}
@Injectable(C, [A, B])
class CImpl implements C {
#a: A;
#b: B;
constructor(a: A, b: B) {
this.#a = a;
this.#b = b;
}
c = () => `C(${this.#b.b()}, ${this.#a.a()})`;
}
let container: Container;
beforeEach(() => {
container = new Container();
});
describe('addInstances', () => {
const O = createInterfaceId<object>('object');
it('fails if the instance is not branded', () => {
expect(() => container.addInstances({ say: 'hello' } as BrandedInstance<object>)).toThrow(
/invoked without branded object/,
);
});
it('fails if the instance is already present', () => {
const a = brandInstance(O, { a: 'a' });
const b = brandInstance(O, { b: 'b' });
expect(() => container.addInstances(a, b)).toThrow(/this ID is already in the container/);
});
it('adds instance', () => {
const instance = { a: 'a' };
const a = brandInstance(O, instance);
container.addInstances(a);
expect(container.get(O)).toBe(instance);
});
});
describe('instantiate', () => {
it('can instantiate three classes A,B,C', () => {
container.instantiate(AImpl, BImpl, CImpl);
const cInstance = container.get(C);
expect(cInstance.c()).toBe('C(B(a), a)');
});
it('instantiates dependencies in multiple instantiate calls', () => {
container.instantiate(AImpl);
// the order is important for this test
// we want to make sure that the stack in circular dependency discovery is being cleared
// to try why this order is necessary, remove the `inStack.delete()` from
// the `if (!cwd && instanceIds.includes(id))` condition in prod code
expect(() => container.instantiate(CImpl, BImpl)).not.toThrow();
});
it('detects duplicate ids', () => {
@Injectable(A, [])
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl, AImpl2)).toThrow(
/The following interface IDs were used multiple times 'A' \(classes: AImpl,AImpl2\)/,
);
});
it('detects duplicate id with pre-existing instance', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
expect(() => container.instantiate(AImpl)).toThrow(/classes are clashing/);
});
it('detects missing dependencies', () => {
expect(() => container.instantiate(BImpl)).toThrow(
/Class BImpl \(interface B\) depends on interfaces \[A]/,
);
});
it('it uses existing instances as dependencies', () => {
const aInstance = new AImpl();
const a = brandInstance(A, aInstance);
container.addInstances(a);
container.instantiate(BImpl);
expect(container.get(B).b()).toBe('B(a)');
});
it("detects classes what aren't decorated with @Injectable", () => {
class AImpl2 implements A {
a = () => 'hello';
}
expect(() => container.instantiate(AImpl2)).toThrow(
/Classes \[AImpl2] are not decorated with @Injectable/,
);
});
it('detects circular dependencies', () => {
@Injectable(A, [C])
class ACircular implements A {
a = () => 'hello';
constructor(c: C) {
// eslint-disable-next-line no-unused-expressions
c;
}
}
expect(() => container.instantiate(ACircular, BImpl, CImpl)).toThrow(
/Circular dependency detected between interfaces \(A,C\), starting with 'A' \(class: ACircular\)./,
);
});
// this test ensures that we don't store any references to the classes and we instantiate them only once
it('does not instantiate classes from previous instantiate call', () => {
let globCount = 0;
@Injectable(A, [])
class Counter implements A {
counter = globCount;
constructor() {
globCount++;
}
a = () => this.counter.toString();
}
container.instantiate(Counter);
container.instantiate(BImpl);
expect(container.get(A).a()).toBe('0');
});
});
describe('get', () => {
it('returns an instance of the interfaceId', () => {
container.instantiate(AImpl);
expect(container.get(A)).toBeInstanceOf(AImpl);
});
it('throws an error for missing dependency', () => {
container.instantiate();
expect(() => container.get(A)).toThrow(/Instance for interface 'A' is not in the container/);
});
});
});
References: |
You are a code assistant | Definition of 'mostRecentFiles' in file src/common/advanced_context/lru_cache.ts in project gitlab-lsp | Definition:
mostRecentFiles({
context,
includeCurrentFile = true,
}: {
context?: IDocContext;
includeCurrentFile?: boolean;
}): IDocContext[] {
const files = Array.from(this.#cache.values());
if (includeCurrentFile) {
return files;
}
return files.filter(
(file) =>
context?.workspaceFolder?.uri === file.workspaceFolder?.uri && file.uri !== context?.uri,
);
}
}
References: |
You are a code assistant | Definition of 'WebviewMetadataProvider' in file src/common/webview/webview_metadata_provider.ts in project gitlab-lsp | Definition:
export class WebviewMetadataProvider {
#plugins: Set<WebviewPlugin>;
#accessInfoProviders: WebviewLocationService;
constructor(accessInfoProviders: WebviewLocationService, plugins: Set<WebviewPlugin>) {
this.#accessInfoProviders = accessInfoProviders;
this.#plugins = plugins;
}
getMetadata(): WebviewMetadata[] {
return Array.from(this.#plugins).map((plugin) => ({
id: plugin.id,
title: plugin.title,
uris: this.#accessInfoProviders.resolveUris(plugin.id),
}));
}
}
References:
- src/node/main.ts:178
- src/common/webview/webview_metadata_provider.test.ts:20
- src/common/webview/webview_metadata_provider.test.ts:25 |
You are a code assistant | Definition of 'sendRequest' in file packages/lib_message_bus/src/types/bus.ts in project gitlab-lsp | Definition:
sendRequest<T extends KeysWithOptionalParams<TRequests>>(
type: T,
): Promise<ExtractRequestResult<TRequests[T]>>;
sendRequest<T extends keyof TRequests>(
type: T,
payload: TRequests[T]['params'],
): Promise<ExtractRequestResult<TRequests[T]>>;
}
/**
* Interface for listening to requests.
* @interface
* @template {RequestMap} TRequests
*/
export interface RequestListener<TRequests extends RequestMap> {
onRequest<T extends KeysWithOptionalParams<TRequests>>(
type: T,
handler: () => Promise<ExtractRequestResult<TRequests[T]>>,
): Disposable;
onRequest<T extends keyof TRequests>(
type: T,
handler: (payload: TRequests[T]['params']) => Promise<ExtractRequestResult<TRequests[T]>>,
): Disposable;
}
/**
* Defines the structure for message definitions, including notifications and requests.
*/
export type MessageDefinitions<
TNotifications extends NotificationMap = NotificationMap,
TRequests extends RequestMap = RequestMap,
> = {
notifications: TNotifications;
requests: TRequests;
};
export type MessageMap<
TInboundMessageDefinitions extends MessageDefinitions = MessageDefinitions,
TOutboundMessageDefinitions extends MessageDefinitions = MessageDefinitions,
> = {
inbound: TInboundMessageDefinitions;
outbound: TOutboundMessageDefinitions;
};
export interface MessageBus<T extends MessageMap = MessageMap>
extends NotificationPublisher<T['outbound']['notifications']>,
NotificationListener<T['inbound']['notifications']>,
RequestPublisher<T['outbound']['requests']>,
RequestListener<T['inbound']['requests']> {}
References: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.