@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.2.0

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

@@ -0,0 +1,50 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IHookCommand, extractHookCommandsFromItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
+import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
+export { extractHookCommandsFromItem };
+/**
+ * Resolves a Claude hook type name to our abstract HookType.
+ */
+export declare function resolveClaudeHookType(name: string): HookType | undefined;
+/**
+ * Gets the Claude hook type name for a given abstract HookType.
+ * Returns undefined if the hook type is not supported in Claude.
+ */
+export declare function getClaudeHookTypeName(hookType: HookType): string | undefined;
+/**
+ * Result of parsing Claude hooks file.
+ */
+export interface IParseClaudeHooksResult {
+    /**
+     * The parsed hooks by type.
+     */
+    readonly hooks: Map<HookType, {
+        hooks: IHookCommand[];
+        originalId: string;
+    }>;
+    /**
+     * Whether all hooks from this file were disabled via `disableAllHooks: true`.
+     */
+    readonly disabledAllHooks: boolean;
+}
+/**
+ * Parses hooks from a Claude settings.json file.
+ * Claude format:
+ * {
+ *   "hooks": {
+ *     "PreToolUse": [
+ *       { "matcher": "Bash", "hooks": [{ "type": "command", "command": "..." }] }
+ *     ]
+ *   }
+ * }
+ *
+ * Or simpler format:
+ * {
+ *   "hooks": {
+ *     "PreToolUse": [{ "type": "command", "command": "..." }]
+ *   }
+ * }
+ *
+ * If the file has `disableAllHooks: true` at the top level, all hooks are filtered out.
+ */
+export declare function parseClaudeHooks(json: unknown, workspaceRootUri: URI | undefined, userHome: string): IParseClaudeHooksResult;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/hookClaudeCompat.js

