@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievements.contribution.js

@@ -0,0 +1,326 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { getActiveElement, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/editor';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
+import { IAICustomizationItemsModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationItemsModel.service';
+import { CHAT_PET_OPEN_ACHIEVEMENTS_COMMAND_ID, chatPetAchievements, ChatPetAchievementIds, isUserAuthoredChatPetCustomization } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatPetAchievements';
+import { ChatPetAchievementsEditor, ChatPetAchievementsContextKeys } from './chatPetAchievementsEditor.js';
+import { ChatPetAchievementsEditorInput } from './chatPetAchievementsEditorInput.js';
+import { ChatPetContextKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatPetService';
+import { IChatPetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(ChatPetAchievementsEditor, ChatPetAchievementsEditor.ID, ( localize(8260, "Achievements Editor"))),
+    [( new SyncDescriptor(ChatPetAchievementsEditorInput))]
+);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: CHAT_PET_OPEN_ACHIEVEMENTS_COMMAND_ID,
+            title: ( localize2(8261, "Open Achievements")),
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatPetContextKeys.enabled))
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: "chat.pet.developer.unlockAllAchievements",
+                    title: ( localize2(8262, "Unlock All Pet Achievements")),
+                    category: Categories.Developer,
+                    precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatPetContextKeys.enabled)),
+                    f1: true
+                });
+            }
+            run(accessor) {
+                const chatPetService = accessor.get(IChatPetService);
+                for (const achievement of chatPetAchievements) {
+                    chatPetService.unlockAchievement(achievement.id);
+                }
+                status(( localize(8263, "All enabled pet achievements unlocked")));
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: "chat.pet.developer.resetAchievements",
+                    title: ( localize2(8264, "Reset Pet Achievements")),
+                    category: Categories.Developer,
+                    precondition: ChatContextKeys.enabled,
+                    f1: true
+                });
+            }
+            run(accessor) {
+                accessor.get(IChatPetService).resetAchievements();
+                status(( localize(8265, "Pet achievements reset")));
+            }
+        });
+    }
+    async run(accessor) {
+        if (!accessor.get(IChatPetService).enabled.get()) {
+            return;
+        }
+        await accessor.get(IEditorService).openEditor(ChatPetAchievementsEditorInput.getOrCreate(), {
+            pinned: true
+        });
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "chat.pet.developer.resetSize",
+            title: ( localize2(8266, "Reset Pet Size")),
+            category: Categories.Developer,
+            precondition: ChatContextKeys.enabled,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const chatPetService = accessor.get(IChatPetService);
+        chatPetService.resetScale();
+        status(( localize(
+            8267,
+            "VS Code pet size reset to {0} percent",
+            Math.round(chatPetService.scale.get() * 100)
+        )));
+    }
+});
+let ChatPetContextContribution = class ChatPetContextContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatPetContext";
+    }
+    constructor(chatPetService, contextKeyService) {
+        super();
+        const enabledContextKey = ChatPetContextKeys.enabled.bindTo(contextKeyService);
+        this._register(autorun(reader => {
+            enabledContextKey.set(chatPetService.enabled.read(reader));
+        }));
+    }
+};
+ChatPetContextContribution = ( __decorate([( __param(0, IChatPetService)), ( __param(1, IContextKeyService))], ChatPetContextContribution));
+const CHAT_PET_KEEP_EDIT_COMMAND_IDS = ( new Set([
+    "chatEditing.acceptFile",
+    "chatEditing.acceptAllFiles",
+    "chatEditor.action.accept",
+    "chatEditor.action.acceptHunk",
+    "chatEditor.action.acceptAllEdits",
+    "chatEditing.multidiff.acceptAllFiles"
+]));
+const CHAT_PET_REVIEW_EDIT_COMMAND_IDS = ( new Set([
+    "chatEditor.action.reviewChanges",
+    "chatEditing.openFileInDiff",
+    "chatEditing.viewChanges",
+    "chatEditing.viewAllSessionChanges",
+    "workbench.changesView.action.viewChanges"
+]));
+const CHAT_PET_COPY_OUTPUT_COMMAND_IDS = ( new Set([
+    "workbench.action.chat.copyAll",
+    "workbench.action.chat.copyItem",
+    "workbench.action.chat.copyFinalResponse",
+    "workbench.action.chat.copyCodeBlock"
+]));
+let ChatPetEditingAchievementContribution = class ChatPetEditingAchievementContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatPetEditingAchievement";
+    }
+    constructor(commandService, chatPetService) {
+        super();
+        this._register(commandService.onDidExecuteCommand(event => {
+            if (( CHAT_PET_KEEP_EDIT_COMMAND_IDS.has(event.commandId))) {
+                chatPetService.unlockAchievement(ChatPetAchievementIds.AgentEditKept);
+            }
+            if (( CHAT_PET_REVIEW_EDIT_COMMAND_IDS.has(event.commandId))) {
+                chatPetService.unlockAchievement(ChatPetAchievementIds.AgentChangesReviewed);
+            }
+            if (( CHAT_PET_COPY_OUTPUT_COMMAND_IDS.has(event.commandId))) {
+                chatPetService.unlockAchievement(ChatPetAchievementIds.UsefulOutputCopied);
+            }
+        }));
+    }
+};
+ChatPetEditingAchievementContribution = ( __decorate([( __param(0, ICommandService)), ( __param(1, IChatPetService))], ChatPetEditingAchievementContribution));
+let ChatPetCustomizationAchievementContribution = class ChatPetCustomizationAchievementContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatPetCustomizationAchievements";
+    }
+    constructor(
+        chatPetService,
+        customizationItemsModel,
+        customizationHarnessService,
+        mcpWorkbenchService,
+        logService
+    ) {
+        super();
+        this.chatPetService = chatPetService;
+        this.customizationItemsModel = customizationItemsModel;
+        this.customizationHarnessService = customizationHarnessService;
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.logService = logService;
+        this.customizationBaselineVersion = 0;
+        this.customizationBaselineReady = false;
+        this.observedSkillIds = ( new Set());
+        this.observedInstructionIds = ( new Set());
+        this.observationInitializationStarted = false;
+        this._register(autorun(reader => {
+            if (!this.chatPetService.enabled.read(reader) || this.observationInitializationStarted) {
+                return;
+            }
+            this.observationInitializationStarted = true;
+            void this.initializeCustomizationObservation();
+            void this.initializeMcpObservation();
+        }));
+    }
+    async initializeCustomizationObservation() {
+        const skills = this.customizationItemsModel.getItems(AICustomizationManagementSection.Skills);
+        const instructions = this.customizationItemsModel.getItems(AICustomizationManagementSection.Instructions);
+        let waitForLatestFetch = false;
+        while (!this._store.isDisposed) {
+            const source = this.customizationItemsModel.getActiveItemSource();
+            if (await this.establishCustomizationBaseline(skills, instructions, source, waitForLatestFetch)) {
+                break;
+            }
+            waitForLatestFetch = true;
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        this._register(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            this.customizationHarnessService.availableHarnesses.read(reader);
+            const source = this.customizationItemsModel.getActiveItemSource();
+            const currentSkillIds = getUserCustomizationIds(skills.read(reader));
+            const currentInstructionIds = getUserCustomizationIds(instructions.read(reader));
+            const enabled = this.chatPetService.enabled.read(reader);
+            const unlocked = ( new Set(this.chatPetService.unlockedAchievements.read(reader)));
+            if (source !== this.observedCustomizationSource) {
+                this.observedCustomizationSource = source;
+                this.customizationBaselineReady = false;
+                void this.establishCustomizationBaseline(skills, instructions, source, true);
+                return;
+            }
+            if (!this.customizationBaselineReady) {
+                return;
+            }
+            const skillAdded = hasAddedId(currentSkillIds, this.observedSkillIds);
+            const instructionAdded = hasAddedId(currentInstructionIds, this.observedInstructionIds);
+            this.observedSkillIds = currentSkillIds;
+            this.observedInstructionIds = currentInstructionIds;
+            if (enabled && skillAdded && !( unlocked.has(ChatPetAchievementIds.CustomSkillPresent))) {
+                this.chatPetService.unlockAchievement(ChatPetAchievementIds.CustomSkillPresent);
+            }
+            if (enabled && instructionAdded && !( unlocked.has(ChatPetAchievementIds.InstructionPresent))) {
+                this.chatPetService.unlockAchievement(ChatPetAchievementIds.InstructionPresent);
+            }
+        }));
+    }
+    async establishCustomizationBaseline(skills, instructions, expectedSource, waitForLatestFetch) {
+        const version = ++this.customizationBaselineVersion;
+        this.customizationBaselineReady = false;
+        if (waitForLatestFetch) {
+            await timeout(0);
+        }
+        await Promise.all([
+            this.customizationItemsModel.whenSectionLoaded(AICustomizationManagementSection.Skills),
+            this.customizationItemsModel.whenSectionLoaded(AICustomizationManagementSection.Instructions)
+        ]);
+        if (this._store.isDisposed || version !== this.customizationBaselineVersion || expectedSource !== this.customizationItemsModel.getActiveItemSource()) {
+            return false;
+        }
+        this.observedCustomizationSource = expectedSource;
+        this.observedSkillIds = getUserCustomizationIds(skills.get());
+        this.observedInstructionIds = getUserCustomizationIds(instructions.get());
+        this.customizationBaselineReady = true;
+        return true;
+    }
+    async initializeMcpObservation() {
+        try {
+            await this.mcpWorkbenchService.queryLocal();
+        } catch (error) {
+            this.logService.error(
+                "[ChatPetCustomizationAchievementContribution] Failed to establish the MCP server baseline",
+                error
+            );
+            return;
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        let observedServerIds = getMcpServerIds(this.mcpWorkbenchService);
+        this._register(this.mcpWorkbenchService.onChange(() => {
+            const currentServerIds = getMcpServerIds(this.mcpWorkbenchService);
+            const serverAdded = hasAddedId(currentServerIds, observedServerIds);
+            observedServerIds = currentServerIds;
+            if (this.chatPetService.enabled.get() && serverAdded && !this.chatPetService.unlockedAchievements.get().includes(ChatPetAchievementIds.McpServerPresent)) {
+                this.chatPetService.unlockAchievement(ChatPetAchievementIds.McpServerPresent);
+            }
+        }));
+    }
+};
+ChatPetCustomizationAchievementContribution = ( __decorate([( __param(0, IChatPetService)), ( __param(1, IAICustomizationItemsModel)), ( __param(2, ICustomizationHarnessService)), ( __param(3, IMcpWorkbenchService)), ( __param(4, ILogService))], ChatPetCustomizationAchievementContribution));
+function getUserCustomizationIds(items) {
+    return ( new Set(( items.filter(item => isUserAuthoredChatPetCustomization(item.source, item.isBuiltin)).map(item => item.id))));
+}
+function getMcpServerIds(mcpWorkbenchService) {
+    return ( new Set(( mcpWorkbenchService.local.map(server => server.id))));
+}
+function hasAddedId(currentIds, previousIds) {
+    for (const id of currentIds) {
+        if (!( previousIds.has(id))) {
+            return true;
+        }
+    }
+    return false;
+}
+class ChatPetAchievementsAccessibilityHelp {
+    constructor() {
+        this.priority = 110;
+        this.name = "chatPetAchievements";
+        this.type = AccessibleViewType.Help;
+        this.when = ChatPetAchievementsContextKeys.focused;
+    }
+    getProvider(_accessor) {
+        const previouslyFocusedElement = getActiveElement();
+        const editorService = _accessor.get(IEditorService);
+        const content = [( localize(
+            8268,
+            "The Achievements modal lists agent-feature achievements and their pet hat rewards. Locked cards reveal a hint and reward while keeping the achievement name and exact unlock requirement hidden."
+        )), ( localize(
+            8269,
+            "Use Tab and Shift+Tab to move through No Hat and the achievement cards. Press Enter or Space on No Hat or an unlocked achievement to change what the pet wears. Newly unlocked cards are announced as New until you activate them. Locked achievements announce their hint and reward and cannot be selected."
+        )), ( localize(
+            8270,
+            "The final TBD card is informational and lists upcoming pet ideas. The VS Code pet and achievements are experimental and may change."
+        )), ( localize(8271, "Press Escape to close the Achievements modal."))].join("\n\n");
+        return ( new AccessibleContentProvider(AccessibleViewProviderId.ChatPetAchievements, {
+            type: AccessibleViewType.Help
+        }, () => content, () => {
+            if (isHTMLElement(previouslyFocusedElement) && previouslyFocusedElement.isConnected && previouslyFocusedElement.getClientRects().length > 0) {
+                previouslyFocusedElement.focus();
+            } else {
+                editorService.activeEditorPane?.focus();
+            }
+        }, AccessibilityVerbositySettingId.ChatPetAchievements));
+    }
+}
+
+export { ChatPetAchievementsAccessibilityHelp, ChatPetContextContribution, ChatPetCustomizationAchievementContribution, ChatPetEditingAchievementContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievementsEditor.d.ts

@@ -0,0 +1,33 @@
+import * as DOM from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { ChatPetAchievementsEditorInput } from "./chatPetAchievementsEditorInput.js";
+import { IChatPetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service";
+export declare const ChatPetAchievementsContextKeys: {
+    focused: RawContextKey<boolean>;
+};
+export declare class ChatPetAchievementsEditor extends EditorPane {
+    private readonly instantiationService;
+    private readonly chatPetService;
+    static readonly ID = "workbench.editor.chatPetAchievements";
+    private readonly editorDisposables;
+    private readonly focusedContextKey;
+    private container;
+    private widget;
+    private dimension;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService, chatPetService: IChatPetService);
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: ChatPetAchievementsEditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    clearInput(): void;
+    layout(dimension: DOM.Dimension): void;
+    focus(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievementsEditor.js

@@ -0,0 +1,99 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, trackFocus } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { ChatPetAchievementsWidget } from './chatPetAchievementsWidget.js';
+import { IChatPetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var ChatPetAchievementsEditor_1;
+const ChatPetAchievementsContextKeys = {
+    focused: ( new RawContextKey("chatPetAchievementsFocused", false, ( localize(8340, "Whether the chat pet Achievements modal is focused"))))
+};
+let ChatPetAchievementsEditor = class ChatPetAchievementsEditor extends EditorPane {
+    static {
+        ChatPetAchievementsEditor_1 = this;
+    }
+    static {
+        this.ID = "workbench.editor.chatPetAchievements";
+    }
+    constructor(
+        group,
+        telemetryService,
+        themeService,
+        storageService,
+        instantiationService,
+        contextKeyService,
+        chatPetService
+    ) {
+        super(
+            ChatPetAchievementsEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.instantiationService = instantiationService;
+        this.chatPetService = chatPetService;
+        this.editorDisposables = this._register(( new DisposableStore()));
+        this.focusedContextKey = ChatPetAchievementsContextKeys.focused.bindTo(contextKeyService);
+        this._register(toDisposable(() => this.focusedContextKey.reset()));
+        this._register(autorun(reader => {
+            if (!this.chatPetService.enabled.read(reader) && this.input) {
+                void this.group.closeEditor(this.input);
+            }
+        }));
+    }
+    createEditor(parent) {
+        this.editorDisposables.clear();
+        this.container = append(parent, $(".chat-pet-achievements-editor"));
+        const focusTracker = this.editorDisposables.add(trackFocus(this.container));
+        this.editorDisposables.add(focusTracker.onDidFocus(() => this.focusedContextKey.set(true)));
+        this.editorDisposables.add(focusTracker.onDidBlur(() => this.focusedContextKey.set(false)));
+        this.widget = this.editorDisposables.add(
+            this.instantiationService.createInstance(ChatPetAchievementsWidget, this.container, () => {
+                if (this.input) {
+                    void this.group.closeEditor(this.input);
+                }
+            })
+        );
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        if (!this.chatPetService.enabled.get()) {
+            await this.group.closeEditor(input);
+            return;
+        }
+        if (this.dimension) {
+            this.layout(this.dimension);
+        }
+    }
+    clearInput() {
+        this.focusedContextKey.set(false);
+        super.clearInput();
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        if (this.container) {
+            this.container.style.width = `${dimension.width}px`;
+            this.container.style.height = `${dimension.height}px`;
+        }
+        this.widget?.layout(dimension);
+    }
+    focus() {
+        super.focus();
+        this.widget?.focus();
+    }
+};
+ChatPetAchievementsEditor = ChatPetAchievementsEditor_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService)), ( __param(5, IContextKeyService)), ( __param(6, IChatPetService))], ChatPetAchievementsEditor));
+
+export { ChatPetAchievementsContextKeys, ChatPetAchievementsEditor };

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievementsEditorInput.d.ts

