@vscode/chat-lib 0.0.1

package/src/_internal/platform/workspaceRecorder/common/workspaceLog.ts

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
+import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
+
+export type LogDocumentId = number;
+
+export type LogEntry =
+	| HeaderLogEntry
+	| ApplicationStartLogEntry
+	| DocumentSetContentLogEntry
+	| DocumentStoreContentLogEntry
+	| DocumentRestoreContentLogEntry
+	| DocumentOpenedLogEntry
+	| DocumentClosedLogEntry
+	| DocumentChangedLogEntry
+	| DocumentFocusChangedLogEntry
+	| DocumentSelectionChangedLogEntry
+	| DocumentEncounteredLogEntry
+	| MetaLogEntry
+	| BookmarkLogEntry
+	| DocumentEventLogEntry
+	| EventLogEntry;
+
+export type DocumentLogEntry = { id: LogDocumentId; time: number };
+export namespace DocumentLogEntry {
+	export function is(entry: unknown): entry is DocumentLogEntry {
+		return !!entry && typeof entry === 'object' && 'id' in entry && 'time' in entry;
+	}
+}
+
+/** First entry of the log */
+export type HeaderLogEntry = { documentType: "workspaceRecording@1.0"; kind: 'header'; repoRootUri: string; time: number; uuid: string };
+
+export type ApplicationStartLogEntry = { kind: 'applicationStart'; time: number; commitHash?: string };
+
+export type DocumentSetContentLogEntry = DocumentLogEntry & { kind: 'setContent'; content: string; /* if undefined, is 0 */ v: number | undefined };
+
+export type DocumentStoreContentLogEntry = DocumentLogEntry & { kind: 'storeContent'; contentId: string; /* if undefined, is 0 */ v: number | undefined };
+
+/** Can only restore from a content id set by any previous store content log entry */
+export type DocumentRestoreContentLogEntry = DocumentLogEntry & { kind: 'restoreContent'; contentId: string; /* if undefined, is 0 */ v: number | undefined };
+
+export type DocumentOpenedLogEntry = DocumentLogEntry & { kind: 'opened' };
+
+export type DocumentClosedLogEntry = DocumentLogEntry & { kind: 'closed' };
+
+export type DocumentChangedLogEntry = DocumentLogEntry & { kind: 'changed'; edit: ISerializedEdit; v: number };
+
+export type DocumentFocusChangedLogEntry = DocumentLogEntry & { kind: 'focused' };
+
+export type DocumentSelectionChangedLogEntry = DocumentLogEntry & { kind: 'selectionChanged'; selection: ISerializedOffsetRange[] };
+
+export type DocumentEncounteredLogEntry = DocumentLogEntry & { kind: 'documentEncountered'; relativePath: string };
+
+export type DocumentEventLogEntry = DocumentLogEntry & { kind: 'documentEvent'; data: unknown };
+
+export type EventLogEntry = { kind: 'event'; time: number; data: unknown };
+
+export type MetaLogEntry = { kind: 'meta'; data: unknown | { repoRootUri: string } };
+
+export type BookmarkLogEntry = { kind: 'bookmark'; time: number };
+
+
+// Edit functions
+
+export type ISerializedOffsetRange = [start: number, endEx: number];
+export type ISerializedEdit = [start: number, endEx: number, text: string][];
+
+export function serializeOffsetRange(offsetRange: OffsetRange): ISerializedOffsetRange {
+	return [offsetRange.start, offsetRange.endExclusive];
+}
+
+export function deserializeOffsetRange(serialized: ISerializedOffsetRange): OffsetRange {
+	return new OffsetRange(serialized[0], serialized[1]);
+}
+
+export function serializeEdit(edit: StringEdit): ISerializedEdit {
+	return edit.replacements.map(e => [e.replaceRange.start, e.replaceRange.endExclusive, e.newText]);
+}
+
+export function deserializeEdit(serialized: ISerializedEdit): StringEdit {
+	return StringEdit.create(serialized.map(e => StringReplacement.replace(new OffsetRange(e[0], e[1]), e[2])));
+}
+
+export type DocumentEventLogEntryData = IDocumentEventDataSetChangeReason | IDocumentEventFetchStart;
+export type EventLogEntryData = IEventFetchEnd;
+
+export interface IDocumentEventDataSetChangeReason {
+	sourceId: "TextModel.setChangeReason";
+	source: string;
+	v: number;
+}
+
+interface IDocumentEventFetchStart {
+	sourceId: "InlineCompletions.fetch";
+	kind: "start";
+	requestId: number;
+	v: number;
+}
+
+export interface IEventFetchEnd {
+	sourceId: "InlineCompletions.fetch";
+	kind: "end";
+	requestId: number;
+	error: string | undefined;
+	result: IFetchResult[];
+}
+
+interface IFetchResult {
+	range: string;
+	text: string;
+	isInlineEdit: boolean;
+	source: string;
+}

