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

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/customizationMigration.js

@@ -0,0 +1,240 @@
+
+import { splitLinesIncludeSeparators } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { basename, dirname, getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { getCleanPromptName, getPromptFileExtension, SKILL_FILENAME, VALID_SKILL_NAME_REGEX } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptHeaderAttributes, PromptFileParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
+import { getCustomizationMigrationTargetType } from '../../common/promptSyntax/service/customizationMigrationService.js';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+
+const retainedPromptHeaderKeys = ( new Set([
+    PromptHeaderAttributes.name,
+    PromptHeaderAttributes.description,
+    PromptHeaderAttributes.argumentHint
+]));
+function migratePromptFileToSkill(promptFile, content, skillNameOverride) {
+    const parser = ( new PromptFileParser());
+    const parsed = parser.parse(promptFile.uri, content);
+    const friendlyName = promptFile.name?.trim() || parsed.header?.name?.trim() || getCleanPromptName(promptFile.uri);
+    const skillName = skillNameOverride ?? sanitizeSkillName(friendlyName);
+    const description = promptFile.description?.trim() || parsed.header?.description?.trim() || friendlyName;
+    const argumentHint = parsed.header?.argumentHint?.trim();
+    const argumentHintAttribute = parsed.header?.getAttribute(PromptHeaderAttributes.argumentHint);
+    const body = getPromptBody(parsed, content);
+    const unsupportedHeaderKeys = parsed.header?.attributes.filter(attribute => !( retainedPromptHeaderKeys.has(attribute.key))).map(attribute => attribute.key) ?? [];
+    const headerLines = [
+        "---",
+        `name: ${skillName}`,
+        `description: ${description}`,
+        "disable-model-invocation: true"
+    ];
+    if (argumentHint) {
+        headerLines.push(
+            `argument-hint: ${formatMigratedHeaderValue(argumentHint, argumentHintAttribute)}`
+        );
+    }
+    headerLines.push("---", "");
+    return {
+        skillName,
+        content: `${headerLines.join("\n")}${body}`,
+        unsupportedHeaderKeys
+    };
+}
+function formatMigratedHeaderValue(value, sourceAttribute) {
+    if (sourceAttribute?.value.type === "scalar") {
+        switch (sourceAttribute.value.format) {
+        case "single":
+            return `'${value.replace(/'/g, `''`)}'`;
+        case "double":
+            return JSON.stringify(value);
+        case "none":
+            return value;
+        }
+    }
+    return value;
+}
+async function migrateCustomizations(customizations, targetFolders, fileService, onMigrationError, options) {
+    const reservedSkillNames = ( new Map());
+    const reservedFileNames = ( new Map());
+    const unsupportedHeaderKeys = ( new Set());
+    const failedCustomizationFileNames = [];
+    const migratedCustomizations = [];
+    const migratedSources = [];
+    let migratedCount = 0;
+    const deleteOriginalFiles = options?.deleteOriginalFiles ?? true;
+    const customizationsBySource = ( new ResourceMap());
+    for (const customization of customizations) {
+        const sourceCustomizations = customizationsBySource.get(customization.uri) ?? [];
+        sourceCustomizations.push(customization);
+        customizationsBySource.set(customization.uri, sourceCustomizations);
+    }
+    for (const sourceCustomizations of ( customizationsBySource.values())) {
+        const sourceCustomization = sourceCustomizations[0];
+        const writtenTargetUris = [];
+        const migratedSourceCustomizations = [];
+        const sourceUnsupportedHeaderKeys = ( new Set());
+        try {
+            const content = ( (await fileService.readFile(sourceCustomization.uri)).value.toString());
+            for (const customization of sourceCustomizations) {
+                const targetType = getCustomizationMigrationTargetType(customization);
+                const targetFolder = targetFolders.get(targetType)?.get(customization.storage);
+                if (!targetFolder) {
+                    throw ( new Error(
+                        `No ${targetType} target folder is configured for ${customization.storage} customizations.`
+                    ));
+                }
+                let targetUri;
+                let migratedContent = content;
+                if (customization.type === PromptsType.prompt) {
+                    const migratedPrompt = migratePromptFileToSkill(customization, content);
+                    const reservedNamesForFolder = getOrCreateReservedNames(targetFolder.uri, reservedSkillNames);
+                    const skillName = await getAvailableMigratedSkillName(
+                        targetFolder.uri,
+                        migratedPrompt.skillName,
+                        reservedNamesForFolder,
+                        fileService
+                    );
+                    const migratedSkill = skillName === migratedPrompt.skillName ? migratedPrompt : migratePromptFileToSkill(customization, content, skillName);
+                    for (const key of migratedSkill.unsupportedHeaderKeys) {
+                        sourceUnsupportedHeaderKeys.add(key);
+                    }
+                    targetUri = createSkillFileUri(targetFolder.uri, skillName);
+                    migratedContent = migratedSkill.content;
+                } else if (customization.type === PromptsType.skill) {
+                    const reservedNamesForFolder = getOrCreateReservedNames(targetFolder.uri, reservedSkillNames);
+                    const skillName = await getAvailableMigratedSkillName(
+                        targetFolder.uri,
+                        basename(dirname(customization.uri)),
+                        reservedNamesForFolder,
+                        fileService
+                    );
+                    targetUri = createSkillFileUri(targetFolder.uri, skillName);
+                } else {
+                    const reservedNamesForFolder = getOrCreateReservedNames(targetFolder.uri, reservedFileNames);
+                    targetUri = await getAvailableMigratedFileUri(targetFolder.uri, customization, reservedNamesForFolder, fileService);
+                }
+                await fileService.createFolder(targetFolder.uri);
+                if (customization.type === PromptsType.skill) {
+                    const sourceFolder = dirname(customization.uri);
+                    const targetSkillFolder = dirname(targetUri);
+                    const stagingFolder = URI.joinPath(targetFolder.uri, `.migration-${generateUuid()}`);
+                    writtenTargetUris.push(stagingFolder);
+                    await fileService.copy(sourceFolder, stagingFolder, false);
+                    await fileService.move(stagingFolder, targetSkillFolder, false);
+                    writtenTargetUris.push(targetSkillFolder);
+                } else {
+                    await fileService.createFolder(dirname(targetUri));
+                    await fileService.createFile(targetUri, VSBuffer.fromString(migratedContent), {
+                        overwrite: false
+                    });
+                    writtenTargetUris.push(targetUri);
+                }
+                migratedSourceCustomizations.push({
+                    uri: targetUri,
+                    type: targetType
+                });
+            }
+            if (deleteOriginalFiles) {
+                const sourceToDelete = sourceCustomization.type === PromptsType.skill ? dirname(sourceCustomization.uri) : sourceCustomization.uri;
+                await fileService.del(sourceToDelete, {
+                    recursive: sourceCustomization.type === PromptsType.skill
+                });
+            }
+            for (const key of sourceUnsupportedHeaderKeys) {
+                unsupportedHeaderKeys.add(key);
+            }
+            migratedCustomizations.push(...migratedSourceCustomizations);
+            migratedSources.push(...( sourceCustomizations.map(customization => ({
+                uri: customization.uri,
+                storage: customization.storage
+            }))));
+            migratedCount += migratedSourceCustomizations.length;
+        } catch (error) {
+            const migrationError = error instanceof Error ? error : ( new Error(String(error)));
+            const rollbackErrors = await rollbackMigrationTargets(writtenTargetUris, fileService);
+            failedCustomizationFileNames.push(basename(sourceCustomization.uri));
+            onMigrationError?.(rollbackErrors.length > 0 ? ( new AggregateError(
+                [migrationError, ...rollbackErrors],
+                `Failed to migrate and roll back ${basename(sourceCustomization.uri)}`
+            )) : migrationError);
+        }
+    }
+    return {
+        migratedCount,
+        failedCustomizationFileNames,
+        unsupportedHeaderKeys: Array.from(unsupportedHeaderKeys).sort(),
+        migratedCustomizations,
+        migratedSources
+    };
+}
+async function rollbackMigrationTargets(targetUris, fileService) {
+    const errors = [];
+    for (let index = targetUris.length - 1; index >= 0; index--) {
+        const targetUri = targetUris[index];
+        try {
+            if (await fileService.exists(targetUri)) {
+                await fileService.del(targetUri, {
+                    recursive: true
+                });
+            }
+        } catch (error) {
+            errors.push(error instanceof Error ? error : ( new Error(String(error))));
+        }
+    }
+    return errors;
+}
+function getOrCreateReservedNames(folder, reservedNames) {
+    const key = getComparisonKey(folder);
+    const names = reservedNames.get(key) ?? ( new Set());
+    reservedNames.set(key, names);
+    return names;
+}
+async function getAvailableMigratedFileUri(targetFolder, customization, reservedNames, fileService) {
+    const extension = getPromptFileExtension(customization.type);
+    const baseName = getCleanPromptName(customization.uri);
+    let fileName = `${baseName}${extension}`;
+    let counter = 2;
+    while (( reservedNames.has(fileName)) || (await fileService.exists(URI.joinPath(targetFolder, fileName)))) {
+        fileName = `${baseName}-${counter++}${extension}`;
+    }
+    reservedNames.add(fileName);
+    return URI.joinPath(targetFolder, fileName);
+}
+function getPromptBody(parsed, content) {
+    const linesWithEol = splitLinesIncludeSeparators(content);
+    if (!parsed.body) {
+        return "";
+    }
+    return linesWithEol.slice(parsed.body.range.startLineNumber - 1).join("").replace(/^\r?\n/, "");
+}
+function createSkillFileUri(skillSourceFolder, skillName) {
+    return URI.joinPath(skillSourceFolder, skillName, SKILL_FILENAME);
+}
+function sanitizeSkillName(name) {
+    const strippedName = name.replace(/<[^>]+>/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+    const trimmedName = trimSkillName(strippedName, 0);
+    if (trimmedName && VALID_SKILL_NAME_REGEX.test(trimmedName)) {
+        return trimmedName;
+    }
+    return "migrated-skill";
+}
+function trimSkillName(skillName, suffixLength) {
+    const maxBaseLength = Math.max(1, 64 - suffixLength);
+    return skillName.slice(0, maxBaseLength).replace(/-+$/g, "");
+}
+async function getAvailableMigratedSkillName(skillSourceFolder, baseSkillName, reservedNames, fileService) {
+    let candidate = baseSkillName;
+    let counter = 2;
+    while (( reservedNames.has(candidate)) || (await fileService.exists(URI.joinPath(skillSourceFolder, candidate)))) {
+        const suffix = `-${counter++}`;
+        const trimmedBaseName = trimSkillName(baseSkillName, suffix.length);
+        candidate = `${trimmedBaseName}${suffix}`;
+    }
+    reservedNames.add(candidate);
+    return candidate;
+}
+
+export { createSkillFileUri, migrateCustomizations, migratePromptFileToSkill, trimSkillName };

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

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/customizationMigrationAccessibility.js

@@ -0,0 +1,53 @@
+
+import { getActiveElement, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibleContentProvider, AccessibleViewProviderId, AccessibleViewType } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_EDITOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import { AICustomizationManagementEditor } from './aiCustomizationManagementEditor.js';
+
+class CustomizationMigrationAccessibleView {
+    constructor(type) {
+        this.type = type;
+        this.priority = 110;
+        this.name = "customization-migrations";
+        this.when = CONTEXT_AI_CUSTOMIZATION_MANAGEMENT_EDITOR;
+    }
+    getProvider(accessor) {
+        const editor = accessor.get(IEditorService).activeEditorPane;
+        if (!(editor instanceof AICustomizationManagementEditor)) {
+            return undefined;
+        }
+        const content = editor.getMigrationAccessibilityContent();
+        if (!content) {
+            return undefined;
+        }
+        const focused = getActiveElement();
+        return (new AccessibleContentProvider(AccessibleViewProviderId.CustomizationMigrations, {
+            type: this.type
+        }, () => this.type === AccessibleViewType.Help ? [( localize(
+            6593,
+            "The migration checklist groups supported migrations by your profile and workspace."
+        )), ( localize(
+            6594,
+            "Use Tab and Shift+Tab to move between controls. Review opens the existing migration page filtered to that location. No files change until you confirm migration."
+        )), ( localize(
+            6595,
+            "Change destinations configures file migration locations. MCP servers always migrate to the workspace root .mcp.json."
+        )), ( localize(
+            6596,
+            "Skip Workspace excludes workspace migrations from the checklist count without changing files. Include Workspace restores them."
+        )), ( localize(
+            6597,
+            "Migration activity records successful changes locally. Expand an activity entry with Enter or Space to read its source and destination paths. Dismiss removes the activity record, not the migrated files."
+        )), ( localize(
+            6598,
+            "Use {0} to read the checklist and activity in the Accessible View.",
+            "<keybinding:editor.action.accessibleView>"
+        ))].join("\n\n") : content, () => isHTMLElement(focused) && focused.isConnected ? focused.focus() : editor.focus(), AccessibilityVerbositySettingId.CustomizationMigrations));
+    }
+}
+AccessibleViewRegistry.register(( new CustomizationMigrationAccessibleView(AccessibleViewType.Help)));
+AccessibleViewRegistry.register(( new CustomizationMigrationAccessibleView(AccessibleViewType.View)));

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

@@ -0,0 +1,82 @@
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ChatConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { CustomizationMigrationCandidate, CustomizationMigrationType, IMcpServerCustomizationMigrationFailure, MigratableConfiguration } from "../../common/promptSyntax/service/customizationMigrationService.js";
+export declare enum CustomizationMigrationCategoryId {
+    PromptFiles = "promptFiles",
+    UserData = "userData",
+    ConfiguredLocations = "configuredLocations",
+    McpServers = "mcpServers"
+}
+export interface ICustomizationMigrationGroup {
+    readonly key: string;
+    readonly label: string;
+    readonly customizations: readonly CustomizationMigrationCandidate[];
+}
+export interface ICustomizationMigrationCandidatePresentation {
+    readonly name: string;
+    readonly selectionAriaLabel: string;
+    readonly pathLabel: string;
+    readonly file?: MigratableConfiguration;
+}
+export interface ICustomizationMigrationConfirmation {
+    readonly message: string;
+    readonly detail: string;
+    readonly primaryButton: string;
+    readonly deleteOriginalsLabel?: string;
+}
+/**
+ * Prominent explanation shown above the migration list.
+ */
+export interface ICustomizationMigrationBanner {
+    readonly message: string | IMarkdownString;
+    readonly consequence?: string;
+}
+/**
+ * A self-contained migration flow. Each category owns its candidates, grouping,
+ * and user-visible copy so migrations stay focused and independently readable.
+ */
+export interface ICustomizationMigrationCategory {
+    readonly id: CustomizationMigrationCategoryId;
+    readonly migrationType: CustomizationMigrationType;
+    /** Prompt types scanned when collecting candidates for this category. */
+    readonly sourceTypes?: readonly PromptsType[];
+    /** Experimental setting gating this migration. Each category is enabled independently. */
+    readonly enablementSetting: ChatConfiguration;
+    /** Settings that must differ from their defaults for this migration to apply. */
+    readonly configurationSettingIds?: readonly string[];
+    readonly shortcutLabel: string;
+    readonly shortcutTooltip: string;
+    readonly cardLabel: string;
+    readonly cardActionLabel: string;
+    readonly cardActionAriaLabel: string;
+    readonly pageTitle: string;
+    readonly pageLinkLabel: string;
+    readonly pageLinkUrl: string;
+    readonly pageEmptyMessage: string;
+    readonly migrateButtonTooltip: string;
+    readonly backLabel: string;
+    readonly noFilesMigratedMessage: string;
+    isCandidate?(customization: MigratableConfiguration): boolean;
+    group(customizations: readonly CustomizationMigrationCandidate[]): readonly ICustomizationMigrationGroup[];
+    getCandidatePresentation(customization: CustomizationMigrationCandidate, getUriLabel: (uri: URI) => string): ICustomizationMigrationCandidatePresentation;
+    getShortcutAriaLabel(count: number): string;
+    getCardDescription(customizations: readonly CustomizationMigrationCandidate[], harnessLabel: string): string;
+    getPageDescription(customizations: readonly CustomizationMigrationCandidate[], harnessLabel: string): string;
+    /** When present, replaces the page description with a prominent banner. */
+    getModifiedSettingIds?(configurationService: IConfigurationService): readonly string[];
+    getBanner?(customizations: readonly CustomizationMigrationCandidate[], harnessLabel: string, destinationLabel: string | undefined, modifiedSettingIds: readonly string[]): ICustomizationMigrationBanner;
+    getConfirmation(customizations: readonly CustomizationMigrationCandidate[], harnessLabel: string, destinationLabel?: string): ICustomizationMigrationConfirmation;
+    getMigratedMessage(migratedCount: number): string;
+    getMigratedWithReviewMessage?(migratedCount: number, unsupportedHeaderKeys: string): string;
+    getFailedMessage(failedFileNames: readonly string[], hiddenFileCount: number): string;
+    getMcpServerFailureMessage?(failures: readonly IMcpServerCustomizationMigrationFailure[]): string;
+}
+export declare const CUSTOMIZATION_MIGRATION_CATEGORIES: readonly ICustomizationMigrationCategory[];
+export declare function getCustomizationMigrationCategory(id: CustomizationMigrationCategoryId): ICustomizationMigrationCategory;
+/**
+ * All prompt types the given categories can discover, so candidates can be collected with one pass per type.
+ */
+export declare function getCustomizationMigrationSourceTypes(categories: readonly ICustomizationMigrationCategory[]): readonly PromptsType[];