@vscode/chat-lib 0.0.1

package/src/_internal/platform/configuration/common/defaultsOnlyConfigurationService.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { ConfigurationScope } from 'vscode';
+import { IExperimentationService } from '../../telemetry/common/nullExperimentationService';
+import { AbstractConfigurationService, BaseConfig, Config, ExperimentBasedConfig, ExperimentBasedConfigType, InspectConfigResult } from './configurationService';
+
+/** Provides only the default values, ignoring the user's settings or exp. */
+
+export class DefaultsOnlyConfigurationService extends AbstractConfigurationService {
+
+	override getConfig<T>(key: Config<T>): T {
+		return this.getDefaultValue(key);
+	}
+
+	override inspectConfig<T>(key: BaseConfig<T>, scope?: ConfigurationScope): InspectConfigResult<T> | undefined {
+		return {
+			defaultValue: this.getDefaultValue(key),
+		};
+	}
+
+	override setConfig(): Promise<void> {
+		return Promise.resolve();
+	}
+
+	override getNonExtensionConfig<T>(configKey: string): T | undefined {
+		return undefined;
+	}
+
+	override getExperimentBasedConfig<T extends ExperimentBasedConfigType>(key: ExperimentBasedConfig<T>, experimentationService: IExperimentationService, scope?: ConfigurationScope): T {
+		return this.getDefaultValue(key);
+	}
+
+	override dumpConfig(): { [key: string]: string } {
+		return {};
+	}
+}

package/src/_internal/platform/configuration/common/jsonSchema.ts

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export type JsonSchema =
+	| NumericJsonSchema
+	| StringJsonSchema
+	| ArrayJsonSchema
+	| ObjectJsonSchema
+	| JsonSchemaReference
+	| EmptyJsonSchema;
+
+export interface EmptyJsonSchema { }
+
+export interface JsonSchemaReference {
+	$ref: string;
+}
+
+export interface BaseJsonSchema {
+	$id?: string;
+	$schema?: string;
+	title?: string;
+	description?: string;
+
+	definitions?: {
+		[name: string]: JsonSchema;
+	};
+
+	enum?: unknown[];
+	format?: string | Format;
+
+	if?: JsonSchema;
+	then?: JsonSchema;
+	else?: JsonSchema;
+	allOf?: JsonSchema[];
+	anyOf?: JsonSchema[];
+	oneOf?: JsonSchema[];
+	not?: JsonSchema;
+}
+
+export type Format =
+	| typeof Format.dateTime
+	| typeof Format.date
+	| typeof Format.time
+	| typeof Format.email
+	| typeof Format.idnEmail
+	| typeof Format.hostname
+	| typeof Format.idnHostname
+	| typeof Format.ipv4
+	| typeof Format.ipv6
+	| typeof Format.uri
+	| typeof Format.uriReference
+	| typeof Format.iri
+	| typeof Format.iriReference
+	| typeof Format.uriTemplate
+	| typeof Format.jsonPointer
+	| typeof Format.relativeJsonPointer
+	| typeof Format.regex;
+
+export namespace Format {
+	export const dateTime = "date-time";
+	export const date = "date";
+	export const time = "time";
+	export const email = "email";
+	export const idnEmail = "idn-email";
+	export const hostname = "hostname";
+	export const idnHostname = "idn-hostname";
+	export const ipv4 = "ipv4";
+	export const ipv6 = "ipv6";
+	export const uri = "uri";
+	export const uriReference = "uri-reference";
+	export const iri = "iri";
+	export const iriReference = "iri-reference";
+	export const uriTemplate = "uri-template";
+	export const jsonPointer = "json-pointer";
+	export const relativeJsonPointer = "relative-json-pointer";
+	export const regex = "regex";
+}
+
+export interface NumericJsonSchema extends BaseJsonSchema {
+	type: JsonSchemaType.Numeric | JsonSchemaType[];
+	multipleOf?: number;
+	maximum?: number;
+	exclusiveMaximum?: boolean;
+	minimum?: number;
+	exclusiveMinimum?: boolean;
+}
+
+export interface StringJsonSchema extends BaseJsonSchema {
+	type: typeof JsonSchemaType.string | JsonSchemaType[];
+	maxLength?: number;
+	minLength?: number;
+	pattern?: string;
+}
+
+export interface ArrayJsonSchema extends BaseJsonSchema {
+	type: typeof JsonSchemaType.array | JsonSchemaType[];
+	items?: JsonSchema | JsonSchema[];
+	additionalItems?: JsonSchema;
+	maxItems?: number;
+	minItems?: number;
+	uniqueItems?: boolean;
+	contains: JsonSchema;
+}
+
+export interface ObjectJsonSchema extends BaseJsonSchema {
+	type: typeof JsonSchemaType.object | JsonSchemaType[];
+	maxProperties?: number;
+	minProperties?: number;
+	required?: string[];
+	properties?: {
+		[name: string]: JsonSchema;
+	};
+	patternProperties?: {
+		[name: string]: JsonSchema;
+	};
+	additionalProperties?: JsonSchema;
+	dependencies?: {
+		[name: string]: JsonSchema | string[];
+	};
+}
+
+namespace JsonSchemaType {
+	export const number = "number";
+	export const integer = "integer";
+	export const array = "array";
+	export const object = "object";
+	export const string = "string";
+	export type Numeric = typeof number | typeof integer;
+}
+
+export type JsonSchemaType =
+	| "null"
+	| "boolean"
+	| typeof JsonSchemaType.object
+	| typeof JsonSchemaType.array
+	| typeof JsonSchemaType.string
+	| JsonSchemaType.Numeric;