package/src/_internal/util/common/anomalyDetection.ts

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/** Sometimes the model gets caught in repeating a simplistic and unhelpful pattern
+ * This file provides functionality to check whether this might be the case
+ */
+interface RepetitionConfig {
+	max_token_sequence_length: number;
+	last_tokens_to_consider: number;
+}
+
+const configs: RepetitionConfig[] = [
+	// in case of single token, 10 repetitions is too much already:
+	{ max_token_sequence_length: 1, last_tokens_to_consider: 10 },
+	// if the last 30 tokens are a repeat of up to 10 tokens, then it's a pattern:
+	{ max_token_sequence_length: 10, last_tokens_to_consider: 30 },
+	// if the pattern is very long, it needs to account for a long stretch so we can be sure
+	{ max_token_sequence_length: 20, last_tokens_to_consider: 45 },
+	{ max_token_sequence_length: 30, last_tokens_to_consider: 60 },
+	{ max_token_sequence_length: 60, last_tokens_to_consider: 120 },
+];
+
+/**
+ * Given a string calculates how many times each line in the string is repeated
+ * @param text The string to analyze
+ * @returns The repeating line, the number of times it repeats, total number of lines
+ */
+export function calculateLineRepetitionStats(text: string): { numberOfRepetitions: number; mostRepeatedLine: string; totalLines: number } {
+	if (text.length === 0) {
+		return { numberOfRepetitions: 0, mostRepeatedLine: '', totalLines: 0 };
+	}
+	const repetitionMap = new Map<string, number>();
+	const lines = text.split('\n');
+	for (let line of lines) {
+		line = line.trim();
+		if (line.length === 0) {
+			continue;
+		}
+		const repetitions = repetitionMap.get(line) || 0;
+		repetitionMap.set(line, repetitions + 1);
+	}
+
+	let mostRepeatedLine = '';
+	let maxRepetitions = 0;
+	for (const [line, repetitions] of repetitionMap.entries()) {
+		if (repetitions > maxRepetitions) {
+			maxRepetitions = repetitions;
+			mostRepeatedLine = line;
+		}
+	}
+
+	return { numberOfRepetitions: maxRepetitions, mostRepeatedLine, totalLines: lines.length };
+}
+
+/**
+ * Return whether the given token array ends in a repetition of a pattern.
+ * Controlling the necessary pattern length is set in the configs array.
+ */
+export function isRepetitive(tokens: readonly string[]): boolean {
+	const tokensBackwards = tokens.slice();
+	tokensBackwards.reverse();
+	return (
+		isRepeatedPattern(tokensBackwards) ||
+		isRepeatedPattern(tokensBackwards.filter(token => token.trim().length > 0))
+	);
+}
+
+/**
+ * Determine whether the given array or string starts with the repetition of a pattern,
+ * according to one of the predefined configs.
+ */
+function isRepeatedPattern<T>(s: ArrayLike<T>): boolean {
+	const prefix = kmp_prefix_function(s);
+	for (const config of configs) {
+		if (s.length < config.last_tokens_to_consider) {
+			continue;
+		}
+		// This is the smallest number of characters that one may shift `s` so that it
+		// overlaps with itself. That is also the smallest length of a repeated
+		// pattern that makes up `s`, where the last repetition is possibly truncated.
+		const patternLength = config.last_tokens_to_consider - 1 - prefix[config.last_tokens_to_consider - 1];
+		if (patternLength <= config.max_token_sequence_length) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/** Return the Knuth-Morris-Pratt prefix function pi.
+ *  For each i=0,..,.s.length-1, then
+ *    pi[i] = max(j < i, s.slice(0,i+1).beginsWith(s.slice(0, j+1)))
+ *  (note pi[0] = -1 by this definition)
+ *  Adapted from
+ *  Introduction to Algorithms, 3rd edition, by Thomas H. Cormen, et al.
+ */
+function kmp_prefix_function<T>(s: ArrayLike<T>): number[] {
+	const pi = Array(s.length).fill(0);
+	pi[0] = -1;
+	let k = -1;
+	for (let q = 1; q < s.length; q++) {
+		while (k >= 0 && s[k + 1] !== s[q]) {
+			k = pi[k];
+		}
+		if (s[k + 1] === s[q]) {
+			k++;
+		}
+		pi[q] = k;
+	}
+	return pi;
+}

package/src/_internal/util/common/arrays.ts

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Counts the number of elements in an array that satisfy a given predicate.
+ */
+export function count<T>(array: T[], predicate: (value: T) => boolean): number {
+	let count = 0;
+	for (const value of array) {
+		if (predicate(value)) {
+			count++;
+		}
+	}
+	return count;
+}
+
+export function findInsertionIndexInSortedArray<T>(array: T[], value: T, isBeforeFunction: (a: T, b: T) => boolean): number {
+	let low = 0;
+	let high = array.length;
+	while (low < high) {
+		const mid = (low + high) >>> 1;
+		if (isBeforeFunction(array[mid], value)) {
+			low = mid + 1;
+		}
+		else {
+			high = mid;
+		}
+	}
+	return low;
+}
+/**
+ * Returns the maximum element in the array according to the given sort callback.
+ * @param arr - The array to search for the maximum element.
+ * @param compare - The sort callback to use for comparing elements.
+ * @returns The maximum element in the array according to the given sort callback.
+ */
+export function max<T>(arr: T[], compare: (a: T, b: T) => number): T | undefined {
+	if (arr.length === 0) {
+		return undefined;
+	}
+
+	let maxElement = arr[0];
+
+	for (let i = 1; i < arr.length; i++) {
+		const currentElement = arr[i];
+
+		if (compare(currentElement, maxElement) > 0) {
+			maxElement = currentElement;
+		}
+	}
+
+	return maxElement;
+}
+
+export function filterMap<T, K>(array: T[], map: (t: T) => K | undefined | null): K[] {
+	const result: K[] = [];
+	for (const element of array) {
+		const mapped = map(element);
+		if (mapped !== undefined && mapped !== null) {
+			result.push(mapped);
+		}
+	}
+	return result;
+}
+
+/**
+ * Behaves just like `Math.min`, so it will return Infinity for an empty array.
+ */
+export function min(array: number[]): number {
+	if (array.length === 0) {
+		return Infinity;
+	}
+
+	let min = array[0];
+	for (let i = 1; i < array.length; i++) {
+		min = Math.min(min, array[i]);
+	}
+	return min;
+}

package/src/_internal/util/common/async.ts

@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DeferredPromise } from '../vs/base/common/async';
+import { BugIndicatingError, CancellationError } from '../vs/base/common/errors';
+
+export type Task<T = void> = () => (Promise<T> | T);
+
+/**
+ * Processes tasks in the order they were scheduled.
+*/
+export class TaskQueue {
+	private _runningTask: Task<any> | undefined = undefined;
+	private _pendingTasks: { task: Task<any>; deferred: DeferredPromise<any>; setUndefinedWhenCleared: boolean }[] = [];
+
+	/**
+	 * Waits for the current and pending tasks to finish, then runs and awaits the given task.
+	 * If the task is skipped because of clearPending, the promise is rejected with a CancellationError.
+	*/
+	public schedule<T>(task: Task<T>): Promise<T> {
+		const deferred = new DeferredPromise<T>();
+		this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: false });
+		this._runIfNotRunning();
+		return deferred.p;
+	}
+
+	/**
+	 * Waits for the current and pending tasks to finish, then runs and awaits the given task.
+	 * If the task is skipped because of clearPending, the promise is resolved with undefined.
+	*/
+	public scheduleSkipIfCleared<T>(task: Task<T>): Promise<T | undefined> {
+		const deferred = new DeferredPromise<T>();
+		this._pendingTasks.push({ task, deferred, setUndefinedWhenCleared: true });
+		this._runIfNotRunning();
+		return deferred.p;
+	}
+
+	private _runIfNotRunning(): void {
+		if (this._runningTask === undefined) {
+			this._processQueue();
+		}
+	}
+
+	private async _processQueue(): Promise<void> {
+		if (this._pendingTasks.length === 0) {
+			return;
+		}
+
+		const next = this._pendingTasks.shift();
+		if (!next) {
+			return;
+		}
+
+		if (this._runningTask) {
+			throw new BugIndicatingError();
+		}
+
+		this._runningTask = next.task;
+
+		try {
+			const result = await next.task();
+			next.deferred.complete(result);
+		} catch (e) {
+			next.deferred.error(e);
+		} finally {
+			this._runningTask = undefined;
+			this._processQueue();
+		}
+	}
+
+	/**
+	 * Clears all pending tasks. Does not cancel the currently running task.
+	*/
+	public clearPending(): void {
+		const tasks = this._pendingTasks;
+		this._pendingTasks = [];
+		for (const task of tasks) {
+			if (task.setUndefinedWhenCleared) {
+				task.deferred.complete(undefined);
+			} else {
+				task.deferred.error(new CancellationError());
+			}
+		}
+	}
+}
+
+export class BatchedProcessor<TArg, TResult> {
+	private _queue: { arg: TArg; promise: DeferredPromise<TResult> }[] = [];
+	private _timeout: any | null = null;
+
+	constructor(
+		private readonly _fn: (args: TArg[]) => Promise<TResult[]>,
+		private readonly _waitingTimeMs: number
+	) { }
+
+	request(arg: TArg): Promise<TResult> {
+		if (this._timeout === null) {
+			this._timeout = setTimeout(() => this._flush(), this._waitingTimeMs);
+		}
+
+		const p = new DeferredPromise<TResult>();
+		this._queue.push({ arg, promise: p });
+		return p.p;
+	}
+
+	private async _flush() {
+		const queue = this._queue;
+		this._queue = [];
+		this._timeout = null;
+
+		const args = queue.map(e => e.arg);
+
+		let results: TResult[];
+		try {
+			results = await this._fn(args);
+		} catch (e) {
+			for (const entry of queue) {
+				entry.promise.error(e);
+			}
+			return;
+		}
+
+		for (const [i, result] of results.entries()) {
+			queue[i].promise.complete(result);
+		}
+	}
+}
+
+export function raceFilter<T>(promises: Promise<T>[], filter: (result: T) => boolean): Promise<T | undefined> {
+	return new Promise((resolve, reject) => {
+		if (promises.length === 0) {
+			resolve(undefined);
+			return;
+		}
+
+		let resolved = false;
+		let unresolvedCount = promises.length;
+		for (const promise of promises) {
+			promise.then(result => {
+				unresolvedCount--;
+				if (!resolved) {
+					if (filter(result)) {
+						resolved = true;
+						resolve(result);
+					} else if (unresolvedCount === 0) {
+						// Last one has to resolve the promise
+						resolve(undefined);
+					}
+				}
+			}).catch(reject);
+		}
+	});
+}

