@codingame/monaco-vscode-api 18.4.0 → 19.0.1

package/vscode/src/vs/editor/common/tokens/tokenArray.js

@@ -1,84 +0,0 @@
-
-import { OffsetRange } from '../core/ranges/offsetRange.js';
-import { LineTokens } from './lineTokens.js';
-
-class TokenArray {
-    static fromLineTokens(lineTokens) {
-        const tokenInfo = [];
-        for (let i = 0; i < lineTokens.getCount(); i++) {
-            tokenInfo.push(( new TokenInfo(
-                lineTokens.getEndOffset(i) - lineTokens.getStartOffset(i),
-                lineTokens.getMetadata(i)
-            )));
-        }
-        return TokenArray.create(tokenInfo);
-    }
-    static create(tokenInfo) {
-        return ( new TokenArray(tokenInfo));
-    }
-    constructor(_tokenInfo) {
-        this._tokenInfo = _tokenInfo;
-    }
-    toLineTokens(lineContent, decoder) {
-        return LineTokens.createFromTextAndMetadata(( this.map((r, t) => ({ text: r.substring(lineContent), metadata: t.metadata }))), decoder);
-    }
-    forEach(cb) {
-        let lengthSum = 0;
-        for (const tokenInfo of this._tokenInfo) {
-            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
-            cb(range, tokenInfo);
-            lengthSum += tokenInfo.length;
-        }
-    }
-    map(cb) {
-        const result = [];
-        let lengthSum = 0;
-        for (const tokenInfo of this._tokenInfo) {
-            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
-            result.push(cb(range, tokenInfo));
-            lengthSum += tokenInfo.length;
-        }
-        return result;
-    }
-    slice(range) {
-        const result = [];
-        let lengthSum = 0;
-        for (const tokenInfo of this._tokenInfo) {
-            const tokenStart = lengthSum;
-            const tokenEndEx = tokenStart + tokenInfo.length;
-            if (tokenEndEx > range.start) {
-                if (tokenStart >= range.endExclusive) {
-                    break;
-                }
-                const deltaBefore = Math.max(0, range.start - tokenStart);
-                const deltaAfter = Math.max(0, tokenEndEx - range.endExclusive);
-                result.push(( new TokenInfo(tokenInfo.length - deltaBefore - deltaAfter, tokenInfo.metadata)));
-            }
-            lengthSum += tokenInfo.length;
-        }
-        return TokenArray.create(result);
-    }
-    append(other) {
-        const result = this._tokenInfo.concat(other._tokenInfo);
-        return TokenArray.create(result);
-    }
-}
-class TokenInfo {
-    constructor(length, metadata) {
-        this.length = length;
-        this.metadata = metadata;
-    }
-}
-class TokenArrayBuilder {
-    constructor() {
-        this._tokens = [];
-    }
-    add(length, metadata) {
-        this._tokens.push(( new TokenInfo(length, metadata)));
-    }
-    build() {
-        return TokenArray.create(this._tokens);
-    }
-}
-
-export { TokenArray, TokenArrayBuilder, TokenInfo };

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineEditsAdapter.d.ts

@@ -1,16 +0,0 @@
-import { Disposable } from "../../../../../base/common/lifecycle.js";
-import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
-import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
-import { ICodeEditor } from "../../../../browser/editorBrowser.js";
-import { ILanguageFeaturesService } from "../../../../common/services/languageFeatures.service.js";
-export declare class InlineEditsAdapterContribution extends Disposable {
-    private readonly instantiationService;
-    static ID: string;
-    static isFirst: boolean;
-    constructor(_editor: ICodeEditor, instantiationService: IInstantiationService);
-}
-export declare class InlineEditsAdapter extends Disposable {
-    private readonly _languageFeaturesService;
-    private readonly _commandService;
-    constructor(_languageFeaturesService: ILanguageFeaturesService, _commandService: ICommandService);
-}

package/vscode/src/vs/editor/contrib/inlineCompletions/browser/model/inlineEditsAdapter.js

