@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -0,0 +1,60 @@
+import { PromptsStorage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+/**
+ * Information about a file that was loaded or skipped.
+ */
+export interface IFileStatusInfo {
+    uri: URI;
+    status: "loaded" | "skipped" | "overwritten";
+    reason?: string;
+    name?: string;
+    storage: PromptsStorage;
+    /** For overwritten files, the name of the file that took precedence */
+    overwrittenBy?: string;
+    /** Extension ID if this file comes from an extension */
+    extensionId?: string;
+}
+/**
+ * Path information with scan order.
+ */
+export interface IPathInfo {
+    uri: URI;
+    exists: boolean;
+    storage: PromptsStorage;
+    /** 1-based scan order (lower = higher priority) */
+    scanOrder: number;
+    /** Original path string for display (e.g., '~/.copilot/agents' or '.github/agents') */
+    displayPath: string;
+    /** Whether this is a default folder (vs custom configured) */
+    isDefault: boolean;
+}
+/**
+ * Status information for a specific type of prompt files.
+ */
+export interface ITypeStatusInfo {
+    type: PromptsType;
+    paths: IPathInfo[];
+    files: IFileStatusInfo[];
+    enabled: boolean;
+}
+/**
+ * Registers the Diagnostics action for the chat context menu.
+ */
+export declare function registerChatCustomizationDiagnosticsAction(): void;
+/**
+ * Formats the status output as a compact markdown string with tree structure.
+ * Files are grouped under their parent paths.
+ * Special files (AGENTS.md, copilot-instructions.md) are merged into their respective sections.
+ */
+export declare function formatStatusOutput(statusInfos: ITypeStatusInfo[], specialFiles: {
+    agentsMd: {
+        enabled: boolean;
+        files: URI[];
+    };
+    copilotInstructions: {
+        enabled: boolean;
+        files: URI[];
+    };
+}, workspaceFolders: readonly IWorkspaceFolder[]): string;

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatCustomizationDiagnosticsAction.js

@@ -0,0 +1,435 @@
+
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { relativePath, basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { COPILOT_CUSTOM_INSTRUCTIONS_FILENAME } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { IUntitledTextEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service';
+import { CHAT_CONFIG_MENU_ID, CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+
+function encodePathForMarkdown(path) {
+    return ( path.split("/").map(segment => encodeURIComponent(segment))).join("/");
+}
+function getRelativePath(uri, workspaceFolders) {
+    const normalizedUri = uri.scheme === Schemas.vscodeUserData ? uri.with({
+        scheme: Schemas.file
+    }) : uri;
+    for (const folder of workspaceFolders) {
+        const relative = relativePath(folder.uri, normalizedUri);
+        if (relative) {
+            return encodePathForMarkdown(relative);
+        }
+    }
+    return encodePathForMarkdown(normalizedUri.fsPath.replace(/\\/g, "/"));
+}
+const TREE_BRANCH = "├─";
+const TREE_END = "└─";
+const ICON_ERROR = "❌";
+const ICON_WARN = "⚠️";
+function registerChatCustomizationDiagnosticsAction() {
+    registerAction2(class DiagnosticsAction extends Action2 {
+        constructor() {
+            super({
+                id: "workbench.action.chat.diagnostics",
+                title: ( localize2(4743, "Diagnostics")),
+                f1: false,
+                category: CHAT_CATEGORY,
+                menu: [{
+                    id: MenuId.ChatContext,
+                    group: "z_clear",
+                    order: -1
+                }, {
+                    id: CHAT_CONFIG_MENU_ID,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals("view", ChatViewId)))),
+                    order: 14,
+                    group: "3_configure"
+                }, {
+                    id: MenuId.ChatWelcomeContext,
+                    group: "2_settings",
+                    order: 0,
+                    when: ( ChatContextKeys.inChatEditor.negate())
+                }]
+            });
+        }
+        async run(accessor) {
+            const promptsService = accessor.get(IPromptsService);
+            const configurationService = accessor.get(IConfigurationService);
+            const fileService = accessor.get(IFileService);
+            const untitledTextEditorService = accessor.get(IUntitledTextEditorService);
+            const commandService = accessor.get(ICommandService);
+            const workspaceContextService = accessor.get(IWorkspaceContextService);
+            const token = CancellationToken.None;
+            const workspaceFolders = workspaceContextService.getWorkspace().folders;
+            const statusInfos = [];
+            const agentsStatus = await collectAgentsStatus(promptsService, fileService, token);
+            statusInfos.push(agentsStatus);
+            const instructionsStatus = await collectInstructionsStatus(promptsService, fileService, token);
+            statusInfos.push(instructionsStatus);
+            const promptsStatus = await collectPromptsStatus(promptsService, fileService, token);
+            statusInfos.push(promptsStatus);
+            const skillsStatus = await collectSkillsStatus(promptsService, configurationService, fileService, token);
+            statusInfos.push(skillsStatus);
+            const specialFilesStatus = await collectSpecialFilesStatus(promptsService, configurationService, token);
+            const output = formatStatusOutput(statusInfos, specialFilesStatus, workspaceFolders);
+            const untitledModel = untitledTextEditorService.create({
+                initialValue: output,
+                languageId: "markdown"
+            });
+            await commandService.executeCommand("vscode.open", untitledModel.resource);
+        }
+    });
+}
+async function collectAgentsStatus(promptsService, fileService, token) {
+    const type = PromptsType.agent;
+    const enabled = true;
+    const resolvedFolders = await promptsService.getResolvedSourceFolders(type);
+    const paths = await convertResolvedFoldersToPathInfo(resolvedFolders, fileService);
+    const discoveryInfo = await promptsService.getPromptDiscoveryInfo(type, token);
+    const files = ( discoveryInfo.files.map(convertDiscoveryResultToFileStatus));
+    return {
+        type,
+        paths,
+        files,
+        enabled
+    };
+}
+async function collectInstructionsStatus(promptsService, fileService, token) {
+    const type = PromptsType.instructions;
+    const enabled = true;
+    const resolvedFolders = await promptsService.getResolvedSourceFolders(type);
+    const paths = await convertResolvedFoldersToPathInfo(resolvedFolders, fileService);
+    const discoveryInfo = await promptsService.getPromptDiscoveryInfo(type, token);
+    const files = ( discoveryInfo.files.filter(f => basename(f.uri) !== COPILOT_CUSTOM_INSTRUCTIONS_FILENAME).map(convertDiscoveryResultToFileStatus));
+    return {
+        type,
+        paths,
+        files,
+        enabled
+    };
+}
+async function collectPromptsStatus(promptsService, fileService, token) {
+    const type = PromptsType.prompt;
+    const enabled = true;
+    const resolvedFolders = await promptsService.getResolvedSourceFolders(type);
+    const paths = await convertResolvedFoldersToPathInfo(resolvedFolders, fileService);
+    const discoveryInfo = await promptsService.getPromptDiscoveryInfo(type, token);
+    const files = ( discoveryInfo.files.map(convertDiscoveryResultToFileStatus));
+    return {
+        type,
+        paths,
+        files,
+        enabled
+    };
+}
+async function collectSkillsStatus(promptsService, configurationService, fileService, token) {
+    const type = PromptsType.skill;
+    const enabled = configurationService.getValue(PromptsConfig.USE_AGENT_SKILLS) ?? false;
+    const resolvedFolders = await promptsService.getResolvedSourceFolders(type);
+    const paths = await convertResolvedFoldersToPathInfo(resolvedFolders, fileService);
+    const discoveryInfo = await promptsService.getPromptDiscoveryInfo(type, token);
+    const files = ( discoveryInfo.files.map(convertDiscoveryResultToFileStatus));
+    return {
+        type,
+        paths,
+        files,
+        enabled
+    };
+}
+async function collectSpecialFilesStatus(promptsService, configurationService, token) {
+    const useAgentMd = configurationService.getValue(PromptsConfig.USE_AGENT_MD) ?? false;
+    let agentMdFiles = [];
+    if (useAgentMd) {
+        agentMdFiles = await promptsService.listAgentMDs(token, false);
+    }
+    const useCopilotInstructions = configurationService.getValue(PromptsConfig.USE_COPILOT_INSTRUCTION_FILES) ?? false;
+    let copilotInstructionsFiles = [];
+    if (useCopilotInstructions) {
+        copilotInstructionsFiles = await promptsService.listCopilotInstructionsMDs(token);
+    }
+    return {
+        agentsMd: {
+            enabled: useAgentMd,
+            files: agentMdFiles
+        },
+        copilotInstructions: {
+            enabled: useCopilotInstructions,
+            files: copilotInstructionsFiles
+        }
+    };
+}
+async function checkDirectoryExists(fileService, uri) {
+    try {
+        const stat = await fileService.stat(uri);
+        return stat.isDirectory;
+    } catch {
+        return false;
+    }
+}
+async function convertResolvedFoldersToPathInfo(resolvedFolders, fileService) {
+    const paths = [];
+    let scanOrder = 1;
+    for (const folder of resolvedFolders) {
+        const exists = await checkDirectoryExists(fileService, folder.uri);
+        paths.push({
+            uri: folder.uri,
+            exists,
+            storage: folder.storage,
+            scanOrder: scanOrder++,
+            displayPath: folder.displayPath ?? folder.uri.path,
+            isDefault: folder.isDefault ?? false
+        });
+    }
+    return paths;
+}
+function getSkipReasonMessage(skipReason, errorMessage) {
+    switch (skipReason) {
+    case "missing-name":
+        return localize(4744, "Missing name attribute");
+    case "missing-description":
+        return localize(4745, "Missing description attribute");
+    case "name-mismatch":
+        return errorMessage ?? ( localize(4746, "Name does not match folder"));
+    case "duplicate-name":
+        return localize(4747, "Overwritten by higher priority file");
+    case "parse-error":
+        return errorMessage ?? ( localize(4748, "Parse error"));
+    case "disabled":
+        return localize(4749, "Disabled");
+    default:
+        return errorMessage ?? ( localize(4750, "Unknown error"));
+    }
+}
+function convertDiscoveryResultToFileStatus(result) {
+    if (result.status === "loaded") {
+        return {
+            uri: result.uri,
+            status: "loaded",
+            name: result.name,
+            storage: result.storage,
+            extensionId: result.extensionId
+        };
+    }
+    if (result.skipReason === "duplicate-name" && result.duplicateOf) {
+        return {
+            uri: result.uri,
+            status: "overwritten",
+            name: result.name,
+            storage: result.storage,
+            overwrittenBy: result.name,
+            extensionId: result.extensionId
+        };
+    }
+    return {
+        uri: result.uri,
+        status: "skipped",
+        name: result.name,
+        reason: getSkipReasonMessage(result.skipReason, result.errorMessage),
+        storage: result.storage,
+        extensionId: result.extensionId
+    };
+}
+function formatStatusOutput(statusInfos, specialFiles, workspaceFolders) {
+    const lines = [];
+    lines.push(`## ${( localize(4751, "Chat Customization Diagnostics"))}`);
+    lines.push(`*${( localize(4752, "WARNING: This file may contain sensitive information."))}*`);
+    lines.push("");
+    for (const info of statusInfos) {
+        const typeName = getTypeName(info.type);
+        if (info.type === PromptsType.skill && !info.enabled) {
+            lines.push(`**${typeName}**`);
+            lines.push(`*${( localize(
+                4753,
+                "Skills are disabled. Enable them by setting `chat.useAgentSkills` to `true` in your settings."
+            ))}*`);
+            lines.push("");
+            continue;
+        }
+        const enabledStatus = info.enabled ? "" : ` *(${( localize(4754, "disabled"))})*`;
+        let loadedCount = info.files.filter(f => f.status === "loaded").length;
+        const skippedCount = info.files.filter(f => f.status === "skipped" || f.status === "overwritten").length;
+        if (info.type === PromptsType.instructions) {
+            if (specialFiles.agentsMd.enabled) {
+                loadedCount += specialFiles.agentsMd.files.length;
+            }
+            if (specialFiles.copilotInstructions.enabled) {
+                loadedCount += specialFiles.copilotInstructions.files.length;
+            }
+        }
+        lines.push(`**${typeName}**${enabledStatus}<br>`);
+        const statsParts = [];
+        if (loadedCount > 0) {
+            if (info.type === PromptsType.skill) {
+                statsParts.push(loadedCount === 1 ? ( localize(4755, "1 skill loaded")) : ( localize(4756, "{0} skills loaded", loadedCount)));
+            } else {
+                statsParts.push(loadedCount === 1 ? ( localize(4757, "1 file loaded")) : ( localize(4758, "{0} files loaded", loadedCount)));
+            }
+        }
+        if (skippedCount > 0) {
+            statsParts.push(( localize(4759, "{0} skipped", skippedCount)));
+        }
+        if (statsParts.length > 0) {
+            lines.push(`*${statsParts.join(", ")}*`);
+        }
+        lines.push("");
+        const allPaths = info.paths;
+        const allFiles = info.files;
+        const filesByPath = ( new Map());
+        const unmatchedFiles = [];
+        for (const file of allFiles) {
+            let matched = false;
+            for (const path of allPaths) {
+                if (isFileUnderPath(file.uri, path.uri)) {
+                    const key = ( path.uri.toString());
+                    if (!( filesByPath.has(key))) {
+                        filesByPath.set(key, []);
+                    }
+                    filesByPath.get(key).push(file);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                unmatchedFiles.push(file);
+            }
+        }
+        let hasContent = false;
+        for (const path of allPaths) {
+            const pathFiles = filesByPath.get(( path.uri.toString())) || [];
+            if (path.exists) {
+                lines.push(`${path.displayPath}<br>`);
+            } else if (path.isDefault) {
+                lines.push(`${path.displayPath}<br>`);
+            } else {
+                lines.push(`${ICON_ERROR} ${path.displayPath} - *${( localize(4760, "Folder does not exist"))}*<br>`);
+            }
+            if (path.exists && pathFiles.length > 0) {
+                for (let i = 0; i < pathFiles.length; i++) {
+                    const file = pathFiles[i];
+                    let fileName;
+                    if (info.type === PromptsType.skill) {
+                        fileName = file.name || `${basename(dirname(file.uri))}`;
+                    } else {
+                        fileName = basename(file.uri);
+                    }
+                    const isLast = i === pathFiles.length - 1;
+                    const prefix = isLast ? TREE_END : TREE_BRANCH;
+                    const filePath = getRelativePath(file.uri, workspaceFolders);
+                    if (file.status === "loaded") {
+                        lines.push(`${prefix} [\`${fileName}\`](${filePath})<br>`);
+                    } else if (file.status === "overwritten") {
+                        lines.push(`${prefix} ${ICON_WARN} [\`${fileName}\`](${filePath}) - *${( localize(4747, "Overwritten by higher priority file"))}*<br>`);
+                    } else {
+                        lines.push(
+                            `${prefix} ${ICON_ERROR} [\`${fileName}\`](${filePath}) - *${file.reason}*<br>`
+                        );
+                    }
+                }
+            }
+            hasContent = true;
+        }
+        if (unmatchedFiles.length > 0) {
+            const filesByExtension = ( new Map());
+            for (const file of unmatchedFiles) {
+                const extId = file.extensionId || "unknown";
+                if (!( filesByExtension.has(extId))) {
+                    filesByExtension.set(extId, []);
+                }
+                filesByExtension.get(extId).push(file);
+            }
+            for (const [extId, extFiles] of filesByExtension) {
+                lines.push(`${( localize(4761, "Extension"))}: ${extId}<br>`);
+                for (let i = 0; i < extFiles.length; i++) {
+                    const file = extFiles[i];
+                    let fileName;
+                    if (info.type === PromptsType.skill) {
+                        fileName = file.name || `${basename(dirname(file.uri))}`;
+                    } else {
+                        fileName = basename(file.uri);
+                    }
+                    const isLast = i === extFiles.length - 1;
+                    const prefix = isLast ? TREE_END : TREE_BRANCH;
+                    const filePath = getRelativePath(file.uri, workspaceFolders);
+                    if (file.status === "loaded") {
+                        lines.push(`${prefix} [\`${fileName}\`](${filePath})<br>`);
+                    } else if (file.status === "overwritten") {
+                        lines.push(`${prefix} ${ICON_WARN} [\`${fileName}\`](${filePath}) - *${( localize(4747, "Overwritten by higher priority file"))}*<br>`);
+                    } else {
+                        lines.push(
+                            `${prefix} ${ICON_ERROR} [\`${fileName}\`](${filePath}) - *${file.reason}*<br>`
+                        );
+                    }
+                }
+            }
+            hasContent = true;
+        }
+        if (info.type === PromptsType.instructions) {
+            if (specialFiles.agentsMd.enabled && specialFiles.agentsMd.files.length > 0) {
+                lines.push(`AGENTS.md<br>`);
+                for (let i = 0; i < specialFiles.agentsMd.files.length; i++) {
+                    const file = specialFiles.agentsMd.files[i];
+                    const fileName = basename(file);
+                    const isLast = i === specialFiles.agentsMd.files.length - 1;
+                    const prefix = isLast ? TREE_END : TREE_BRANCH;
+                    const filePath = getRelativePath(file, workspaceFolders);
+                    lines.push(`${prefix} [\`${fileName}\`](${filePath})<br>`);
+                }
+                hasContent = true;
+            } else if (!specialFiles.agentsMd.enabled) {
+                lines.push(`AGENTS.md -<br>`);
+                hasContent = true;
+            }
+            if (specialFiles.copilotInstructions.enabled && specialFiles.copilotInstructions.files.length > 0) {
+                lines.push(`${COPILOT_CUSTOM_INSTRUCTIONS_FILENAME}<br>`);
+                for (let i = 0; i < specialFiles.copilotInstructions.files.length; i++) {
+                    const file = specialFiles.copilotInstructions.files[i];
+                    const fileName = basename(file);
+                    const isLast = i === specialFiles.copilotInstructions.files.length - 1;
+                    const prefix = isLast ? TREE_END : TREE_BRANCH;
+                    const filePath = getRelativePath(file, workspaceFolders);
+                    lines.push(`${prefix} [\`${fileName}\`](${filePath})<br>`);
+                }
+                hasContent = true;
+            } else if (!specialFiles.copilotInstructions.enabled) {
+                lines.push(`${COPILOT_CUSTOM_INSTRUCTIONS_FILENAME} -<br>`);
+                hasContent = true;
+            }
+        }
+        if (!hasContent && info.enabled) {
+            lines.push(`*${( localize(4762, "No files loaded"))}*`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function isFileUnderPath(fileUri, pathUri) {
+    const filePath = ( fileUri.toString());
+    const folderPath = ( pathUri.toString());
+    return filePath.startsWith(folderPath + "/") || filePath.startsWith(folderPath + "\\");
+}
+function getTypeName(type) {
+    switch (type) {
+    case PromptsType.agent:
+        return localize(4763, "Custom Agents");
+    case PromptsType.instructions:
+        return localize(4764, "Instructions");
+    case PromptsType.prompt:
+        return localize(4765, "Prompt Files");
+    case PromptsType.skill:
+        return localize(4766, "Skills");
+    default:
+        return type;
+    }
+}
+
+export { formatStatusOutput, registerChatCustomizationDiagnosticsAction };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatDeveloperActions.js

@@ -1,5 +1,6 @@
 
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { URI, isUriComponents } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
 import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
@@ -8,17 +9,28 @@ import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 
+function uriReplacer(_key, value) {
+    if (URI.isUri(value)) {
+        return ( value.toString());
+    }
+    if (isUriComponents(value)) {
+        return ( ( URI.from(value)).toString());
+    }
+    return value;
+}
 function registerChatDeveloperActions() {
     registerAction2(LogChatInputHistoryAction);
     registerAction2(LogChatIndexAction);
     registerAction2(InspectChatModelAction);
 }
 class LogChatInputHistoryAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.logInputHistory'; }
+    static {
+        this.ID = "workbench.action.chat.logInputHistory";
+    }
     constructor() {
         super({
             id: LogChatInputHistoryAction.ID,
-            title: ( localize2(4732, "Log Chat Input History")),
+            title: ( localize2(4767, "Log Chat Input History")),
             icon: Codicon.attach,
             category: Categories.Developer,
             f1: true,
@@ -31,11 +43,13 @@ class LogChatInputHistoryAction extends Action2 {
     }
 }
 class LogChatIndexAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.logChatIndex'; }
+    static {
+        this.ID = "workbench.action.chat.logChatIndex";
+    }
     constructor() {
         super({
             id: LogChatIndexAction.ID,
-            title: ( localize2(4733, "Log Chat Index")),
+            title: ( localize2(4768, "Log Chat Index")),
             icon: Codicon.attach,
             category: Categories.Developer,
             f1: true,
@@ -48,11 +62,13 @@ class LogChatIndexAction extends Action2 {
     }
 }
 class InspectChatModelAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.inspectChatModel'; }
+    static {
+        this.ID = "workbench.action.chat.inspectChatModel";
+    }
     constructor() {
         super({
             id: InspectChatModelAction.ID,
-            title: ( localize2(4734, "Inspect Chat Model")),
+            title: ( localize2(4769, "Inspect Chat Model")),
             icon: Codicon.inspect,
             category: Categories.Developer,
             f1: true,
@@ -68,21 +84,21 @@ class InspectChatModelAction extends Action2 {
         }
         const model = widget.viewModel.model;
         const modelData = model.toJSON();
-        let output = '# Chat Model Inspection\n\n';
+        let output = "# Chat Model Inspection\n\n";
         const requests = modelData.requests;
         if (requests && requests.length > 0) {
             const latestRequest = requests[requests.length - 1];
             if (latestRequest.response) {
-                output += '## Latest Response\n\n';
-                output += '```json\n' + JSON.stringify(latestRequest.response, null, 2) + '\n```\n\n';
+                output += "## Latest Response\n\n";
+                output += "```json\n" + JSON.stringify(latestRequest.response, uriReplacer, 2) + "\n```\n\n";
             }
         }
-        output += '## Full Chat Model\n\n';
-        output += '```json\n' + JSON.stringify(modelData, null, 2) + '\n```\n';
+        output += "## Full Chat Model\n\n";
+        output += "```json\n" + JSON.stringify(modelData, uriReplacer, 2) + "\n```\n";
         await editorService.openEditor({
             resource: undefined,
             contents: output,
-            languageId: 'markdown',
+            languageId: "markdown",
             options: {
                 pinned: true
             }

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatFileTreeActions.js

@@ -12,16 +12,16 @@ function registerChatFileTreeActions() {
     registerAction2(class NextFileTreeAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.nextFileTree',
-                title: ( localize2(4760, "Next File Tree")),
+                id: "workbench.action.chat.nextFileTree",
+                title: ( localize2(4800, "Next File Tree")),
                 keybinding: {
                     primary: KeyMod.CtrlCmd | KeyCode.F9,
                     weight: KeybindingWeight.WorkbenchContrib,
-                    when: ChatContextKeys.inChatSession,
+                    when: ChatContextKeys.inChatSession
                 },
                 precondition: ChatContextKeys.enabled,
                 f1: true,
-                category: CHAT_CATEGORY,
+                category: CHAT_CATEGORY
             });
         }
         run(accessor, ...args) {
@@ -31,16 +31,16 @@ function registerChatFileTreeActions() {
     registerAction2(class PreviousFileTreeAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.previousFileTree',
-                title: ( localize2(4761, "Previous File Tree")),
+                id: "workbench.action.chat.previousFileTree",
+                title: ( localize2(4801, "Previous File Tree")),
                 keybinding: {
                     primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.F9,
                     weight: KeybindingWeight.WorkbenchContrib,
-                    when: ChatContextKeys.inChatSession,
+                    when: ChatContextKeys.inChatSession
                 },
                 precondition: ChatContextKeys.enabled,
                 f1: true,
-                category: CHAT_CATEGORY,
+                category: CHAT_CATEGORY
             });
         }
         run(accessor, ...args) {
@@ -56,16 +56,14 @@ function navigateTrees(accessor, reverse) {
     }
     const focused = !widget.inputEditor.hasWidgetFocus() && widget.getFocus();
     const focusedResponse = isResponseVM(focused) ? focused : undefined;
-    const currentResponse = focusedResponse ?? widget.viewModel?.getItems().reverse().find((item) => isResponseVM(item));
+    const currentResponse = focusedResponse ?? widget.viewModel?.getItems().reverse().find(item => isResponseVM(item));
     if (!currentResponse) {
         return;
     }
     widget.reveal(currentResponse);
     const responseFileTrees = widget.getFileTreeInfosForResponse(currentResponse);
     const lastFocusedFileTree = widget.getLastFocusedFileTreeForResponse(currentResponse);
-    const focusIdx = lastFocusedFileTree ?
-        (lastFocusedFileTree.treeIndex + (reverse ? -1 : 1) + responseFileTrees.length) % responseFileTrees.length :
-        reverse ? responseFileTrees.length - 1 : 0;
+    const focusIdx = lastFocusedFileTree ? (lastFocusedFileTree.treeIndex + (reverse ? -1 : 1) + responseFileTrees.length) % responseFileTrees.length : reverse ? responseFileTrees.length - 1 : 0;
     responseFileTrees[focusIdx]?.focus();
 }
 

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

@@ -5,16 +5,18 @@ import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbe
 import { IExtensionManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 export declare class ChatGettingStartedContribution extends Disposable implements IWorkbenchContribution {
     private readonly productService;
     private readonly extensionService;
     private readonly extensionManagementService;
     private readonly storageService;
     private readonly chatWidgetService;
+    private readonly configurationService;
     static readonly ID = "workbench.contrib.chatGettingStarted";
     private recentlyInstalled;
     private static readonly hideWelcomeView;
-    constructor(productService: IProductService, extensionService: IExtensionService, extensionManagementService: IExtensionManagementService, storageService: IStorageService, chatWidgetService: IChatWidgetService);
+    constructor(productService: IProductService, extensionService: IExtensionService, extensionManagementService: IExtensionManagementService, storageService: IStorageService, chatWidgetService: IChatWidgetService, configurationService: IConfigurationService);
     private registerListeners;
     private onDidInstallChat;
 }