package/src/_internal/util/common/cache.ts

@@ -0,0 +1,183 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable } from '../vs/base/common/lifecycle';
+
+class Node<T> {
+	key: string;
+	value: T;
+	prev: Node<T> | null = null;
+	next: Node<T> | null = null;
+
+	constructor(key: string, value: T) {
+		this.key = key;
+		this.value = value;
+	}
+}
+
+export class LRUCache<T> {
+	private readonly _capacity: number;
+	private readonly _cache: Map<string, Node<T>>;
+	private readonly _head: Node<T>;
+	private readonly _tail: Node<T>;
+
+	constructor(size = 10) {
+		if (size < 1) {
+			throw new Error('Cache size must be at least 1');
+		}
+		this._capacity = size;
+		this._cache = new Map<string, Node<T>>();
+		this._head = new Node<T>('', null as any);
+		this._tail = new Node<T>('', null as any);
+		this._head.next = this._tail;
+		this._tail.prev = this._head;
+	}
+
+	private _addNode(node: Node<T>) {
+		node.prev = this._head;
+		node.next = this._head.next;
+		this._head.next!.prev = node;
+		this._head.next = node;
+	}
+
+	private _removeNode(node: Node<T>) {
+		const prev = node.prev;
+		const next = node.next;
+		prev!.next = next;
+		next!.prev = prev;
+	}
+
+	private _moveToHead(node: Node<T>) {
+		this._removeNode(node);
+		this._addNode(node);
+	}
+
+	private _popTail(): Node<T> {
+		const res = this._tail.prev!;
+		this._removeNode(res);
+		return res;
+	}
+
+	clear() {
+		this._cache.clear();
+		this._head.next = this._tail;
+		this._tail.prev = this._head;
+	}
+
+	/**
+	 * Deletes the cache entry for the given key, if it exists.
+	 * @param key The key of the cache entry to delete.
+	 * @returns The value of the deleted cache entry, or undefined if the key was not found.
+	 */
+	deleteKey(key: string): T | undefined {
+		const node = this._cache.get(key);
+		if (!node) {
+			return undefined;
+		}
+		this._removeNode(node);
+		this._cache.delete(key);
+		return node.value;
+	}
+
+	get(key: string): T | undefined {
+		const node = this._cache.get(key);
+		if (!node) {
+			return undefined;
+		}
+		this._moveToHead(node);
+		return node.value;
+	}
+
+	/**
+	 * Return a copy of all the keys stored in the LRU cache, in LRU order.
+	 *
+	 * The returned array is safe to modify, as this call allocates a copy of a
+	 * private array used to represent those keys.
+	 */
+	keys(): string[] {
+		const keys: string[] = [];
+		let current = this._head.next;
+		while (current !== this._tail) {
+			keys.push(current!.key);
+			current = current!.next;
+		}
+		return keys;
+	}
+
+	getValues() {
+		const values: T[] = [];
+		let current = this._head.next;
+		while (current !== this._tail) {
+			values.push(current!.value);
+			current = current!.next;
+		}
+		return values;
+	}
+
+	/** @returns the evicted [key, value]  */
+	put(key: string, value: T): [string, T] | undefined {
+		let node = this._cache.get(key);
+		if (node) {
+			node.value = value;
+			this._moveToHead(node);
+		} else {
+			node = new Node<T>(key, value);
+			this._cache.set(key, node);
+			this._addNode(node);
+
+			if (this._cache.size > this._capacity) {
+				const tail = this._popTail();
+				this._cache.delete(tail.key);
+				return [tail.key, tail.value] as const;
+			}
+		}
+	}
+}
+
+export class DisposablesLRUCache<T extends IDisposable> implements IDisposable {
+	private readonly actual: LRUCache<T>;
+
+	constructor(size?: number) {
+		this.actual = new LRUCache<T>(size);
+	}
+
+	dispose() {
+		this.clear();
+	}
+
+	clear() {
+		const values = this.actual.getValues();
+		for (const value of values) {
+			value.dispose();
+		}
+		this.actual.clear();
+	}
+
+	deleteKey(key: string): void {
+		const value = this.actual.deleteKey(key);
+		if (value) {
+			value.dispose();
+		}
+	}
+
+	get(key: string): T | undefined {
+		return this.actual.get(key);
+	}
+
+	keys(): string[] {
+		return this.actual.keys();
+	}
+
+	getValues() {
+		return this.actual.getValues();
+	}
+
+	put(key: string, value: T): void {
+		const evicted = this.actual.put(key, value);
+		if (evicted) {
+			evicted[1].dispose();
+		}
+	}
+}

