@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/workbench/api/common/extHostTypes/textEdit.ts

@@ -0,0 +1,99 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  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 '../../../../base/common/errors';
+import { es5ClassCompat } from './es5ClassCompat';
+import { Position } from './position';
+import { Range } from './range';
+
+export enum EndOfLine {
+	LF = 1,
+	CRLF = 2
+}
+
+@es5ClassCompat
+export class TextEdit {
+
+	static isTextEdit(thing: any): thing is TextEdit {
+		if (thing instanceof TextEdit) {
+			return true;
+		}
+		if (!thing) {
+			return false;
+		}
+		return Range.isRange((<TextEdit>thing))
+			&& typeof (<TextEdit>thing).newText === 'string';
+	}
+
+	static replace(range: Range, newText: string): TextEdit {
+		return new TextEdit(range, newText);
+	}
+
+	static insert(position: Position, newText: string): TextEdit {
+		return TextEdit.replace(new Range(position, position), newText);
+	}
+
+	static delete(range: Range): TextEdit {
+		return TextEdit.replace(range, '');
+	}
+
+	static setEndOfLine(eol: EndOfLine): TextEdit {
+		const ret = new TextEdit(new Range(new Position(0, 0), new Position(0, 0)), '');
+		ret.newEol = eol;
+		return ret;
+	}
+
+	protected _range: Range;
+	protected _newText: string | null;
+	protected _newEol?: EndOfLine;
+
+	get range(): Range {
+		return this._range;
+	}
+
+	set range(value: Range) {
+		if (value && !Range.isRange(value)) {
+			throw illegalArgument('range');
+		}
+		this._range = value;
+	}
+
+	get newText(): string {
+		return this._newText || '';
+	}
+
+	set newText(value: string) {
+		if (value && typeof value !== 'string') {
+			throw illegalArgument('newText');
+		}
+		this._newText = value;
+	}
+
+	get newEol(): EndOfLine | undefined {
+		return this._newEol;
+	}
+
+	set newEol(value: EndOfLine | undefined) {
+		if (value && typeof value !== 'number') {
+			throw illegalArgument('newEol');
+		}
+		this._newEol = value;
+	}
+
+	constructor(range: Range, newText: string | null) {
+		this._range = range;
+		this._newText = newText;
+	}
+
+	toJSON(): any {
+		return {
+			range: this.range,
+			newText: this.newText,
+			newEol: this._newEol
+		};
+	}
+}