package/src/_internal/platform/configuration/common/validator.ts

@@ -0,0 +1,242 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { JsonSchema } from './jsonSchema';
+
+export interface IValidator<T> {
+	validate(content: unknown): { content: T; error: undefined } | { content: undefined; error: ValidationError };
+
+	toSchema(): JsonSchema;
+}
+
+export type ValidatorType<T> = T extends IValidator<infer U> ? U : never;
+
+export interface ValidationError {
+	message: string;
+}
+
+interface TypeOfMap {
+	string: string;
+	number: number;
+	boolean: boolean;
+	object: object;
+	undefined: undefined;
+	function: Function;
+	symbol: symbol;
+}
+
+class TypeofValidator<TKey extends keyof TypeOfMap> implements IValidator<TypeOfMap[TKey]> {
+	constructor(private readonly type: TKey) { }
+
+	validate(content: unknown): { content: TypeOfMap[TKey]; error: undefined } | { content: undefined; error: ValidationError } {
+		if (typeof content !== this.type) {
+			return { content: undefined, error: { message: `Expected ${this.type}, but got ${typeof content}` } };
+		}
+
+		return { content: content as TypeOfMap[TKey], error: undefined };
+	}
+
+	toSchema(): JsonSchema {
+		return { type: this.type };
+	}
+}
+
+const vStringValidator = new TypeofValidator("string");
+export function vString(): IValidator<string> { return vStringValidator; }
+
+const vNumberValidator = new TypeofValidator("number");
+export function vNumber(): IValidator<number> { return vNumberValidator; }
+
+const vBooleanValidator = new TypeofValidator("boolean");
+export function vBoolean(): IValidator<boolean> { return vBooleanValidator; }
+
+const vObjAnyValidator = new TypeofValidator("object");
+export function vObjAny(): IValidator<object> { return vObjAnyValidator; }
+
+const vUndefinedValidator = new TypeofValidator("undefined");
+export function vUndefined(): IValidator<undefined> { return vUndefinedValidator; }
+
+export function vUnchecked<T>(): IValidator<T> {
+	return {
+		validate(content: unknown): { content: T; error: undefined } {
+			return { content: content as T, error: undefined };
+		},
+		toSchema() {
+			return {
+
+			};
+		},
+	};
+}
+
+export function vUnknown(): IValidator<unknown> {
+	return vUnchecked();
+}
+
+export type ObjectProperties = Record<string, any>;
+
+export function vObj<T extends Record<string, IValidator<any>>>(properties: T): IValidator<{ [K in keyof T]: ValidatorType<T[K]> }> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			if (typeof content !== "object" || content === null) {
+				return { content: undefined, error: { message: "Expected object" } };
+			}
+
+			const result: any = {};
+			for (const key in properties) {
+				const validator = properties[key];
+				const { content: value, error } = validator.validate((content as any)[key]);
+				if (error) {
+					return { content: undefined, error: { message: `Error in property ${key}: ${error.message}` } };
+				}
+
+				result[key] = value;
+			}
+
+			return { content: result, error: undefined };
+		},
+		toSchema() {
+			return {
+				type: "object",
+				properties: Object.fromEntries(Object.entries(properties).map(([key, validator]) => [key, validator.toSchema()])),
+			};
+		}
+	};
+}
+
+export function vArray<T>(validator: IValidator<T>): IValidator<T[]> {
+	return {
+		validate(content: unknown): { content: T[]; error: undefined } | { content: undefined; error: ValidationError } {
+			if (!Array.isArray(content)) {
+				return { content: undefined, error: { message: "Expected array" } };
+			}
+
+			const result: T[] = [];
+			for (let i = 0; i < content.length; i++) {
+				const { content: value, error } = validator.validate(content[i]);
+				if (error) {
+					return { content: undefined, error: { message: `Error in element ${i}: ${error.message}` } };
+				}
+
+				result.push(value);
+			}
+
+			return { content: result, error: undefined };
+		},
+
+		toSchema(): JsonSchema {
+			return {
+				type: "array",
+				items: validator.toSchema(),
+			};
+		}
+	};
+}
+
+export function vTuple<T extends IValidator<any>[]>(...validators: T): IValidator<{ [K in keyof T]: ValidatorType<T[K]> }> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			if (!Array.isArray(content)) {
+				return { content: undefined, error: { message: "Expected array" } };
+			}
+
+			if (content.length !== validators.length) {
+				return { content: undefined, error: { message: `Expected tuple of length ${validators.length}, but got ${content.length}` } };
+			}
+
+			const result: any = [];
+			for (let i = 0; i < validators.length; i++) {
+				const validator = validators[i];
+				const { content: value, error } = validator.validate(content[i]);
+				if (error) {
+					return { content: undefined, error: { message: `Error in element ${i}: ${error.message}` } };
+				}
+
+				result.push(value);
+			}
+
+			return { content: result, error: undefined };
+		},
+
+		toSchema(): JsonSchema {
+			return {
+				type: "array",
+				items: validators.map(validator => validator.toSchema()),
+			};
+		}
+	};
+}
+
+export function vUnion<T extends IValidator<any>[]>(...validators: T): IValidator<ValidatorType<T[number]>> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			let lastError: ValidationError | undefined;
+			for (const validator of validators) {
+				const { content: value, error } = validator.validate(content);
+				if (!error) {
+					return { content: value, error: undefined };
+				}
+
+				lastError = error;
+			}
+
+			return { content: undefined, error: lastError! };
+		},
+
+		toSchema(): JsonSchema {
+			return {
+				oneOf: validators.map(validator => validator.toSchema()),
+			};
+		}
+	};
+}
+
+export function vEnum<T extends string[]>(...values: T): IValidator<T[number]> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			if (values.indexOf(content as any) === -1) {
+				return { content: undefined, error: { message: `Expected one of: ${values.join(", ")}` } };
+			}
+
+			return { content, error: undefined };
+		},
+
+		toSchema(): JsonSchema {
+			return {
+				enum: values,
+			};
+		}
+	};
+}
+
+export function vLiteral<T extends string>(value: T): IValidator<T> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			if (content !== value) {
+				return { content: undefined, error: { message: `Expected: ${value}` } };
+			}
+
+			return { content, error: undefined };
+		},
+
+		toSchema(): JsonSchema {
+			return {
+				const: value,
+			};
+		}
+	};
+}
+
+export function vLazy<T>(fn: () => IValidator<T>): IValidator<T> {
+	return {
+		validate(content: unknown): { content: any; error: undefined } | { content: undefined; error: ValidationError } {
+			return fn().validate(content);
+		},
+
+		toSchema(): JsonSchema {
+			return fn().toSchema();
+		}
+	};
+}