@@ -1,94 +0,0 @@
-
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import '../../../../../base/common/observableInternal/index.js';
-import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
-import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
-import { InlineEditTriggerKind } from '../../../../common/languages.js';
-import { ILanguageFeaturesService } from '../../../../common/services/languageFeatures.service.js';
-import { autorunWithStore } from '../../../../../base/common/observableInternal/reactions/autorun.js';
-import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
-
-var InlineEditsAdapterContribution_1;
-let InlineEditsAdapterContribution = class InlineEditsAdapterContribution extends Disposable {
-    static { InlineEditsAdapterContribution_1 = this; }
-    static { this.ID = 'editor.contrib.inlineEditsAdapter'; }
-    static { this.isFirst = true; }
-    constructor(_editor, instantiationService) {
-        super();
-        this.instantiationService = instantiationService;
-        if (InlineEditsAdapterContribution_1.isFirst) {
-            InlineEditsAdapterContribution_1.isFirst = false;
-            this.instantiationService.createInstance(InlineEditsAdapter);
-        }
-    }
-};
-InlineEditsAdapterContribution = InlineEditsAdapterContribution_1 = ( __decorate([
-    ( __param(1, IInstantiationService))
-], InlineEditsAdapterContribution));
-let InlineEditsAdapter = class InlineEditsAdapter extends Disposable {
-    constructor(_languageFeaturesService, _commandService) {
-        super();
-        this._languageFeaturesService = _languageFeaturesService;
-        this._commandService = _commandService;
-        const didChangeSignal = observableSignalFromEvent('didChangeSignal', this._languageFeaturesService.inlineEditProvider.onDidChange);
-        this._register(autorunWithStore((reader, store) => {
-            didChangeSignal.read(reader);
-            store.add(this._languageFeaturesService.inlineCompletionsProvider.register('*', {
-                async provideInlineCompletions(model, position, context, token) {
-                    if (!context.includeInlineEdits) {
-                        return undefined;
-                    }
-                    const allInlineEditProvider = _languageFeaturesService.inlineEditProvider.all(model);
-                    const inlineEdits = await Promise.all(( allInlineEditProvider.map(async (provider) => {
-                        const result = await provider.provideInlineEdit(model, {
-                            triggerKind: InlineEditTriggerKind.Automatic,
-                            requestUuid: context.requestUuid
-                        }, token);
-                        if (!result) {
-                            return undefined;
-                        }
-                        return { result, provider };
-                    })));
-                    const definedEdits = inlineEdits.filter(e => !!e);
-                    return {
-                        edits: definedEdits,
-                        items: ( definedEdits.map(e => {
-                            return {
-                                range: e.result.range,
-                                showRange: e.result.showRange,
-                                insertText: e.result.text,
-                                command: e.result.accepted,
-                                shownCommand: e.result.shown,
-                                action: e.result.action,
-                                isInlineEdit: true,
-                                edit: e.result,
-                            };
-                        })),
-                        commands: definedEdits.flatMap(e => e.result.commands ?? []),
-                        enableForwardStability: true,
-                    };
-                },
-                handleRejection: (completions, item) => {
-                    if (item.edit.rejected) {
-                        this._commandService.executeCommand(item.edit.rejected.id, ...(item.edit.rejected.arguments ?? []));
-                    }
-                },
-                freeInlineCompletions(c) {
-                    for (const e of c.edits) {
-                        e.provider.freeInlineEdit(e.result);
-                    }
-                },
-                toString() {
-                    return 'InlineEditsAdapter';
-                }
-            }));
-        }));
-    }
-};
-InlineEditsAdapter = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, ICommandService))
-], InlineEditsAdapter));
-
-export { InlineEditsAdapter, InlineEditsAdapterContribution };

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.d.ts