package/src/_internal/vscodeTypes.ts

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as vscode from 'vscode';
+
+export import Position = vscode.Position;
+export import Range = vscode.Range;
+export import Selection = vscode.Selection;
+export import EventEmitter = vscode.EventEmitter;
+export import CancellationTokenSource = vscode.CancellationTokenSource;
+export import Diagnostic = vscode.Diagnostic;
+export import TextEdit = vscode.TextEdit;
+export import WorkspaceEdit = vscode.WorkspaceEdit;
+export import Uri = vscode.Uri;
+export import MarkdownString = vscode.MarkdownString;
+export import TextEditorCursorStyle = vscode.TextEditorCursorStyle;
+export import TextEditorLineNumbersStyle = vscode.TextEditorLineNumbersStyle;
+export import TextEditorRevealType = vscode.TextEditorRevealType;
+export import EndOfLine = vscode.EndOfLine;
+export import DiagnosticSeverity = vscode.DiagnosticSeverity;
+export import ExtensionMode = vscode.ExtensionMode;
+export import Location = vscode.Location;
+export import DiagnosticRelatedInformation = vscode.DiagnosticRelatedInformation;
+export import ChatVariableLevel = vscode.ChatVariableLevel;
+export import ChatResponseClearToPreviousToolInvocationReason = vscode.ChatResponseClearToPreviousToolInvocationReason;
+export import ChatResponseMarkdownPart = vscode.ChatResponseMarkdownPart;
+export import ChatResponseThinkingProgressPart = vscode.ChatResponseThinkingProgressPart;
+export import ChatResponseFileTreePart = vscode.ChatResponseFileTreePart;
+export import ChatResponseAnchorPart = vscode.ChatResponseAnchorPart;
+export import ChatResponseProgressPart = vscode.ChatResponseProgressPart;
+export import ChatResponseProgressPart2 = vscode.ChatResponseProgressPart2;
+export import ChatResponseReferencePart = vscode.ChatResponseReferencePart;
+export import ChatResponseReferencePart2 = vscode.ChatResponseReferencePart2;
+export import ChatResponseCodeCitationPart = vscode.ChatResponseCodeCitationPart;
+export import ChatResponseCommandButtonPart = vscode.ChatResponseCommandButtonPart;
+export import ChatResponseWarningPart = vscode.ChatResponseWarningPart;
+export import ChatResponseMovePart = vscode.ChatResponseMovePart;
+export import ChatResponseExtensionsPart = vscode.ChatResponseExtensionsPart;
+export import ChatResponsePullRequestPart = vscode.ChatResponsePullRequestPart;
+export import ChatResponseMarkdownWithVulnerabilitiesPart = vscode.ChatResponseMarkdownWithVulnerabilitiesPart;
+export import ChatResponseCodeblockUriPart = vscode.ChatResponseCodeblockUriPart;
+export import ChatResponseTextEditPart = vscode.ChatResponseTextEditPart;
+export import ChatResponseNotebookEditPart = vscode.ChatResponseNotebookEditPart;
+export import ChatResponseConfirmationPart = vscode.ChatResponseConfirmationPart;
+export import ChatPrepareToolInvocationPart = vscode.ChatPrepareToolInvocationPart;
+export import ChatRequest = vscode.ChatRequest;
+export import ChatRequestTurn = vscode.ChatRequestTurn;
+export import ChatResponseTurn = vscode.ChatResponseTurn;
+export import NewSymbolName = vscode.NewSymbolName;
+export import NewSymbolNameTag = vscode.NewSymbolNameTag;
+export import NewSymbolNameTriggerKind = vscode.NewSymbolNameTriggerKind;
+export import ChatLocation = vscode.ChatLocation;
+export import ChatRequestEditorData = vscode.ChatRequestEditorData;
+export import ChatRequestNotebookData = vscode.ChatRequestNotebookData;
+export import LanguageModelToolInformation = vscode.LanguageModelToolInformation;
+export import LanguageModelToolResult = vscode.LanguageModelToolResult;
+export import ExtendedLanguageModelToolResult = vscode.ExtendedLanguageModelToolResult;
+export import LanguageModelToolResult2 = vscode.LanguageModelToolResult2;
+export import SymbolInformation = vscode.SymbolInformation;
+export import LanguageModelPromptTsxPart = vscode.LanguageModelPromptTsxPart;
+export import LanguageModelTextPart = vscode.LanguageModelTextPart;
+export import LanguageModelTextPart2 = vscode.LanguageModelTextPart2;
+export import LanguageModelDataPart = vscode.LanguageModelDataPart;
+export import LanguageModelDataPart2 = vscode.LanguageModelDataPart2;
+export import LanguageModelPartAudience = vscode.LanguageModelPartAudience;
+export import LanguageModelToolMCPSource = vscode.LanguageModelToolMCPSource;
+export import LanguageModelToolExtensionSource = vscode.LanguageModelToolExtensionSource;
+export import ChatImageMimeType = vscode.ChatImageMimeType;
+export import ChatReferenceBinaryData = vscode.ChatReferenceBinaryData;
+export import ChatReferenceDiagnostic = vscode.ChatReferenceDiagnostic;
+export import TextSearchMatch2 = vscode.TextSearchMatch2;
+export import AISearchKeyword = vscode.AISearchKeyword;
+export import ExcludeSettingOptions = vscode.ExcludeSettingOptions;
+export import NotebookCellKind = vscode.NotebookCellKind;
+export import NotebookRange = vscode.NotebookRange;
+export import NotebookEdit = vscode.NotebookEdit;
+export import NotebookCellData = vscode.NotebookCellData;
+export import NotebookData = vscode.NotebookData;
+export import ChatErrorLevel = vscode.ChatErrorLevel;
+export import TerminalShellExecutionCommandLineConfidence = vscode.TerminalShellExecutionCommandLineConfidence;
+export import ChatRequestEditedFileEventKind = vscode.ChatRequestEditedFileEventKind;
+export import Extension = vscode.Extension;
+export import LanguageModelToolCallPart = vscode.LanguageModelToolCallPart;
+export import LanguageModelToolResultPart = vscode.LanguageModelToolResultPart;
+export import LanguageModelToolResultPart2 = vscode.LanguageModelToolResultPart2;
+export import LanguageModelChatMessageRole = vscode.LanguageModelChatMessageRole;
+export import TextEditorSelectionChangeKind = vscode.TextEditorSelectionChangeKind;
+export import TextDocumentChangeReason = vscode.TextDocumentChangeReason;
+export import ChatToolInvocationPart = vscode.ChatToolInvocationPart;
+export import ChatResponseTurn2 = vscode.ChatResponseTurn2;
+export import ChatRequestTurn2 = vscode.ChatRequestTurn2;
+
+export const l10n = {
+	/**
+	 * @deprecated Only use this import in tests. For the actual extension,
+	 * use `import { l10n } from 'vscode'` or `import * as l10n from '@vscode/l10n'`.
+	 */
+	t: vscode.l10n.t
+};

