@vscode/chat-lib 0.0.1

package/src/_internal/platform/inlineCompletions/common/api.ts

@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import type * as vscode from 'vscode';
+
+
+export namespace Copilot {
+
+	export type DocumentUri = string;
+
+	export type Position = {
+		line: number;
+		character: number;
+	}
+
+	export type Range = {
+		start: Position;
+		end: Position;
+	}
+
+	/**
+	* The ContextProvider API allows extensions to provide additional context items that
+	* Copilot can use in its prompt. This file contains type definitions for the methods
+	* and the data structures used by the API.
+	*
+	* Note: providing context is not enough to ensure that the context will be used in the prompt.
+	*
+	* The API is exposed as an export of the Copilot extension. To use it, you can cast the
+	* exported object to the ContextProviderApiV1 interface.
+	*
+	* Example:
+	* ```
+	* const copilot = vscode.extensions.getExtension("github.copilot");
+	* const contextProviderAPI = copilot.exports.getContextProviderAPI("v1") as ContextProviderApiV1;
+	* ```
+	*/
+	export interface ContextProviderApiV1 {
+		registerContextProvider<T extends SupportedContextItem>(provider: ContextProvider<T>): vscode.Disposable;
+	}
+
+	/**
+	* Each extension can register a number of context providers, uniquely identified by their ID.
+	* In addition, each provider has to provide:
+	* - a DocumentSelector, to specify the file types for which the provider is active
+	* - a ContextResolver, a function that returns the context items for a given request
+	*
+	* Example:
+	* ```
+	* contextProviderAPI.registerContextProvider<Trait>({
+	*  id: "pythonProvider",
+	*  selector: [{ language: "python" }],
+	*  resolver: {
+	*      resolve: async (request, token) => {
+	*        return [{name: 'traitName', value: 'traitValue'}];
+	*      }
+	*  }
+	* });
+	* ```
+	*/
+	export interface ContextProvider<T extends SupportedContextItem> {
+		id: string;
+		selector: vscode.DocumentSelector;
+		resolver: ContextResolver<T>;
+	}
+
+	export interface ContextResolver<T extends SupportedContextItem> {
+		resolve(request: ResolveRequest, token: vscode.CancellationToken): Promise<T> | Promise<T[]> | AsyncIterable<T>;
+		// Optional method to be invoked if the request timed out. This requests additional context items.
+		resolveOnTimeout?(request: ResolveRequest): T | readonly T[] | undefined;
+	}
+
+	/**
+	 * The first argument of the resolve method is a ResolveRequest object, which informs
+	 * the provider about:
+	 * - the completionId, a unique identifier for the completion request
+	 * - the documentContext, which contains information about the document for which the context is requested
+	 * - the activeExperiments, a map of active experiments and their values
+	 * - the timeBudget the provider has to provide context items
+	 * - the previousUsageStatistics, which contains information about the last request to the provider
+	 */
+	export type Status = 'full' | 'partial' | 'none';
+
+	export type ContextUsageStatistics = {
+		usage: Status;
+		resolution: Status;
+	};
+
+	interface TextEdit {
+		/**
+		* The range of the text document to be manipulated. To insert
+		* text into a document create a range where start === end.
+		*/
+		range: Range;
+		/**
+		* The string to be inserted. For delete operations use an
+		* empty string.
+		*/
+		newText: string;
+	}
+
+	export type ProposedTextEdit = TextEdit & {
+		positionAfterEdit: Position;
+		// Indicates whether the edit is suggested by the IDE. Otherwise it's assumed to be speculative
+		source?: 'selectedCompletionInfo';
+	};
+
+	export interface DocumentContext {
+		uri: DocumentUri;
+		languageId: string;
+		version: number;
+		// Position and offset are relative to the provided version of the document.
+		// The position after an edit is applied is found in ProposedTextEdit.positionAfterEdit.
+		/**
+		 * @deprecated Use `position` instead.
+		 */
+		offset: number;
+		position?: Position;
+		proposedEdits?: ProposedTextEdit[];
+	}
+	export interface ResolveRequest {
+		// A unique ID to correlate the request with the completion request.
+		completionId: string;
+		// Optional the opportunity ID provided by VS Code core.
+		opportunityId?: string;
+
+		documentContext: DocumentContext;
+
+		activeExperiments: Map<string, string | number | boolean | string[]>;
+
+		/**
+		 * The number of milliseconds for the context provider to provide context items.
+		 * After the time budget runs out, the request will be cancelled via the CancellationToken.
+		 * Providers can use this value as a hint when computing context. Providers should expect the
+		 * request to be cancelled once the time budget runs out.
+		 *
+		 * @deprecated Use `timeoutEnd` instead.
+		 */
+		timeBudget: number;
+
+		/**
+		 * Unix timestamp representing the exact time the request will be cancelled via the CancellationToken.
+		 */
+		timeoutEnd: number;
+
+		/**
+		 * Various statistics about the last completion request. This can be used by the context provider
+		 * to make decisions about what context to provide for the current call.
+		 */
+		previousUsageStatistics?: ContextUsageStatistics;
+
+		/**
+		 * Data from completionItem
+		 *
+		 * See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#completionItem
+		 */
+		data?: unknown;
+
+		/**
+		 * Allows specifying the source of the context item, e.g., 'nes'.
+		 *
+		 * @experimental
+		 */
+		source: string;
+	}
+
+	/**
+	 * These are the data types that can be provided by a context provider. Any non-conforming
+	 * context items will be filtered out.
+	 */
+	interface ContextItem {
+		/**
+		 * Specifies the relative importance with respect to items of the same type.
+		 * Cross-type comparisons is currently handled by the wishlist.
+		 * Accepted values are integers in the range [0, 100], where 100 is the highest importance.
+		 * Items with non-conforming importance values will be filtered out.
+		 * Default value is 0.
+		 */
+		importance?: number;
+	}
+
+	// A key-value pair used for short string snippets.
+	export interface Trait extends ContextItem {
+		name: string;
+		value: string;
+	}
+
+	// Code snippet extracted from a file. The URI is used for content exclusion.
+	export interface CodeSnippet extends ContextItem {
+		uri: string;
+		value: string;
+		// Additional URIs that contribute the same code snippet.
+		additionalUris?: string[];
+	}
+
+	export type SupportedContextItem = Trait | CodeSnippet;
+
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/diagnosticData.ts

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { isEqual } from '../../../../util/vs/base/common/resources';
+import { URI } from '../../../../util/vs/base/common/uri';
+import { OffsetRange } from '../../../../util/vs/editor/common/core/ranges/offsetRange';
+
+export class DiagnosticData {
+	constructor(
+		public readonly documentUri: URI,
+		public readonly message: string,
+		public readonly severity: 'error' | 'warning',
+		public readonly range: OffsetRange,
+		public readonly code: string | number | undefined,
+		public readonly source: string | undefined,
+	) { }
+
+	public toString(): string {
+		return `${this.severity.toUpperCase()}: ${this.message} (${this.range})`;
+	}
+
+	public equals(other: DiagnosticData): boolean {
+		return isEqual(this.documentUri, other.documentUri)
+			&& this.message === other.message
+			&& this.severity === other.severity
+			&& this.range.equals(other.range)
+			&& this.code === other.code
+			&& this.source === other.source;
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/documentId.ts

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CachedFunction } from '../../../../util/vs/base/common/cache';
+import { basename, extname } from '../../../../util/vs/base/common/path';
+import { URI } from '../../../../util/vs/base/common/uri';
+
+/**
+ * Refers to a document, independent of its content or a point in time.
+ * Two document ids are equal if they are triple-equal.
+*/
+export class DocumentId {
+	private static readonly _cache = new CachedFunction({ getCacheKey: JSON.stringify }, (arg: { uri: string }) => new DocumentId(arg.uri));
+	public static create(uri: string): DocumentId {
+		return DocumentId._cache.get({ uri });
+	}
+
+	private readonly _uri = URI.parse(this.uri);
+
+	private constructor(
+		public readonly uri: string,
+	) {
+	}
+
+	public get path(): string {
+		return this._uri.path;
+	}
+
+	public get fragment(): string {
+		return this._uri.fragment;
+	}
+
+	public toString(): string {
+		return this.uri;
+	}
+
+	public get baseName(): string {
+		return basename(this.uri);
+	}
+
+	public get extension(): string {
+		return extname(this.uri);
+	}
+
+	public toUri(): URI {
+		return this._uri;
+	}
+}
+
+export type SerializedDocumentId = string;

package/src/_internal/platform/inlineEdits/common/dataTypes/edit.ts

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { assertFn } from '../../../../util/vs/base/common/assert';
+import { BaseEdit } from '../../../../util/vs/editor/common/core/edits/edit';
+import { LineEdit } from '../../../../util/vs/editor/common/core/edits/lineEdit';
+import { BaseStringEdit, BaseStringReplacement, StringEdit } from '../../../../util/vs/editor/common/core/edits/stringEdit';
+import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
+import { deserializeStringEdit, SerializedEdit, serializeStringEdit } from './editUtils';
+import { RootedLineEdit } from './rootedLineEdit';
+
+export class RootedEdit<TEdit extends BaseStringEdit<BaseStringReplacement<any>, any> = StringEdit> {
+
+	public static toLineEdit(edit: RootedEdit<BaseStringEdit<BaseStringReplacement<any>, any>>): LineEdit {
+		return LineEdit.fromEdit(edit.edit as StringEdit, edit.base);
+	}
+
+	constructor(
+		public readonly base: StringText,
+		public readonly edit: TEdit,
+	) { }
+
+	public getEditedState(): StringText {
+		return this.edit.applyOnText(this.base);
+	}
+
+	/**
+	 * Creates a rooted edit `r`, such that
+	 * * `r.initialState.equals(this.initialState.apply(onto))`
+	 * * `(r.initialState.apply(r.edit)).equals(this.initialState.apply(onto).apply(this.edit))`
+	*/
+	public rebase(onto: StringEdit): RootedEdit {
+		const result: RootedEdit = null!;
+
+		// TODO implement
+
+		assertFn(() => result.base.equals(onto.applyOnText(this.base)));
+		assertFn(() => result.edit.applyOnText(result.base).equals(this.edit.applyOnText(onto.applyOnText(this.base))));
+
+		return result;
+	}
+
+	public toString(): string {
+		const e = RootedLineEdit.fromEdit(this);
+		return e.toString();
+	}
+
+	/**
+	 * If `r.base.equals(this.base)` and `r.getEditedState().equals(this.getEditedState())`, then `r.normalize().equals(this.normalize())`.
+	*/
+	public normalize(): RootedEdit {
+		return new RootedEdit(this.base, this.edit.normalizeOnSource(this.base.value));
+	}
+
+	public equals(other: RootedEdit): boolean {
+		return this.base.equals(other.base) && this.edit.equals(other.edit);
+	}
+}
+
+export type TReplacement<TEdit> = TEdit extends BaseEdit<infer TReplacement, any> ? TReplacement : never;
+
+/**
+ * Represents a sequence of single edits.
+*/
+export class SingleEdits<TEdit extends BaseStringEdit<BaseStringReplacement<any>, any> = StringEdit> {
+	constructor(
+		/**
+		 * The edits are applied in order and don't have to be sorted.
+		*/
+		public readonly edits: readonly TEdit['TReplacement'][],
+	) { }
+
+	compose(): StringEdit {
+		return StringEdit.compose(this.edits.map(e => e.toEdit()));
+	}
+
+	apply(value: string): string {
+		return this.compose().apply(value);
+	}
+
+	isEmpty(): boolean {
+		return this.edits.length === 0;
+	}
+
+	toEdits(): Edits<StringEdit> {
+		return new Edits(StringEdit, this.edits.map(e => e.toEdit()));
+	}
+}
+
+/**
+ * Represents a sequence of edits.
+*/
+export class Edits<T extends BaseStringEdit<BaseStringReplacement<any>, any> = StringEdit> {
+	public static single(edit: StringEdit): Edits {
+		return new Edits(StringEdit, [edit]);
+	}
+
+	constructor(
+		private readonly _editType: new (replacements: readonly TReplacement<T>[]) => T,
+		/**
+		 * The edits are applied in given order and don't have to be sorted.
+		 * Least to most recent.
+		 */
+		public readonly edits: readonly T[],
+	) { }
+
+	compose(): T {
+		let edit = new this._editType([]);
+		for (const e of this.edits) {
+			edit = edit.compose(e);
+		}
+		return edit;
+	}
+
+	add(edit: T): Edits<T> {
+		return new Edits(this._editType, [...this.edits, edit]);
+	}
+
+	apply(value: string): string {
+		return this.compose().apply(value);
+	}
+
+	isEmpty(): boolean {
+		return this.edits.length === 0;
+	}
+
+	swap(editFirst: StringEdit): { edits: Edits; editLast: StringEdit } | undefined {
+		let eM = editFirst;
+		const newEdits: StringEdit[] = [];
+		for (const e of this.edits) {
+			const e_ = BaseStringEdit.trySwap(eM, e);
+			if (!e_) {
+				return undefined;
+			}
+			newEdits.push(e_.e1);
+			eM = e_.e2;
+		}
+		return { edits: new Edits(StringEdit, newEdits), editLast: eM };
+	}
+
+	/*mapData<T2 extends IEditData<T2> | void = void>(f: (data: T) => T2): Edits<T2> {
+		return new Edits(this.edits.map(e => e.mapData(f)));
+	}*/
+
+	serialize(): SerializedEdit[] {
+		return this.edits.map(e => serializeStringEdit(e));
+	}
+
+	public static deserialize(v: SerializedEdit[]): Edits {
+		return new Edits(StringEdit, v.map(e => deserializeStringEdit(e)));
+	}
+
+	toHumanReadablePatch(base: StringText): string {
+		let curBase = base;
+		const result: string[] = [];
+		for (const edit of this.edits) {
+			const lineEdit = RootedEdit.toLineEdit(new RootedEdit(curBase, edit));
+			result.push(lineEdit.humanReadablePatch(curBase.getLines()));
+			curBase = edit.applyOnText(curBase);
+		}
+		return result.join('\n---\n');
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/editUtils.ts

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { illegalArgument } from '../../../../util/vs/base/common/errors';
+import { BaseStringEdit, BaseStringReplacement, StringEdit, StringReplacement } from '../../../../util/vs/editor/common/core/edits/stringEdit';
+import { OffsetRange } from '../../../../util/vs/editor/common/core/ranges/offsetRange';
+import { SingleEdits } from './edit';
+import { Permutation } from './permutation';
+
+export function serializeStringEdit(edit: BaseStringEdit): SerializedEdit {
+	return edit.replacements.map(e => serializeSingleEdit(e));
+}
+
+export function serializeSingleEdit(edit: BaseStringReplacement): SerializedReplacement {
+	return [edit.replaceRange.start, edit.replaceRange.endExclusive, edit.newText];
+}
+
+export function deserializeStringEdit(serialized: SerializedEdit): StringEdit {
+	return new StringEdit(serialized.map(e => deserializeSingleEdit(e)));
+}
+
+function deserializeSingleEdit(serialized: SerializedReplacement): StringReplacement {
+	return new StringReplacement(
+		new OffsetRange(serialized[0], serialized[1]),
+		serialized[2],
+	);
+}
+
+export type SerializedEdit = SerializedReplacement[];
+
+export type SerializedReplacement = [startOffset: number, endOffsetEx: number, newText: string];
+
+/**
+ * For every single text edit, it creates a new edit.
+ * If permutation is not given, decomposed in-order.
+ */
+export function decomposeStringEdit<TEdit extends BaseStringEdit<BaseStringReplacement, TEdit>>(edit: TEdit, permutation?: Permutation): SingleEdits<TEdit> {
+	if (permutation === undefined) {
+		const result: BaseStringReplacement[] = [];
+		let offset = 0;
+		for (const e of edit.replacements) {
+			result.push(e.delta(offset));
+
+			offset += e.newText.length - e.replaceRange.length;
+		}
+		return new SingleEdits(result);
+	}
+
+	if (edit.replacements.length !== permutation.arrayLength) {
+		throw illegalArgument(`Number of edits ${edit.replacements.length} does not match ${permutation.arrayLength}`);
+	}
+
+	const result: BaseStringReplacement[] = [];
+	const sortedSingleEdits = edit.replacements.slice();
+
+	for (let i = 0; i < edit.replacements.length; ++i) {
+
+		const idxInEdits = permutation.mapIndexBack(i);
+		const singleEdit = sortedSingleEdits[idxInEdits];
+
+		result.push(singleEdit);
+
+		// move all edits that occur after `singleEdit`
+		for (let j = idxInEdits; j < sortedSingleEdits.length; ++j) {
+			const offsetDelta = singleEdit.newText.length - singleEdit.replaceRange.length;
+			const e = sortedSingleEdits[j];
+			sortedSingleEdits[j] = e.delta(offsetDelta);
+		}
+	}
+
+	return new SingleEdits(result);
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/fetchCancellationError.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationError } from '../../../../util/vs/base/common/errors';
+
+export class FetchCancellationError extends CancellationError {
+	constructor(
+		public readonly extraInformation?: string
+	) {
+		super();
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/languageContext.ts

@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Diagnostic, Uri } from '../../../../util/common/test/shims/vscodeTypesShim';
+import { ContextItem, ContextKind, SnippetContext, TraitContext } from '../../../languageServer/common/languageContextService';
+
+export type LanguageContextEntry = {
+	context: ContextItem;
+	timeStamp: number;
+	onTimeout: boolean;
+}
+
+export type LanguageContextResponse = {
+	start: number;
+	end: number;
+	items: LanguageContextEntry[];
+}
+
+type SerializedSnippetContext = {
+	kind: ContextKind.Snippet;
+	priority: number;
+	uri: string;
+	additionalUris?: string[];
+	value: string;
+}
+
+type SerializedTraitContext = {
+	kind: ContextKind.Trait;
+	priority: number;
+	name: string;
+	value: string;
+}
+
+type SerializedContextItem = SerializedSnippetContext | SerializedTraitContext;
+
+export type SerializedContextResponse = {
+	start: number;
+	end: number;
+	items: {
+		context: SerializedContextItem;
+		timeStamp: number;
+	}[];
+}
+
+export function serializeLanguageContext(response: LanguageContextResponse): SerializedContextResponse {
+	return {
+		start: response.start,
+		end: response.end,
+		items: response.items.map(item => ({
+			context: serializeLanguageContextItem(item.context),
+			timeStamp: item.timeStamp,
+			onTimeout: item.onTimeout,
+		}))
+	};
+}
+
+function serializeLanguageContextItem(context: ContextItem): SerializedContextItem {
+	switch (context.kind) {
+		case ContextKind.Snippet:
+			return serializeSnippetContext(context);
+		case ContextKind.Trait:
+			return serializeTraitContext(context);
+	}
+}
+
+function serializeSnippetContext(context: SnippetContext): SerializedSnippetContext {
+	return {
+		kind: context.kind,
+		priority: context.priority,
+		uri: context.uri.toString(),
+		additionalUris: context.additionalUris?.map(uri => uri.toString()),
+		value: context.value
+	};
+}
+
+function serializeTraitContext(context: TraitContext): SerializedTraitContext {
+	return {
+		kind: context.kind,
+		priority: context.priority,
+		name: context.name,
+		value: context.value
+	};
+}
+
+export type SerializedDiagnostic = {
+	uri: string;
+	severity: number;
+	message: string;
+	source: string;
+}
+
+function serializeDiagnostic(diagnostic: Diagnostic, resource: Uri): SerializedDiagnostic {
+	return {
+		uri: resource.toString(),
+		severity: diagnostic.severity,
+		message: diagnostic.message,
+		source: diagnostic.source || ''
+	};
+}
+
+export function serializeFileDiagnostics(diagnostics: [Uri, Diagnostic[]][]): SerializedDiagnostic[] {
+	return diagnostics.flatMap(([resource, diags]) =>
+		diags.map(diagnostic => serializeDiagnostic(diagnostic, resource))
+	);
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/languageId.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export type LanguageId = string & { _brand: 'languageId' };
+
+export namespace LanguageId {
+	export const PlainText = create('plaintext');
+
+	export function create(value: string): LanguageId {
+		return value as LanguageId;
+	}
+}