@@ -1,243 +0,0 @@
-import { CancellationToken } from "../../../../base/common/cancellation.js";
-import { Event } from "../../../../base/common/event.js";
-import { IMarkdownString } from "../../../../base/common/htmlContent.js";
-import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
-import { ThemeIcon } from "../../../../base/common/themables.js";
-import { URI } from "../../../../base/common/uri.js";
-import { Command } from "../../../../editor/common/languages.js";
-import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
-import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
-import { ILogService } from "../../../../platform/log/common/log.service.js";
-import { IProductService } from "../../../../platform/product/common/productService.service.js";
-import { IRequestService } from "../../../../platform/request/common/request.service.js";
-import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
-import { IChatAgentService, type IChatAgentNameService } from "./chatAgents.service.js";
-import { IChatAgentEditedFileEvent, IChatProgressHistoryResponseContent, IChatRequestVariableData, ISerializableChatAgentData } from "./chatModel.js";
-import { IRawChatCommandContribution } from "@codingame/monaco-vscode-7adbeffb-8051-54a9-8c9b-b62ce9e5836f-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes";
-import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "./chatService.js";
-import { ChatAgentLocation, ChatMode } from "./constants.js";
-export interface IChatAgentHistoryEntry {
-    request: IChatAgentRequest;
-    response: ReadonlyArray<IChatProgressHistoryResponseContent | IChatTaskDto>;
-    result: IChatAgentResult;
-}
-export interface IChatAgentData {
-    id: string;
-    name: string;
-    fullName?: string;
-    description?: string;
-    when?: string;
-    extensionId: ExtensionIdentifier;
-    extensionPublisherId: string;
-    publisherDisplayName?: string;
-    extensionDisplayName: string;
-    isDefault?: boolean;
-    isDynamic?: boolean;
-    isCore?: boolean;
-    metadata: IChatAgentMetadata;
-    slashCommands: IChatAgentCommand[];
-    locations: ChatAgentLocation[];
-    modes: ChatMode[];
-    disambiguation: {
-        category: string;
-        description: string;
-        examples: string[];
-    }[];
-}
-export interface IChatWelcomeMessageContent {
-    icon: ThemeIcon;
-    title: string;
-    message: IMarkdownString;
-}
-export interface IChatAgentImplementation {
-    invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
-    setRequestPaused?(requestId: string, isPaused: boolean): void;
-    provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
-    provideChatTitle?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
-}
-export interface IChatParticipantDetectionResult {
-    participant: string;
-    command?: string;
-}
-export interface IChatParticipantMetadata {
-    participant: string;
-    command?: string;
-    disambiguation: {
-        category: string;
-        description: string;
-        examples: string[];
-    }[];
-}
-export interface IChatParticipantDetectionProvider {
-    provideParticipantDetection(request: IChatAgentRequest, history: IChatAgentHistoryEntry[], options: {
-        location: ChatAgentLocation;
-        participants: IChatParticipantMetadata[];
-    }, token: CancellationToken): Promise<IChatParticipantDetectionResult | null | undefined>;
-}
-export type IChatAgent = IChatAgentData & IChatAgentImplementation;
-export interface IChatAgentCommand extends IRawChatCommandContribution {
-    followupPlaceholder?: string;
-}
-export interface IChatRequesterInformation {
-    name: string;
-    icon?: URI;
-}
-export interface IChatAgentMetadata {
-    helpTextPrefix?: string | IMarkdownString;
-    helpTextVariablesPrefix?: string | IMarkdownString;
-    helpTextPostfix?: string | IMarkdownString;
-    icon?: URI;
-    iconDark?: URI;
-    themeIcon?: ThemeIcon;
-    sampleRequest?: string;
-    supportIssueReporting?: boolean;
-    followupPlaceholder?: string;
-    isSticky?: boolean;
-    requester?: IChatRequesterInformation;
-    additionalWelcomeMessage?: string | IMarkdownString;
-}
-export interface IChatAgentRequest {
-    sessionId: string;
-    requestId: string;
-    agentId: string;
-    command?: string;
-    message: string;
-    attempt?: number;
-    enableCommandDetection?: boolean;
-    isParticipantDetected?: boolean;
-    variables: IChatRequestVariableData;
-    location: ChatAgentLocation;
-    locationData?: IChatLocationData;
-    acceptedConfirmationData?: any[];
-    rejectedConfirmationData?: any[];
-    userSelectedModelId?: string;
-    userSelectedTools?: Record<string, boolean>;
-    modeInstructions?: string;
-    toolSelectionIsExclusive?: boolean;
-    editedFileEvents?: IChatAgentEditedFileEvent[];
-}
-export interface IChatQuestion {
-    readonly prompt: string;
-    readonly participant?: string;
-    readonly command?: string;
-}
-export interface IChatAgentResultTimings {
-    firstProgress?: number;
-    totalElapsed: number;
-}
-export interface IChatAgentResult {
-    errorDetails?: IChatResponseErrorDetails;
-    timings?: IChatAgentResultTimings;
-    readonly metadata?: {
-        readonly [key: string]: any;
-    };
-    nextQuestion?: IChatQuestion;
-}
-export interface IChatAgentCompletionItem {
-    id: string;
-    name?: string;
-    fullName?: string;
-    icon?: ThemeIcon;
-    value: unknown;
-    command?: Command;
-}
-export declare class ChatAgentService extends Disposable implements IChatAgentService {
-    private readonly contextKeyService;
-    static readonly AGENT_LEADER = "@";
-    _serviceBrand: undefined;
-    private _agents;
-    private readonly _onDidChangeAgents;
-    readonly onDidChangeAgents: Event<IChatAgent | undefined>;
-    private readonly _agentsContextKeys;
-    private readonly _hasDefaultAgent;
-    private readonly _extensionAgentRegistered;
-    private readonly _defaultAgentRegistered;
-    private readonly _editingAgentRegistered;
-    private _hasToolsAgent;
-    private _chatParticipantDetectionProviders;
-    constructor(contextKeyService: IContextKeyService);
-    registerAgent(id: string, data: IChatAgentData): IDisposable;
-    private _updateAgentsContextKeys;
-    private _updateContextKeys;
-    registerAgentImplementation(id: string, agentImpl: IChatAgentImplementation): IDisposable;
-    registerDynamicAgent(data: IChatAgentData, agentImpl: IChatAgentImplementation): IDisposable;
-    private _agentCompletionProviders;
-    registerAgentCompletionProvider(id: string, provider: (query: string, token: CancellationToken) => Promise<IChatAgentCompletionItem[]>): {
-        dispose: () => void;
-    };
-    getAgentCompletionItems(id: string, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
-    updateAgent(id: string, updateMetadata: IChatAgentMetadata): void;
-    getDefaultAgent(location: ChatAgentLocation, mode?: ChatMode): IChatAgent | undefined;
-    get hasToolsAgent(): boolean;
-    getContributedDefaultAgent(location: ChatAgentLocation): IChatAgentData | undefined;
-    private _preferExtensionAgent;
-    getAgent(id: string, includeDisabled?: boolean): IChatAgentData | undefined;
-    private _agentIsEnabled;
-    getAgentByFullyQualifiedId(id: string): IChatAgentData | undefined;
-    getAgents(): IChatAgentData[];
-    getActivatedAgents(): IChatAgent[];
-    getAgentsByName(name: string): IChatAgentData[];
-    private _preferExtensionAgents;
-    agentHasDupeName(id: string): boolean;
-    invokeAgent(id: string, request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
-    setRequestPaused(id: string, requestId: string, isPaused: boolean): void;
-    getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
-    getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
-    registerChatParticipantDetectionProvider(handle: number, provider: IChatParticipantDetectionProvider): IDisposable;
-    hasChatParticipantDetectionProviders(): boolean;
-    detectAgentOrCommand(request: IChatAgentRequest, history: IChatAgentHistoryEntry[], options: {
-        location: ChatAgentLocation;
-    }, token: CancellationToken): Promise<{
-        agent: IChatAgentData;
-        command?: IChatAgentCommand;
-    } | undefined>;
-}
-export declare class MergedChatAgent implements IChatAgent {
-    private readonly data;
-    private readonly impl;
-    constructor(data: IChatAgentData, impl: IChatAgentImplementation);
-    when?: string | undefined;
-    publisherDisplayName?: string | undefined;
-    isDynamic?: boolean | undefined;
-    get id(): string;
-    get name(): string;
-    get fullName(): string;
-    get description(): string;
-    get extensionId(): ExtensionIdentifier;
-    get extensionPublisherId(): string;
-    get extensionPublisherDisplayName(): string | undefined;
-    get extensionDisplayName(): string;
-    get isDefault(): boolean | undefined;
-    get isCore(): boolean | undefined;
-    get metadata(): IChatAgentMetadata;
-    get slashCommands(): IChatAgentCommand[];
-    get locations(): ChatAgentLocation[];
-    get modes(): ChatMode[];
-    get disambiguation(): {
-        category: string;
-        description: string;
-        examples: string[];
-    }[];
-    invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
-    setRequestPaused(requestId: string, isPaused: boolean): void;
-    provideFollowups(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
-    toJSON(): IChatAgentData;
-}
-export declare class ChatAgentNameService implements IChatAgentNameService {
-    private readonly requestService;
-    private readonly logService;
-    private readonly storageService;
-    private static readonly StorageKey;
-    _serviceBrand: undefined;
-    private readonly url;
-    private registry;
-    private disposed;
-    constructor(productService: IProductService, requestService: IRequestService, logService: ILogService, storageService: IStorageService);
-    private refresh;
-    private update;
-    getAgentNameRestriction(chatAgentData: IChatAgentData): boolean;
-    private checkAgentNameRestriction;
-    dispose(): void;
-}
-export declare function getFullyQualifiedId(chatAgentData: IChatAgentData): string;
-export declare function reviveSerializedAgent(raw: ISerializableChatAgentData): IChatAgentData;