@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,198 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,32 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,52 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,165 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,74 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,14 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,107 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,14 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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;
-	}
-}