@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -0,0 +1,489 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+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 '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { PluginSourceKind } from '../common/plugins/pluginMarketplaceService.js';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+function sanitizeCacheSegment(name) {
+    return name.replace(/[\\/:*?"<>|]/g, "_");
+}
+function gitRevisionCacheSuffix(ref, sha) {
+    if (sha) {
+        return [`sha_${sanitizeCacheSegment(sha)}`];
+    }
+    if (ref) {
+        return [`ref_${sanitizeCacheSegment(ref)}`];
+    }
+    return [];
+}
+function showGitOutputAction(commandService) {
+    return (new Action(
+        "showGitOutput",
+        localize(6248, "Show Git Output"),
+        undefined,
+        true,
+        () => {
+            commandService.executeCommand("git.showOutput");
+        }
+    ));
+}
+function shellEscapeArg(value) {
+    if (isWindows) {
+        return `"${value.replace(/[`$"]/g, "`$&")}"`;
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatShellCommand(args) {
+    const [command, ...rest] = args;
+    return [command, ...( rest.map(arg => shellEscapeArg(arg)))].join(" ");
+}
+let AbstractGitPluginSource = class AbstractGitPluginSource {
+    constructor(
+        _commandService,
+        _fileService,
+        _logService,
+        _notificationService,
+        _progressService
+    ) {
+        this._commandService = _commandService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._notificationService = _notificationService;
+        this._progressService = _progressService;
+    }
+    getCleanupTarget(cacheRoot, descriptor) {
+        return this.getInstallUri(cacheRoot, descriptor);
+    }
+    async ensure(cacheRoot, plugin, options) {
+        const descriptor = plugin.sourceDescriptor;
+        const repoDir = this.getInstallUri(cacheRoot, descriptor);
+        const repoExists = await this._fileService.exists(repoDir);
+        const label = this._displayLabel(descriptor);
+        if (repoExists) {
+            await this._checkoutRevision(repoDir, descriptor, options?.failureLabel ?? label);
+            return repoDir;
+        }
+        const progressTitle = options?.progressTitle ?? ( localize(6249, "Cloning plugin source '{0}'...", label));
+        const failureLabel = options?.failureLabel ?? label;
+        const ref = descriptor.ref;
+        await this._cloneRepository(repoDir, this._cloneUrl(descriptor), progressTitle, failureLabel, ref);
+        await this._checkoutRevision(repoDir, descriptor, failureLabel);
+        return repoDir;
+    }
+    async update(cacheRoot, plugin, options) {
+        const descriptor = plugin.sourceDescriptor;
+        const repoDir = this.getInstallUri(cacheRoot, descriptor);
+        const repoExists = await this._fileService.exists(repoDir);
+        if (!repoExists) {
+            this._logService.warn(
+                `[${this.kind}] Cannot update plugin '${options?.pluginName ?? plugin.name}': source repository not cloned`
+            );
+            return;
+        }
+        const updateLabel = options?.pluginName ?? plugin.name;
+        const failureLabel = options?.failureLabel ?? updateLabel;
+        try {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(6250, "Updating plugin '{0}'...", updateLabel)),
+                cancellable: false
+            }, async () => {
+                await this._commandService.executeCommand("git.openRepository", repoDir.fsPath);
+                const git = descriptor;
+                if (git.sha) {
+                    await this._commandService.executeCommand("git.fetch", repoDir.fsPath);
+                } else {
+                    await this._commandService.executeCommand("_git.pull", repoDir.fsPath);
+                }
+                await this._checkoutRevision(repoDir, descriptor, failureLabel);
+            });
+        } catch (err) {
+            this._logService.error(`[${this.kind}] Failed to update plugin source '${updateLabel}':`, err);
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6251,
+                    "Failed to update plugin '{0}': {1}",
+                    failureLabel,
+                    err?.message ?? String(err)
+                )),
+                actions: {
+                    primary: [showGitOutputAction(this._commandService)]
+                }
+            });
+        }
+    }
+    async _cloneRepository(repoDir, cloneUrl, progressTitle, failureLabel, ref) {
+        try {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: progressTitle,
+                cancellable: false
+            }, async () => {
+                await this._fileService.createFolder(dirname(repoDir));
+                await this._commandService.executeCommand("_git.cloneRepository", cloneUrl, repoDir.fsPath, ref);
+            });
+        } catch (err) {
+            this._logService.error(`[${this.kind}] Failed to clone ${cloneUrl}:`, err);
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6252,
+                    "Failed to install plugin '{0}': {1}",
+                    failureLabel,
+                    err?.message ?? String(err)
+                )),
+                actions: {
+                    primary: [showGitOutputAction(this._commandService)]
+                }
+            });
+            throw err;
+        }
+    }
+    async _checkoutRevision(repoDir, descriptor, failureLabel) {
+        const git = descriptor;
+        if (!git.sha && !git.ref) {
+            return;
+        }
+        try {
+            if (git.sha) {
+                await this._commandService.executeCommand("_git.checkout", repoDir.fsPath, git.sha, true);
+                return;
+            }
+            await this._commandService.executeCommand("_git.checkout", repoDir.fsPath, git.ref);
+        } catch (err) {
+            this._logService.error(`[${this.kind}] Failed to checkout revision for '${failureLabel}':`, err);
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6253,
+                    "Failed to checkout plugin '{0}' to requested revision: {1}",
+                    failureLabel,
+                    err?.message ?? String(err)
+                )),
+                actions: {
+                    primary: [showGitOutputAction(this._commandService)]
+                }
+            });
+            throw err;
+        }
+    }
+};
+AbstractGitPluginSource = ( __decorate([( __param(0, ICommandService)), ( __param(1, IFileService)), ( __param(2, ILogService)), ( __param(3, INotificationService)), ( __param(4, IProgressService))], AbstractGitPluginSource));
+class RelativePathPluginSource {
+    constructor() {
+        this.kind = PluginSourceKind.RelativePath;
+    }
+    getInstallUri(_cacheRoot, _descriptor) {
+        throw ( new Error("Use getPluginInstallUri() for relative-path sources"));
+    }
+    async ensure(_cacheRoot, _plugin, _options) {
+        throw ( new Error("Use ensureRepository() for relative-path sources"));
+    }
+    async update(_cacheRoot, _plugin, _options) {
+        throw ( new Error("Use pullRepository() for relative-path sources"));
+    }
+    getCleanupTarget(_cacheRoot, _descriptor) {
+        return undefined;
+    }
+    getLabel(descriptor) {
+        return descriptor.path || ".";
+    }
+}
+class GitHubPluginSource extends AbstractGitPluginSource {
+    constructor() {
+        super(...arguments);
+        this.kind = PluginSourceKind.GitHub;
+    }
+    getInstallUri(cacheRoot, descriptor) {
+        const gh = descriptor;
+        const [owner, repo] = gh.repo.split("/");
+        return joinPath(
+            cacheRoot,
+            "github.com",
+            owner,
+            repo,
+            ...gitRevisionCacheSuffix(gh.ref, gh.sha)
+        );
+    }
+    getLabel(descriptor) {
+        return descriptor.repo;
+    }
+    _cloneUrl(descriptor) {
+        return `https://github.com/${descriptor.repo}.git`;
+    }
+    _displayLabel(descriptor) {
+        return descriptor.repo;
+    }
+}
+class GitUrlPluginSource extends AbstractGitPluginSource {
+    constructor() {
+        super(...arguments);
+        this.kind = PluginSourceKind.GitUrl;
+    }
+    getInstallUri(cacheRoot, descriptor) {
+        const git = descriptor;
+        const segments = this._gitUrlCacheSegments(git.url, git.ref, git.sha);
+        return joinPath(cacheRoot, ...segments);
+    }
+    getLabel(descriptor) {
+        return descriptor.url;
+    }
+    _cloneUrl(descriptor) {
+        return descriptor.url;
+    }
+    _displayLabel(descriptor) {
+        return descriptor.url;
+    }
+    _gitUrlCacheSegments(url, ref, sha) {
+        try {
+            const parsed = ( URI.parse(url));
+            const authority = (parsed.authority || "unknown").replace(/[\\/:*?"<>|]/g, "_").toLowerCase();
+            const pathPart = parsed.path.replace(/^\/+/, "").replace(/\.git$/i, "").replace(/\/+$/g, "");
+            const segments = ( pathPart.split("/").map(s => s.replace(/[\\/:*?"<>|]/g, "_")));
+            return [authority, ...segments, ...gitRevisionCacheSuffix(ref, sha)];
+        } catch {
+            return [
+                "git",
+                url.replace(/[\\/:*?"<>|]/g, "_"),
+                ...gitRevisionCacheSuffix(ref, sha)
+            ];
+        }
+    }
+}
+let AbstractPackagePluginSource = class AbstractPackagePluginSource {
+    constructor(
+        _dialogService,
+        _fileService,
+        _logService,
+        _notificationService,
+        _progressService,
+        _terminalService
+    ) {
+        this._dialogService = _dialogService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._notificationService = _notificationService;
+        this._progressService = _progressService;
+        this._terminalService = _terminalService;
+    }
+    getCleanupTarget(cacheRoot, descriptor) {
+        return this._getCacheDir(cacheRoot, descriptor);
+    }
+    async ensure(cacheRoot, plugin, _options) {
+        const cacheDir = this._getCacheDir(cacheRoot, plugin.sourceDescriptor);
+        await this._fileService.createFolder(cacheDir);
+        return cacheDir;
+    }
+    async update(cacheRoot, plugin, _options) {
+        const installDir = this._getCacheDir(cacheRoot, plugin.sourceDescriptor);
+        const pluginDir = this.getInstallUri(cacheRoot, plugin.sourceDescriptor);
+        await this.runInstall(installDir, pluginDir, plugin);
+    }
+    async runInstall(installDir, pluginDir, plugin) {
+        const args = this._buildInstallArgs(installDir, plugin);
+        const command = formatShellCommand(args);
+        const confirmed = await this._confirmTerminalCommand(plugin.name, command);
+        if (!confirmed) {
+            return undefined;
+        }
+        const progressTitle = ( localize(6254, "Installing {0} plugin '{1}'...", this._managerName, plugin.name));
+        const {
+            success,
+            terminal
+        } = await this._runTerminalCommand(command, progressTitle);
+        if (!success) {
+            return undefined;
+        }
+        const exists = await this._fileService.exists(pluginDir);
+        if (!exists) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6255,
+                    "{0} package '{1}' was not found after installation.",
+                    this._managerName,
+                    this.getLabel(plugin.sourceDescriptor)
+                ))
+            });
+            return undefined;
+        }
+        terminal?.dispose();
+        return {
+            pluginDir
+        };
+    }
+    async _confirmTerminalCommand(pluginName, command) {
+        const {
+            confirmed
+        } = await this._dialogService.confirm({
+            type: "question",
+            message: ( localize(6256, "Install Plugin '{0}'?", pluginName)),
+            detail: ( localize(6257, "This will run the following command in a terminal:\n\n{0}", command)),
+            primaryButton: ( localize(6258, "&&Install"))
+        });
+        return confirmed;
+    }
+    async _runTerminalCommand(command, progressTitle) {
+        let terminal;
+        try {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: progressTitle,
+                cancellable: false
+            }, async () => {
+                terminal = await this._terminalService.createTerminal({
+                    config: {
+                        name: ( localize(6259, "Plugin Install")),
+                        forceShellIntegration: true,
+                        isTransient: true,
+                        isFeatureTerminal: true
+                    }
+                });
+                await terminal.processReady;
+                this._terminalService.setActiveInstance(terminal);
+                const commandResultPromise = this._waitForTerminalCommandCompletion(terminal);
+                await terminal.runCommand(command, true);
+                const exitCode = await commandResultPromise;
+                if (exitCode !== 0) {
+                    throw ( new Error(( localize(6260, "Command exited with code {0}", exitCode))));
+                }
+            });
+            return {
+                success: true,
+                terminal
+            };
+        } catch (err) {
+            this._logService.error(`[${this.kind}] Terminal command failed:`, err);
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    6261,
+                    "Plugin installation command failed: {0}",
+                    err?.message ?? String(err)
+                ))
+            });
+            return {
+                success: false,
+                terminal
+            };
+        }
+    }
+    _waitForTerminalCommandCompletion(terminal) {
+        return ( new Promise(resolve => {
+            const disposables = ( new DisposableStore());
+            let isResolved = false;
+            const resolveAndDispose = exitCode => {
+                if (isResolved) {
+                    return;
+                }
+                isResolved = true;
+                disposables.dispose();
+                resolve(exitCode);
+            };
+            const attachCommandFinishedListener = () => {
+                const commandDetection = terminal.capabilities.get(TerminalCapability.CommandDetection);
+                if (!commandDetection) {
+                    return;
+                }
+                disposables.add(commandDetection.onCommandFinished(command => {
+                    resolveAndDispose(command.exitCode ?? 0);
+                }));
+            };
+            attachCommandFinishedListener();
+            disposables.add(
+                terminal.capabilities.onDidAddCommandDetectionCapability(() => attachCommandFinishedListener())
+            );
+            const timeoutHandle = timeout(120_000);
+            disposables.add(toDisposable(() => timeoutHandle.cancel()));
+            void timeoutHandle.then(() => {
+                if (isResolved) {
+                    return;
+                }
+                this._logService.warn(`[${this.kind}] Terminal command completion timed out`);
+                resolveAndDispose(undefined);
+            });
+        }));
+    }
+};
+AbstractPackagePluginSource = ( __decorate([( __param(0, IDialogService)), ( __param(1, IFileService)), ( __param(2, ILogService)), ( __param(3, INotificationService)), ( __param(4, IProgressService)), ( __param(5, ITerminalService))], AbstractPackagePluginSource));
+class NpmPluginSource extends AbstractPackagePluginSource {
+    constructor() {
+        super(...arguments);
+        this.kind = PluginSourceKind.Npm;
+        this._managerName = "npm";
+    }
+    getInstallUri(cacheRoot, descriptor) {
+        const npm = descriptor;
+        return joinPath(
+            cacheRoot,
+            "npm",
+            sanitizeCacheSegment(npm.package),
+            "node_modules",
+            npm.package
+        );
+    }
+    getLabel(descriptor) {
+        const npm = descriptor;
+        return npm.version ? `${npm.package}@${npm.version}` : npm.package;
+    }
+    _getCacheDir(cacheRoot, descriptor) {
+        const npm = descriptor;
+        return joinPath(cacheRoot, "npm", sanitizeCacheSegment(npm.package));
+    }
+    _buildInstallArgs(installDir, plugin) {
+        const npm = plugin.sourceDescriptor;
+        const packageSpec = npm.version ? `${npm.package}@${npm.version}` : npm.package;
+        const args = ["npm", "install", "--prefix", installDir.fsPath, packageSpec];
+        if (npm.registry) {
+            args.push("--registry", npm.registry);
+        }
+        return args;
+    }
+}
+class PipPluginSource extends AbstractPackagePluginSource {
+    constructor() {
+        super(...arguments);
+        this.kind = PluginSourceKind.Pip;
+        this._managerName = "pip";
+    }
+    getInstallUri(cacheRoot, descriptor) {
+        const pip = descriptor;
+        return joinPath(cacheRoot, "pip", sanitizeCacheSegment(pip.package));
+    }
+    getLabel(descriptor) {
+        const pip = descriptor;
+        return pip.version ? `${pip.package}==${pip.version}` : pip.package;
+    }
+    _getCacheDir(cacheRoot, descriptor) {
+        const pip = descriptor;
+        return joinPath(cacheRoot, "pip", sanitizeCacheSegment(pip.package));
+    }
+    _buildInstallArgs(installDir, plugin) {
+        const pip = plugin.sourceDescriptor;
+        const packageSpec = pip.version ? `${pip.package}==${pip.version}` : pip.package;
+        const args = ["pip", "install", "--target", installDir.fsPath, packageSpec];
+        if (pip.registry) {
+            args.push("--index-url", pip.registry);
+        }
+        return args;
+    }
+}
+
+export { AbstractPackagePluginSource, GitHubPluginSource, GitUrlPluginSource, NpmPluginSource, PipPluginSource, RelativePathPluginSource };

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/chatModeActions.js