@@ -0,0 +1,17 @@
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IModalEditorOptions, IModalEditorOptionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { EditorInputCapabilities, IUntypedEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+export declare class ChatPetAchievementsEditorInput extends EditorInput implements IModalEditorOptionsProvider {
+    static readonly ID = "workbench.editors.chatPetAchievements";
+    private static instance;
+    readonly resource: undefined;
+    static getOrCreate(): ChatPetAchievementsEditorInput;
+    get capabilities(): EditorInputCapabilities;
+    get typeId(): string;
+    getName(): string;
+    getIcon(): ThemeIcon;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    getModalEditorOptions(): IModalEditorOptions;
+    resolve(): Promise<null>;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievementsEditorInput.js

@@ -0,0 +1,46 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
+
+class ChatPetAchievementsEditorInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = undefined;
+    }
+    static {
+        this.ID = "workbench.editors.chatPetAchievements";
+    }
+    static getOrCreate() {
+        if (!ChatPetAchievementsEditorInput.instance || ChatPetAchievementsEditorInput.instance.isDisposed()) {
+            ChatPetAchievementsEditorInput.instance = ( new ChatPetAchievementsEditorInput());
+        }
+        return ChatPetAchievementsEditorInput.instance;
+    }
+    get capabilities() {
+        return super.capabilities | EditorInputCapabilities.Singleton | EditorInputCapabilities.RequiresModal;
+    }
+    get typeId() {
+        return ChatPetAchievementsEditorInput.ID;
+    }
+    getName() {
+        return localize(8341, "Achievements");
+    }
+    getIcon() {
+        return Codicon.starFull;
+    }
+    matches(otherInput) {
+        return super.matches(otherInput) || otherInput instanceof ChatPetAchievementsEditorInput;
+    }
+    getModalEditorOptions() {
+        return {
+            compactHeader: true
+        };
+    }
+    async resolve() {
+        return null;
+    }
+}
+
+export { ChatPetAchievementsEditorInput };

package/vscode/src/vs/workbench/contrib/chat/browser/chatPetAchievementsWidget.d.ts

@@ -0,0 +1,27 @@
+import * as DOM from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IChatPetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service";
+export declare class ChatPetAchievementsWidget extends Disposable {
+    private readonly onDidRequestClose;
+    private readonly chatPetService;
+    private readonly themeService;
+    private readonly logService;
+    private readonly container;
+    private readonly content;
+    private readonly scrollable;
+    private readonly renderDisposables;
+    private readonly accessoryCards;
+    private unseenAchievementIds;
+    private focusTarget;
+    private lastDimension;
+    constructor(parent: HTMLElement, onDidRequestClose: () => void, chatPetService: IChatPetService, themeService: IThemeService, logService: ILogService);
+    layout(dimension?: DOM.Dimension): void;
+    focus(): void;
+    private render;
+    private renderCardPreview;
+    private selectAccessory;
+    private updateSelectedAccessory;
+    private updateNewAchievements;
+}