package/src/_internal/platform/diff/common/diffService.ts

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createServiceIdentifier } from '../../../util/common/services';
+import { ILinesDiffComputerOptions, MovedText } from '../../../util/vs/editor/common/diff/linesDiffComputer';
+import { DetailedLineRangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
+
+
+export const IDiffService = createServiceIdentifier<IDiffService>('IDiffService');
+
+export interface IDiffService {
+
+	readonly _serviceBrand: undefined;
+
+	computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDocumentDiff>;
+}
+
+export interface IDocumentDiff {
+	/**
+	 * If true, both text models are identical (byte-wise).
+	 */
+	readonly identical: boolean;
+
+	/**
+	 * If true, the diff computation timed out and the diff might not be accurate.
+	 */
+	readonly quitEarly: boolean;
+
+	/**
+	 * Maps all modified line ranges in the original to the corresponding line ranges in the modified text model.
+	 */
+	readonly changes: readonly DetailedLineRangeMapping[];
+
+	/**
+	 * Sorted by original line ranges.
+	 * The original line ranges and the modified line ranges must be disjoint (but can be touching).
+	 */
+	readonly moves: readonly MovedText[];
+}

package/src/_internal/platform/diff/common/diffWorker.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DefaultLinesDiffComputer } from '../../../util/vs/editor/common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer';
+import { ILinesDiffComputerOptions } from '../../../util/vs/editor/common/diff/linesDiffComputer';
+import { DetailedLineRangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
+
+
+export async function computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDiffComputationResult> {
+	return computeDiffSync(original, modified, options);
+}
+
+export function computeDiffSync(original: string, modified: string, options: ILinesDiffComputerOptions): IDiffComputationResult {
+	const originalLines = original.split(/\r\n|\r|\n/);
+	const modifiedLines = modified.split(/\r\n|\r|\n/);
+	const diffComputer = new DefaultLinesDiffComputer();
+	const result = diffComputer.computeDiff(originalLines, modifiedLines, options);
+
+	const identical = (result.changes.length > 0 ? false : original === modified);
+
+	function getLineChanges(changes: readonly DetailedLineRangeMapping[]): ILineChange[] {
+		return changes.map(m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
+			m.originalRange.startLineNumber,
+			m.originalRange.startColumn,
+			m.originalRange.endLineNumber,
+			m.originalRange.endColumn,
+			m.modifiedRange.startLineNumber,
+			m.modifiedRange.startColumn,
+			m.modifiedRange.endLineNumber,
+			m.modifiedRange.endColumn,
+		])]));
+	}
+
+	return {
+		identical,
+		quitEarly: result.hitTimeout,
+		changes: getLineChanges(result.changes),
+		moves: result.moves.map(m => ([
+			m.lineRangeMapping.original.startLineNumber,
+			m.lineRangeMapping.original.endLineNumberExclusive,
+			m.lineRangeMapping.modified.startLineNumber,
+			m.lineRangeMapping.modified.endLineNumberExclusive,
+			getLineChanges(m.changes)
+		])),
+	};
+}
+
+export interface IDiffComputationResult {
+	quitEarly: boolean;
+	changes: ILineChange[];
+	identical: boolean;
+	moves: ITextMove[];
+}
+
+export type ILineChange = [
+	originalStartLine: number,
+	originalEndLine: number,
+	modifiedStartLine: number,
+	modifiedEndLine: number,
+	charChanges: ICharChange[] | undefined,
+];
+
+export type ICharChange = [
+	originalStartLine: number,
+	originalStartColumn: number,
+	originalEndLine: number,
+	originalEndColumn: number,
+
+	modifiedStartLine: number,
+	modifiedStartColumn: number,
+	modifiedEndLine: number,
+	modifiedEndColumn: number,
+];
+
+export type ITextMove = [
+	originalStartLine: number,
+	originalEndLine: number,
+	modifiedStartLine: number,
+	modifiedEndLine: number,
+	changes: ILineChange[],
+];