@@ -0,0 +1,78 @@
+
+import { toHookType, extractHookCommandsFromItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+export { extractHookCommandsFromItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { HOOKS_BY_TARGET } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+
+let _hookTypeToClaudeName;
+function getHookTypeToClaudeNameMap() {
+    if (!_hookTypeToClaudeName) {
+        _hookTypeToClaudeName = ( new Map());
+        for (const [claudeName, hookType] of Object.entries(HOOKS_BY_TARGET[Target.Claude])) {
+            _hookTypeToClaudeName.set(hookType, claudeName);
+        }
+    }
+    return _hookTypeToClaudeName;
+}
+function resolveClaudeHookType(name) {
+    return HOOKS_BY_TARGET[Target.Claude][name];
+}
+function getClaudeHookTypeName(hookType) {
+    return getHookTypeToClaudeNameMap().get(hookType);
+}
+function parseClaudeHooks(json, workspaceRootUri, userHome) {
+    const result = ( new Map());
+    if (!json || typeof json !== "object") {
+        return {
+            hooks: result,
+            disabledAllHooks: false
+        };
+    }
+    const root = json;
+    if (root.disableAllHooks === true) {
+        return {
+            hooks: result,
+            disabledAllHooks: true
+        };
+    }
+    const hooks = root.hooks;
+    if (!hooks || typeof hooks !== "object") {
+        return {
+            hooks: result,
+            disabledAllHooks: false
+        };
+    }
+    const hooksObj = hooks;
+    for (const originalId of ( Object.keys(hooksObj))) {
+        const hookType = resolveClaudeHookType(originalId) ?? toHookType(originalId);
+        if (!hookType) {
+            continue;
+        }
+        const hookArray = hooksObj[originalId];
+        if (!Array.isArray(hookArray)) {
+            continue;
+        }
+        const commands = [];
+        for (const item of hookArray) {
+            const extracted = extractHookCommandsFromItem(item, workspaceRootUri, userHome);
+            commands.push(...extracted);
+        }
+        if (commands.length > 0) {
+            const existing = result.get(hookType);
+            if (existing) {
+                existing.hooks.push(...commands);
+            } else {
+                result.set(hookType, {
+                    hooks: commands,
+                    originalId
+                });
+            }
+        }
+    }
+    return {
+        hooks: result,
+        disabledAllHooks: false
+    };
+}
+
+export { getClaudeHookTypeName, parseClaudeHooks, resolveClaudeHookType };

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

@@ -0,0 +1,77 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IHookCommand } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
+import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
+/**
+ * Represents a hook source with its original and normalized properties.
+ * Used to display hooks from different formats in a unified view.
+ */
+export interface IResolvedHookEntry {
+    /** The normalized hook type (our canonical HookType enum) */
+    readonly hookType: HookType;
+    /** The original hook type ID as it appears in the source file */
+    readonly originalHookTypeId: string;
+    /** The source format this hook came from */
+    readonly sourceFormat: HookSourceFormat;
+    /** The resolved hook command */
+    readonly command: IHookCommand;
+    /** The index of this hook in its array (for editing) */
+    readonly index: number;
+}
+/**
+ * Supported hook file formats.
+ */
+export declare enum HookSourceFormat {
+    /** GitHub Copilot hooks .json format */
+    Copilot = "copilot",
+    /** Claude settings.json / settings.local.json format */
+    Claude = "claude"
+}
+/**
+ * Determines the hook source format based on the file URI.
+ */
+export declare function getHookSourceFormat(fileUri: URI): HookSourceFormat;
+/**
+ * Checks if a file is read-only based on its source format.
+ * Claude settings files should be read-only from our perspective since they have a different format.
+ */
+export declare function isReadOnlyHookSource(format: HookSourceFormat): boolean;
+/**
+ * Parses hooks from a Copilot hooks .json file (our native format).
+ */
+export declare function parseCopilotHooks(json: unknown, workspaceRootUri: URI | undefined, userHome: string): Map<HookType, {
+    hooks: IHookCommand[];
+    originalId: string;
+}>;
+/**
+ * Result of parsing hooks from a file.
+ */
+export interface IParseHooksFromFileResult {
+    readonly format: HookSourceFormat;
+    readonly hooks: Map<HookType, {
+        hooks: IHookCommand[];
+        originalId: string;
+    }>;
+    /**
+     * Whether all hooks from this file were disabled via `disableAllHooks: true`.
+     */
+    readonly disabledAllHooks: boolean;
+}
+/**
+ * Parses hooks from any supported format, auto-detecting the format from the file URI.
+ */
+export declare function parseHooksFromFile(fileUri: URI, json: unknown, workspaceRootUri: URI | undefined, userHome: string): IParseHooksFromFileResult;
+/**
+ * Parses hooks from a file, ignoring the `disableAllHooks` flag.
+ * Used by diagnostics to show which hooks are hidden when `disableAllHooks: true` is set.
+ */
+export declare function parseHooksIgnoringDisableAll(fileUri: URI, json: unknown, workspaceRootUri: URI | undefined, userHome: string): IParseHooksFromFileResult;
+/**
+ * Gets a human-readable label for a hook source format.
+ */
+export declare function getHookSourceFormatLabel(format: HookSourceFormat): string;
+/**
+ * Builds a new hook entry object in the appropriate format for the given source format.
+ * - Copilot format: `{ type: 'command', command: '' }`
+ * - Claude format: `{ matcher: '', hooks: [{ type: 'command', command: '' }] }`
+ */
+export declare function buildNewHookEntry(format: HookSourceFormat): Record<string, unknown>;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/hookCompatibility.js

@@ -0,0 +1,120 @@
+
+import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { toHookType, extractHookCommandsFromItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { parseClaudeHooks } from './hookClaudeCompat.js';
+import { resolveCopilotCliHookType } from './hookCopilotCliCompat.js';
+
+var HookSourceFormat;
+(function(HookSourceFormat) {
+    HookSourceFormat["Copilot"] = "copilot";
+    HookSourceFormat["Claude"] = "claude";
+})(HookSourceFormat || (HookSourceFormat = {}));
+function getHookSourceFormat(fileUri) {
+    const filename = basename(fileUri.path).toLowerCase();
+    const dir = dirname(fileUri.path);
+    if ((filename === "settings.json" || filename === "settings.local.json") && dir.endsWith(".claude")) {
+        return HookSourceFormat.Claude;
+    }
+    return HookSourceFormat.Copilot;
+}
+function parseCopilotHooks(json, workspaceRootUri, userHome) {
+    const result = ( new Map());
+    if (!json || typeof json !== "object") {
+        return result;
+    }
+    const root = json;
+    const hooks = root.hooks;
+    if (!hooks || typeof hooks !== "object") {
+        return result;
+    }
+    const hooksObj = hooks;
+    for (const originalId of ( Object.keys(hooksObj))) {
+        const hookType = resolveCopilotCliHookType(originalId) ?? toHookType(originalId);
+        if (!hookType) {
+            continue;
+        }
+        const hookArray = hooksObj[originalId];
+        if (!Array.isArray(hookArray)) {
+            continue;
+        }
+        const commands = [];
+        for (const item of hookArray) {
+            const extracted = extractHookCommandsFromItem(item, workspaceRootUri, userHome);
+            commands.push(...extracted);
+        }
+        if (commands.length > 0) {
+            result.set(hookType, {
+                hooks: commands,
+                originalId
+            });
+        }
+    }
+    return result;
+}
+function parseHooksFromFile(fileUri, json, workspaceRootUri, userHome) {
+    const format = getHookSourceFormat(fileUri);
+    let hooks;
+    let disabledAllHooks = false;
+    switch (format) {
+    case HookSourceFormat.Claude:
+        {
+            const result = parseClaudeHooks(json, workspaceRootUri, userHome);
+            hooks = result.hooks;
+            disabledAllHooks = result.disabledAllHooks;
+            break;
+        }
+    case HookSourceFormat.Copilot:
+    default:
+        hooks = parseCopilotHooks(json, workspaceRootUri, userHome);
+        break;
+    }
+    return {
+        format,
+        hooks,
+        disabledAllHooks
+    };
+}
+function parseHooksIgnoringDisableAll(fileUri, json, workspaceRootUri, userHome) {
+    const format = getHookSourceFormat(fileUri);
+    let hooks;
+    switch (format) {
+    case HookSourceFormat.Claude:
+        {
+            if (json && typeof json === "object") {
+                const {
+                    disableAllHooks: _,
+                    ...rest
+                } = json;
+                const result = parseClaudeHooks(rest, workspaceRootUri, userHome);
+                hooks = result.hooks;
+            } else {
+                hooks = ( new Map());
+            }
+            break;
+        }
+    case HookSourceFormat.Copilot:
+    default:
+        hooks = parseCopilotHooks(json, workspaceRootUri, userHome);
+        break;
+    }
+    return {
+        format,
+        hooks,
+        disabledAllHooks: true
+    };
+}
+function buildNewHookEntry(format) {
+    const commandEntry = {
+        type: "command",
+        command: ""
+    };
+    if (format === HookSourceFormat.Claude) {
+        return {
+            matcher: "",
+            hooks: [commandEntry]
+        };
+    }
+    return commandEntry;
+}
+
+export { HookSourceFormat, buildNewHookEntry, getHookSourceFormat, parseCopilotHooks, parseHooksFromFile, parseHooksIgnoringDisableAll };

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

@@ -0,0 +1,10 @@
+import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
+/**
+ * Resolves a Copilot CLI hook type name to our abstract HookType.
+ */
+export declare function resolveCopilotCliHookType(name: string): HookType | undefined;
+/**
+ * Gets the Copilot CLI hook type name for a given abstract HookType.
+ * Returns undefined if the hook type is not supported in Copilot CLI.
+ */
+export declare function getCopilotCliHookTypeName(hookType: HookType): string | undefined;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/hookCopilotCliCompat.js

@@ -0,0 +1,23 @@
+
+import { HOOKS_BY_TARGET } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+
+const COPILOT_CLI_HOOK_TYPE_MAP = HOOKS_BY_TARGET[Target.GitHubCopilot];
+let _hookTypeToCopilotCliName;
+function getHookTypeToCopilotCliNameMap() {
+    if (!_hookTypeToCopilotCliName) {
+        _hookTypeToCopilotCliName = ( new Map());
+        for (const [copilotCliName, hookType] of Object.entries(COPILOT_CLI_HOOK_TYPE_MAP)) {
+            _hookTypeToCopilotCliName.set(hookType, copilotCliName);
+        }
+    }
+    return _hookTypeToCopilotCliName;
+}
+function resolveCopilotCliHookType(name) {
+    return COPILOT_CLI_HOOK_TYPE_MAP[name];
+}
+function getCopilotCliHookTypeName(hookType) {
+    return getHookTypeToCopilotCliNameMap().get(hookType);
+}
+
+export { getCopilotCliHookTypeName, resolveCopilotCliHookType };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/extensionPromptFileService.d.ts

@@ -0,0 +1,92 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IExtensionDescription } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { IExtensionPromptPath, IPromptFileContext, IPromptFileResource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+/**
+ * Event payload emitted by {@link ExtensionPromptFileService.onDidChange}.
+ */
+export interface IExtensionPromptFilesChangeEvent {
+    readonly type: PromptsType;
+}
+/**
+ * Owns the registry of prompt files contributed by extensions, both via
+ * static contribution points (see {@link registerContributedFile}) and via
+ * dynamic providers registered through the proposed extension API (see
+ * {@link registerPromptFileProvider}).
+ *
+ * Exposes a per-type getter ({@link getExtensionPromptFiles}) that merges
+ * both sources and applies any `when` clauses, plus a single change event
+ * ({@link onDidChange}) carrying the affected {@link PromptsType}.
+ */
+export declare class ExtensionPromptFileService extends Disposable {
+    private readonly logger;
+    private readonly fileService;
+    private readonly modelService;
+    private readonly extensionService;
+    private readonly filesConfigService;
+    private readonly contextKeyService;
+    /**
+     * Files contributed via extension contribution points, keyed by type then URI.
+     */
+    private readonly contributedFiles;
+    /**
+     * Providers registered via the proposed extension API.
+     */
+    private readonly _promptFileProviders;
+    /**
+     * Context keys referenced by tracked `when` clauses (from contributed
+     * files and provider results). Used to know when to re-evaluate.
+     */
+    private readonly _contributedWhenKeys;
+    private readonly _contributedWhenClauses;
+    private readonly _providerWhenClauses;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<IExtensionPromptFilesChangeEvent>;
+    /**
+     * Pending URIs to mark as readonly, flushed on the next microtask.
+     * Batches multiple `registerContributedFile` calls (which happen
+     * synchronously in the extension point handler) into a single
+     * `updateReadonly` call to avoid firing `onDidChangeReadonly` per file.
+     */
+    private _pendingReadonlyUris;
+    private _pendingReadonlyFlush;
+    constructor(logger: ILogService, fileService: IFileService, modelService: IModelService, extensionService: IExtensionService, filesConfigService: IFilesConfigurationService, contextKeyService: IContextKeyService);
+    /**
+     * Returns the merged list of extension-contributed prompt files for the
+     * given type, filtered by their `when` clause.
+     */
+    getExtensionPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IExtensionPromptPath[]>;
+    /**
+     * Registers a file contributed via a static contribution point. Returns
+     * a disposable that removes the contribution.
+     */
+    registerContributedFile(type: PromptsType, uri: URI, extension: IExtensionDescription, name?: string, description?: string, when?: string, sessionTypes?: readonly string[]): IDisposable;
+    /**
+     * Registers a prompt file provider (CustomAgentProvider, InstructionsProvider, or PromptFileProvider).
+     * This is called by the extension host bridge when an extension registers a provider via
+     * vscode.chat.registerCustomAgentProvider(), registerInstructionsProvider(), or
+     * registerPromptFileProvider().
+     */
+    registerPromptFileProvider(extension: IExtensionDescription, type: PromptsType, provider: {
+        onDidChangePromptFiles?: Event<void>;
+        providePromptFiles: (context: IPromptFileContext, token: CancellationToken) => Promise<IPromptFileResource[] | undefined>;
+    }): IDisposable;
+    private _listFromProviders;
+    private _getProviderActivationEvent;
+    private _enqueueReadonlyUpdate;
+    private _updateContributedWhenKeys;
+    private _validateAndSanitizeSkillFile;
+    private _parsePromptFile;
+    private _sanitizeAgentSkillText;
+    private _truncateAgentSkillName;
+    private _truncateAgentSkillDescription;
+}