@vscode/chat-lib 0.0.1 → 0.0.2

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

@@ -1,118 +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 { 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

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

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

@@ -1,155 +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 { 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

@@ -1,183 +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 { 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

@@ -1,41 +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 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;
-}