@@ -17,7 +17,7 @@ class ConfigAgentActionImpl extends Action2 {
         const openerService = accessor.get(IOpenerService);
         const pickers = instaService.createInstance(PromptFilePickers);
         const placeholder = ( localize(
-            5691,
+            6268,
             "Select the custom agents to open and configure visibility in the agent picker"
         ));
         const result = await pickers.selectPromptFile({
@@ -35,8 +35,8 @@ const PICKER_CONFIGURE_AGENTS_ACTION_ID = "workbench.action.chat.picker.customag
 function createPickerConfigureAgentsActionConfig(disabled) {
     const config = {
         id: disabled ? PICKER_CONFIGURE_AGENTS_ACTION_ID + ".disabled" : PICKER_CONFIGURE_AGENTS_ACTION_ID,
-        title: ( localize2(5692, "Configure Custom Agents...")),
-        tooltip: disabled ? ( localize(5693, "Managed by your organization")) : undefined,
+        title: ( localize2(6269, "Configure Custom Agents...")),
+        tooltip: disabled ? ( localize(6270, "Managed by your organization")) : undefined,
         icon: disabled ? Codicon.lock : undefined,
         category: CHAT_CATEGORY,
         f1: false,
@@ -62,8 +62,8 @@ const CONFIGURE_AGENTS_ACTION_ID = "workbench.action.chat.configure.customagents
 function createManageAgentsActionConfig(disabled) {
     const base = {
         id: disabled ? CONFIGURE_AGENTS_ACTION_ID + ".disabled" : CONFIGURE_AGENTS_ACTION_ID,
-        title: ( localize2(5694, "Configure Custom Agents...")),
-        shortTitle: ( localize(5695, "Custom Agents")),
+        title: ( localize2(6271, "Configure Custom Agents...")),
+        shortTitle: ( localize(6272, "Custom Agents")),
         icon: disabled ? Codicon.lock : Codicon.bookmark,
         f1: !disabled,
         precondition: disabled ? ( ContextKeyExpr.false()) : ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.Modes.agentModeDisabledByPolicy.negate()))),
@@ -77,7 +77,7 @@ function createManageAgentsActionConfig(disabled) {
     };
     return disabled ? {
         ...base,
-        tooltip: ( localize(5693, "Managed by your organization"))
+        tooltip: ( localize(6270, "Managed by your organization"))
     } : base;
 }
 class ManageAgentsAction extends ConfigAgentActionImpl {

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

@@ -1,9 +1,27 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { ITextEditorSelection } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+/**
+ * Optional callbacks and settings for customizing the hook creation and opening behaviour.
+ * The agentic editor passes these to open hooks in the embedded editor and
+ * track worktree files for auto-commit.
+ */
+export interface IHookQuickPickOptions {
+    /** Override how the hook file is opened. If not provided, uses editorService.openEditor. */
+    readonly openEditor?: (resource: URI, options?: {
+        selection?: ITextEditorSelection;
+    }) => Promise<void>;
+    /** Called after a new hook file is created on disk. */
+    readonly onHookFileCreated?: (uri: URI) => void;
+    /** Filter the displayed hook types to those supported by the given target. */
+    readonly target?: Target;
+}
 /**
  * Shows the Configure Hooks quick pick UI, allowing the user to view,
  * open, or create hooks. Can be called from the action or slash command.
  */
-export declare function showConfigureHooksQuickPick(accessor: ServicesAccessor): Promise<void>;
+export declare function showConfigureHooksQuickPick(accessor: ServicesAccessor, options?: IHookQuickPickOptions): Promise<void>;
 /**
  * Helper to register the `Manage Hooks` action.
  */