package/src/_internal/util/common/crypto.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.
+ *--------------------------------------------------------------------------------------------*/
+
+export async function createRequestHMAC(hmacSecret: string | undefined): Promise<string | undefined> {
+	// If we don't have the right env variables this could happen
+	if (!hmacSecret) {
+		return undefined;
+	}
+
+	const key = await crypto.subtle.importKey(
+		"raw",
+		new TextEncoder().encode(hmacSecret),
+		{ name: "HMAC", hash: "SHA-256" },
+		false,
+		["sign"]
+	);
+
+	const current = Math.floor(Date.now() / 1000).toString();
+	const textEncoder = new TextEncoder();
+	const data = textEncoder.encode(current);
+
+	const signature = await crypto.subtle.sign("HMAC", key, data);
+	const signatureArray = Array.from(new Uint8Array(signature));
+	const signatureHex = signatureArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+	return `${current}.${signatureHex}`;
+}
+
+export async function createSha256Hash(data: string | Uint8Array): Promise<string> {
+	const dataUint8 = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+	const hashBuffer = await crypto.subtle.digest('SHA-256', dataUint8);
+	const hashArray = new Uint8Array(hashBuffer);
+	let hashHex = '';
+	for (const byte of hashArray) {
+		hashHex += byte.toString(16).padStart(2, '0');
+	}
+
+	return hashHex;
+}