@codingame/monaco-vscode-api 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/api/common/extHostChatSessions.js

@@ -3,23 +3,22 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { coalesce } from '../../../base/common/arrays.js';
 import { CancellationToken, CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { CancellationError } from '../../../base/common/errors.js';
-import { Emitter, Event } from '../../../base/common/event.js';
+import { Emitter } from '../../../base/common/event.js';
 import { Disposable, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
-import { ResourceMap } from '../../../base/common/map.js';
+import { ResourceSet, ResourceMap } from '../../../base/common/map.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
+import { equals } from '../../../base/common/objects.js';
 import { basename } from '../../../base/common/resources.js';
 import { URI } from '../../../base/common/uri.js';
 import { SymbolKind, SymbolKinds } from '../../../editor/common/languages.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind } from '../../contrib/chat/common/attachments/chatVariableEntries.js';
-import { ChatSessionStatus } from '../../contrib/chat/common/chatSessionsService.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatAgentResponseStream } from './extHostChatAgents2.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { MarkdownString, ChatAgentRequest, Location, Diagnostic, ChatResponsePart } from './extHostTypeConverters.js';
+import { ChatSessionItem, ChatAgentRequest, Location, Diagnostic, ChatResponsePart } from './extHostTypeConverters.js';
 import { Disposable as Disposable$1, ChatRequestTurn, ChatReferenceDiagnostic } from './extHostTypes.js';
-import { equals } from '../../../base/common/objects.js';
 import { Location as Location$1 } from './extHostTypes/location.js';
 
 var ExtHostChatSessions_1;
@@ -125,30 +124,65 @@ class ChatSessionItemImpl {
         return this.#metadata;
     }
     set metadata(value) {
+        if (value !== undefined) {
+            try {
+                JSON.stringify(value);
+            } catch {
+                throw ( new Error("metadata must be JSON-serializable"));
+            }
+        }
         if (!equals(this.#metadata, value)) {
             this.#metadata = value;
             this.#onChanged();
         }
     }
 }
+function computeItemsDelta(oldItems, newItems) {
+    const delta = {
+        addedOrUpdated: ( new ResourceMap()),
+        removed: ( new ResourceSet())
+    };
+    for (const [newResource, newItem] of newItems) {
+        const oldItem = oldItems.get(newResource);
+        if (oldItem !== newItem) {
+            delta.addedOrUpdated.set(newResource, newItem);
+        }
+    }
+    for (const oldResource of ( oldItems.keys())) {
+        if (!( newItems.has(oldResource))) {
+            delta.removed.add(oldResource);
+        }
+    }
+    return delta;
+}
+function convertChatSessionDeltaToDto(delta) {
+    return {
+        addedOrUpdated: delta.addedOrUpdated ? Array.from(( delta.addedOrUpdated.values()), ChatSessionItem.from) : [],
+        removed: delta.removed ? Array.from(( delta.removed.keys())) : []
+    };
+}
 class ChatSessionItemCollectionImpl {
     #items = ( new ResourceMap());
-    #onItemsChanged;
-    constructor(onItemsChanged) {
-        this.#onItemsChanged = onItemsChanged;
+    #proxy;
+    #controllerHandle;
+    constructor(controllerHandle, proxy) {
+        this.#proxy = proxy;
+        this.#controllerHandle = controllerHandle;
     }
     get size() {
         return this.#items.size;
     }
-    replace(items) {
-        if (items.length === 0 && this.#items.size === 0) {
+    replace(newItems) {
+        if (!newItems.length && !this.#items.size) {
             return;
         }
-        this.#items.clear();
-        for (const item of items) {
-            this.#items.set(item.resource, item);
+        const newItemsMap = ( new ResourceMap(( newItems.map(item => [item.resource, item]))));
+        const delta = computeItemsDelta(this.#items, newItemsMap);
+        if (!delta.addedOrUpdated?.size && !delta.removed?.size) {
+            return;
         }
-        this.#onItemsChanged();
+        this.#items = newItemsMap;
+        void this.#proxy.$updateChatSessionItems(this.#controllerHandle, convertChatSessionDeltaToDto(delta));
     }
     forEach(callback, thisArg) {
         for (const [_, item] of this.#items) {
@@ -156,12 +190,20 @@ class ChatSessionItemCollectionImpl {
         }
     }
     add(item) {
+        const existing = this.#items.get(item.resource);
+        if (existing && existing === item) {
+            return;
+        }
         this.#items.set(item.resource, item);
-        this.#onItemsChanged();
+        void this.#proxy.$addOrUpdateChatSessionItem(this.#controllerHandle, ChatSessionItem.from(item));
     }
     delete(resource) {
-        this.#items.delete(resource);
-        this.#onItemsChanged();
+        if (this.#items.delete(resource)) {
+            void this.#proxy.$updateChatSessionItems(this.#controllerHandle, {
+                addedOrUpdated: [],
+                removed: [resource]
+            });
+        }
     }
     get(resource) {
         return this.#items.get(resource);
@@ -216,48 +258,65 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         this._languageModels = _languageModels;
         this._extHostRpc = _extHostRpc;
         this._logService = _logService;
-        this._itemProviderHandlePool = 0;
-        this._chatSessionItemProviders = ( new Map());
         this._itemControllerHandlePool = 0;
         this._chatSessionItemControllers = ( new Map());
         this._contentProviderHandlePool = 0;
         this._chatSessionContentProviders = ( new Map());
-        this._sessionItems = ( new ResourceMap());
         this._extHostChatSessions = ( new ResourceMap());
         this._providerOptionGroups = ( new Map());
         this._proxy = ( this._extHostRpc.getProxy(MainContext.MainThreadChatSessions));
         commands.registerArgumentProcessor({
             processArgument: arg => {
                 if (arg && arg.$mid === MarshalledId.AgentSessionContext) {
-                    const id = arg.session.resource || arg.sessionId;
-                    const sessionContent = this._sessionItems.get(id);
-                    if (sessionContent) {
-                        return sessionContent;
-                    } else {
-                        this._logService.warn(`No chat session found for ID: ${id}`);
-                        return arg;
+                    const resource = arg.session.resource;
+                    for (const {
+                        controller
+                    } of ( this._chatSessionItemControllers.values())) {
+                        const item = controller.items.get(resource);
+                        if (item) {
+                            return item;
+                        }
                     }
+                    this._logService.warn(`No chat session found with uri: ${resource}`);
+                    return arg;
                 }
                 return arg;
             }
         });
     }
     registerChatSessionItemProvider(extension, chatSessionType, provider) {
-        const handle = this._itemProviderHandlePool++;
+        const controllerHandle = this._itemControllerHandlePool++;
         const disposables = ( new DisposableStore());
-        this._chatSessionItemProviders.set(handle, {
-            provider,
+        const onDidChangeChatSessionItemStateEmitter = disposables.add(( new Emitter()));
+        const collection = ( new ChatSessionItemCollectionImpl(controllerHandle, this._proxy));
+        const controller = {
+            id: chatSessionType,
+            items: collection,
+            createChatSessionItem: (_resource, _label) => {
+                throw ( new Error("Not implemented for providers"));
+            },
+            onDidChangeChatSessionItemState: onDidChangeChatSessionItemStateEmitter.event,
+            newChatSessionItemHandler: undefined,
+            dispose: () => {
+                disposables.dispose();
+            },
+            refreshHandler: async token => {
+                const items = (await provider.provideChatSessionItems(token)) ?? [];
+                collection.replace(items);
+            }
+        };
+        this._chatSessionItemControllers.set(controllerHandle, {
+            chatSessionType: chatSessionType,
+            controller,
             extension,
             disposable: disposables,
-            sessionType: chatSessionType
+            onDidChangeChatSessionItemStateEmitter
         });
-        this._proxy.$registerChatSessionItemProvider(handle, chatSessionType);
+        this._proxy.$registerChatSessionItemController(controllerHandle, chatSessionType);
         if (provider.onDidChangeChatSessionItems) {
             disposables.add(provider.onDidChangeChatSessionItems(() => {
-                this._logService.trace(
-                    `ExtHostChatSessions. Firing $onDidChangeChatSessionItems for ${chatSessionType}`
-                );
-                this._proxy.$onDidChangeChatSessionItems(handle);
+                this._logService.trace(`ExtHostChatSessions. Provider items changed for ${chatSessionType}`);
+                controller.refreshHandler(CancellationToken.None);
             }));
         }
         if (provider.onDidCommitChatSessionItem) {
@@ -266,14 +325,14 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                     original,
                     modified
                 } = e;
-                this._proxy.$onDidCommitChatSessionItem(handle, original.resource, modified.resource);
+                this._proxy.$onDidCommitChatSessionItem(controllerHandle, original.resource, modified.resource);
             }));
         }
         return {
             dispose: () => {
-                this._chatSessionItemProviders.delete(handle);
+                this._chatSessionItemControllers.delete(controllerHandle);
                 disposables.dispose();
-                this._proxy.$unregisterChatSessionItemProvider(handle);
+                this._proxy.$unregisterChatSessionItemController(controllerHandle);
             }
         };
     }
@@ -281,34 +340,17 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const controllerHandle = this._itemControllerHandlePool++;
         const disposables = ( new DisposableStore());
         let isDisposed = false;
-        let refreshIdPool = 0;
-        let activeRefreshId = undefined;
-        const onDidChangeItemsEmitter = disposables.add(( new Emitter()));
+        let newChatSessionItemHandler;
         const onDidChangeChatSessionItemStateEmitter = disposables.add(( new Emitter()));
-        const notifyItemsChanged = () => {
-            if (typeof activeRefreshId === "undefined") {
-                onDidChangeItemsEmitter.fire();
-            }
-        };
-        const collection = ( new ChatSessionItemCollectionImpl(() => {
-            notifyItemsChanged();
-        }));
+        const collection = ( new ChatSessionItemCollectionImpl(controllerHandle, this._proxy));
         const controller = ( Object.freeze({
             id,
             refreshHandler: async refreshToken => {
                 if (isDisposed) {
                     throw ( new Error("ChatSessionItemController has been disposed"));
                 }
-                const opId = ++refreshIdPool;
-                activeRefreshId = opId;
-                try {
-                    this._logService.trace(`ExtHostChatSessions. Controller(${id}).refresh()`);
-                    await refreshHandler(refreshToken);
-                } finally {
-                    if (activeRefreshId === opId) {
-                        activeRefreshId = undefined;
-                    }
-                }
+                this._logService.trace(`ExtHostChatSessions. Controller(${id}).refresh()`);
+                await refreshHandler(refreshToken);
             },
             items: collection,
             onDidChangeChatSessionItemState: onDidChangeChatSessionItemStateEmitter.event,
@@ -316,9 +358,18 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 if (isDisposed) {
                     throw ( new Error("ChatSessionItemController has been disposed"));
                 }
-                return ( new ChatSessionItemImpl(resource, label, () => {
-                    notifyItemsChanged();
+                const item = ( new ChatSessionItemImpl(resource, label, () => {
+                    if (collection.get(resource) === item) {
+                        void this._proxy.$addOrUpdateChatSessionItem(controllerHandle, ChatSessionItem.from(item));
+                    }
                 }));
+                return item;
+            },
+            get newChatSessionItemHandler() {
+                return newChatSessionItemHandler;
+            },
+            set newChatSessionItemHandler(handler) {
+                newChatSessionItemHandler = handler;
             },
             dispose: () => {
                 isDisposed = true;
@@ -329,20 +380,13 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             controller,
             extension,
             disposable: disposables,
-            sessionType: id,
+            chatSessionType: id,
             onDidChangeChatSessionItemStateEmitter
         });
-        disposables.add(this.registerChatSessionItemProvider(extension, id, {
-            onDidChangeChatSessionItems: onDidChangeItemsEmitter.event,
-            onDidCommitChatSessionItem: Event.None,
-            provideChatSessionItems: async token => {
-                await controller.refreshHandler(token);
-                return Array.from(controller.items, x => x[1]);
-            }
-        }));
+        this._proxy.$registerChatSessionItemController(controllerHandle, id);
         disposables.add(toDisposable(() => {
             this._chatSessionItemControllers.delete(controllerHandle);
-            this._proxy.$unregisterChatSessionItemProvider(controllerHandle);
+            this._proxy.$unregisterChatSessionItemController(controllerHandle);
         }));
         return controller;
     }
@@ -372,66 +416,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             this._proxy.$unregisterChatSessionContentProvider(handle);
         });
     }
-    convertChatSessionStatus(status) {
-        if (status === undefined) {
-            return undefined;
-        }
-        switch (status) {
-        case
-        0:
-            return ChatSessionStatus.Failed;
-        case
-        1:
-            return ChatSessionStatus.Completed;
-        case
-        2:
-            return ChatSessionStatus.InProgress;
-        default:
-            return undefined;
-        }
-    }
-    convertChatSessionItem(sessionContent) {
-        const timing = sessionContent.timing;
-        const created = timing?.created ?? timing?.startTime ?? 0;
-        const lastRequestStarted = timing?.lastRequestStarted ?? timing?.startTime;
-        const lastRequestEnded = timing?.lastRequestEnded ?? timing?.endTime;
-        return {
-            resource: sessionContent.resource,
-            label: sessionContent.label,
-            description: sessionContent.description ? MarkdownString.from(sessionContent.description) : undefined,
-            badge: sessionContent.badge ? MarkdownString.from(sessionContent.badge) : undefined,
-            status: this.convertChatSessionStatus(sessionContent.status),
-            archived: sessionContent.archived,
-            tooltip: MarkdownString.fromStrict(sessionContent.tooltip),
-            timing: {
-                created,
-                lastRequestStarted,
-                lastRequestEnded
-            },
-            changes: sessionContent.changes instanceof Array ? sessionContent.changes : undefined,
-            metadata: sessionContent.metadata
-        };
-    }
-    async $provideChatSessionItems(handle, token) {
-        const itemProvider = this._chatSessionItemProviders.get(handle);
-        if (!itemProvider) {
-            this._logService.error(`No provider registered for handle ${handle}`);
-            return [];
-        }
-        this._logService.trace(
-            `ExtHostChatSessions:$provideChatSessionItems(${itemProvider.sessionType})`
-        );
-        const items = (await itemProvider.provider.provideChatSessionItems(token)) ?? [];
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const response = [];
-        for (const sessionContent of items) {
-            this._sessionItems.set(sessionContent.resource, sessionContent);
-            response.push(this.convertChatSessionItem(sessionContent));
-        }
-        return response;
-    }
     async $provideChatSessionContent(handle, sessionResourceComponents, token) {
         const provider = this._chatSessionContentProviders.get(handle);
         if (!provider) {
@@ -480,6 +464,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         return {
             id: sessionId + "",
             resource: URI.revive(sessionResource),
+            title: session.title,
             hasActiveResponseCallback: !!session.activeResponseCallback,
             hasRequestHandler: !!session.requestHandler,
             supportsInterruption: !!capabilities?.supportsInterruptions,
@@ -530,15 +515,20 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             return;
         }
         try {
-            const {
-                optionGroups
-            } = await provider.provideChatSessionProviderOptions(token);
-            if (!optionGroups) {
+            const result = await provider.provideChatSessionProviderOptions(token);
+            if (!result) {
                 return;
             }
-            this._providerOptionGroups.set(handle, optionGroups);
+            const {
+                optionGroups,
+                newSessionOptions
+            } = result;
+            if (optionGroups) {
+                this._providerOptionGroups.set(handle, optionGroups);
+            }
             return {
-                optionGroups
+                optionGroups,
+                newSessionOptions
             };
         } catch (error) {
             this._logService.error(
@@ -606,7 +596,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             command: turn.command,
             variableData: variables.length > 0 ? {
                 variables
-            } : undefined
+            } : undefined,
+            modelId: turn.modelId
         };
     }
     convertReferenceToVariable(ref) {
@@ -698,6 +689,34 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             return [];
         }
     }
+    async $refreshChatSessionItems(handle, token) {
+        const controllerData = this._chatSessionItemControllers.get(handle);
+        if (!controllerData) {
+            this._logService.warn(`No controller found for handle ${handle}`);
+            return;
+        }
+        await controllerData.controller.refreshHandler(token);
+    }
+    async $newChatSessionItem(handle, request, token) {
+        const controllerData = this._chatSessionItemControllers.get(handle);
+        if (!controllerData) {
+            this._logService.warn(`No controller found for handle ${handle}`);
+            return undefined;
+        }
+        const handler = controllerData.controller.newChatSessionItemHandler;
+        if (!handler) {
+            return undefined;
+        }
+        const model = await this.getModelForRequest(request, controllerData.extension);
+        const chatRequest = ChatAgentRequest.to(request, undefined, model, [], ( new Map()), controllerData.extension, this._logService);
+        const item = await handler({
+            request: chatRequest
+        }, token);
+        if (!item) {
+            return undefined;
+        }
+        return ChatSessionItem.from(item);
+    }
     $onDidChangeChatSessionItemState(controllerHandle, sessionResourceComponents, archived) {
         const controllerData = this._chatSessionItemControllers.get(controllerHandle);
         if (!controllerData) {

package/vscode/src/vs/workbench/api/common/extHostComments.js

@@ -481,6 +481,7 @@ function createExtHostComments(mainContext, commands, documents) {
         dispose() {
             this._isDiposed = true;
             this._acceptInputDisposables.dispose();
+            this._onDidUpdateCommentThread.dispose();
             this._localDisposables.forEach(disposable => disposable.dispose());
         }
     }

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.js

@@ -125,7 +125,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2692,
+                            2738,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

package/vscode/src/vs/workbench/api/common/extHostDocuments.d.ts

@@ -6,6 +6,7 @@ import { ExtHostDocumentsAndEditors } from "./extHostDocumentsAndEditors.js";
 import type * as vscode from "vscode";
 import { ISerializedModelContentChangedEvent } from "../../../editor/common/textModelEvents.js";
 export declare class ExtHostDocuments implements ExtHostDocumentsShape {
+    private readonly _toDispose;
     private readonly _onDidAddDocument;
     private readonly _onDidRemoveDocument;
     private readonly _onDidChangeDocument;
@@ -16,7 +17,6 @@ export declare class ExtHostDocuments implements ExtHostDocumentsShape {
     readonly onDidChangeDocument: Event<vscode.TextDocumentChangeEvent>;
     readonly onDidChangeDocumentWithReason: Event<vscode.TextDocumentChangeEvent>;
     readonly onDidSaveDocument: Event<vscode.TextDocument>;
-    private readonly _toDispose;
     private _proxy;
     private _documentsAndEditors;
     private _documentLoader;

package/vscode/src/vs/workbench/api/common/extHostDocuments.js

@@ -11,17 +11,17 @@ import { TextDocumentChangeReason } from './extHostTypes.js';
 
 class ExtHostDocuments {
     constructor(mainContext, documentsAndEditors) {
-        this._onDidAddDocument = ( new Emitter());
-        this._onDidRemoveDocument = ( new Emitter());
-        this._onDidChangeDocument = ( new Emitter());
-        this._onDidChangeDocumentWithReason = ( new Emitter());
-        this._onDidSaveDocument = ( new Emitter());
+        this._toDispose = ( new DisposableStore());
+        this._onDidAddDocument = this._toDispose.add(( new Emitter()));
+        this._onDidRemoveDocument = this._toDispose.add(( new Emitter()));
+        this._onDidChangeDocument = this._toDispose.add(( new Emitter()));
+        this._onDidChangeDocumentWithReason = this._toDispose.add(( new Emitter()));
+        this._onDidSaveDocument = this._toDispose.add(( new Emitter()));
         this.onDidAddDocument = this._onDidAddDocument.event;
         this.onDidRemoveDocument = this._onDidRemoveDocument.event;
         this.onDidChangeDocument = this._onDidChangeDocument.event;
         this.onDidChangeDocumentWithReason = this._onDidChangeDocumentWithReason.event;
         this.onDidSaveDocument = this._onDidSaveDocument.event;
-        this._toDispose = ( new DisposableStore());
         this._documentLoader = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadDocuments));
         this._documentsAndEditors = documentsAndEditors;

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -440,7 +440,10 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                         if (!messagePort) {
                             return undefined;
                         }
-                        const onDidReceiveMessage = Event.buffer(Event.fromDOMEventEmitter(messagePort, "message", e => e.data));
+                        const onDidReceiveMessage = Event.buffer(
+                            Event.fromDOMEventEmitter(messagePort, "message", e => e.data),
+                            "onDidReceiveMessage"
+                        );
                         messagePort.start();
                         messagePassingProtocol = {
                             onDidReceiveMessage,
@@ -611,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2693, "Cannot load test runner."))));
+            throw ( new Error(( localize(2739, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
         const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2694,
+                2740,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

package/vscode/src/vs/workbench/api/common/extHostGitExtensionService.d.ts

@@ -0,0 +1,31 @@
+import type * as vscode from "vscode";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { UriComponents } from "../../../base/common/uri.js";
+import { IExtHostExtensionService } from "./extHostExtensionService.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+import { ExtHostGitExtensionShape, GitRefDto, GitRefQueryDto, GitRepositoryStateDto } from "./extHost.protocol.js";
+export interface IExtHostGitExtensionService extends ExtHostGitExtensionShape {
+    readonly _serviceBrand: undefined;
+}
+export declare const IExtHostGitExtensionService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostGitExtensionService>;
+export declare class ExtHostGitExtensionService extends Disposable implements IExtHostGitExtensionService {
+    private readonly _extHostExtensionService;
+    readonly _serviceBrand: undefined;
+    private static _handlePool;
+    private _gitApi;
+    private readonly _proxy;
+    private readonly _repositories;
+    private readonly _repositoryByUri;
+    private readonly _disposables;
+    constructor(extHostRpc: IExtHostRpcService, _extHostExtensionService: IExtHostExtensionService);
+    $isGitExtensionAvailable(): Promise<boolean>;
+    $openRepository(uri: UriComponents): Promise<{
+        handle: number;
+        rootUri: UriComponents;
+        state: GitRepositoryStateDto;
+    } | undefined>;
+    $getRefs(handle: number, query: GitRefQueryDto, token?: vscode.CancellationToken): Promise<GitRefDto[]>;
+    $getRepositoryState(handle: number): Promise<GitRepositoryStateDto | undefined>;
+    private _ensureGitApi;
+    dispose(): void;
+}