package/src/_internal/platform/diff/node/diffServiceImpl.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { WorkerWithRpcProxy } from '../../../util/node/worker';
+import { Lazy } from '../../../util/vs/base/common/lazy';
+import * as path from '../../../util/vs/base/common/path';
+import { Range } from '../../../util/vs/editor/common/core/range';
+import { LineRange } from '../../../util/vs/editor/common/core/ranges/lineRange';
+
+import { existsSync } from 'fs';
+import { ILinesDiffComputerOptions, MovedText } from '../../../util/vs/editor/common/diff/linesDiffComputer';
+import { DetailedLineRangeMapping, LineRangeMapping, RangeMapping } from '../../../util/vs/editor/common/diff/rangeMapping';
+import { IDiffService, IDocumentDiff } from '../common/diffService';
+import * as diffWorker from '../common/diffWorker';
+
+export class DiffServiceImpl implements IDiffService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private _worker: Lazy<WorkerWithRpcProxy<typeof diffWorker>>;
+
+	constructor(private _useWorker = true) {
+		this._worker = new Lazy(() => {
+			const workerPath = firstExistingPath([
+				path.join(__dirname, 'diffWorker.js'), // after bundling by esbuild
+				path.join(__dirname, '../../../../dist/diffWorker.js'), // relative to the typescript source file (for tsx)
+			]);
+
+			if (workerPath === undefined) {
+				throw new Error('DiffServiceImpl: worker file not found');
+			}
+
+			return new WorkerWithRpcProxy<typeof diffWorker>(workerPath, {
+				name: 'Diff worker',
+			});
+		});
+	}
+
+	dispose(): void {
+		this._worker.rawValue?.terminate();
+	}
+
+	async computeDiff(original: string, modified: string, options: ILinesDiffComputerOptions): Promise<IDocumentDiff> {
+		const result = this._useWorker ?
+			await this._worker.value.proxy.computeDiff(original, modified, options) :
+			await diffWorker.computeDiff(original, modified, options);
+
+		// Convert from space efficient JSON data to rich objects.
+		const diff: IDocumentDiff = {
+			identical: result.identical,
+			quitEarly: result.quitEarly,
+			changes: toLineRangeMappings(result.changes),
+			moves: result.moves.map(m => new MovedText(
+				new LineRangeMapping(new LineRange(m[0], m[1]), new LineRange(m[2], m[3])),
+				toLineRangeMappings(m[4])
+			))
+		};
+		return diff;
+	}
+}
+
+export function toLineRangeMappings(changes: readonly diffWorker.ILineChange[]): readonly DetailedLineRangeMapping[] {
+	return changes.map(
+		(c) => new DetailedLineRangeMapping(
+			new LineRange(c[0], c[1]),
+			new LineRange(c[2], c[3]),
+			c[4]?.map(
+				(c) => new RangeMapping(
+					new Range(c[0], c[1], c[2], c[3]),
+					new Range(c[4], c[5], c[6], c[7])
+				)
+			)
+		)
+	);
+}
+
+function firstExistingPath(paths: string[]): string | undefined {
+	for (const p of paths) {
+		if (existsSync(p)) {
+			return p;
+		}
+	}
+}