package/src/main.ts

@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+import { DebugRecorder } from './_internal/extension/inlineEdits/node/debugRecorder';
+import { NextEditProvider } from './_internal/extension/inlineEdits/node/nextEditProvider';
+import { LlmNESTelemetryBuilder } from './_internal/extension/inlineEdits/node/nextEditProviderTelemetry';
+import { INextEditResult } from './_internal/extension/inlineEdits/node/nextEditResult';
+import { ChatMLFetcherImpl } from './_internal/extension/prompt/node/chatMLFetcher';
+import { XtabProvider } from './_internal/extension/xtab/node/xtabProvider';
+import { IAuthenticationService } from './_internal/platform/authentication/common/authentication';
+import { ICopilotTokenManager } from './_internal/platform/authentication/common/copilotTokenManager';
+import { CopilotTokenStore, ICopilotTokenStore } from './_internal/platform/authentication/common/copilotTokenStore';
+import { StaticGitHubAuthenticationService } from './_internal/platform/authentication/common/staticGitHubAuthenticationService';
+import { getStaticGitHubToken } from './_internal/platform/authentication/node/copilotTokenManager';
+import { IChatMLFetcher } from './_internal/platform/chat/common/chatMLFetcher';
+import { IChatQuotaService } from './_internal/platform/chat/common/chatQuotaService';
+import { ChatQuotaService } from './_internal/platform/chat/common/chatQuotaServiceImpl';
+import { IConversationOptions } from './_internal/platform/chat/common/conversationOptions';
+import { IInteractionService, InteractionService } from './_internal/platform/chat/common/interactionService';
+import { ConfigKey, IConfigurationService } from './_internal/platform/configuration/common/configurationService';
+import { DefaultsOnlyConfigurationService } from './_internal/platform/configuration/common/defaultsOnlyConfigurationService';
+import { IDiffService } from './_internal/platform/diff/common/diffService';
+import { DiffServiceImpl } from './_internal/platform/diff/node/diffServiceImpl';
+import { ICAPIClientService } from './_internal/platform/endpoint/common/capiClient';
+import { IDomainService } from './_internal/platform/endpoint/common/domainService';
+import { CAPIClientImpl } from './_internal/platform/endpoint/node/capiClientImpl';
+import { DomainService } from './_internal/platform/endpoint/node/domainServiceImpl';
+import { IEnvService } from './_internal/platform/env/common/envService';
+import { NullEnvService } from './_internal/platform/env/common/nullEnvService';
+import { IGitExtensionService } from './_internal/platform/git/common/gitExtensionService';
+import { NullGitExtensionService } from './_internal/platform/git/common/nullGitExtensionService';
+import { IIgnoreService, NullIgnoreService } from './_internal/platform/ignore/common/ignoreService';
+import { DocumentId } from './_internal/platform/inlineEdits/common/dataTypes/documentId';
+import { InlineEditRequestLogContext } from './_internal/platform/inlineEdits/common/inlineEditLogContext';
+import { ObservableGit } from './_internal/platform/inlineEdits/common/observableGit';
+import { ObservableWorkspace } from './_internal/platform/inlineEdits/common/observableWorkspace';
+import { NesHistoryContextProvider } from './_internal/platform/inlineEdits/common/workspaceEditTracker/nesHistoryContextProvider';
+import { NesXtabHistoryTracker } from './_internal/platform/inlineEdits/common/workspaceEditTracker/nesXtabHistoryTracker';
+import { ILanguageContextProviderService } from './_internal/platform/languageContextProvider/common/languageContextProviderService';
+import { NullLanguageContextProviderService } from './_internal/platform/languageContextProvider/common/nullLanguageContextProviderService';
+import { ILanguageDiagnosticsService } from './_internal/platform/languages/common/languageDiagnosticsService';
+import { TestLanguageDiagnosticsService } from './_internal/platform/languages/common/testLanguageDiagnosticsService';
+import { ConsoleLog, ILogService, LogLevel, LogServiceImpl } from './_internal/platform/log/common/logService';
+import { FetchOptions, IAbortController, IFetcherService } from './_internal/platform/networking/common/fetcherService';
+import { IFetcher } from './_internal/platform/networking/common/networking';
+import { NullRequestLogger } from './_internal/platform/requestLogger/node/nullRequestLogger';
+import { IRequestLogger } from './_internal/platform/requestLogger/node/requestLogger';
+import { ISimulationTestContext, NulSimulationTestContext } from './_internal/platform/simulationTestContext/common/simulationTestContext';
+import { ISnippyService, NullSnippyService } from './_internal/platform/snippy/common/snippyService';
+import { IExperimentationService, NullExperimentationService } from './_internal/platform/telemetry/common/nullExperimentationService';
+import { NullTelemetryService } from './_internal/platform/telemetry/common/nullTelemetryService';
+import { ITelemetryService } from './_internal/platform/telemetry/common/telemetry';
+import { ITokenizerProvider, TokenizerProvider } from './_internal/platform/tokenizer/node/tokenizer';
+import { IWorkspaceService, NullWorkspaceService } from './_internal/platform/workspace/common/workspaceService';
+import { InstantiationServiceBuilder } from './_internal/util/common/services';
+import { CancellationToken } from './_internal/util/vs/base/common/cancellation';
+import { Disposable } from './_internal/util/vs/base/common/lifecycle';
+import { generateUuid } from './_internal/util/vs/base/common/uuid';
+import { SyncDescriptor } from './_internal/util/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from './_internal/util/vs/platform/instantiation/common/instantiation';
+
+
+export function createNESProvider(workspace: ObservableWorkspace, fetcher: IFetcher, copilotTokenManager: ICopilotTokenManager): INESProvider {
+	const instantiationService = setupServices(fetcher, copilotTokenManager);
+	return instantiationService.createInstance(NESProvider, workspace);
+}
+
+class NESProvider extends Disposable implements INESProvider {
+	private readonly _nextEditProvider: NextEditProvider;
+	private readonly _debugRecorder: DebugRecorder;
+
+	constructor(
+		private _workspace: ObservableWorkspace,
+		@IInstantiationService instantiationService: IInstantiationService,
+		@IExperimentationService private readonly _expService: IExperimentationService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IWorkspaceService private readonly _workspaceService: IWorkspaceService,
+	) {
+		super();
+		const statelessNextEditProvider = instantiationService.createInstance(XtabProvider);
+		const git = instantiationService.createInstance(ObservableGit);
+		const historyContextProvider = new NesHistoryContextProvider(this._workspace, git);
+		const xtabDiffNEntries = this._configurationService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabDiffNEntries, this._expService);
+		const xtabHistoryTracker = new NesXtabHistoryTracker(this._workspace, xtabDiffNEntries);
+		this._debugRecorder = this._register(new DebugRecorder(this._workspace));
+
+		this._nextEditProvider = instantiationService.createInstance(NextEditProvider, this._workspace, statelessNextEditProvider, historyContextProvider, xtabHistoryTracker, this._debugRecorder);
+	}
+
+	getId(): string {
+		return this._nextEditProvider.ID;
+	}
+
+	async getNextEdit(documentUri: vscode.Uri, cancellationToken: CancellationToken): Promise<INextEditResult> {
+		const docId = DocumentId.create(documentUri.toString());
+
+		// Create minimal required context objects
+		const context: vscode.InlineCompletionContext = {
+			triggerKind: 1, // Invoke
+			selectedCompletionInfo: undefined,
+			requestUuid: generateUuid(),
+			requestIssuedDateTime: Date.now(),
+			earliestShownDateTime: Date.now() + 200,
+		};
+
+		// Create log context
+		const logContext = new InlineEditRequestLogContext(documentUri.toString(), 1, context);
+
+		const document = this._workspace.getDocument(docId);
+		if (!document) {
+			throw new Error('DocumentNotFound');
+		}
+
+		// Create telemetry builder - we'll need to pass null/undefined for services we don't have
+		const telemetryBuilder = new LlmNESTelemetryBuilder(
+			new NullGitExtensionService(), // IGitExtensionService
+			undefined, // INotebookService
+			this._workspaceService, // IWorkspaceService
+			this._nextEditProvider.ID, // providerId
+			document, // doc
+			this._debugRecorder, // debugRecorder
+			undefined // requestBookmark
+		);
+
+		return await this._nextEditProvider.getNextEdit(docId, context, logContext, cancellationToken, telemetryBuilder);
+	}
+}
+
+export interface INESProvider {
+	getId(): string;
+	getNextEdit(documentUri: vscode.Uri, cancellationToken: CancellationToken): Promise<INextEditResult>;
+	dispose(): void;
+}
+
+function setupServices(fetcher: IFetcher, copilotTokenManager: ICopilotTokenManager) {
+	const builder = new InstantiationServiceBuilder();
+	builder.define(IConfigurationService, new SyncDescriptor(DefaultsOnlyConfigurationService));
+	builder.define(IExperimentationService, new SyncDescriptor(NullExperimentationService));
+	builder.define(ISimulationTestContext, new SyncDescriptor(NulSimulationTestContext));
+	builder.define(IWorkspaceService, new SyncDescriptor(NullWorkspaceService));
+	builder.define(IDiffService, new SyncDescriptor(DiffServiceImpl, [false]));
+	builder.define(ILogService, new SyncDescriptor(LogServiceImpl, [[new ConsoleLog(undefined, LogLevel.Trace)]]));
+	builder.define(IGitExtensionService, new SyncDescriptor(NullGitExtensionService));
+	builder.define(ILanguageContextProviderService, new SyncDescriptor(NullLanguageContextProviderService));
+	builder.define(ILanguageDiagnosticsService, new SyncDescriptor(TestLanguageDiagnosticsService));
+	builder.define(IIgnoreService, new SyncDescriptor(NullIgnoreService));
+	builder.define(ISnippyService, new SyncDescriptor(NullSnippyService));
+	builder.define(IDomainService, new SyncDescriptor(DomainService));
+	builder.define(ICAPIClientService, new SyncDescriptor(CAPIClientImpl));
+	builder.define(ICopilotTokenStore, new SyncDescriptor(CopilotTokenStore));
+	builder.define(IEnvService, new SyncDescriptor(NullEnvService));
+	builder.define(IFetcherService, new SyncDescriptor(SingleFetcherService, [fetcher]));
+	builder.define(ITelemetryService, new SyncDescriptor(NullTelemetryService));
+	builder.define(IAuthenticationService, new SyncDescriptor(StaticGitHubAuthenticationService, [getStaticGitHubToken]));
+	builder.define(ICopilotTokenManager, copilotTokenManager);
+	builder.define(IChatMLFetcher, new SyncDescriptor(ChatMLFetcherImpl));
+	builder.define(IChatQuotaService, new SyncDescriptor(ChatQuotaService));
+	builder.define(IInteractionService, new SyncDescriptor(InteractionService));
+	builder.define(IRequestLogger, new SyncDescriptor(NullRequestLogger));
+	builder.define(ITokenizerProvider, new SyncDescriptor(TokenizerProvider, [false]));
+	builder.define(IConversationOptions, {
+		_serviceBrand: undefined,
+		maxResponseTokens: undefined,
+		temperature: 0.1,
+		topP: 1,
+		rejectionMessage: 'Sorry, but I can only assist with programming related questions.',
+	});
+	return builder.seal();
+}
+
+class SingleFetcherService implements IFetcherService {
+
+	declare readonly _serviceBrand: undefined;
+
+	constructor(
+		private readonly _fetcher: IFetcher,
+	) { }
+
+	getUserAgentLibrary(): string {
+		return this._fetcher.getUserAgentLibrary();
+	}
+
+	fetch(url: string, options: FetchOptions) {
+		return this._fetcher.fetch(url, options);
+	}
+	disconnectAll(): Promise<unknown> {
+		return this._fetcher.disconnectAll();
+	}
+	makeAbortController(): IAbortController {
+		return this._fetcher.makeAbortController();
+	}
+	isAbortError(e: any): boolean {
+		return this._fetcher.isAbortError(e);
+	}
+	isInternetDisconnectedError(e: any): boolean {
+		return this._fetcher.isInternetDisconnectedError(e);
+	}
+	isFetcherError(e: any): boolean {
+		return this._fetcher.isFetcherError(e);
+	}
+	getUserMessageForFetcherError(err: any): string {
+		return this._fetcher.getUserMessageForFetcherError(err);
+	}
+}